mini_kraken 0.1.03 → 0.1.08

data/lib/mini_kraken/core/vocabulary.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'association'
 require_relative 'association_walker'
 
 module MiniKraken
@@ -19,31 +23,34 @@ module MiniKraken
         @rankings = {} unless aParent
       end
 
-      # Return a Fiber object that can iterate over this vocabulary and
+      # Return a Enumerator object that can iterate over this vocabulary and
       # all its direct and indirect parent(s).
-      # @return [Fiber<Vocabulary, NilClass>]
+      # @return [Enumerator<Vocabulary, NilClass>]
       def ancestor_walker
-        Fiber.new do
+        unless @ancestors # Not yet in cache?...
+          @ancestors = []
           relative = self
-          while relative do
-            Fiber.yield relative
+          while relative
+            @ancestors << relative
             relative = relative.parent
           end
-
-          Fiber.yield nil # nil marks end of iteration...
+          @ancestors << nil # nil marks end of iteration...
         end
+
+        @ancestors.to_enum
       end
 
       def clear_rankings
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
+
           orphan = orphan_temp
         end
 
-        orphan.rankings.clear if orphan.rankings
+        orphan.rankings&.clear
       end
 
       # @param aName [String]
@@ -52,42 +59,50 @@ module MiniKraken
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
+
           orphan = orphan_temp
         end
 
         raise StandardError unless orphan
 
+        rank = nil
         if orphan.rankings.include?(aName)
-          orphan.rankings[aName]
+          rank = orphan.rankings[aName]
         else
-          other = alternate_names.find do |a_name| 
-            orphan.rankings.include?(a_name) 
+          other = alternate_names.find do |a_name|
+            rank = orphan.rankings.include?(a_name)
           end
           if other
-            get_rank(other)
+            rank = get_rank(other)
           else
             rank = orphan.rankings.keys.size
             orphan.rankings[aName] = rank
-            rank
           end
         end
+
+        rank
       end
 
-      # Record an association between a variable with given name and a term.
-      # @param anAssociation [Association]
-      def add_assoc(anAssociation)
-        name = anAssociation.var_name
-        unless include?(name)
+      # Record an association between a variable with given user-defined name
+      # and a term.
+      # @param aName [String, Variable] A user-defined variable name
+      # @param aTerm [Term] A term to associate with the variable
+      def add_assoc(aName, aTerm)
+        name = aName.respond_to?(:name) ? aName.name : aName
+
+        var = name2var(name)
+        unless var
           err_msg = "Unknown variable '#{name}'."
           raise StandardError, err_msg
         end
-        found_assocs = associations[name]
-        if found_assocs
-          found_assocs << anAssociation
+        siblings = detect_fuse(var, aTerm)
+        if siblings.empty?
+          anAssociation = Association.new(var.i_name, aTerm)
+          do_add_assocs([anAssociation]).first
         else
-          associations[name] = [anAssociation]
+          fuse_vars(siblings << var)
         end
       end
 
@@ -95,19 +110,117 @@ module MiniKraken
       # Can be overridden in other to propagate associations from child
       # @param _descendent [Outcome]
       def propagate(_descendent)
-        #Do nothing...
+        # Do nothing...
       end
 
-      # Remove all the associations.
+      # Remove all the associations of this vocabulary
       def clear
         associations.clear
       end
 
+      # @param aVarName [String] A user-defined variable name
+      # @param other [Vocabulary]
+      def move_assocs(aVarName, other)
+        i_name = to_internal(aVarName)
+        assocs = other.associations[i_name]
+        if assocs
+          do_add_assocs(assocs)
+          other.associations.delete(i_name)
+        end
+      end
+
       # Merge the associations from another vocabulary-like object.
       # @param another [Vocabulary]
       def merge(another)
