functional-ruby 0.7.1 → 0.7.2

data/lib/functional/behaviour.rb

@@ -1,2 +1,2 @@
-# Support the Scandinavian spelling
-require_relative 'behavior'
+# Support the Scandinavian spelling
+require_relative 'behavior'

data/lib/functional/pattern_matching.rb

@@ -1,133 +1,133 @@
-module PatternMatching
-
-  UNBOUND = Class.new
-  ALL = Class.new
-
-  private
-
-  GUARD_CLAUSE = Class.new do # :nodoc:
-    def initialize(func, clazz, matcher) # :nodoc:
-      @func = func
-      @clazz = clazz
-      @matcher = matcher
-    end
-    def when(&block) # :nodoc:
-      unless block_given?
-        raise ArgumentError.new("block missing for `when` guard on function `#{@func}` of class #{@clazz}")
-      end
-      @matcher[@matcher.length-1] = block
-      return nil
-    end
-  end
-
-  def self.__match_pattern__(args, pattern) # :nodoc:
-    return unless (pattern.last == ALL && args.length >= pattern.length) \
-      || (args.length == pattern.length)
-    pattern.each_with_index do |p, i|
-      break if p == ALL && i+1 == pattern.length
-      arg = args[i]
-      next if p.is_a?(Class) && arg.is_a?(p)
-      if p.is_a?(Hash) && arg.is_a?(Hash) && ! p.empty?
-        p.each do |key, value|
-          return false unless arg.has_key?(key)
-          next if value == UNBOUND
-          return false unless arg[key] == value
-        end
-        next
-      end
-      return false unless p == UNBOUND || p == arg
-    end
-    return true
-  end
-
-  def self.__unbound_args__(match, args) # :nodoc:
-    argv = []
-    match.first.each_with_index do |p, i|
-      if p == ALL && i == match.first.length-1
-        argv << args[(i..args.length)].reduce([]){|memo, arg| memo << arg }
-      elsif p.is_a?(Hash) && p.values.include?(UNBOUND)
-        p.each do |key, value|
-          argv << args[i][key] if value == UNBOUND
-        end
-      elsif p.is_a?(Hash) || p == UNBOUND || p.is_a?(Class)
-        argv << args[i] 
-      end
-    end
-    return argv
-  end
-
-  def self.__pattern_match__(clazz, func, *args, &block) # :nodoc:
-    args = args.first
-
-    matchers = clazz.__function_pattern_matches__[func]
-    return [:nodef, nil] if matchers.nil?
-
-    match = matchers.detect do |matcher|
-      if PatternMatching.__match_pattern__(args, matcher.first)
-        if matcher.last.nil?
-          true # no guard clause
-        else
-          self.instance_exec(*PatternMatching.__unbound_args__(matcher, args), &matcher.last)
-        end
-      end
-    end
-
-    return (match ? [:ok, match] : [:nomatch, nil])
-  end
-
-  protected
-
-  def self.included(base)
-
-    class << base
-
-      public
-
-      def _() # :nodoc:
-        return UNBOUND
-      end
-
-      def defn(func, *args, &block)
-        unless block_given?
-          raise ArgumentError.new("block missing for definition of function `#{func}` on class #{self}")
-        end
-
-        pattern = __add_pattern_for__(func, *args, &block)
-
-        unless self.instance_methods(false).include?(func)
-
-          define_method(func) do |*args, &block|
-            result, match = PatternMatching.__pattern_match__(self.method(func).owner, func, args, block)
-            if result == :ok
-              # if a match is found call the block
-              argv = PatternMatching.__unbound_args__(match, args)
-              return self.instance_exec(*argv, &match[1])
-            else # if result == :nodef || result == :nomatch
-              begin
-                super(*args, &block)
-              rescue NoMethodError, ArgumentError
-                raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
-              end
-            end
-          end
-        end
-
-        return GUARD_CLAUSE.new(func, self, pattern)
-      end
-
-      public
-
-      def __function_pattern_matches__ # :nodoc:
-        @__function_pattern_matches__ ||= Hash.new
-      end
-
-      def __add_pattern_for__(func, *args, &block) # :nodoc:
-        block = Proc.new{} unless block_given?
-        matchers = self.__function_pattern_matches__
-        matchers[func] = [] unless matchers.has_key?(func)
-        matchers[func] << [args, block, nil]
-        return matchers[func].last
-      end
-    end
-  end
-end
+module PatternMatching
+
+  UNBOUND = Class.new
+  ALL = Class.new
+
+  private
+
+  GUARD_CLAUSE = Class.new do # :nodoc:
+    def initialize(func, clazz, matcher) # :nodoc:
+      @func = func
+      @clazz = clazz
+      @matcher = matcher
+    end
+    def when(&block) # :nodoc:
+      unless block_given?
+        raise ArgumentError.new("block missing for `when` guard on function `#{@func}` of class #{@clazz}")
+      end
+      @matcher[@matcher.length-1] = block
+      return nil
+    end
+  end
+
+  def self.__match_pattern__(args, pattern) # :nodoc:
+    return unless (pattern.last == ALL && args.length >= pattern.length) \
+      || (args.length == pattern.length)
+    pattern.each_with_index do |p, i|
+      break if p == ALL && i+1 == pattern.length
+      arg = args[i]
+      next if p.is_a?(Class) && arg.is_a?(p)
+      if p.is_a?(Hash) && arg.is_a?(Hash) && ! p.empty?
+        p.each do |key, value|
+          return false unless arg.has_key?(key)
+          next if value == UNBOUND
+          return false unless arg[key] == value
+        end
+        next
+      end
+      return false unless p == UNBOUND || p == arg
+    end
+    return true
+  end
+
+  def self.__unbound_args__(match, args) # :nodoc:
+    argv = []
+    match.first.each_with_index do |p, i|
+      if p == ALL && i == match.first.length-1
+        argv << args[(i..args.length)].reduce([]){|memo, arg| memo << arg }
+      elsif p.is_a?(Hash) && p.values.include?(UNBOUND)
+        p.each do |key, value|
+          argv << args[i][key] if value == UNBOUND
+        end
+      elsif p.is_a?(Hash) || p == UNBOUND || p.is_a?(Class)
+        argv << args[i] 
+      end
+    end
+    return argv
+  end
+
+  def self.__pattern_match__(clazz, func, *args, &block) # :nodoc:
+    args = args.first
+
+    matchers = clazz.__function_pattern_matches__[func]
+    return [:nodef, nil] if matchers.nil?
+
+    match = matchers.detect do |matcher|
+      if PatternMatching.__match_pattern__(args, matcher.first)
+        if matcher.last.nil?
+          true # no guard clause
+        else
+          self.instance_exec(*PatternMatching.__unbound_args__(matcher, args), &matcher.last)
+        end
+      end
+    end
+
+    return (match ? [:ok, match] : [:nomatch, nil])
+  end
+
+  protected
+
+  def self.included(base)
+
+    class << base
+
+      public
+
+      def _() # :nodoc:
+        return UNBOUND
+      end
+
+      def defn(func, *args, &block)
+        unless block_given?
+          raise ArgumentError.new("block missing for definition of function `#{func}` on class #{self}")
+        end
+
+        pattern = __add_pattern_for__(func, *args, &block)
+
+        unless self.instance_methods(false).include?(func)
+
+          define_method(func) do |*args, &block|
+            result, match = PatternMatching.__pattern_match__(self.method(func).owner, func, args, block)
+            if result == :ok
+              # if a match is found call the block
+              argv = PatternMatching.__unbound_args__(match, args)
+              return self.instance_exec(*argv, &match[1])
+            else # if result == :nodef || result == :nomatch
+              begin
+                super(*args, &block)
+              rescue NoMethodError, ArgumentError
+                raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
+              end
+            end
+          end
+        end
+
+        return GUARD_CLAUSE.new(func, self, pattern)
+      end
+
+      public
+
+      def __function_pattern_matches__ # :nodoc:
+        @__function_pattern_matches__ ||= Hash.new
+      end
+
+      def __add_pattern_for__(func, *args, &block) # :nodoc:
+        block = Proc.new{} unless block_given?
+        matchers = self.__function_pattern_matches__
+        matchers[func] = [] unless matchers.has_key?(func)
+        matchers[func] << [args, block, nil]
+        return matchers[func].last
+      end
+    end
+  end
+end

