[ruby-core:112391] [Ruby master Feature#19432] Introduce a wrapping operator (&) to Proc

13 Feb 2023

      Issue #19432 has been updated by nobu (Nobuyoshi Nakada).

Status changed from Open to Feedback

Your first example seems unnecessary complicated.

```ruby
def text(s)
  "<text>#{s}</text>"
end
def strong(s)
  "<strong>#{s}</strong>"
end
def em(s)
  "<em>#{s}</em>"
end

def markup(s, *marks)
  result = -> { text s }

  marks.each do |mark|
    case mark
    when "bold"
      result >>= ->(s) { strong(s) }
    when "italic"
      result >>= method(:em)
    end
  end
  result.call
end

puts markup(*ARGV)
```

```shell-session
$ ruby feature-19432.rb test
<text>test</text>

$ ruby feature-19432.rb test bold
<strong><text>test</text></strong>

$ ruby feature-19432.rb test italic
<em><text>test</text></em>

$ ruby feature-19432.rb test bold italic
<em><strong><text>test</text></strong></em>

$ ruby feature-19432.rb test italic bold
<strong><em><text>test</text></em></strong>
```

Anyway, I can't get the reason `Proc#<<` and `Proc#>>` are not enough.

----------------------------------------
Feature #19432: Introduce a wrapping operator (&) to Proc
https://bugs.ruby-lang.org/issues/19432#change-101833

* Author: joel@drapper.me (Joel Drapper)
* Status: Feedback
* Priority: Normal
----------------------------------------
I don't know if this concept exists under another name, or whether there’s a technical term for it. I often find myself wanting to wrap a proc in another proc.

Here's a snippet from a recent example where a visitor class renders a TipTap AST. Given a `text` node, we want to output the text by calling the `text` method with the value. But if the text has `marks`, we want to iterate through each mark, wrapping the output for each mark. It's possible to do this using the `>>=` operator if each proc explicitly returns another proc.

```ruby
when "text"
  result = -> { -> { text node["text"] } }

  node["marks"]&.each do |mark|
    case mark["type"]
    when "bold"
      result >>= -> (r) { -> { strong { r.call } } }
    when "italic"
      result >>= -> (r) { -> { em { r.call } } }
    end
  end

  result.call.call
end
```

This is quite difficult to follow and the `result.call.call` feels wrong. I think the concept of wrapping one proc in another proc would make for a great addition to `Proc` itself. I prototyped this using the `&` operator.

```ruby
class Proc
  def &(other)
    -> { other.call(self) }
  end
end
```

With this definition, we can call `&` on the original proc with our other proc to return a new proc that calls the other proc with the original proc as an argument. It also works with `&=`, so the above code can be refactored to this:

```ruby
when "text"
  result = -> { text node["text"] }

  node["marks"]&.each do |mark|
    case mark["type"]
    when "bold"
      result &= -> (r) { strong { r.call } }
    when "italic"
      result &= -> (r) { em { r.call } }
    end
  end

  result.call
end
```

-- 
https://bugs.ruby-lang.org/