mini_kraken 0.1.02 → 0.1.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6ff930902d2d1d8967acaab13146a2f1f884b4dab5cdf5dc23b14e043baac76
-  data.tar.gz: 702bd83538e9e94edac5e17943af72438d3c91296221c80e6172d1cbbf1df71c
+  metadata.gz: ba23145a960593f3910547ace544235fcf3f9c9f5ee45b593e3aa465231e37fe
+  data.tar.gz: f2e1e6371cb9873192fece615acc2a6bd9021c5e7f8b1865b4a108ab414d5e8e
 SHA512:
-  metadata.gz: 4885be585b956b690762ff66365098d4ed0cd6bd141410863afa1701431f6cc4fc6749fc5a2fff4e2689cbd3f9ac7035f057458de2b364df6a34015a252deaed
-  data.tar.gz: 6180e86da36cdb2d2d3fd0daf6e53061513064b40df79980f36c73d97418e0016c5985bb03d573a338508a8c2d1745dfa2340c62c261177716d57ec4676e5cba
+  metadata.gz: 0d8c08206038cb1b1d0fe339ace8f5ee4bcb9a91afb10447b8bc15624253774fcfd8fd1e1c4b07faa687fc2f5071bd4e46db0bcc2323044f2d36222db9906e80
+  data.tar.gz: 9f55752adc900a4cfa9aa82906aab0c513f3cf35918c7a50e170ce16201fad8dc471e2f364efaaa9f8db935f35b18bbb12e4af1ef4a74d297f03f54dfc92eda3

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## [0.1.03] - 2020-05-01
+Passes all frames 1:1 up to 1:47 of "Reasoned Schemer" book
+
 ## [0.1.02] - 2020-04-28
 Major code refactoring. Passes all frames 1:1 up to 1:36 of "Reasoned Schemer" book
 

data/lib/mini_kraken/core/any_value.rb

@@ -3,8 +3,10 @@ module MiniKraken
     class AnyValue
       attr_reader :rank
       
-      def initialize(aRank)
-        @rank = aRank
+      # @param aName [String]
+      # @param anEnv [Vocabulary]
+      def initialize(aName, anEnv, alternate_names = [])
+        @rank = anEnv.get_rank(aName, alternate_names)
       end
       
       def ==(other)

data/lib/mini_kraken/core/variable.rb

@@ -29,14 +29,10 @@ module MiniKraken
       end
 
       def quote(anEnvironment)
-        # raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
-        # freshness = anEnvironment.freshness_ref(self)
-        # raise StandardError, "class #{freshness}" unless freshness.kind_of?(Freshness)
-        # raise StandardError, "class #{freshness.associated}" if freshness.associated.kind_of?(Freshness)
-        # freshness.fresh? ? AnyValue.new(0) : freshness.associated.quote(anEnvironment)
+        raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
 
         val = anEnvironment.quote_ref(self)
-        val.nil? ? AnyValue.new(0) : val
+        val.nil? ? AnyValue.new(name, anEnvironment) : val
       end
 
       private

data/lib/mini_kraken/core/variable_ref.rb

@@ -21,6 +21,13 @@ module MiniKraken
         env.fresh?(self)
       end
 
+      # @param env [Environment]
+      # @return [Boolean]
+      def bound?(env)
+        freshness = env.freshness_ref(self)
+        freshness.degree == :bound
+      end
+
       # @param env [Environment]
       # @return [Boolean]
       def ground?(env)
@@ -46,18 +53,59 @@ module MiniKraken
         freshness = env.freshness_ref(self)
         freshness.associated
       end
-      
+
       # @param env [Environment]
       # @return [Freshness]
       def freshness(env)
         freshness = env.freshness_ref(self)
-      end      
-      
+      end
+
 
       # @param env [Environment]
       def quote(env)
         val = env.quote_ref(self)
-        val.nil? ? AnyValue.new(0) : val
+        val.nil? ? AnyValue.new(var_name, env, names_fused(env)) : val
+      end
+
+      # param another [VariableRef]
+      # @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
+
+        # '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?
+      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 }
+      end
+
+      # param another [VariableRef]
+      # @param env [Environment]
+      # @return [Boolean]
+      def different_from?(another, env)
+        !fused_with?(another, env)
       end
 
       private

data/lib/mini_kraken/core/vocabulary.rb

@@ -9,10 +9,14 @@ module MiniKraken
       # @return [Hash] Pairs of the kind {String => Array[Association]}
       attr_reader :associations
 
