mutant 0.9.3 → 0.9.8

data/lib/mutant/base.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module Functor
-    include AbstractType
-
-    abstract_method :fmap
-
-  private
-
-    # Raise error unless block is provided
-    #
-    # @raise [MissingBlockError]
-    #   if no block is given
-    #
-    # @return [self]
-    def require_block
-      fail LocalJumpError unless block_given?
-      self
-    end
-  end # Functor
-
-  class Maybe
-    include(
-      AbstractType,
-      Adamantium::Flat,
-      Functor
-    )
-
-    class Nothing < self
-      instance = new
-
-      define_method(:new) { instance }
-
-      # Evaluate functor block
-      #
-      # @return [Maybe::Nothing]
-      def fmap(&block)
-        require_block(&block)
-      end
-
-      # Evaluate applicative block
-      #
-      # @return [Maybe::Nothing]
-      def apply(&block)
-        require_block(&block)
-      end
-    end # Nothing
-
-    class Just < self
-      include Concord.new(:value)
-
-      # Evalute functor block
-      #
-      # @return [Maybe::Just<Object>]
-      def fmap
-        Just.new(yield(value))
-      end
-
-      # Evalute applicative block
-      #
-      # @return [Maybe]
-      def apply
-        yield(value)
-      end
-    end # Just
-  end # Maybe
-
-  class Either
-    include(
-      AbstractType,
-      Adamantium::Flat,
-      Concord.new(:value),
-      Functor
-    )
-
-    # Execute block and wrap error in left
-    #
-    # @param [Class:Exception] error
-    #
-    # @return [Either<Exception, Object>]
-    def self.wrap_error(error)
-      Right.new(yield)
-    rescue error => exception
-      Left.new(exception)
-    end
-
-    class Left < self
-      # Evaluate functor block
-      #
-      # @return [Either::Left<Object>]
-      def fmap(&block)
-        require_block(&block)
-      end
-
-      # Evaluate applicative block
-      #
-      # @return [Either::Left<Object>]
-      def apply(&block)
-        require_block(&block)
-      end
-
-      # Unwrap value from left
-      #
-      # @return [Object]
-      def from_left
-        value
-      end
-
-      # Unwrap value from right
-      #
-      # @return [Object]
-      #
-      # rubocop:disable Style/GuardClause
-      def from_right
-        if block_given?
-          yield(value)
-        else
-          fail "Expected right value, got #{inspect}"
-        end
-      end
-      # rubocop:enable Style/GuardClause
-
-      # Map over left value
-      #
-      # @return [Either::Right<Object>]
-      def lmap
-        Left.new(yield(value))
-      end
-
-      # Evaluate left side of branch
-      #
-      # @param [#call] left
-      # @param [#call] _right
-      def either(left, _right)
-        left.call(value)
-      end
-    end # Left
-
-    class Right < self
-      # Evaluate functor block
-      #
-      # @return [Either::Right<Object>]
-      def fmap
-        Right.new(yield(value))
-      end
-
-      # Evaluate applicative block
-      #
-      # @return [Either<Object>]
-      def apply
-        yield(value)
-      end
-
-      # Unwrap value from left
-      #
-      # @return [Object]
-      #
-      # rubocop:disable Style/GuardClause
-      def from_left
-        if block_given?
-          yield(value)
-        else
-          fail "Expected left value, got #{inspect}"
-        end
-      end
-      # rubocop:enable Style/GuardClause
-
-      # Unwrap value from right
-      #
-      # @return [Object]
-      def from_right
-        value
-      end
-
-      # Map over left value
-      #
-      # @return [Either::Right<Object>]
-      def lmap(&block)
-        require_block(&block)
-      end
-
-      # Evaluate right side of branch
-      #
-      # @param [#call] _left
-      # @param [#call] right
-      def either(_left, right)
-        right.call(value)
-      end
-    end # Right
-  end # Either
-end # Mutant

