mini_kraken 0.1.05 → 0.1.10

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,151 +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
-
-=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
-      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/goal.rb

@@ -3,8 +3,10 @@
 require_relative 'environment'
 
 module MiniKraken
+  require_relative 'goal_arg'
+
   module Core
-    class Goal
+    class Goal < GoalArg
       # @return [Relation] The relation corresponding to this goal
       attr_reader :relation
 
@@ -35,7 +37,7 @@ module MiniKraken
 
         prefix = 'Invalid goal argument '
         args.each do |actl|
-          raise StandardError, prefix + actl.to_s unless actl.kind_of?(Term)
+          raise StandardError, prefix + actl.to_s unless actl.kind_of?(GoalArg)
         end
 
         args.dup

data/lib/mini_kraken/core/goal_arg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # The generalization of any iem that can be
+    # passed as arugement to a goal.
+    class GoalArg
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/goal_relation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'relation'
+
+module MiniKraken
+  module Core
+    # A specialization of a relation that accepts only goal(s)
+    # as its arguments.
+    class GoalRelation < Relation
+      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/outcome.rb

@@ -2,36 +2,52 @@
 
 require_relative 'vocabulary'
 
-module MiniKraken
-  module Core
-    class Outcome
-      include Vocabulary # Use mix-in module
+unless MiniKraken::Core.constants(false).include? :Outcome
+  module MiniKraken
+    module Core
+      class Outcome
+        include Vocabulary # Use mix-in module
+
+        # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
+        attr_reader :resultant
+
+        def initialize(aResult, aParent = nil)
+          init_vocabulary(aParent)
+          @resultant = aResult
+        end
 
-      # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
-      attr_reader :resultant
+        def self.failure(aParent = nil)
+          new(:"#u", aParent)
+        end
 
-      def initialize(aResult, aParent = nil)
-        init_vocabulary(aParent)
-        @resultant = aResult
-      end
+        def self.success(aParent = nil)
+          new(:"#s", aParent)
+        end
 
-      def successful?
-        resultant == :"#s"
-      end
+        def successful?
+          resultant == :"#s"
+        end
 
-      def ==(other)
-        are_equal = false
+        def ==(other)
+          are_equal = false
 
-        if resultant == other.resultant && parent == other.parent &&
-           associations == other.associations
-          are_equal = true
+          if resultant == other.resultant && parent == other.parent &&
+             associations == other.associations
+            are_equal = true
+          end
+
+          are_equal
         end
 
-        are_equal
-      end
-    end # class
+        protected
+
+        def introspect
+          ", @resultant=#{resultant}"
+        end
+      end # class
 
-    Failure = Outcome.new(:"#u")
-    BasicSuccess = Outcome.new(:"#s")
+      Failure = Outcome.new(:"#u")
+      BasicSuccess = Outcome.new(:"#s")
+    end # module
   end # module
-end # module
+end # defined