[ruby-core:86368] [Ruby trunk Feature#14392] Pipe operator

Issue #14392 has been updated by bughit (bug hit).


this important feature discussion has been derailed by a bad description/justification

the purpose of the pipe operator is to enable sane, readable, functional chaining.  Controlling method visibility through it is not worth even mentioning.

it's fairly self evident that

`fn1 |> fn2 |> fn3 |> fn4 |> fn5`

is superior to

`fn5(fn4(fn3(fn2(fn1()))))`

the longer the chain the more so

This would not be a casual drop in for ruby, as it needs some sort of partial application syntax (using <> here), something like this

`value |> method_or_proc<1, 2>`

`method_or_proc<1, 2>` would produce (pseudocode since proc invocation uses different syntax) `->arg{method_or_proc(arg, 1, 2)}`

`method_or_proc<1, 2, _>` would produce `->arg{method_or_proc(1, 2, arg)}`

you could get fancier

`method_or_proc<1, *, 2>` => `->*args{method_or_proc(1, *args, 2)}`

there's little doubt that this feature would make functional style a lot more pleasant in ruby


----------------------------------------
Feature #14392: Pipe operator
https://bugs.ruby-lang.org/issues/14392#change-71295

* Author: dsferreira (Daniel Ferreira)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I would like to see implemented in ruby a pipe operator as we have in elixir.

An example of application I have in mind is this:

```ruby
class Foo

  def bar(var)
    puts “Hello #{var}!”
  end |> private
  
  def baz(arg)
    bar(arg)
  end 
 
end

foo = Foo.new
foo.baz("Fred") # => "Hello Fred!"
```

It can also help simplify method chains:

```ruby
class Secret

  def initialise(user, password)
    @user = user
    @password = password
  end

  def second_pass(encrypted_string)
    encrypted_string.chain_4.chain_5.chain_6
  end |> private

  ##
  #  Super encryption

  def super_encryption
    @password.chain_1.chain_2.chain_3
      |> second_pass
  end |> public

end
```

And also simplify codes like this:

```ruby
class Foo

  def bar(*args)
    baz = args.select { |arg| arg =~ /regex/ }.first
    good?(baz)
  end

  public :bar

  def good(arg)
    arg.to_s.size > 10
  end
  
  private :good

end
```

to become:

```ruby
class Foo

  ##
  # Bar public method.

  def bar(*args)
    args.select { |arg| arg =~ /regex/ }.first
      |> good?
  end |> public

  def good(arg)
    arg.to_s.size > 10
  end |> private

end
```

Lots of local variables would be saved and I would expect some performance improvements with that.



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>