proposal-pipeline-operator

There is a js proposal to add this to language: https://github.com/tc39/proposal-pipeline-operator There are few exceptions (namespaces, enums) but typescript has been quite averse to adding non-standard language level features outside type annotations. This feature will likely come to ts after this proposal has been accepted for js.

It feels weird that the CSS WG does a popular vote for a different syntax implementing the same feature, something that an expert opinion should weigh way more then popular demand. But at the same time TC39 picked an archaic version of the pipeline operator (|> https://github.com/tc39/proposal-pipeline-operator) despite a clear demand from the community to pick a functional one. Perhaps the two committees should learn a bit from each other.

The pipeline operator [1] is a bit further along, although I'm not exactly holding my breath for it either. At least it currently has a champion. With pipelines import { map, takeWhile, forEach } from "iterlib"; getPlayers() |> map(%, x => x.character()) |> takeWhile(%, x => x.strength > 100) |> forEach(%, x => console.log(x)); 1: https://github.com/tc39/proposal-pipeline-operator

This is common in the functional paradigm, although syntax and semantics varies in sometimes important ways among languages. There's a long-standing TC39 proposal to add it to JS. It's interesting to read it to see examples of the aforementioned differences. https://github.com/tc39/proposal-pipeline-operator

For reference. Pattern matching: https://github.com/tc39/proposal-pattern-matching Do expression: https://github.com/tc39/proposal-do-expressions Pipe operator: https://github.com/tc39/proposal-pipeline-operator

This is quite elegant! Direct link to the source of OP's pipe function and recursive type definitions: https://github.com/MathisBullinger/froebel/blob/main/pipe.ts... On a related note, I've been frustrated by the slow progress on https://github.com/tc39/proposal-pipeline-operator - specifically the thread in https://github.com/tc39/proposal-pipeline-operator/issues/91 which has 668 comments over 4+ years and shows no meaningful sign of consensus. The TC39 group is (justifiably) very concerned about backwards and future compatibility, and Typescript has a policy of not introducing syntax that is in scope for Javascript itself until the syntax has formally reached a stable state (see: https://github.com/Microsoft/TypeScript/issues/2103#issuecom...) - so we're far from having a pure operator for this. But `pipe((n: number) => n.toString(),

> Switch statements JS has had switch statements for a long time. Do you mean switch "expressions" that can be used inline? It's not pretty but JS has long supported that too using either eval() "hacks" or IIFEs: https://stackoverflow.com/questions/32451049/is-eval-the-onl... Do you mean pattern matching? There are two Stage 1 TC39 proposals with different approaches to it: More hands-on/direct: https://github.com/tc39/proposal-pattern-matching More indirect: https://github.com/tc39/proposal-do-expressions > list comprehensions There are several libraries with strong Iterator support today that while not syntactically gorgeous do great jobs at allowing you to write simple list operations. Off the top of my head are IxJS and iter-tools, but also classic mainstays like up to date versions of lodash and Ramda. There's a Stage 2 proposal to b

> So really monads are essentially an abbreviated syntax? Chaining functions, where (some of) the arguments are hidden from the language syntax and inserted by the compiler? That's a part of it, for instance see: https://philipnilsson.github.io/Badness10k/posts/2017-05-07-... I recently wrote a note related to this that had a useful exchange: >> When you see a "do" block, where do you look to figure out what it's actually doing? > If you need to know, you look at what consumes the result. If it's abstract (say it's a top level binding `... -> m a` where the m is abstract) *you don't _need_ to know "what it is actually doing" - it should be correct for any choice of* `m`. The behavior, and the "laws" or perhaps general far-reaching properties, are the more important part of Monads I think. > How does that relate to “pipe operator” as in h

So really monads are essentially an abbreviated syntax? Chaining functions, where (some of) the arguments are hidden from the language syntax and inserted by the compiler? How does that relate to “pipe operator” as in https://github.com/tc39/proposal-pipeline-operator Are monads also linear types? I mean, if I have a monad which represents system IO state, each value of system state can only be consumed once in actual execution, I can’t split the IO state in two and print different outputs on each branch. But I can do that in a conditional expression because only one branch is ever actually realised. For IO state, data branching is only allowed when guarded by control branching.

Same thing, but for JavaScript: https://github.com/tc39/proposal-pipeline-operator Going forward, the pipe operator is going to be showing up in many new languages. I've used elixir a lot, and the pipe operator is a genius piece of syntactic sugar.