mini_kraken 0.2.02 → 0.2.03

data/spec/core/def_relation_spec.rb

@@ -17,6 +17,7 @@ require_relative '../../lib/mini_kraken/core/def_relation'
 module MiniKraken
   module Core
     describe DefRelation do
+      # (defrel (teao t) (== 'tea t))
       let(:tea) { KSymbol.new(:tea) }
       let(:formal_t) { FormalArg.new('t') }
       let(:t_ref) { FormalRef.new('t') }
@@ -53,13 +54,13 @@ module MiniKraken
           defrel = DefRelation.new('teao', equals_tea, [formal_t])
           solver = defrel.solver_for([tea], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           outcome = solver.resume
           expect(outcome).to be_nil
 
           solver = defrel.solver_for([cup], env)
           outcome = solver.resume
-          expect(outcome).not_to be_successful
+          expect(outcome).not_to be_success
           outcome = solver.resume
           expect(outcome).to be_nil
         end
@@ -69,7 +70,7 @@ module MiniKraken
           env.add_var(Variable.new('x'))
           solver = defrel.solver_for([ref_x], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(ref_x.value(outcome)).to eq(tea)
 
           outcome = solver.resume
@@ -80,11 +81,11 @@ module MiniKraken
           env.add_var(Variable.new('x'))
           solver = subject.solver_for([ref_x], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(ref_x.value(outcome)).to eq(tea)
 
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(ref_x.value(outcome)).to eq(cup)
 
           outcome = solver.resume

data/spec/core/disj2_spec.rb

@@ -52,7 +52,7 @@ module MiniKraken
         it 'should fails if both arguments fail' do
           # Covers frame 1:55
           solver = subject.solver_for([fails, fails], env)
-          expect(solver.resume).not_to be_successful
+          expect(solver.resume).not_to be_success
           expect(solver.resume).to be_nil
         end
 
@@ -61,7 +61,7 @@ module MiniKraken
           subgoal = Goal.new(Equals.instance, [olive, ref_q])
           solver = subject.solver_for([subgoal, fails], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations['q'].first.value).to eq(olive)
           expect(solver.resume).to be_nil
         end
@@ -71,7 +71,7 @@ module MiniKraken
           subgoal = Goal.new(Equals.instance, [oil, ref_q])
           solver = subject.solver_for([fails, subgoal], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations['q'].first.value).to eq(oil)
           expect(solver.resume).to be_nil
         end
@@ -84,12 +84,12 @@ module MiniKraken
 
           # First solution
           outcome1 = solver.resume
-          expect(outcome1).to be_successful
+          expect(outcome1).to be_success
           expect(outcome1.associations['q'].first.value).to eq(olive)
 
           # Second solution
           outcome2 = solver.resume
-          expect(outcome2).to be_successful
+          expect(outcome2).to be_success
           expect(outcome2.associations['q'].first.value).to eq(oil)
           expect(solver.resume).to be_nil
         end

data/spec/core/duck_fiber_spec.rb

@@ -40,7 +40,7 @@ module MiniKraken
           succeeding = DuckFiber.new(:success)
           outcome = nil
           expect { outcome = succeeding.resume }.not_to raise_error
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.parent).to be_nil
 
           # Only one result should be yielded

data/spec/core/equals_spec.rb

@@ -106,7 +106,7 @@ module MiniKraken
         it 'should succeed for a right-handed fresh argument' do
           result = solve_for(pea, ref_q)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations.size).to eq(1)
           expect(env.associations['q'].first.value).to eq(pea)
           expect(var_q.fresh?(result)).to be_falsey
@@ -116,7 +116,7 @@ module MiniKraken
         it 'should succeed for a left-handed fresh argument' do
           result = solve_for(ref_q, pea)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations.size).to eq(1)
           expect(env.associations['q'].first.value).to eq(pea)
           expect(var_q.fresh?(result)).to be_falsey
