# Enumerable#every, the Functor and Ruby support for HOM

**URL:** <https://www.ruby-forum.com/t/enumerable-every-the-functor-and-ruby-support-for-hom/220689>\
**Category:** Ruby\
**Created:** [June 17, 2012, 12:48am UTC](https://www.ruby-forum.com/t/enumerable-every-the-functor-and-ruby-support-for-hom/220689 "2012-06-17T00:48:24Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![aris](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/a/258eb7/32.png) [@aris](https://www.ruby-forum.com/u/aris)\
**Post date:** [June 17, 2012, 12:48am UTC](https://www.ruby-forum.com/t/enumerable-every-the-functor-and-ruby-support-for-hom/220689/1 "2012-06-17T00:48:24Z")

</div>

Have you heard of `Enumerable#every`? It lets you apply a method call to  
all elements of an enumerable. Check it out…

[1,2,3].every + 3 #=\> [4,5,6]

[1,2,3].every \* 3 #=\> [3,6,9]

words = [“hello”, “world”]  
words.every.upcase!  
words #=\> [“HELLO”, “WORLD”]

Essentially every is a convenient and nicely readable “fluent notation”  
alternative to using a map/collect block.

Now you might be wondering how this bit of magic is achieved? Here is  
the  
definition.

```
module Enumerable
   def every
      Functor.new do |op,*args|
        map{ |a| a.send(op,*args) }
      end
   end
end

```

As you can see it works via something called a “Functor”. Generally  
speaking, a “functor” is simply an object that encapsulates a function.  
In  
this case I have used the term as a concise reference to a specialized  
form  
of such to achieve [Higher Order  
Messaging](http://en.wikipedia.org/wiki/Higher_order_message). The basic definition of this class is:

class Functor  
def initialize(&function)  
@function = function  
end  
def method\_missing(op, \*args, &blk)  
@function.call(op, \*args, &blk)  
end  
end

This Functor class can be used in many many ways. Enumerable#every is  
just  
one of many examples. In fact, Ruby’s own Enumerator class is actually  
just  
a highly specialized type of Functor.

As useful as a Functor can be, it does however have two downsides. First  
it  
depends on #method\_missing. This means public Object methods  
can interfere with its usefulness. This can be worked around by making  
Functor a subclass of BasicObject. Though a few public methods remain,  
this  
is good enough for all practical purposes. A more problematic issue is  
the  
fact that it requires the creation of an indeterminate object every time  
the a method using a Functor is called. This is pretty inefficient,  
slows  
things down and requires us to be memory conscious. Caching can be used  
in  
some cases, but rarely is it an ideal fix.

Recently I came up with an idea that would allow these issues to be  
circumvented entirely. I realized that since this is a higher order  
_message_, then really it would be best handled as a messaging issue  
–hence via the definition of a “higher order method”. In other words if  
Ruby had built-in support for the concept, the intermediate object would  
not be necessary and consequently interfering public methods would not  
exist. To facilitate this, I came up with a potential notation. Here’s  
how  
it would be used to define Enumerable#every:

```
module Enumerable
  def every => op, *args
    map{ |a| a.send(op,*args) }
  end
end

```

(Hmm… as I typed this it occurs to me that maybe `=>` would be more  
intuitive if it pointed the other way using `<=`.) Regardless of the  
actual  
notation used, the idea is to allow Ruby to handle higher-order-messages  
internally as a special type of method.

For reference here are a few other examples of using Functor:  
\*

> <https://github.com/rubyworks/facets/blob/main/lib/core/facets/string/file.rb>

\*

> <https://github.com/rubyworks/facets/blob/main/lib/core/facets/kernel/ergo.rb>

\*

> <https://github.com/rubyworks/facets/blob/main/lib/core/facets/kernel/not.rb>

P.S. There is also a functor gem out there, but it is not the Functor as  
defined above. The functor gem came along well after the one described  
here  
(which is included with Ruby F.s). The gems’s implementation is  
basically a kind of struct that supports multiple dispatch capabilities.  
The above is much more generic and actually can even be used to create  
the  
functor gem’s more specialized kind with just a bit of extra code.
