functional-ruby 0.5.0 → 0.6.0

data/lib/functional/agent.rb

@@ -0,0 +1,130 @@
+require 'observer'
+require 'thread'
+
+require 'functional/global_thread_pool'
+
+module Functional
+
+  # An agent is a single atomic value that represents an identity. The current value
+  # of the agent can be requested at any time (#deref). Each agent has a work queue and operates on
+  # the global thread pool. Consumers can #post code blocks to the agent. The code block (function)
+  # will receive the current value of the agent as its sole parameter. The return value of the block
+  # will become the new value of the agent. Agents support two error handling modes: fail and continue.
+  # A good example of an agent is a shared incrementing counter, such as the score in a video game.
+  class Agent
+    include Observable
+
+    TIMEOUT = 5
+
+    attr_reader :initial
+    attr_reader :timeout
+
+    def initialize(initial, timeout = TIMEOUT)
+      @value = initial
+      @timeout = timeout
+      @rescuers = []
+      @validator = nil
+      @queue = Queue.new
+
+      $GLOBAL_THREAD_POOL << proc{ work }
+    end
+
+    def value(timeout = 0) return @value; end
+    alias_method :deref, :value
+
+    def rescue(clazz = Exception, &block)
+      @rescuers << Rescuer.new(clazz, block) if block_given?
+      return self
+    end
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+    def validate(&block)
+      @validator = block if block_given?
+      return self
+    end
+    alias_method :validates, :validate
+    alias_method :validate_with, :validate
+    alias_method :validates_with, :validate
+
+    def post(&block)
+      return @queue.length unless block_given?
+      @queue << block
+      return @queue.length
+    end
+
+    def <<(block)
+      self.post(&block)
+      return self
+    end
+
+    def length
+      @queue.length
+    end
+    alias_method :size, :length
+    alias_method :count, :length
+
+    alias_method :add_watch, :add_observer
+
+    private
+
+    # @private
+    Rescuer = Struct.new(:clazz, :block)
+
+    # @private
+    def try_rescue(ex) # :nodoc:
+      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
+      rescuer.block.call(ex) if rescuer
+    rescue Exception => e
+      # supress
+    end
+
+    # @private
+    def work # :nodoc:
+      loop do
+        Thread.pass
+        handler = @queue.pop
+        begin
+          result = Timeout.timeout(@timeout){
+            handler.call(@value)
+          }
+          if @validator.nil? || @validator.call(result)
+            @value = result
+            changed
+            notify_observers(Time.now, @value)
+          end
+        rescue Exception => ex
+          try_rescue(ex)
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+
+  def agent(initial, timeout = Functional::Agent::TIMEOUT)
+    return Functional::Agent.new(initial, timeout)
+  end
+  module_function :agent
+
+  def deref(agent, timeout = nil)
+    if agent.respond_to?(:deref)
+      return agent.deref(timeout)
+    elsif agent.respond_to?(:value)
+      return agent.deref(timeout)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+
+  def post(agent, &block)
+    if agent.respond_to?(:post)
+      return agent.post(&block)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+end

data/lib/functional/all.rb

@@ -1,5 +1,13 @@
+require 'functional/agent'
 require 'functional/behavior'
+require 'functional/cached_thread_pool'
 require 'functional/concurrency'
-require 'functional/core'
+require 'functional/event'
+require 'functional/fixed_thread_pool'
+require 'functional/future'
+require 'functional/obligation'
 require 'functional/pattern_matching'
+require 'functional/promise'
+require 'functional/thread_pool'
+require 'functional/utilities'
 require 'functional/version'

data/lib/functional/behavior.rb

@@ -1,12 +1,78 @@
-def behavior_info(name, callbacks = {})
-  $__behavior_info__ ||= {}
-  $__behavior_info__[name.to_sym] = callbacks.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-end
+module Kernel
+
+  BehaviorError = Class.new(StandardError)
+
+  # Define a behavioral specification (interface).
+  #
+  # @param name [Symbol] the name of the behavior
+  # @param functions [Hash] function names and their arity as key/value pairs
+  def behavior_info(name, functions = {})
+    $__behavior_info__ ||= {}
+    $__behavior_info__[name.to_sym] = functions.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+  end
+
+  alias :behaviour_info :behavior_info
+  alias :interface :behavior_info
+
+  module_function :behavior_info
+  module_function :behaviour_info
+  module_function :interface
+
+  # Specify a #behavior_info to enforce on the enclosing class
+  #
+  # @param name [Symbol] name of the #behavior_info being implemented
+  def behavior(name)
+
+    name = name.to_sym
+    raise BehaviorError.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 BehaviorError.new("undefined callback functions in #{self} (behavior '#{name}')")
+        else
+          return obj
+        end
+      end
+    end
+  end
 
