# Each

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
 `¨`

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 `f¨>`. In J it is `f&.>`.

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. `f¨` can therefore be defined as `⊂⍤f⍥⊃⍤0`.

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 `+` is a scalar function.

```      1 + 1 2 3 4
2 3 4 5
1 +¨ 1 2 3 4
2 3 4 5
```

## Examples

```      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│
└───┴───┴───┘
```

### 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:

```      (⊂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│
└────────┴────────┴────────┘
```

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:

```      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│
└────────┴────────┴────────┘
```

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" `X⊃¨⊂Y`, which simulates `Y[X]` for (possibly nested) vector Y and simple X:

```      (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│
└───┴───┘
```