mini_kraken 0.1.06 → 0.1.07

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 800d58c5efac32c005931c5a019f4440060728d1061c381bd10f95d554a525b1
-  data.tar.gz: 217448cd67ca952439e81da5c89393ddd57d061d7ca9d5ed310119d1aab32cbf
+  metadata.gz: 15536181da18de42e83ec948742a97c63338f2065841849de64d3537eeeb9bc1
+  data.tar.gz: bb25b2bfcab17da55d5dfa6845e699fa2a48e89e19956f3c63f2e755577d4ae7
 SHA512:
-  metadata.gz: e52d5bdc7a34e1b303f2423fd8463766852bd61dc14d77e7bce43bcf653fd43d2331eb8f4bbc1beee13958e4621c9729b728d0cf5bbb5336bd5e277bf859a473
-  data.tar.gz: 75b7a091579f667b41949905861ec314eb6a269ca5316b67df80cbf9f02d6d86ecd1c0ff74d61de3018c802e7c48ff7a2e4719bcb75f0ef45cca0092ebd3cb25
+  metadata.gz: a964e66c182fa2d834007c2003fa7b16b0e91d8cc80f8525de9c95df89d81523a9a2e93c7e57c2a96605ce6af5244324d5a7bf80c877d46a8a647726a3ac1e49
+  data.tar.gz: 6608b250a6949ce6d7f3fd4c548c7525595fc20c808b5fa327b2cdc1b48ac5b37dd05ee92ae4a8ea2e9a5f76477c24afd5b20e6d1851061afca43952f8d75949

data/.travis.yml

@@ -3,5 +3,9 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.6.3
+  - 2.7.1
+  - 2.6.6
+  - 2.5.8
+  - 2.4.10
+  - jruby-head
 before_install: gem install bundler -v 2.0.2

data/CHANGELOG.md

@@ -1,5 +1,20 @@
+## [0.1.07] - 2020-05-23
+- Implementation of `disj2` (two arguments disjunction - or -)
+
+### New
+- Class `Disj2` as subclass of `GoalRelation` that implements the disjunction of two subgoals
+
+### CHANGED
+- Class `Disj2`: common code with `Conj2` class factored out to superclass `GoalRelation`
+- File `cons_cell.rb`: prevent multiple inclusions via different requires
+- Method `Vocabulary#ancestor_walker` now returns an `Enumerator` instead of a `Fiber`.
+
+### FIXED
+- Method `RunStarExpression#run` clear associations and rankings for second and consecutive solmutions
+
+
 ## [0.1.06] - 2020-05-20
-- Implementation of `conj2` (two arguments conjunction)
+- Implementation of `conj2` (two arguments conjunction - and -)
 
 ### New
 - Class `CompositeGoal`

data/README.md

@@ -15,9 +15,9 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] run\*  
 - [X] fresh 
 - [X] conj2  
+- [X] disj2  
 
 ### TODO
-- [ ] disj2  
 - [ ] defrel 
 - [ ] conde  
 - [ ] Occurs check

data/lib/mini_kraken/core/conj2.rb

@@ -68,19 +68,6 @@ module MiniKraken
 
         Fiber.yield nil
       end
-
-      private
-
-      def validated_args(actuals)
-        actuals.each do |arg|
-          unless arg.kind_of?(Goal)
-            prefix = 'conj2 expects goal as argument, found a '
-            raise StandardError, prefix + "'#{arg.class}'"
-          end
-        end
-
-        actuals
-      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/cons_cell.rb

@@ -2,47 +2,53 @@
 
 require_relative 'composite_term'
 
