mini_kraken 0.2.02 → 0.3.02

data/spec/glue/dsl_chap2_spec.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/glue/dsl'
+
+
+module MiniKraken
+  module Glue
+    describe 'DSL (Chap 2)' do
+      include DSL
+
+      context 'Chapter 2 examples:' do
+        # ((:a) (:b) (:c))
+        let(:abc) { cons(cons(:a), cons(cons(:b), cons(cons(:c)))) }
+
+        # '(:a :c :o :r :n)
+        let(:acorn) { cons(:a, cons(:c, cons(:o, cons(:r, cons(:n))))) }
+
+        # '(:c :o :r :n)
+        let(:corn) { cons(:c, cons(:o, cons(:r, cons(:n)))) }
+
+        # '(:grape :raisin :pear)'
+        let(:fruits) { cons(:grape, cons(:raisin, cons(:pear))) }
+
+        let(:uuid_pattern) do
+          /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+        end
+
+        it 'accepts caro definition inspired from frame 2:6' do
+          # Reasoned S2, frame 2:6
+          # (defrel (caro p a)
+          #   (fresh (d)
+          #   (== (cons a d) p)))
+
+          # As 'p' has a special meaning in Ruby, the argument has been renamed to 'r'
+          caro_rel = defrel('caro', %w[r a], fresh('d', unify(cons(a, d), r)))
+
+          # Check side-effect from DSL
+          expect(instance_variable_get(:@defrels)['caro']).to eq(caro_rel)
+
+          # Check results of defrel
+          expect(caro_rel).to be_kind_of(Rela::DefRelation)
+          expect(caro_rel.name).to eq('caro')
+          expect(caro_rel.arity).to eq(2)
+          expect(caro_rel.formals[0]).to match(/^r_/)
+          expect(caro_rel.formals[0]).to match(uuid_pattern)
+          expect(caro_rel.formals[1]).to match(/^a_/)
+          expect(caro_rel.formals[1]).to match(uuid_pattern)
+          g_template = caro_rel.expression
+
+          # Checking the 'fresh' part
+          expect(g_template).to be_kind_of(Core::Goal)
+          expect(g_template.relation).to be_kind_of(Rela::Fresh)
+          expect(g_template.actuals[0]).to eq('d')
+          fresh_2nd_actual = g_template.actuals[1]
+
+          # Checking the (== (cons a d) r) sub-expression
+          expect(fresh_2nd_actual).to be_kind_of(Core::Goal)
+          expect(fresh_2nd_actual.relation.name).to eq('unify')
+          expect(fresh_2nd_actual.actuals[0]).to be_kind_of(Composite::ConsCell)
+          expect(fresh_2nd_actual.actuals[0].to_s).to match(/^\(a_[-0-9a-f]+ \. d\)$/)
+          expect(fresh_2nd_actual.actuals[1]).to be_kind_of(Core::LogVarRef)
+          expect(fresh_2nd_actual.actuals[1].name).to match(/^r_[-0-9a-f]+$/)
+        end
+
+        # In Scheme:
+        # (defrel (caro p a)
+        #   (fresh (d)
+        #   (== p (cons a d))))
+        # In Ruby, `p`is a standard Kernel method => replace it by `r`
+        def defrel_caro
+          defrel('caro', %w[r a], fresh('d', unify(r, cons(a, d))))
+        end
+
+        it 'passes frame 2:3' do
+          defrel_caro
+
+          # (run* q
+          #   (caro '(a c o r n) q)) ;; => (a)
+          result = run_star('q', caro(acorn, q))
+          expect(result.car).to eq(:a)
+        end
+
+        it 'passes frame 2:4' do
+          defrel_caro
+
+          # (run* q
+          #   (caro '(a c o r n) 'a)) ;; => (_0)
+          result = run_star('q', caro(acorn, :a))
+          expect(result.car).to eq(:_0)
+        end
+
+        # IT FAILS
+        it 'passes frame 2:5' do
+          defrel_caro
+
+          # (run* r
+          #   (fresh (x y)
+          #     (caro '(,r ,y) x)
+          #     (== 'pear x)));; r => (pear)
+          result = run_star('r', fresh(%w[x y],
+            [caro(cons(r, cons(y)), x),
+              unify(:pear, x)]))
+          expect(result.car).to eq(:pear)
+        end
+
+        it 'passes frame 2:8' do
+          defrel_caro
+
+          # (run* r
+          #   (fresh (x y)
+          #     (caro '(grape raisin pear) x)
+          #     (caro '((a) (b) (c)) y)
+          #     (== (cons x y) r))) ;; r => ((grape a))
+
+          result = run_star('r', fresh(%w[x y],
+            [caro(fruits, x),
+              caro(abc, y),
+              unify(cons(x, y), r)]))
+          expect(result.car).to eq(cons(:grape, cons(:a)))
+        end
+
+        it 'accepts cdro definition inspired from frame 2:13' do
+          # Reasoned S2, frame 2:13
+          # (defrel (cdro p d)
+          #   (fresh (a)
+          #   (== (cons a d) p)))
+
+          # As 'p' has a special meaning in Ruby, the argument has been remaned to 'r'
+          cdro_rel = defrel('cdro', %w[r d], fresh('a', unify(cons(a, d), r)))
+
+          expect(cdro_rel).to be_kind_of(Rela::DefRelation)
+          expect(cdro_rel.name).to eq('cdro')
+          expect(cdro_rel.arity).to eq(2)
+          expect(cdro_rel.formals[0]).to match(/^r_[-0-9a-f]+$/)
+          expect(cdro_rel.formals[1]).to match(/^d_[-0-9a-f]+$/)
+          g_template = cdro_rel.expression
+          expect(g_template.relation).to be_kind_of(Rela::Fresh)
+          expect(g_template.actuals).to include('a')
+        end
+
+        # In Scheme:
+        # (defrel (cdro p d)
+        #   (fresh (a)
+        #   (== p (cons a d))))
+        # In Ruby, `p`is a standard Kernel method => replace it by `r`
+        def defrel_cdro
+          defrel('cdro', %w[r d], fresh('a', unify(r, cons(a, d))))
+        end
+
+        it 'passes unnesting process in frame 2:12' do
+          defrel_caro
+          defrel_cdro
+
+          # (run* r
+          #   (fresh (v)
+          #     (cdro '(acorn) v)
+          #     (fresh (w)
+          #       (cdro v w)
+          #       (caro w r))) ;; r => (o)
+
+          result = run_star('r', fresh('v',
+            [cdro(acorn, v),
+              fresh('w',
+                [cdro(v, w),
+                  caro(w, r)])]))
+          expect(result.car).to eq(:o)
+        end
+
+        it 'passes frame 2:15' do
+          defrel_caro
+          defrel_cdro
+
+          # (run* r
+          #   (fresh (x y)
+          #     (cdro '(grape raisin pear) x)
+          #     (caro '((a) (b) (c)) y)
+          #     (== (cons x y) r))) ;; r => (((raisin pear) a))
+
+          result = run_star('r', fresh(%w[x y],
+            [cdro(fruits, x),
+              caro(abc, y),
+              unify(cons(x, y), r)]))
+          expect(result.to_s).to eq('(((:raisin :pear) :a))')
+        end
+
+        it 'passes frame 2:16' do
+          defrel_cdro
+
+          # (run* q
+          #   (cdro '(a c o r n) '(c o r n))) ;; => (_0)
+          result = run_star('r', cdro(acorn, corn))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 2:17' do
+          defrel_cdro
+
+          # (run* x
+          #   (cdro '(c o r n) '(,x r n))) ;; => (o)
+          result = run_star('x', cdro(corn, cons(x, cons(:r, cons(:n)))))
+          expect(result.car).to eq(:o)
+        end
+
+        it 'passes frame 2:18' do
+          defrel_caro
+          defrel_cdro
+
+          # (run* l
+          #   (fresh (x)
+          #     (cdro l '(c o r n))
+          #     (caro l x)
+          #     (== 'a x))) ;; l => ('(a c o r n))
+
+          result = run_star('l', fresh('x',
+            [cdro(l, corn),
+              caro(l, x),
+              unify(:a, x)]))
+          expect(result.to_s).to eq('((:a :c :o :r :n))')
+        end
+
+        it 'accepts conso definition inspired from frame 2:25' do
+          defrel_caro
+          defrel_cdro
+
+          # Reasoned S2, frame 2:25
+          # (defrel (conso a p d)
+          #   (caro  p a)
+          #   (cdro p d))
+
+          # As 'p' has a special meaning in Ruby, the argument has been remaned to 'r'
+          conso_rel = defrel('conso', %w[a d r], [caro(r, a), cdro(r, d)])
+
+          expect(conso_rel).to be_kind_of(Rela::DefRelation)
+          expect(conso_rel.name).to eq('conso')
+          expect(conso_rel.arity).to eq(3)
+          expect(conso_rel.formals[0]).to match(/^a_[-0-9a-f]+$/)
+          expect(conso_rel.formals[1]).to match(/^d_[-0-9a-f]+$/)
+          expect(conso_rel.formals[2]).to match(/^r_[-0-9a-f]+$/)
+          g_template = conso_rel.expression
+          expect(g_template.relation).to be_kind_of(Rela::Conj2)
+          g1 = g_template.actuals[0]
+          expect(g1).to be_kind_of(Core::Goal)
+          expect(g1.relation.name).to eq('caro')
+          expect(g1.actuals[0].name).to match(/^r_/)
+          expect(g1.actuals[1].name).to match(/^a_/)
+
+          g2 = g_template.actuals[1]
+          expect(g2).to be_kind_of(Core::Goal)
+          expect(g2.relation.name).to eq('cdro')
+          expect(g2.actuals[0].name).to match(/^r_/)
+          expect(g2.actuals[1].name).to match(/^d_/)
+        end
+
+        # In Scheme:
+          # (defrel (conso a d p)
+          #   (caro  p a)
+          #   (cdro p d))
+        # In Ruby, `p`is a standard Kernel method => replace it by `r`
+        def defrel_conso
+          defrel_caro
+          defrel_cdro
+
+          # Definition derived from frame 2:25
+          # defrel('conso', %w[a d r], [caro(r, a), cdro(r, d)])
+
+          # Definition derived from frame 2:26
+          defrel('conso', %w[a d r], [unify(cons(a, d), r)])
+        end
+
+        it 'passes frame 2:19' do
+          defrel_conso
+
+          # (run* l
+          #   (conso '(a b c) '(d e) l)) ;; => (((a b c) d e))
+
+          result = run_star('l', conso(list(:a, :b, :c), list(:d, :e), l))
+          expect(result.to_s).to eq('(((:a :b :c) :d :e))')
+        end
+
+        it 'passes frame 2:20' do
+          defrel_conso
+
+          # (run* x
+          #   (conso x '(a b c) '(d a b c))) ;; => (d)
+
+          result = run_star('x', conso(x, list(:a, :b, :c), list(:d, :a, :b, :c)))
+          expect(result.to_s).to eq('(:d)')
+        end
+
+        it 'passes frame 2:21' do
+          defrel_conso
+
+          # (run* r
+          #   (fresh (x y z)
+          #     (== '(e a d ,x) r)
+          #     (conso y '(a ,z c) r))) ;; => ((e a d c)
+
+          expr = fresh(%w[x y z],
+            [unify(list(:e, :a, :d, x), r),
+              conso(y, list(:a, z, :c), r)])
+          result = run_star('r', expr)
+          expect(result.to_s).to eq('((:e :a :d :c))')
+        end
+
+        it 'passes frame 2:22' do
+          defrel_conso
+
+          # (run* x
+          #   (conso x '(a ,x c) '(d a ,x c))) ;; => (d)
+
+          result = run_star('x', conso(x, list(:a, x, :c), list(:d, :a, x, :c)))
+          expect(result.to_s).to eq('(:d)')
+        end
+
+        it 'passes frame 2:23' do
+          defrel_conso
+
+          # (run* l
+          #   (fresh (x)
+          #     (== '(d a ,x c) l)
+          #     (conso x '(a ,x c) l))) ;; => ((d a d c)
+
+          expr = fresh(%w[x],
+            [unify(list(:d, :a, x, :c), l),
+              conso(x, list(:a, x, :c), l)])
+          result = run_star('l', expr)
+          expect(result.to_s).to eq('((:d :a :d :c))')
+        end
+
+        it 'passes frame 2:24' do
+          defrel_conso
+
+          # (run* l
+          #   (fresh (x)
+          #     (conso x '(a ,x c) l)))
+          #     (== '(d a ,x c) l) ;; => ((d a d c)
+
+          expr = fresh(%w[x],
+            [conso(x, list(:a, x, :c), l),
+              unify(list(:d, :a, x, :c), l)])
+          result = run_star('l', expr)
+          expect(result.to_s).to eq('((:d :a :d :c))')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -1,19 +1,11 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/goal'
-require_relative '../../lib/mini_kraken/core/conde'
-require_relative '../../lib/mini_kraken/core/conj2'
-require_relative '../../lib/mini_kraken/core/def_relation'
-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/formal_arg'
-require_relative '../../lib/mini_kraken/core/formal_ref'
-require_relative '../../lib/mini_kraken/core/goal_template'
-require_relative '../../lib/mini_kraken/core/succeed'
-
-require_relative '../support/factory_methods'
+
+require_relative '../../lib/mini_kraken/core/all_core'
+require_relative '../../lib/mini_kraken/rela/all_rela'
+require_relative '../support/factory_atomic'
+# require_relative '../support/factory_methods'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/glue/run_star_expression'
@@ -22,14 +14,19 @@ require_relative '../../lib/mini_kraken/glue/run_star_expression'
 module MiniKraken
   module Glue
     describe RunStarExpression do
