mini_kraken 0.2.03 → 0.3.03

data/lib/mini_kraken/core/atomic_term.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'term'
-require_relative 'freshness'
-
-module MiniKraken
-  module Core
-    # An atomic term is an elementary Minikraken term that cannot be
-    # decomposed into simpler MiniKraken data value(s).
-    class AtomicTerm < Term
-      # @return [Object] Internal representation of a MiniKraken data value
-      attr_reader :value
-
-      # @param aValue [Object] Ruby representation of MiniKraken data value
-      def initialize(aValue)
-        super()
-        @value = aValue
-        @value.freeze
-      end
-
-      # An atomic term is by definition a ground term: since it doesn't contain
-      # any bound variable (in Prolog sense).
-      # @param _env [Vocabulary]
-      # @return [Freshness]
-      def freshness(_env)
-        Freshness.new(:ground, self)
-      end
-
-      # An atomic term is a ground term: by definition it doesn't contain
-      # any fresh variable.
-      # @param _env [Vocabulary]
-      # @return [FalseClass]
-      def fresh?(_env)
-        false
-      end
-
-      # An atomic term is a ground term: by definition it doesn't contain
-      # any fresh variable.
-      # @param _env [Vocabulary]
-      # @return [TrueClass]
-      def ground?(_env)
-        true
-      end
-
-      # @return [AtomicTerm]
-      def quote(_env)
-        self
-      end
-
-      # Data equality testing
-      # @return [Boolean]
-      def ==(other)
-        if other.respond_to?(:value)
-          value == other.value
-        else
-          value == other
-        end
-      end
-
-      # Type and data equality testing
-      # @return [Boolean]
-      def eql?(other)
-        (self.class == other.class) && value.eql?(other.value)
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/base_arg.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module MiniKraken
-  module Core
-    # Abstract class that is a generalization for goal actual arguments or
-    # for arguments of goal template.
-    class BaseArg
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/binary_relation.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'relation'
-require_relative 'composite_term'
-
-module MiniKraken
-  module Core
-    class BinaryRelation < Relation
-      # @param aName [String] Name of the relation.
-      # @param alternateName [String, NilClass] Alternative name (optional).
-      def initialize(aName, alternateName = nil)
-        super(aName, alternateName)
-        freeze
-      end
-
-      # Number of arguments for the relation.
-      # @return [Integer]
-      def arity
-        2
-      end
-
-      protected
-
-      # table: Commute
-      # |arg1                | arg2               | arg2.ground? || Commute |
-      # | isa? Atomic        | isa? Atomic        | dont_care    || Yes     |
-      # | isa? Atomic        | isa? CompositeTerm | dont_care    || Yes     |
-      # | isa? Atomic        | isa? VariableRef   | dont_care    || Yes     |
-      # | isa? CompositeTerm | isa? Atomic        | true         || No      |
-      # | isa? CompositeTerm | isa? CompositeTerm | false        || Yes     |
-      # | isa? CompositeTerm | isa? CompositeTerm | true         || No      |
-      # | isa? CompositeTerm | isa? VariableRef   | dont_care    || Yes     |
-      # | isa? VariableRef   | isa? Atomic        | dont_care    || No      |
-      # | isa? VariableRef   | isa? CompositeTerm | dont_care    || No      |
-      # | isa? VariableRef   | isa? VariableRef   | false        || Yes     |
-      # | isa? VariableRef   | isa? VariableRef   | true         || No      |
-      def commute_cond(arg1, arg2, env)
-        commuting = true
-        arg2_is_var_ref = arg2.kind_of?(VariableRef)
-
-        if arg1.kind_of?(CompositeTerm)
-          if arg2_is_var_ref
-            commuting = true
-          else
-            commuting = !arg2.ground?(env)
-          end
-        elsif arg1.kind_of?(VariableRef)
-          if arg2_is_var_ref
-            commuting = !arg2.ground?(env)
-          else
-            commuting = false
-          end
-        end
-
-        if commuting
-          [arg2, arg1]
-        else
-          [arg1, arg2]
-        end
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/composite_goal.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'environment'
-
-module MiniKraken
-  module Core
-    class CompositeGoal
-      # @return [Operator] The operator corresponding to this goal
-      attr_reader :operator
-
-      # @return [Array<Goal>] The child goals (sub-goals)
-      attr_reader :children
-
-      # @param anOperator [Operator] The operator corresponding to this goal
-      # @param theChildren [Array<Goal>] The child goals (sub-goals)
-      def initialize(anOperator, theChildren)
-        @operator = anOperator
-        @children = validated_children(theChildren)
-      end
-
-      # Attempt to achieve the goal for a given context (environment)
-      # @param anEnv [Environment] The context in which the goal take place.
-      # @return [Fiber<Outcome>] A Fiber object that will generate the results.
-      def attain(anEnv)
-        operator.solver_for(children, anEnv)
-      end
-
-      private
-
-      def validated_children(theChildren)
-        my_arity = operator.arity
-        if args.size != my_arity
-          err_msg = "Goal has #{theChildren.size} arguments, expected #{my_arity}"
-          raise StandardError, err_msg
-        end
-
-        prefix = 'Invalid goal argument '
-        theChildren.each do |subg|
-          raise StandardError, prefix + subg.to_s unless subg.kind_of?(Goal)
-        end
-
-        theChildren.dup
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/composite_term.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'term'
-require_relative 'freshness'
-
-module MiniKraken
-  module Core
-    # An composite term is an Minikraken term that can be
-    # decomposed into simpler MiniKraken data value(s).
-    class CompositeTerm < Term
-      # Abstract method (to override). Return the child terms.
-      # @return [Array<Term>]
-      def children
-        raise NotImplementedError, 'This method must re-defined in subclass(es).'
-      end
-
-      # A composite term is fresh when all its members are nil or all non-nil members
-      # are all fresh
-      # A composite term is bound when it is not fresh and not ground
-      # A composite term is a ground term when all its non-nil members are ground.
-      # @param _env [Vocabulary]
-      # @return [Freshness]
-      def freshness(_env)
-         env.freshness_composite(self)
-      end
-
-      # @param env [Environment]
-      # @return [Boolean]
-      def fresh?(env)
-        env.fresh_value?(self)
-      end
-
-      # A composite is ground if all its children are ground
-      def ground?(anEnv)
-        children.all? do |child|
-          child.nil? || child.ground?(anEnv)
-        end
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/conde.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'conj2'
-require_relative 'duck_fiber'
-require_relative 'fail'
-require_relative 'goal'
-require_relative 'goal_relation'
-require_relative 'outcome'
-
-unless MiniKraken::Core.constants(false).include? :Conde
-  module MiniKraken
-    module Core
-      # A polyadic relation (i.e. it can takes an arbitrary number of argumentt)
-      # that behaves as the disjunction of its arguments.
-      # It succeeds if at least one of its goal arguments succeeds.
-      class Conde < GoalRelation
-        include Singleton
-
-        def initialize
-          super('conde', nil)
-        end
-
-        # A relation is polyadic when it accepts an arbitrary number of arguments.
-        # @return [TrueClass]
-        def polyadic?
-          true
-        end
-
-        # @param actuals [Array<Term>] A two-elements array
-        # @param anEnv [Vocabulary] A vocabulary object
-        # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
-        def solver_for(actuals, anEnv)
-          args = *validated_args(actuals)
-          Fiber.new { cond(args, anEnv) }
-        end
-
-        # Yields [Outcome, NilClass] result of the disjunction
-        # @param goals [Array<Goal>] Array of goals
-        # @param voc [Vocabulary] A vocabulary object
-        def cond(goals, voc)
-          # require 'debug'
-          success = false
-
-          goals.each do |g|
-            fiber = nil
-
-            case g
-              when Core::Goal
-                fiber = g.attain(voc)
-              when Core::Environment
-                fiber = g.attain(voc)
-              when Array
-                conjunct = conjunction(g)
-                fiber = conjunct.attain(voc)
-              when Core::ConsCell
-                goal_array = to_goal_array(g)
-                conjunct = conjunction(goal_array)
-                fiber = conjunct.attain(voc)
-            end
-            loop do
-              outcome = fiber.resume
-              break unless outcome
-
-              outcome.parent = voc unless outcome.parent
-              if outcome.success?
-                success = true
-                Fiber.yield outcome
-                outcome.clear
-              end
-            end
-          end
-
-          Fiber.yield Outcome.new(:"#u", voc) unless success
-          Fiber.yield nil
-        end
-
-        private
-
-        def validated_args(actuals)
-          result = []
-
-          actuals.each do |arg|
-            case arg
-              when Core::Goal
-                result << arg
-
-              when Core::Environment
-                result << arg
-
-              when Array
-                result << validated_args(arg)
-
-              else
-                prefix = "#{name} expects goal as argument, found a "
-                raise StandardError, prefix + "'#{arg.class}'"
-            end
-          end
-
-          result
-        end
-
-        def conjunction(goal_array)
-          result = nil
-
-          loop do
-            conjunctions = []
-            goal_array.each_slice(2) do |uno_duo|
-              if uno_duo.size == 2
-                conjunctions << Core::Goal.new(Core::Conj2.instance, uno_duo)
-              else
-                conjunctions << uno_duo[0]
-              end
-            end
-            if conjunctions.size == 1
-              result = conjunctions[0]
-              break
-            end
-            goal_array = conjunctions
-          end
-
-          result
-        end
-
-        def to_goal_array(aCons)
-          array = []
-          curr_node = aCons
-          loop do
-            array << curr_node.car if curr_node.car.kind_of?(Core::Goal)
-            break unless curr_node.cdr
-            break unless curr_node.car.kind_of?(Core::Goal)
-
-            curr_node = curr_node.cdr
-          end
-
-          array
-        end
-      end # class
-
-      Conde.instance.freeze
-    end # module
-  end # module
-end # unless

