mini_kraken 0.1.03 → 0.1.08

data/lib/mini_kraken/core/cons_cell.rb

@@ -1,44 +1,54 @@
+# frozen_string_literal: true
+
 require_relative 'composite_term'
 
-module MiniKraken
-  module Core
-    class ConsCell < CompositeTerm
-      attr_reader :car
-      attr_reader :cdr
-
-      def initialize(obj1, obj2 = nil)
-        @car = obj1
-        @cdr = obj2
-      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
-    end # class
-
-    # Constant representing the null (empty) list.
-    NullList = ConsCell.new(nil, nil).freeze
+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)
+          @car = obj1
+          @cdr = obj2
+        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
+
+        def append(another)
+          @cdr = another
+        end
+      end # class
+
+      # Constant representing the null (empty) list.
+      NullList = ConsCell.new(nil, nil).freeze
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/designation.rb

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

@@ -0,0 +1,71 @@
+# 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? :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/duck_fiber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'outcome'
 
 module MiniKraken
@@ -28,13 +30,13 @@ module MiniKraken
           return nil
         end
       end
-      
+
       def valid_outcome(outcomeKind)
         case outcomeKind
           when :failure
             Failure
           when :success
-            BasicSuccess
+            Outcome.new(:"#s")
           else
             raise StandardError, "Unknonw outcome kind #{outcomeKind}"
         end

data/lib/mini_kraken/core/environment.rb

@@ -1,17 +1,26 @@
+# frozen_string_literal: true
+
+require 'set'
 require_relative 'vocabulary'
 
 module MiniKraken
   module Core
     class Environment
-      include Vocabulary  # Use mix-in module
+      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]
@@ -22,6 +31,13 @@ module MiniKraken
           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.
@@ -31,23 +47,21 @@ module MiniKraken
         # Rollout associations from hierarchy
         walker = descendent.ancestor_walker
         begin
-          env = walker.resume
+          env = walker.next
           break if env.nil?
-          env.do_propagate(descendent) if env.kind_of?(Environment) 
+
+          env.do_propagate(descendent) if env.kind_of?(Environment)
         end until env.equal?(self)
       end
 
-      # Move associations from descendent outcome object
+      # Roll up associations from descendent outcome object
+      # @param descendent [Outcome]
       def do_propagate(descendent)
-        return unless descendent.successful? 
+        return unless descendent.successful?
 
         vars.each_key do |var_name|
           assocs = descendent[var_name]
-          assocs.each do |assoc|
-            own = self[var_name]
-            add_assoc(assoc) unless assoc.equal?(own)
-          end
-          descendent.associations.delete(var_name) unless assocs.empty?
+          move_assocs(var_name, descendent)
         end
       end
 
@@ -56,4 +70,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/equals.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require_relative 'binary_relation'
 # require_relative 'any_value'
@@ -5,212 +7,149 @@ require_relative 'duck_fiber'
 require_relative 'variable'
 require_relative 'variable_ref'
 
-module MiniKraken
-  module Core
-    # equals tries to unify two terms
-    class Equals < BinaryRelation
-      include Singleton
+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
+        def initialize
+          super('equals', '==')
+        end
 
-=begin
-    double data flow:
-      A goal has actual arguments
-      When its corresponding relation is invoked
-      this one will return two things: (a success, the bindings/constraints
-      resulting from the relation)
-      the bindings/constraints can be undone if enclosing fails, otherwise
-      the bindings/constraints are rolled up.
-=end
-=begin
-      def unify(aGoal, vars)
-        arg1, arg2 = aGoal.actuals
-        arg_kinds = [arg1.kind_of?(VariableRef), arg2.kind_of?(VariableRef)]
-        case arg_kinds
-        when [false, false]
-          if arg1.eql?(arg2)
-            result = Outcome.new(:"#s", [])
-          else
-            result = Failure
-          end
-        when [false, true]
-          if arg2.fresh?
-            arg2.bind_to(arg1)
-            result = Outcome.new(:"#s", [arg1])
-          else
-            if arg2.value.eql?(arg1)
-              result = Outcome.new(:"#s", [arg1])
-            else
-              result = Failure
-            end
-          end
-        when [true, false]
-          if arg1.fresh?
-            arg1.bind_to(arg2)
-            result = Outcome.new(:"#s", [arg2])
-          else
-            if arg1.value.eql?(arg2)
-              result = Outcome.new(:"#s", [arg2])
-            else
-              result = Failure
-            end
-          end
-        when [true, true]
-          case [arg1.fresh?, arg2.fresh?]
-          when [false, false]
-            if arg1.value == arg2.value
-              result = Outcome.new(:"#s", [arg1.value])
+        # @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.new(:"#s", anEnv)
             else
               result = Failure
             end
