mini_kraken 0.1.04 → 0.1.05

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
@@ -25,7 +29,7 @@ module MiniKraken
       def ancestor_walker
         Fiber.new do
           relative = self
-          while relative do
+          while relative
             Fiber.yield relative
             relative = relative.parent
           end
@@ -40,10 +44,11 @@ module MiniKraken
         loop do
           orphan_temp = walker.resume
           break unless orphan_temp
+
           orphan = orphan_temp
         end
 
-        orphan.rankings.clear if orphan.rankings
+        orphan.rankings&.clear
       end
 
       # @param aName [String]
@@ -54,6 +59,7 @@ module MiniKraken
         loop do
           orphan_temp = walker.resume
           break unless orphan_temp
+
           orphan = orphan_temp
         end
 
@@ -62,8 +68,8 @@ module MiniKraken
         if orphan.rankings.include?(aName)
           orphan.rankings[aName]
         else
-          other = alternate_names.find do |a_name| 
-            orphan.rankings.include?(a_name) 
+          other = alternate_names.find do |a_name|
+            orphan.rankings.include?(a_name)
           end
           if other
             get_rank(other)
@@ -75,19 +81,24 @@ module MiniKraken
         end
       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 +106,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.resume
+            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 +228,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
 
@@ -149,7 +258,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 +270,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.resume
+          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 aName [String] internal variable name
+      # @return [Variable]
+      def i_name2var(i_name)
+        var = nil
+        voc = nil
         walker = ancestor_walker
+
         loop do
           voc = walker.resume
           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.resume
+          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.resume
+          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 +401,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'
@@ -20,20 +22,19 @@ module MiniKraken
       def run
         result = nil
         solver = env.goal.attain(env)
-        # require 'debug'        
+        # require 'debug'
         loop do
           outcome = solver.resume
           break if outcome.nil?
+
           env.clear
           if result # ... more than one result...
+          elsif outcome.successful?
+            env.propagate(outcome)
+            # require 'debug'
+            result = Core::ConsCell.new(var.quote(outcome))
           else
-            if outcome.successful?
-              env.propagate(outcome)
-              # require 'debug'
-              result = Core::ConsCell.new(var.quote(outcome))
-            else
-              result = Core::NullList
-            end
+            result = Core::NullList
           end
         end
 
@@ -41,4 +42,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
-  VERSION = '0.1.04'.freeze
+  VERSION = '0.1.05'
 end

data/lib/mini_kraken.rb

@@ -1,4 +1,6 @@
-require "mini_kraken/version"
+# frozen_string_literal: true
+
+require 'mini_kraken/version'
 
 module MiniKraken
   class Error < StandardError; end

data/mini_kraken.gemspec

@@ -1,6 +1,8 @@
-lib = File.expand_path("lib", __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "mini_kraken/version"
+require 'mini_kraken/version'
 
 # Implementation module
 module PkgExtending
@@ -10,7 +12,7 @@ module PkgExtending
       '.travis.yml',
       'Gemfile',
       'Rakefile',
-      'CHANGELOG.md',      
+      'CHANGELOG.md',
       'LICENSE.txt',
       'README.md',
       'mini_kraken.gemspec',
@@ -31,25 +33,25 @@ module PkgExtending
 end # module
 
 Gem::Specification.new do |spec|
-  spec.name          = "mini_kraken"
+  spec.name          = 'mini_kraken'
   spec.version       = MiniKraken::VERSION
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
   spec.summary       = %q{Implementation of Minikanren language in Ruby. WIP}
   spec.description   = %q{Implementation of Minikanren language in Ruby. WIP}
-  spec.homepage      = "https://github.com/famished-tiger/mini_kraken"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/famished-tiger/mini_kraken'
+  spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  
+  spec.require_paths = ['lib']
+
   PkgExtending.pkg_files(spec)
-  PkgExtending.pkg_documentation(spec)  
+  PkgExtending.pkg_documentation(spec)
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/spec/core/association_spec.rb

@@ -10,20 +10,20 @@ require_relative '../../lib/mini_kraken/core/association'
 module MiniKraken
   module Core
     describe Association do
-      let(:pea) {KSymbol.new(:pea) }
+      let(:pea) { KSymbol.new(:pea) }
       subject { Association.new('q', pea) }
 
       context 'Initialization:' do
         it 'should be initialized with a name and a value' do
           expect { Association.new('q', pea) }.not_to raise_error
         end
-        
+
         it 'should be initialized with a variable and a value' do
           expect { Association.new(Variable.new('p'), pea) }.not_to raise_error
-        end        
+        end
 
         it 'should know the variable name' do
-          expect(subject.var_name).to eq('q')
+          expect(subject.i_name).to eq('q')
         end
 
         it 'should know the associated value' do

data/spec/core/association_walker_spec.rb

@@ -58,14 +58,14 @@ module MiniKraken
 
         it 'should return composite when it has ground composite term(s)' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
           expr1 = cons(pea, cons(pod, cons(ref_q)))
           expect(subject.walk_value(expr1, env)).to eq(expr1)
         end
 
         it 'should return nil when no assocation exists' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
           env.add_var(var_x)
 
           expect(subject.find_ground(var_x.name, env)).to be_nil
@@ -73,7 +73,7 @@ module MiniKraken
 
         it 'should find an atomic term directly associated' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(pea)
@@ -82,8 +82,8 @@ module MiniKraken
         it 'should find an atomic term directly associated' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', pea))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', pea)
           expect(env['x']).not_to be_nil
 
           result = subject.find_ground(var_q.name, env)
