Port remaining facets methods that use functor.

Author: trans

lib/functor/array/recursively.rb

@@ -0,0 +1,53 @@
+require 'functor'
+require 'functor/enumerable/recursively'
+
+class Array
+
+  # Apply a method to array, and recursively apply that method
+  # to each sub-array or given +types+.
+  #
+  # By default the sub-types are passed thru uneffected. Passing
+  # a block to #recursively can be used to change this.
+  #
+  # types - List of class types to recurse. [Array<Class>]
+  # block - Optional filter procedure to apply on each recursion. 
+  #
+  # Examples
+  #
+  #   arr = ["a", ["b", "c"]]
+  #   arr.recursively.map{ |v| v.to_sym }
+  #   #=> [:a, [:b, :c]]
+  #
+  #   arr = ["a", ["b", "c"]]
+  #   arr.recursively{ |a| a.reverse }.map{ |v| v.to_sym }
+  #   #=> [:a, [:c, :b]]
+  #
+  # Returns [Recursor].
+
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  ## TODO: When no longer needing to support 1.8.6 we could get rid of
+  ## the Recursor class and use:
+  ##
+  ## def recursively(*types, &block)
+  ##   types = types.empty? ? [self.class] : types
+  ##   Functor.new do |op, &yld|
+  ##     rec = block || lambda{ |a| a }
+  ##     yld = yld   || lambda{ |v| v }  # ? to_enum
+  ##     __send__(op) do |v|
+  ##       case v
+  ##       when String # b/c of 1.8
+  ##         yld.call(v)
+  ##       when *types
+  ##         res = v.recursively(*types, &block).__send__(op,&yld)
+  ##         rec.call(res)
+  ##       else
+  ##         yld.call(v)
+  ##       end
+  ##     end
+  ##   end
+  ## end
+
+end

lib/functor/enumerable/apply.rb

@@ -0,0 +1,19 @@
+require 'functor/enumerable/per'
+
+module Enumerable
+
+  # Returns an elemental object. This allows
+  # you to map a method on to every element.
+  #
+  #   r = [1,2,3].apply.+ 
+  #   r  #=> 6
+  #
+  def apply
+    #Functor.new do |sym, *args, &blk|
+    #  inject{ |r, e| r.__send__(sym, e, *args, &blk) }
+    #end
+    per(:inject)
+  end
+
+end
+

lib/functor/enumerable/recursively.rb

@@ -0,0 +1,66 @@
+module Enumerable
+
+  # Returns a recursive functor, that allows enumerable methods to iterate
+  # through enumerable sub-elements. By default it only recurses over
+  # elements of the same type.
+  #
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  # Recursor is a specialized Functor for recurively iterating over Enumerables.
+  #
+  # TODO: Return Enumerator if no +yld+ block is given.
+  #
+  # TODO: Add limiting +depth+ option to Enumerable#recursively?
+  #
+  class Recursor
+    instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
+
+    def initialize(enum, *types, &block)
+      @enum   = enum
+      @types  = types.empty? ? [@enum.class] : types
+      @block  = block
+    end
+
+    def method_missing(op, &yld)
+      rec = @block || lambda{ |v| v }
+      yld = yld    || lambda{ |v| v }  # ? to_enum
+      @enum.__send__(op) do |v|
+        case v
+        when String # b/c of 1.8
+          yld.call(v)
+        when *@types
+          res = v.recursively(*@types, &@block).__send__(op,&yld)
+          rec.call(res)
+        else
+          yld.call(v)
+        end
+      end
+    end
+  end
+
+  ## TODO: When no longer needing to support 1.8.6 we could get rid of
+  ## the Recursor class and use:
+  ## #
+  ## def recursively(*types, &block)
+  ##   types = types.empty? ? [self.class] : types
+  ##   Functor.new do |op, &yld|
+  ##     rec = block || lambda{ |v| v }
+  ##     yld = yld   || lambda{ |v| v }  # ? to_enum
+  ##     __send__(op) do |v|
+  ##       case v
+  ##       when String # b/c of 1.8
+  ##         yld.call(v)
+  ##       when *types
+  ##         res = v.recursively(*types, &block).__send__(op,&yld)
+  ##         rec.call(res)
+  ##       else
+  ##         yld.call(v)
+  ##       end
+  ##     end
+  ##   end
+  ## end
+
+end
+

lib/functor/extensions.rb

@@ -1,25 +1,38 @@
 require 'functor'
 
+require 'functor/array/recursively'
+
 require 'functor/enumerable/accrue'
 require 'functor/enumerable/accumulate'
 require 'functor/enumerable/all'
 require 'functor/enumerable/any'
+require 'functor/enumerable/apply'
 require 'functor/enumerable/every'
 require 'functor/enumerable/ewise'
 require 'functor/enumerable/having'
 require 'functor/enumerable/in_order_of'
 require 'functor/enumerable/per'
+require 'functor/enumerable/recursively'
 require 'functor/enumerable/where'
 
 require 'functor/enumerator/fx'
 
 require 'functor/hash/data'
+require 'functor/hash/recursively'
 
 require 'functor/kernel/as'
 require 'functor/kernel/as_new'
 require 'functor/kernel/eigen'
+require 'functor/kernel/ergo'
+require 'functor/kernel/meta'
 require 'functor/kernel/not'
 require 'functor/kernel/respond'