+      # @return [Hash] Pairs of the kind {String => Integer}
+      attr_reader :rankings
+
       # @param aParent [Environment, NilClass] Parent environment to this one.
       def init_vocabulary(aParent = nil)
         @parent = validated_parent(aParent)
         @associations = {}
+        @rankings = {} unless aParent
       end
 
       # Return a Fiber object that can iterate over this vocabulary and
@@ -30,6 +34,47 @@ module MiniKraken
         end
       end
 
+      def clear_rankings
+        walker = ancestor_walker
+        orphan = nil
+        loop do
+          orphan_temp = walker.resume
+          break unless orphan_temp
+          orphan = orphan_temp
+        end
+
+        orphan.rankings.clear if orphan.rankings
+      end
+
+      # @param aName [String]
+      # @param alternate_names [Array<String>]
+      def get_rank(aName, alternate_names = [])
+        walker = ancestor_walker
+        orphan = nil
+        loop do
+          orphan_temp = walker.resume
+          break unless orphan_temp
+          orphan = orphan_temp
+        end
+
+        raise StandardError unless orphan
+
+        if orphan.rankings.include?(aName)
+          orphan.rankings[aName]
+        else
+          other = alternate_names.find do |a_name| 
+            orphan.rankings.include?(a_name) 
+          end
+          if other
+            get_rank(other)
+          else
+            rank = orphan.rankings.keys.size
+            orphan.rankings[aName] = rank
+            rank
+          end
+        end
+      end
+
       # Record an association between a variable with given name and a term.
       # @param anAssociation [Association]
       def add_assoc(anAssociation)
@@ -89,13 +134,13 @@ module MiniKraken
         ground_term = walker.walk_value(val, self)
         ground_term.nil? ? true : false
       end
-      
+
       # A composite term is fresh when all its members are nil or all non-nil members
       # are all fresh
-      # A composite term is bound when it is not fresh and not ground      
+      # A composite term is bound when it is not fresh and not ground
       # A composite term is a ground term when all its non-nil members are ground.
       # @param aComposite [CompositeTerm]
-      # @return [Freshness]      
+      # @return [Freshness]
       def freshness_composite(aComposite)
         walker = AssociationWalker.new
         walker.freshness_composite(aComposite)
@@ -110,10 +155,10 @@ module MiniKraken
       end
 
       # @param aVariableRef [VariableRef]
-      # @return [Term, NilClass]      
+      # @return [Term, NilClass]
       def quote_ref(aVariableRef)
         walker = AssociationWalker.new
-        walker.quote_term(aVariableRef, self)      
+        walker.quote_term(aVariableRef, self)
       end
 
       # @param aName [String]

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -29,6 +29,7 @@ module MiniKraken
           else
             if outcome.successful?
               env.propagate(outcome)
+              # require 'debug'
               result = Core::ConsCell.new(var.quote(outcome))
             else
               result = Core::NullList

data/lib/mini_kraken/version.rb

@@ -1,3 +1,3 @@
 module MiniKraken
-  VERSION = '0.1.02'.freeze
+  VERSION = '0.1.03'.freeze
 end

data/spec/core/equals_spec.rb

@@ -44,7 +44,7 @@ module MiniKraken
 
         let(:pea) { KSymbol.new(:pea) }
         let(:pod) { KSymbol.new(:pod) }
-        let(:sample_cons) { ConsCell.new(pea, nil) }
+        let(:sample_cons) { ConsCell.new(pea) }
         let(:a_composite) { ConsCell.new(pod) }
         let(:env) { Environment.new }
         let(:var_q) { build_var('q') }
@@ -94,6 +94,8 @@ module MiniKraken
         end
 
         it 'should fail for one right literal and one composite arguments' do
+          # Reasoned S2, frame 1:44
+          # (== '(pea) 'pea) ;; => #u
           result = solve_for(sample_cons, pea)
 
           expect(result.resultant).to eq(:"#u")
@@ -283,6 +285,19 @@ module MiniKraken
           expect(ref_x.fresh?(env)).to be_falsey
           expect(ref_q.fresh?(env)).to be_falsey
         end
+        
+        it 'should fail for one right literal and one composite arguments' do
+          # Reasoned S2, frame 1:46
+          # x associated to ('pea 'pod)
+          # (== '(,x) x) ;; => #u
+          expr1 = cons(pea, cons(pod))
+          ref_x.associate(expr1, env)
+          expr2 = cons(ref_x)
+          result = solve_for(expr2, ref_x)
+
+          expect(result.resultant).to eq(:"#u")
+          expect(result.associations).to be_empty
+        end        
       end # context
     end # describe
   end # module

