Issue #20770 has been updated by zverok (Victor Shepelev). @AlexandreMagro I don’t think this analogy is suitable here. Of course, there are operators that aren’t convenient to use in chaining (though, I should admit to the sin of sometimes just using `the.chain.with.+(argument).like.that`, and it works and follows the existing Ruby semantics and intuitions, even if not to everybody’s liking). But my point was that the proposed construct is _specifically_ for easier chaining but doesn’t fall in line with any other Ruby’s tool for that. I think a comparison with Elixir demonstrates that. In Elixir, you’ll say, “see, whatever you need to do with the value, just do with more `|>`, it is all the same.” In Ruby, you say “when you work with collections, you do `.method` and blocks; when you work with methods object already has, you do `.method`; when you need debug print in the middle of the chain, you can `.tap { p _1 }` just like that... But oh, there is also this one nice operator which you can’t mix with anything but it is there too... And it also creates an invisible block like nowhere else, but it is just there for convenience and looking like Elixir, sometimes!” That’s the major drawback of the proposal in my eyes, and I fail to see a comparably major _gain_. ---------------------------------------- Feature #20770: A *new* pipe operator proposal https://bugs.ruby-lang.org/issues/20770#change-110024 * Author: AlexandreMagro (Alexandre Magro) * Status: Open ---------------------------------------- Hello, This is my first contribution here. I have seen previous discussions around introducing a pipe operator, but it seems the community didn't reach a consensus. I would like to revisit this idea with a simpler approach, more of a syntactic sugar that aligns with how other languages implement the pipe operator, but without making significant changes to Ruby's syntax. Currently, we often write code like this: ```ruby value = half(square(add(value, 3))) ``` We can achieve the same result using the `then` method: ```ruby value = value.then { add(_1, 3) }.then { square(_1) }.then { half(_1) } ``` While `then` helps with readability, we can simplify it further using the proposed pipe operator: ```ruby value = add(value, 3) |> square(_1) |> half(_1) ``` Moreover, with the upcoming `it` feature in Ruby 3.4 (#18980), the code could look even cleaner: ```ruby value = add(value, 3) |> square(it) |> half(it) ``` This proposal uses the anonymous block argument `(_1)`, and with `it`, it simplifies the code without introducing complex syntax changes. It would allow us to achieve the same results as in other languages that support pipe operators, but in a way that feels natural to Ruby, using existing constructs like `then` underneath. I believe this operator would enhance code readability and maintainability, especially in cases where multiple operations are chained together. Thank you for considering this proposal! -- https://bugs.ruby-lang.org/