From: danieldasilvaferreira@...
Date: 2018-01-24T14:59:14+00:00
Subject: [ruby-core:85055] [Ruby trunk Feature#14392] Pipe operator

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


 Hanmac (Hans Mackowiak) wrote:

> `private def bar(var)`

I don't like the syntax it provides.

What I do currently is:

```
class Foo

  def bar(var)
    puts ���Hello #{var}!���
  end

  private :bar

  def baz(arg)
    bar(arg)
  end

  public :baz

end
```

Looking forward for a solution to reduce the impact of that declaration.
(In my libraries I want the declaration of the access modifier for every method in every class and every module with proper documentation in place to understand what is the visibility of each method at all times.)

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

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