data/lib/functional/utilities.rb

@@ -1,192 +1,192 @@
-require 'pp'
-require 'stringio'
-require 'erb'
-require 'rbconfig'
-
-Infinity = 1/0.0 unless defined?(Infinity)
-NaN = 0/0.0 unless defined?(NaN)
-
-module Kernel
-
-  # Compute the difference (delta) between two values.
-  #
-  # When a block is given the block will be applied to both arguments.
-  # Using a block in this way allows computation against a specific field
-  # in a data set of hashes or objects.
-  #
-  # @yield iterates over each element in the data set
-  # @yieldparam item each element in the data set
-  #
-  # @param [Object] v1 the first value
-  # @param [Object] v2 the second value
-  #
-  # @return [Float] positive value representing the difference
-  #   between the two parameters
-  def delta(v1, v2)
-    if block_given?
-      v1 = yield(v1)
-      v2 = yield(v2)
-    end
-    return (v1 - v2).abs
-  end
-  module_function :delta
-
-  # Perform an operation numerous times, passing the value of the
-  # previous iteration, and collecting the results into an array.
-  #
-  # @yield iterates over each element in the data set
-  # @yieldparam previous the initial value (or nil) for the first
-  #   iteration then the value of the previous iteration for all
-  #   subsequent iterations
-  #
-  # @param [Integer] count the number of times to perform the operation
-  # @param [Object] initial the initial value to pass to the first iteration
-  #
-  # @return [Array] the results of the iterations collected into an array
-  def repeatedly(count, initial = nil)
-    return [] if (count = count.to_i) == 0
-    return count.times.collect{ nil } unless block_given?
-    return count.times.collect do
-      initial = yield(initial)
-    end
-  end
-  module_function :repeatedly
-
-  # Try an operation. If it fails (raises an exception), wait a second
-  # and try again. Try no more than the given number of times.
-  #
-  # @yield Tries the given block operation
-  #
-  # @param [Integer] tries The maximum number of times to attempt the operation.
-  # @param [Array] args Optional block arguments
-  #
-  # @return [Boolean] true if the operation succeeds on any attempt,
-  #   false if none of the attempts are successful
-  def retro(tries, *args)
-    tries = tries.to_i
-    return false if tries == 0 || ! block_given?
-    yield(*args)
-    return true
-  rescue Exception
-    sleep(1)
-    if (tries = tries - 1) > 0
-      retry
-    else
-      return false
-    end
-  end
-  module_function :retro
-
-  # Sandbox the given operation at a high $SAFE level.
-  #
-  # @param args [Array] zero or more arguments to pass to the block
-  #
-  # @return [Object] the result of the block operation
-  def safe(*args)
-    raise ArgumentError.new('no block given') unless block_given?
-    if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
-      result = nil
-      t = Thread.new do
-        $SAFE = 3
-        result = yield(*args)
-      end
-      t.join
-      return result
-    else
-      return yield(*args)
-    end
-  end
-  module_function :safe
-
-  # Open a file, read it, close the file, and return its contents.
-  #
-  # @param file [String] path to and name of the file to open
-  #
-  # @return [String] file contents
-  #
-  # @see slurpee
-  def slurp(file)
-    File.open(file, 'rb') {|f| f.read }
-  end
-  module_function :slurp
-
-  # Open a file, read it, close the file, run the contents through the
-  # ERB parser, and return updated contents.
-  #
-  # @param file [String] path to and name of the file to open
-  # @param safe_level [Integer] when not nil, ERB will $SAFE set to this
-  #
-  # @return [String] file contents
-  #
-  # @see slurpee
-  def slurpee(file, safe_level = nil)
-    ERB.new(slurp(file), safe_level).result
-  end
-  module_function :slurpee
-
-  # Run the given block and time how long it takes in seconds. All arguments
-  # will be passed to the block. The function will return two values. The
-  # first value will be the duration of the timer in seconds. The second
-  # return value will be the result of the block.
-  #
-  # @param args [Array] zero or more arguments to pass to the block
-  #
-  # @return [Integer, Object] the duration of the operation in seconds and
-  #   the result of the block operation
-  def timer(*args)
-    return 0,nil unless block_given?
-    t1 = Time.now
-    result = yield(*args)
-    t2 = Time.now
-    return (t2 - t1), result
-  end
-  module_function :timer
-
-  #############################################################################
-
-  # @private
-  # @see http://cirw.in/blog/find-references
-  def object_counts # :nodoc:
-    counts = Hash.new{ 0 }
-    ObjectSpace.each_object do |obj|
-      counts[obj.class] += 1
-    end
-    return counts
-  end
-  module_function :object_counts
-
-  # @private
-  # @see http://rhaseventh.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
-  def pp_s(*objs) # :nodoc:
-    s = StringIO.new
-    objs.each {|obj|
-      PP.pp(obj, s)
-    }
-    s.rewind
-    s.read
-  end
-  module_function :pp_s
-
-  # @private
-  def repl? # :nodoc:
-    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
-  end
-  module_function :repl?
-
-  # @private
-  def strftimer(seconds) # :nodoc:
-    Time.at(seconds).gmtime.strftime('%R:%S.%L')
-  end
-  module_function :strftimer
-
-  # @private
-  def timestamp # :nodoc:
-    return Time.now.getutc.to_i
-  end
-
-  def write_object_counts(name = 'ruby')
-    file = "#{name}_#{Time.now.to_i}.txt"
-    File.open(file, 'w') {|f| f.write(pp_s(object_counts)) }
-  end
-  module_function :write_object_counts
-end
+require 'pp'
+require 'stringio'
+require 'erb'
+require 'rbconfig'
+
+Infinity = 1/0.0 unless defined?(Infinity)
+NaN = 0/0.0 unless defined?(NaN)
+
+module Kernel
+
+  # Compute the difference (delta) between two values.
+  #
+  # When a block is given the block will be applied to both arguments.
+  # Using a block in this way allows computation against a specific field
+  # in a data set of hashes or objects.
+  #
+  # @yield iterates over each element in the data set
+  # @yieldparam item each element in the data set
+  #
+  # @param [Object] v1 the first value
+  # @param [Object] v2 the second value
+  #
+  # @return [Float] positive value representing the difference
+  #   between the two parameters
+  def delta(v1, v2)
+    if block_given?
+      v1 = yield(v1)
+      v2 = yield(v2)
+    end
+    return (v1 - v2).abs
+  end
+  module_function :delta
+
+  # Perform an operation numerous times, passing the value of the
+  # previous iteration, and collecting the results into an array.
+  #
+  # @yield iterates over each element in the data set
+  # @yieldparam previous the initial value (or nil) for the first
+  #   iteration then the value of the previous iteration for all
+  #   subsequent iterations
+  #
+  # @param [Integer] count the number of times to perform the operation
+  # @param [Object] initial the initial value to pass to the first iteration
+  #
+  # @return [Array] the results of the iterations collected into an array
+  def repeatedly(count, initial = nil)
+    return [] if (count = count.to_i) == 0
+    return count.times.collect{ nil } unless block_given?
+    return count.times.collect do
+      initial = yield(initial)
+    end
+  end
+  module_function :repeatedly
+
+  # Try an operation. If it fails (raises an exception), wait a second
+  # and try again. Try no more than the given number of times.
+  #
+  # @yield Tries the given block operation
+  #
+  # @param [Integer] tries The maximum number of times to attempt the operation.
+  # @param [Array] args Optional block arguments
+  #
+  # @return [Boolean] true if the operation succeeds on any attempt,
+  #   false if none of the attempts are successful
+  def retro(tries, *args)
+    tries = tries.to_i
+    return false if tries == 0 || ! block_given?
+    yield(*args)
+    return true
+  rescue Exception
+    sleep(1)
+    if (tries = tries - 1) > 0
+      retry
+    else
+      return false
+    end
+  end
+  module_function :retro
+
+  # Sandbox the given operation at a high $SAFE level.
+  #
+  # @param args [Array] zero or more arguments to pass to the block
+  #
+  # @return [Object] the result of the block operation
+  def safe(*args)
+    raise ArgumentError.new('no block given') unless block_given?
+    if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
+      result = nil
+      t = Thread.new do
+        $SAFE = 3
+        result = yield(*args)
+      end
+      t.join
+      return result
+    else
+      return yield(*args)
+    end
+  end
+  module_function :safe
+
+  # Open a file, read it, close the file, and return its contents.
+  #
+  # @param file [String] path to and name of the file to open
+  #
+  # @return [String] file contents
+  #
+  # @see slurpee
+  def slurp(file)
+    File.open(file, 'rb') {|f| f.read }
+  end
+  module_function :slurp
+
+  # Open a file, read it, close the file, run the contents through the
+  # ERB parser, and return updated contents.
+  #
+  # @param file [String] path to and name of the file to open
+  # @param safe_level [Integer] when not nil, ERB will $SAFE set to this
+  #
+  # @return [String] file contents
+  #
+  # @see slurpee
+  def slurpee(file, safe_level = nil)
+    ERB.new(slurp(file), safe_level).result
+  end
+  module_function :slurpee
+
+  # Run the given block and time how long it takes in seconds. All arguments
+  # will be passed to the block. The function will return two values. The
+  # first value will be the duration of the timer in seconds. The second
+  # return value will be the result of the block.
+  #
+  # @param args [Array] zero or more arguments to pass to the block
+  #
+  # @return [Integer, Object] the duration of the operation in seconds and
+  #   the result of the block operation
+  def timer(*args)
+    return 0,nil unless block_given?
+    t1 = Time.now
+    result = yield(*args)
+    t2 = Time.now
+    return (t2 - t1), result
+  end
+  module_function :timer
+
+  #############################################################################
+
+  # @private
+  # @see http://cirw.in/blog/find-references
+  def object_counts # :nodoc:
+    counts = Hash.new{ 0 }
+    ObjectSpace.each_object do |obj|
+      counts[obj.class] += 1
+    end
+    return counts
+  end
+  module_function :object_counts
+
+  # @private
+  # @see http://rhaseventh.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
+  def pp_s(*objs) # :nodoc:
+    s = StringIO.new
+    objs.each {|obj|
+      PP.pp(obj, s)
+    }
+    s.rewind
+    s.read
+  end
+  module_function :pp_s
+
+  # @private
+  def repl? # :nodoc:
+    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
+  end
+  module_function :repl?
+
+  # @private
+  def strftimer(seconds) # :nodoc:
+    Time.at(seconds).gmtime.strftime('%R:%S.%L')
+  end
+  module_function :strftimer
+
+  # @private
+  def timestamp # :nodoc:
+    return Time.now.getutc.to_i
+  end
+
+  def write_object_counts(name = 'ruby')
+    file = "#{name}_#{Time.now.to_i}.txt"
+    File.open(file, 'w') {|f| f.write(pp_s(object_counts)) }
+  end
+  module_function :write_object_counts
+end