-      include FactoryMethods
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
-      let(:sample_goal) { equals_goal(pea, pod) }
+      let(:sample_goal) { unify_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) }
 
+      def unify_goal(arg1, arg2)
+        Core::Goal.new(Rela::Unify.instance, [arg1, arg2])
+      end
+
       context 'Initialization:' do
         it 'could be initialized with a name and a goal' do
           expect { RunStarExpression.new('q', sample_goal) }.not_to raise_error
@@ -39,17 +36,18 @@ module MiniKraken
           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 '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.env.vars.values[0].name).to eq('q')
+          definitions = subject.ctx.symbol_table.current_scope.defns
+          expect(definitions['q']).not_to be_nil
+          expect(definitions.values[0].name).to eq('q')
         end
 
         it 'should know its goal' do
-          expect(subject.env.goal).to eq(sample_goal)
+          expect(subject.goal).to eq(sample_goal)
         end
       end # context
 
@@ -69,25 +67,37 @@ module MiniKraken
         let(:split) { k_symbol(:split) }
         let(:tea) { k_symbol(:tea) }
         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_z) { Core::VariableRef.new('z') }
-        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') }
+        let(:ref_q) { Core::LogVarRef.new('q') }
+        let(:ref_r) { Core::LogVarRef.new('r') }
+        let(:ref_x) { Core::LogVarRef.new('x') }
+        let(:ref_y) { Core::LogVarRef.new('y') }
+        let(:ref_z) { Core::LogVarRef.new('z') }
+        let(:ref_s) { Core::LogVarRef.new('s') }
+        let(:ref_t) { Core::LogVarRef.new('t') }
+        let(:ref_u) { Core::LogVarRef.new('u') }
+        let(:ref_z) { Core::LogVarRef.new('z') }
         let(:t_ref) { Core::FormalRef.new('t') }