data/lib/mini_kraken/core/conj2.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'duck_fiber'
-require_relative 'goal'
-require_relative 'goal_relation'
-require_relative 'outcome'
-
-unless MiniKraken::Core.constants(false).include? :Conj2
-  module MiniKraken
-    module Core
-      # The conjunction is a relation that accepts only goal(s) as its two
-      # arguments. It succeeds if and only both its goal arguments succeeds.
-      class Conj2 < GoalRelation
-        include Singleton
-
-        def initialize
-          super('conj2', nil)
-        end
-
-        # @param actuals [Array<Term>] A two-elements array
-        # @param anEnv [Vocabulary] A vocabulary object
-        # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
-        def solver_for(actuals, anEnv)
-          g1, g2 = *validated_args(actuals)
-          Fiber.new { conjunction(g1, g2, anEnv) }
-        end
-
-        # Yields [Outcome, NilClass] result of the conjunction
-        # @param g1 [Goal] First goal argument
-        # @param g2 [Goal] Second goal argument
-        # @param voc [Vocabulary] A vocabulary object
-        def conjunction(g1, g2, voc)
-          # require 'debug'
-          if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
-            Fiber.yield Outcome.new(:"#u", voc)
-          else
-            outcome1 = nil
-            outcome2 = nil
-            f1 = g1.attain(voc)
-            loop do
-              outcome1 = f1.resume
-              break unless outcome1
-
-              outcome1.parent = voc unless outcome1.parent
-              if outcome1.success?
-                f2 = g2.attain(outcome1)
-                loop do
-                  outcome2 = f2.resume
-                  break unless outcome2
-
-                  outcome2.parent = voc unless outcome2.parent
-                  if outcome2.success?
-                    res = Outcome.new(:"#s", voc)
-                    res.merge(outcome1)
-                    res.merge(outcome2)
-                    Fiber.yield res
-                  else
-                    Fiber.yield outcome2
-                  end
-                  outcome2.clear
-                end
-              else
-                Fiber.yield outcome1
-              end
-              if outcome1.success? && (outcome2&.success? || outcome2.nil?)
-                voc.clear
-              end
-            end
-          end
-
-          Fiber.yield nil
-        end
-      end # class
-
-      Conj2.instance.freeze
-    end # module
-  end # module
-end # unless