That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```
const doubleThenSquareRoot = value=>squareRoot(double(value))
```

Pipe:
```
const doubleThenSquareRoot = double |> squareRoot
```

On Fri, 25 Aug 2017 at 00:36 dante federici <c.dante.federici at gmail.com>
wrote:

> This is probably covered by the pipeline operator proposal:
>
> https://github.com/tc39/proposal-pipeline-operator
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20170824/97ef35a8/attachment.html>

That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```javascript
const doubleThenSquareRoot = value=>squareRoot(double(value))
```

Pipe:
```javascript
const doubleThenSquareRoot = double |> squareRoot
```

That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```javascript
const doubleThenSquareRoot = value=>squareRoot(double(value))
```


Pipe:
```javascript
const doubleThenSquareRoot = double |> squareRoot
```

That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```javascript
const doubleThenSquareRoot = value=>squareRoot(double(value));
```

Pipe:
```javascript
const doubleThenSquareRoot = double |> squareRoot;
```

That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```javascript
const doubleThenSquareRoot = value=>squareRoot(double(value))
```

vs
Pipe:
```javascript
const doubleThenSquareRoot = double |> squareRoot
```

That's a syntax for calling functions, not creating a composed function for
being called any time.

Personally I don't find that proposal compelling because I don't think it
saves much code vs current syntax - it only straightens the order and
replaces () with using |>.

However, if it were used for function composition instead, it could be more
useful e.g.

Current way:
```javascript
const doubleThenSquareRoot = value=>squareRoot(double(value))
```

Pipe:
```javascript
const doubleThenSquareRoot = double |> squareRoot
```