mini_kraken 0.2.04 → 0.3.00

data/spec/core/relation_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/relation'
+
+
+module MiniKraken
+  module Core
+    describe Relation do
+      subject { Relation.new('caro', 2) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an arity' do
+          expect { Relation.new('caro', Arity.new(2, 2)) }.not_to raise_error
+        end
+
+        it 'should be initialized with a name and an integer' do
+          expect { Relation.new('caro', 2) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('caro')
+        end
+
+        it 'should know its arity' do
+          expect(subject.arity).to eq(Arity.new(2, 2))
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/scope_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/scope'
+
+module MiniKraken
+  module Core
+    describe Scope do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      let(:mother) { Scope.new }
+      subject { Scope.new(mother) }
+
+      def var(aName)
+        LogVar.new(aName)
+      end
+
+      context 'Initialization:' do
+        it 'could be initialized without argument' do
+          expect { Scope.new }.not_to raise_error
+        end
+
+        it 'could be initialized with a parent scope' do
+          expect { Scope.new(mother) }.not_to raise_error
+        end
+
+        it "shouldn't have definitions by default" do
+          expect(subject.defns).to be_empty
+        end
+
+        it 'should know its parent (if any)' do
+          expect(subject.parent).to eq(mother)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a variable' do
+          subject.insert(var('a'))
+          expect(subject.defns).not_to be_empty
+          var_a = subject.defns['a']
+          expect(var_a).to be_kind_of(Core::LogVar)
+          expect(var_a.label).to eq('a')
+        end
+
+        it 'should accept the addition of multiple variables' do
+          subject.insert(var('a'))
+          expect(subject.defns).not_to be_empty
+
+          subject.insert(var('b'))
+          var_b = subject.defns['b']
+          expect(var_b).to be_kind_of(Core::LogVar)
+          expect(var_b.label).to eq('b')
+        end
+
+        it 'should set the suffix of just created variable' do
+          subject.insert(var('a'))
+          var_a = subject.defns['a']
+          expect(var_a.suffix).to eq("_#{subject.object_id.to_s(16)}")
+        end
+
+        it 'should complain when variable names collide' do
+          subject.insert(var('c'))
+          expect(subject.defns['c']).to be_kind_of(Core::LogVar)
+          err = StandardError
+          err_msg = "Variable with name 'c' already exists."
+          expect { subject.insert(var('c')) }.to raise_error(err, err_msg)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/solver_adapter_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'singleton'
+
+require_relative '../../lib/mini_kraken/core/context'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/solver_adapter'
+
+
+module MiniKraken
+  module Core
+    describe SolverAdapter do
+      let(:ctx) { Context.new }
+      let(:fib) { make_fiber(ctx, true, true, false, nil) }
+      let(:blk) do
+        lambda do |adapter, _context|
+          adapter.adaptee.resume
+        end
+      end
+      subject { SolverAdapter.new(fib, &blk) }
+
+      # Factory method.
+      def make_fiber(ctx, *args)
+        Fiber.new do
+          signature = *args
+          signature.each do |outcome|
+            if outcome
+              Fiber.yield ctx.succeeded!
+              next
+            elsif outcome.nil?
+              Fiber.yield nil
+              break
+            else
+              Fiber.yield ctx.failed!
+              next
+            end
+          end
+        end
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized with a Fiber-like object' do
+          expect { SolverAdapter.new(fib, &blk) }.not_to raise_error
+        end
+
+        it 'should know its adaptee' do
+          expect(subject.adaptee).to eq(fib)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should respond to the resume message' do
+          result = subject.resume(ctx)
+          expect(result).to be_success
+
+          result = subject.resume(ctx)
+          expect(result).to be_success
+
+          result = subject.resume(ctx)
+          expect(result).to be_failure
+
+          result = subject.resume(ctx)
+          expect(result).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/specification_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/specification'
+
+
+module MiniKraken
+  module Core
+    describe Specification do
+      subject { Specification.new('cons', 2) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an arity' do
+          expect { Specification.new('cons', Arity.new(2, 2)) }.not_to raise_error
+        end
+
+        it 'should be initialized with a name and an integer' do
+          expect { Specification.new('cons', 2) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('cons')
+        end
+
+        it 'should know its arity' do
+          expect(subject.arity).to be_binary
+        end
+      end # context
+
+      context 'Provided services:' do
+        it "should complain when number of arguments does't fit arity" do
+          dummy_arg = double('dummy-stuff')
+
+          err = StandardError
+          err_msg = 'Count of arguments (1) is out of allowed range (2, 2).'
+          expect { subject.check_arity([dummy_arg]) }.to raise_error(err, err_msg)
+        end
+      end
+    end # describe
+  end # module
+end # module

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

@@ -22,14 +22,14 @@ module MiniKraken
         it 'passes frame 1:10' do
           # (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
           # (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
 
@@ -37,7 +37,7 @@ 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
 
@@ -52,14 +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
           # (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
 
@@ -67,28 +67,30 @@ 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
-          # (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
           # (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
           # (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
 
@@ -96,7 +98,7 @@ module MiniKraken
           # Beware: quasiquoting
           # (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
 
@@ -107,14 +109,14 @@ module MiniKraken
           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))
+          result = run_star('q', unify(expr1, expr2))
           expect(result.car).to eq(:pea)
         end
 
         it 'passes frame 1:35' do
           # (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
 
@@ -125,21 +127,21 @@ module MiniKraken
           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)))
+          result = run_star('q', fresh('x', unify(expr1, expr2)))
           expect(result.car).to eq(:pod)
         end
 
         it 'passes frame 1:37' do
           # (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
           # (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
 
@@ -147,7 +149,7 @@ 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
@@ -155,7 +157,7 @@ module MiniKraken
         it 'passes frame 1:42' do
           # (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
@@ -163,7 +165,7 @@ module MiniKraken
         it 'passes frame 1:43' do
           # (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
@@ -179,14 +181,14 @@ module MiniKraken
         it 'passes frame 1:51' do
           # (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
           # (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
 
@@ -194,14 +196,14 @@ 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
           # (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
 
@@ -215,21 +217,21 @@ module MiniKraken
         it 'passes frame 1:56' do
           # (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
           # (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
           # (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
@@ -238,7 +240,7 @@ module MiniKraken
           # (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)))
@@ -249,7 +251,7 @@ module MiniKraken
           #           (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
 
@@ -258,7 +260,7 @@ module MiniKraken
           #           (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
 
@@ -267,7 +269,7 @@ module MiniKraken
           #           (== '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
 
@@ -280,9 +282,10 @@ 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
@@ -296,9 +299,9 @@ 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
@@ -312,9 +315,9 @@ 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
@@ -327,9 +330,9 @@ 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
@@ -354,14 +357,15 @@ 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
@@ -370,8 +374,8 @@ module MiniKraken
           #     (== '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
@@ -381,8 +385,9 @@ module MiniKraken
           #     (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
@@ -399,9 +404,10 @@ 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
@@ -416,11 +422,10 @@ 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
@@ -431,9 +436,9 @@ 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
@@ -443,42 +448,26 @@ module MiniKraken
           #   (== '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
           # (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
@@ -502,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)))
@@ -544,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))'
@@ -564,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))'
@@ -578,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)
@@ -593,8 +582,8 @@ 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
@@ -607,8 +596,8 @@ 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
@@ -621,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)