@@ -127,7 +127,7 @@ module MiniKraken
           ref_q.associate(pod, env)
 
           result = solve_for(pod, ref_q)
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations.size).to eq(1) # No new association
           expect(ref_q.fresh?(result)).not_to be_truthy
           expect(ref_q.values(result).first).to eq(pod)
@@ -137,7 +137,7 @@ module MiniKraken
           ref_q.associate(pod, env)
 
           result = solve_for(ref_q, pod)
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).to be_falsey
           expect(ref_q.values(result).first).to eq(pod)
@@ -147,7 +147,7 @@ module MiniKraken
           ref_q.associate(pod, env)
 
           result = solve_for(pea, ref_q)
-          expect(result).not_to be_successful
+          expect(result).not_to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).to be_falsey
           expect(ref_q.values(result).first).to eq(pod)
@@ -157,7 +157,7 @@ module MiniKraken
           ref_q.associate(pod, env)
 
           result = solve_for(ref_q, pea)
-          expect(result).not_to be_successful
+          expect(result).not_to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).to be_falsey
           expect(ref_q.values(result).first).to eq(pod)
@@ -166,7 +166,7 @@ module MiniKraken
         it 'should succeed for a composite and right-handed fresh argument' do
           result = solve_for(sample_cons, ref_q)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations.size).to eq(1)
           expect(ref_q.fresh?(result)).to be_falsey
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -175,7 +175,7 @@ module MiniKraken
         it 'should succeed for composite and left-handed fresh argument' do
           result = solve_for(ref_q, sample_cons)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations.size).to eq(1)
           expect(ref_q.fresh?(result)).to be_falsey
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -186,7 +186,7 @@ module MiniKraken
           composite = ConsCell.new(pea)
           result = solve_for(composite, ref_q)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).not_to be_truthy
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -197,7 +197,7 @@ module MiniKraken
           composite = ConsCell.new(pea)
           result = solve_for(ref_q, composite)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).not_to be_truthy
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -208,7 +208,7 @@ module MiniKraken
           composite = ConsCell.new(pod)
           result = solve_for(composite, ref_q)
 
-          expect(result).not_to be_successful
+          expect(result).to be_failure
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).not_to be_truthy
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -219,7 +219,7 @@ module MiniKraken
           composite = ConsCell.new(pod)
           result = solve_for(ref_q, composite)
 
-          expect(result).not_to be_successful
+          expect(result).not_to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).not_to be_truthy
           expect(ref_q.values(result).first).to eq(sample_cons)
@@ -228,7 +228,7 @@ module MiniKraken
         it 'should succeed for both identical fresh arguments' do
           result = solve_for(ref_q, ref_q)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).to be_truthy
         end
@@ -236,7 +236,7 @@ module MiniKraken
         it 'should succeed for both same fresh arguments' do
           result = solve_for(ref_q, ref_q_bis)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
           expect(ref_q.fresh?(result)).to be_truthy
           expect(ref_q_bis.fresh?(result)).to be_truthy
@@ -245,7 +245,7 @@ module MiniKraken
         it 'should succeed for both distinct fresh arguments' do
           result = solve_for(ref_x, ref_y)
 
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(env.associations).to be_empty # Symmetric association
           expect(ref_x.fresh?(result)).to be_truthy
           expect(ref_y.fresh?(result)).to be_truthy
@@ -258,7 +258,7 @@ module MiniKraken
           expect(ref_y.fresh?(env)).to be_falsey
 
           result = solve_for(ref_x, ref_y)
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(result.associations).to be_empty
         end
 
@@ -269,19 +269,20 @@ module MiniKraken
           expect(ref_y.fresh?(env)).to be_falsey
 
           result = solve_for(ref_x, ref_y)
-          expect(result).not_to be_successful
+          expect(result).not_to be_success
           expect(result.associations).to be_empty
         end
 
         it 'should unify composite terms with variables' 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))