+require 'functor/kernel/tap'
+require 'functor/kernel/try'
+
+require 'functor/module/method_space'
+
+require 'functor/object/against'
 
 require 'functor/object_space/reflect'
 
@@ -28,3 +41,5 @@
 
 require 'functor/symbol/as_s'
 
+
+

lib/functor/hash/recursively.rb

@@ -0,0 +1,61 @@
+require 'functor'
+require 'functor/enumerable/recursively'
+
+class Hash
+
+  # Apply a block to a hash, and recursively apply that block
+  # to each sub-hash:
+  #
+  #     h = {:a=>1, :b=>{:x=>1, :y=>2}}
+  #     h.recursively.map{ |k,v| [k.to_s, v] }
+  #     #=> [["a", 1], ["b", [["y", 2], ["x", 1]]]]
+  #
+  # The recursive iteration can be treated separately from the non-recursive
+  # iteration by passing a block to the #recursive method:
+  #
+  #     h = {:a=>1, :b=>{:x=>1, :y=>2}}
+  #     h.recursively{ |k,v| [k.to_s, v] }.map{ |k,v| [k.to_s, v.to_s] }
+  #     #=> [["a", "1"], ["b", [["y", "2"], ["x", "1"]]]]
+  #
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  class Recursor < Enumerable::Recursor #:nodoc:
+    def method_missing(op, &yld)
+      yld = yld    || lambda{ |k,v| [k,v] }  # ? to_enum
+      rec = @block || yld #lambda{ |k,v| [k,v] }
+      @enum.__send__(op) do |k,v|
+        case v
+        when String # b/c of 1.8
+          yld.call(k,v)
+        when *@types
+          res = v.recursively(*@types, &@block).__send__(op,&yld)
+          rec.call(k, res)
+        else
+          yld.call(k,v)
+        end
+      end
+    end
+  end
+
+## TODO: When no longer need 1.8.6 support.
+=begin
+  def recursively(*types, &block)
+    types = types.empty? ? [self.class] : types
+    Functor.new do |op, &yld|
+      rec = block || yld
+      __send__(op) do |k,v|
+        case v
+        when *types
+          rec.call(k, v.recursively(*types, &block).__send__(op,&yld))
+        else
+          yld.call(k,v)
+        end
+      end
+    end
+  end
+=end
+
+end
+

lib/functor/kernel/ergo.rb

@@ -0,0 +1,44 @@
+require 'functor'
+
+module Kernel
+
+  # Yield self -or- return self.
+  #
+  #   "a".ergo.upcase #=> "A"
+  #   nil.ergo.foobar #=> nil
+  #
+  #   "a".ergo{ |o| o.upcase } #=> "A"
+  #   nil.ergo{ |o| o.foobar } #=> nil
+  #
+  # This is like #tap, but #tap yields self and returns self,
+  # where as #ergo yields self but returns the result.
+  #
+  # CREDIT: Daniel DeLorme
+
+  def ergo(&b)
+    if block_given?
+      b.arity == 1 ? yield(self) : instance_eval(&b)
+    else
+      self
+    end
+  end
+
+end
+
+class NilClass
+
+  FUNCTOR = Functor.new{ nil }
+  
+  # Compliments Kernel#ergo.
+  #
+  #   "a".ergo{ |o| o.upcase } #=> "A"
+  #   nil.ergo{ |o| o.bar }    #=> nil
+  #
+  # CREDIT: Daniel DeLorme
+
+  def ergo
+    FUNCTOR unless block_given?
+  end
+
+end
+

lib/functor/kernel/meta.rb

@@ -0,0 +1,33 @@
+require 'functor'
+
+module Kernel
+
+  # Call methods on the eigenclass (i.e. the singleton_class).
+  #
+  #     name = "Tom"
+  #     name.eigen.define_method(:turkey){ self + " Turkey" }
+  #     name.turkey #=> "Tom Turkey"
+  #
+  # One of the nice things you can do with #eigen is define class attributes
+  # without having to open a `class << self` block.
+  #
+  #     c = Class.new do
+  #       meta.attr_accessor :a
+  #     end
+  #     c.a = 1
+  #     c.a #=> 1
+  #
+  def meta
+    Functor.new do |op,*a,&b|
+      (class << self; self; end).class_eval do
+        __send__(op,*a,&b)
+      end
+    end
+  end
+
+  def eigen
+    warn "The `eigen' method is deprecated. Please use `meta' instead."
+    meta
+  end
+
+end

lib/functor/kernel/tap.rb

@@ -0,0 +1,36 @@
+require 'functor'
+
+module Kernel
+
+  # The tap K-Combinator. This yields self -and- returns self.
+  #
+  #   'foo.yml'.tap{ |f| YAML.load(f) }  #=> 'foo.yml'
+  #
+  # Unlike Ruby's definition, this rendition can be used as a higher
+  # order message. This form allows a single call before returning
+  # the receiver.
+  #
+  #   YAML.tap.load_file('foo.yml').load_file('bar.yml')
+  #
+  # IMPORTANT: This is a core override!
+
+  def tap #:yield:
+    if block_given?
+      yield(self)
+      self
+    else
+      Functor.new{ |op,*a,&b| self.send(op, *a, &b); self }
+    end
+  end
+
+  # Old Definition:
+  #
+  #   def tap #:yield:
+  #     if block_given?
+  #       b.arity == 1 ? yield(self) : instance_eval(&b)
+  #     end
+  #     return self
+  #   end
+  #
+
+end