mini_kraken 0.3.02 → 0.3.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef8d438d839320f5a38af687cfef1e4018a687d5a9b3d071f5a485fa03cab3d
-  data.tar.gz: a8aefa5c850913634dbe5b28bec9c605782ef2ef7e8791632a9f7b504937442d
+  metadata.gz: b0c4ccbb33a59eddd02ccbb56c5ad942002cb131e834b345a35c47a81985f999
+  data.tar.gz: ed3aba64c03d87c7f56b9516a0a8fa78aa6bbd39eb1bb39e6ece7b68f6226cd9
 SHA512:
-  metadata.gz: 521fefadf00ba08606646afdd5f881a1a7bd4626221085c69adc2e822a2c2777b6fa28d71ea5f6541c614e0b8e9ca8470cab2301683d1c9f235bb1e3535f20f3
-  data.tar.gz: 99478f83ad99813aa29d82cef6cc5b8ad3d5df376d56819151ecc508d62f0a0fd23a62a1fb3553f8aa231e8c317ad5aa6930503b2cd8ff2951b6d94ca8b3480c
+  metadata.gz: 13890c7b650bb8d83ac660c5e9c0d33cf87094f286a1e8d349095ee98dd8ec66652f16e5cc89928fb593c5dd921c9e612dc2d8f8ec565754baa4cb36c93e1256
+  data.tar.gz: 2358ff17fc9f2982675ff10d17761bf909db4fe38acc8f6f16389b3a31ea286ce4ad20cc1240147886baac98fb5ea047012ffc191ce58f1cf45cea0ca2e2341f

data/CHANGELOG.md

@@ -1,5 +1,19 @@
+## [0.3.03] - 2020-12-20
+- `mini_kraken` now implements the `nullo`, `pairo` relations.
+- Passes all examples from 2:1 up to 2:51 but 2:37
+
+### CHANGED
+- Class `ConsCell`: default value for cdr is NullList instead of nil.
+- Method `ConsCellVisitor#df_visitor`: no visit of car and cdr fiels of a null ConsCell
+- Method `Unify#unify_references` now supports the unification of of floating references
+
+### FIXED
+- Method `ParametrizedTerm#dup_cond` now performs replacement of Array elements.
+- Method `Unify#unify_composite_terms` fixed typo in a method call
+- Method `Unify#unify_references` fixed typo of exception class
+
 ## [0.3.02] - 2020-12-19
-- `mini_kraken` now implements `conso` relation.
+- `mini_kraken` now implements the `conso` relation.
 
 ### CHANGED
 - Method `Context#build_solution` old source code (redundant) removed.

data/README.md

@@ -11,10 +11,10 @@ Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason Hemann: "The Reaso
 ISBN: 9780262535519, (2018), MIT Press.
 
 ### Features
+- Test suite patterned on examples from the reference book
 - Pure Ruby implementation, not a port from another language
 - Object-Oriented design
 - No runtime dependencies
-- Test suite patterned on examples from the reference book.
 
 ### miniKanren Features
 - [X] ( == ) unify
@@ -26,16 +26,24 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] defrel  
 - [X] caro
 - [X] cdro
-- [X] conso 
+- [X] conso
+- [X] nullo  
+- [X] pairo 
 
 ### TODO
 
 - [ ] Occurs check
 
-Pair-centric relations from Chapter 2 
-- [ ] nullo  
-- [ ] pairo  
-- [ ] singletono  
+Pair-centric relations from Chapter 2  
+- [ ] singletono
+
+List-centric relations from Chapter 3
+- [ ] listo 
+- [ ] lolo  
+- [ ] loso 
+- [ ] membero
+- [ ] proper_membero
+
 
 ## Installation
 

data/lib/mini_kraken/composite/cons_cell.rb

@@ -52,11 +52,11 @@ module MiniKraken
       # will silently replace the null list by a nil.
       # @param obj1 [Term, NilClass]
       # @param obj2 [Term, NilClass]
-      def initialize(obj1, obj2 = nil)
+      def initialize(obj1, obj2 = NullList)
         super()
         @car = obj1
         if obj2.kind_of?(ConsCell) && obj2.null?
-          @cdr = nil
+          @cdr = NullList
         else
           @cdr = obj2
         end
@@ -68,6 +68,35 @@ module MiniKraken
         new(nil, nil)
       end
 
