mini_kraken 0.2.03 → 0.2.04

data/lib/mini_kraken/core/equals.rb

@@ -2,192 +2,190 @@
 
 require 'singleton'
 require_relative 'binary_relation'
-require_relative 'cons_cell_visitor'
+require_relative '../composite/cons_cell_visitor'
 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', '==')
+require_relative 'log_var'
+require_relative 'log_var_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) do
+          outcome = unification(arg1, arg2, anEnv)
+          outcome.prune!
         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) do
-            outcome = unification(arg1, arg2, anEnv)
-            outcome.prune!
+      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
-
-        def unification(arg1, arg2, anEnv)
-          arg1_nil = arg1.nil?
-          arg2_nil = arg2.nil?
-          if arg1_nil || arg2_nil
-            if arg1_nil && arg2_nil
+        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? LogVarRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
+      # | isa? LogVarRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
+      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+      # | isa? LogVarRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
+      # | isa? LogVarRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
+      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+      # | isa? LogVarRef   | isa? LogVarRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
+      # | isa? LogVarRef   | isa? LogVarRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
+      # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
+      # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
+      # | isa? LogVarRef   | isa? LogVarRef   | 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?(Atomic::AtomicTerm)
+          result = Outcome.success(anEnv) if arg1.eql?(arg2)
+        elsif arg1.kind_of?(Composite::CompositeTerm)
+          if arg2.kind_of?(Composite::CompositeTerm) # Atomic::AtomicTerm is default case => fail
+            result = unify_composite_terms(arg1, arg2, anEnv)
+          end
+        elsif arg1.kind_of?(LogVarRef)
+          arg1_freshness = arg1.freshness(anEnv)
+          if arg2.kind_of?(Atomic::AtomicTerm)
+            if arg1_freshness.degree == :fresh
               result = Outcome.success(anEnv)
+              arg1.associate(arg2, result)
             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)
+              result = Outcome.success(anEnv) if arg1.value(anEnv).eql?(arg2)
             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...
-                arg1_associated = arg1_freshness.associated
-                unless arg1_associated.kind_of?(AtomicTerm)
-                  result = unify_composite_terms(arg1_associated, arg2, anEnv)
-                end
+          elsif arg2.kind_of?(Composite::CompositeTerm)
+            if arg1_freshness.degree == :fresh
+              result = Outcome.success(anEnv)
+              arg1.associate(arg2, result)
+            else
+              # Ground case...
+              arg1_associated = arg1_freshness.associated
+              unless arg1_associated.kind_of?(Atomic::AtomicTerm)
+                result = unify_composite_terms(arg1_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)
+            end
+          elsif arg2.kind_of?(LogVarRef)
+            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)
-              else
-                raise StandardError, "Unsupported freshness combination #{freshness}"
+                arg2.associate(arg1, result)
               end
+            when [true, false]
+              result = Outcome.success(anEnv)
+              arg1.associate(arg2, result)
             else
-              arg_kinds = [arg1.class, arg2.class]
-              raise StandardError, "Unsupported combination #{arg_kinds}"
+              raise StandardError, "Unsupported freshness combination #{freshness}"
             end
+          else
+            arg_kinds = [arg1.class, arg2.class]
+            raise StandardError, "Unsupported combination #{arg_kinds}"
           end
-
-          result
         end
 
-        # @param arg1 [ConsCell]
-        # @param arg2 [ConsCell]
-        # @return [Outcome]
-        def unify_composite_terms(arg1, arg2, anEnv)
-          # require 'debug'
-          result = Outcome.success(anEnv)
-          # We'll do parallel iteration
-          visitor1 = ConsCellVisitor.df_visitor(arg1)
-          visitor2 = ConsCellVisitor.df_visitor(arg2)
-          skip_children1 = false
-          skip_children2 = false
-
-          loop do
-            side1, cell1 = visitor1.resume(skip_children1)
-            side2, cell2 = visitor2.resume(skip_children2)
-            if side1 != side2
-              result = Outcome.failure(anEnv)
-            elsif side1 == :stop
-              break
-            else
-              case [cell1.class, cell2.class] # nil, AtomicTerm, ConsCell, VariableRef
-                when [ConsCell, ConsCell]
-                  skip_children1 = false
-                  skip_children2 = false
-                when [ConsCell, VariableRef]
-                  skip_children1 = true
-                  skip_children2 = false
-                  sub_result = unification(cell1, cell2, anEnv)
-                  result = merge_results(result, sub_result)
-                when [VariableRef, ConsCell]
-                  skip_children1 = false
-                  skip_children2 = true
-                  sub_result = do_unification(cell1, cell2, anEnv)
-                  result = merge_results(result, sub_result)
-              else
+        result
+      end
+
+      # @param arg1 [Composite::ConsCell]
+      # @param arg2 [Composite::ConsCell]
+      # @return [Outcome]
+      def unify_composite_terms(arg1, arg2, anEnv)
+        # require 'debug'
+        result = Outcome.success(anEnv)
+        # We'll do parallel iteration
+        visitor1 = Composite::ConsCellVisitor.df_visitor(arg1)
+        visitor2 = Composite::ConsCellVisitor.df_visitor(arg2)
+        skip_children1 = false
+        skip_children2 = false
+
+        loop do
+          side1, cell1 = visitor1.resume(skip_children1)
+          side2, cell2 = visitor2.resume(skip_children2)
+          if side1 != side2
+            result = Outcome.failure(anEnv)
+          elsif side1 == :stop
+            break
+          else
+            case [cell1.class, cell2.class] # nil, Atomic::AtomicTerm, Composite::ConsCell, LogVarRef
+              when [Composite::ConsCell, Composite::ConsCell]
                 skip_children1 = false
                 skip_children2 = false
