Each
Each (¨) is a primitive monadic operator which applies its operand to each element of the arguments, and returns an array whose elements are the results. If two arguments are given, their elements are matched using conformability rules.
Definition
Each is defined only in nested APLs. Some flat APLs obtain analogous functionality by using an Under operator with close composition along with the rank-0 function Disclose (or Unbox). In SHARP APL this is written <syntaxhighlight lang=apl inline>f¨></source>. In J it is <syntaxhighlight lang=j inline>f&.></source>.
Each differs from the Rank operator with rank 0 in that the operand arguments and results are not enclosed. As the elements of a nested array they need not be scalar. <syntaxhighlight lang=apl inline>f¨</source> can therefore be defined as <syntaxhighlight lang=apl inline>⊂⍤f⍥⊃⍤0</source>.
The Each operator has no effect on scalar functions, since these functions already map over each array element. For example, both expressions below have the same meaning, since <syntaxhighlight lang=apl inline>+</source> is a scalar function. <syntaxhighlight lang=apl>
1 + 1 2 3 4
2 3 4 5
1 +¨ 1 2 3 4
2 3 4 5 </source>
Examples
<syntaxhighlight lang=apl>
1,1 2 3 ⍝ join 1 with 1 2 3
1 1 2 3
1,¨1 2 3 ⍝ join 1 with each element of 1 2 3
┌───┬───┬───┐ │1 1│1 2│1 3│ └───┴───┴───┘
x←'abc' 'def' 'ghi'
⌽x ⍝ reverse x
┌───┬───┬───┐ │ghi│def│abc│ └───┴───┴───┘
⌽¨x ⍝ reverse each element of x
┌───┬───┬───┐ │cba│fed│ihg│ └───┴───┴───┘ </source>
Mapping
It is very common to pair up an entire array with each element of a different array. There are two common ways to do this using Each. The first is to enclose the argument that is to be used as a whole for each element of the other array: <syntaxhighlight lang=apl>
(⊂10 20 30),¨1 2 3 ⍝ Computes (10 20 30,1)(10 20 30,2)(10 20 30,3)
┌──────────┬──────────┬──────────┐ │10 20 30 1│10 20 30 2│10 20 30 3│ └──────────┴──────────┴──────────┘
10 20 30,¨⊂1 2 3 ⍝ Computes (10,1 2 3)(20,1 2 3)(30,1 2 3)
┌────────┬────────┬────────┐ │10 1 2 3│20 1 2 3│30 1 2 3│ └────────┴────────┴────────┘ </source> The other method is by binding the argument that is to be used as a whole to the function, deriving a monadic function, which is then applied using Each: <syntaxhighlight lang=apl>
10 20 30∘,¨1 2 3 ⍝ Computes (10 20 30,1)(10 20 30,2)(10 20 30,3)
┌──────────┬──────────┬──────────┐ │10 20 30 1│10 20 30 2│10 20 30 3│ └──────────┴──────────┴──────────┘
,∘1 2 3¨10 20 30 ⍝ Computes (10,1 2 3)(20,1 2 3)(30,1 2 3)
┌────────┬────────┬────────┐ │10 1 2 3│20 1 2 3│30 1 2 3│ └────────┴────────┴────────┘ </source> Note how binding a right argument derives a monadic function which still takes its single argument on the right.
Selecting
An enclosed array is a scalar, which is subject to scalar extension. This can be used to simulate outer product by a one-sided Each (pair the entire right argument with each element of the left argument, or vice versa). An application of this behavior is the "chipmunk idiom" <syntaxhighlight lang=apl inline>X⊃¨⊂Y</source>, which simulates <syntaxhighlight lang=apl inline>Y[X]</source> for (possibly nested) vector Y and simple X:
<syntaxhighlight lang=apl>
(2 2⍴1 2 2 1)⊃¨⊂(1 2)(3 4)(5 6) ⍝ Computes (1 2)(3 4)(5 6)[2 2⍴1 2 2 1]
┌───┬───┐ │1 2│3 4│ ├───┼───┤ │3 4│1 2│ └───┴───┘ </source>
External links
Lessons
Documentation