From: joel@...
Date: 2018-02-20T19:08:08+00:00
Subject: [ruby-core:85700] [Ruby trunk Feature#14392] Pipe operator

Issue #14392 has been updated by joelvh (Joel Van Horn).


Hanmac (Hans Mackowiak) wrote:
> Symbol#pri and others will never work because you failed to understand how Object work in ruby
> 
> so NO "easily do by extending Symbol class"
> 
> ----
> 
> there is also using them as modifier for the class scope
> 
> ~~~ruby
> class Foo
> 
> private
>   def bar
>   end
> 
> protected
>   def foo
>   end
> 
> public
>   def foobar
>   end
> end
> ~~~

Daniel,

I'm just curious... does the modifier in the class scope work for you as Hans mentioned, or is it really overall piping syntax that you want for more than just scoping methods? You can use that modifier before each method you define, and it doesn't have to be out-dented if that makes it appear like you're sectioning off your class methods.


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

* 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:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>