+      # Set one element of the pair
+      # @param member [Symbol]
+      # @param element [Term]
+      def set!(member, element)
+        case member
+          when :car
+            set_car!(element)
+          when :cdr
+            set_cdr!(element)
+          else
+            raise StandardError, "Undefined cons cell member #{member}"
+          end
+      end
+
+      # Change the car of ConsCell to 'element'.
+      # Analogue of set-car! procedure in Scheme.
+      # @param element [Term]
+      def set_car!(element)
+        @cdr = NullList if null?
+        @car = element
+      end
+
+      # Change the cdr of ConsCell to 'element'.
+      # Analogue of set-cdr! procedure in Scheme.
+      # @param element [Term]
+      def set_cdr!(element)
+        @cdr = element
+      end
+
       def children
         [car, cdr]
       end
@@ -93,13 +122,13 @@ module MiniKraken
         !pinned?(ctx)
       end
 
-      # Does the composite have a definite value?
+      # Does the cons cell have a definite value?
       # @return [Boolean]
       def pinned?(ctx)
-        @pinned_car ||= car.nil? || car.pinned?(ctx)
-        @pinned_cdr ||= cdr.nil? || cdr.pinned?(ctx)
+        pinned_car = car.nil? || car.pinned?(ctx)
+        pinned_cdr = cdr.nil? || cdr.pinned?(ctx)
 
-        @pinned_car && @pinned_cdr
+        pinned_car && pinned_cdr
       end
 
       # Return true if car and cdr fields have the same values as the other
@@ -166,7 +195,7 @@ module MiniKraken
         head = curr_cell = nil
         path = []
 
-        visitor = ConsCellVisitor.df_visitor(self) # Breadth-first!
+        visitor = ConsCellVisitor.df_visitor(self)
         skip_children = false
 
         loop do
@@ -180,9 +209,15 @@ module MiniKraken
               if curr_cell
                 curr_cell.set!(side, new_cell)
                 path.push(curr_cell) unless side == :cdr
+              else
+                head = new_cell                
+                path.push(new_cell)
+              end
+              if side == :cdr && cell.null?
+                curr_cell = path.pop
+              else
+                curr_cell = new_cell
               end
-              curr_cell = new_cell
-              head ||= new_cell
 
             when Core::LogVarRef
               # Is this robust?
@@ -194,7 +229,6 @@ module MiniKraken
               expanded = ctx.expand_value_of(i_name, theSubstitutions)
               curr_cell.set!(side, expanded)
               curr_cell = path.pop if side == :cdr
-
             else
               curr_cell.set!(side, cell)
               curr_cell = path.pop if side == :cdr
@@ -245,47 +279,15 @@ module MiniKraken
         head
       end
 
-      # Set one element of the pair
-      # @param member [Symbol]
-      # @param element [Term]
-      def set!(member, element)
-        case member
-          when :car
-            set_car!(element)
-          when :cdr
-            @pinned_cdr = nil
-            @cdr = element
-          else
-            raise StandardError, "Undefined cons cell member #{member}"
-          end
-      end
-
-      # Change the car of ConsCell to 'element'.
-      # Analogue of set-car! procedure in Scheme.
-      # @param element [Term]
-      def set_car!(element)
-        @pinned_car = nil # To force re-evaluation
-        @car = element
-      end
-
-      # Change the cdr of ConsCell to 'element'.
-      # Analogue of set-cdr! procedure in Scheme.
-      # @param element [Term]
-      def set_cdr!(element)
-        @pinned_cdr = nil # To force re-evaluation
-        @cdr = (element.kind_of?(ConsCell) && element.null?) ? nil : element
-      end
-
       protected
 
       def pair_to_s
         result = +car.to_s
         if cdr
-          result << ' '
           if cdr.kind_of?(ConsCell)
-            result << cdr.pair_to_s
+            result << " #{cdr.pair_to_s}" unless cdr.null?
           else
-            result << ". #{cdr}"
+            result << " . #{cdr}"
           end
         end
 

data/lib/mini_kraken/composite/cons_cell_visitor.rb

@@ -33,7 +33,7 @@ module MiniKraken
             next if skip_children || skipping
 
             skipping = false
-            if cell.is_a?(ConsCell)
+            if cell.is_a?(ConsCell) && !cell.null?
               visit_stack.push([:cdr, cell.cdr])
               visit_stack.push([:car, cell.car])
             end

data/lib/mini_kraken/core/parametrized_term.rb

@@ -34,7 +34,14 @@ module MiniKraken
       # @return [Term]
       def dup_cond(substitutions)
         duplicate = dup
