From: danieldasilvaferreira@...
Date: 2018-01-24T16:24:12+00:00
Subject: [ruby-core:85063] [Ruby trunk Feature#14392] Pipe operator

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


zverok (Victor Shepelev) wrote:

> That's the way, obviously.

Fortunately not every one look at things the same way, and I believe ruby core allows us to come in and discuss matters.
This is an important matter to me.
I know not many people looks at it the way I do but still it is my view and my requirement.

In my code I like to organise the methods in alphabetical order and not by public, protected, private hierarchy.

The reason why I do that?

Because that simplifies a bunch of things. It may be the way my mind works.
It doesn't mean I'm not able to work with the code format that is out there in the wild to see.
Code like mine I never saw.
But I do it like that because I consider it the best way.

This type of code:

```ruby
class Foo

  private def bar
  end
  
  ##
  # Baz public method.

  public def baz
  end

end
```

hurts my eyes. So the best I can achieve right now is:

```ruby
class Foo

  def bar
  end
  
  private :bar

  ##
  # Baz public method.

  def baz
  end

  public :baz

end
```

Which is fine but not ideal and I aim for the ideal.

It will be reject anyways but I will still continue to seek for a better option.

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

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