# Split composition

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
```
APL syntax 
General Comparison with traditional mathematicsPrecedenceTacit programming (Train, Hook, Split composition)
Array Numeric literalStringStrand notationObject literalArray notation (design considerations)