data/lib/mutant/variable.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Lightweight shared variables
-  #
-  # ignore :reek:TooManyMethods
-  class Variable
-    EMPTY = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::EMPTY')
-    end.new.freeze
-
-    TIMEOUT = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::TIMEOUT')
-    end.new.freeze
-
-    # Result of operation that may time out
-    class Result
-      include AbstractType, Adamantium::Flat
-
-      # Test if take resulted in a timeout
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def timeout?
-        instance_of?(Timeout)
-      end
-
-      abstract_method :value
-
-      # Instance returned on timeouts
-      class Timeout < self
-        include Equalizer.new
-
-        INSTANCE = new
-
-        # Construct new object
-        #
-        # @return [Timeout]
-        def self.new
-          INSTANCE
-        end
-      end # Timeout
-
-      # Instance returned without timeouts
-      class Value < self
-        include Concord::Public.new(:value)
-      end # Value
-    end # Result
-
-    private_constant(*constants(false))
-
-    # Initialize object
-    #
-    # @param [Object] value
-    #   the initial value
-    #
-    # @return [undefined]
-    def initialize(condition_variable:, mutex:, value: EMPTY)
-      @full  = condition_variable.new
-      @mutex = mutex.new
-      @value = value
-    end
-
-    # Take value from mvar, block on empty
-    #
-    # @return [Object]
-    def take
-      synchronize do
-        wait_full
-        perform_take
-      end
-    end
-
-    # Take value from mvar, with timeout
-    #
-    # @param [Float] Timeout
-    #
-    # @return [Result::Timeout]
-    #   in case take resulted in a timeout
-    #
-    # @return [Result::Value]
-    #   in case take resulted in a value
-    def take_timeout(timeout)
-      synchronize do
-        if wait_timeout(@full, timeout, &method(:full?))
-          Result::Timeout.new
-        else
-          Result::Value.new(perform_take)
-        end
-      end
-    end
-
-    # Read value from variable
-    #
-    # @return [Object]
-    #   the contents of the mvar
-    def read
-      synchronize do
-        wait_full
-        @value
-      end
-    end
-
-    # Try put value into the variable, non blocking
-    #
-    # @param [Object] value
-    #
-    # @return [self]
-    def try_put(value)
-      synchronize do
-        perform_put(value) if empty?
-      end
-
-      self
-    end
-
-    # Execute block with value, blocking
-    #
-    # @yield [Object]
-    #
-    # @return [Object]
-    #   the blocks return value
-    def with
-      synchronize do
-        wait_full
-        yield @value
-      end
-    end
-
-  private
-
-    # Perform the put
-    #
-    # @param [Object] value
-    def perform_put(value)
-      (@value = value).tap { @full.signal }
-    end
-
-    # Execute block under mutex
-    #
-    # @return [self]
-    def synchronize(&block)
-      @mutex.synchronize(&block)
-    end
-
-    # Wait for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [undefined]
-    def wait(event)
-      event.wait(@mutex) until yield
-    end
-
-    # Wait with timeout for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [Boolean]
-    #   if wait was terminated due a timeout
-    #
-    # @return [undefined]
-    #   otherwise
-    def wait_timeout(event, timeout)
-      loop do
-        break true if timeout <= 0
-        break if yield
-        timeout -= Timer.elapsed { event.wait(@mutex, timeout) }
-      end
-    end
-
-    # Wait till mvar is full
-    #
-    # @return [undefined]
-    def wait_full
-      wait(@full, &method(:full?))
-    end
-
-    # Test if state is full
-    #
-    # @return [Boolean]
-    def full?
-      !empty?
-    end
-
-    # Test if state is empty
-    #
-    # @return [Boolean]
-    def empty?
-      @value.equal?(EMPTY)
-    end
-
-    # Shared variable that can be written at most once
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class IVar < self
-
-      # Exception raised on ivar errors
-      class Error < RuntimeError; end
-
-      # Put valie into the mvar, raises if already full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      #
-      # @raise Error
-      #   if already full
-      def put(value)
-        synchronize do
-          fail Error, 'is immutable' if full?
-          perform_put(value)
-        end
-
-        self
-      end
-
-    private
-
-      # Perform take operation
-      #
-      # @return [Object]
-      def perform_take
-        @value
-      end
-    end # IVar
-
-    # Shared variable that can be written multiple times
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class MVar < self
-
-      # Initialize object
-      #
-      # @param [Object] value
-      #   the initial value
-      #
-      # @return [undefined]
-      def initialize(condition_variable:, mutex:, value: EMPTY)
-        super
-        @empty = condition_variable.new
-      end
-
-      # Put value into mvar, block on full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      def put(value)
-        synchronize do
-          wait(@empty, &method(:empty?))
-          perform_put(value)
-        end
-
-        self
-      end
-
-      # Modify mvar
-      #
-      # @return [Object]
-      def modify
-        synchronize do
-          wait_full
-          perform_put(yield(@value))
-        end
-      end
-
-    private
-
-      # Empty the mvar
-      #
-      # @return [Object]
-      def perform_take
-        @value.tap do
-          @value = EMPTY
-          @empty.signal
-        end
-      end
-    end # MVar
-  end # Variable
-end # Mutant