data/spec/core/vocabulary_spec.rb

@@ -182,6 +182,25 @@ module MiniKraken
           subject.add_assoc(Association.new('x', pea))
           expect(subject.fresh?(ref_q)).to be_falsey
         end
+
+        it 'should rank names sequentially' do
+          2.times do
+            expect(subject.get_rank('a')).to eq(0)
+            expect(subject.get_rank('z')).to eq(1)
+            expect(subject.get_rank('c')).to eq(2)
+          end
+        end
+        
+        it 'should clear the rankings' do
+          expect(subject.get_rank('a')).to eq(0)
+          expect(subject.get_rank('z')).to eq(1)
+          
+          subject.clear_rankings
+          expect(grandma.rankings).to be_empty
+
+          expect(subject.get_rank('z')).to eq(0)    
+          expect(subject.get_rank('a')).to eq(1)          
+        end
       end # context
     end # describe
   end # module

data/spec/glue/run_star_expression_spec.rb

@@ -39,6 +39,10 @@ module MiniKraken
       context 'Provided services:' do
         let(:ref_q) { Core::VariableRef.new('q') }
         let(:ref_x) { Core::VariableRef.new('x') }
+        let(:ref_y) { Core::VariableRef.new('y') }
+        let(:ref_s) { Core::VariableRef.new('s') }
+        let(:ref_t) { Core::VariableRef.new('t') }
+        let(:ref_u) { Core::VariableRef.new('u') }        
 
         it "should return a null list with the fail goal" do
           # Reasoned S2, frame 1:7
@@ -127,6 +131,9 @@ module MiniKraken
           result = instance.run
           expect(ref_q.fresh?(instance.env)).to be_falsey
           expect(ref_x.fresh?(fresh_env)).to be_truthy
+
+          #  Reasoned S2, frame 1:40
+          expect(ref_q.different_from?(ref_x, fresh_env)).to be_truthy
           expect(result.car).to eq(pea)
         end
 
@@ -166,6 +173,11 @@ module MiniKraken
           result = instance.run
           expect(ref_q.fresh?(instance.env)).to be_truthy
           expect(ref_x.fresh?(fresh_env)).to be_truthy
+
+          # q should be fused with x...
+          expect(ref_q.fused_with?(ref_x, fresh_env)).to be_truthy
+          expect(ref_q.names_fused(fresh_env)).to eq(['x'])
+          expect(ref_x.names_fused(fresh_env)).to eq(['q'])
           expect(result.car).to eq(any_value(0))
         end
 
@@ -225,8 +237,8 @@ module MiniKraken
         end
 
         it 'should unify complex equality expressions (II)' do
-          # # Reasoned S2, frame 1:36
-          # # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
+          # Reasoned S2, frame 1:36
+          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
           expr1 = cons(cons(cons(ref_q)), ref_x)
           expr2 = cons(cons(cons(ref_x)), pod)
           goal = equals_goal(expr1, expr2)
@@ -241,6 +253,104 @@ module MiniKraken
           expect(ref_x.fresh?(fresh_env)).to be_falsey
           expect(result.car).to eq(pod)
         end
