# Split composition: Difference between revisions

No edit summary |
m (Language source block, instead of pre) |
||

Line 4: | Line 4: | ||

In [[Extended Dyalog APL]] and [[dzaima/APL]], the construct can be formed using [[Reverse Compose]] (<code>⍛</code>) and [[Compose]] (<code>∘</code>). In this example, we multiply the [[interval]] (integers up until) of the left argument, with the [[Magnitude]] of the right: | In [[Extended Dyalog APL]] and [[dzaima/APL]], the construct can be formed using [[Reverse Compose]] (<code>⍛</code>) and [[Compose]] (<code>∘</code>). In this example, we multiply the [[interval]] (integers up until) of the left argument, with the [[Magnitude]] of the right: | ||

< | <source lang=apl> | ||

5 ⍳⍛×∘| 5 ¯8 ¯2 ¯5 3 | 5 ⍳⍛×∘| 5 ¯8 ¯2 ¯5 3 | ||

5 16 6 20 15 | 5 16 6 20 15 | ||

</ | </source> | ||

This is evaluated as <source lang=apl inline>(⍳5) × (|5 ¯8 ¯2 ¯5 3)</source>. A further example concatenates the reciprocal of the left argument with the negation of the right: | This is evaluated as <source lang=apl inline>(⍳5) × (|5 ¯8 ¯2 ¯5 3)</source>. A further example concatenates the reciprocal of the left argument with the negation of the right: | ||

<source lang=apl> | <source lang=apl> |

## Revision as of 00:04, 27 April 2022

**Split-compose** is a tacit construct, used to pre-process its argument(s) with the left and right-most operand before applying the middle operand between the result. Given functions `f`

, `g`

, and `h`

, the split composition on arguments `x`

and `y`

is defined as `(f x) g (h y)`

.

The name was introduced by the I language, where it is represented with `O`

, a higher-order function that applies first to the middle function and then the two outer functions (`O`

also represents the Over operator). It doesn't appear as a primitive in any APL, nor can it, because it is a composition of three functions, while a compositional operator can take no more than two operands. This situation is identical to that of the fork. Both split-compose and fork can be constructed using two companion operators, tying together the three involved functions.

In Extended Dyalog APL and dzaima/APL, the construct can be formed using Reverse Compose (`⍛`

) and Compose (`∘`

). In this example, we multiply the interval (integers up until) of the left argument, with the Magnitude of the right:

```
5 ⍳⍛×∘| 5 ¯8 ¯2 ¯5 3
5 16 6 20 15
```

This is evaluated as `(⍳5) × (|5 ¯8 ¯2 ¯5 3)`

. A further example concatenates the reciprocal of the left argument with the negation of the right:

```
2(,⍨∘÷⍨∘-⍨⍨)4
0.5 ¯4
```

This is evaluated as `(÷2) × (-4)`

.

## Alternatives

In dialects that lack Reverse Compose (and even Compose), split-compose can be written either by defining the missing operator(s), or as a single derived function or fork, if this is supported. For example, in Dyalog APL the expression can be formed with Compose and Commute (`⍨`

) as `g⍨∘f⍨∘h`

:

```
5 ×⍨∘⍳⍨∘| 5 ¯8 ¯2 ¯5 3
5 16 6 20 15
2(,⍨∘÷⍨∘-)4
0.5 ¯4
```

Note that `g∘h⍨∘f⍨`

applies `f`

before `h`

which can matter for functions with side effects. For example, consider the following where `'x' f⍛g∘h 'y'`

would print `hfg`

:

```
f←{⍞←⊃⎕SI}
g←{⍞←⊃⎕SI}
h←{⍞←⊃⎕SI}
'x' g⍨∘f⍨∘h 'y'
hfg
'x' g∘h⍨∘f⍨ 'y'
fhg
```

The equivalent fork is `f⍤⊣ g h⍤⊢`

, for example:

```
5 (⍳⍤⊣×|⍤⊢) 5 ¯8 ¯2 ¯5 3
5 16 6 20 15
2(÷⍤⊣,-⍤⊢)4
0.5 ¯4
```