-module MiniKraken
-  module Core
-    class ConsCell < CompositeTerm
-      attr_reader :car
-      attr_reader :cdr
-
-      def initialize(obj1, obj2 = nil)
-        @car = obj1
-        @cdr = obj2
-      end
-
-      def children
-        [car, cdr]
-      end
-
-      # Return true if it is an empty list, otherwise false.
-      # A list is empty, when both car and cdr fields are nil.
-      def null?
-        car.nil? && cdr.nil?
-      end
-
-      def ==(other)
-        return false unless other.respond_to?(:car)
-
-        (car == other.car) && (cdr == other.cdr)
-      end
-
-      def eql?(other)
-        (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
-      end
-
-      def quote(anEnv)
-        return self if null?
-
-        new_car = car.nil? ? nil : car.quote(anEnv)
-        new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)
-        ConsCell.new(new_car, new_cdr)
-      end
-    end # class
-
-    # Constant representing the null (empty) list.
-    NullList = ConsCell.new(nil, nil).freeze
+unless MiniKraken::Core.constants(false).include? :ConsCell
+  module MiniKraken
+    module Core
+      class ConsCell < CompositeTerm
+        attr_reader :car
+        attr_reader :cdr
+
+        def initialize(obj1, obj2 = nil)
+          @car = obj1
+          @cdr = obj2
+        end
+
+        def children
+          [car, cdr]
+        end
+
+        # Return true if it is an empty list, otherwise false.
+        # A list is empty, when both car and cdr fields are nil.
+        def null?
+          car.nil? && cdr.nil?
+        end
+
+        def ==(other)
+          return false unless other.respond_to?(:car)
+
+          (car == other.car) && (cdr == other.cdr)
+        end
+
+        def eql?(other)
+          (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
+        end
+
+        def quote(anEnv)
+          return self if null?
+
+          new_car = car.nil? ? nil : car.quote(anEnv)
+          new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)
+          ConsCell.new(new_car, new_cdr)
+        end
+
+        def append(another)
+          @cdr = another
+        end
+      end # class
+
+      # Constant representing the null (empty) list.
+      NullList = ConsCell.new(nil, nil).freeze
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/disj2.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'duck_fiber'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+module MiniKraken
+  module Core
+    # The disjunction is a relation that accepts only goal(s) as its two
+    # arguments. It succeeds if at least one of its goal arguments succeeds.
+    class Disj2 < GoalRelation
+      include Singleton
+
+      def initialize
+        super('disj2', nil)
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param anEnv [Vocabulary] A vocabulary object
+      # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
+      def solver_for(actuals, anEnv)
+        g1, g2 = *validated_args(actuals)
+        Fiber.new { disjunction(g1, g2, anEnv) }
+      end
+
+      # Yields [Outcome, NilClass] result of the disjunction
+      # @param g1 [Goal] First goal argument
+      # @param g2 [Goal] Second goal argument
+      # @param voc [Vocabulary] A vocabulary object
+      def disjunction(g1, g2, voc)
+        # require 'debug'
+        outcome1 = nil
+        outcome2 = nil
+        if g1.relation.kind_of?(Fail) && g2.relation.kind_of?(Fail)
+          Fiber.yield Outcome.new(:"#u", voc)
+        else
+          f1 = g1.attain(voc)
+          loop do
+            outcome1 = f1.resume
+            break unless outcome1
+
+            outcome1.parent = voc unless outcome1.parent
+            if outcome1.successful?
+              Fiber.yield outcome1
+              outcome1.clear
+            end
+          end
+          f2 = g2.attain(voc)
+          loop do
+            outcome2 = f2.resume
+            break unless outcome2
+
+            outcome2.parent = voc unless outcome2.parent
+            if outcome2.successful?
+              Fiber.yield outcome2
+              outcome2.clear
+            end
+          end
+        end
+
+        Fiber.yield nil
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/environment.rb

@@ -47,7 +47,7 @@ module MiniKraken
         # Rollout associations from hierarchy
         walker = descendent.ancestor_walker
         begin
-          env = walker.resume
+          env = walker.next
           break if env.nil?
 
           env.do_propagate(descendent) if env.kind_of?(Environment)

data/lib/mini_kraken/core/goal_relation.rb

@@ -10,6 +10,19 @@ module MiniKraken
       def arity
         2
       end
+
+      protected
+
+      def validated_args(actuals)
+        actuals.each do |arg|
+          unless arg.kind_of?(Goal)
+            prefix = "#{name} expects goal as argument, found a "
+            raise StandardError, prefix + "'#{arg.class}'"
+          end
+        end
+
+        actuals
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/outcome.rb

@@ -2,36 +2,38 @@
 
 require_relative 'vocabulary'
 
-module MiniKraken
-  module Core
-    class Outcome
-      include Vocabulary # Use mix-in module
-
-      # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
-      attr_reader :resultant
+unless MiniKraken::Core.constants(false).include? :Outcome
+  module MiniKraken
+    module Core
+      class Outcome
+        include Vocabulary # Use mix-in module
+
+        # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
+        attr_reader :resultant
+
+        def initialize(aResult, aParent = nil)
+          init_vocabulary(aParent)
+          @resultant = aResult
+        end
 
-      def initialize(aResult, aParent = nil)
-        init_vocabulary(aParent)
-        @resultant = aResult
-      end
+        def successful?
+          resultant == :"#s"
+        end
 
-      def successful?
-        resultant == :"#s"
-      end
+        def ==(other)
+          are_equal = false
 
-      def ==(other)
-        are_equal = false
+          if resultant == other.resultant && parent == other.parent &&
+             associations == other.associations
+            are_equal = true
+          end
 
-        if resultant == other.resultant && parent == other.parent &&
-           associations == other.associations
-          are_equal = true
+          are_equal
         end
+      end # class
 
-        are_equal
-      end
-    end # class
-
-    Failure = Outcome.new(:"#u")
-    BasicSuccess = Outcome.new(:"#s")
+      Failure = Outcome.new(:"#u")
+      BasicSuccess = Outcome.new(:"#s")
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/vocabulary.rb

@@ -23,26 +23,28 @@ module MiniKraken
         @rankings = {} unless aParent
       end
 
-      # Return a Fiber object that can iterate over this vocabulary and
+      # Return a Enumerator object that can iterate over this vocabulary and
       # all its direct and indirect parent(s).
-      # @return [Fiber<Vocabulary, NilClass>]
+      # @return [Enumerator<Vocabulary, NilClass>]
       def ancestor_walker
-        Fiber.new do
+        unless @ancestors # Not yet in cache?...
+          @ancestors = []
           relative = self
           while relative
-            Fiber.yield relative
+            @ancestors << relative
             relative = relative.parent
           end
-
-          Fiber.yield nil # nil marks end of iteration...
+          @ancestors << nil # nil marks end of iteration...
         end
+
+        @ancestors.to_enum
       end
 
       def clear_rankings
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
 
           orphan = orphan_temp
@@ -57,7 +59,7 @@ module MiniKraken
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
 
           orphan = orphan_temp
@@ -182,7 +184,7 @@ module MiniKraken
           walker = ancestor_walker
 
           loop do
-            voc = walker.resume
+            voc = walker.next
             break unless voc
 
             if voc.associations.include?(old_i_name)
@@ -277,7 +279,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           if voc
             next unless voc.respond_to?(:vars) && voc.vars.include?(aName)
 
@@ -299,7 +301,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           if voc
             next unless voc.respond_to?(:ivars) && voc.ivars.include?(i_name)
 
@@ -335,7 +337,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           break unless voc
           next unless voc.respond_to?(:ivars)
 
@@ -358,7 +360,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           break unless voc
           next unless voc.associations.include?(i_name)
 

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -21,20 +21,29 @@ module MiniKraken
 
       def run
         result = nil
+        next_result = nil
         solver = env.goal.attain(env)
         # require 'debug'
         loop do
+          env.clear
+          env.clear_rankings
           outcome = solver.resume
           break if outcome.nil?
 
-          env.clear
           if result # ... more than one result...
+            if outcome.successful?
+              next_result.append(Core::ConsCell.new(var.quote(outcome)))
+            else
+              next_result.append(Core::NullList)
+            end
+            next_result = next_result.cdr
           elsif outcome.successful?
             env.propagate(outcome)
             result = Core::ConsCell.new(var.quote(outcome))
+            next_result = result
           else
             result = Core::NullList
-            env.associations.freeze
+            next_result = result
           end
         end
 

data/lib/mini_kraken/version.rb

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

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,144 @@
+# 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
+
+        it 'should yield success and set associations' do
+          # # Weird: this example succeeds if run alone...
+          # # 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/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

data/spec/glue/run_star_expression_spec.rb

@@ -3,6 +3,7 @@
 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'
@@ -40,6 +41,8 @@ module MiniKraken
       context 'Provided services:' do
         let(:corn) { k_symbol(:corn) }
         let(:meal) { k_symbol(:meal) }
