mini_kraken 0.1.06 → 0.1.11

data/lib/mini_kraken/core/duck_fiber.rb

@@ -36,7 +36,7 @@ module MiniKraken
           when :failure
             Failure
           when :success
-            BasicSuccess
+            Outcome.new(:"#s")
           else
             raise StandardError, "Unknonw outcome kind #{outcomeKind}"
         end

data/lib/mini_kraken/core/environment.rb

@@ -47,7 +47,7 @@ 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)

data/lib/mini_kraken/core/equals.rb

@@ -7,145 +7,153 @@ 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
-
-      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.new(:"#s", anEnv)
-          else
-            result = Failure
-          end
-          return result
+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
-        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
-
-      # 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
-
-        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)
+
+        # @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.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+              result = Outcome.failure(anEnv)
             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)
+            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
+
+
+        # 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 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
+          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)
-                arg2.associate(arg1, result)
+              else
+                raise StandardError, "Unsupported freshness combination #{freshness}"
               end
             else
-              raise StandardError, "Unsupported freshness combination #{freshness}"
+              arg_kinds = [arg1.class, arg2.class]
+              raise StandardError, "Unsupported combination #{arg_kinds}"
             end
-          else
-            arg_kinds = [arg1.class, arg2.class]
-            raise StandardError, "Unsupported combination #{arg_kinds}"
           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
-
-        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
+        # @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)
+              associations = subresults.reduce(memo) do |sub_total, outcome|
+                sub_total.merge(outcome)
+                sub_total
+              end
+              result = memo
             end
-            result = memo
           end
+
+          result
         end
+      end # class
 
-        result
-      end
-    end # class
+      Equals.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/fail.rb

@@ -4,20 +4,24 @@ require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
-module MiniKraken
-  module Core
-    # A nullary relation that unconditionally always fails.
-    class Fail < NullaryRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Fail
+  module MiniKraken
+    module Core
+      # A nullary relation that unconditionally always fails.
+      class Fail < NullaryRelation
+        include Singleton
 
-      def initialize
-        super('fail', '#u')
-      end
+        def initialize
+          super('fail', '#u')
+        end
 
-      # @return [DuckFiber]
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:failure)
-      end
-    end # class
+        # @return [DuckFiber]
+        def solver_for(_actuals, _env)
+          DuckFiber.new(:failure)
+        end
+      end # class
+
+      Fail.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/formal_arg.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # The generalization of any iem that can be
+    # passed as arugement to a goal.
+    class FormalArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/formal_ref.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A formal reference represents the occurrence of a formal argument name in a
+    # goal template argument list.
+    class FormalRef < BaseArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/goal_arg.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'base_arg'
+
 module MiniKraken
   module Core
-    # The generalization of any iem that can be
-    # passed as arugement to a goal.
-    class GoalArg
+    # The generalization of any item that can be
+    # passed as arugement to a goal object
+    class GoalArg < BaseArg
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/goal_relation.rb

@@ -10,6 +10,19 @@ module MiniKraken
       def arity
         2
       end
+
+      protected
+
+      def validated_args(actuals)
+        actuals.each do |arg|
+          unless arg.kind_of?(Goal)
+            prefix = "#{name} expects goal as argument, found a "
+            raise StandardError, prefix + "'#{arg.class}'"
+          end
+        end
+
+        actuals
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/goal_template.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A meta-goal that is parametrized with generic formal arguments.
+    # The individual goals are instantiated when the formal arguments
+    # are bound to goal arguments
+    class GoalTemplate < BaseArg
+      # @return [Array<BaseArg>}] Arguments of goal template.
+      attr_reader :args
+
+      # @return [Relation] Main relation for the goal template
+      attr_reader :relation
+
+      def initialize(aRelation, theArgs)
+        @relation = validated_relation(aRelation)
+        @args = validated_args(theArgs)
+      end
+
+      # @param formals [Array<FormalArg>] Array of formal arguments
+      # @param actuals [Array<GoalArg>] Array of actual arguments
+      # @return [Goal] instantiate a goal object given the actuals and environment
+      def instantiate(formals, actuals)
+        formals2actuals = {}
+        formals.each_with_index do |frml, i|
+          formals2actuals[frml.name] = actuals[i]
+        end
+
+        do_instantiate(formals2actuals)
+      end
+
+      private
+
+      def validated_relation(aRelation)
+        aRelation
+      end
+
+      def validated_args(theArgs)
+        theArgs
+      end
+
+      def do_instantiate(formals2actuals)
+        goal_args = []
+        args.each do |arg|
+          if arg.kind_of?(FormalRef)
+            goal_args << formals2actuals[arg.name]
+          elsif arg.kind_of?(GoalTemplate)
+            goal_args << arg.send(:do_instantiate, formals2actuals)
+          else
+            goal_args << arg
+          end
+        end
+
+        Goal.new(relation, goal_args)
+      end
+    end # class
+  end # module
+end # module