-        let(:equals_tea) { Core::GoalTemplate.new(Core::Equals.instance, [tea, t_ref]) }
-        let(:equals_cup) { Core::GoalTemplate.new(Core::Equals.instance, [cup, t_ref]) }
-        let(:g_template) { Core::GoalTemplate.new(Core::Disj2.instance, [equals_tea, equals_cup]) }
-        let(:formal_t) { Core::FormalArg.new('t') }
 
-        # Reasoned S2, frame 1:82
-        # (defrel (teacupo t)
-        #   (disj2 (== 'tea t) (== 'cup t)))
-        let(:teacupo_rel) { Core::DefRelation.new('teacupo', g_template, [formal_t]) }
+        # @return [Core::Goal]
+        def fresh(names, subgoal)
+          # puts "#{__callee__} #{names}"
+          if names.kind_of?(Array)
+            k_names = names.map { |nm| Atomic::KString.new(nm) }
+          else
+            k_names = Atomic::KString.new(names)
+          end
+          Core::Goal.new(Rela::Fresh.instance, [k_names, subgoal])
+        end
+
+        def conj2(term1, term2)
+           Core::Goal.new(Rela::Conj2.instance, [term1, term2])
+        end
+
+        def unify(term1, term2)
+           Core::Goal.new(Rela::Unify.instance, [term1, term2])
+        end
+
+
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -98,904 +108,70 @@ module MiniKraken
           expect(instance.run).to be_null
         end
 
