From: "austin (Austin Ziegler) via ruby-core" <ruby-core@...>
Date: 2024-11-29T17:27:32+00:00
Subject: [ruby-core:120060] [Ruby master Feature#20770] A *new* pipe operator proposal

Issue #20770 has been updated by austin (Austin Ziegler).


lpogic (��ukasz Pomiet��o) wrote in #note-49:

> The notation `a |>= b` could be considered syntactic sugar for `a = a |> b`. Please remember that most binary operators in Ruby have similar syntactic sugar (including `||` and `&&`). I don't see why the "pipe" operator should be an exception.
> 
> I see the potential for such a feature in situations where we want to perform some operation on an object and replace it with the result. So far, only operations of type `foo.a = foo.a / b` can be written without explicitly referring to `foo.a` twice (`foo.a /= b`). Swapping the order of arguments or using a method instead of an operator breaks the notation. However, using a "pipe" with assignment would give us more freedom, since it would apply to any case where `foo.a` is on both sides of the assignment: `foo.a |>= b / _`, `foo.a |>= _.div b`.
> 
> Perhaps this is not an essential issue for the idea itself, but I think it may have an impact on the direction of change.

I do not see how any of this improves the readability of the code. IMO, it does the exact opposite. Remember, the `|>` proposal here is essentially syntax sugar for `.then` with an invisible block:

```ruby
foo.bar |> b / _
foo.bar.then { b / _1 }
```

*Neither* of these is as readable as `b / foo.bar`, and your example introducing `|>=` is less readable than `foo.bar = b / foo.bar`, if slightly shorter and substantially less readable.

A pipeline operator, if one is introduced to Ruby (and I don't think Ruby needs one), is a relatively efficient way of carrying the result from one expression into a parameter of the next expression, and is *generally* considered less readable when there is only one function in the pipeline. That is:

```elixir
foo |> bar() # less readable
bar(foo) # more readable

baz(bar(foo)) # less readable
foo
|> bar()
|> baz() # mor�� readable
```

> Another thing I think is worth considering is the conditional "pipe" operator. It could combine features of the "pipe" operator with the `&&`. Like "pipe" with assignment, it could prevent self-repeating in some cases. Let's assume its notation would be `&>`:
> ```ruby
> foo = Struct.new(:bar).new
> # Please assume the code above is immutable.
> 
> v = foo.bar &> Integer.sqrt _  # No exception here as right side is evaluated only if foo.bar is not false nor nil.
> v # => nil
> ```
>
> How can I put this more simply?

I don't see how that is more readable than `v = foo.bar && Integer.sqrt(foo.bar)`. I would oppose `&>` regardless, because `|>` is not the opposite in the way that `&&` and `||` are.

 ---

As I said, I don't think Ruby needs a pipe operator, but I wonder if a *different* approach might be taken. In irb, `_` is automatically assigned the result of the previous expression (well, expression *line*; it doesn't carry *within* an expression). What if that was done for Ruby as a whole? That is, `v = foo.bar && Integer.sqrt(_)` would be the same as `v = foo.bar && Integer.sqrt(foo.bar)` because `_` would be the value of `foo.bar`.

Similarly, you could get a pipeline behaviour without any extra syntax elements:

```ruby
"https://api.github.com/repos/ruby/ruby"
URI.parse(_)
Net::HTTP.get(_)
JSON.parse(_)
_.fetch("stargazers_count")
puts "Ruby has #{_} stars"
```

It would *substantially* complicate parsing (one would only want to "assign" `_` if an expression *uses* it), and right now `_` is a valid variable name (if usually used for an unused parameter).

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

* 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/