+              when [Composite::ConsCell, LogVarRef]
+                skip_children1 = true
+                skip_children2 = false
                 sub_result = unification(cell1, cell2, anEnv)
                 result = merge_results(result, sub_result)
-              end
+              when [LogVarRef, Composite::ConsCell]
+                skip_children1 = false
+                skip_children2 = true
+                sub_result = do_unification(cell1, cell2, anEnv)
+                result = merge_results(result, sub_result)
+            else
+              skip_children1 = false
+              skip_children2 = false
+              sub_result = unification(cell1, cell2, anEnv)
+              result = merge_results(result, sub_result)
             end
-
-            break if result.failure?
           end
 
-          result
+          break if result.failure?
         end
 
-        def merge_results(result1, result2)
-          raise StandardError if result2.kind_of?(Hash)
+        result
+      end
 
-          if result2.success?
-            result1.merge(result2)
-            result1
-          else
-            result2
-          end
+      def merge_results(result1, result2)
+        raise StandardError if result2.kind_of?(Hash)
+
+        if result2.success?
+          result1.merge(result2)
+          result1
+        else
+          result2
         end
-      end # class
+      end
+    end # class
 
-      Equals.instance.freeze
-    end # module
+    Equals.instance.freeze
   end # module
-end # unless
+end # module

data/lib/mini_kraken/core/goal_relation.rb

@@ -15,9 +15,9 @@ module MiniKraken
 
       def validated_args(actuals)
         actuals.each do |arg|
-          unless arg.kind_of?(Goal)
+          unless arg.kind_of?(Goal) || arg.kind_of?(Glue::FreshEnv)
             prefix = "#{name} expects goal as argument, found a "
-            raise StandardError, prefix + "'#{arg.class}'"
+            raise StandardError, prefix + "'#{arg.class}': #{arg}"
           end
         end
 

data/lib/mini_kraken/core/goal_template.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base_arg'
-require_relative 'cons_cell_visitor'
+require_relative '../composite/cons_cell_visitor'
 
 module MiniKraken
   module Core
@@ -54,7 +54,7 @@ module MiniKraken
             goal_args << formals2actuals[arg.name]
           elsif arg.kind_of?(GoalTemplate)
             goal_args << arg.send(:do_instantiate, formals2actuals)
-          elsif arg.kind_of?(ConsCell)
+          elsif arg.kind_of?(Composite::ConsCell)
             # if list contains a formal_ref it must be replaced by the actual
             goal_args << transform(arg, formals2actuals)
           else
@@ -71,9 +71,9 @@ module MiniKraken
         return aConsCell if aConsCell.null?
 
         member = { car: :@car, cdr: :@cdr }
-        visitor = ConsCellVisitor.df_visitor(aConsCell)
+        visitor = Composite::ConsCellVisitor.df_visitor(aConsCell)
         side, cell = visitor.resume
-        result = ConsCell.new(nil, nil)
+        result = Composite::ConsCell.new(nil, nil)
         node = result
 
         loop do
@@ -84,15 +84,15 @@ module MiniKraken
           case cell
             when FormalRef
               converted = formals2actuals[cell.name]
-            when ConsCell
-              converted = ConsCell.new(nil, nil)
+            when Composite::ConsCell
+              converted = Composite::ConsCell.new(nil, nil)
             when GoalTemplate
               converted = cell.send(:do_instantiate, formals2actuals)
             else
               converted = cell
           end
           node.instance_variable_set(member[side], converted)
-          node = converted if converted.kind_of?(ConsCell)
+          node = converted if converted.kind_of?(Composite::ConsCell)
         end
 
         result

data/lib/mini_kraken/core/{variable.rb → log_var.rb}

@@ -6,24 +6,31 @@ require_relative 'vocabulary'
 
 module MiniKraken
   module Core
-    # Representation of a MiniKraken variable.
-    # It is a named slot that can be associated with one value.
-    class Variable
+    # Representation of a MiniKraken logical variable.
+    # It is a named slot that can be associated with one value at the time.
+    # In relational programming, there is no explicit assignment expression.
+    # A logical variable acquire a value through an algorithm called 
+    # 'unification'.
+    class LogVar
       include Designation # Mixin: Acquire name attribute
 
       # @return [String] Internal variable name used by MiniKraken
       attr_accessor :i_name
 
+      # Create a logical variable with given name
       # @param aName [String] The name of the variable
       def initialize(aName)
         init_designation(aName)
         @i_name = name.dup
       end
 
+      # Indicate whether this variable is fused with another one.
+      # @return [Boolean]
       def fused?
         name != i_name
       end
 
+      # @param [Core::Vocabulary]
       def quote(env)
         raise StandardError, "class #{env}" unless env.kind_of?(Vocabulary)
 

data/lib/mini_kraken/core/{variable_ref.rb → log_var_ref.rb}

@@ -8,7 +8,7 @@ module MiniKraken
   module Core
     # A variable reference represents the occurrence of a variable (name) in a
     # MiniKraken term.
-    class VariableRef < Term
+    class LogVarRef < Term
       include Designation # Mixin: Acquire name attribute
       alias var_name name
 
@@ -48,7 +48,7 @@ module MiniKraken
         val.nil? ? AnyValue.new(var_name, env, names_fused(env)) : val
       end
 
-      # param another [VariableRef]
+      # param another [LogVarRef]
       # @param env [Environment]
       # @return [Boolean]
       def fused_with?(another, env)
@@ -63,7 +63,7 @@ module MiniKraken
         env.names_fused(var_name)
       end
 
-      # param another [VariableRef]
+      # param another [LogVarRef]
       # @param env [Environment]
       # @return [Boolean]
       def different_from?(another, env)