-          when [false, true]
-            arg2.bind_to(arg1)
-            result = Outcome.new(:"#s", arg1.value)
-          when [true, false]
-            arg1.bind_to(arg2)
-            result = Outcome.new(:"#s", arg2.value)
-          when [true, true]
-            if arg1.variable.name == arg2.variable.name
-              result = Outcome.new(:"#s", [])
-            else
-              # TODO: add constraints
-              result = Outcome.new(:"#s", [])
-            end
+            return result
           end
-        end
+          new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
+          result = do_unification(new_arg1, new_arg2, anEnv)
+          # anEnv.merge(result) if result.successful? && !result.association.empty?
 
-        result
-      end
-=end
-
-    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.new(:"#s", anEnv)
-        else
-          result = Failure
+          result
         end
-        return result
-      end
-      new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-      result = do_unification(new_arg1, new_arg2, anEnv)
-      # anEnv.merge(result) if result.successful? && !result.association.empty?
 
-      result
-    end
+        private
 
-    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.new(:"#s", anEnv) if arg1.equal?(arg2)
 
-    # 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.new(:"#s", anEnv) if arg1.equal?(arg2)
-      result = Outcome.new(:"#u", anEnv) # default case
+          result = Outcome.new(:"#u", anEnv) # default case
 
-      if arg1.kind_of?(AtomicTerm)
-        result = BasicSuccess 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.new(:"#s", anEnv)
-            arg1.associate(arg2, result)
-          else
-            result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
-          end
-        elsif arg2.kind_of?(CompositeTerm)
-          if arg1_freshness.degree == :fresh
-            result = Outcome.new(:"#s", 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.new(:"#s", anEnv) 
-            if arg1.var_name != arg2.var_name
-              arg1.associate(arg2, result) 
-              arg2.associate(arg1, result)
+          if arg1.kind_of?(AtomicTerm)
+            result = BasicSuccess 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.new(:"#s", anEnv)
+                arg1.associate(arg2, result)
+              else
+                result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+              end
+            elsif arg2.kind_of?(CompositeTerm)
+              if arg1_freshness.degree == :fresh
+                result = Outcome.new(:"#s", 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.new(:"#s", anEnv)
+                if arg1.var_name != arg2.var_name
+                  arg1.associate(arg2, result)
+                  arg2.associate(arg1, result)
+                end
+              else
+                raise StandardError, "Unsupported freshness combination #{freshness}"
+              end
+            else
+              arg_kinds = [arg1.class, arg2.class]
+              raise StandardError, "Unsupported combination #{arg_kinds}"
             end
-          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
+          result
+        end
 
-  # @return [Freshness]
-    def unify_composite_terms(arg1, arg2, anEnv)
-      # require 'debug'
-      result = Outcome.new(:"#u", anEnv)
-      children1 = arg1.children
-      children2 = arg2.children
+        # @return [Freshness]
+        def unify_composite_terms(arg1, arg2, anEnv)
+          # require 'debug'
+          result = Outcome.new(:"#u", 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.new(:"#s", anEnv)
-          associations = subresults.reduce(memo) do |sub_total, outcome|
-            sub_total.merge(outcome)
-            sub_total
+          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.new(:"#s", anEnv)
+              associations = subresults.reduce(memo) do |sub_total, outcome|
+                sub_total.merge(outcome)
+                sub_total
+              end
+              result = memo
+            end
           end
-          result = memo
-        end
-      end
-
-      result
-    end
 
-    end # class
+          result
+        end
+      end # class
+      
+      Equals.instance.freeze
+    end # module
   end # module
-end # module
+end # unless