mini_kraken 0.1.12 → 0.2.03

data/spec/glue/dsl_chap2_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/glue/dsl'
+
+
+module MiniKraken
+  module Glue
+    describe 'DSL (Chap 2)' do
+      include DSL
+
+      context 'Chapter 2 examples:' do
+        let(:acorn) { cons(:a, cons(:c, cons(:o, cons(:r, cons(:n))))) }
+
+        it 'accepts caro definition inspired from frame 2:6' do
+          # Reasoned S2, frame 2:6
+          # (defrel (caro p a)
+          #   (fresh (d)
+          #   (== (cons a d) p)))
+
+          # As 'p' has a special meaning in Ruby, the argument has been remaned to 'r'
+          caro_rel = defrel('caro', %w[r a]) do
+            fresh('d', equals(cons(a, d), r))
+          end
+
+          expect(caro_rel).to be_kind_of(Core::DefRelation)
+          expect(caro_rel.name).to eq('caro')
+          expect(caro_rel.arity).to eq(2)
+          expect(caro_rel.formals[0].name).to eq('r')
+          expect(caro_rel.formals[1].name).to eq('a')
+          g_template = caro_rel.goal_template
+          expect(g_template).to be_kind_of(FreshEnvFactory)
+          expect(g_template.names).to include('d')
+        end
+
+        # In Scheme:
+        # (defrel (caro p a)
+        #   (fresh (d)
+        #   (== (cons a d) p)))
+        # In Ruby, `p`is a stnadard Kernel method => replaced by `r`
+        def defrel_caro
+          defrel('caro', %w[r a]) { fresh('d', equals(cons(a, d), r)) }
+        end
+
+        it 'passes frame 2:3' do
+          defrel_caro
+
+          # (run* q
+          #   (caro '(a c o r n) q)) ;; => (a)
+          result = run_star('q', caro(acorn, q))
+          expect(result.car).to eq(:a)
+        end
+
+        it 'passes frame 2:4' do
+          defrel_caro
+
+          # (run* q
+          #   (caro '(a c o r n) 'a)) ;; => (_0)
+          result = run_star('q', caro(acorn, :a))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 2:5' do
+          defrel_caro
+
+          # (run* r
+          #   (fresh (x y)
+          #     (caro '(,r ,y) x)
+          #     (== 'pear x)));; r => (pear)
+          result = run_star('r', fresh(%w[x y],
+            [caro(cons(r, cons(y)), x),
+              equals(:pear, x)]))
+          expect(result.car).to eq(:pear)
+        end
+
+        it 'passes frame 2:8' do
+          defrel_caro
+
+          # (run* r
+          #   (fresh (x y)
+          #     (caro '(grape raisin pear) x)
+          #     (caro '((a) (b) (c)) y)
+          #     (== (cons x y) r))) ;; r => ((grape a))
+          fruits = cons(:grape, cons(:raisin, cons(:pear)))
+          expect(fruits.to_s).to eq('(:grape :raisin :pear)')
+          abc = cons(cons(:a), cons(cons(:b), cons(cons(:c))))
+          expect(abc.to_s).to eq('((:a) (:b) (:c))')
+
+          result = run_star('r', fresh(%w[x y],
+            [caro(fruits, x),
+              caro(abc, y),
+              equals(cons(x, y), r)]))
+          expect(result.car).to eq(cons(:grape, cons(:a)))
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/fresh_env_factory_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal_template'
+
+require_relative '../support/factory_methods'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/glue/fresh_env_factory'
+
+
+module MiniKraken
+  module Glue
+    describe FreshEnvFactory do
+      include FactoryMethods
+
+      # (fresh (d) (== d r))
+      let(:r_formal_ref) { Core::FormalRef.new('r') }
+      let(:d_ref) { var_ref('d') }
+      let(:sample_goal_t) do
+        Core::GoalTemplate.new(Core::Equals.instance, [d_ref, r_formal_ref])
+      end
+      subject { FreshEnvFactory.new(['d'], sample_goal_t) }
+
+      context 'Initialization:' do
+        it 'should be initialized with names and a goal template' do
+          expect { FreshEnvFactory.new(['d'], sample_goal_t) }.not_to raise_error
+        end
+
+        it 'should know the variable names' do
+          expect(subject.names).to eq(['d'])
+        end
+
+        it 'should know the goal template' do
+          expect(subject.goal_template).to eq(sample_goal_t)
+        end
+      end # context
+
+      context 'Factory for FreshEnv instances' do
+        # (defrel (caro r a)
+        #   (fresh (d)
+        #   (== (cons a d) r)))
+        # ;; r, a are formal args, they part of caro signature
+        # ;; d is a formal ref argument
+        let(:pea) { k_symbol(:pea) }
+        let(:q_ref) { var_ref('q') }
+        let(:r_formal) { Core::FormalRef.new('r') }
+        let(:a_formal) { Core::FormalRef.new('a') }
+        let(:t_param1) { Core::ConsCell.new(a_formal, d_ref) }
+        let(:other_goal_t) do
+          Core::GoalTemplate.new(Core::Equals.instance, [t_param1, r_formal])
+        end
+
+        # (fresh (d) (== d r))
+        it 'should build FreshEnv instance with simple goal' do
+          created = subject.instantiate([r_formal], [pea])
+
+          # Are variables correctly built?
+          expect(created).to be_kind_of(FreshEnv)
+          expect(created.vars['d']).to be_kind_of(Core::Variable)
+
+          # Is the goal correectly built?
+          goal = created.goal
+          expect(goal.relation).to eq(Core::Equals.instance)
+          expect(goal.actuals[0]).to be_kind_of(Core::VariableRef)
+          expect(goal.actuals[0].name).to eq('d')
+          expect(goal.actuals[1]).to be_kind_of(Core::KSymbol)
+          expect(goal.actuals[1]).to eq(:pea)
+        end
+
+        it 'should build FreshEnv instance with goal' do
+          instance = FreshEnvFactory.new(['d'], other_goal_t)
+          acorn = cons(k_symbol(:a), cons(k_symbol(:c), cons(k_symbol(:o),
+            cons(k_symbol(:r), cons(k_symbol(:n))))))
+          created = instance.instantiate([r_formal, a_formal], [acorn, q_ref])
+
+          # Are variables correctly built?
+          expect(created).to be_kind_of(FreshEnv)
+          expect(created.vars['d']).to be_kind_of(Core::Variable)
+
+          # Is the goal correctly built?
+          goal = created.goal
+          expect(goal.relation).to eq(Core::Equals.instance)
+          expect(goal.actuals[0]).to be_kind_of(Core::ConsCell)
+          expect(goal.actuals[0].car).to be_kind_of(Core::VariableRef)
+          expect(goal.actuals[0].car.name).to eq('q')
+          expect(goal.actuals[0].cdr).to be_kind_of(Core::VariableRef)
+          expect(goal.actuals[0].cdr.name).to eq('d')
+          expect(goal.actuals[1]).to be_kind_of(Core::ConsCell)
+          expect(goal.actuals[1].to_s).to eq('(:a :c :o :r :n)')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -23,6 +23,7 @@ module MiniKraken
   module Glue
     describe RunStarExpression do
       include FactoryMethods
