mini_kraken 0.2.02 → 0.3.02

data/spec/core/succeed_spec.rb

@@ -21,17 +21,17 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
-        it 'should unconditionally return a success result' do
-          args = double('fake-args')
-          env = double('fake-env')
+        let(:ctx) { Context.new }
 
+        it 'should unconditionally return a success result' do
           solver = nil
-          expect { solver = subject.solver_for(args, env) }.not_to raise_error
+          expect { solver = subject.solver_for([], ctx) }.not_to raise_error
 
           # Solver should quack like a Fiber
           dummy_arg = double('dummy-stuff')
           result = solver.resume(dummy_arg)
-          expect(result).to eq(BasicSuccess)
+          expect(result).to eq(ctx)
+          expect(result).to be_success
 
           # Only one "solution", next 'resume' call should return nil
           result = solver.resume(dummy_arg)

data/spec/core/symbol_table_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/log_var'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/symbol_table'
+
+module MiniKraken
+  module Core
+    describe SymbolTable do
+      subject { SymbolTable.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { SymbolTable.new }.not_to raise_error
+        end
+
+        it 'should have a root scope' do
+          expect(subject.root).not_to be_nil
+          expect(subject.current_scope).to eq(subject.root)
+          expect(subject.root).to be_kind_of(Core::Scope)
+        end
+
+        it "shouldn't have names at initialization" do
+          expect(subject.name2scopes).to be_empty
+        end
+
+        it 'should be empty at initialization' do
+          expect(subject).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        def var(aName)
+          LogVar.new(aName)
+        end
+
+        it 'should allow the addition of a variable' do
+          expect { subject.insert(var('q')) }.not_to raise_error
+          expect(subject).not_to be_empty
+          expect(subject.name2scopes['q']).to be_kind_of(Array)
+          expect(subject.name2scopes['q'].size).to eq(1)
+          expect(subject.name2scopes['q'].first).to eq(subject.current_scope)
+          expect(subject.current_scope.defns['q']).to be_kind_of(Core::LogVar)
+        end
+
+        it 'should allow the addition of several labels for same env' do
+          i_name = subject.insert(var('q'))
+          expect(i_name).to match(/^q_[0-9a-z]+$/)
+
+          expect { subject.insert(var('x')) }.not_to raise_error
+          expect(subject.name2scopes['x']).to be_kind_of(Array)
+          expect(subject.name2scopes['x'].first).to eq(subject.current_scope)
+          expect(subject.current_scope.defns['x']).to be_kind_of(Core::LogVar)
+        end
+
+        it 'should allow the entry into a new scope' do
+          subject.insert(var('q'))
+          new_scope = Core::Scope.new
+          expect { subject.enter_scope(new_scope) }.not_to raise_error
+          expect(subject.current_scope).to eq(new_scope)
+          expect(subject.current_scope.parent).to eq(subject.root)
+          expect(subject.name2scopes['q']).to eq([subject.root])
+        end
+
+        it 'should allow the addition of same name in different scopes' do
+          subject.insert(var('q'))
+          subject.enter_scope(Core::Scope.new)
+          subject.insert(var('q'))
+          expect(subject.name2scopes['q']).to be_kind_of(Array)
+          expect(subject.name2scopes['q'].size).to eq(2)
+          expect(subject.name2scopes['q'].first).to eq(subject.root)
+          expect(subject.name2scopes['q'].last).to eq(subject.current_scope)
+          expect(subject.current_scope.defns['q']).to be_kind_of(Core::LogVar)
+        end
+
+        it 'should allow the removal of a scope' do
+          subject.insert(var('q'))
+          new_scope = Core::Scope.new
+          subject.enter_scope(new_scope)
+          subject.insert(var('q'))
+          expect(subject.name2scopes['q'].size).to eq(2)
+
+          expect { subject.leave_scope }.not_to raise_error
+          expect(subject.current_scope).to eq(subject.root)
+          expect(subject.name2scopes['q'].size).to eq(1)
+          expect(subject.name2scopes['q']).to eq([subject.root])
+        end
+
+        it 'should allow the search of an entry based on its name' do
+          subject.insert(var('q'))
+          subject.insert(var('x'))
+          subject.enter_scope(Core::Scope.new)
+          subject.insert(var('q'))
+          subject.insert(var('y'))
+
+          # Search for unknown name
+          expect(subject.lookup('z')).to be_nil
+
+          # Search for existing unique names
+          expect(subject.lookup('y')).to eq(subject.current_scope.defns['y'])
+          expect(subject.lookup('x')).to eq(subject.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup('q')).to eq(subject.current_scope.defns['q'])
+        end
+
+        it 'should allow the search of an entry based on its i_name' do
+          subject.insert(var('q'))
+          i_name_x = subject.insert(var('x'))
+          subject.enter_scope(Core::Scope.new)
+          i_name_q2 = subject.insert(var('q'))
+          i_name_y = subject.insert(var('y'))
+
+          # Search for unknown i_name
+          expect(subject.lookup_i_name('dummy')).to be_nil
+
+          curr_scope = subject.current_scope
+          # # Search for existing unique names
+          expect(subject.lookup_i_name(i_name_y)).to eq(curr_scope.defns['y'])
+          expect(subject.lookup_i_name(i_name_x)).to eq(subject.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup_i_name(i_name_q2)).to eq(curr_scope.defns['q'])
+        end
+
+        it 'should list all the variables defined in all the szcope chain' do
+          subject.insert(var('q'))
+          subject.enter_scope(Core::Scope.new)
+          subject.insert(var('x'))
+          subject.enter_scope(Core::Scope.new)
+          subject.insert(var('y'))
+          subject.insert(var('x'))
+
+          vars = subject.all_variables
+          expect(vars.map(&:name)).to eq(%w[q x y x])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/dsl_chap1_spec.rb

@@ -13,7 +13,6 @@ module MiniKraken
 
       context 'Chapter 1 examples:' do
         it 'passes frame 1:7' do
-          # Reasoned S2, frame 1:7
           # (run* q #u) ;; => ()
 
           result = run_star('q', _fail)
@@ -21,18 +20,16 @@ module MiniKraken
         end
 
         it 'passes frame 1:10' do
-          # Reasoned S2, frame 1:10
           # (run* q (== 'pea 'pod) ;; => ()
 
-          result = run_star('q', equals(:pea, :pod))
+          result = run_star('q', unify(: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))
+          result = run_star('q', unify(q, :pea))
           expect(result.car).to eq(:pea)
         end
 
@@ -40,12 +37,11 @@ module MiniKraken
           # Reasoned S2, frame 1:12
           # (run* q (== 'pea q) ;; => (pea)
 
-          result = run_star('q', equals(:pea, q))
+          result = run_star('q', unify(: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)
@@ -56,15 +52,14 @@ module MiniKraken
           # Reasoned S2, frame 1:19
           # (run* q (== 'pea 'pea)) ;; => (_0)
 
-          result = run_star('q', equals(:pea, :pea))
+          result = run_star('q', unify(: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))
+          result = run_star('q', unify(q, q))
           expect(result.car).to eq(:_0)
         end
 
@@ -72,80 +67,81 @@ module MiniKraken
           # Reasoned S2, frame 1:21
           # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
 
-          result = run_star('q', fresh('x', equals(:pea, q)))
+          result = run_star('q', fresh('x', unify(: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))
+          # (run* q
+          #   (fresh (x)
+          #     (== (cons x '()) q))) ;; => ((_0))
+
+          result = run_star('q', fresh('x', unify(cons(x, null_list), q)))
+          expect(result.car.to_s).to eq('(_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)))
+          result = run_star('q', fresh('x', unify(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)))
+          result = run_star('q', unify(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)))
+          result = run_star('q', unify(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)
 
-          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', unify(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))))
+          result = run_star('q', fresh('x', unify(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)
 
-          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', unify(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)))
+          result = run_star('q', fresh('x', unify(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))))))
+          result = run_star('q', fresh('x', fresh('y', unify(cons(q, cons(y)), cons(cons(x, cons(y)), cons(x))))))
           expect(result.car).to eq(cons(:_0, cons(:_0)))
         end
 
@@ -153,25 +149,23 @@ module MiniKraken
           # 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))))
+          result = run_star('q', fresh('x', fresh('y', unify(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))))
+          result = run_star('s', fresh('t', fresh('u', unify(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))))
+          result = run_star('q', fresh('x', fresh('y', unify(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
@@ -185,18 +179,16 @@ module MiniKraken
         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)))
+          result = run_star('q', conj2(succeed, unify(: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)))
+          result = run_star('q', conj2(_fail, unify(:corn, q)))
           expect(result).to be_null
         end
 
@@ -204,20 +196,18 @@ module MiniKraken
           # Reasoned S2, frame 1:53
           # (run* q (conj2 (== 'corn q)(== 'meal q)) ;; => ()
 
-          result = run_star('q', conj2(equals(:corn, q), equals(:meal, q)))
+          result = run_star('q', conj2(unify(:corn, q), unify(: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)))
+          result = run_star('q', conj2(unify(:corn, q), unify(: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))
@@ -225,73 +215,65 @@ module MiniKraken
         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))
+          result = run_star('q', disj2(unify(: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)))
+          result = run_star('q', disj2(_fail, unify(: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)))
+          result = run_star('q', disj2(unify(:olive, q), unify(: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)))))
+          result = run_star('q', fresh('x', (fresh 'y', disj2(unify(cons(x, cons(y)), q), unify(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)))
+          result = run_star('x', disj2(conj2(unify(:olive, x), _fail), unify(: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)))
+          result = run_star('x', disj2(conj2(unify(:olive, x), succeed), unify(: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)))
+          result = run_star('x', disj2(unify(:oil, x), conj2(unify(: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
@@ -300,13 +282,13 @@ module MiniKraken
           #               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)))))
+          result = run_star('x', disj2(conj2(unify(:virgin, x), _fail),
+            disj2(unify(:olive, x), disj2(succeed, unify(:oil, x)))))
           expect(result).to eq(cons(:olive, cons(:_0, cons(:oil))))
+          expect(result.to_s).to eq('(:olive _0 :oil)')
         end
 
         it 'passes frame 1:67' do
-          # Reasoned S2, frame 1:67
           # (run* r
           #   (fresh x
           #     (fresh y
@@ -317,13 +299,12 @@ module MiniKraken
           #             (== '(,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))))
+            conj2(unify(:split, x),
+            conj2(unify(:pea, y), unify(cons(x, cons(y)), r))))))
+          expect(result.to_s).to eq('((:split :pea))')
         end
 
         it 'passes frame 1:68' do
-          # Reasoned S2, frame 1:68
           # (run* r
           #   (fresh x
           #     (fresh y
@@ -334,13 +315,12 @@ module MiniKraken
           #         (== '(,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))))
+            conj2(conj2(unify(:split, x), unify(:pea, y)),
+              unify(cons(x, cons(y)), r)))))
+          expect(result.to_s).to eq('((:split :pea))')
         end
 
         it 'passes frame 1:70' do
-          # Reasoned S2, frame 1:70
           # (run* r
           #   (fresh (x y)
           #     (conj2
@@ -350,13 +330,12 @@ module MiniKraken
           #       (== '(,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))))
+            conj2(unify(:split, x), unify(:pea, y)),
+            unify(cons(x, cons(y)), r))))
+          expect(result.to_s).to eq('((:split :pea))')
         end
 
         it 'passes frame 1:72' do
