From: zverok.offline@... Date: 2020-11-29T18:32:10+00:00 Subject: [ruby-core:101142] [Ruby master Feature#17353] Functional chaining operator Issue #17353 has been updated by zverok (Victor Shepelev). "Let's take `|>` from Elixir" is proposed roughly once a month. The problem with this proposal is that it doesn't work well with Ruby syntax. Ruby's core chaining module is `Enumerable` ("core" in the sense it shows how the things are designed here), and core chainable item is block. So let's look at your example: ```ruby def handle(requests) = requests |> Array.filter { not _1.from.user.banned? } |> Array.map { _1 |> main_router.emit } |> Array.each &awaiter ``` There is no way (besides "it is Elegant Because It Is Elegant In Elixir") how exactly it is better than ```ruby def handle(requests) = requests .filter { not _1.from.user.banned? } .map { main_router.emit(_1) } .each &awaiter ``` Now, this (one-item chaining): ```ruby gets.to_i |> make_stuff |> format "the number is %d" |> puts ``` is handled by [Object#then](https://ruby-doc.org/core-2.7.0/Object.html#method-i-then), existing since 2.6: ```ruby gets.to_i .then(&method(:make_stuff)) .then { format "the number is %d", _1 } .then(&method(:puts)) ``` Which is exactly "ideologically compatible" with how Enumerable chaining works, trivially implemented and place nice with all possible Ruby intuitions. Now, method references and currying is another, sadder, story, but it would be sad with any chaining syntax. ---------------------------------------- Feature #17353: Functional chaining operator https://bugs.ruby-lang.org/issues/17353#change-88823 * Author: fulcanelly (Maks Kompanienko) * Status: Open * Priority: Normal ---------------------------------------- Since ruby already moving in that direction(functional), I would like to propose add to it OCaml-like chaining/pipe operator into ruby. Which would allow such syntax ``` ruby def handle(requests) = requests |> Array.filter { not _1.from.user.banned? } |> Array.map { _1 |> main_router.emit } |> Array.each &awaiter ``` What exactly happens here ? Let's look at a bit easier example: ``` ruby gets.to_i |> make_stuff |> format "the number is %d" |> puts ``` Which is expands exactly to the code below ```ruby puts(format("the number is %d", make_stuff(gets.to_i))) ``` So what this operator does is nothing but just tricky form of AST building Advantages: * Increase readability * It's more duck type-ish Limitations: * cant be overloaded -- https://bugs.ruby-lang.org/ Unsubscribe: