mini_kraken 0.1.05 → 0.1.10

data/lib/mini_kraken/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniKraken
-  VERSION = '0.1.05'
+  VERSION = '0.1.10'
 end

data/spec/core/conj2_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/conj2'
+
+
+module MiniKraken
+  module Core
+    describe Conj2 do
+      subject { Conj2.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Conj2.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('conj2')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:env) { Environment.new }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:ref_q) { VariableRef.new('q') }
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        it 'should yield one failure if one of the goal is fail' do
+          # Fail as first argument
+          solver = subject.solver_for([fails, succeeds], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+
+          # Fail as second argument
+          solver = subject.solver_for([succeeds, fails], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if both arguments are succeed goals' do
+          # Covers frame 1-50
+          solver = subject.solver_for([succeeds, succeeds], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations).to be_empty
+          expect(solver.resume).to be_nil
+        end
+
+        it 'should yield success and set associations' do
+          # Covers frame 1-51
+          env.add_var(var_q)
+          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
+          solver = subject.solver_for([succeeds, sub_goal], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations).not_to be_empty
+          expect(outcome.associations['q'].first.value).to eq(corn)
+        end
+
+        it 'should yield fails and set no associations' do
+          # Covers frame 1-52
+          env.add_var(var_q)
+          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
+          solver = subject.solver_for([fails, sub_goal], env)
+          outcome = solver.resume
+          expect(outcome).not_to be_successful
+          expect(outcome.associations).to be_empty
+        end
+
+        it 'should yield fails when sub-goals are incompatible' do
+          # Covers frame 1-53
+          env.add_var(var_q)
+          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
+          sub_goal2 = Goal.new(Equals.instance, [meal, ref_q])
+          solver = subject.solver_for([sub_goal1, sub_goal2], env)
+          outcome = solver.resume
+          expect(outcome).not_to be_successful
+          expect(outcome.associations).to be_empty
+        end
+
+        it 'should yield success when sub-goals are same and successful' do
+          # Covers frame 1-54
+          env.add_var(var_q)
+          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
+          sub_goal2 = Goal.new(Equals.instance, [corn, ref_q])
+          solver = subject.solver_for([sub_goal1, sub_goal2], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations).not_to be_empty
+          expect(outcome.associations['q'].first.value).to eq(corn)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/cons_cell_spec.rb

@@ -58,6 +58,14 @@ module MiniKraken
           different = ConsCell.new(pea)
           expect(subject.eql?(different)).to be_falsey
         end
+
+        it 'should append another cons cell' do
+          instance = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.append(trail)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to eq(trail)
+        end
       end # context
     end # describe
   end # module

data/spec/core/disj2_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/disj2'
+
+module MiniKraken
+  module Core
+    describe Disj2 do
+      subject { Disj2.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Disj2.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('disj2')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:oil) { KSymbol.new(:oil) }
+        let(:olive) { KSymbol.new(:olive) }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:ref_q) { VariableRef.new('q') }
+        let(:env) do
+          e = Environment.new
+          e.add_var(var_q)
+          e
+        end
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        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).to be_nil
+        end
+
+        it 'yield success if first argument succeeds' do
+          # Covers frame 1:56
+          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.associations['q'].first.value).to eq(olive)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if second argument succeeds' do
+          # Covers frame 1:57
+          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.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield two solutions if both arguments succeed' do
+          # Covers frame 1:58
+          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
+          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['q'].first.value).to eq(olive)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/duck_fiber_spec.rb

@@ -40,12 +40,23 @@ module MiniKraken
           succeeding = DuckFiber.new(:success)
           outcome = nil
           expect { outcome = succeeding.resume }.not_to raise_error
-          expect(outcome).to eq(BasicSuccess)
+          expect(outcome).to be_successful
+          expect(outcome.parent).to be_nil
 
           # Only one result should be yielded
           expect(succeeding.resume).to be_nil
         end
 
+        it 'should yield a distinct success object' do
+          instance1 = DuckFiber.new(:success)
+          outcome1 = instance1.resume
+
+          instance2 = DuckFiber.new(:success)
+          outcome2 = instance1.resume
+
+          expect(outcome1).not_to be_equal(outcome2)
+        end
+
         it 'should behave like a Fiber yielding a custom outcome' do
           tailored = DuckFiber.new(:custom) { Outcome.new(:"#s", parent) }
           outcome = nil

