Feature #14392
Updated by dsferreira (Daniel Ferreira) almost 8 years ago
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 do { |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.