mini_kraken 0.1.04 → 0.1.05

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'
@@ -24,193 +26,132 @@ module MiniKraken
       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", [])
+      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]
-          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
+          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.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
-        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])
+        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 = Failure
+              result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
             end
-          end
-        when [true, true]
-          case [arg1.fresh?, arg2.fresh?]
-          when [false, false]
-            if arg1.value == arg2.value
-              result = Outcome.new(:"#s", [arg1.value])
+          elsif arg2.kind_of?(CompositeTerm)
+            if arg1_freshness.degree == :fresh
+              result = Outcome.new(:"#s", anEnv)
+              arg1.associate(arg2, result)
             else
-              result = Failure
+              # Ground case...
+              result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
             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", [])
+          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
-              # TODO: add constraints
-              result = Outcome.new(:"#s", [])
+              raise StandardError, "Unsupported freshness combination #{freshness}"
             end
+          else
+            arg_kinds = [arg1.class, arg2.class]
+            raise StandardError, "Unsupported combination #{arg_kinds}"
           end
         end
 
         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
-        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
+      # @return [Freshness]
+      def unify_composite_terms(arg1, arg2, anEnv)
+        # require 'debug'
+        result = Outcome.new(:"#u", anEnv)
+        children1 = arg1.children
+        children2 = arg2.children
 
-    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)
-          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)
+        if children1.size == children2.size
+          i = 0
+          subresults = children1.map do |child1|
+            child2 = children2[i]
+            i += 1
+            unification(child1, child2, 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)
+          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
-          else
-            raise StandardError, "Unsupported freshness combination #{freshness}"
+            result = memo
           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.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
-          end
-          result = memo
-        end
+        result
       end
-
-      result
-    end
-
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/fail.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
@@ -18,4 +20,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/freshness.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     # Freshness: fresh, bound, ground
@@ -12,31 +14,32 @@ module MiniKraken
       def initialize(aDegree, anAssociated)
         super(aDegree, valid_associated(anAssociated))
       end
-      
+
       def fresh?
-        self.degree == :fresh
+        degree == :fresh
       end
 
       def bound?
-        self.degree == :bound
+        degree == :bound
       end
 
       def ground?
-        self.degree == :ground
+        degree == :ground
       end
 
       # Does this instance represent something fresh according to
       # "Reasoned Schemer" book ?
       def rs_fresh?
-        self.degree != ground
+        degree != ground
       end
-      
+
       private
-      
+
       def valid_associated(anAssociated)
         raise StandardError, 'Wrong argument' if anAssociated.kind_of?(self.class)
+
         anAssociated
       end
     end # struct
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/goal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'environment'
 
 module MiniKraken
@@ -31,7 +33,7 @@ module MiniKraken
           raise StandardError, err_msg
         end
 
-        prefix = "Invalid goal argument "
+        prefix = 'Invalid goal argument '
         args.each do |actl|
           raise StandardError, prefix + actl.to_s unless actl.kind_of?(Term)
         end
@@ -40,4 +42,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/k_integer.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require_relative 'atomic_term'
 
 module MiniKraken
   module Core
     # A specialized atomic term that represents an integer value.
-    # in MiniKraken 
+    # in MiniKraken
     class KInteger < AtomicTerm
-    
       # @param aValue [Integer] Ruby representation of integer value
       def initialize(aValue)
         super(aValue)
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/k_symbol.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require_relative 'atomic_term'
 
 module MiniKraken
   module Core
     # A specialized atomic term that represents a symbolic value.
-    # in MiniKraken   
+    # in MiniKraken
     class KSymbol < AtomicTerm
-    
       # @param aValue [Symbol] Ruby representation of symbol value
       def initialize(aValue)
         super(aValue)
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/nullary_relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'relation'
 
 module MiniKraken
@@ -17,4 +19,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/outcome.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'vocabulary'
 
 module MiniKraken
@@ -14,14 +16,14 @@ module MiniKraken
       end
 
       def successful?
-        self.resultant == :"#s"
+        resultant == :"#s"
       end
 
       def ==(other)
         are_equal = false
 
         if resultant == other.resultant && parent == other.parent &&
-          associations == other.associations
+           associations == other.associations
           are_equal = true
         end
 
@@ -32,4 +34,4 @@ module MiniKraken
     Failure = Outcome.new(:"#u")
     BasicSuccess = Outcome.new(:"#s")
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     class Relation
@@ -20,25 +22,9 @@ module MiniKraken
         raise NotImplementedError
       end
 