+
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
       let(:sample_goal) { equals_goal(pea, pod) }
@@ -126,6 +127,7 @@ module MiniKraken
 
         it 'should return a null list with the succeed goal' do
           instance = RunStarExpression.new('q', succeeds)
+          expect(instance.env.vars).to be_include('q')
 
           # (display (run* q succeed)) ;; => (_0)
           # Reasoned S2, frame 1:16
@@ -243,7 +245,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:34
-          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pod)
+          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
           result = instance.run
           expect(result.car).to eq(pea)
         end
@@ -264,8 +266,8 @@ module MiniKraken
         it 'should unify complex equality expressions (IV)' do
           # 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)
+          expr1 = cons(cons(cons(ref_q)), cons(ref_x))
+          expr2 = cons(cons(cons(ref_x)), cons(pod))
           goal = equals_goal(expr1, expr2)
           fresh_env = FreshEnv.new(['x'], goal)
           instance = RunStarExpression.new('q', fresh_env)
@@ -362,7 +364,6 @@ module MiniKraken
           expect(result.car).to eq(any_value(0))
         end
 
-        # TODO: fix erratic RSpec failure
         it 'should support conjunction of one succeed and a successful goal' do
           subgoal = equals_goal(corn, ref_q)
           goal = conj2_goal(succeeds, subgoal)