-        updated_actuals = actuals.map { |e| e.dup_cond(substitutions) }
+
+        updated_actuals = actuals.map do |e|
+          if e.is_a?(Array)
+            e.map {|item| item.dup_cond(substitutions) }
+          else
+            e.dup_cond(substitutions) 
+          end
+        end
         duplicate.actuals.concat(updated_actuals)
 
         duplicate

data/lib/mini_kraken/glue/dsl.rb

@@ -60,6 +60,7 @@ module MiniKraken
           when Array
             formals = theFormals
         end
+
         rela = Rela::DefRelation.new(relationName, aGoalExpr, formals)
         add_defrel(rela)
       end

data/lib/mini_kraken/rela/unify.rb

@@ -156,11 +156,11 @@ module MiniKraken
         skip_children1 = skip_children2 = false
 
         loop do
-          # side.. can be: :car, :cdr, :stop
+          # side can be: :car, :cdr, :stop
           side1, cell1 = visitor1.resume(skip_children1)
           side2, cell2 = visitor2.resume(skip_children2)
           if side1 != side2
-            ctx.failed
+            ctx.failed!
           elsif side1 == :stop
             break
           else
@@ -244,8 +244,15 @@ module MiniKraken
         if ref1.unbound?(ctx) || ref2.unbound?(ctx)
           ctx.fuse([ref1.name, ref2.name])
           ctx.succeeded!
+        elsif ref1.floating?(ctx) && ref2.floating?(ctx)
+          raise StandarrError if  ctx.associations_for(ref1.name).size > 1
+          val1 = ctx.associations_for(ref1.name)[0].value
+          raise StandarrError if  ctx.associations_for(ref2.name).size > 1          
+          val2 = ctx.associations_for(ref2.name)[0].value
+          unification(val1, val2, ctx)
+          ctx.fuse([ref1.name, ref2.name]) if ctx.success?
         else
-          raise NotImplentedError
+          raise NotImplementedError
         end
         # if both refs are fresh, fuse them
         # if one ref is fresh & the other one isn't then bind fresh one (occurs check)

data/lib/mini_kraken/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniKraken
-  VERSION = '0.3.02'
+  VERSION = '0.3.03'
 end

data/spec/composite/cons_cell_spec.rb

@@ -53,10 +53,10 @@ module MiniKraken
           expect(NullList).to be_null
         end
 
-        it 'simplifies cdr if its referencing a null list' do
+        it 'initialize cdr if its referencing the null list' do
           instance = ConsCell.new(pea, NullList)
           expect(instance.car).to eq(pea)
-          expect(instance.cdr).to be_nil
+          expect(instance.cdr).to be_null
         end
       end # context
 
@@ -83,7 +83,7 @@ module MiniKraken
           head = ConsCell.new(pod)
           instance.set_car!(head)
           expect(instance.car).to eq(head)
-          expect(instance.cdr).to be_nil
+          expect(instance.cdr).to be_null
         end
 
         it 'should set_cdr! another cons cell' do

data/spec/composite/cons_cell_visitor_spec.rb

@@ -32,8 +32,8 @@ module MiniKraken
           null_list = ConsCell.null
           visitor = subject.df_visitor(null_list)
           expect(visitor.resume).to eq([:car, null_list])
-          expect(visitor.resume).to eq([:car, nil])
-          expect(visitor.resume).to eq([:cdr, nil])
+
+          # The car and cdr fields aren't visited
           expect(visitor.resume).to eq([:stop, nil])
         end
 
@@ -41,7 +41,7 @@ module MiniKraken
           visitor = subject.df_visitor(l_pea)
           expect(visitor.resume).to eq([:car, l_pea])
           expect(visitor.resume).to eq([:car, pea])
-          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:stop, nil])
         end
 
@@ -51,7 +51,7 @@ module MiniKraken
           expect(visitor.resume).to eq([:car, pea])
           expect(visitor.resume).to eq([:cdr, l_pea_pod.cdr])
           expect(visitor.resume).to eq([:car, pod])
-          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:stop, nil])
         end
 
@@ -63,7 +63,7 @@ module MiniKraken
           expect(visitor.resume).to eq([:car, pod])
           expect(visitor.resume).to eq([:cdr, l_pea_pod_corn.cdr.cdr])
           expect(visitor.resume).to eq([:car, corn])
-          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:stop, nil])
         end
       end # context
@@ -106,8 +106,8 @@ module MiniKraken
           expect(visitor.resume).to eq([:car, composite.car])
           expect(visitor.resume).to eq([:car, composite.car.car])
           expect(visitor.resume).to eq([:car, pea])