-alias :behaviour_info :behavior_info
-alias :interface :behavior_info
+  alias :behaviour :behavior
+  alias :behaves_as :behavior
+
+  module_function :behavior
+  module_function :behaviour
+  module_function :behaves_as
+end
 
 class Object
+
+  # Does the object implement the given #behavior_info?
+  #
+  # @note Will return true if the object implements the
+  # required methods. The object's class hierarchy does
+  # not necessarily have to include a corresponding
+  # #behavior call.
+  #
+  # @param name [Symbol] name of the #behavior_info to
+  # verify behavior against.
+  #
+  # @return [Boolean] whether or not the required public
+  # methods are implemented
   def behaves_as?(name)
 
     name = name.to_sym
@@ -24,36 +90,3 @@ class Object
     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/cached_thread_pool.rb

@@ -0,0 +1,122 @@
+require 'thread'
+
+require 'functional/thread_pool'
+require 'functional/utilities'
+
+module Functional
+
+  def self.new_cached_thread_pool
+    return CachedThreadPool.new
+  end
+
+  class CachedThreadPool < ThreadPool
+    behavior(:thread_pool)
+
+    DEFAULT_GC_INTERVAL = 60
+    DEFAULT_THREAD_IDLETIME = 60
+
+    attr_reader :working
+
+    def initialize(opts = {})
+      @gc_interval = opts[:gc_interval] || DEFAULT_GC_INTERVAL
+      @thread_idletime = opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME
+      super()
+      @working = 0
+      @mutex = Mutex.new
+    end
+
+    def kill
+      @status = :killed
+      @mutex.synchronize do
+        @pool.each{|t| Thread.kill(t.thread) }
+      end
+    end
+
+    def size
+      return @pool.length
+    end
+
+    def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      if running?
+        collect_garbage if @pool.empty?
+        @mutex.synchronize do
+          if @working >= @pool.length
+            create_worker_thread
+          end
+          @queue << [args, block]
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    # @private
+    def status # :nodoc:
+      @mutex.synchronize do
+        @pool.collect do |worker|
+          [
+            worker.status,
+            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
+            worker.thread.status
+          ]
+        end
+      end
+    end
+
+    private
+
+    Worker = Struct.new(:status, :idletime, :thread)
+
+    # @private
+    def create_worker_thread # :nodoc:
+      worker = Worker.new(:idle, timestamp, nil)
+
+      worker.thread = Thread.new(worker) do |me|
+
+        loop do
+          task = @queue.pop
+
+          @working += 1
+          me.status = :working
+
+          if task == :stop
+            me.status = :stopping
+            break
+          else
+            task.last.call(*task.first)
+            @working -= 1
+            me.status = :idle
+            me.idletime = timestamp
+          end
+        end
+
+        @pool.delete(me)
+        if @pool.empty?
+          @termination.set
+          @status = :shutdown unless killed?
+        end
+      end
+
+      @pool << worker
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        loop do
+          sleep(@gc_interval)
+          @mutex.synchronize do
+            @pool.reject! do |worker|
+              worker.thread.status.nil? ||
+                (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))
+            end
+          end
+          @working = @pool.count{|worker| worker.status == :working}
+          break if @pool.empty?
+        end
+      end
+    end
+  end
+end

data/lib/functional/concurrency.rb

@@ -1,27 +1,35 @@
-# 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
+require 'thread'
 
-# http://richhickey.github.io/clojure/clojure.core-api.html
-# * agent
-# * add-watch
-# * apply
-# * assert
-# * await
-# * future
-# * memoize
-# * promise
-# * send
-# * slurp
+require 'functional/agent'
+require 'functional/future'
+require 'functional/promise'
 
-# 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
+require 'functional/thread_pool'
+require 'functional/cached_thread_pool'
+require 'functional/fixed_thread_pool'
 
