From: "prijutme4ty (Ilya Vorontsov)" <prijutme4ty@...>
Date: 2012-06-30T06:22:12+09:00
Subject: [ruby-core:45972] [ruby-trunk - Feature #6594] Integrated Functor


Issue #6594 has been updated by prijutme4ty (Ilya Vorontsov).


trans (Thomas Sawyer) wrote:
> @prijutme4ty Your link appears to be broken, but I am glad to see your interest on HOM. I would need to know more about your callable symbols idea to know if it is HOM like Functor. My impression from your example is that it might be a type of call recorder (akin to a Spy).
> 
> I am surprised that you think Functor seems complex, when basic model is simply:
> 
>   class Functor
>     def initialize(&function)
>       @function = function
>     end
>     def method_missing(op, *args, &blk)
>       @function.call(op, *args, &block)
>     end
>   end
> 
> For one example, probably the first I ever made, is #every. I wrote about it at https://groups.google.com/forum/?fromgroups#!topic/ruby-talk-google/zW_IDKq754A

Sorry for a long delay with my reply. Here's a correct link to my code https://github.com/prijutme4ty/bioinform/blob/master/lib/bioinform/support/callable_symbol.rb

Yes, my code is chain recorder in some sense. But really all examples of use functor are just the same simple one-line method replacement. My approach to this #every method looks like 
[1,2,3].map &:+.(3)  #=> [4,5,6]
[1,2,3].map &:*.(3)  #=> [3,6,9]
and you can see, I don't create any additional like #every, I just use already existing methods.

Example with upcase can be easily written in core ruby
words = ["hello", "world"]
words.each &:upcase! # or words.map &:upcase
words  #=> ["HELLO", "WORLD"]


Can you give an example where creating Functor object really makes things easier. I understand that concept can be really very powerful, but not in such simple examples.
I've called Functor complex only because calling #send method always looks like a trick. I think that only libraries should use methods like #send and other metaprogramming techniques, but programmer as long as possible should stay away from using metaprogramming. What to me, methods like #every can be defined in a gem (but not in "user-code", so this shouldn't be such a usual task) so introducing new syntax is overkill unless you provide really fine cases where functor can be used in "user-code" (not for only a dozen of methods like #every).
----------------------------------------
Feature #6594: Integrated Functor
https://bugs.ruby-lang.org/issues/6594#change-27577

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: 2.0.0


=begin
I know the developers meeting is coming up so I'd like to get a few ideas I've had sitting in the wings out in the air before then.

One the more useful is the idea of integrating Functors directly into the language. "Functor" is the term I use for "higher-order function".

I blogged about this idea and you can read it here: http://trans.github.com/2011-09-07-ruby-heart-higher-order-functions/

The super short version is this:

  def f => op, arg
    arg.send(__op__, arg)
  end

  f + 3  #=> 6
  f * 3  #=> 9

Another example:

  class String
    def file => op, *args
      File.send(__op__, self, *args)
    end
  end

  "README.rdoc".file.mtime  #=> 2012-06-14 12:34:45 -0400

I'm using `=>` as means of indicating a higher-order function. Of course another syntax could be used if this won't fly. The important thing is the idea of higher-order functions being integrated directly into the language. Doing this without that integration requires the creation of an intermediate object for each call which is very inefficient.
=end



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