From: "AlexandreMagro (Alexandre Magro) via ruby-core" <ruby-core@...>
Date: 2024-09-30T21:23:29+00:00
Subject: [ruby-core:119366] [Ruby master Feature#20770] A *new* pipe operator proposal

Issue #20770 has been updated by AlexandreMagro (Alexandre Magro).


vo.x (Vit Ondruch) wrote in #note-6:
> Code like `add(value, 3)` is hardly some idiomatic Ruby. If it was Ruby, then you'd likely use `value.add(3)` or `value + 3`. Other examples of readable code are [here](https://poignant.guide/book/chapter-3.html). I can't see what is readable about the new operator.
> 
> Also, I'd say that `Math` module is bad example in general, because it seems to be influenced by commonly used math notation. But arguably, having something like `Math::PI.cos` or `3.14.cos` would be quite natural for Ruby.

I believe there���s a misunderstanding here. The example `add(value, 3)` is not intended to represent an idiomatic Ruby expression, like `value + 3`. Rather, it illustrates how a method call that modifies or processes a value would work within a pipeline.

Using the pipe operator is helpful for showing the order of executions. For example, if you want to execute a function `f` followed by `g`, you could write:

```
g(f(x))
```

However, it's easier to follow the order of executions (e.g., f and then g) when written like this:

```
x |> f |> g
```

In real-world scenarios, especially when working with APIs or complex transformations, it's common to prepare data step by step before reaching the final function. Instead of using intermediate variables, which might only be used once, the pipe operator offers a clearer and more efficient solution. For instance, consider fetching and processing data from a client API:

```
response = URI.parse(client_api_url)
response = Net::HTTP.get(response)
response = JSON.parse(response).fetch("client_data")
puts "Client info: #{response}"
```

With the pipe operator, the same logic can be simplified and made more readable:

```
client_api_url
  |> URI.parse(it)
  |> Net::HTTP.get(it)
  |> JSON.parse(it).fetch(important_key)
```

This approach not only avoids unnecessary variables but also makes the flow of data through the pipeline much clearer. The pipe operator simplifies this pattern and ensures readability, without adding complexity to method calls. It also provides flexibility in how the "passed" value is used throughout the steps.

Again, these are simplified examples of real-world problems, where the pipe operator can help streamline and clarify otherwise convoluted method chains.

----------------------------------------
Feature #20770: A *new* pipe operator proposal
https://bugs.ruby-lang.org/issues/20770#change-109979

* 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/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/