Look inside ((thx 2 other Snap!-users for ideas!)
It's a work in progress. Some of the functions it contains:
1. "do": though it may look useless at first sight it’s actually quite handy for a programmer, facilitating code development, debugging and documentation;
2. "let"+ "be": a mechanism for declaring and at the same time initializing (multiple) variables.
3. A logging facility, for debugging and optimization.
4. Commands to modify a variable's value.
5. Advanced sorting options.
6. Memoïzation, both for single~ and multi-variable (recursive) functions.data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKAAAAB4CAYAAAB1ovlvAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAoKADAAQAAAABAAAAeAAAAAAeaS0RAAAE70lEQVR4Ae2dTUhUURTHj6YRQp8uIhywkKQkg4LaiGB+RJgEYWWplDGbLE2sZdt2LQqhRaskkCgQ2vSxEKK1UlBWUBEYkX1QERFC1tiMpmnKOF6unDtzfm7See/ec8/v/2Pue+K8ssbiX8IXBJQIZCvVpSwExgkgICKoEkBAVfwUR0AcUCWAgKr4KY6AOKBKAAFV8VMcAXFAlQACquKnOALigCoBBFTFT3EExAFVAgioip/iCIgDqgQQUBU/xREQB1QJIKAqfoojIA6oEkBAVfwUR0AcUCWAgKr4KY6AOKBKAAFV8VMcAXFAlQACquKnOALigCoBBFTFT3EExAFVAgioip/iCIgDqgQQUBU/xREQB1QJIKAq/tSKDw4OpnZiGp6Vk4ZrNrfk7OVDcvpyqewsbpHRr+tlX1Wb5OfnZwSHLB7Rmx45nr90XJYUd08t9tVAnjQf6JR3gxFpOnRi6vV0+wYB0yixQ2ezZFvV7AXHYiKPr++RGz13Zx8M/BUEDDygyeX9/w74sn+ZNB88I8Pj74Ctk6el3b9cA6ZBZM+GbsvH3G7ZkXtMfn3dMHENWPv3GrAkDRpIskQEnAbnyoWLEu1sl5ycsLDEvhdK16nM/N802IKnCfjizgO5t7dNXq9dKodbo/K2aLUcaD4y7Qy+9U2A3wP6Jsp8CyIQ1l6zoKX7P/n+04dycvRRcFuw/07DmZEtOJwsTK6ELdhk7OE0jYDhZGFyJQhoMvZwmkbAcLIwuRIENBl7OE0jYDhZmFwJApqMPZymETCcLEyuBAFNxh5O0wgYThYmV4KAJmMPp2kEDCcLkytBQJOxh9M0AoaThcmVIKDJ2MNpGgHDycLkSviL6CSxJx6J0fvhiRR+GpOWw41JzuSQKwH+Inoecl23eqSj/6bI6G8pHcmT+t21Ur1mo5SVlc0zksOpEEDAFCjVtB+VvhXfZp755Yc0bCmTzSvXSbSiTiKRyMzj/JQSAa4BU8I090nx5+rMfYBXUybANeA8qBJb8Pi737QtuHJVkZSXl88zksOpEGALTkLp301ILH4T0pTkTA65EkBAV3KM80KAa0AvGJnElQACupJjnBcCCOgFI5O4EkBAV3KM80IAAb1gZBJXAgjoSo5xXgggoBeMTOJKAAFdyTHOCwEE9IKRSVwJIKArOcZ5IYCAXjAyiSsBBHQlxzgvBBDQC0YmcSWAgK7kGOeFAAJ6wcgkrgQQ0JUc47wQQEAvGJnElQACupJjnBcCCOgFI5O4EuBTca7kDIxLfChroFckt/C5NLUcXJSO+VDSomDNnEmvdfXJ1Y7PEpOfsqr0jdTVV0hJtXh7MgQCZo4ri9ZJY805Ge7bOmP+EXkvFQ0FUrB5qeyPbnd+MgTXgDOw8sNCCPh4MgTXgAshbvDcxBacePeb2IKH4lvwLtlUGYs/GaLBCw22YC8YM3OSyZuQnPhNSDM3IZkZsvWuuAa0boBy/wioHID18gho3QDl/hFQOQDr5RHQugHK/SOgcgDWyyOgdQOU+0dA5QCsl0dA6wYo94+AygFYL4+A1g1Q7h8BlQOwXh4BrRug3D8CKgdgvTwCWjdAuX8EVA7AenkEtG6Acv8IqByA9fIIaN0A5f4RUDkA6+UR0LoByv0joHIA1ssjoHUDlPtHQOUArJdHQOsGKPePgMoBWC+PgNYNUO7/D1q0yPkY2vG8AAAAAElFTkSuQmCCLook inside ((thx 2 other Snap!-users for ideas!)
It's a work in progress. Some of the functions it contains:
1. "do": though it may look useless at first sight it’s actually quite handy for a programmer, facilitating code development, debugging and documentation;
2. "let"+ "be": a mechanism for declaring and at the same time initializing (multiple) variables.
3. A logging facility, for debugging and optimization.
4. Commands to modify a variable's value.
5. Advanced sorting options.
6. Memoïzation, both for single~ and multi-variable (recursive) functions.WHAT IT DOES: Keep multiple coherent actions together, such that they can easily be moved, copied, commented on, temporarily switched off, deleted, etc
INPUT:
1. The first slot is a switch to specify whether the encapsulated code will be executed, or switched off (e.g. for debugging purposes).
2. In the second slot comments (even multiple lines) may be added.
3. The third (C-shaped) slot is for the action(-s) to be executed (or not, depending on the switch in slot 1).pt:o texto multilinha _
trueFeel free to add a separate comment on the entire cluster of blocks ...This command works similar to “change … by …”, except it also works if variable is a list.This command works similar to “change … by …”, except it also works if variable is a list.This command works similar to “change … by …”, except it also works if variable is a list.This command works similar to “change … by …”, except it also works if variable is a list.Reports the accumulated value of a series of terms. Inspired by SICP (par. 1.3.1, exercise 1.32).
INPUT:
1. combiner is a reporter detemining how the terms are accumulated, e.g. summation or multiplication.
2. null-value is the value that, when combined with an arbitrary value, yields that same value. E.g. with summation this is 0, for multiplication and exponentiation: 1.
3. term is a reporter generating the correponding term from a base value.
4. start-value is the base value of the first term in the series.
5. next is a reporter generating the next base value from the current one.
6. stop-condition is a predicate operating on the base value.
This command works similar to “change … by …”, except it also works if variable is a list.This command works similar to “change … by …”, except it also works if variable is a list.Reports the reverse of a list, with each of its sublists deep-reversed.111any messageblastmouse-infestedAllows reading global settings programmatically.
Eisenberg's Law: Anything you can do from the user interface you should be able to do in your program, and vice versa. This library is just a beginning; there are many UI controls outside of the Settings menu.pt:o valor da configuração _
ca:paràmetre _
Project notes
Project name
User
Presentation mode
Language
Zoom blocks
Stage size
Stage scale
Retina display support
Long form input dialog
Plain prototype labels
Input sliders
Execute on slider change
Clicking sound
Turbo mode
Flat design
Keyboard editing
Visible stepping
Thread safe scripts
Prefer smooth animations
Flat line ends
Codification support
Inheritance support
Hyper blocks support
Visible paletteMulti-branched conditional.
If the first (Boolean) input is True, then the script in
the second (C-slot) input is run, and this block stops.
Additional tests can be added by putting one or more
ELSE IF blocks in the third (variadic) Boolean slot.
Use the arrowheads to get the number of Boolean
slots you need. Each ELSE IF block provides a Boolean
slot for a condition to test and a script slot for what to do
if the condition is True. You can put an ELSE block in
the last Boolean input to CASES for a script to run if
all the tests turn out False.
As soon as a condition is True, no further tests are done
and no further scripts are run.pt:se _ , então _ _
ca:casos: si _ llavors _ _
For use with the CASES block.
See its help message.pt:senão, se _ , então _
ca:altrament si _ llavors _
For use with the CASES block.
See its help message.pt:senão, _
ca:si no _
Creates and reports a new scanner, to be assigned to a variable.
The input may be a list or a text.
Subsequent CALL-s to the variable will report
the first, second (etc.) top level item or line, respectively.index0eofpt:o texto multilinha _
ca:multilínia _
11WHAT IT IS: A further development of "LET a BE [] IN loop".
WHAT IT DOES: Provide a generalized container for iteration.
INPUT:
1. Control variable (upvar) of the iteration process
2. Start value of the control variable
3. Reporter producing the next control variable from the current
4. Predicate of the control variable producing the condition that must be satisfied in order for the script to proceed to the next iteration(-s)
5. Actions to be performed during each iteration:
HOW TO USE IT: "Just add code".
INTERESTING: It uses recursion when proceeding to the next iteration. pt:tendo _ o valor inicial _ , executa _ definido como _
ca:fes que _ sigui _ al _ _
new valuept:tendo _ o valor inicial _ , executa _ definido como _
ca:fes que _ sigui _ al _ _
HiLoHiLo
LoHiCreates a new log (for debugging and optimization purposes), and reports it.current timepreceding timelabeldata (optional)Reports variadic input as a list.firstposition11111"Let" is a mechanism, available in Scheme, JavaScript and several other languages, to declare and intialize local variables. By default the “let” block supports 1 variable; it can be extended *ad libitum*, using the “be” block.This block implements a "let"-mechanism, similiar to e.g. Scheme and JavaScript. The upvar in slot 1 is a created as local variable, and it's initialized with the "value" in slot 2, which it also reports,. Several "be"-blocks may be collected in a "let"-block.WHAT Select the top (n) items from a list, sorted by corresponding keys
HOW Repeated Selection sort. Keys need to be pre-calculated (= before calling this block)
INPUT
1. number of items to be selected
2. list of items
3. list of keys corresponding with (2)
4. order in which keys must be sorted: from hgh to low or from low to high
INFORMATION for small (n), usually faster than a full sort
EXAMPLE
keyselect (5) from (list of applicants) by (list of: priority number for each person, may be a result of a complicated process) order (HiLo = highest priority first) 1
allHiLoHiLo
LoHi1combinerHiLofirst keypositionfirst data itemremaining indices1HiLoHiLo
LoHisortkeysWHAT Reports a new list of data, sorted by corresponding keys
HOW Using Snap!'s standard SORT on a list of keys and indices. Keys need to be precalculated (= before calling this block).
INPUT
1. list of items
2. list of keys corresponding with (1)
3. order in which keys must be sorted: from hgh to low or from low to high
INFORMATION Faster than using standard SORT with a complicated sort key function (especially for large datasets)
EXAMPLE
keysort (list of applicants) by: (list of: priority number for each person, may be a result of a complicated process) order: (HiLo = highest priority first) HiLoHiLo
LoHiln(length)2004008006selectsortposition1positiontempworking datalow11105WHAT IT DOES Define multi-branch conditional action.
INPUT
1. default (C-shape): action to be taken if none of the special cases apply;
2. special cases (variadic): any number of predicates, usually activating specific actions. Preferably use CASE block for each case.
APPLICATION EXAMPLE, saying the sign of a number (x):
cases, default: (say(0)), special:
(case(x > 0) (say(+)))
(case(x < 0) (say (-)))WHAT IT DOES Provide an IF THEN -operation, reporting the result of "IF"
INPUT
1. test (Boolean) = condition to be evaluated (result is reported)
2. action (C-shape) = action to be taken if the test yields true
APPLICATION To be used in combination with CASES-block
APPLICATION EXAMPLE, saying the sign of a number (x):
cases, default: (say (0)), special:
(case (x > 0) (say (+)))
(case(x < 0) (say (-)))falsede:fange _ _
ca:agafa _ _
es:atrapar _ _
fr:attrape _ _
pt:captura _ _
contde:wirf _
ca:llança _
es:lanzar _
fr:lance _
pt:lança _
catchtagde:fange _ _
ca:agafa _ _
es:atrapar _ _
fr:attrape _ _
pt:captura _ _
contde:wirf _ _
ca:llança _ _
es:lanzar _ _
fr:lance _ _
pt:lança _ _
catchtagThis is a breakpoint block, to be used in debugging.
The Boolean input specifies the condition under which
the program should pause. (Use True for an unconditional breakpoint.) The intent is that the script should have
SHOW VARIABLE blocks for the process's local variables.
After the pause, this block automatically hides all temporary variables.de:falls _ dann _ und pause $pause-1-255-220-0
ca:si _ fes _ i atura-ho tot $pause-1-255-220-0
es:si _ haz _ y páralo todo $pause-1-255-220-0
fr:si _ faire _ et mettre tout en pause $pause-1-255-220-0
pt:se _ , então _ e faz pausa em tudo $pause-1-255-220-0
This block does nothing.
Use it when you are calling a reporter
for its side effect and don't care about
its return value.de:ignoriere _
ca:ignora _
es:ignorar _
fr:ignore _
pt:ignora _
Call f(f(f(...(f(x))))) n times where the three input slots are n, f, and x from left to right. The # variable can be used inside f to represent how many times f has been called.pt:o resultado de _ invocações em cascata de _ com argumento inicial _ _
ca:en cascada _ vegades _ _ _
Call f(f(f(...(f(x))))) until condition is true, where the three input slots are condition, f, and x from left to right. The # variable can be used inside f or condition to indicate how many times f has been called.pt:o resultado da invocação em cascata até que _ de _ com argumento inicial _ _
ca:en cascada fins _ _ _ _
Returns the function x↦f(g(x)) where f and g are the two inputs.pt:a composição de _ com _
ca:composa _ _
Like the built-in REPEAT UNTIL block, except that the ending condition is not tested until the script has been run the first time. So the script is run at least once.pt:repete _ até que _ $loop-0.7
ca:repeteix _ fins _
Run the script repeatedly, as long as the given condition is true. Runs the script at least once before testing the condition.pt:repete _ enquanto _ $loop-0.7
ca:repeteix _ mentre _
Runs the script repeatedly, as long as the condition is true. Tests the condition before the first time the script is run. Like the built in REPEAT UNTIL except that in this block the condition must be true, not false.pt:enquanto _ , repete _ $loop-0.7
Runs the script the specified number of times, like the built-in REPEAT block, but this one provides the # variable that can be used inside the script. Try
REPEAT (200)
MOVE (#) STEPS
RIGHT 92
with the pen down.pt:repete _ vezes _ _ $loop-0.7
ca:repeteix _ _ _
The primitive FOR block uses an implicit step of ±1 depending on which of the starting and ending values is larger. This version allows you to provide an explicit step value. If the sign of the step input is incompatible with the ordering of the starting and ending values, the script will not be run at all.pt:para _ de _ com passo _ a _ _ $loop-0.7
ca:per _ = _ incrementant _ fins _ _
1110Provides LOOP as a function of one input that runs
the body of the LET with A set to the function input,
so the body can run itself recursively.
See COPY block in Variables for an example of use.pt:tendo _ o valor inicial _ , executa _ definido como _
ca:fes que _ sigui _ al _ _
new valueWHAT IT DOES Define multi-branch conditional action.
INPUT
1. default (C-shape): action to be taken if none of the special cases apply;
2. special cases (variadic): any number of predicates, usually activating specific actions. Preferably use CASE block for each case.
APPLICATION EXAMPLE, saying the sign of a number (x):
cases, default: (say(0)), special:
(case(x > 0) (say(+)))
(case(x < 0) (say (-)))Reports a new list whose items are the same as in the input list, except that if two or more equal items appear in the input list, only the last one is kept in the result.ca:elimina els duplicats de _
Reports a sorted version of the list in its first input slot, using the comparison function in the second input slot. For a list of numbers, using < as the comparison function will sort from low to high; using > will sort from high to low.ca:ordena _ segons criteri _
The second input is an "association list," a list of two-item lists. Each of those smaller lists has a "key" as its first item and a "value" as its second. ASSOC reports the first key-value pair in the association list whose key matches the first input.ca:associació _ _
1Takes a (possibly deep) list as input,
and reports a human-readable text form
of the list (namely, Lisp notation).
Will not work on circular lists.ca:notació textual de _
()SENTENCE is the main constructor for sentences, represented
as lists of words. It takes zero or more inputs, each of which can
be either a list or a text string. If a list, the input is assumed to be
a list of words. If a text string, it is converted to a list of words using
SENTENCE→LIST. Then all the lists of words are appended to form a new list of words.
If the inputs are lists of lists rather than lists of words, SENTENCE,
like APPEND, does only one level of flattening, reporting a list of
all the items of all the input lists.ca:frase _
ZIP takes any number of lists as inputs. The lists should all be the same length. ZIP reports a list of lists in which the first item is a list of all the first items, the second item is a list of all the second items, etc.
Viewing the inputs as the rows of a matrix, ZIP reports its transpose.The identity function reports its input.Takes as input a function of N inputs and N lists.
The function is called with item 1 of all the lists as its inputs, with item 2 of all the lists as its inputs, and so on. (The lists should all be the same length.)ca:multi-mapeja _ sobre _
Takes a sentence in text string form and reports the sentence as a list of its words.de:Satz $arrowRight Liste _
ca:frase $arrowRight llista _
es:frase $arrowRight lista _
fr:phrase $arrowRight liste _
pt:uma lista com as palavras da frase _
12x12Takes any number of Boolean (true/false) inputs (use the left and right arrowheads to adjust the number of input slots) and reports TRUE only if all of the inputs are TRUE, otherwise FALSE. Like AND but for multiple inputs.pt:todas as afirmações _ são verdadeiras
ca:tots _ ?
1Takes any number of Boolean (true/false) inputs (use the left and right arrowheads to adjust the number of input slots) and reports TRUE if at least one input is TRUE, otherwise FALSE.pt:alguma das afirmações _ é verdadeira
ca:qualsevol _ ?
100option A1option B00option A1option BCatch errors.
Runs the first script. If it succeeds, nothing else happens.
But if it has an error (something that would otherwise result
in a red halo around the block), then the second script is run,
with the text of the error message that would have been shown in the variable ERROR.pt:tenta executar _ e, em caso de erro _ , executa _
ca:prova de forma segura _ i si _ _
Throw an error.
Makes a red halo appear around the script that runs it,
with the input text shown in a speech balloon next to
the script, just like any Snap! error.
This is useful to put in the second script of SAFELY TRY
after some other instructions to undo the partial work of
the first script.pt:lança o erro _
Catch errors in a reporter.
Evaluates its first input. If that expression successfully reports a value, this block reports that value. If the expression causes a Snap! error,
then the final input slot is evaluated with the text of what would have
been the error message in variable ERROR. SAFELY TRY then reports the value of that final expression.
Sometimes you'll want to throw an error in the final expression. You
can put an ERROR block inside a CALL block to do that.ca:prova de forma segura reportant _ i si _ reportant _
errThis block carries out the given script for each item of the given list, like the primitive FOR EACH.
What's different is that it provides the # variable, which will contain the item number in the list of each item in turn, 1 while processing item 1, and so on.ca:_ per cada _ de _ _
parentkey&1childinput listmemoized functioninput list12data:image/png;base64,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's a place for an epilogue perhaps to store some ideas for further development. Hint: how will we get back to where we came from now?Feel free to add a separate comment on the entire cluster of blocks ...falseThe action within this "do-block is apperently an alternative algorithm, switched of for now. Compared to the other algorithm this one is less concise, and less robust regarding stage size0.1The switch toggles between the "ïf" and "else"-scripts.1000