mini_kraken 0.2.02 → 0.3.02

data/lib/mini_kraken/core/cons_cell.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'composite_term'
-
-unless MiniKraken::Core.constants(false).include? :ConsCell
-  module MiniKraken
-    module Core
-      class ConsCell < CompositeTerm
-        attr_reader :car
-        attr_reader :cdr
-
-        def initialize(obj1, obj2 = nil)
-          super()
-          @car = obj1
-          if obj2.kind_of?(ConsCell) && obj2.null?
-            @cdr = nil
-          else
-            @cdr = obj2
-          end
-        end
-
-        def children
-          [car, cdr]
-        end
-
-        # Return true if it is an empty list, otherwise false.
-        # A list is empty, when both car and cdr fields are nil.
-        def null?
-          car.nil? && cdr.nil?
-        end
-
-        def ==(other)
-          return false unless other.respond_to?(:car)
-
-          (car == other.car) && (cdr == other.cdr)
-        end
-
-        def eql?(other)
-          (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
-        end
-
-        def quote(anEnv)
-          return self if null?
-
-          new_car = car.nil? ? nil : car.quote(anEnv)
-          new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)
-          ConsCell.new(new_car, new_cdr)
-        end
-
-        # Use the list notation from Lisp as a text representation.
-        def to_s
-          return '()' if null?
-
-          "(#{pair_to_s})"
-        end
-
-        def append(another)
-          @cdr = another
-        end
-
-        protected
-
-        def pair_to_s
-          result = +car.to_s
-          if cdr
-            result << ' '
-            if cdr.kind_of?(ConsCell)
-              result << cdr.pair_to_s
-            else
-              result << ". #{cdr}"
-            end
-          end
-
-          result
-        end
-      end # class
-
-      # Constant representing the null (empty) list.
-      NullList = ConsCell.new(nil, nil).freeze
-    end # module
-  end # module
-end # defined

