mini_kraken 0.1.12 → 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
@@ -52,7 +52,7 @@ module MiniKraken
           outcome1 = instance1.resume
 
           instance2 = DuckFiber.new(:success)
-          outcome2 = instance1.resume
+          outcome2 = instance2.resume
 
           expect(outcome1).not_to be_equal(outcome2)
         end

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/k_boolean_spec.rb

@@ -101,6 +101,12 @@ module MiniKraken
           # Default Ruby representation, different value
           expect(subject == false).to be_falsy
         end
+
+        it 'provides a text representation of itself' do
+          expect(subject.to_s).to eq('true')
+          other = KBoolean.new('#f')
+          expect(other.to_s).to eq('false')
+        end
       end # context
     end # describe
   end # module

data/spec/core/k_symbol_spec.rb

@@ -65,6 +65,10 @@ module MiniKraken
           # Default Ruby representation, different value
           expect(subject == :pod).to be_falsy
         end
+
+        it 'should provide a string representation of itself' do
+          expect(subject.to_s).to eq(':pea')
+        end
       end # context
     end # describe
   end # module

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

@@ -0,0 +1,679 @@
+# 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 1)' do
+      include DSL
+
+      context 'Chapter 1 examples:' do
+        it 'passes frame 1:7' do
+          # Reasoned S2, frame 1:7
+          # (run* q #u) ;; => ()
+
+          result = run_star('q', _fail)
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:10' do
+          # Reasoned S2, frame 1:10
+          # (run* q (== 'pea 'pod) ;; => ()
+
+          result = run_star('q', equals(:pea, :pod))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:11' do
+          # Reasoned S2, frame 1:11
+          # (run* q (== q 'pea) ;; => (pea)
+
+          result = run_star('q', equals(q, :pea))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:12' do
+          # Reasoned S2, frame 1:12
+          # (run* q (== 'pea q) ;; => (pea)
+
+          result = run_star('q', equals(:pea, q))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:17' do
+          # Reasoned S2, frame 1:17
+          # (run* q succeed) ;; => (_0)
+
+          result = run_star('q', succeed)
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:19' do
+          # Reasoned S2, frame 1:19
+          # (run* q (== 'pea 'pea)) ;; => (_0)
+
+          result = run_star('q', equals(:pea, :pea))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:20' do
+          # Reasoned S2, frame 1:20
+          # (run* q (== q q)) ;; => (_0)
+
+          result = run_star('q', equals(q, q))
+          expect(result.car).to eq(:_0)
+        end
+
+        it "supports 'fresh' and passes frame 1:21" do
+          # Reasoned S2, frame 1:21
+          # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
+
+          result = run_star('q', fresh('x', equals(:pea, q)))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:25' do
+          # Reasoned S2, frame 1:25
+          # (run* q (fresh (x) (== (cons x '()) q))) ;; => ((_0))
+          # require 'debug' Invalid goal argument
+          result = run_star('q', fresh('x', equals(cons(x, null), q)))
+          expect(result.car).to eq(cons(:_0))
+        end
+
+        it 'passes frame 1:31' do
+          # Reasoned S2, frame 1:31
+          # (run* q (fresh (x) (== x q))) ;; => (_0)
+
+          result = run_star('q', fresh('x', equals(x, q)))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:32' do
+          # Reasoned S2, frame 1:32
+          # (run* q (==  '(((pea)) pod) '(((pea)) pod))) ;; => (_0)
+
+          result = run_star('q', equals(cons(cons(:pea), :pod), cons(cons(:pea), :pod)))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:33' do
+          # Beware: quasiquoting
+          # Reasoned S2, frame 1:33
+          # (run* q (==  '(((pea)) pod) '(((pea)) ,q))) ;; => ('pod)
+
+          result = run_star('q', equals(cons(cons(:pea), :pod), cons(cons(:pea), q)))
+          expect(result.car).to eq(:pod)
+        end
+
+        it 'passes frame 1:34' do
+          # Reasoned S2, frame 1:34
+          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
+
+          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
+
+        it 'passes frame 1:35' do
+          # Reasoned S2, frame 1:35
+          # (run* q (fresh (x) (==  '(((,q)) pod) `(((,x)) pod)))) ;; => (_0)
+
+          result = run_star('q', fresh('x', equals(cons(cons(q), :pod), cons(cons(x), :pod))))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:36' do
+          # Reasoned S2, frame 1:36
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('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
+
+        it 'passes frame 1:37' do
+          # Reasoned S2, frame 1:37
+          # (run* q (fresh (x) (==  '( ,x ,x) q))) ;; => (_0 _0)
+
+          result = run_star('q', fresh('x', equals(cons(x, cons(x)), q)))
+          expect(result.car).to eq(cons(:_0, cons(:_0)))
+        end
+
+        it 'passes frame 1:38' do
+          # Reasoned S2, frame 1:38
+          # (run* q (fresh (x) (fresh (y) (==  '( ,q ,y) '((,x ,y) ,x))))) ;; => (_0 _0)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(q, cons(y)), cons(cons(x, cons(y)), cons(x))))))
+          expect(result.car).to eq(cons(:_0, cons(:_0)))
+        end
+
+        it 'passes frame 1:41' do
+          # Reasoned S2, frame 1:41
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y) q)))) ;; => (_0 _1)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(x, cons(y)), q))))
+          # q should be bound to '(,x ,y)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:42' do
+          # Reasoned S2, frame 1:42
+          # (run* s (fresh (t) (fresh (u) (==  '( ,t ,u) s)))) ;; => (_0 _1)
+
+          result = run_star('s', fresh('t', fresh('u', equals(cons(t, cons(u)), s))))
+          # s should be bound to '(,t ,u)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:43' do
+          # Reasoned S2, frame 1:43
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y ,x) q)))) ;; => (_0 _1 _0)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(x, cons(y, cons(x))), q))))
+          # q should be bound to '(,x ,y, ,x)
+          expect(result.car).to eq(cons(:_0, cons(:_1, cons(:_0))))
+        end
+
+        it "supports 'conj2' relation and passes frame 1:50" do
+          # Reasoned S2, frame 1:50
+          # (run* q (conj2 succeed succeed)) ;; => (_0)
+
+          result = run_star('q', conj2(succeed, succeed))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:51' do
+          # Reasoned S2, frame 1:51
+          # (run* q (conj2 succeed (== 'corn q)) ;; => ('corn)
+
+          result = run_star('q', conj2(succeed, equals(:corn, q)))
+          expect(result.car).to eq(:corn)
+        end
+
+        it 'passes frame 1:52' do
+          # Reasoned S2, frame 1:52
+          # (run* q (conj2 fail (== 'corn q)) ;; => ()
+
+          result = run_star('q', conj2(_fail, equals(:corn, q)))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:53' do
+          # Reasoned S2, frame 1:53
+          # (run* q (conj2 (== 'corn q)(== 'meal q)) ;; => ()
+
+          result = run_star('q', conj2(equals(:corn, q), equals(:meal, q)))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:54' do
+          # Reasoned S2, frame 1:54
+          # (run* q (conj2 (== 'corn q)(== 'corn q)) ;; => ('corn)
+
+          result = run_star('q', conj2(equals(:corn, q), equals(:corn, q)))
+          expect(result.car).to eq(:corn)
+        end
+
+        it "supports 'disj2' and passes frame 1:55" do
+          # Reasoned S2, frame 1:55
+          # (run* q (disj2 fail fail)) ;; => ()
+
+          result = run_star('q', disj2(_fail, _fail))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:56' do
+          # Reasoned S2, frame 1:56
+          # (run* q (disj2 (== 'olive q) fail)) ;; => ('olive)
+
+          result = run_star('q', disj2(equals(:olive, q), _fail))
+          expect(result.car).to eq(:olive)
+        end
+
+        it 'passes frame 1:57' do
+          # Reasoned S2, frame 1:57
+          # (run* q (disj2 fail (== 'oil q))) ;; => (oil)
+
+          result = run_star('q', disj2(_fail, equals(:oil, q)))
+          expect(result.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:58' do
+          # Reasoned S2, frame 1:58
+          # (run* q (disj2 (== 'olive q) (== 'oil q))) ;; => (olive oil)
+
+          result = run_star('q', disj2(equals(:olive, q), equals(:oil, q)))
+          expect(result.car).to eq(:olive)
+          expect(result.cdr.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:59' do
+          # Reasoned S2, frame 1:59
+          # (run* q (fresh (x) (fresh (y) (disj2  (== '( ,x ,y ) q) (== '( ,x ,y ) q)))))
+          # ;; => ((_0 _1) (_0 _1))
+
+          result = run_star('q', fresh('x', (fresh 'y', disj2(equals(cons(x, cons(y)), q), equals(cons(x, cons(y)), q)))))
+          # q should be bound to '(,x ,y), then to '(,y ,x)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+          expect(result.cdr.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:62' do
+          # Reasoned S2, frame 1:62
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) fail)
+          #           (== 'oil x))) ;; => (oil)
+
+          result = run_star('x', disj2(conj2(equals(:olive, x), _fail), equals(:oil, x)))
+          expect(result.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:63' do
+          # Reasoned S2, frame 1:63
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) succeed)
+          #           ('oil x))) ;; => (olive oil)
+
+          result = run_star('x', disj2(conj2(equals(:olive, x), succeed), equals(:oil, x)))
+          expect(result).to eq(cons(:olive, cons(:oil)))
+        end
+
+        it 'passes frame 1:64' do
+          # Reasoned S2, frame 1:64
+          # (run* x (disj2
+          #           (== 'oil x)
+          #           (conj2 (== 'olive x) succeed))) ;; => (oil olive)
+
+          result = run_star('x', disj2(equals(:oil, x), conj2(equals(:olive, x), succeed)))
+          expect(result).to eq(cons(:oil, cons(:olive)))
+        end
+
+        it 'passes frame 1:65' do
+          # Reasoned S2, frame 1:65
+          # (run* x (disj2
+          #           (conj2(== 'virgin x) fail)
+          #           (disj2
+          #             (== 'olive x)
+          #             (dis2
+          #               succeed
+          #               (== 'oil x))))) ;; => (olive _0 oil)
+
+          result = run_star('x', disj2(conj2(equals(:virgin, x), _fail),
+            disj2(equals(:olive, x), disj2(succeed, equals(:oil, x)))))
+          expect(result).to eq(cons(:olive, cons(:_0, cons(:oil))))
+        end
+
+        it 'passes frame 1:67' do
+          # Reasoned S2, frame 1:67
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #           (== 'split x)
+          #           (conj2
+          #             (== 'pea y)
+          #             (== '(,x ,y) r)))))) ;; => ((split pea))
+
+          result = run_star('r', fresh('x', fresh('y',
+            conj2(equals(:split, x),
+            conj2(equals(:pea, y), equals(cons(x, cons(y)), r))))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:68' do
+          # Reasoned S2, frame 1:68
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #         (conj2
+          #           (== 'split x)
+          #           (== 'pea y)
+          #         (== '(,x ,y) r)))))) ;; => ((split pea))
+
+          result = run_star('r', fresh('x', fresh('y',
+            conj2(conj2(equals(:split, x), equals(:pea, y)),
+              equals(cons(x, cons(y)), r)))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:70' do
+          # Reasoned S2, frame 1:70
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (conj2
+          #         (== 'split x)
+          #         (== 'pea y)
+          #       (== '(,x ,y) r))))) ;; => ((split pea))
+
+          result = run_star('r', fresh(%w[x y], conj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            equals(cons(x, cons(y)), r))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:72' do
+          # Reasoned S2, frame 1:72
+          # (run* (r x y)
+          #   (conj2
+          #     (conj2
+          #       (== 'split x)
+          #       (== 'pea y))
+          #     (== '(,x ,y) r))) ;; => (((split pea) split pea))
+          #             o
+          #            / \
+          #            o  nil
+          #          /  \
+          #         /    \
+          #        /      \
+          #       /        \
+          #      /          \
+          #      o           o
+          #     / \         / \
+          # split  o   split   o
+          #       / \         / \
+          #    pea  nil     pea  nil
+
+          result = run_star(%w[r x y], conj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            equals(cons(x, cons(y)), r)))
+          expect(result.car.car.car).to eq(:split)
+          expect(result.car.car.cdr.car).to eq(:pea)
+          expect(result.car.car.cdr.cdr).to be_nil
+          expect(result.car.cdr.car).to eq(:split)
+          expect(result.car.cdr.cdr.car).to eq(:pea)
+          expect(result.car.cdr.cdr.cdr).to be_nil
+        end
+
+        it 'passes frame 1:75' do
+          # Reasoned S2, frame 1:75
+          # (run* (x y)
+          #   (conj2
+          #     (== 'split x)
+          #     (== 'pea y))) ;; => ((split pea))
+
+          result = run_star(%w[x y], conj2(equals(:split, x), equals(:pea, y)))
+          expect(result.car).to eq(list(:split, :pea))
+        end
+
+        it 'passes frame 1:76' do
+          # Reasoned S2, frame 1:76
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+
+          result = run_star(%w[x y], disj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            conj2(equals(:red, x), equals(:bean, y))))
+          expect(result.car).to eq(list(:split, :pea))
+          expect(result.cdr.car).to eq(list(:red, :bean))
+        end
+
+        it 'passes frame 1:77' do
+          # Reasoned S2, frame 1:77
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (disj2
+          #         (conj2 (== 'split x) (== 'pea y))
+          #         (conj2 (== 'red x) (== 'bean y)))
+          #       (== '(,x ,y soup) r)))) ;; => ((split pea soup) (red bean soup))
+
+          result = run_star('r',
+            fresh(%w[x y], conj2(
+              disj2(
+                conj2(equals(:split, x), equals(:pea, y)),
+                conj2(equals(:red, x), equals(:bean, y))),
+              equals(cons(x, cons(y, cons(:soup))), r))))
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
+        end
+
+        it 'passes frame 1:78' do
+          # Reasoned S2, frame 1:78
+          # (run* r
+          #   (fresh (x y)
+          #     (disj2
+          #       (conj2 (== 'split x) (== 'pea y))
+          #       (conj2 (== 'red x) (== 'bean y)))
+          #     (== '(,x ,y soup) r))) ;; => ((split pea soup) (red bean soup))
+
+          result = run_star('r',
+            fresh(%w[x y], [disj2(
+              conj2(equals(:split, x), equals(:pea, y)),
+              conj2(equals(:red, x), equals(:bean, y))),
+              equals(cons(x, cons(y, cons(:soup))), r)]))
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
+        end
+
+        it 'passes frame 1:80' do
+          # Reasoned S2, frame 1:80
+          # (run* (x y z)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))
+          #   (== 'soup z)) ;; => ((split pea soup) (red bean soup))
+
+          result = run_star(%w[x y z], [disj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            conj2(equals(:red, x), equals(:bean, y))),
+            equals(:soup, z)])
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
+        end
+
+        it 'passes frame 1:81' do
+          # Reasoned S2, frame 1:81
+          # (run* (x y)
+          #   (== 'split x)
+          #   (== 'pea y)) ;; => ((split pea))
+
+          result = run_star(%w[x y], [equals(:split, x), equals(:pea, y)])
+          expect(result.car).to eq(list(:split, :pea))
+        end
+
+        it "supports 'defrel' and passes frame 1:82" do
+          # Reasoned S2, frame 1:82
+          # (defrel (teacupo t)
+          #   (disj2 (== 'tea t) (== 'cup t)))
+
+          result = defrel('teacupo', 't') do
+            disj2(equals(:tea, t), equals(:cup, t))
+          end
+
+          expect(result).to be_kind_of(Core::DefRelation)
+          expect(result.name).to eq('teacupo')
+          expect(result.formals.size).to eq(1)
+          expect(result.formals[0].name).to eq('t')
+          g_template = result.goal_template
+          expect(g_template).to be_kind_of(Core::GoalTemplate)
+          expect(g_template.relation).to eq(Core::Disj2.instance)
+
+          first_arg = g_template.args[0]
+          expect(first_arg).to be_kind_of(Core::GoalTemplate)
+          expect(first_arg.relation).to eq(Core::Equals.instance)
+          expect(first_arg.args[0]).to eq(:tea)
+          expect(first_arg.args[1]).to be_kind_of(Core::FormalRef)
+          expect(first_arg.args[1].name).to eq('t')
+          second_arg = g_template.args[1]
+          expect(second_arg).to be_kind_of(Core::GoalTemplate)
+          expect(second_arg.relation).to eq(Core::Equals.instance)
+          expect(second_arg.args[0]).to eq(:cup)
+          expect(second_arg.args[1]).to be_kind_of(Core::FormalRef)
+          expect(second_arg.args[1].name).to eq('t')
+        end
+
+        def defrel_teacupo
+          defrel('teacupo', 't') { disj2(equals(:tea, t), equals(:cup, t)) }
+        end
+
+        it "supports the invokation of a 'defrel' and passes frame 1:83" do
+          # Reasoned S2, frame 1:83
+          # (run* x
+          #   (teacupo x)) ;; => ((tea cup))
+
+          defrel_teacupo
+          result = run_star('x', teacupo(x))
+
+          expect(result).to eq(cons(:tea, cons(:cup)))
+        end
+
+        it 'supports booleans and passes frame 1:84' do
+          # Reasoned S2, frame 1:84
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (== #t y))
+          #     (conj2 (== #f x) (== #t y))) ;; => ((#f #t)(tea #t) (cup #t))
+
+          defrel_teacupo
+          result = run_star(%w[x y],
+            disj2(
+              conj2(teacupo(x), equals('#t', y)),
+              conj2(equals('#f', x), equals('#t', y))))
+
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(:tea, cons(true)))
+          expect(result.cdr.car).to eq(cons(:cup, cons(true)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(true)))
+        end
+
+        it 'passes frame 1:85' do
+          # Reasoned S2, frame 1:85
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo y)) ;; => ((tea tea)(tea cup)(cup tea)(cup c))
+
+          defrel_teacupo
+          result = run_star(%w[x y], [teacupo(x), teacupo(y)])
+
+          expect(result.car).to eq(cons(:tea, cons(:tea)))
+          expect(result.cdr.car).to eq(cons(:tea, cons(:cup)))
+          expect(result.cdr.cdr.car).to eq(cons(:cup, cons(:tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(:cup, cons(:cup)))
+        end
+
+        it 'passes frame 1:86' do
+          # Reasoned S2, frame 1:86
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo x)) ;; => ((tea _0)(cup _0))
+
+          defrel_teacupo
+          result = run_star(%w[x y], [teacupo(x), teacupo(x)])
+          expect(result.to_s).to eq('((:tea _0) (:cup _0))')
+        end
+
+        it 'passes frame 1:87' do
+          # Reasoned S2, frame 1:87
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (teacupo x))
+          #     (conj2 (== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+
+          defrel_teacupo
+          result = run_star(%w[x y], disj2(
+              conj2(teacupo(x), teacupo(x)),
+              conj2(equals('#f', x), teacupo(y))))
+
+          # Order of solutions differs from RS book
+          expected = '((:tea _0) (:cup _0) (false :tea) (false :cup))'
+          expect(result.to_s).to eq(expected)
+          expect(result.car).to eq(cons(:tea, cons(:_0)))
+          expect(result.cdr.car).to eq(cons(:cup, cons(:_0)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(:tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(:cup)))
+        end
+
+        it 'supports conde and passes frame 1:88 (i)' do
+          # Reasoned S2, frame 1:88
+          # (run* (x y)
+          #   (conde
+          #     ((teacupo x) (teacupo x))
+          #     ((== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+
+          defrel_teacupo
+          result = run_star(%w[x y], conde(
+              [teacupo(x), teacupo(x)],
+              [equals('#f', x), teacupo(y)]))
+
+          # Order of solutions differs from RS book
+          expected = '((:tea _0) (:cup _0) (false :tea) (false :cup))'
+          expect(result.to_s).to eq(expected)
+        end
+
+        it 'supports conde and passes frame 1:88 (ii)' do
+          # Reasoned S2, frame 1:88 (second part, a rewrite of 1:76)
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = run_star(%w[x y], conde(
+            [equals(:split, x), equals(:pea, y)],
+            [equals(:red, x), equals(:bean, y)]))
+
+          expected = '((:split :pea) (:red :bean))'
+          expect(result.to_s).to eq(expected)
+        end
+
+        it 'passes frame 1:89' do
+          # Reasoned S2, frame 1:89 (rewrite of 1:62)
+          # (run* x
+          #   (conde
+          #     ((== 'olive x) fail)
+          #     ('oil x))) ;; => (oil)
+
+          result = run_star('x', conde(
+            [equals(:olive, x), _fail],
+            equals(:oil, x)))
+
+          expect(result.to_s).to eq('(:oil)')
+        end
+
+        it 'passes frame 1:90' do
+          # Reasoned S2, frame 1:90
+          # (run* (x y)
+          #   (conde
+          #     ((fresh (z)
+          #       (== 'lentil z)))
+          #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
+
+          result = run_star(%w[x y], conde(
+            [fresh(%w[z], equals(:lentil, z))],
+            [equals(x, y)]))
+
+          expect(result.to_s).to eq('((_0 _1) (_0 _0))')
+        end
+
+        it 'passes frame 1:91' do
+          # Reasoned S2, frame 1:91
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y))
+          #     ((== 'green x) (== 'lentil y))))
+          # ;; => ((split pea)(red bean)(green lentil))
+          result = run_star(%w[x y], conde(
+            [equals(:split, x), equals(:pea, y)],
+            [equals(:red, x), equals(:bean, y)],
+            [equals(:green, x), equals(:lentil, y)]))
+
+          expected = '((:split :pea) (:red :bean) (:green :lentil))'
+          expect(result.to_s).to eq(expected)
+        end
+      end # context
+    end # describe
+  end # module
+end # module