-        it 'should return a null list when a goal fails' do
+        it 'should return a null list with a failing goal' do
           # Reasoned S2, frame 1:10
-          # (run* q (== 'pea 'pod) ;; => ()
-
-          expect(subject.run).to be_null
-          expect(ref_q.fresh?(subject.env)).to be_truthy
-        end
-
-        it 'should unify the variable with the equals goal with symbol' do
-          goal = equals_goal(ref_q, pea)
-          instance = RunStarExpression.new('q', goal)
-
-          # Reasoned S2, frame 1:11
-          # (run* q (== q 'pea) ;; => (pea)
-          expect(instance.run.car).to eq(pea)
-        end
+          # (run* q (== 'pea 'pod)) ;; => ()
+          instance = RunStarExpression.new('q', unify(pea, pod))
 
-        it 'should unify the righthand variable(s)' do
-          goal = equals_goal(pea, ref_q)
-          instance = RunStarExpression.new('q', goal)
-
-          # Reasoned S2, frame 1:12
-          # (run* q (== 'pea q) ;; => (pea)
-          expect(instance.run.car).to eq(pea)
+          expect(instance.run).to be_null
         end
 
-        it 'should return a null list with the succeed goal' do
-          instance = RunStarExpression.new('q', succeeds)
-          expect(instance.env.vars).to be_include('q')
-
-          # (display (run* q succeed)) ;; => (_0)
-          # Reasoned S2, frame 1:16
-          result = instance.run
-
+        it 'should return a _0 with the succeed goal' do
           # Reasoned S2, frame 1:17
-          expect(result.car).to eq(any_value(0))
-        end
+          # (run* q #s) ;; => (_0)
+          success = Core::Goal.new(Core::Succeed.instance, [])
+          instance = RunStarExpression.new('q', success)
 
-        it 'should keep variable fresh when no unification occurs (I)' do
-          goal = equals_goal(pea, pea)
-          instance = RunStarExpression.new('q', goal)
-
-          # (display (run* q (== 'pea 'pea))) ;; => (_0)
-          # Reasoned S2, frame 1:19
-          result = instance.run
-          expect(result.car).to eq(any_value(0))
+          expect(instance.run.to_s).to eq('(_0)')
         end
 
-        it 'should keep variable fresh when no unification occurs (II)' do
-          ref1_q = Core::VariableRef.new('q')
-          ref2_q = Core::VariableRef.new('q')
-          goal = equals_goal(ref1_q, ref2_q)
-          instance = RunStarExpression.new('q', goal)
-
-          # (display (run* q (== q q))) ;; => (_0)
-          # Reasoned S2, frame 1:20
-          result = instance.run
-          expect(result.car).to eq(any_value(0))
-        end
-
-        it 'should accept the nesting of sub-environment' do
-          goal = equals_goal(pea, ref_q)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          # Reasoned S2, frame 1:21..23
-          # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
-          result = instance.run
-
-          #  Reasoned S2, frame 1:40
-          expect(ref_q.different_from?(ref_x, fresh_env)).to be_truthy
-          expect(result.car).to eq(pea)
-        end
-
-        it 'should unify nested variables' do
-          goal = equals_goal(pea, ref_x)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          # Reasoned S2, frame 1:24
-          # (run* q (fresh (x) (== 'pea x))) ;; => (_0)
-          result = instance.run
-          expect(result.car).to eq(any_value(0))
-        end
-
-        it 'should accept expression with variables' do
-          goal = equals_goal(cons(ref_x), ref_q)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          # Reasoned S2, frame 1:25
-          # (run* q (fresh (x) (== (cons x '()) q))) ;; => ((_0))
-          result = instance.run
-          expect(result.car).to eq(cons(any_value(0)))
-        end
-
-        it 'should accept fused variables' do
-          goal = equals_goal(ref_x, ref_q)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          # Reasoned S2, frame 1:31
-          # (run* q (fresh (x) (== x q))) ;; => (_0)
-          result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
-          expect(ref_x.fresh?(fresh_env)).to be_truthy
-
-          # q should be fused with x...
-          expect(ref_q.fused_with?(ref_x, fresh_env)).to be_truthy
-          expect(ref_q.names_fused(fresh_env)).to eq(['x'])
-          expect(ref_x.names_fused(fresh_env)).to eq(['q'])
-          expect(result.car).to eq(any_value(0))
-        end
-
-        it 'should cope with complex equality expressions' do
-          expr1 = cons(cons(cons(pea)), pod)
-          expr2 = cons(cons(cons(pea)), pod)
-          goal = equals_goal(expr1, expr2)
-          instance = RunStarExpression.new('q', goal)
-
-          # Reasoned S2, frame 1:32
-          # (run* q (==  '(((pea)) pod) '(((pea)) pod))) ;; => (_0)
-          result = instance.run
-          expect(result.car).to eq(any_value(0))
-        end
-
-        it 'should unify complex equality expressions (I)' do
-          expr1 = cons(cons(cons(pea)), pod)
-          expr2 = cons(cons(cons(pea)), ref_q)
-          goal = equals_goal(expr1, expr2)
-          instance = RunStarExpression.new('q', goal)
-
-          # Beware: quasiquoting
-          # Reasoned S2, frame 1:33
-          # (run* q (==  '(((pea)) pod) `(((pea)) ,q))) ;; => ('pod)
-          result = instance.run
-          expect(result.car).to eq(pod)
-        end
-
-        it 'should unify complex equality expressions (II)' do
-          expr1 = cons(cons(cons(ref_q)), pod)
-          expr2 = cons(cons(cons(pea)), pod)
-          goal = equals_goal(expr1, expr2)
-          instance = RunStarExpression.new('q', goal)
-
-          # Reasoned S2, frame 1:34
-          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
-          result = instance.run
-          expect(result.car).to eq(pea)
-        end
-
-        it 'should unify complex equality expressions (III)' do
-          expr1 = cons(cons(cons(ref_q)), pod)
-          expr2 = cons(cons(cons(ref_x)), pod)
-          goal = equals_goal(expr1, expr2)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          # Reasoned S2, frame 1:35
-          # (run* q (fresh (x) (==  '(((,q)) pod) `(((,x)) pod)))) ;; => (_0)
-          result = instance.run
-          expect(result.car).to eq(any_value(0))
-        end
-
-        it 'should unify complex equality expressions (IV)' do
-          # Reasoned S2, frame 1:36
-          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
-          expr1 = cons(cons(cons(ref_q)), ref_x)
-          expr2 = cons(cons(cons(ref_x)), pod)
-          goal = equals_goal(expr1, expr2)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          result = instance.run
-          expect(result.car).to eq(pod)
-        end
-
-        it 'should unify with repeated fresh variable' do
-          # Reasoned S2, frame 1:37
-          # (run* q (fresh (x) (==  '( ,x ,x) q))) ;; => (_0 _0)
-          expr1 = cons(ref_x, cons(ref_x))
-          goal = equals_goal(expr1, ref_q)
-          fresh_env = FreshEnv.new(['x'], goal)
-          instance = RunStarExpression.new('q', fresh_env)
-
-          result = instance.run
-          expect(result.car).to eq(cons(any_value(0), cons(any_value(0))))
-        end
-
-        it 'should unify multiple times' do
-          # Reasoned S2, frame 1:38
-          # (run* q (fresh (x) (fresh (y) (==  '( ,q ,y) '((,x ,y) ,x))))) ;; => (_0 _0)
-          expr1 = cons(ref_q, cons(ref_y))
-          expr2 = cons(cons(ref_x, cons(ref_y)), cons(ref_x))
-          goal = equals_goal(expr1, expr2)
-          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
-
-          # y should be fused with x...
-          var_x = fresh_env_y.name2var('x')
-          var_y = fresh_env_y.name2var('y')
-          expect(var_x.i_name).to eq(var_y.i_name)
-          expect(ref_y.fused_with?(ref_x, fresh_env_y)).to be_truthy
-          expect(ref_x.names_fused(fresh_env_y)).to eq(['y'])
-          expect(ref_y.names_fused(fresh_env_y)).to eq(['x'])
-
-          # q should be bound to '(,x ,x)
-          expect(result.car).to eq(cons(any_value(0), cons(any_value(0))))
-        end
-
-        it 'should support multiple fresh variables' do
-          # Reasoned S2, frame 1:41
-          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y) q)))) ;; => (_0 _1)
-          expr1 = cons(ref_x, cons(ref_y))
-          goal = equals_goal(expr1, ref_q)
-          fresh_env_y = FreshEnv.new(['y'], goal)
-          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
-          instance = RunStarExpression.new('q', fresh_env_x)
+        it 'should return a value with a succeeding goal and q bound' do
+          # Reasoned S2, frame 1:11
+          # (run* q (== q 'pea)) ;; => (pea)
+          instance = RunStarExpression.new('q', unify(ref_q, pea))
 