data/spec/core/equals_spec.rb

@@ -275,9 +275,9 @@ module MiniKraken
 
         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(ref_q), ref_x)
-          expr2 = cons(cons(ref_x), pod)
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(cons(ref_q)), ref_x)
+          expr2 = cons(cons(cons(ref_x)), pod)
 
           result = solve_for(expr1, expr2)
           # require 'debug'

data/spec/core/outcome_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/vocabulary'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/outcome'
+
+module MiniKraken
+  module Core
+    describe Outcome do
+      let(:voc) do
+        obj = Object.new
+        obj.extend(Vocabulary)
+        obj
+      end
+      subject { Outcome.new(:"#s", voc) }
+
+      context 'Initialization:' do
+        it 'should be created with a symbol and a vocabulary' do
+          expect { Outcome.new(:"#s", voc) }.not_to raise_error
+        end
+
+        it 'should know its resultant' do
+          expect(subject.resultant).to eq(:"#s")
+        end
+
+        it 'should know its parent' do
+          expect(subject.parent).to eq(voc)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should have a factory for failing outcome' do
+          instance = Outcome.failure(voc)
+          expect(instance.resultant).to eq(:"#u")
+          expect(instance.parent).to eq(voc)
+        end
+
+        it 'should have a factory for succeeding outcome' do
+          instance = Outcome.success(voc)
+          expect(instance.resultant).to eq(:"#s")
+          expect(instance.parent).to eq(voc)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/vocabulary_spec.rb

@@ -79,11 +79,11 @@ module MiniKraken
 
         it 'should provide a walker over ancestors' do
           walker = subject.ancestor_walker
-          expect(walker).to be_kind_of(Fiber)
-          expect(walker.resume).to eq(subject)
-          expect(walker.resume).to eq(mother)
-          expect(walker.resume).to eq(grandma)
-          expect(walker.resume).to be_nil
+          expect(walker).to be_kind_of(Enumerator)
+          expect(walker.next).to eq(subject)
+          expect(walker.next).to eq(mother)
+          expect(walker.next).to eq(grandma)
+          expect(walker.next).to be_nil
         end
 
         it 'should know if a variable is defined' do
@@ -207,6 +207,12 @@ module MiniKraken
           expect(subject.get_rank('z')).to eq(0)
           expect(subject.get_rank('a')).to eq(1)
         end
+
+        it 'should provide a String representation of itself' do
+          expectation = +"#<#{subject.class}:#{subject.object_id.to_s(16)} @parent="
+          expectation << "#<#{subject.parent.class}:#{subject.parent.object_id.to_s(16)}>>"
+          expect(subject.inspect).to eq(expectation)
+        end
       end # context
     end # describe
   end # module

data/spec/glue/fresh_env_spec.rb

@@ -3,7 +3,9 @@
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/mini_kraken/core/goal'
 require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/fail'
 require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/succeed'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/glue/fresh_env'
@@ -17,15 +19,39 @@ module MiniKraken
       let(:sample_goal) do
         Core::Goal.new(Core::Equals.instance, [pea, pod])
       end
+      let(:pea_goal) do
+        Core::Goal.new(Core::Equals.instance, [pea, pea])
+      end
+      let(:goal_succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
+      let(:goal_fails) { Core::Goal.new(Core::Fail.instance, []) }
       subject { FreshEnv.new(['q'], sample_goal) }
 
       context 'Initialization:' do
-        it 'should be initialized with an array of names' do
+        it 'could be initialized with names and a goal' do
           expect { FreshEnv.new(['q'], sample_goal) }.not_to raise_error
         end
 
+        it 'could be  initialized with names and goals' do
+          expect { FreshEnv.new(%w[x y], [pea_goal, goal_succeeds]) }.not_to raise_error
+        end
+
         it 'should know its variables' do
           expect(subject.vars['q']).not_to be_nil
+
+          instance = FreshEnv.new(%w[x y], sample_goal)
+          expect(instance.vars['x']).not_to be_nil
+          expect(instance.vars['y']).not_to be_nil
+        end
+
+        it 'should know its goal' do
+          # Single goal at initialization
+          expect(subject.goal).to eq(sample_goal)
+
+          # Multiple goals at initialization
+          instance = FreshEnv.new(['q'], [pea_goal, goal_succeeds])
+          expect(instance.goal.relation.name).to eq('conj2')
+          expect(instance.goal.actuals[0]).to eq(pea_goal)
+          expect(instance.goal.actuals[1]).to eq(goal_succeeds)
         end
       end # context
 

data/spec/glue/run_star_expression_spec.rb

@@ -2,6 +2,8 @@
 
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/conj2'
+require_relative '../../lib/mini_kraken/core/disj2'
 require_relative '../../lib/mini_kraken/core/equals'
 require_relative '../../lib/mini_kraken/core/fail'
 require_relative '../../lib/mini_kraken/core/succeed'
@@ -19,16 +21,26 @@ module MiniKraken
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
       let(:sample_goal) { equals_goal(pea, pod) }
+      let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+      let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
       subject { RunStarExpression.new('q', sample_goal) }
 
       context 'Initialization:' do
-        it 'should be initialized with a name and a goal' do
+        it 'could be initialized with a name and a goal' do
           expect { RunStarExpression.new('q', sample_goal) }.not_to raise_error
         end
 
+        it 'could be initialized with multiple names and a goal' do
+          expect { RunStarExpression.new(%w[r x y], sample_goal) }.not_to raise_error
+        end
+
+        it 'could be initialized with multiple names and goals' do
+          expect { RunStarExpression.new(%w[r x y], [succeeds, succeeds]) }.not_to raise_error
+        end
+
         it 'should know its variables' do
           expect(subject.env.vars['q']).not_to be_nil
-          expect(subject.var.name).to eq('q')
+          expect(subject.env.vars.values[0].name).to eq('q')
         end
 
         it 'should know its goal' do
@@ -37,12 +49,23 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:bean) { k_symbol(:bean) }
+        let(:corn) { k_symbol(:corn) }
+        let(:meal) { k_symbol(:meal) }
+        let(:oil) { k_symbol(:oil) }
+        let(:olive) { k_symbol(:olive) }
+        let(:red) { k_symbol(:red) }
+        let(:soup) { k_symbol(:soup) }
+        let(:split) { k_symbol(:split) }
+        let(:virgin) { k_symbol(:virgin) }
         let(:ref_q) { Core::VariableRef.new('q') }