+          expect(expr1.to_s).to eq('(((q)) x)')
+          expr2 = cons(cons(cons(ref_x)), cons(pod))
+          expect(expr2.to_s).to eq('(((x)) :pod)')
 
           result = solve_for(expr1, expr2)
-          # require 'debug'
-          expect(result).to be_successful
+          expect(result).to be_success
           expect(ref_x.fresh?(env)).to be_falsey
           expect(ref_q.fresh?(env)).to be_falsey
         end
@@ -298,6 +299,18 @@ module MiniKraken
           expect(result.resultant).to eq(:"#u")
           expect(result.associations).to be_empty
         end
+
+        it 'should unify variables with a list' do
+          # Variant of Reasoned S2, frame 2:3
+          # (== (cons q x) '(a c o r n)) ;; q => :a, x => '(c o r n)
+          expr1 = cons(ref_q, ref_x)
+          acorn = cons(k_symbol(:a), cons(k_symbol(:c),
+            cons(k_symbol(:o), cons(k_symbol(:r), cons(k_symbol(:n))))))
+          result = solve_for(expr1, acorn)
+          expect(result.resultant).to eq(:"#s")
+          q_value = env.associations['q'].first.value
+          expect(q_value).to eq(:a)
+        end
       end # context
     end # describe
   end # module

data/spec/core/goal_spec.rb

@@ -40,7 +40,7 @@ module MiniKraken
       context 'Provided services:' do
         it 'should fail if relation does not succeed' do
           solver = subject.attain(env)
-          expect(solver.resume).not_to be_successful
+          expect(solver.resume).not_to be_success
 
           # No more solution...
           expect(solver.resume).to be_nil
@@ -50,7 +50,7 @@ module MiniKraken
           instance = Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pea)])
 
           solver = instance.attain(env)
-          expect(solver.resume).to be_successful
+          expect(solver.resume).to be_success
 
           # No more solution...
           expect(solver.resume).to be_nil

data/spec/core/outcome_spec.rb

@@ -25,6 +25,14 @@ module MiniKraken
           expect(subject.resultant).to eq(:"#s")
         end
 
+        it 'should know whether it represents a failure' do
+          expect(Outcome.new(:"#u")).to be_failure
+        end
+
+        it 'should know whether it represents a success' do
+          expect(subject).to be_success
+        end
+
         it 'should know its parent' do
           expect(subject.parent).to eq(voc)
         end

data/spec/core/variable_ref_spec.rb

@@ -21,6 +21,9 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        it 'knows its text representation' do
+          expect(subject.to_s).to eq('q')
+        end
       end # context
     end # describe
   end # module

data/spec/glue/dsl_chap1_spec.rb

@@ -113,7 +113,11 @@ module MiniKraken
           # Reasoned S2, frame 1:34
           # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
 
-          result = run_star('q', equals(cons(cons(q), :pod), cons(cons(:pea), q)))
+          expr1 = cons(cons(cons(q)), cons(:pod))
+          expect(expr1.to_s).to eq('(((q)) :pod)')
+          expr2 = cons(cons(cons(:pea)), cons(:pod))
+          expect(expr2.to_s).to eq('(((:pea)) :pod)')
+          result = run_star('q', equals(expr1, expr2))
           expect(result.car).to eq(:pea)
         end
 
@@ -129,7 +133,11 @@ module MiniKraken
           # Reasoned S2, frame 1:36
           # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
 
-          result = run_star('q', fresh('x', equals(cons(cons(cons(q)), x), cons(cons(cons(x)), :pod))))
+          expr1 = cons(cons(cons(q)), cons(x))
+          expect(expr1.to_s).to eq('(((q)) x)')
+          expr2 = cons(cons(cons(x)), cons(:pod))
+          expect(expr2.to_s).to eq('(((x)) :pod)')
+          result = run_star('q', fresh('x', equals(expr1, expr2)))
           expect(result.car).to eq(:pod)
         end
 

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