-        another.associations.each_pair do |_name, assocs|
-          assocs.each { |a| add_assoc(a) }
+        another.associations.each_value { |assocs| do_add_assocs(assocs) }
+      end
+
+      # Check that the provided variable must be fused with the argument.
+      # @return [Array<Variable>]
+      def detect_fuse(aVariable, aTerm)
+        return [] unless aTerm.kind_of?(VariableRef)
+
+        assocs = self[aTerm.var_name]
+        # Simplified implementation: cope with binary cycles only...
+        # TODO: Extend to n-ary (n > 2) cycles
+        assoc_refs = assocs.select { |a| a.value.kind_of?(VariableRef) }
+        return [] if assoc_refs.empty? # No relevant association...
+
+        visitees = Set.new
+        to_fuse = []
+        to_visit = assoc_refs
+        loop do
+          assc = to_visit.shift
+          next if visitees.include?(assc)
+
+          visitees.add(assc)
+          ref = assc.value
+          if ref.var_name == aVariable.name
+            to_fuse << assc.i_name unless assc.i_name == aVariable.i_name
+          end
+          other_assocs = self[ref.var_name]
+          other_assoc_refs = other_assocs.select { |a| a.value.kind_of?(VariableRef) }
+          other_assoc_refs.each do |a|
+            to_visit << a unless visitess.include?(a)
+          end
+
+
+          break if to_visit.empty?
+        end
+
+        to_fuse.map { |i_name| i_name2var(i_name) }
+      end
+
+      # Fuse the given variables, that is:
+      # Collect all their associations
+      # Put them under a new internal name
+      # Remove all entries from old internal names
+      # For all fused variables, change internal names
+      # @param theVars [Array<Variable>]
+      def fuse_vars(theVars)
+        new_i_name = Object.new.object_id.to_s
+        fused_vars = theVars.dup
+        fused_vars.each do |a_var|
+          old_i_name = a_var.i_name
+          old_names = fused_vars.map(&:name)
+          walker = ancestor_walker
+
+          loop do
+            voc = walker.next
+            break unless voc
+
+            if voc.associations.include?(old_i_name)
+              assocs = voc.associations[old_i_name]
+              keep_assocs = assocs.reject do |assc|
+                assc.value.kind_of?(VariableRef) && old_names.include?(assc.value.var_name)
+              end
+              unless keep_assocs.empty?
+                keep_assocs.each { |assc| assc.i_name = new_i_name }
+                if voc.associations.include?(new_i_name)
+                  voc.associations[new_i_name].concat(keep_assocs)
+                else
+                  voc.associations[new_i_name] = keep_assocs
+                end
+              end
+              voc.associations.delete(old_i_name)
+            end
+            next unless voc.respond_to?(:vars) && voc.vars.include?(a_var.name)
+
+            user_names = voc.ivars[old_i_name]
+            unseen = user_names.reject { |nm| old_names.include?(nm) }
+            unseen.each do |usr_name|
+              new_var = name2var(usr_name)
+              fused_vars << new_var
+            end
+            unless voc.ivars.include?(new_i_name)
+              voc.ivars[new_i_name] = user_names
+            else
+              voc.ivars[new_i_name].merge(user_names)
+            end
+            voc.ivars.delete(old_i_name)
+            break
+          end
+          a_var.i_name = new_i_name
         end
       end
 
@@ -119,7 +232,7 @@ module MiniKraken
       end
 
       # @param var [Variable, VariableRef] variable for which the value to retrieve
-      # @return [Term, NilClase]
+      # @return [Term, NilClass]
       def ground_value(var)
         name = var.respond_to?(:var_name) ? var.var_name : var.name
 
@@ -127,7 +240,7 @@ module MiniKraken
         walker.find_ground(name, self)
       end
 
-      # @param var [CompositeTerm] the composite term to check.
+      # @param val [CompositeTerm] the composite term to check.
       # @return [Boolean]
       def fresh_value?(val)
         walker = AssociationWalker.new
@@ -149,7 +262,7 @@ module MiniKraken
       # Determine whether the reference points to a fresh, bound or ground term.
       # @param aVariableRef [VariableRef]
       # @return [Freshness]
-     def freshness_ref(aVariableRef)
+      def freshness_ref(aVariableRef)
         walker = AssociationWalker.new
         walker.determine_freshness(aVariableRef, self)
       end
@@ -161,33 +274,124 @@ module MiniKraken
         walker.quote_term(aVariableRef, self)
       end
 
-      # @param aName [String]
-      # @return [Array<Association>]
-      def [](aName)
-        assoc_arr = associations[aName]
-        assoc_arr = [] if assoc_arr.nil?
+      # Return the variable with given user-defined variable name.
+      # @param aName [String] User-defined variable name
+      def name2var(aName)
+        var = nil
+        walker = ancestor_walker
 
-        assoc_arr.concat(parent[aName]) if parent
-        assoc_arr
+        loop do
+          voc = walker.next
+          if voc
+            next unless voc.respond_to?(:vars) && voc.vars.include?(aName)
+
+            var = voc.vars[aName]
+          end
+
+          break
+        end
+
+        var
       end
 
-      # Check that a variable with given name is defined in this vocabulary
-      # of one of its ancestor.
-      # @return [Boolean]
-      def include?(aVarName)
-        var_found = false
+      # Return the variable with given internal variable name.
+      # @param i_name [String] internal variable name
+      # @return [Variable]
+      def i_name2var(i_name)
+        var = nil
+        voc = nil
         walker = ancestor_walker