+        let(:ref_r) { Core::VariableRef.new('r') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
         let(:ref_s) { Core::VariableRef.new('s') }
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
+        let(:ref_z) { Core::VariableRef.new('z') }
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -51,7 +74,6 @@ module MiniKraken
           instance = RunStarExpression.new('q', failing)
 
           expect(instance.run).to be_null
-          expect(ref_q.fresh?(instance.env)).to be_truthy
         end
 
         it 'should return a null list when a goal fails' do
@@ -69,7 +91,6 @@ module MiniKraken
           # Reasoned S2, frame 1:11
           # (run* q (== q 'pea) ;; => (pea)
           expect(instance.run.car).to eq(pea)
-          expect(ref_q.fresh?(instance.env)).to be_falsey
         end
 
         it 'should unify the righthand variable(s)' do
@@ -79,19 +100,14 @@ module MiniKraken
           # Reasoned S2, frame 1:12
           # (run* q (== 'pea q) ;; => (pea)
           expect(instance.run.car).to eq(pea)
-
-          # Reasoned S2, frame 1:15
-          expect(ref_q.fresh?(instance.env)).to be_falsey
         end
 
         it 'should return a null list with the succeed goal' do
-          success = Core::Goal.new(Core::Succeed.instance, [])
-          instance = RunStarExpression.new('q', success)
+          instance = RunStarExpression.new('q', succeeds)
 
           # (display (run* q succeed)) ;; => (_0)
           # Reasoned S2, frame 1:16
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
 
           # Reasoned S2, frame 1:17
           expect(result.car).to eq(any_value(0))
@@ -104,7 +120,6 @@ module MiniKraken
           # (display (run* q (== 'pea 'pea))) ;; => (_0)
           # Reasoned S2, frame 1:19
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
           expect(result.car).to eq(any_value(0))
         end
 
@@ -117,7 +132,6 @@ module MiniKraken
           # (display (run* q (== q q))) ;; => (_0)
           # Reasoned S2, frame 1:20
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
           expect(result.car).to eq(any_value(0))
         end
 
@@ -129,8 +143,6 @@ module MiniKraken
           # Reasoned S2, frame 1:21..23
           # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_falsey
-          expect(ref_x.fresh?(fresh_env)).to be_truthy
 
           #  Reasoned S2, frame 1:40
           expect(ref_q.different_from?(ref_x, fresh_env)).to be_truthy
@@ -145,8 +157,6 @@ module MiniKraken
           # Reasoned S2, frame 1:24
           # (run* q (fresh (x) (== 'pea x))) ;; => (_0)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
-          expect(ref_x.fresh?(fresh_env)).to be_falsey
           expect(result.car).to eq(any_value(0))
         end
 
@@ -158,8 +168,6 @@ module MiniKraken
           # Reasoned S2, frame 1:25
           # (run* q (fresh (x) (== (cons x '()) q))) ;; => ((_0))
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
-          expect(ref_x.fresh?(fresh_env)).to be_truthy
           expect(result.car).to eq(cons(any_value(0)))
         end
 
@@ -190,7 +198,6 @@ module MiniKraken
           # Reasoned S2, frame 1:32
           # (run* q (==  '(((pea)) pod) '(((pea)) pod))) ;; => (_0)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
           expect(result.car).to eq(any_value(0))
         end
 
@@ -204,7 +211,6 @@ module MiniKraken
           # Reasoned S2, frame 1:33
           # (run* q (==  '(((pea)) pod) `(((pea)) ,q))) ;; => ('pod)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_falsey
           expect(result.car).to eq(pod)
         end
 
@@ -217,7 +223,6 @@ module MiniKraken
           # Reasoned S2, frame 1:34
           # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pod)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_falsey
           expect(result.car).to eq(pea)
         end
 
@@ -231,8 +236,6 @@ module MiniKraken
           # Reasoned S2, frame 1:35
           # (run* q (fresh (x) (==  '(((,q)) pod) `(((,x)) pod)))) ;; => (_0)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
-          expect(ref_x.fresh?(fresh_env)).to be_truthy
           expect(result.car).to eq(any_value(0))
         end
 
@@ -246,11 +249,6 @@ module MiniKraken
           instance = RunStarExpression.new('q', fresh_env)
 
           result = instance.run
-
-          # Does propagate work correctly?
-          expect(ref_q.fresh?(instance.env)).to be_truthy # x isn't defined here
-          expect(ref_q.fresh?(fresh_env)).to be_falsey
-          expect(ref_x.fresh?(fresh_env)).to be_falsey
           expect(result.car).to eq(pod)
         end
 
@@ -263,9 +261,6 @@ module MiniKraken
           instance = RunStarExpression.new('q', fresh_env)
 
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy # x isn't defined here
-          expect(ref_q.fresh?(fresh_env)).to be_truthy
-          expect(ref_x.fresh?(fresh_env)).to be_truthy
           expect(result.car).to eq(cons(any_value(0), cons(any_value(0))))
         end
 
@@ -280,12 +275,6 @@ module MiniKraken
           instance = RunStarExpression.new('q', fresh_env_x)
 
           result = instance.run
-          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_q.bound?(fresh_env_y)).to be_truthy
-          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_x.bound?(fresh_env_y)).to be_falsy
-          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_y.bound?(fresh_env_y)).to be_falsy
 
           # y should be fused with x...
           var_x = fresh_env_y.name2var('x')
@@ -309,13 +298,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', fresh_env_x)
 
           result = instance.run
-          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
           # q should be bound to '(,x ,y)
-          expect(ref_q.bound?(fresh_env_y)).to be_truthy
-          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_x.bound?(fresh_env_y)).to be_falsey
-          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_y.bound?(fresh_env_y)).to be_falsey
           expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
         end
 
@@ -329,13 +312,7 @@ module MiniKraken
           instance = RunStarExpression.new('s', fresh_env_t)
 
           result = instance.run
-          expect(ref_s.fresh?(fresh_env_u)).to be_truthy
           # s should be bound to '(,t ,u)
-          expect(ref_s.bound?(fresh_env_u)).to be_truthy
-          expect(ref_t.fresh?(fresh_env_u)).to be_truthy
-          expect(ref_t.bound?(fresh_env_u)).to be_falsey
-          expect(ref_u.fresh?(fresh_env_u)).to be_truthy
-          expect(ref_u.bound?(fresh_env_u)).to be_falsey
           expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
         end
 
@@ -349,13 +326,461 @@ module MiniKraken
           instance = RunStarExpression.new('q', fresh_env_x)
 
           result = instance.run