-      # Attempt to achieve the goal for a given context (environment)
-      # @param anEnv [Environment] The context in which the goal take place.
-      # @return [Fiber<Outcome>] A Fiber object that will generate the results.
-      # def solve(args, anEnv)
-       # Fiber instance responds to resume(*args) message
-        # If too much resume calls => FiberError: dead fiber called message.
-
-        # Fiber.new do |first_yield_arg| do
-          # begin
-            # result = relation.solve(actuals, anEnv)
-            # Fiber.yield result
-          # while result.success?
-
-          nil
-      # end
-
       def inspect
-        alt_name ? alt_name : name
+        alt_name || name
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/succeed.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
@@ -11,10 +13,10 @@ module MiniKraken
       def initialize
         super('succeed', '#s')
       end
-      
+
       def solver_for(_actuals, _env)
         DuckFiber.new(:success)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/term.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     # The generalization of data value in MiniKraken

data/lib/mini_kraken/core/variable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'any_value'
 require_relative 'vocabulary'
 
@@ -6,12 +8,16 @@ module MiniKraken
     # Representation of a MiniKraken variable.
     # It is a named slot that can be associated with one value.
     class Variable
-      # @return [String] Name of the variable
+      # @return [String] User-defined name of the variable
       attr_reader :name
 
+      # @return [String] Internal variable name used by MiniKraken
+      attr_accessor :i_name
+
       # @param aName [String] The name of the variable
       def initialize(aName)
         @name = valid_name(aName)
+        @i_name = name.dup
       end
 
       def fresh?(anEnvironment)
@@ -21,13 +27,17 @@ module MiniKraken
       # @param env [Environment]
       # @return [Freshness]
       def freshness(env)
-        freshness = env.freshness_ref(self)
+        env.freshness_ref(self)
       end
 
       def ground?(anEnvironment)
         !fresh?(anEnvironment)
       end
 
+      def fused?
+        name != i_name
+      end
+
       def quote(anEnvironment)
         raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
 
@@ -39,7 +49,7 @@ module MiniKraken
 
       def valid_name(aName)
         if aName.empty?
-          raise StandardError, "Variable name may not be empty."
+          raise StandardError, 'Variable name may not be empty.'
         end
 
         aName

data/lib/mini_kraken/core/variable_ref.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 require_relative 'term'
 require_relative 'any_value'
-require_relative 'association'
 
 module MiniKraken
   module Core
@@ -37,8 +38,7 @@ module MiniKraken
       # @param aValue [Term]
       # @param env [Environment]
       def associate(aValue, env)
-        assoc = Association.new(var_name, aValue)
-        env.add_assoc(assoc)
+        env.add_assoc(var_name, aValue)
       end
 
       # @param env [Environment]
@@ -57,10 +57,9 @@ module MiniKraken
       # @param env [Environment]
       # @return [Freshness]
       def freshness(env)
-        freshness = env.freshness_ref(self)
+        env.freshness_ref(self)
       end
 
-
       # @param env [Environment]
       def quote(env)
         val = env.quote_ref(self)
@@ -71,34 +70,15 @@ module MiniKraken
       # @param env [Environment]
       # @return [Boolean]
       def fused_with?(another, env)
-        # I should point to 'another'...
-        other_name = another.var_name
-        to_another = values(env).find do |val|
-          val.kind_of?(VariableRef) && val.var_name == other_name
-        end
-        return false unless to_another
+        my_var = env.name2var(var_name)
+        return false unless my_var.fused?
 
-        # 'another' should point to me
-        to_me = another.values(env).find do |val|
-          val.kind_of?(VariableRef) && val.var_name == var_name
-        end
-        !to_me.nil?
+        other_var = env.name2var(another.var_name)
+        return my_var.i_name == other_var.i_name
       end
 
       def names_fused(env)
-        to_others = values(env).select do |val|
-          val.kind_of?(VariableRef)
-        end
-        return [] if to_others.empty?
-
-        # 'others' should point to me
-        to_me = to_others.select do |other|
-          other.values(env).find do |val|
-            val.kind_of?(VariableRef) && val.var_name == var_name
-          end
-        end
-
-        to_me.map { |other| other.var_name }
+        env.names_fused(var_name)
       end
 
       # param another [VariableRef]
@@ -112,13 +92,11 @@ module MiniKraken
 
       def valid_name(aName)
         if aName.empty?
-          raise StandardError, "Variable name may not be empty."
+          raise StandardError, 'Variable name may not be empty.'
         end
 
         aName
       end
-
-
     end # class
   end # module
 end # module