+
         loop do
-          voc = walker.resume
+          voc = walker.next
           if voc
-            next unless voc.respond_to?(:vars) && voc.vars.include?(aVarName)
-            var_found = true
+            next unless voc.respond_to?(:ivars) && voc.ivars.include?(i_name)
+
+            var_name = voc.ivars[i_name].first # TODO: what if multiple vars?
+            var = voc.vars[var_name]
           end
 
           break
         end
 
-        var_found
+        raise StandardError, 'Nil variable object' if var.nil?
+
+        var
+      end
+
+      # Return the internal name to corresponding to a given user-defined
+      #   variable name.
+      # @param aName [String] User-defined variable name
+      def to_internal(aName)
+        var = name2var(aName)
+        var ? var.i_name : nil
+      end
+
+      # Return the internal names fused with given user-defined
+      #   variable name.
+      # @param aName [String] User-defined variable name
+      def names_fused(aName)
+        var = name2var(aName)
+        return [] unless var.fused?
+
+        i_name = var.i_name
+        names = []
+        walker = ancestor_walker
+
+        loop do
+          voc = walker.next
+          break unless voc
+          next unless voc.respond_to?(:ivars)
+
+          if voc.ivars.include?(i_name)
+            fused = voc.ivars[i_name]
+            names.concat(fused.to_a)
+          end
+        end
+
+        names.uniq!
+        names.reject { |nm| nm == aName }
+      end
+
+      # Retrieve all the associations for a given variable
+      # @param aVariable [Variable]
+      # @return [Array<Association>]
+      def assocs4var(aVariable)
+        i_name = aVariable.i_name
+        assocs = []
+        walker = ancestor_walker
+
+        loop do
+          voc = walker.next
+          break unless voc
+          next unless voc.associations.include?(i_name)
+
+          assocs.concat(voc.associations[i_name])
+        end
+
+        assocs
+      end
+
+      # @param aName [String] User-defined variable name
+      # @return [Array<Association>]
+      def [](aName)
+        iname = to_internal(aName)
+        return [] unless iname
+
+        assoc_arr = associations[iname]
+        assoc_arr = [] if assoc_arr.nil?
+
+        # TODO: Optimize
+        assoc_arr.concat(parent[aName]) if parent
+        assoc_arr
+      end
+
+      # Check that a variable with given name is defined in this vocabulary
+      # or one of its ancestor.
+      # @param aVarName [String] A user-defined variable name.
+      # @return [Boolean]
+      def include?(aVarName)
+        name2var(aVarName) ? true : false
       end
 
       protected
@@ -201,6 +405,21 @@ module MiniKraken
 
         aParent
       end
+
+      # @param theAssociations [Array<Association>]
+      def do_add_assocs(theAssociations)
+        theAssociations.each do |assc|
+          i_name = assc.i_name
+          found_assocs = associations[i_name]
+          if found_assocs
+            found_assocs << assc
+          else
+            associations[i_name] = [assc]
+          end
+
+          assc
+        end
+      end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/glue/fresh_env.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../core/environment'
 require_relative '../core/variable'
 
@@ -20,12 +22,12 @@ module MiniKraken
       end
 
       # Attempt to achieve the goal given this environment
-      # @param aParent [Environment] 
-      # @return [Fiber<Outcome>] A Fiber object that will generate the results.      
+      # @param aParent [Environment]
+      # @return [Fiber<Outcome>] A Fiber object that will generate the results.
       def attain(aParent)
         self.parent = aParent
         goal.attain(self)
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../core/any_value'
 require_relative '../core/cons_cell'
 require_relative 'fresh_env'
@@ -19,21 +21,29 @@ module MiniKraken
 
       def run
         result = nil
+        next_result = nil
         solver = env.goal.attain(env)
-        # require 'debug'        
+        # require 'debug'
         loop do
+          env.clear
+          env.clear_rankings
           outcome = solver.resume
           break if outcome.nil?
-          env.clear
+
           if result # ... more than one result...
-          else
             if outcome.successful?
-              env.propagate(outcome)
-              # require 'debug'
-              result = Core::ConsCell.new(var.quote(outcome))
+              next_result.append(Core::ConsCell.new(var.quote(outcome)))
             else
-              result = Core::NullList
+              next_result.append(Core::NullList)
             end
+            next_result = next_result.cdr
+          elsif outcome.successful?
+            env.propagate(outcome)
+            result = Core::ConsCell.new(var.quote(outcome))
+            next_result = result
+          else
+            result = Core::NullList
+            next_result = result
           end
         end
 
@@ -41,4 +51,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module