-          expect(ref_q.fresh?(fresh_env_y)).to be_truthy
           # q should be bound to '(,x ,y, ,x)
-          expect(ref_q.bound?(fresh_env_y)).to be_truthy
-          expect(ref_x.fresh?(fresh_env_y)).to be_truthy
-          expect(ref_y.fresh?(fresh_env_y)).to be_truthy
           expect(result.car).to eq(cons(any_value(0), cons(any_value(1), cons(any_value(0)))))
         end
+
+        it 'should support conjunction of two succeed' do
+          goal = conj2_goal(succeeds, succeeds)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:50
+          # (run* q (conj2 succeed succeed)) ;; => (_0)
+          result = instance.run
+          expect(result.car).to eq(any_value(0))
+        end
+
+        # TODO: fix erratic RSpec failure
+        it 'should support conjunction of one succeed and a successful goal' do
+          subgoal = equals_goal(corn, ref_q)
+          goal = conj2_goal(succeeds, subgoal)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:51
+          # (run* q (conj2 succeed (== 'corn q)) ;; => ('corn)
+          result = instance.run
+          expect(result.car).to eq(corn)
+        end
+
+        it 'should support conjunction of one fail and a successful goal' do
+          subgoal = equals_goal(corn, ref_q)
+          goal = conj2_goal(fails, subgoal)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:52
+          # (run* q (conj2 fail (== 'corn q)) ;; => ()
+          expect(instance.run).to be_null
+        end
+
+        it 'should support conjunction of two contradictory goals' do
+          subgoal1 = equals_goal(corn, ref_q)
+          subgoal2 = equals_goal(meal, ref_q)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:53
+          # (run* q (conj2 (== 'corn q)(== 'meal q)) ;; => ()
+          expect(instance.run).to be_null
+        end
+
+        it 'should succeed the conjunction of two identical goals' do
+          subgoal1 = equals_goal(corn, ref_q)
+          subgoal2 = equals_goal(corn, ref_q)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:54
+          # (run* q (conj2 (== 'corn q)(== 'corn q)) ;; => ('corn)
+          result = instance.run
+          expect(result.car).to eq(corn)
+        end
+
+        it 'should not yield solution when both disjunction arguments fail' do
+          goal = disj2_goal(fails, fails)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:55
+          # (run* q (disj2 fail fail)) ;; => ()
+          expect(instance.run).to be_null
+        end
+
+        it 'should yield solution when first argument succeed' do
+          subgoal = Core::Goal.new(Core::Equals.instance, [olive, ref_q])
+          goal = disj2_goal(subgoal, fails)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:56
+          # (run* q (disj2 (== 'olive q) fail)) ;; => ('olive)
+          result = instance.run
+          expect(result.car).to eq(olive)
+        end
+
+        it 'should yield solution when second argument succeed' do
+          subgoal = Core::Goal.new(Core::Equals.instance, [oil, ref_q])
+          goal = disj2_goal(fails, subgoal)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:57
+          # (run* q (disj2 fail (== 'oil q))) ;; => (oil)
+          result = instance.run
+          expect(result.car).to eq(oil)
+        end
+
+        it 'should yield solutions when both arguments succeed' do
+          subgoal1 = Core::Goal.new(Core::Equals.instance, [olive, ref_q])
+          subgoal2 = Core::Goal.new(Core::Equals.instance, [oil, ref_q])
+          goal = disj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:58
+          # (run* q (disj2 (== 'olive q) (== 'oil q))) ;; => (olive oil)
+          result = instance.run
+          expect(result.car).to eq(olive)
+          expect(result.cdr.car).to eq(oil)
+        end
+
+        it 'should support the nesting of variables and disjunction' do
+          # Reasoned S2, frame 1:59
+          # (run* q (fresh (x) (fresh (y) (disj2  (== '( ,x ,y ) q) (== '( ,x ,y ) q)))))
+          # ;; => ((_0 _1) (_0 _1))
+          expr1 = cons(ref_x, cons(ref_y))
+          subgoal1 = equals_goal(expr1, ref_q)
+          expr2 = cons(ref_y, cons(ref_x))
+          subgoal2 = equals_goal(expr2, ref_q)
+          goal = disj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('q', fresh_env_x)
+
+          result = instance.run
+          # q should be bound to '(,x ,y), then to '(,y ,x)
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+          expect(result.cdr.car).to eq(cons(any_value(0), cons(any_value(1))))
+        end
+
+        it 'should accept nesting of disj2 and conj2 (I)' do
+          conj_subgoal = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          conjunction = conj2_goal(conj_subgoal, fails)
+          subgoal = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          goal = disj2_goal(conjunction, subgoal)
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:62
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) fail)
+          #           ('oil x))) ;; => (oil)
+          result = instance.run
+          expect(result.car).to eq(oil)
+        end
+
+        it 'should accept nesting of disj2 and conj2 (II)' do
+          conj_subgoal = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          conjunction = conj2_goal(conj_subgoal, succeeds)
+          subgoal = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          goal = disj2_goal(conjunction, subgoal)
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:63
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) succeed)
+          #           ('oil x))) ;; => (olive oil)
+          result = instance.run
+          expect(result.car).to eq(olive)
+          expect(result.cdr.car).to eq(oil)
+        end
+
+        it 'should accept nesting of disj2 and conj2 (III)' do
+          conj_subgoal = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          conjunction = conj2_goal(conj_subgoal, succeeds)
+          subgoal = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          goal = disj2_goal(subgoal, conjunction)
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:64
+          # (run* x (disj2
+          #           ('oil x)
+          #           (conj2 (== 'olive x) succeed))) ;; => (oil olive)
+          result = instance.run
+          expect(result.car).to eq(oil)
+          expect(result.cdr.car).to eq(olive)
+        end
+
+        it 'should accept nesting of disj2 and conj2 (IV)' do
+          oil_goal = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          disja = disj2_goal(succeeds, oil_goal)
+          olive_goal = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          disjb = disj2_goal(olive_goal, disja)
+          virgin_goal = Core::Goal.new(Core::Equals.instance, [virgin, ref_x])
+          conjunction = conj2_goal(virgin_goal, fails)
+          goal = disj2_goal(conjunction, disjb)
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:65
+          # (run* x (disj2
+          #           (conj2(== 'virgin x) fails)
+          #           (disj2
+          #             (== 'olive x)
+          #             (dis2
+          #               succeeds
+          #               (== 'oil x))))) ;; => (olive _0 oil)
+          result = instance.run
+          expect(result.car).to eq(olive)
+          expect(result.cdr.car).to eq(any_value(0))
+          expect(result.cdr.cdr.car).to eq(oil)
+        end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (I)' do
+          subgoal1 = equals_goal(split, ref_x)
+          expr1 = equals_goal(pea, ref_y)
+          expr2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          subgoal2 = conj2_goal(expr1, expr2)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:67
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #           (== 'split x)
+          #           (conj2
+          #             (== 'pea y)
+          #             (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (II)' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:68
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #         (conj2
+          #           (== 'split x)
+          #           (== 'pea y)
+          #         (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:70
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (conj2
+          #         (== 'split x)
+          #         (== 'pea y)
+          #       (== '(,x ,y) r))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[r x y], goal)
+
+          # 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 = instance.run
+          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 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          goal = conj2_goal(expr1, expr2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:75
+          # (run* (x y)
+          #   (conj2
+          #     (== 'split x)
+          #     (== 'pea y))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:76
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+        end
+
+        it 'should allow nesting a disjunction inside of conjunction' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(red, ref_x)
+          subgoal1 = disj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(ref_x, ref_y)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # (display (run* (x y)
+          #   (conj2
+          #     (disj2
+          #       (== 'split x)
+          #       (== 'red x))
+          #     (== x y)))) ;; => ((split split) (red red))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(split)
+          expect(result.cdr.car.cdr.car).to eq(red)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          subgoal3 = disj2_goal(subgoal1, subgoal2)
+          subgoal4 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          goal = conj2_goal(subgoal3, subgoal4)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # 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 = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow fresh with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          fresh_env = FreshEnv.new(%w[x y], [goal1, goal2])
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # 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 = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow run* with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(soup, ref_z)
+          instance = RunStarExpression.new(%w[x y z], [goal1, goal2])
+
+          # 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 = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow simplified expressions with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          instance = RunStarExpression.new(%w[x y], [expr1, expr2])
+
+          # Reasoned S2, frame 1:81
+          # (run* (x y)
+          #   (== 'split x)
+          #   (== 'pea y)) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
       end # context
     end # describe
   end # module