-          # Reasoned S2, frame 1:72
           # (run* (r x y)
           #   (conj2
           #     (conj2
@@ -378,43 +357,42 @@ module MiniKraken
           #    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)))
+            conj2(unify(:split, x), unify(:pea, y)),
+            unify(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
+          expect(result.to_s).to eq('(((:split :pea) :split :pea))')
         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))
+          result = run_star(%w[x y], conj2(unify(:split, x), unify(:pea, y)))
+          expect(result.to_s).to eq('((: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))))
+            conj2(unify(:split, x), unify(:pea, y)),
+            conj2(unify(:red, x), unify(:bean, y))))
+          expect(result.to_s).to eq('((:split :pea) (:red :bean))')
           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
@@ -426,15 +404,15 @@ module MiniKraken
           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))))
+                conj2(unify(:split, x), unify(:pea, y)),
+                conj2(unify(:red, x), unify(:bean, y))),
+              unify(cons(x, cons(y, cons(:soup))), r))))
+          expect(result.to_s).to eq('((:split :pea :soup) (:red :bean :soup))')
           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
@@ -444,15 +422,13 @@ module MiniKraken
 
           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))
+              conj2(unify(:split, x), unify(:pea, y)),
+              conj2(unify(:red, x), unify(:bean, y))),
+              unify(cons(x, cons(y, cons(:soup))), r)]))
+          expect(result.to_s).to eq('((:split :pea :soup) (: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))
@@ -460,56 +436,38 @@ module MiniKraken
           #   (== '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)])
+            conj2(unify(:split, x), unify(:pea, y)),
+            conj2(unify(:red, x), unify(:bean, y))),
+            unify(: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)])
+          result = run_star(%w[x y], [unify(:split, x), unify(: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)
+          expr = disj2(unify(:tea, t), unify(:cup, t))
+          result = defrel('teacupo', ['t'], expr)
+          expect(result).to be_kind_of(Rela::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')
+          expect(result.formals[0]).to match(/^t_/)
+          goal_expr = result.expression
+          expect(goal_expr).to be_kind_of(Core::Goal)
+          expect(goal_expr.relation).to eq(Rela::Disj2.instance)
         end
 
-        def defrel_teacupo
-          defrel('teacupo', 't') { disj2(equals(:tea, t), equals(:cup, t)) }
+        let(:defrel_teacupo) do
+          defrel('teacupo', ['t'], disj2(unify(:tea, t), unify(:cup, t)))
         end
 
         it "supports the invokation of a 'defrel' and passes frame 1:83" do
@@ -533,8 +491,8 @@ module MiniKraken
           defrel_teacupo
           result = run_star(%w[x y],
             disj2(
-              conj2(teacupo(x), equals('#t', y)),
-              conj2(equals('#f', x), equals('#t', y))))
+              conj2(teacupo(x), unify('#t', y)),
+              conj2(unify('#f', x), unify('#t', y))))
 
           # Order of solutions differs from RS book
           expect(result.car).to eq(cons(:tea, cons(true)))
@@ -543,7 +501,6 @@ module MiniKraken
         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))
