operator :together for Proc objects

Author: avorozhtsov

README

@@ -35,10 +35,10 @@ records [word, frequency] he should run
 One can make calculations lazy just by converting container to lazy one:
    records.to_lazy. ...
 
-Lazy container allows to dramatically reduce memory usage when 
+LazyEnumerable allows to dramatically reduce memory usage when
 using piped transfromations: map, select, uniq, pipe, and reduce.
 
-The only problem is method +sort+, which requires all records to be 
+The only problem is the method +sort+, which requires all records to be
 loaded to memory. But one can use any scalable external sort:
 
   cat records.txt | \ 

lib/core_ext.rb

@@ -1,5 +1,6 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'meta_ext'
+require 'proc_ext'
 require 'hash_ext'
 

lib/meta_ext.rb

@@ -14,11 +14,6 @@ def extract_options(args)
   end
 end
 
-class Proc
-  # This alias make it possible use blocks as virtual input streams or arrays. 
-  alias :<< :call
-end
-
 class Symbol
   unless public_method_defined? :to_proc
     def to_proc

lib/proc_ext.rb

@@ -0,0 +1,117 @@
+class Proc
+  alias << call
+
+  class MultipleValue < Array
+    def initialize(*args)
+      args.each_with_index{|e,i| self[i] = e}
+    end
+    def each_with_recursion(&block)
+      each_without_recursion do |e|
+        if e.is_a?(MultipleValue)
+          e.each(&block)
+        else
+          block[e]
+        end
+      end
+    end
+    alias each_without_recursion each
+    alias each each_with_recursion
+  end
+ 
+  attr_accessor :together_blocks
+  # protected :together_blocks, :together_blocks=
+
+  def together(other)
+    block = Proc.new do |reduced_value, e|
+      reduced_value = MV( *([reduced_value]*block.together_blocks.size) ) unless reduced_value.is_a?(MultipleValue)
+      i = -1
+      reduced_value.map!{|rv|
+        block.together_blocks[i+=1][rv, e] 
+      } 
+    end
+    block.together_blocks = (self.together_blocks || [self]) + (other.together_blocks || [other])
+    block
+  end
+  alias + together 
+end
+
+def MV(*args)
+  Proc::MultipleValue.new(*args)
+end
+
+class Symbol
+  unless public_method_defined? :to_proc
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  class TestProcExt < Test::Unit::TestCase
+    def test_reducers_sum
+    
+      b = :+.to_proc + :*.to_proc
+
+      assert_equal(
+        [15, 120],
+        [1,2,3,4,5].inject(&b)
+      )
+
+      assert_equal(
+        [17, 240],
+        [1,2,3,4,5].inject(2, &b)
+      )
+
+      assert_equal(
+        [17, 1200],
+        [1,2,3,4,5].inject( MV(2,10),  &b )
+      )
+      
+      c = :+.to_proc + :+.to_proc + :+.to_proc
+      assert_equal(
+        [15, 16, 17],
+        [1,2,3,4,5].inject( MV(0,1,2),  &c ).to_a
+      )
+    end
+
+    def test_abc
+      a = :+.to_proc
+      b = a + :*.to_proc
+      d = lambda{|x,y| [x,y].min}
+      c = b + d
+      e = d + b
+      assert_equal(
+        6,  
+        [1,2,3].inject(&a)
+      )
+
+      assert_equal(
+        1,  
+        [4,3,1,4,5].inject(&d)
+      )
+    
+      assert_equal(
+        [10, 30],
+        [2,3,5].inject(&b)
+      )
+      
+      assert(
+        3,
+        c.send(:together_blocks).size
+      )
+
+      assert_equal(
+        [10, 30, 2],
+        [3,2,5].inject(&c)
+      )
+
+      assert_equal(
+        [2, 10, 30],
+        [3,2,5].inject(&e)
+      )
+    end
+  end
+end
+