@@ -93,9 +93,9 @@ module MiniKraken
         it 'should cope with cyclic structures' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', pea))
-          env.add_assoc(Association.new('x', ref_q))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', pea)
+          env.add_assoc('x', ref_q)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(pea)
@@ -107,7 +107,7 @@ module MiniKraken
         it 'should cope with a composite with atomic terms only' do
           env.add_var(var_q)
           expr = cons(pea, cons(pod, cons(pea)))
-          env.add_assoc(Association.new('q', expr))
+          env.add_assoc('q', expr)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(expr)
@@ -117,7 +117,7 @@ module MiniKraken
           env.add_var(var_q)
           env.add_var(var_x)
           expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc(Association.new('q', expr))
+          env.add_assoc('q', expr)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to be_nil
@@ -127,14 +127,13 @@ module MiniKraken
           env.add_var(var_q)
           env.add_var(var_x)
           expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc(Association.new('q', expr))
-          env.add_assoc(Association.new('x', pod))
+          env.add_assoc('q', expr)
+          env.add_assoc('x', pod)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(expr)
         end
-=begin
-=end
+
         it 'should categorize a variable without association as free' do
           env.add_var(var_q)
           result = subject.determine_freshness(ref_q, env)
@@ -145,22 +144,24 @@ module MiniKraken
         it 'should categorize a variable related to fresh variable as bound' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
+          env.add_assoc('q', ref_x)
 
           result = subject.determine_freshness(ref_q, env)
           expect(result).to be_bound
           expect(result.associated).to eq(ref_x)
         end
 
-        it 'should categorize a variable even in presence of cycle(s)' do
+        it 'should categorize a variable even in presence of fused var(s)' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', ref_q))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', ref_q)
+          # q and x are fused...
 
           result = subject.determine_freshness(ref_q, env)
-          expect(result).to be_bound
-          expect(result.associated).to eq(ref_x)
+          expect(result).to be_fresh
+          expect(var_q.i_name).to eq(var_x.i_name)
+          expect(env.associations).to be_empty
         end
 
         it 'should categorize an atomic term as ground term' do
@@ -176,15 +177,15 @@ module MiniKraken
           expect(result).to be_ground
           expect(result.associated).to eq(composite)
         end
-        
+
         it 'should categorize a composite term as bound term' do
-          # Bound composite: a composite where at least one member is fresh        
-          env.add_var(var_q)       
+          # Bound composite: a composite where at least one member is fresh
+          env.add_var(var_q)
           composite = cons(pea, cons(ref_q))
           result = subject.determine_freshness(composite, env)
           expect(result).to be_bound
           expect(result.associated).to eq(composite)
-        end        
+        end
       end # context
     end # describe
   end # module