@@ -558,7 +515,6 @@ module MiniKraken
         end
 
         it 'passes frame 1:86' do
-          # Reasoned S2, frame 1:86
           # (run* (x y)
           #   (teacupo x)
           #   (teacupo x)) ;; => ((tea _0)(cup _0))
@@ -569,7 +525,6 @@ module MiniKraken
         end
 
         it 'passes frame 1:87' do
-          # Reasoned S2, frame 1:87
           # (run* (x y)
           #   (disj2
           #     (conj2 (teacupo x) (teacupo x))
@@ -578,7 +533,7 @@ module MiniKraken
           defrel_teacupo
           result = run_star(%w[x y], disj2(
               conj2(teacupo(x), teacupo(x)),
-              conj2(equals('#f', x), teacupo(y))))
+              conj2(unify('#f', x), teacupo(y))))
 
           # Order of solutions differs from RS book
           expected = '((:tea _0) (:cup _0) (false :tea) (false :cup))'
@@ -590,7 +545,6 @@ module MiniKraken
         end
 
         it 'supports conde and passes frame 1:88 (i)' do
-          # Reasoned S2, frame 1:88
           # (run* (x y)
           #   (conde
           #     ((teacupo x) (teacupo x))
@@ -599,7 +553,7 @@ module MiniKraken
           defrel_teacupo
           result = run_star(%w[x y], conde(
               [teacupo(x), teacupo(x)],
-              [equals('#f', x), teacupo(y)]))
+              [unify('#f', x), teacupo(y)]))
 
           # Order of solutions differs from RS book
           expected = '((:tea _0) (:cup _0) (false :tea) (false :cup))'
@@ -613,8 +567,8 @@ module MiniKraken
           #     ((== '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)]))
+            [unify(:split, x), unify(:pea, y)],
+            [unify(:red, x), unify(:bean, y)]))
 
           expected = '((:split :pea) (:red :bean))'
           expect(result.to_s).to eq(expected)
@@ -628,14 +582,13 @@ module MiniKraken
           #     ('oil x))) ;; => (oil)
 
           result = run_star('x', conde(
-            [equals(:olive, x), _fail],
-            equals(:oil, x)))
+            [unify(:olive, x), _fail],
+            unify(: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)
@@ -643,14 +596,13 @@ module MiniKraken
           #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
 
           result = run_star(%w[x y], conde(
-            [fresh(%w[z], equals(:lentil, z))],
-            [equals(x, y)]))
+            [fresh(%w[z], unify(:lentil, z))],
+            [unify(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))
@@ -658,9 +610,9 @@ module MiniKraken
           #     ((== '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)]))
+            [unify(:split, x), unify(:pea, y)],
+            [unify(:red, x), unify(:bean, y)],
+            [unify(:green, x), unify(:lentil, y)]))
 
           expected = '((:split :pea) (:red :bean) (:green :lentil))'
           expect(result.to_s).to eq(expected)