Issue #20770 has been updated by AlexandreMagro (Alexandre Magro). vo.x (Vit Ondruch) wrote in #note-18:
Right, this was far fetched and would not work admittedly. But that is why I proposed the `client_api_url.to(URI)`, because after all, this is IMHO mostly about type conversion. Why would I ever want to call something like `URI.parse(it)`? Why would I need to know there is `parse` method and why would I need to put `it` / `_1` multiple times everywhere and every time in different context.
Zverok was precise in his comment. I understand your point, but the idea of to(URI) introduces an inversion of responsibility, which can lead to dependency inversion issues — a poor practice in software design, especially when working with different libraries. It's unclear what you mean by `client_api_url` in this context since, in my example, it was simply a string. Having a .to method on a string seems generic and nonsensical. As for the question "Why would I ever want to call something like URI.parse(it)?", code is already written this way. The pipe operator doesn’t change the syntax but rather inverts the reading flow. Lastly, the pipe operator is a well-established concept that aims to streamline existing Ruby syntax, not alter it. ```ruby client_api_url |> URI.parse(it) |> Net::HTTP.get(it) |> JSON.parse(it).fetch(important_key) ``` This is so clean. It's just Ruby. ---------------------------------------- Feature #20770: A *new* pipe operator proposal https://bugs.ruby-lang.org/issues/20770#change-109998 * 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/