data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKAAAAB4CAYAAAB1ovlvAAAAAXNSR0IArs4c6QAAA/VJREFUeF7t3DGPEkEYh/F3SUxsbLmY2BEo0QI7GuwtqCygtiSh4hNAa0J5n4AE6OhtqE2khwYbGwwxIaLimrtEIjGLzGZ3/7fMY+uy784zP0UmeEEYhqHxiwKiAgEAReUZe18AgECQFjgBuFwuU3mYUqmUyn25af4LOAG8uW1ctOLPb9+fXAfAi7J5eZEDwNBubl9dFOnL63f2/emL47UAvCiblxdFAlyv19Zut63f71u9XjczAHopJOVFRwLs9Xq23W7vEUYBfPTyjf34MDU7/Dx5TP4GTHnXruj2vAVf0WbmcSkOAO+Wd+mZdcCHkDxqEDyzI8B4T8iHkHjdfHiVE0COYXwgke0aHQDyKTjbrfFjWiTA+XxunU7HhsPh2WOY4PETC7995VOwH14SX+VZgNVq1RaLRSTAwrPn9uvTx38eimOYxPfpam/IW/DVbm0+FuYAkGOYfGxpvp7SEWC8xXEME6+bD69yAsgxjA8ksl2jA0COYbLdGj+mRQI8HA7WaDRsMBhwDOOHBckqIwFOp1MrFosWBAHHMJKt8WMob8F+7PODXaUDQI5hHuwu5vjBHAHGWynHMPG6+fAqJ4Acw/hAIts1OgDkGCbbrfFjWiTA3W53/CbMuf+UxLdh/ICS1iojAY5GI7v7Nsxms+EYJq363Pf0R3Oc/8kIvAXjJfkCDv8G5Bgm+fzckR9OhAFpAQBK8zMcgBiQFgCgND/DAYgBaQEASvMzHIAYkBYAoDQ/wwGIAWkBAErzMxyAGJAWAKA0P8MBiAFpAQBK8zMcgBiQFgCgND/DAYgBaQEASvMzHIAYkBYAoDQ/wwGIAWkBAErzMxyAGJAWAKA0P8MBiAFpAQBK8zMcgBEGarWadbtda7VaKEmxAADPxG02m8ffXa1WNplMrFwup7gd/t0agP/Z878R/rm0UCjYfr+32Wzmn5iEVwxAACZMyu12AHR4Cx6Px1apVNwKc/XZAgDkQ4j0jwgApfkZDkAMSAsAUJqf4QDEgLQAAKX5GQ5ADEgLAFCan+EAxIC0AACl+RkOQAxICwBQmp/hAMSAtAAApfkZDkAMSAsAUJqf4QDEgLQAAKX5GQ5ADEgLAFCan+EAxIC0AACl+RkOQAxICwBQmp/hAMSAtAAApfkZDkAMSAsAUJqf4QDEgLQAAKX5GQ5ADEgLAFCan+EAxIC0AACl+RkOQAxICwBQmp/hAMSAtAAApfkZDkAMSAsAUJqf4QDEgLQAAKX5GQ5ADEgLAFCan+EAxIC0AACl+RkOQAxICwBQmp/hAMSAtAAApfkZDkAMSAsAUJqf4QDEgLQAAKX5GQ5ADEgLAFCan+EAxIC0AACl+Rn+G8489LeEyrWiAAAAAElFTkSuQmCCActs like MOV in assembler.

blal11cl0one1

The stream version of ITEM (1) OF. The equivalent of SICP function STREAM-CAR. This block is one of five lower-level stream blocks, directly interacting with the data structure, hiding it from the higher-level stream blocks. General info on streams: see the help text of TAIL OF STREAM.

pt:o primeiro item do canal _ The stream version of ALL BUT FIRST OF. The equivalent of SICP* function STREAM-CDR. This block is one of five lower-level stream blocks, directly interacting with the data structure, hiding it from the higher-level stream blocks. The others are: HEAD OF STREAM, IN FRONT OF STREAM, IS STREAM EMPTY?, and THE EMPTY STREAM. Very Short Introduction To Streams: ----------------------------------------------- Streams, also called lazy lists, are like lists except that items are not computed until they're needed. This allows for more efficient handling of large computed lists, and even infinite lists. The only piece of magic is in IN FRONT OF STREAM, whose second input is of type Unevaluated, which means that it's effectively a procedure, with a sort of invisible gray ring. So HEAD OF STREAM is just ITEM 1 OF, but TAIL OF STREAM has a CALL block to make the computation happen. For a demo of streams, try the block STREAM DEMO. Plus, each stream block has its own demo(-s), to be accessed from their respective edit windows. *For a tutorial introduction to streams, read Structure and Interpretation of Computer Programs (SICP), section 3.5 (at the time of writing this Help text, the full text could be read on the internet: https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/index.html); or Brian Harvey's lecture notes (start on page 74): https://people.eecs.berkeley.edu/~bh/61a-pages/Volume2/notes.pdf As of release 2 of the Streams library, the data structure of streams was simplified, and so were TAIL OF STREAM and IN FRONT OF STREAM. Streams created with release 1 of the library (perhaps stored in a variable, or otherwise) can be used with release 2 blocks; insofar as they were already (partly) evaluated, they will be re-evaluated.