-          result = instance.run
-          # q should be bound to '(,x ,y)
-          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+          expect(instance.run.to_s).to eq('(:pea)')
         end
 
-        it 'should work with variable names' do
-          # Reasoned S2, frame 1:42
-          # (run* s (fresh (t) (fresh (u) (==  '( ,t ,u) s)))) ;; => (_0 _1)
-          expr1 = cons(ref_t, cons(ref_u))
-          goal = equals_goal(expr1, ref_s)
-          fresh_env_u = FreshEnv.new(['u'], goal)
-          fresh_env_t = FreshEnv.new(['t'], fresh_env_u)
-          instance = RunStarExpression.new('s', fresh_env_t)
+        it 'should return a _0 with a succeeding goal and q fresh' do
+          # Reasoned S2, frame 1:11
+          # (run* q (== q q)) ;; => (_0)
+          instance = RunStarExpression.new('q', unify(ref_q, ref_q))
 
-          result = instance.run
-          # s should be bound to '(,t ,u)
-          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+          expect(instance.run.to_s).to eq('(_0)')
         end
 
-        it 'should support repeated variables' do
-          # Reasoned S2, frame 1:43
-          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y ,x) q)))) ;; => (_0 _1 _0)
-          expr1 = cons(ref_x, cons(ref_y, cons(ref_x)))
-          goal = equals_goal(expr1, ref_q)
-          fresh_env_y = FreshEnv.new(['y'], goal)
-          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
-          instance = RunStarExpression.new('q', fresh_env_x)
+        it 'should support the fresh form to nest scopes' do
+          # Reasoned S2, frame 1:21
+          # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
+          subgoal = unify(pea, ref_q)
+          instance = RunStarExpression.new('q', fresh('x', subgoal))
 
