Project

General

Profile

Feature #14392

Updated by dsferreira (Daniel Ferreira) almost 4 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.

Back