@@ -480,7 +481,7 @@ module MiniKraken
           # Reasoned S2, frame 1:62
           # (run* x (disj2
           #           (conj2 (== 'olive x) fail)
-          #           ('oil x))) ;; => (oil)
+          #           (== 'oil x))) ;; => (oil)
           result = instance.run
           expect(result.car).to eq(oil)
         end
@@ -510,7 +511,7 @@ module MiniKraken
 
           # Reasoned S2, frame 1:64
           # (run* x (disj2
-          #           ('oil x)
+          #           (== 'oil x)
           #           (conj2 (== 'olive x) succeed))) ;; => (oil olive)
           result = instance.run
           expect(result.car).to eq(oil)
@@ -529,11 +530,11 @@ module MiniKraken
 
           # Reasoned S2, frame 1:65
           # (run* x (disj2
-          #           (conj2(== 'virgin x) fails)
+          #           (conj2(== 'virgin x) fail)
           #           (disj2
           #             (== 'olive x)
           #             (dis2
-          #               succeeds
+          #               succeed
           #               (== 'oil x))))) ;; => (olive _0 oil)
           result = instance.run
           expect(result.car).to eq(olive)
@@ -648,7 +649,7 @@ module MiniKraken
           expect(result.car.cdr.cdr.cdr).to be_nil
         end
 
-        it 'should allow simplication of expressions' do
+        it 'should allow simplification of expressions' do
           expr1 = equals_goal(split, ref_x)
           expr2 = equals_goal(pea, ref_y)
           goal = conj2_goal(expr1, expr2)
@@ -968,8 +969,7 @@ module MiniKraken
           #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
           result = instance.run
           expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
-          # Bug: next line fails
-          # expect(result.cdr.car).to eq(cons(any_value(0), cons(any_value(0))))
+          expect(result.cdr.car).to eq(cons(any_value(0), cons(any_value(0))))
         end
 
         it 'accepts conde with more than two condition lines' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,7 @@ extra_rdoc_files:
 - README.md
 files:
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -79,6 +80,7 @@ files:
 - lib/mini_kraken/core/conde.rb
 - lib/mini_kraken/core/conj2.rb
 - lib/mini_kraken/core/cons_cell.rb
+- lib/mini_kraken/core/cons_cell_visitor.rb
 - lib/mini_kraken/core/def_relation.rb
 - lib/mini_kraken/core/designation.rb
 - lib/mini_kraken/core/disj2.rb
@@ -104,15 +106,19 @@ files:
 - lib/mini_kraken/core/variable.rb
 - lib/mini_kraken/core/variable_ref.rb
 - lib/mini_kraken/core/vocabulary.rb
+- lib/mini_kraken/glue/dsl.rb
 - lib/mini_kraken/glue/fresh_env.rb
+- lib/mini_kraken/glue/fresh_env_factory.rb
 - lib/mini_kraken/glue/run_star_expression.rb
 - lib/mini_kraken/version.rb
 - mini_kraken.gemspec
+- spec/.rubocop.yml
 - spec/core/association_spec.rb
 - spec/core/association_walker_spec.rb
 - spec/core/conde_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/cons_cell_visitor_spec.rb
 - spec/core/def_relation_spec.rb
 - spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
@@ -128,6 +134,9 @@ files:
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb
 - spec/core/vocabulary_spec.rb
+- spec/glue/dsl_chap1_spec.rb
+- spec/glue/dsl_chap2_spec.rb
+- spec/glue/fresh_env_factory_spec.rb
 - spec/glue/fresh_env_spec.rb
 - spec/glue/run_star_expression_spec.rb
 - spec/mini_kraken_spec.rb
@@ -144,9 +153,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -163,6 +172,7 @@ test_files:
 - spec/core/conde_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/cons_cell_visitor_spec.rb
 - spec/core/def_relation_spec.rb
 - spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
@@ -178,6 +188,9 @@ test_files:
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb
 - spec/core/vocabulary_spec.rb
+- spec/glue/dsl_chap1_spec.rb
+- spec/glue/dsl_chap2_spec.rb
+- spec/glue/fresh_env_factory_spec.rb
 - spec/glue/fresh_env_spec.rb
 - spec/glue/run_star_expression_spec.rb
 - spec/mini_kraken_spec.rb