+
+        it 'should unify with repeated fresh variable' do
+          # Reasoned S2, frame 1:37
+          # (run* q (fresh (x) (==  '( ,x ,x) q))) ;; => (_0 _0)
+          expr1 = cons(ref_x, cons(ref_x))
+          goal = equals_goal(expr1, ref_q)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy # x isn't defined here
+          expect(ref_q.fresh?(fresh_env)).to be_truthy
+          expect(ref_x.fresh?(fresh_env)).to be_truthy
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(0))))
+        end
+
+        it 'should unify multiple times' do
+          # Reasoned S2, frame 1:38
+          # (run* q (fresh (x) (fresh (y) (==  '( ,q ,y) '((,x ,y) ,x))))) ;; => (_0 _0)
+          expr1 = cons(ref_q, cons(ref_y))
+          expr2 = cons(cons(ref_x, cons(ref_y)), cons(ref_x))
+          goal = equals_goal(expr1, expr2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('q', fresh_env_x)
+
+          result = instance.run
+          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_q.bound?(fresh_env_y)).to be_truthy
+          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_x.bound?(fresh_env_y)).to be_truthy
+          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_y.bound?(fresh_env_y)).to be_truthy
+
+          # y should be fused with x...
+          expect(ref_y.fused_with?(ref_x, fresh_env_y)).to be_truthy
+          expect(ref_x.names_fused(fresh_env_y)).to eq(['y'])
+          expect(ref_y.names_fused(fresh_env_y)).to eq(['x'])
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(0))))
+        end
+
+        it 'should support multiple fresh variables' do
+          # Reasoned S2, frame 1:41
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y) q)))) ;; => (_0 _1)
+          expr1 = cons(ref_x, cons(ref_y))
+          goal = equals_goal(expr1, ref_q)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('q', fresh_env_x)
+
+          result = instance.run
+          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
+          # q should be bound to '(,x ,y)
+          expect(ref_q.bound?(fresh_env_y)).to be_truthy
+          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_x.bound?(fresh_env_y)).to be_falsey
+          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_y.bound?(fresh_env_y)).to be_falsey
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+        end
+        
+        it 'should work with variable names' do
+          # Reasoned S2, frame 1:42
+          # (run* s (fresh (t) (fresh (u) (==  '( ,t ,u) s)))) ;; => (_0 _1)
+          expr1 = cons(ref_t, cons(ref_u))
+          goal = equals_goal(expr1, ref_s)
+          fresh_env_u = FreshEnv.new(['u'], goal)
+          fresh_env_t = FreshEnv.new(['t'], fresh_env_u)
+          instance = RunStarExpression.new('s', fresh_env_t)
+
+          result = instance.run
+          expect(ref_s.fresh?(fresh_env_u)).to be_truthy
+          # s should be bound to '(,t ,u)
+          expect(ref_s.bound?(fresh_env_u)).to be_truthy
+          expect(ref_t.fresh?(fresh_env_u)).to be_truthy
+          expect(ref_t.bound?(fresh_env_u)).to be_falsey
+          expect(ref_u.fresh?(fresh_env_u)).to be_truthy
+          expect(ref_u.bound?(fresh_env_u)).to be_falsey
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+        end  
+
+        it 'should support repeated variables' do
+          # Reasoned S2, frame 1:43
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y ,x) q)))) ;; => (_0 _1 _0)
+          expr1 = cons(ref_x, cons(ref_y, cons(ref_x)))
+          goal = equals_goal(expr1, ref_q)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('q', fresh_env_x)
+
+          result = instance.run
+          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
+          # q should be bound to '(,x ,y, ,x)
+          expect(ref_q.bound?(fresh_env_y)).to be_truthy
+          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
+          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1), cons(any_value(0)))))
+        end        
       end # context
     end # describe
   end # module

data/spec/support/factory_methods.rb

@@ -11,42 +11,44 @@ module MiniKraken
     # @param rank [Integer]
     # @return [Core::AnyValue]
     def any_value(rank)
-      Core::AnyValue.new(rank)
+      any_val = Core::AnyValue.allocate
+      any_val.instance_variable_set(:@rank, rank)
+      any_val
     end
 
     # Factory method for constructing a ConsCell
     # @param obj1 [Term]
-    # @param obj2 [Term]    
-    # @return [Core::ConsCell]    
+    # @param obj2 [Term]
+    # @return [Core::ConsCell]
     def cons(obj1, obj2 = nil)
       Core::ConsCell.new(obj1, obj2)
     end
 
     # Factory method for constructing a goal using the Equals relation.
     # @param arg1 [Term]
-    # @param arg2 [Term]    
-    # @return [Core::Goal]     
+    # @param arg2 [Term]
+    # @return [Core::Goal]
     def equals_goal(arg1, arg2)
       Core::Goal.new(Core::Equals.instance, [arg1, arg2])
     end
 
     # Factory method for constructing a KSymbol instance
     # @param aSymbol [Symbol]
-    # @return [Core::KSymbol]    
+    # @return [Core::KSymbol]
     def k_symbol(aSymbol)
       Core::KSymbol.new(aSymbol)
     end
-    
+
     # Factory method for constructing a Variable
     # @param var_name [String]
-    # @return [Core::Variable]    
+    # @return [Core::Variable]
     def var_ref(var_name)
       Core::Variable.new(var_name)
     end
-    
+
     # Factory method for constructing a VariableRef
     # @param var_name [String]
-    # @return [Core::VariableRef]    
+    # @return [Core::VariableRef]
     def var_ref(var_name)
       Core::VariableRef.new(var_name)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.02
+  version: 0.1.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-28 00:00:00.000000000 Z
+date: 2020-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler