functional-ruby 0.5.0

data/lib/functional/all.rb

@@ -0,0 +1,5 @@
+require 'functional/behavior'
+require 'functional/concurrency'
+require 'functional/core'
+require 'functional/pattern_matching'
+require 'functional/version'

data/lib/functional/behavior.rb

@@ -0,0 +1,59 @@
+def behavior_info(name, callbacks = {})
+  $__behavior_info__ ||= {}
+  $__behavior_info__[name.to_sym] = callbacks.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+end
+
+alias :behaviour_info :behavior_info
+alias :interface :behavior_info
+
+class Object
+  def behaves_as?(name)
+
+    name = name.to_sym
+    bi = $__behavior_info__[name]
+    return false if bi.nil?
+
+    bi.each do |method, arity|
+      begin
+        return false unless arity == :any || self.method(method).arity == arity
+      rescue NameError
+        return false
+      end
+    end
+
+    return true
+  end
+end
+
+def behavior(name)
+
+  name = name.to_sym
+  raise ArgumentError.new("undefined behavior '#{name}'") if $__behavior_info__[name].nil?
+
+  clazz = self.method(:behavior).receiver
+
+  unless clazz.instance_methods(false).include?(:behaviors)
+    class << clazz
+      def behaviors
+        @behaviors ||= []
+      end
+    end
+  end
+
+  clazz.behaviors << name
+
+  class << clazz
+    def new(*args, &block)
+      name = self.behaviors.first
+      obj = super
+      unless obj.behaves_as?(name)
+        raise ArgumentError.new("undefined callback functions in #{self} (behavior '#{name}')")
+      else
+        return obj
+      end
+    end
+  end
+end
+
+alias :behaviour :behavior
+alias :behaves_as :behavior

data/lib/functional/behaviour.rb

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

data/lib/functional/concurrency.rb

@@ -0,0 +1,27 @@
+# http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+# http://www.lesismore.co.za/rubyenums.html
+# http://gistflow.com/posts/682-ruby-enums-approaches
+
+# http://richhickey.github.io/clojure/clojure.core-api.html
+# * agent
+# * add-watch
+# * apply
+# * assert
+# * await
+# * future
+# * memoize
+# * promise
+# * send
+# * slurp
+
+# Other stuff
+# * pure - creates an object, freezes it, and removes the unfreeze method
+# * retry - retries something x times if it fails
+# * promise = ala JavaScript http://blog.parse.com/2013/01/29/whats-so-great-about-javascript-promises/
+# * ada range type - http://en.wikibooks.org/wiki/Ada_Programming/Types/range
+# * slurpee - slurp + erb parsing
+# * spawn/send/receive - http://www.erlang.org/doc/reference_manual/processes.html
+
+# Using Ruby's queue for sending messages between threads
+# * http://www.subelsky.com/2010/02/using-rubys-queue-class-to-manage-inter.html
+# * http://www.ruby-doc.org/stdlib-1.9.3/libdoc/thread/rdoc/Queue.html#method-i-pop

data/lib/functional/core.rb

@@ -0,0 +1,62 @@
+require 'pp'
+require 'stringio'
+
+Infinity = 1/0.0 unless defined?(Infinity)
+NaN = 0/0.0 unless defined?(NaN)
+
+module Kernel
+
+  private
+
+  def repl?
+    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
+  end
+  module_function :repl?
+
+  def safe(*args, &block)
+    raise ArgumentError.new('no block given') unless block_given?
+    result = nil
+    t = Thread.new do
+      $SAFE = 3
+      result = self.instance_exec(*args, &block)
+    end
+    t.join
+    return result
+  end
+  module_function :safe
+
+  # http://rhaseventh.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
+  def pp_s(*objs)
+    s = StringIO.new
+    objs.each {|obj|
+      PP.pp(obj, s)
+    }
+    s.rewind
+    s.read
+  end
+  module_function :pp_s
+
+  # 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
+
+end

data/lib/functional/pattern_matching.rb

@@ -0,0 +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

data/lib/functional/version.rb

@@ -0,0 +1,3 @@
+module Functional
+  VERSION = '0.5.0'
+end

data/spec/functional/behavior_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+#behaviour_info(:gen_foo, foo: 0, bar: 1, baz: 2, boom: -1, bam: :any)
+
+#class Foo
+  #behavior(:gen_foo)
+
+  #def foo
+    #return 'foo/0'
+  #end
+
+  #def bar(one, &block)
+    #return 'bar/1'
+  #end
+
+  #def baz(one, two)
+    #return 'baz/2'
+  #end
+
+  #def boom(*args)
+    #return 'boom/-1'
+  #end
+
+  #def bam
+    #return 'bam!'
+  #end
+#end
+
+describe 'behavior/interface definitions' do
+
+  before(:each) do
+    $__behavior_info__ = {}
+  end
+
+  context 'behavior_info/2' do
+
+    it 'accepts a symbol name' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts a string name' do
+      behavior_info('gen_foo', foo: 0)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts zero function names' do
+      behavior_info(:gen_foo)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts symbols for function names' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts strings as function names' do
+      behavior_info(:gen_foo, 'foo' => 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts numeric arity values' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts :any as an arity value' do
+      behavior_info(:gen_foo, foo: :any)
+      $__behavior_info__.values.first.should == {foo: :any}
+    end
+  end
+
+  context 'behavior/1' do
+
+    it 'raises an exception if the behavior has not been defined' do
+      lambda {
+        Class.new{
+          behavior(:gen_foo)
+        }
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'can be called multiple times for one class' do
+      behavior_info(:gen_foo, foo: 0)
+      behavior_info(:gen_bar, bar: 0)
+
+      lambda {
+        Class.new{
+          behavior(:gen_foo)
+          behavior(:gen_bar)
+        }
+      }.should_not raise_error
+    end
+  end
+
+  context 'behavior check on object creation' do
+
+    it 'raises an exception when one or more function definitions are missing' do
+      behavior_info(:gen_foo, foo: 0, bar: 1)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo() nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when one or more functions do not have proper arity' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo(broken) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'accepts any arity when function arity is set to :any' do
+      behavior_info(:gen_foo, foo: :any)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo(first) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should_not raise_error(ArgumentError)
+    end
+
+    it 'creates the object when function definitions match' do
+      behavior_info(:gen_foo, foo: 0, bar: 1)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo() nil; end
+        def bar(first) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  context '#behaves_as?' do
+
+    it 'returns true when the behavior is fully suported' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new {
+        def foo() nil; end
+        def bar(first) nil; end
+        def baz(first, second) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'accepts any arity when function arity is set to :any' do
+      behavior_info(:gen_foo, foo: :any)
+      clazz = Class.new {
+        def foo(*args, &block) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'returns false when the behavior is partially supported' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new {
+        def foo() nil; end
+        def bar(first) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'returns false when the behavior is not supported at all' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'returns false when the behavior does not exist' do
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'accepts behavior name as a symbol' do
+      behavior_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'accepts behavior name as a string' do
+      behavior_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?('gen_foo').should be_true
+    end
+  end
+
+  context 'aliases' do
+
+    it 'aliases behaviour_info for behavior_info' do
+      behaviour_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases interface for behavior_info' do
+      interface(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases behaviour for behavior' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behaviour(:gen_foo)
+        def foo() nil; end
+      }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases behaves_as for behavior' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behaves_as :gen_foo
+        def foo() nil; end
+      }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+  end
+
+end