[ruby-core:90590] [Ruby trunk Feature#15301] Symbol#call, returning method bound with arguments

Issue #15301 has been updated by shuber (Sean Huber).


@zverok wrote:
> I don't believe it is possible at all (both from the technical and organizational points of view).

Ah ok bummer if true! Can you please clarify what you meant by `organizational` above?

Note to future self (or other interested parties) - poke around `compile.c`, `parse.y`, `node.c`, and `node.h` to see what something like this would take.

> If you do, probably you should create another ticket, not turning this one, pretty short and focused on _one particular proposal_ into the "who could invent 10 new syntaxes in one comment" challenge.

Lol just trying to suggest some alternatives since Matz doesn't seem to be into the `Symbol#call` suggestion. I do very much like this shorthand concept of applying arguments to blocks/procs like you're proposing and I hope we get to see some implementation of it. Thank you for your feedback!

----------------------------------------
Feature #15301: Symbol#call, returning method bound with arguments
https://bugs.ruby-lang.org/issues/15301#change-75744

* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
In one Reddit discussion I've got stuck with this simple, yet seemingly powerful idea, not sure if it was discussed anytime previously (can't find on the bug tracker, but maybe I am just bad at searching):

```ruby
class Symbol
  def call(*args, &block)
    proc { |x| x.send(self, *args, &block) }
  end
end

[10, 20, 30].map &:modulo.(3) # => [1, 2, 0]
[[1, -2], [-3, -4]].map(&:map.(&:abs)) # => [[1, 2], [3, 4]]
[1, 2, 3, 4].map &:**.(2) # => [1, 4, 9, 16]
```

I understand and respect core team's reluctance for adding new methods to core classes, but from the top of my head I can't invent _incredibly_ bad consequences (there, of course, could be some codebases that defined their own `Symbol#call` in a different way, but I don't estimate the probability as super-high; and the same could be said almost for any new method).

On the other hand, resulting code seems pretty nice, "Rubyish", explainable and mostly unambiguous. 

Would like to hear other's opinions.

PS: One obvious objection could be that it is almost a de-facto standard to have any object's `#to_proc` to return proc doing exactly the same what the `#call` does (if the object happen to have both). It is unfortunate, but I believe the people will use to it, considering the possible gains. And, anyway, that's only "de-facto" rule, not the language standard :) 



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

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>