+        let(:oil) { k_symbol(:oil) }
+        let(:olive) { k_symbol(:olive) }
         let(:ref_q) { Core::VariableRef.new('q') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
@@ -56,7 +59,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
@@ -74,7 +76,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
@@ -84,9 +85,6 @@ 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
@@ -96,7 +94,6 @@ module MiniKraken
           # (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))
@@ -109,7 +106,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
 
@@ -122,7 +118,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
 
@@ -134,8 +129,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
@@ -150,8 +143,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
 
@@ -163,8 +154,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
 
@@ -195,7 +184,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
 
@@ -209,7 +197,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
 
@@ -222,7 +209,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
 
@@ -236,8 +222,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
 
@@ -251,11 +235,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
 
@@ -268,9 +247,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
 
@@ -285,12 +261,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')
@@ -314,13 +284,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
 
@@ -334,13 +298,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
 
@@ -354,11 +312,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, ,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
 
@@ -369,7 +323,6 @@ module MiniKraken
           # Reasoned S2, frame 1:50
           # (run* q (conj2 succeed succeed)) ;; => (_0)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_truthy
           expect(result.car).to eq(any_value(0))
         end
 
@@ -382,7 +335,6 @@ module MiniKraken
           # # Reasoned S2, frame 1:51
           # # (run* q (conj2 succeed (== 'corn q)) ;; => ('corn)
           # result = instance.run
-          # expect(ref_q.fresh?(instance.env)).to be_falsy
           # expect(result.car).to eq(corn)
         # end
 
@@ -394,7 +346,6 @@ module MiniKraken
           # Reasoned S2, frame 1:52
           # (run* q (conj2 fail (== 'corn q)) ;; => ()
           expect(instance.run).to be_null
-          expect(ref_q.fresh?(instance.env)).to be_truthy
         end
 
         it 'should support conjunction of two contradictory goals' do
@@ -406,7 +357,6 @@ module MiniKraken
           # Reasoned S2, frame 1:53
           # (run* q (conj2 (== 'corn q)(== 'meal q)) ;; => ()
           expect(instance.run).to be_null
-          expect(ref_q.fresh?(instance.env)).to be_truthy
         end
 
         it 'should succeed the conjunction of two identical goals' do
@@ -418,9 +368,118 @@ module MiniKraken
           # Reasoned S2, frame 1:54
           # (run* q (conj2 (== 'corn q)(== 'corn q)) ;; => ('corn)
           result = instance.run
-          expect(ref_q.fresh?(instance.env)).to be_falsy
           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 (equals '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 (equals '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 (equals 'olive q) (equals '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
       end # context
     end # describe
   end # module

data/spec/support/factory_methods.rb

@@ -34,7 +34,7 @@ module MiniKraken
       Core::Goal.new(Core::Equals.instance, [arg1, arg2])
     end
 
-    # Factory method for constructing a goal using the Equals relation.
+    # Factory method for constructing a goal using the conjunction relation.
     # @param g1 [Core::Goal]
     # @param g2 [Core::Goal]
     # @return [Core::Goal]
@@ -42,6 +42,14 @@ module MiniKraken
       Core::Goal.new(Core::Conj2.instance, [g1, g2])
     end
 
+    # Factory method for constructing a goal using the disjunction relation.
+    # @param g1 [Core::Goal]
+    # @param g2 [Core::Goal]
+    # @return [Core::Goal]
+    def disj2_goal(g1, g2)
+      Core::Goal.new(Core::Disj2.instance, [g1, g2])
+    end
+
     # Factory method for constructing a KSymbol instance
     # @param aSymbol [Symbol]
     # @return [Core::KSymbol]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.06
+  version: 0.1.07
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-21 00:00:00.000000000 Z
+date: 2020-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,7 @@ files:
 - lib/mini_kraken/core/conj2.rb
 - lib/mini_kraken/core/cons_cell.rb
 - lib/mini_kraken/core/designation.rb
+- lib/mini_kraken/core/disj2.rb
 - lib/mini_kraken/core/duck_fiber.rb
 - lib/mini_kraken/core/environment.rb
 - lib/mini_kraken/core/equals.rb
@@ -104,6 +105,7 @@ files:
 - spec/core/association_walker_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
 - spec/core/environment_spec.rb
 - spec/core/equals_spec.rb
@@ -148,6 +150,7 @@ test_files:
 - spec/core/association_walker_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
 - spec/core/environment_spec.rb
 - spec/core/equals_spec.rb