pt:um canal com todos os itens de _ menos o primeiro 2423true4The stream version of IN FRONT OF. The equivalent of SICP function CONS-STREAM. The 2nd input parameter is of type Unevaluated. Therefore, calling IN FRONT OF STREAM causes only the first item of the new stream to be evaluated, not the rest of the stream. The latter will be performed, as required, by TAIL OF STREAM. This block is one of five lower-level stream blocks, directly interacting with the data structure, hiding it from the higher-level stream blocks. General info on streams: see the help text of TAIL OF STREAM.

pt:a prefixação de _ ao canal _ A multiline text block, that doesn’t *do* anything.

no comment!A stream without elements. This block is one of five lower-level stream blocks, directly interacting with the data structure, hiding it for the higher-level stream blocks. General info on streams: see the help text of TAIL OF STREAM.

A multiline text block, that doesn’t *do* anything.

no comment!Report if a stream has no elements. The stream version of IS EMPTY?. The equivalent of SICP function STREAM-NULL? A stream is considered empty only if it has been computed and is equal to THE EMPTY STREAM. A stream that has not yet been computed (because it was made with IN FRONT OF STREAM, for example, or with a KEEP whose predicate is never satisfied, isn't empty even though it may not have any elements. This block is one of five lower-level stream blocks, directly interacting with the data structure, hiding it for the higher-level stream blocks. General Info on streams: see the help text of TAIL OF STREAM.

Create a stream from a finite collection of items, like the LIST primitive. Since this block is typically used for small amounts of data, it does not delay computation of its inputs. If you are using a list of all the desired values as input, make sure it is specified to be an INPUT LIST General info on streams: see the help text of TAIL OF STREAM.

pt:um canal com _ 1The stream version of NUMBERS FROM () TO (), with no ending number because it reports the infinite stream of all the integers greater than or equal to its input. Read the code! It's deceptively simple. General info on streams: see the help text of TAIL OF STREAM.

pt:um canal com os números a partir de _ 1Create an infinite stream repeating a finite collection of items. General info on streams: see the help text of TAIL OF STREAM.

pt:um canal com _ 11A highly user-configurable stream generator. INPUT 1. Function generating new stream items; 2. Index (#) of the current item within the stream (may be used by the embedded function); 3. Seeds, i.e. first items of the stream. HOW IT WORKS E.g. with 2 seeds: when generating item 3, items 1 and 2 are inserted into the 1st and 2nd empty slot, repectively, of the embedded function. When item 4 is generated, items 2 and 3 are inserted … (etc.) RESULT An infinite stream. Open the block editor for an example. General info on streams: see the help text of TAIL OF STREAMS.

pt:um canal com os números a partir de _ 1#length1The stream version of variadic MAP (any number of input streams, like MULTMAP in the List utilities library). All input streams must be either infinite or of the same length. General info on streams: see the help text of TAIL OF STREAM.

pt:a aplicação de _ aos itens dos canais _ Create, and at once initialize, and report, a local variable.

Like MAP OVER STREAM(S), but it flattens the result (one level). That is, it requires its first input to be a function that reports a stream, so that MAP would report a stream of streams. FLATMAP reports a stream whose items are *the items of* the streams reported by that function. FLATMAP for lists is typically defined using APPEND to join the items of the sublists. Since streams can be infinite, the substreams can't be appended. Instead, FLATMAP uses INTERLEAVE STREAMS to combine the items of the substreams. Therefore, the order of items in the result is not guaranteed. General info on streams: see the help text of TAIL OF STREAM.

denominator1denominator1A stream version of Python’s list comprehension, with an extra twist. It runs faster than KEEP from MAP, and MAP over KEEP (and MAP over KEEP from MAP, of course). - For MAP over KEEP from MAP, use all slots; - If all you need is MAP over KEEP, leave the third slot empty. - For KEEP from MAP, leave the first slot empty. - For MAP over MAP (really?), make the second slot TRUE. - For KEEP from MAP over KEEP, use an extra KEEP block. - (etc.) General info on streams: see the help text of TAIL OF STREAM.

15letter1The stream version of KEEP. WARNING: If the predicate is such that, beyond a certain point, no other item will ever pass the test, a search with KEEP will not terminate. In such cases, use SEGMENT OF STREAM. General info on streams: see the help text of TAIL OF STREAM.

pt:os itens tais que _ do canal _

map resultThis 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 _ pl:ignoruj _

1The counterpart of IN FRONT OF: returns the first input attached at the back end of the list that is the second input

Declare and at once intialize a local variable

A combination of FIND FIRST ITEM and INDEX OF, for streams. INPUTS: 1. condition to be satisfied by item; 2. stream to be searched. RESULT: a list of two values: 1. item’s value; 2. index of item within the stream. If no item within a finite stream satisfies the condition, "" is reported. If no item within an *infinite* stream satisfies the condition, the search will not terminate (to prevent this, limit the size of the input stream using SEGMENT OF STREAM). General info on streams: see the help text of TAIL OF STREAMS.

index1stream100validxfalse

intermediateReport a specified number of items from a stream as a list. The “delayed continuation”, starting immediately after the last of the reported items, is made available as an upvar (see inside for demo of continuation; be careful not to use the same identifier for input and upvar continuations). Replaces SHOW STREAM from version 1 of this library. The inputs are an integer and a stream. With a positive integer, LIST ... STREAM reports a regular finite list of length less than (for short finite streams) or equal to the integer. It's useful because an infinite stream can't be displayed in a finite amount of time. Alternatively, ”all” (or “Infinity”) may be used as first input, for the showing to continue until the end of the stream will have been reached. Better not try this with infinite streams: the process may never terminate! Another cause of not terminating: 1. the input stream is part of a chain of streams AND 2. the number of elements of the input stream is less than the number of items specified to be reported AND 3. the first stream of the input chain is infinite. For example: LIST ( 10 ) ITEMS OF STREAM ( KEEP ITEMS SUCH THAT ( _ < 5 ) FROM STREAM ( STREAM WITH NUMBERS FROM ( 1 ) ) ). Explanation: after the first 4 items, LIST ( 10 ) ITEMS OF STREAM will keep on asking for more input, and STREAM WITH NUMBERS FROM ( 1 ) will keep generating new items forever, each of which will be discarded by KEEP ITEMS SUCH THAT ( _ < 5 ) FROM STREAM, which is the middle part of the chain. General info on streams: see the help text of TAIL OF STREAM.

10all=InfinitydownstreamThis is the stream version of the COMBINE block for lists. Since lists are finite, it's always possible to combine *all* items of a list. For example, given a list of numbers, it's possible to add all the numbers and report a single number, the sum. Since a stream can be infinite, it's not, in general, possible to combine all its items. Instead, this block reports a stream. The first item of the result stream is the first item of the input stream; the second item of the result stream is the result of combining the first two items of the input; the third item is the result of combining the first three items; and so on. INPUTS: 1. input stream 2. combiner (function) RESULT A stream. The first element is the head of the input stream. Each following element is calculated by applying the combiner on the preceding *result* item and the value of the current /input/ item: result (i) = combiner (result (i-1), input (i)). General info on streams: see the help text of TAIL OF STREAM.

pt:um canal com os números a partir de _ 1InfinityInfinity1The stream version of UNIQUES OF (list). This implementation though elegant is unsuitable for large data. Edit the block to find a faster but less elegant version. General info on streams: see the help text of TAIL OF STREAM.

As of v2 of the Streams library, this block is obsolete (kept as a hidden block for upward compatibility from v1).

pt:a aplicação de _ aos itens dos canais _ Replace any variable from the caller scope with its value

lambdaReplace any variable from the second scope, whose name is not used for a variable within the first scope, with its value.

var name21variablesvariables

namectx

false1

falseReports "unique" items from a stream. An item's unicity is defined as it satisfying the specified condition ("comparator") against any of the earlier reported items. Within the comparator, the first empty slot denotes the current item, the second empty slot denotes any of the earlier reported items. With the comparator ring left empty, the default comparator is _ ≠ _. If the switch “latest 1st” is true, each input item is compared with the latest of all earlier results, then with the second latest, and so on. If the switch is false, the first cimparison will be with the oldest of all earlier results. Though this will not influence nthe outcome, one of the approaches is probably faster.

truetrue110#

trueAn advanced version of INCREMENTALLY COMBINE. The functional difference isi the “precursor”, the would-be item (0) of the result stream.

headAppend any number of streams. To be used only if all streams but the last are finite; otherwise use INTERLEAVE STREAMS. General info in streams: see the help text of TAIL OF STREAM.

first1A variation of FLATMAP delivering a more even distribution of output items over mapped substreams. Applicable only if function (input 1) will create streams. General info on streams: see the help text of TAIL OF STREAM.

denominator1Reports the greatest common divisor of its inputs. If the inputs are values in {0,1} then this is equivalent to the logical OR of the values, with 0=False, 1=True. Hence the APL symbol ∨. Also accepts Snap! Booleans as inputs.

Takes a dyadic scalar function as input, and hyperizes it, so that it can take lists as inputs. Don't use on slow functions (this has compiled map calls). Meant for use on primitives.

abReports True if the input is an APL scalar, i.e., either an atomic (non-list) value, or an array (list of lists) of any depth with only one atomic item, e.g., (list (list (list (3)))).

1Reports a flat list of the maximum size of the input array along each dimension: number of rows, number of columns, etc. "Maximum" because it works even if the array isn't uniformly shaped.

The input must be a value for which SCALAR? reports true, i.e., either an atom or a list of any depth but only one scalar item of item of... etc. This function returns the underlying scalar (number, etc.).

1Takes 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.)

The identity function reports its input.

reports True iff the input is 0 or False.

A variation of FLATTEN STREAM delivering a more balanced distribution of output items among substreams.

insert counter-1remove empty substreamsflatten*substreamsresult111Create a stream that is the result of appending (rather tah interleaving) streams mapped over the input stream. Will only be applicable if function (input 1) will create *finite* streams. General info on streams: see the help text of TAIL OF STREAM.

Alternately report items from each stream. A generalization of SICP function INTERLEAVE-DELAYED. For finite lists, the way to make one list combining the items from several input lists is to APPEND them. But that doesn't work for possibly infinite streams; if the first stream is infinite, no items from the second or additional input streams would be included. Instead, you have to INTERLEAVE the streams, take an item from the first one, an item from the second one, and so on. This ensures that every item of every stream will turn up eventually in the result stream. This block makes no guarantees regarding the precise order in which items appear in the result stream. General info in streams: see the help text of TAIL OF STREAM.

Merge 2 streams, in ascending order (as established by “_ < _”). For the result stream to be in ascending (or non-descending) order, both of the input streams must be. General info on streams: see the help text of TAIL OF STREAMS.

keyskv-pairscolumns1111212Interleave streams that are themselves elements of a stream, such that they become one stream. Does not work on streams whose 1st level items are not (all) streams. General info on streams: see the help text of TAIL OF STREAM.

Reports a list containing a specified number of items from a stream. Replaces SHOW STREAM from version 1 of this library. The inputs are an integer and a stream. With a positive integer, LIST ... STREAM reports a regular finite list of length less than (for shorter finite streams) or equal to the integer. It's useful because an infinite stream can't be displayed in a finite amount of time. Alternatively, ”all” (or “Infinity”) may be used as first input, for the showing to continue until the end of the stream will have been reached. Better not try this with infinite streams: the process will never terminate. General info on streams: see the help text of TAIL OF STREAM.

10all=InfinityMerge any nunber of streams, ordered by key (ascending) INPUT 1. streams to be merged. For the algorithm to work, each of the streams must be pre-ordered by the same key function. 2. a reporter (“key function”) assigning a key to be sorted by, to each input stream item 3. switch indicating whether output items should be unique, as compared to previous items. 4. ”distinguisher”, a two-iitem predicate indicating whether one item is considered unique as compared to another item (default: “_ = _”). RESULT A stream of items from the input streams, ordered by the same key function, and possibly filtered for uniqueness. REMARK Keys are sorted in ascending order as established by “_ < _”. General info on streams: see the help text of TAIL OF STREAMS.

truekeyskv-pairscolumns11merge*1121kv-pairs11head21key112121local historyhead21local history2121

key akey b

key akey bReport a specific item from a stream. (i.e. stream in, item out) The inputs are a positive integer (item number), and the stream. The equivalent of SICP function STREAM-REF. Note that looking for something in a stream by index isn't a very "streamly" style of work. General info on streams: see the help text of TAIL OF STREAM

11.5Reports 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 _ copy of datasplitmerge11#1#2

key akey bb

key akey bbEavesdrop on a stream in action. For debugging purposes only! The log will consume a lot of memory. INPUTS: 1. the stream to be inspected 2. the list to be used as log (put it in a variable watcher to see changes happen) 3. a label for these log entries (optional: not used if this slot is left empty) 4. whether each entry into the log will be indexed (default: FALSE) Reports the input stream, so that it can be inserted in a composition of functions. General info on streams: see the help text of TAIL OF STREAM.

false

de:ist _ leer? wordReports a segment (a contiguous subset) of the input stream, based on given starting and ending conditions. One use of this block is to select a finite subset of a potentially infinite stream, which might be necessary to avoid an infinite recursion. INPUTS: 1. input stream; 2. start condition; 3. end condition; 4. whether to include the first item satisfying the end condition (default = FALSE) SPECIFYING THE START AND END CONDITIONS The two conditions are predicate functions of two inputs, namely, an item from the stream and that item's index (position in the stream). In the start condition, the index is with respect to the input stream; in the end condition, though, the index is taken with respect to the /result/ stream. If the start condition is empty, the resulting segment starts at the beginning of the input stream. If the end condition is empty, the resulting segment will reach to the end of the input stream, or will be infinite if the input is infinite. General info on streams: see the help text of TAIL OF STREAM.

false15falseRead the code while running it. General info on streams: read the help text of TAIL OF STREAM.

denominator1A stream containing all the positive rational numbers:15hanoi1A stream showing which disc to move next in an infinitely tall ”Towers of Hanoi” puzzle:15Demo finished.2Call this block with STREAM WITH NUMBERS FROM 2 as its input to get the infinite stream of all the prime numbers. It's called SIEVE because the algorithm it uses is the Sieve of Eratosthenes: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes General info on streams: see the help text of TAIL OF STREAM.

pt:a crivagem do canal _

As of v2 of the Streams library, this block is obsolete (kept as a hidden block for upward compatibility with v1).

10Edit me.

10create streamshigher order functions and UNIQUESmix streamsANDselectorsdemosEdit me!As of v2 of the Streams Library, this function as been superseded by KEEP ITEMS () FROM STREAM ().

pt:os itens tais que _ do canal _

pt:um canal com _ helpThe stream equivalant of FOR EACH (item) OF (list). CAUTION If the embedded action uses a variable that is external to this block, the variable can not be changed inside the action. General info on streams: see the help text of TAIL OF STREAMS.

A stream of sorted items (in ascending order) from an unsorted list. So item 1 of the stream is the list’s smallest item. If you are only looking for a few of a list’s smallest items, but don’t know how many in advance, this approach makes sense. For practical purposes, [SORTED] OF is usually faster, though. This is because the latter block’s JavaScript code was very much optimized for runtime efficiency - it ain’t fair, really.

lowestlow indexlengthlength21

no comment!

first1

Merge two streams, keeping only items satisfying a logical condition with respect to the items of a second stream. INPUT 1. primary stream; 2. logical operator (AND, OR, XOR, NOT); 3. secondary stream; 4. key function, by which both streams are supposed to have been pre-sorted (ascending). WHAT IT DOES (with each logical operator) AND: items from the primary stream that are also in the secondary stream will be kept (in case of multiple copies in either stream: the output stream will contain as many copies as the minimum number of copies of both input streams); OR: items that are either in the primary or secondary stream, or both, will be kept. In case of multiple copies of an item: like AND. XOR: like OR, but items that are in both streams will be excluded. NOT: items are kept that are in the primary stream and not in the secondary stream.

ANDAND OR XOR but NOTORXORThe counterpart of IN FRONT OF: returns the first input attached at the back end of the list that is the second input

Reverses a list.

The helper for reverse.

de:fange _ _ ca:agafa _ _ es:atrapar _ _ fr:attrape _ _ pt:captura _ _ pl:przechwyć _ _ cont

de:wirf _ ca:llança _ es:lanzar _ fr:lance _ pt:lança _ pl:wyrzuć _ catchtag

de:fange _ _ ca:agafa _ _ es:atrapar _ _ fr:attrape _ _ pt:captura _ _ pl:przechwyć _ _ cont

de:wirf _ _ ca:llança _ _ es:lanzar _ _ fr:lance _ _ pt:lança _ _ pl:wyrzuć _ _ 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 pl:jeżeli _ wykonaj _ i pauzuj wszystko $pause-1-255-220-0 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 _ _ _ pl:kaskada _ razy _ _ _ 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 _ _ _ _ pl:kaskada aż _ _ _ _ Returns the function x↦f(g(x)) where f and g are the two inputs.

pt:a composição de _ com _ ca:composa _ _ pl:skomponuj _ _ 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 _ pl:powtarzaj _ aż _ 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 _ pl:powtarzaj _ gdy _ 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 pl:powtarzaj gdy _ _ 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 _ _ _ pl:powtórz _ _ _ 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 _ _ pl:dla _ = _ co _ do _ _ 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 _ _ pl:ustaw _ na _ w _ _ new value

de:führe _ mit Continuation aus

de:rufe _ mit Continuation auf This block reports the value of the variable with the name given. It looks for that variable following the scope order 'script' -> 'sprite' -> 'global' (the first match it finds). If that variable does not exist (in any scope) an error happens, stopping their script. You can check it before using the "does var (name) exists?" block.

pt:o valor de _ pl:zmienna _ §_getVarNamesDictThis block creates new variables on the selected scope: global (for all sprites), sprite (for this sprite only) or script (only for that blocks stack) with the names given (in 'names' list). If there is already a variable with that name in that scope, it does nothing: no errors and no overwrites.

pt:cria as variáveis _ _ ca:crea les _ variables _ es:crear las _ variables _ de:erstellen _ var _ pl:utwórz zmienną _ _ globalglobal sprite scriptThis block deletes all the variables with the names given (inside input list). Each name will make only one variable deletion, and this will be the variable found following the scope order: 'script' -> 'sprite' -> 'global'. If we have a "testing" sprite variable and also a "testing" global one, deleting "testing" will delete only the sprite one (Yes! we can also do "delete var (testing, testing)" to delete both. If one variable does not exists (in any scope) an error happens, stopping block action in that point. You can check it before with the "does var (name) exists?"block.

pt:remove as variáveis _ ca:esborra les variables _ es:borrar variables _ de:löschen var _ pl:usuń zmienną _ This block sets the given value (last input) to the variable named with the name givent (var input). It looks for that variable following the scope order 'script' -> 'sprite' -> 'global' (the first match it finds). If that variable does not exist (in any scope) an error happens, stopping their script. You can check it before using the "does var (name) exists?" block.

ca:assigna a _ el valor _ es:asignar a _ el valor _ pt:altera _ para _ de:setze var _ auf _ pl:ustaw zmienną _ na _ §_getVarNamesDictThis block reports "true" if there is a variable with this given name (input slot) in that context. It can be a global, sprite or script variable. Otherwise it reports "false".

pt:a variável _ existe ca:existeix la variable _ ? es:existe la variable _ ? de:existiert var _ ? pl:zmienna _ istnieje? err_resetThis block turns on (show) the watcher view on stage (if it was not already activated) of the variable with the given name (slot input). It can only access to the closest variable scope (if there different variables with the same name in different scopes) following the order 'script' -> 'sprite' -> 'global'. No errors if that variable does not exist.

ca:mostra la variable _ es:mostrar variable _ pt:mostra a variável _ de:zeige var _ pl:pokaż zmienną _ §_getVarNamesDictThis block turns off (hide) the watcher view on stage (if it was not already activated) of the variable with the given name (slot input). It can only access to the closest variable scope (if there different variables with the same name in different scopes) following the order 'script' -> 'sprite' -> 'global'. No errors if that variable does not exist.

ca:amaga la variable _ es:esconder variable _ pt:esconde a variável _ de:verstecke var _ pl:ukryj zmienną _ §_getVarNamesDict

1The first input is a shape list as in SHAPE OF. The output is an array with those dimensions containing the atomic items of the second input, repeating values if more are needed.

Reports the greater of its two inputs. Works on strings too.

Reports a flat list of all the atomic elements of sublists of the input list.

Reports the number of dimensions of the input.

11list1Takes a multidimensional array, and reports an array whose dimensions are reversed (as reported by SHAPE OF). In the case of a two-dimensional array, does the usual transposition of rows and columns.

Reverses the order of the (toplevel) items of the input. If the input is a matrix, this means it reverses the order of the rows, which is a reflection through a horizontal axis, as the ⦵ symbol suggests.

Like MAP, but can take any number of lists as inputs. The lists must all be the same size. The function input must take a number of inputs equal to the number of lists. MULTIMAP calls the function with all the first items, then all the second items, and so on.

colscolumns

Computes a generalized matrix multiplication. In normal matrix multiplication, each cell of the result is computed by multiplying individual numbers within a row of the left input and a column of the right input, and then adding those products. In APL terms this is +.× ("plus dot times") Any dyadic functions can replace addition and multiplication in this algorithm; a common case is ∨.∧ ("or dot and")

listlast111last111Reports the smaller of its two inputs.

This function has two names because there are two ways to understand it. Lisp way: A matrix is a list of rows. This block combines the numbers in each row, producing one value for the entire row. APL way: A matrix is made of vectors. This block takes each column as a vector, and does vector arithmetic on the columns, producing one column as the result.

choicesindexchoicesReports 1 if the input is positive, 0 if the input is zero, or -1 if the input is negative.

0falseabsreports 1 divided by its input.

This block reports a random integer between 1 and its input. To roll more than one die, use (for three dice) roll (reshape as 3 items of 6) APL: ?3⍴6 Don't use reshape as 3 items of (roll 6), because that would roll one die and report 3 copies of the same random roll.

Reports the not-and of its inputs, in the form 0 for false, 1 for true.

Reports the not-and of its inputs, in the form 0 for false, 1 for true.

Reports True if the left input is less than or equal to the right input. Reports a Snap! Boolean, not an integer 0 or 1.

Reports True if the left input is greater than than or equal to the right input. Reports a Snap! Boolean, not an integer 0 or 1.

Reports False if its inputs are equal; reports True if its inputs are not equal. The inputs can have any non-list values. (Lists are hyperized.) If the inputs are Booleans (True/False or 1/0), this is also the exclusive-or function.

Reports a Snap! Boolean False if the input is False or 0; reports True otherwise.

Boolean0Turns list of list of ... a single scalar (e.g., ((((x)))) ) into just the scalar. Error if called with anything else.

Make scalar called with non-singleton input If the input is a positive integer, reports a list of the numbers from 1 to that input. (If the input is 0, reports an empty list.) If the input is a list of positive integers, reports an array with the shape specified by the input (as in ⍴ reshape) in which each item is a list of the indices of that item in the array (so technically the shape has one more dimension than the input, whose size is the size of the input). If the input is a list that includes 0, the result is an array whose shape is the part of the input list before the 0, in which every element is empty. If you'd like some other value in every element, MD-MAP a constant function over the result. For list inputs, the size of the result grows very quickly, more or less the factorial of the size of the input. Snap! will not attempt to compute a result bigger than a few million atomic items. ⍳(⍳ 9) will work (≈ 3 million atoms) but ⍳(⍳ 10) will give an error.

If the rank of the left input is one more than the rank of the right input, reports the index of the right input in the left input, or if not found, reports one more than the length of the left input. If the rank of the left input is equal to the rank of the right input, reports a vector of the indices of the items of the right input in the left input (mapping this function over the right input). If the rank of the left input is more than that of the right input by 2 or more, reports a vector, the location of the right input in the left in each dimension. It is an error if the rank of the left input is less than that of the right input.

1resultThis isn't an APL function, although it's related to the outer product. It takes any number of lists, and reports a list of all possible tuples with one item from each of the lists. The length of the result is the product of the lengths of the inputs. The result gets very big very quickly. Snap! will refuse to do this computation if the result would be more than a few million atomic items. (crossproduct (⍳(⍳9))) makes about 3 million atomic items; (crossproduct (⍳(⍳10))) gives an error message.

Reports an array of Booleans the same shape as the left input, indicating which of the atoms in the left input appear anywhere in the right input. (The structure of the right input doesn't matter.)

Like append, but: A scalar input is treated as an array the same shape as the other input except that the last item of the shape is 1. If the two inputs are of different ranks, the function is mapped over the larger ranked input. Catenate adds new columns, by appending to each row.

listIf the input is a nesting of length=1 lists, which APL treats as a scalar (the innermost item) for many purposes, report that innermost scalar. Otherwise, report the input as is. Exposing this block for users is important because Snap! /does not/ treat such a nesting as a scalar, so you might need to use this in translating an APL program to Snap!. (But the functions in the APL library already use this block as needed.)

Reports a vector of indices of the items of the input, in order of the values of the items, so that item (grade up (foo)) of (foo) reports the items in sorted order, smallest to largest. For a matrix, sorts the rows based on their first items, or if those are equal, based on their second items, etc.

Compares two vectors for sorting. Compare first items; if those are equal compare second items; etc.

1111Reports a vector of indices of the items of the input, in order of the values of the items, so that item (grade down (foo)) of (foo) reports the items in sorted order, largest to smallest. For a matrix, sorts the rows based on their first items, or if those are equal, based on their second items, etc.

The left input must be a vector of Booleans (either Snap! form or APL form); the right input must be an array whose first dimension is equal to the length of the left input. The block reports an array of the same rank as the right input, containing only those items (rows, for a matrix) for which the corresponding Boolean is True (or 1).

The left input must be a vector of Booleans (either Snap! form or APL form); the right input must be an array whose last dimension is equal to the length of the left input. The block reports an array of the same rank as the right input, containing only those items (columns, for a matrix) for which the corresponding Boolean is True (or 1).

Turns a row-wise (in Lisp terminology) function into a column-wise one.

Reverses the order of the columns of the input, which is a reflection through a vertical axis, as the ⏀ symbol suggests.

This function has two names because there are two ways to understand it. Lisp way: A matrix is a list of rows. This block turns it into a list of columns, and combines the numbers in each column, producing one value for the entire column. APL way: A matrix is made of vectors. This block takes each row as a vector, and does vector arithmetic on the rows, producing one row as the result.

Like append, but: A scalar input is treated as a vector of length 1. If the two inputs are of different ranks, the function is mapped over the larger ranked input. Catenate vertically adds new rows, by appending to each column.

listA hyperblock version of JOIN. The regular JOIN isn't hyperized because it can accept a list as input, representing it as text.

A positive left input selects the first n items of the right input. A negative left input selects the last abs(n) items of the right input. If the right input is a matrix, a numeric left input selects rows; the left input may also be a two-item vector, in which case the first number is applied to the rows and the second number is applied to the columns. Similarly for higher-dimension arrays.

1length0absvalueindexA positive left input selects all but the first n items of the right input. A negative left input selects all but the last abs(n) items of the right input. If the right input is a matrix, a numeric left input selects rows; the left input may also be a two-item vector, in which case the first number is applied to the rows and the second number is applied to the columns. Similarly for higher-dimension arrays.

0valueindexThrow 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 _

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.

( )Computes logarithms in any base. The base is the left input. It's usual in APL that if there's a main data input and some sort of control input, the latter comes on the left. This is because APL syntax, unless you use parentheses, groups computations from right to left. APL has a monadic version of this function that computes natural logs (log to the base e).

Computes the number of combinations of right-input things taken left-input at a time, otherwise known as the elements of Pascal's triangle. This block shares the ! symbol with the monadic factorial function, because the formula for computing this function uses factorials.

The factorial of a positive integer n is the product of the integers from 1 to n. In real APL, the domain of this function is extended beyond integers to compute the gamma function.

Acts just like the function selected from the pulldown menu, but hyperized, so comparing two equal-sized lists reports a list of the same length as the inputs, with the results of item-by-item comparisons.

﹦﹦ ≠ identical to and or is _ a _?Reports the least common multiple of its inputs. If the inputs are values in {0,1} then this is equivalent to the logical AND of the values, with 0=False, 1=True. Hence the APL symbol ∧. Also accepts Snap! Booleans as inputs.

Reports 1 if the input is False or 0; otherwise reports 0.

Reports its input. This is useful to fit a value into a different-type input slot, e.g., number into list slot.

Report a list with left-input random integers in the range 1 to right-input. No number appears more than once in the result. The left input must be less than or equal to the right input.

Given two arrays A and B, reports an array whose dimensions are APPEND(SHAPE OF (A), SHAPE OF (B)) in which each atomic item of the result is computed by applying the dyadic function input to an item of A and an item of B.

11turn LISP syntax text code into blocks

de:verwandle Code _ in Blöcke ca:blocs del codi textual _ (+ 3 4)turn blocks into LISP syntax text code.

de:verwandle Blöcke _ in Code _ formatiert ca:codi textual dels blocs _ formatats _ true

de:Objekt _ $_field $_thing11

de:klone _ _ $_field $_thing11

de:Feld _ von _ _ §_dynamicMenu

de:füge _ zu _ hinzu $_field $_thing11old

de:Wenn Variable _ sich ändert §_getVarNamesDictoldcallertrue

de:Wenn _ > _ $_volumevolume=$_volume timer=$_timer5

de:Wenn Hintergrund zu _ wechselt §_dynamicMenulast state

de:hat _ sich ereignet? last stateold

de:hat _ sich verändert? oldtrueold

de:Wenn _ sich ändert oldtrue

de:Neigung _ ar:_ الميل ض ca:inclinació _ cs:náklon _ el:κλίση _ es:inclinación _ fr:inclinaison _ gl:inclinación _ ja:_ 仰角 nl:kantel _ pl:nachylenie _ pt_BR:inclinação _ pt:inclinação _ ru:наклон _ ta:சாய் _ tr:eğilim _ zh_CN:倾角 _ zh_TW:倾角 _ xx y z ~ xyz

data:image/png;base64,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2000*the empty stream*00