-          expect(visitor.resume).to eq([:cdr, nil])
-          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, NullList])
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:cdr, pod])
         end
       end # context
@@ -134,7 +134,7 @@ module MiniKraken
           # Tell to skip children by passing a true value to resume
           expect(visitor.resume(true)).to eq([:cdr, tree.cdr.cdr])
           expect(visitor.resume).to eq([:car, corn])
-          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:stop, nil])
         end
       end # context
@@ -149,7 +149,9 @@ module MiniKraken
           expect(visitor.resume).to eq([:car, first_cell])
           expect(visitor.resume).to eq([:car, pea])
           expect(visitor.resume).to eq([:cdr, second_cell])
-          expect(visitor.resume).to eq([:cdr, nil]) # Skip car (was already visited)
+
+          # Skip car (was already visited)
+          expect(visitor.resume).to eq([:cdr, NullList])
           expect(visitor.resume).to eq([:stop, nil])
         end
       end # context

data/spec/glue/dsl_chap2_spec.rb

@@ -230,7 +230,8 @@ module MiniKraken
           #   (caro  p a)
           #   (cdro p d))
 
-          # As 'p' has a special meaning in Ruby, the argument has been remaned to 'r'
+          # As 'p' has a special meaning in Ruby, the argument has been renamed
+          # to 'r'
           conso_rel = defrel('conso', %w[a d r], [caro(r, a), cdro(r, d)])
 
           expect(conso_rel).to be_kind_of(Rela::DefRelation)
@@ -254,16 +255,17 @@ module MiniKraken
           expect(g2.actuals[1].name).to match(/^d_/)
         end
 
-        # In Scheme:
-          # (defrel (conso a d p)
-          #   (caro  p a)
-          #   (cdro p d))
-        # In Ruby, `p`is a standard Kernel method => replace it by `r`
+
         def defrel_conso
           defrel_caro
           defrel_cdro
 
           # Definition derived from frame 2:25
+          # In Scheme:
+          # (defrel (conso a d p)
+          #   (caro  p a)
+          #   (cdro p d))
+          # In Ruby, `p`is a standard Kernel method => replace it by `r`
           # defrel('conso', %w[a d r], [caro(r, a), cdro(r, d)])
 
           # Definition derived from frame 2:26
@@ -344,6 +346,189 @@ module MiniKraken
           result = run_star('l', expr)
           expect(result.to_s).to eq('((:d :a :d :c))')
         end
