[ruby-core:61387] [ruby-trunk - Feature #9552] Module map!

Issue #9552 has been updated by Boris Stitnicky.


I apologize for the late response. Again, I experienced that the method I'm proposing here has much practical use in my code. As for a better name, I can think of:

`#compose`  --- weight: 3  -- as in functional composition
`#apply`    --- weight: 1  -- as in functional application
`#chain`    --- weight: 4  -- as in method chaining

`#compose` is perhaps the most politically correct. While `#apply` is not theoretically incorrect, the word too generic (much like `using`) and overloads the metalanguage (English speaking about Ruby) too much. From these newly made up options, I personally prefer `#chain`, which is sufficiently rare, expressive, and short to boot. I will be renaming `Module#map!` to `Module#chain` in my personal library, too -- thank you for forcing me to think.

----------------------------------------
Feature #9552: Module map!
https://bugs.ruby-lang.org/issues/9552#change-45698

* Author: Boris Stitnicky
* Status: Feedback
* Priority: Normal
* Assignee: 
* Category: 
* Target version: 
----------------------------------------
I would like to beg for `map!` directive in `Module`. I can imitate it with this code:

```ruby
class Module
  def map! **hash, &block
    hash.each_pair { |mapped_method_symbol, original_method_symbol|
      define_method mapped_method_symbol do |*args, &b|
        block.( send original_method_symbol, *args, &b )
      end
    }
  end
end
```

And then

```ruby
class Foo; attr_accessor :name end
class Bar; attr_accessor :name end
class Baz; attr_accessor :name end

class FooBarBazCollection < Array
  def foos; select { |e| e.is_a? Place } end
  def bars; select { |e| e.is_a? Transition } end
  def bazs; select { |e| e.is_a? Arc } end
  map! fn: :foos, barn: :bars, bazn: :bazs do |retval| retval.map &:name end
end
```

I solemnly declare that I have encountered this pattern in my work on Petri net gem sufficiently many times to warrant this meta approach. The above method `#map!` is not perfect, because it makes the "mapped" methods more omnivorous -- accepting even such sets of arguments, for which the originals returned `ArgumentError`. I do not know how to solve this without asking for a core-level solution.



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