-# 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
+require 'functional/global_thread_pool'
+
+require 'functional/event_machine_defer_proxy' if defined?(EventMachine)
+
+module Kernel
+
+  # Post the given agruments and block to the Global Thread Pool.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] operation to be performed concurrently
+  #
+  # @return [true,false] success/failre of thread creation
+  #
+  # @note Althought based on Go's goroutines and Erlang's spawn/1,
+  # Ruby has a vastly different runtime. Threads aren't nearly as
+  # efficient in Ruby. Use this function appropriately.
+  #
+  # @see http://golang.org/doc/effective_go.html#goroutines
+  # @see https://gobyexample.com/goroutines
+  def go(*args, &block)
+    return false unless block_given?
+    $GLOBAL_THREAD_POOL.post(*args, &block)
+  end
+  module_function :go
+end

data/lib/functional/core.rb

@@ -1,62 +1,2 @@
-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
+require 'functional/behavior'
+require 'functional/pattern_matching'

data/lib/functional/event.rb

@@ -0,0 +1,53 @@
+require 'thread'
+require 'timeout'
+
+module Functional
+
+  class Event
+
+    def initialize
+      @set = false
+      @notifier = Queue.new
+      @mutex = Mutex.new
+      @waiting = 0
+    end
+
+    def set?
+      return @set == true
+    end
+
+    def set
+      return true if set?
+      @mutex.synchronize {
+        @set = true
+        while @waiting > 0
+          @notifier << :set
+          @waiting -= 1
+        end
+      }
+    end
+
+    def reset
+      @mutex.synchronize {
+        @set = false
+      }
+    end
+
+    def wait(timeout = nil)
+      return true if set?
+
+      if timeout.nil?
+        @waiting += 1
+        @notifier.pop
+      else
+        Timeout::timeout(timeout) do
+          @waiting += 1
+          @notifier.pop
+        end
+      end
+      return true
+    rescue Timeout::Error
+      return false
+    end
+  end
+end

data/lib/functional/event_machine_defer_proxy.rb

@@ -0,0 +1,23 @@
+require 'functional/global_thread_pool'
+
+module Functional
+
+  class EventMachineDeferProxy
+    behavior(:global_thread_pool)
+
+    def post(*args, &block)
+      if args.empty?
+        EventMachine.defer(block)
+      else
+        new_block = proc{ block.call(*args) }
+        EventMachine.defer(new_block)
+      end
+      return true
+    end
+
+    def <<(block)
+      EventMachine.defer(block)
+      return self
+    end
+  end
+end

data/lib/functional/fixed_thread_pool.rb

@@ -0,0 +1,89 @@
+require 'thread'
+
+require 'functional/thread_pool'
+require 'functional/event'
+
+module Functional
+
+  def self.new_fixed_thread_pool(size)
+    return FixedThreadPool.new(size)
+  end
+
+  class FixedThreadPool < ThreadPool
+    behavior(:thread_pool)
+
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 1024
+
+    def initialize(size)
+      super()
+      if size < MIN_POOL_SIZE || size > MAX_POOL_SIZE
+        raise ArgumentError.new("size must be between #{MIN_POOL_SIZE} and #{MAX_POOL_SIZE}")
+      end
+
+      @pool = size.times.collect{ create_worker_thread }
+      collect_garbage
+    end
+
+    def kill
+      @status = :killed
+      @pool.each{|t| Thread.kill(t) }
+    end
+
+    def size
+      if running?
+        return @pool.length
+      else
+        return 0
+      end
+    end
+
+    def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      if running?
+        @queue << [args, block]
+        return true
+      else
+        return false
+      end
+    end
+
+    # @private
+    def status # :nodoc:
+      @pool.collect{|t| t.status }
+    end
+
+    private
+
+    # @private
+    def create_worker_thread # :nodoc:
+      Thread.new do
+        loop do
+          task = @queue.pop
+          if task == :stop
+            break
+          else
+            task.last.call(*task.first)
+          end
+        end
+        @pool.delete(Thread.current)
+        if @pool.empty?
+          @termination.set
+          @status = :shutdown unless killed?
+        end
+      end
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        sleep(1)
+        @pool.size.times do |i|
+          if @pool[i].status.nil?
+            @pool[i] = create_worker_thread
+          end
+        end
+      end
+    end
+  end
+end