data/lib/mini_kraken/core/def_relation.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'relation'
-
-module MiniKraken
-  module Core
-    # A relation that is parametrized with generic formal arguments
-    # and a goal template expression.
-    class DefRelation < Relation
-      # @return [Array<FormalArg>] formal arguments of this DefRelation
-      attr_reader :formals
-
-      # @return [GoalTemplate] goal template
-      attr_reader :goal_template
-
-      # @param aName [String] name of def relation
-      # @param aGoalTemplate [GoalTemplate]
-      def initialize(aName, aGoalTemplate, theFormals, alternateName = nil)
-        super(aName, alternateName)
-        @formals = validated_formals(theFormals)
-        @goal_template = validated_goal_template(aGoalTemplate)
-        freeze
-      end
-
-      # Number of arguments for the relation.
-      # @return [Integer]
-      def arity
-        formals.size
-      end
-
-      # @param actuals [Array<Term>] A two-elements array
-      # @param anEnv [Vocabulary] A vocabulary object
-      # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
-      def solver_for(actuals, anEnv)
-        goal = goal_template.instantiate(formals, actuals)
-        goal.attain(anEnv)
-      end
-
-      private
-
-      def validated_formals(theFormals)
-        theFormals
-      end
-
-      def validated_goal_template(aGoalTemplate)
-        aGoalTemplate
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/designation.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module MiniKraken
-  module Core
-    # Wordnet definition: Identifying word or words by which someone or
-    # something is called and classified or distinguished from others.
-    # Mix-in module that contains factored code for managing named entries
-    # in a vocabulary such as variables and variable references.
-    module Designation
-      # @return [String] User-defined name of the variable
-      attr_reader :name
-
-      def init_designation(aName)
-        @name = valid_name(aName)
-      end
-
-      # @param voc [Vocabulary]
-      # @return [Freshness]
-      def freshness(voc)
-        voc.freshness_ref(self)
-      end
-
-      # @param voc [Vocabulary]
-      # @return [Boolean]
-      def fresh?(voc)
-        frsh = freshness(voc)
-        frsh.degree == :fresh || frsh.degree == :bound
-      end
-
-      # @param voc [Vocabulary]
-      # @return [Boolean]
-      def bound?(voc)
-        frsh = freshness(voc)
-        frsh.degree == :bound
-      end
-
-      # @param voc [Vocabulary]
-      # @return [Boolean]
-      def ground?(voc)
-        frsh = freshness(voc)
-        frsh.degree == :bound
-      end
-
-      private
-
-      def valid_name(aName)
-        if aName.empty?
-          raise StandardError, 'Variable name may not be empty.'
-        end
-
-        aName
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/disj2.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'duck_fiber'
-require_relative 'fail'
-require_relative 'goal'
-require_relative 'goal_relation'
-require_relative 'outcome'
-
-unless MiniKraken::Core.constants(false).include? :Disj2
-  module MiniKraken
-    module Core
-      # The disjunction is a relation that accepts only goal(s) as its two
-      # arguments. It succeeds if at least one of its goal arguments succeeds.
-      class Disj2 < GoalRelation
-        include Singleton
-
-        def initialize
-          super('disj2', 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 { disjunction(g1, g2, anEnv) }
-        end
-
-        # Yields [Outcome, NilClass] result of the disjunction
-        # @param g1 [Goal] First goal argument
-        # @param g2 [Goal] Second goal argument
-        # @param voc [Vocabulary] A vocabulary object
-        def disjunction(g1, g2, voc)
-          # require 'debug'
-          outcome1 = nil
-          outcome2 = nil
-          if g1.relation.kind_of?(Fail) && g2.relation.kind_of?(Fail)
-            Fiber.yield Outcome.new(:"#u", voc)
-          else
-            f1 = g1.attain(voc)
-            loop do
-              outcome1 = f1.resume
-              break unless outcome1
-
-              outcome1.parent = voc unless outcome1.parent
-              if outcome1.successful?
-                Fiber.yield outcome1
-                outcome1.clear
-              end
-            end
-            f2 = g2.attain(voc)
-            loop do
-              outcome2 = f2.resume
-              break unless outcome2
-
-              outcome2.parent = voc unless outcome2.parent
-              if outcome2.successful?
-                Fiber.yield outcome2
-                outcome2.clear
-              end
-            end
-          end
-
-          Fiber.yield nil
-        end
-      end # class
-
-      Disj2.instance.freeze
-    end # module
-  end # module
-end # unless

data/lib/mini_kraken/core/environment.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require_relative 'vocabulary'
-
-module MiniKraken
-  module Core
-    class Environment
-      include Vocabulary # Use mix-in module
-
-      # Mapping from user-defined name to Variable instance
-      # @return [Hash] Pairs of the kind {String => Variable}
-      attr_reader :vars
-
-      # Mapping from internal name to user-defined name(s)
-      # @return [Hash] Pairs of the kind {String => Set<String>}
-      attr_reader :ivars
-
-      # @param aParent [Environment, NilClass] Parent environment to this one.
-      def initialize(aParent = nil)
-        init_vocabulary(aParent)
-        @vars = {}
-        @ivars = {}
-      end
-
-      # @param aVariable [Variable]
-      def add_var(aVariable)
-        name = aVariable.name
-        if vars.include?(name)
-          err_msg = "Variable with name '#{name}' already exists."
-          raise StandardError, err_msg
-        end
-        vars[name] = aVariable
-        i_name = aVariable.i_name
-        if ivars.include?(i_name)
-          set = ivars[i_name]
-          set.add(name)
-        else
-          ivars[i_name] = Set.new([i_name])
-        end
-      end
-
-      # Handler for the event: an outcome has been produced.
-      # Can be overridden in other to propagate associations from child
-      # @param descendent [Outcome]
-      def propagate(descendent)
-        # Rollout associations from hierarchy
-        walker = descendent.ancestor_walker
-        begin
-          env = walker.next
-          break if env.nil?
-
-          env.do_propagate(descendent) if env.kind_of?(Environment)
-        end until env.equal?(self)
-      end
-
-      # Roll up associations from descendent outcome object
-      # @param descendent [Outcome]
-      def do_propagate(descendent)
-        return unless descendent.successful?
-
-        vars.each_key do |var_name|
-          # assocs = descendent[var_name]
-          move_assocs(var_name, descendent)
-        end
-      end
-
-      def merge_vars(descendent)
-        descendent.vars.each_value { |vr| add_var(vr) }
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/equals.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'binary_relation'
-# require_relative 'any_value'
-require_relative 'duck_fiber'
-require_relative 'variable'
-require_relative 'variable_ref'
-
-unless MiniKraken::Core.constants(false).include? :Equals
-  module MiniKraken
-    module Core
-      # equals tries to unify two terms
-      class Equals < BinaryRelation
-        include Singleton
-
-        def initialize
-          super('equals', '==')
-        end
-
-        # @param actuals [Array<Term>] A two-elements array
-        # @param anEnv [Vocabulary] A vocabulary object
-        # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
-        def solver_for(actuals, anEnv)
-          arg1, arg2 = *actuals
-          DuckFiber.new(:custom) { unification(arg1, arg2, anEnv) }
-        end
-
-        def unification(arg1, arg2, anEnv)
-          arg1_nil = arg1.nil?
-          arg2_nil = arg2.nil?
-          if arg1_nil || arg2_nil
-            if arg1_nil && arg2_nil
-              result = Outcome.success(anEnv)
-            else
-              result = Outcome.failure(anEnv)
-            end
-            return result
-          end
-          new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-          do_unification(new_arg1, new_arg2, anEnv)
-        end
-
-        private
-
-
-        # table: Unification
-        # | arg1               | arg2               | Criterion                                 || Unification              |
-        # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
-        # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is false                    || { "u", [] }              |
-        # | isa? CompositeTerm | isa? Atomic        | dont_care                                 || { "u", [] }              |
-        # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.car, arg2.car) => "s"    || { "s", [bindings*] }     |
-        # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.cdr, arg2.cdr) => "u"    || { "u", [] )              |             |
-        # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
-        # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
-        # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-        # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-        # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
-        # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
-        # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-        # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
-        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
-        # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-        # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
-        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [false, false]||                          |
-        # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-        # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
-        def do_unification(arg1, arg2, anEnv)
-          # require 'debug'
-          return Outcome.success(anEnv) if arg1.equal?(arg2)
-
-          result = Outcome.failure(anEnv) # default case
-
-          if arg1.kind_of?(AtomicTerm)
-            result = Outcome.success(anEnv) if arg1.eql?(arg2)
-          elsif arg1.kind_of?(CompositeTerm)
-            if arg2.kind_of?(CompositeTerm) # AtomicTerm is default case => fail
-              result = unify_composite_terms(arg1, arg2, anEnv)
-            end
-          elsif arg1.kind_of?(VariableRef)
-            arg1_freshness = arg1.freshness(anEnv)
-            if arg2.kind_of?(AtomicTerm)
-              if arg1_freshness.degree == :fresh
-                result = Outcome.success(anEnv)
-                arg1.associate(arg2, result)
-              else
-                result = Outcome.success(anEnv) if arg1.value(anEnv).eql?(arg2)
-              end
-            elsif arg2.kind_of?(CompositeTerm)
-              if arg1_freshness.degree == :fresh
-                result = Outcome.success(anEnv)
-                arg1.associate(arg2, result)
-              else
-                # Ground case...
-                result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
-              end
-            elsif arg2.kind_of?(VariableRef)
-              freshness = [arg1.fresh?(anEnv), arg2.fresh?(anEnv)]
-              case freshness
-              when [false, false] # TODO: confirm this...
-                result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
-              when [true, true]
-                result = Outcome.success(anEnv)
-                if arg1.var_name != arg2.var_name
-                  arg1.associate(arg2, result)
-                  arg2.associate(arg1, result)
-                end
-              when [true, false]
-                result = Outcome.success(anEnv)
-                arg1.associate(arg2, result)
-              else
-                raise StandardError, "Unsupported freshness combination #{freshness}"
-              end
-            else
-              arg_kinds = [arg1.class, arg2.class]
-              raise StandardError, "Unsupported combination #{arg_kinds}"
-            end
-          end
-
-          result
-        end
-
-        # @return [Freshness]
-        def unify_composite_terms(arg1, arg2, anEnv)
-          # require 'debug'
-          result = Outcome.failure(anEnv)
-          children1 = arg1.children
-          children2 = arg2.children
-
-          if children1.size == children2.size
-            i = 0
-            subresults = children1.map do |child1|
-              child2 = children2[i]
-              i += 1
-              unification(child1, child2, anEnv)
-            end
-            total_success = subresults.all?(&:successful?)
-            if total_success
-              memo = Outcome.success(anEnv)
-              subresults.reduce(memo) do |sub_total, outcome|
-                sub_total.merge(outcome)
-                sub_total
-              end
-              result = memo
-            end
-          end
-
-          result
-        end
-      end # class
-
-      Equals.instance.freeze
-    end # module
-  end # module
-end # unless