(item () of [list v]) 

define (my reporter)
{do calculation stuff::grey
}report ()::custom cap

definition of <boolean>{
run code to solve stuff
}<boolean> true if <>::looks cap 

qwertycodechamp90411 wrote:

Let's say I wanted a custom boolean block. It would look like this?

definition of <boolean>{
run code to solve stuff
}<boolean> true if <>::looks cap 

define <boolean name>

report <>:: custom cap

or

define <boolean name>
{}(report <>:: custom cap):: custom cap

<boolean name:: custom-arg> true if <false:: operators>:: custom cap

medians wrote:

ninjahanzo wrote:

<boolean name:: custom-arg> true if <false:: operators>:: custom cap

can cause confusion if it was that in Snap.

<boolean name> true if <boolean name>::custom cap

mumu245 wrote:

I think local variables could just be put in the hat.

define (  max (x) (y) )
if <[x] > [y]> then 
return with (x)
else
return with (y)
end

when green flag clicked
say ( max (2)(1))

The_Dark_Skeleton wrote:

Layout idea:

define (max (x ::custom-arg) (y ::custom-arg) ::custom)
if <(x ::custom-arg) > (y::custom-arg)> then 
return with (x ::custom-arg) ::custom cap //if this is returned, the custom block stops
end
return with (y ::custom-arg) ::custom cap //so this cannot run if x was already returned

when green flag clicked
say (max (2)(1) ::custom)

Scratch cat would say 2 then.

define (report (val ::custom-arg) ::custom)
return (val ::custom-arg) ::custom cap

mumu245 wrote:

I think local variables could just be put in the hat.

medians wrote:

I think that could create clutter with the actual parameters though or at least get confused with them, so I'm thinking that they should just create it in the block or something.

define is (n) prime? ::reporter
local variables (d ::#84bd13) ::custom
set [d v] to [2] ::#84bd13
repeat until <((d ::#84bd13) * (d ::#84bd13)) > (n)>
    if <(n) mod (d ::#84bd13)> then
        return <true ::control> and end ::custom
    end
end
return <false ::control> and end ::custom

(call{if<(my variable)=[true]>then
return[Yes]::grey cap
else
return[No]::grey cap
}::control)

brooc210 wrote:

(#2232)

thugatwoary wrote:

(#2232)
The lack of this feature is seriously harmful to Scratch, since it encourages the creation of massive spaghetti reporters. Just look at this:

((x) ^ (min/max (y) ((z) ^ (2) :: custom) :: custom) :: custom)

compared to this absolute gargantuan unreadable mess:

([e^ v] of (([ln v] of (x)) * ((((y) + ([e^ v] of (([ln v] of (z)) * (2)) :: operators)) + ([abs v] of ((y) + ([e^ v] of (([ln v] of (z)) * (2)) :: operators))))/(2))) :: operators)

Probably not the best example as there's little practical use for this script, but you can definitely see the point, and there's definitely cases where it gets worse exponentially, especially once you involve blocks that cannot be made using just reporters so you need massive clunky block workarounds and it becomes a nightmare to do any math using those functions without this feature.

I agree.

// The first item of a stack frame is the index to the previous stack frame.
// The second item is the number of variables.
// What follows this header is a sequence of variables, each of which takes up two items.
// The first item of a variable is its name, and the second item is its value.
// Shadowing is not implemented, could be implemented using recursion.
define begin stack frame
add (stack base) to [stack v]
set [stack base v] to (length of [stack v])
add (0) to [stack v]

define close stack frame
repeat ((item ((stack base) + (1)) of [stack v]) * (2))
delete (length of [stack base v]) of [stack v]
end
set [stack base v] to (item (stack base) of [stack v])
delete (length of [stack base v]) of [stack v]
delete (length of [stack base v]) of [stack v]

define (local (name) :: custom)
set [i v] to ((stack base) + (2))
repeat (item ((stack base) + (1)) of [stack v])
if <(item (i) of [stack base v]) = (name)> then
report (item ((i) + (1)) of [stack base v]) :: custom
end
change [i v] by (2)
end
report [] :: custom

define set local (var) to (value)
set [i v] to ((stack base) + (2))
repeat (item ((stack base) + (1)) of [stack v])
if <(item (i) of [stack base v]) = (name)> then
replace item (item ((i) + (1)) of [stack v]) of [stack v] with (value)
stop [this script v]
end
change [i v] by (2)
end
replace item ((stack base) + (1)) of [stack v] with ((item ((stack base) + (1)) of [stack v]) + (1))
add (var) to [stack v]
add (value) to [stack v]

when green flag clicked
begin stack frame :: custom
set local [foo] to [hello] :: custom
set local [bar] to [world] :: custom
say (join (local [foo] :: custom) (local [bar] :: custom))
close stack frame :: custom

pkhead wrote:

i doubt the st would add local variables and such. someone probably already spoke my opinion, but i'm too lazy to search 122 pages of replies to confirm that. Also, local variables can be implemented currently in Scratch by treating a list as a stack, but it isn't very practical because to access local variables, you either have to access variables via list indices, or use a command custom block that, given a variable name, writes the value of it to some variable/list, in which case you still need to use global variables or list indices. I think custom reporters would allow that technique to be practical. Posting a possible implementation, if custom reporters were a thing in Scratch, because i'm extremely bored. Of course it would be slower than if it were implemented into Scratch, but at least it's something.

// The first item of a stack frame is the index to the previous stack frame.
// The second item is the number of variables.
// What follows this header is a sequence of variables, each of which takes up two items.
// The first item of a variable is its name, and the second item is its value.
// Shadowing is not implemented, could be implemented using recursion.
define begin stack frame
add (stack base) to [stack v]
set [stack base v] to (length of [stack v])
add (0) to [stack v]

define close stack frame
repeat ((item ((stack base) + (1)) of [stack v]) * (2))
delete (length of [stack base v]) of [stack v]
end
set [stack base v] to (item (stack base) of [stack v])
delete (length of [stack base v]) of [stack v]
delete (length of [stack base v]) of [stack v]

define (local (name) :: custom)
set [i v] to ((stack base) + (2))
repeat (item ((stack base) + (1)) of [stack v])
if <(item (i) of [stack base v]) = (name)> then
report (item ((i) + (1)) of [stack base v]) :: custom
end
change [i v] by (2)
end
report [] :: custom

define set local (var) to (value)
set [i v] to ((stack base) + (2))
repeat (item ((stack base) + (1)) of [stack v])
if <(item (i) of [stack base v]) = (name)> then
replace item (item ((i) + (1)) of [stack v]) of [stack v] with (value)
stop [this script v]
end
change [i v] by (2)
end
replace item ((stack base) + (1)) of [stack v] with ((item ((stack base) + (1)) of [stack v]) + (1))
add (var) to [stack v]
add (value) to [stack v]

when green flag clicked
begin stack frame :: custom
set local [foo] to [hello] :: custom
set local [bar] to [world] :: custom
say (join (local [foo] :: custom) (local [bar] :: custom))
close stack frame :: custom