proposal-pipeline-operator

All the stuff babel includes is really impressive. Checkout the pipeline operator: https://github.com/babel/proposals/issues/29 (https://github.com/tc39/proposal-pipeline-operator) That's some cutting-edge stuff. I wouldn't want to use it until it was official, but it's cool to have the opportunity to try TC39 (https://github.com/tc39) proposals via babel. In addition to the normal compiler usage for the latest standards. > We received a $1k/month donation from Facebook Open Source! > This the highest monthly donation we have gotten since the start (next highest is $100/month). When I read this, I kind of mumbled to myself, "that's all?" It goes to show how poorly funded open source projects are. We rely on these tools, file issues, and want them to work, yet there isn't enough to even pay someone to work on it full time. https://twitter.

This is object-oriented method chaining. Not the same thing as functional composition (piping is essentially just left-to-right composition), which is what's mentioned in the OP. It's also nowhere near as flexible, because it requires the return value to be responsible for providing a set of APIs for the next method call on every step of the chain, whereas each function in a functional composition can operate on any arbitrary input/output. There's actually a proposal for a pipeline operator in JS that I personally really like: https://github.com/tc39/proposal-pipeline-operator I have no idea if it's getting enough traction to get standardized anytime soon though. In lieu of that, I personally just use Ramda's `pipe` function: http://ramdajs.com/docs/#pipe Which accomplishes the same thing, but with a bit more ceremony, and not quite as co

I feel like the functional code you wrote was written to intentionally obfuscate what is being done. For instance, composing a bunch of methods inline doesn't have any utility for it unless you define what compose(xor, lol, rofl) really means. Ideally this is how it should be written for maximum readability. things |> pluck('bar') |> map(xor) |> map(lol) |> map(rofl) |> reduce(differenceWith('id') The code is written equally well without using pipe operator but the proposal to introduce it is in works [1]. Here is it using lodash (not even lodash-fp), and this is going to do a single for loop when executing because this is lazy. _.chain(things) .pluck('bar') .map(_.xor) .map(_.lol) .map(_.rofl) .reduce(_.differenceWith('id')) .value(); It's no less readable than the code you'd write using using unfolded

Refers to this ESNext proposal : https://github.com/gilbert/es-pipeline-operator By @svensauleau : https://twitter.com/svensauleau/status/881878965585145858