+
+        # it 'passes frame 2:25' do
+          # defrel_conso
+
+          # # (run* l
+          # #   (fresh (d t x y w)
+          # #     (conso w '(n u s) t)
+          # #     (cdro l t)
+          # #     (caro l x)
+          # #     (== 'b x)
+          # #     (cdro l d)
+          # #     (caro d y)
+          # #     (== 'o y))) ;; => ((b o n u s))
+
+          # expr = fresh(%w[d t x y w],
+            # [conso(w, list(:n, :u, :s), t),
+              # cdro(l, t),
+              # caro(l, x),
+              # unify(:b, x),
+              # cdro(l, d),
+              # caro(d, y),
+              # unify(:o, y)])
+          # result = run_star('l', expr)
+          # expect(result.to_s).to eq('((:b :o :n :u :s))')
+        # end
+
+        it 'accepts nullo definition inspired from frame 2:33' do
+          # Reasoned S2, frame 2:33
+          # (defrel (nullo x)
+          #   (==  '() x)
+
+          nullo_rel = defrel('nullo', %w[x], unify(null, x))
+
+          expect(nullo_rel).to be_kind_of(Rela::DefRelation)
+          expect(nullo_rel.name).to eq('nullo')
+          expect(nullo_rel.arity).to eq(1)
+          expect(nullo_rel.formals[0]).to match(/^x_[-0-9a-f]+$/)
+          g_template = nullo_rel.expression
+          expect(g_template.relation).to be_kind_of(Rela::Unify)
+          expect(g_template.actuals[0]).to be_null
+          expect(g_template.actuals[1]).to be_kind_of(Core::LogVarRef)
+          expect(g_template.actuals[1].name).to match(/^x_[-0-9a-f]+$/)
+        end
+
+        def defrel_nullo
+          # Definition derived from frame 2:33
+          defrel('nullo', %w[x], unify(null_list, x))
+        end
+
+        it 'passes frame 2:30' do
+          defrel_nullo
+
+          # (run* q
+          #   (nullo '(grape raisin pear))) ;; => ()
+
+          result = run_star('q', nullo(list(:grape, :raisin, :pear)))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 2:31' do
+          defrel_nullo
+
+          # (run* q
+          #   (nullo '())) ;; => (_0)
+
+          result = run_star('q', nullo(null_list))
+          expect(result.to_s).to eq('(_0)')
+        end
+
+        it 'passes frame 2:32' do
+          defrel_nullo
+
+          # (run* x
+          #   (nullo x)) ;; => (())
+
+          result = run_star('x', nullo(x))
+          expect(result.to_s).to eq('(())')
+        end
+
+        it 'passes frame 2:35' do
+          defrel_nullo
+
+          # (run* r
+          #   (fresh (x y)
+          #     (== (cons x (cons y 'salad)) r))) ;; => ((_0 _1 . salad))
+
+          result = run_star('r', fresh(%w[x y],
+            unify(cons(x, cons(y, :salad)), r)))
+          expect(result.to_s).to eq('((_0 _1 . :salad))')
+        end
+
+        it 'passes frame 2:45' do
+          defrel_nullo
+
+          # (run* r
+          #   (fresh (x y)
+          #     (== (cons x (cons y 'salad)) r))) ;; => ((_0 _1 . salad))
+
+          result = run_star('r', fresh(%w[x y],
+            unify(cons(x, cons(y, :salad)), r)))
+          expect(result.to_s).to eq('((_0 _1 . :salad))')
+        end
+
+        it 'accepts pairo definition inspired from frame 2:46' do
+          defrel_conso
+
+          # Reasoned S2, frame 2:46
+          # (defrel (pairo r)
+          #   (fresh (a d)
+          #     (conso a d r)))
+
+          pairo_rel = defrel('pairo', %w[r],fresh(%w[a d], conso(a, d, r)))
+
+          expect(pairo_rel).to be_kind_of(Rela::DefRelation)
+          expect(pairo_rel.name).to eq('pairo')
+          expect(pairo_rel.arity).to eq(1)
+          expect(pairo_rel.formals[0]).to match(/^r_[-0-9a-f]+$/)
+          g_template = pairo_rel.expression
+          expect(g_template.relation).to be_kind_of(Rela::Fresh)
+          expect(g_template.actuals[0]).to eq(%w[a d])
+          expect(g_template.actuals[1]).to be_kind_of(Core::Goal)
+          expect(g_template.actuals[1].relation.name).to eq('conso')
+          expect(g_template.actuals[1].actuals[0].name).to eq('a')
+          expect(g_template.actuals[1].actuals[1].name).to eq('d')
+          expect(g_template.actuals[1].actuals[2].name).to match(/^r_[-0-9a-f]+$/)
+        end
+
+        def defrel_pairo
+          defrel_conso
+
+          # Definition derived from frame 2:46
+          defrel('pairo', %w[r],fresh(%w[a d], conso(a, d, r)))
+        end
+
+        it 'passes frame 2:47' do
+          defrel_pairo
+
+          # (run* q
+          #   (pairo (cons q q))) ;; => (_0)
+
+          result = run_star('q', pairo(cons(q, q)))
+          expect(result.to_s).to eq('(_0)')
+        end
+        
+        it 'passes frame 2:48' do
+          defrel_pairo
+
+          # (run* q
+          #   (pairo '())) ;; => ()
+
+          result = run_star('q', pairo(null_list))
+          expect(result.to_s).to eq('()')
+        end
+
+        it 'passes frame 2:49' do
+          defrel_pairo
+
+          # (run* q
+          #   (pairo 'pair)) ;; => ()
+
+          result = run_star('q', pairo(:pair))
+          expect(result.to_s).to eq('()')
+        end
+
+        it 'passes frame 2:50' do
+          defrel_pairo
+
+          # (run* x
+          #   (pairo x)) ;; => ((_0 . _1))
+
+          result = run_star('x', pairo(x))
+          expect(result.to_s).to eq('((_0 . _1))')
+        end
+
+        it 'passes frame 2:51' do
+          defrel_pairo
+
+          # (run* r
+          #   (pairo (cons r '()))) ;; => (_0)
+
+          result = run_star('r', pairo(cons(r, null_list)))
+          expect(result.to_s).to eq('(_0)')
+        end         
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.3.02
+  version: 0.3.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-19 00:00:00.000000000 Z
+date: 2020-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler