From: danieldasilvaferreira@...
Date: 2018-01-25T07:07:20+00:00
Subject: [ruby-core:85099] [Ruby trunk Feature#14392] Pipe operator

Issue #14392 has been updated by dsferreira (Daniel Ferreira).


 shyouhei (Shyouhei Urabe) wrote:

> Is it really worth adding a new syntax to replace private def... ?

For me it is Shyouhei. 
Like I said before, I care a lot about the visibility of my methods. 
The clear definition of each interface and its preservation over time it is a top concern in my architectural work.
The interface integrity is this way guaranteed by a strict rule deeming that every method has its own access modifier set.
This applies to `public`, `protected` and `private`.
Naming is hard and very important and the API resembles that. It is sweat printed in. (Just to try to express my emotions about this)

We are talking about hundreds to not say thousands of method name duplications that I have in my code base currently.
I don't mind having the extra work but I'm not everybody.

Now, why do I require the visibility being set after the method definition?
Because I order my methods alphabetically and I don't want to order them by visibility.
By using: `"private def ..."` alphabetical order based on method name makes little sense to my mind.

I code ruby because of its elegance and fluidity so I always strive to write code that makes sense to my eyes.

The proposal of the pipe operator makes perfect sense to me because it resembles my bash memories and it comes as natural as a no brainer.



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

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