[ruby-core:85102] [Ruby trunk Feature#14392] Pipe operator

Issue #14392 has been updated by shyouhei (Shyouhei Urabe).


dsferreira (Daniel Ferreira) wrote:
> 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.

To be clear I am not against specifying method visibility.

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

Don't you have difficulties writing elixir code then?  They, too, don't take visibilities at the last.

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

If you prefer sound visibility specifiers rather than implicit ones, I think that a visibility of a method shall be placed somewhere near the method name.  By placing private after the end of a method body, that specifier should become too hard to find out the corres[onding method name.  To me, def ... end |> private seems far less "fluent" than private def ...

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

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