# PipeFunctionChaining
Implementation of pipe-based function chaining syntax

## Background 
Please see this thread: 

https://scsynth.org/t/function-chaining-operators-opinions-thoughts-do-you-like-this-a-big-hopefully-discursive-post/6627

The following is an abridged version of the above link.

## What it is
Two operators: `|>` and `<|`

## Forward chaining: `|>` operator
A way of chaining function calls together. Here, each _ becomes the result of the previous expression.

### With UGens
```SuperCollider
SinOsc.ar(440) |> LPF.ar(_, \lpf.kr(15000)) |> HPF.ar(_, \hpf.kr(20)) 
|> Out.ar(\out.kr(0), _);
```
A sine wave that is filtered by a low pass, then high pass, then outputted.

### With functions
```SuperCollider
~f = {|i|  "f".postln; i + 1; };
~g = {|i|  "g".postln; i * 2; };
~h = {|i|  "h".postln; i - 2; };

2 |> ~g |> ~f |> ~h;

// returns : g f h -> 3
```

## Backward chaining: `<|` operator
Executed from the right to the left.

### With functions
```SuperCollider
~h <| ~f <| ~g <| 2
// returns : g f h -> 3
```

### With UGens
```SuperCollider
Out.ar(\out.kr(0), _) <| HPF.ar(_, \hpf.kr(20)) <| LPF.ar(_, \lpf.kr(15000)) <| SinOsc.ar(440)
```

## Gotchas
It can get weird - the following is valid.
```SuperCollider
~f = {|i|  "f".postln; i + 1; };
~g = {|i|  "g".postln; i * 2; };
~h = {|i|  "h".postln; i - 2; };

~f <| ( ~g <| 1 |> ~h |> ~g ) |> ~h
// These are equivalent
(1 |> ~g |> ~h |> ~g |> ~f |> ~h)
```

### Brackets
For forward chaining, you need to add brackets around each function
```SuperCollider
1 |> (_ + 1) |> (_ * 2); // works
1 |> _ + 1 |> _ * 2; // does not
```

It gets weirder with backwards…
```SuperCollider
_ * 2 <|  _ + 1 <| 1 // this will evaluate, but returns the wrong result.
(_ * 2) <| ( _ + 1) <| 1 // correct
```
However this mostly goes away if you call messages with a . on the underscore.

### Multi-arity functions are messy.
```SuperCollider
-1 |> (_.neg) |> (_ * 3.5) |> { |r| 
	2 |> (_.sin) |> { |two|
		4 |> _.pow(two) |> _.round(r)
	}
}
```
