functional-ruby 0.6.0 → 0.7.0

data/lib/functional/event_machine_defer_proxy.rb

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

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

data/lib/functional/future.rb

@@ -1,42 +0,0 @@
-require 'thread'
-
-require 'functional/obligation'
-require 'functional/global_thread_pool'
-
-module Functional
-
-  class Future
-    include Obligation
-    behavior(:future)
-
-    def initialize(*args)
-
-      unless block_given?
-        @state = :fulfilled
-      else
-        @value = nil
-        @state = :pending
-        $GLOBAL_THREAD_POOL.post do
-          semaphore.synchronize do
-            Thread.pass
-            begin
-              @value = yield(*args)
-              @state = :fulfilled
-            rescue Exception => ex
-              @state = :rejected
-              @reason = ex
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-module Kernel
-
-  def future(*args, &block)
-    return Functional::Future.new(*args, &block)
-  end
-  module_function :future
-end

data/lib/functional/global_thread_pool.rb

@@ -1,3 +0,0 @@
-require 'functional/cached_thread_pool'
-
-$GLOBAL_THREAD_POOL ||= Functional::CachedThreadPool.new

data/lib/functional/obligation.rb

@@ -1,121 +0,0 @@
-require 'thread'
-require 'timeout'
-
-require 'functional/behavior'
-
-behavior_info(:future,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0)
-
-behavior_info(:promise,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0,
-              then: 0,
-              rescue: -1)
-
-module Functional
-
-  module Obligation
-
-    attr_reader :state
-    attr_reader :reason
-
-    # Has the obligation been fulfilled?
-    # @return [Boolean]
-    def fulfilled?() return(@state == :fulfilled); end
-    alias_method :realized?, :fulfilled?
-
-    # Is obligation completion still pending?
-    # @return [Boolean]
-    def pending?() return(!(fulfilled? || rejected?)); end
-
-    def value(timeout = nil)
-      if !pending? || timeout == 0
-        return @value
-      elsif timeout.nil?
-        return semaphore.synchronize { @value }
-      else
-        begin
-          return Timeout::timeout(timeout.to_f) {
-            semaphore.synchronize { @value }
-          }
-        rescue Timeout::Error => ex
-          return nil
-        end
-      end
-    end
-    alias_method :deref, :value
-
-    # Has the promise been rejected?
-    # @return [Boolean]
-    def rejected?() return(@state == :rejected); end
-
-    protected
-
-    def semaphore
-      @semaphore ||= Mutex.new
-    end
-  end
-end
-
-module Kernel
-
-  def deref(obligation, timeout = nil)
-    if obligation.respond_to?(:deref)
-      return obligation.deref(timeout)
-    elsif obligation.respond_to?(:value)
-      return obligation.deref(timeout)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-
-  def pending?(obligation)
-    if obligation.respond_to?(:pending?)
-      return obligation.pending?
-    else
-      return false
-    end
-  end
-  module_function :pending?
-
-  def fulfilled?(obligation)
-    if obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
-    elsif obligation.respond_to?(:realized?)
-      return obligation.realized?
-    else
-      return false
-    end
-  end
-  module_function :fulfilled?
-
-  def realized?(obligation)
-    if obligation.respond_to?(:realized?)
-      return obligation.realized?
-    elsif obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
-    else
-      return false
-    end
-  end
-  module_function :realized?
-
-  def rejected?(obligation)
-    if obligation.respond_to?(:rejected?)
-      return obligation.rejected?
-    else
-      return false
-    end
-  end
-  module_function :rejected?
-end

data/lib/functional/promise.rb