-          result = instance.run
-          # q should be bound to '(,x ,y, ,x)
-          expect(result.car).to eq(cons(any_value(0), cons(any_value(1), cons(any_value(0)))))
+          expect(instance.run.to_s).to eq('(:pea)')
         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)
+          goal = conj2(succeeds, succeeds)
+          instance = RunStarExpression.new('q', goal)
+
           result = instance.run
-          expect(result.car).to eq(any_value(0))
+          expect(result.to_s).to eq('(_0)')
         end
 
         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) fail)
-          #           (disj2
-          #             (== 'olive x)
-          #             (dis2
-          #               succeed
-          #               (== '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 simplification 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
+          subgoal = unify(corn, ref_q)
+          instance = RunStarExpression.new('q', conj2(succeeds, subgoal))
 
-        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)
+          expect(result.to_s).to eq('(:corn)')
         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
-
-        it 'should solve expression with defrel' do
-          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
-
-          # Reasoned S2, frame 1:83
-          # (run* x
-          #   (teacupo x)) ;; => ((tea cup))
-          instance = RunStarExpression.new('x', teacupo_goal)
-
-          result = instance.run
-          expect(result.car).to eq(tea)
-          expect(result.cdr.car).to eq(cup)
-        end
-
-        it 'should solve expression with defrel and booleans' do
-          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
-          expr2 = equals_goal(k_true, ref_y)
-          subgoal1 = conj2_goal(teacupo_goal, expr2)
-          expr3 = equals_goal(k_false, ref_x)
-          expr4 = equals_goal(k_true, ref_y)
-          subgoal2 = conj2_goal(expr3, expr4)
-          goal = disj2_goal(subgoal1, subgoal2)
-          # Reasoned S2, frame 1:84
-          # (run* (x y)
-          #   (disj2
-          #     (conj2 (teacupo x) (== #t y))
-          #     (conj2 (== #f x) (== #t y))) ;; => ((#f #t)(tea #t) (cup #t))
-          instance = RunStarExpression.new(%w[x y], goal)
-
-          result = instance.run
-          # Order of solutions differs from RS book
-          expect(result.car).to eq(cons(tea, cons(true)))
-          expect(result.cdr.car).to eq(cons(cup, cons(true)))
-          expect(result.cdr.cdr.car).to eq(cons(false, cons(true)))
-        end
-
-        it 'should solve expression with two variable and defrel' do
-          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
-          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_y])
-
-          # Reasoned S2, frame 1:85
-          # (run* (x y)
-          #   (teacupo x)
-          #   (teacupo y)) ;; => ((tea tea)(tea cup)(cup tea)(cup c))
-          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
-
-          result = instance.run
-          expect(result.car).to eq(cons(tea, cons(tea)))
-          expect(result.cdr.car).to eq(cons(tea, cons(cup)))
-          expect(result.cdr.cdr.car).to eq(cons(cup, cons(tea)))
-          expect(result.cdr.cdr.cdr.car).to eq(cons(cup, cons(cup)))
-        end
-
-        it 'should solve expression with two variable and defrel' do
-          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
-          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
-
-          # Reasoned S2, frame 1:86
-          # (run* (x y)
-          #   (teacupo x)
-          #   (teacupo x)) ;; => ((tea _0)(cup _0))
-          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
-
-          result = instance.run
-          expect(result.car).to eq(cons(tea, cons(any_value(0))))
-          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
-        end
-
-        it 'should solve expression with defrel and booleans' do
-          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
-          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
-          subgoal1 = conj2_goal(teacupo_goal1, teacupo_goal2)
-          expr3 = equals_goal(k_false, ref_x)
-          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
-          subgoal2 = conj2_goal(expr3, expr4)
-          goal = disj2_goal(subgoal1, subgoal2)
-          # Reasoned S2, frame 1:87
-          # (run* (x y)
-          #   (disj2
-          #     (conj2 (teacupo x) (teacupo x))
-          #     (conj2 (== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
-          instance = RunStarExpression.new(%w[x y], goal)
-
-          result = instance.run
-          # Order of solutions differs from RS book
-          expect(result.car).to eq(cons(tea, cons(any_value(0))))
-          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
-          expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
-          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
-        end
-
-        it 'should allow conde in the goal expression' do
-          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
-          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
-          expr3 = equals_goal(k_false, ref_x)
-          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
-          goal = conde_goal([[teacupo_goal1, teacupo_goal2], [expr3, expr4]])
-          # Reasoned S2, frame 1:88
-          # (run* (x y)
-          #   (conde
-          #     ((teacupo x) (teacupo x))
-          #     ((== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
-          instance = RunStarExpression.new(%w[x y], goal)
-
-          result = instance.run
-          expect(result.car).to eq(cons(tea, cons(any_value(0))))
-          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
-          expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
-          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
-        end
-
-        it 'should allow simplication of expressions (conde version)' do
-          expr1 = equals_goal(split, ref_x)
-          expr2 = equals_goal(pea, ref_y)
-          combo1 = [expr1, expr2]
-          expr3 = equals_goal(red, ref_x)
-          expr4 = equals_goal(bean, ref_y)
-          combo2 = [expr3, expr4]
-          goal = conde_goal([combo1, combo2])
-          instance = RunStarExpression.new(%w[x y], goal)
-
-          # Reasoned S2, frame 1:88 (second part, a rewrite of 1:76)
-          # (run* (x y)
-          #   (conde
-          #     ((== 'split x) (== 'pea y))
-          #     ((== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
-          result = 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 accept nesting of disj2 and conj2 (conde version)' do
-          equals_olive = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
-          combo = [equals_olive, fails]
-          equals_oil = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
-          goal = conde_goal([combo, equals_oil])
-          instance = RunStarExpression.new('x', goal)
-
-          # Reasoned S2, frame 1:89 (rewrite of 1:62)
-          # (run* x
-          #   (conde
-          #     ((== 'olive x) fail)
-          #     ('oil x))) ;; => (oil)
-          result = instance.run
-          expect(result.car).to eq(oil)
-        end
-
-        it 'should accept nesting of conde inside a fresh context' do
-          equals_lentil = Core::Goal.new(Core::Equals.instance, [lentil, ref_z])
-          fresh_env = FreshEnv.new(['z'], equals_lentil)
-          equals_xy = Core::Goal.new(Core::Equals.instance, [ref_x, ref_y])
-          goal = conde_goal([fresh_env, equals_xy])
-          instance = RunStarExpression.new(%w[x y], goal)
-          fresh_env.parent = instance.env
-
-          # Reasoned S2, frame 1:90
-          # (run* (x y)
-          #   (conde
-          #     ((fresh (z)
-          #       (== 'lentil z)))
-          #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
-          result = instance.run
-          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(0))))
-        end
-
-        it 'accepts conde with more than two condition lines' do
-          expr1 = equals_goal(split, ref_x)
-          expr2 = equals_goal(pea, ref_y)
-          combo1 = [expr1, expr2]
-          expr3 = equals_goal(red, ref_x)
-          expr4 = equals_goal(bean, ref_y)
-          combo2 = [expr3, expr4]
-          expr5 = equals_goal(green, ref_x)
-          expr6 = equals_goal(lentil, ref_y)
-          combo3 = [expr5, expr6]
-          goal = conde_goal([combo1, combo2, combo3])
-          instance = RunStarExpression.new(%w[x y], goal)
-
-          # Reasoned S2, frame 1:91
-          # (run* (x y)
-          #   (conde
-          #     ((== 'split x) (== 'pea y))
-          #     ((== 'red x) (== 'bean y))
-          #     ((== 'green x) (== 'lentil y))))
-          # ;; => ((split pea)(red bean)(green lentil))
-          result = instance.run
-          expect(result.car).to eq(cons(split, cons(pea)))
-          expect(result.cdr.car).to eq(cons(red, cons(bean)))
-          expect(result.cdr.cdr.car).to eq(cons(green, cons(lentil)))
-        end
+        # TODO: add two solutions case
+        # TODO: add fused variables
       end # context
     end # describe
   end # module