Issue #20770 has been updated by eightbitraptor (Matthew Valentine-House). [The Ruby-lang homepage](https://www.ruby-lang.org) states that Ruby has
a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
And on the [about page](https://www.ruby-lang.org/en/about/):
Ruby often uses very limited punctuation and usually prefers English keywords, some punctuation is used to decorate Ruby.
In my opinion this proposal conflicts with this description because: 1. `|>` is less natural to read than the English word `then`. `then` has a clear and unambiguous meaning, `|>` is an arbitrary combination of symbols that developers need to learn. 2. `|>` masks complexity - requiring users to learn and remember knowledge that could be easily read from the source code. I don't understand, from reading this discussion, what benefit we would gain from writing the proposed: ``` client_api_url |> URI.parse(it) |> Net::HTTP.get(it) |> JSON.parse(it).fetch(important_key) ``` especially when, as has already been pointed out, we can do this in the current version: ``` client_api_url .then { URI.parse(it) } .then { Net::HTTP.get(it) } .then { JSON.parse(it).fetch(important_key) } ``` which is arguably more readable, and more intention revealing. Lastly
bringing functionality from functional languages into Ruby without introducing any complexity, while maintaining ruby's simplicity.
This isn't importing functionality from other languages, merely syntax. I'm against adopting syntax if there isn't a clear (and preferable measurable) benefit to the Ruby ecosystem. ---------------------------------------- Feature #20770: A *new* pipe operator proposal https://bugs.ruby-lang.org/issues/20770#change-110007 * 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/