@@ -1,194 +0,0 @@
-require 'thread'
-
-require 'functional/obligation'
-require 'functional/global_thread_pool'
-
-module Functional
-
-  class Promise
-    include Obligation
-    behavior(:future)
-    behavior(:promise)
-
-    # Creates a new promise object. "A promise represents the eventual
-    # value returned from the single completion of an operation."
-    # Promises can be chained in a tree structure where each promise
-    # has zero or more children. Promises are resolved asynchronously
-    # in the order they are added to the tree. Parents are guaranteed
-    # to be resolved before their children. The result of each promise
-    # is passed to each of its children upon resolution. When
-    # a promise is rejected all its children will be summarily rejected.
-    # A promise that is neither resolved or rejected is pending.
-    #
-    # @param args [Array] zero or more arguments for the block
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
-    # @see http://wiki.commonjs.org/wiki/Promises/A
-    # @see http://promises-aplus.github.io/promises-spec/
-    def initialize(*args, &block)
-      if args.first.is_a?(Promise)
-        @parent = args.first
-      else
-        @parent = nil
-        @chain = [self]
-      end
-
-      @mutex = Mutex.new
-      @handler = block || Proc.new{|result| result }
-      @state = :pending
-      @value = nil
-      @reason = nil
-      @children = []
-      @rescuers = []
-
-      realize(*args) if root?
-    end
-
-    # Create a new child Promise. The block argument for the child will
-    # be the result of fulfilling its parent. If the child will
-    # immediately be rejected if the parent has already been rejected.
-    #
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
-    # @return [Promise] the new promise
-    def then(&block)
-      child = @mutex.synchronize do
-        block = Proc.new{|result| result } unless block_given?
-        @children << Promise.new(self, &block)
-        @children.last.on_reject(@reason) if rejected?
-        push(@children.last)
-        @children.last
-      end
-      return child
-    end
-
-    # Add a rescue handler to be run if the promise is rejected (via raised
-    # exception). Multiple rescue handlers may be added to a Promise.
-    # Rescue blocks will be checked in order and the first one with a
-    # matching Exception class will be processed. The block argument
-    # will be the exception that caused the rejection.
-    #
-    # @param clazz [Class] The class of exception to rescue
-    # @param block [Proc] the block to call if the rescue is matched
-    #
-    # @return [self] so that additional chaining can occur
-    def rescue(clazz = Exception, &block)
-      @mutex.synchronize do
-        @rescuers << Rescuer.new(clazz, block) if block_given?
-      end
-      return self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    protected
-
-    attr_reader :parent
-    attr_reader :handler
-    attr_reader :rescuers
-
-    # @private
-    Rescuer = Struct.new(:clazz, :block)
-
-    # @private
-    def root # :nodoc:
-      current = self
-      current = current.parent until current.root?
-      return current
-    end
-
-    # @private
-    def root? # :nodoc:
-      @parent.nil?
-    end
-
-    # @private
-    def push(promise) # :nodoc:
-      if root?
-        @chain << promise
-      else
-        @parent.push(promise)
-      end
-    end
-
-    # @private
-    def on_fulfill(value) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @value = @handler.call(value)
-          @state = :fulfilled
-          @reason = nil
-        end
-      end
-      return @value
-    end
-
-    # @private
-    def on_reject(reason) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @state = :rejected
-          @reason = reason
-          self.try_rescue(reason)
-          @value = nil
-        end
-        @children.each{|child| child.on_reject(reason) }
-      end
-    end
-
-    # @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 realize(*args) # :nodoc:
-      $GLOBAL_THREAD_POOL.post(@chain, @mutex, args) do |chain, mutex, args|
-        result = args.length == 1 ? args.first : args
-        index = 0
-        loop do
-          Thread.pass
-          current = mutex.synchronize{ chain[index] }
-          unless current.rejected?
-            current.semaphore.synchronize do
-              begin
-                result = current.on_fulfill(result)
-              rescue Exception => ex
-                current.on_reject(ex)
-              end
-            end
-          end
-          index += 1
-          sleep while index >= chain.length
-        end
-      end
-    end
-  end
-end
-
-module Kernel
-
-  # Creates a new promise object. "A promise represents the eventual
-  # value returned from the single completion of an operation."
-  # Promises can be chained in a tree structure where each promise
-  # has zero or more children. Promises are resolved asynchronously
-  # in the order they are added to the tree. Parents are guaranteed
-  # to be resolved before their children. The result of each promise
-  # is passes to each of its children when the child resolves. When
-  # a promise is rejected all its children will be summarily rejected.
-  # A promise added to a rejected promise will immediately be rejected.
-  # A promise that is neither resolved or rejected is pending.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] the block to call when attempting fulfillment
-  #
-  # @see Promise
-  # @see http://wiki.commonjs.org/wiki/Promises/A
-  def promise(*args, &block)
-    return Functional::Promise.new(*args, &block)
-  end
-  module_function :promise
-end