mini_kraken 0.1.07 → 0.1.08

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15536181da18de42e83ec948742a97c63338f2065841849de64d3537eeeb9bc1
-  data.tar.gz: bb25b2bfcab17da55d5dfa6845e699fa2a48e89e19956f3c63f2e755577d4ae7
+  metadata.gz: 32a6f92773457338343dffa1343906883ffdbafbf7f8fd9ace170062cc34d345
+  data.tar.gz: cb7d3e6b88f8bea952bea7f214eaf73af97857de6958f65592a15b7ee7ef2510
 SHA512:
-  metadata.gz: a964e66c182fa2d834007c2003fa7b16b0e91d8cc80f8525de9c95df89d81523a9a2e93c7e57c2a96605ce6af5244324d5a7bf80c877d46a8a647726a3ac1e49
-  data.tar.gz: 6608b250a6949ce6d7f3fd4c548c7525595fc20c808b5fa327b2cdc1b48ac5b37dd05ee92ae4a8ea2e9a5f76477c24afd5b20e6d1851061afca43952f8d75949
+  metadata.gz: db730590bcc99203f8983fe19b5e0d0b90c77819c07875bc34c100bc843c9b3e5e3e148833149d3264847a190cc9ce5bcf1fa31f74723b8c8e8006a56948d738
+  data.tar.gz: 4cb5cb8f327e7cb81028621ad67e36afecee8bc90beac1cd6449573b85092191d39d55dfbe2de9f52a5868a66bf4c8288a3223b41815528fb651eead36d3f4fa

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.1.08] - 2020-05-30
+- Fix of nasty bug (object aliasing) that caused flaky failures in specs.
+
+### FIXED
+- `DuckFiber#resume` each call returns a distinct `Outcome` instance when successful.
+
 ## [0.1.07] - 2020-05-23
 - Implementation of `disj2` (two arguments disjunction - or -)
 

data/lib/mini_kraken/core/conj2.rb

@@ -6,68 +6,72 @@ require_relative 'goal'
 require_relative 'goal_relation'
 require_relative 'outcome'
 
-module MiniKraken
-  module Core
-    # The conjunction is a relation that accepts only goal(s) as its two
-    # arguments. It succeeds if and only both its goal arguments succeeds.
-    class Conj2 < GoalRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Conj2
+  module MiniKraken
+    module Core
+      # The conjunction is a relation that accepts only goal(s) as its two
+      # arguments. It succeeds if and only both its goal arguments succeeds.
+      class Conj2 < GoalRelation
+        include Singleton
 
-      def initialize
-        super('conj2', nil)
-      end
+        def initialize
+          super('conj2', 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 { conjunction(g1, g2, anEnv) }
-      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 { conjunction(g1, g2, anEnv) }
+        end
 
-      # Yields [Outcome, NilClass] result of the conjunction
-      # @param g1 [Goal] First goal argument
-      # @param g2 [Goal] Second goal argument
-      # @param voc [Vocabulary] A vocabulary object
-      def conjunction(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
+        # Yields [Outcome, NilClass] result of the conjunction
+        # @param g1 [Goal] First goal argument
+        # @param g2 [Goal] Second goal argument
+        # @param voc [Vocabulary] A vocabulary object
+        def conjunction(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?
-              f2 = g2.attain(outcome1)
-              loop do
-                outcome2 = f2.resume
-                break unless outcome2
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                f2 = g2.attain(outcome1)
+                loop do
+                  outcome2 = f2.resume
+                  break unless outcome2
 
-                outcome2.parent = voc unless outcome2.parent
-                if outcome2.successful?
-                  res = Outcome.new(:"#s", voc)
-                  res.merge(outcome1)
-                  res.merge(outcome2)
-                  Fiber.yield res
-                else
-                  Fiber.yield outcome2
+                  outcome2.parent = voc unless outcome2.parent
+                  if outcome2.successful?
+                    res = Outcome.new(:"#s", voc)
+                    res.merge(outcome1)
+                    res.merge(outcome2)
+                    Fiber.yield res
+                  else
+                    Fiber.yield outcome2
+                  end
+                  outcome2.clear
                 end
-                outcome2.clear
+              else
+                Fiber.yield outcome1
               end
-            else
-              Fiber.yield outcome1
+              voc.clear if outcome1&.successful? && outcome2&.successful?
             end
-            voc.clear if outcome1&.successful? && outcome2&.successful?
           end
+
+          Fiber.yield nil
         end
+      end # class
 
-        Fiber.yield nil
-      end
-    end # class
+      Conj2.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/disj2.rb

@@ -6,62 +6,66 @@ 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
+unless MiniKraken::Core.constants(false).include? :Disj2
+  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
+        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
+        # @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
+        # 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
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                Fiber.yield outcome1
+                outcome1.clear
+              end
             end
-          end
-          f2 = g2.attain(voc)
-          loop do
-            outcome2 = f2.resume
-            break unless outcome2
+            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
+              outcome2.parent = voc unless outcome2.parent
+              if outcome2.successful?
+                Fiber.yield outcome2
+                outcome2.clear
+              end
             end
           end
+
+          Fiber.yield nil
         end
+      end # class
 
-        Fiber.yield nil
-      end
-    end # class
+      Disj2.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/duck_fiber.rb

@@ -36,7 +36,7 @@ module MiniKraken
           when :failure
             Failure
           when :success
-            BasicSuccess
+            Outcome.new(:"#s")
           else
             raise StandardError, "Unknonw outcome kind #{outcomeKind}"
         end

data/lib/mini_kraken/core/equals.rb

@@ -7,145 +7,149 @@ require_relative 'duck_fiber'
 require_relative 'variable'
 require_relative 'variable_ref'
 
-module MiniKraken
-  module Core
-    # equals tries to unify two terms
-    class Equals < BinaryRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Equals
+  module MiniKraken
+    module Core
+      # equals tries to unify two terms
+      class Equals < BinaryRelation
+        include Singleton
 
-      def initialize
-        super('equals', '==')
-      end
+        def initialize
+          super('equals', '==')
+        end
 
-      # @param actuals [Array<Term>] A two-elements array
-      # @param anEnv [Vocabulary] A vocabulary object
-      # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
-      def solver_for(actuals, anEnv)
-        arg1, arg2 = *actuals
-        DuckFiber.new(:custom) { unification(arg1, arg2, anEnv) }
-      end
+        # @param actuals [Array<Term>] A two-elements array
+        # @param anEnv [Vocabulary] A vocabulary object
+        # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
+        def solver_for(actuals, anEnv)
+          arg1, arg2 = *actuals
+          DuckFiber.new(:custom) { unification(arg1, arg2, anEnv) }
+        end
 
-      def unification(arg1, arg2, anEnv)
-        arg1_nil = arg1.nil?
-        arg2_nil = arg2.nil?
-        if arg1_nil || arg2_nil
-          if arg1_nil && arg2_nil
-            result = Outcome.new(:"#s", anEnv)
-          else
-            result = Failure
+        def unification(arg1, arg2, anEnv)
+          arg1_nil = arg1.nil?
+          arg2_nil = arg2.nil?
+          if arg1_nil || arg2_nil
+            if arg1_nil && arg2_nil
+              result = Outcome.new(:"#s", anEnv)
+            else
+              result = Failure
+            end
+            return result
           end
-          return result
-        end
-        new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-        result = do_unification(new_arg1, new_arg2, anEnv)
-        # anEnv.merge(result) if result.successful? && !result.association.empty?
+          new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
+          result = do_unification(new_arg1, new_arg2, anEnv)
+          # anEnv.merge(result) if result.successful? && !result.association.empty?
 
-        result
-      end
+          result
+        end
 
-      private
+        private
 
-      # table: Unification
-      # | arg1               | arg2               | Criterion                                 || Unification              |
-      # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
-      # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is false                    || { "u", [] }              |
-      # | isa? CompositeTerm | isa? Atomic        | dont_care                                 || { "u", [] }              |
-      # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.car, arg2.car) => "s"    || { "s", [bindings*] }     |
-      # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.cdr, arg2.cdr) => "u"    || { "u", [] )              |             |
-      # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
-      # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
-      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-      # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
-      # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
-      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-      # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
-      # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
-      # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
-      # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [false, false]||                          |
-      # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
-      def do_unification(arg1, arg2, anEnv)
-        # require 'debug'
-        return Outcome.new(:"#s", anEnv) if arg1.equal?(arg2)
+        # table: Unification
+        # | arg1               | arg2               | Criterion                                 || Unification              |
+        # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
+        # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is false                    || { "u", [] }              |
+        # | isa? CompositeTerm | isa? Atomic        | dont_care                                 || { "u", [] }              |
+        # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.car, arg2.car) => "s"    || { "s", [bindings*] }     |
+        # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.cdr, arg2.cdr) => "u"    || { "u", [] )              |             |
+        # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
+        # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
+        # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+        # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+        # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
+        # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
+        # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+        # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
+        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
+        # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
+        # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
+        # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [false, false]||                          |
+        # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
+        # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
+        def do_unification(arg1, arg2, anEnv)
+          # require 'debug'
+          return Outcome.new(:"#s", anEnv) if arg1.equal?(arg2)
 
-        result = Outcome.new(:"#u", anEnv) # default case
+          result = Outcome.new(:"#u", anEnv) # default case
 
-        if arg1.kind_of?(AtomicTerm)
-          result = BasicSuccess if arg1.eql?(arg2)
-        elsif arg1.kind_of?(CompositeTerm)
-          if arg2.kind_of?(CompositeTerm) # AtomicTerm is default case => fail
-            result = unify_composite_terms(arg1, arg2, anEnv)
-          end
-        elsif arg1.kind_of?(VariableRef)
-          arg1_freshness = arg1.freshness(anEnv)
-          if arg2.kind_of?(AtomicTerm)
-            if arg1_freshness.degree == :fresh
-              result = Outcome.new(:"#s", anEnv)
-              arg1.associate(arg2, result)
-            else
-              result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
-            end
-          elsif arg2.kind_of?(CompositeTerm)
-            if arg1_freshness.degree == :fresh
-              result = Outcome.new(:"#s", anEnv)
-              arg1.associate(arg2, result)
-            else
-              # Ground case...
-              result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
+          if arg1.kind_of?(AtomicTerm)
+            result = BasicSuccess if arg1.eql?(arg2)
+          elsif arg1.kind_of?(CompositeTerm)
+            if arg2.kind_of?(CompositeTerm) # AtomicTerm is default case => fail
+              result = unify_composite_terms(arg1, arg2, anEnv)
             end
-          elsif arg2.kind_of?(VariableRef)
-            freshness = [arg1.fresh?(anEnv), arg2.fresh?(anEnv)]
-            case freshness
-            when [false, false] # TODO: confirm this...
-              result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
-            when [true, true]
-              result = Outcome.new(:"#s", anEnv)
-              if arg1.var_name != arg2.var_name
+          elsif arg1.kind_of?(VariableRef)
+            arg1_freshness = arg1.freshness(anEnv)
+            if arg2.kind_of?(AtomicTerm)
+              if arg1_freshness.degree == :fresh
+                result = Outcome.new(:"#s", anEnv)
+                arg1.associate(arg2, result)
+              else
+                result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+              end
+            elsif arg2.kind_of?(CompositeTerm)
+              if arg1_freshness.degree == :fresh
+                result = Outcome.new(:"#s", anEnv)
                 arg1.associate(arg2, result)
-                arg2.associate(arg1, result)
+              else
+                # Ground case...
+                result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
+              end
+            elsif arg2.kind_of?(VariableRef)
+              freshness = [arg1.fresh?(anEnv), arg2.fresh?(anEnv)]
+              case freshness
+              when [false, false] # TODO: confirm this...
+                result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
+              when [true, true]
+                result = Outcome.new(:"#s", anEnv)
+                if arg1.var_name != arg2.var_name
+                  arg1.associate(arg2, result)
+                  arg2.associate(arg1, result)
+                end
+              else
+                raise StandardError, "Unsupported freshness combination #{freshness}"
               end
             else
-              raise StandardError, "Unsupported freshness combination #{freshness}"
+              arg_kinds = [arg1.class, arg2.class]
+              raise StandardError, "Unsupported combination #{arg_kinds}"
             end
-          else
-            arg_kinds = [arg1.class, arg2.class]
-            raise StandardError, "Unsupported combination #{arg_kinds}"
           end
-        end
 
-        result
-      end
+          result
+        end
 
-      # @return [Freshness]
-      def unify_composite_terms(arg1, arg2, anEnv)
-        # require 'debug'
-        result = Outcome.new(:"#u", anEnv)
-        children1 = arg1.children
-        children2 = arg2.children
+        # @return [Freshness]
+        def unify_composite_terms(arg1, arg2, anEnv)
+          # require 'debug'
+          result = Outcome.new(:"#u", anEnv)
+          children1 = arg1.children
+          children2 = arg2.children
 
-        if children1.size == children2.size
-          i = 0
-          subresults = children1.map do |child1|
-            child2 = children2[i]
-            i += 1
-            unification(child1, child2, anEnv)
-          end
-          total_success = subresults.all?(&:successful?)
-          if total_success
-            memo = Outcome.new(:"#s", anEnv)
-            associations = subresults.reduce(memo) do |sub_total, outcome|
-              sub_total.merge(outcome)
-              sub_total
+          if children1.size == children2.size
+            i = 0
+            subresults = children1.map do |child1|
+              child2 = children2[i]
+              i += 1
+              unification(child1, child2, anEnv)
+            end
+            total_success = subresults.all?(&:successful?)
+            if total_success
+              memo = Outcome.new(:"#s", anEnv)
+              associations = subresults.reduce(memo) do |sub_total, outcome|
+                sub_total.merge(outcome)
+                sub_total
+              end
+              result = memo
             end
-            result = memo
           end
-        end
 
-        result
-      end
-    end # class
+          result
+        end
+      end # class
+      
+      Equals.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/fail.rb

@@ -4,20 +4,24 @@ require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
-module MiniKraken
-  module Core
-    # A nullary relation that unconditionally always fails.
-    class Fail < NullaryRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Fail
+  module MiniKraken
+    module Core
+      # A nullary relation that unconditionally always fails.
+      class Fail < NullaryRelation
+        include Singleton
 
-      def initialize
-        super('fail', '#u')
-      end
+        def initialize
+          super('fail', '#u')
+        end
 
-      # @return [DuckFiber]
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:failure)
-      end
-    end # class
+        # @return [DuckFiber]
+        def solver_for(_actuals, _env)
+          DuckFiber.new(:failure)
+        end
+      end # class
+
+      Fail.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/succeed.rb

@@ -4,19 +4,23 @@ require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
-module MiniKraken
-  module Core
-    # A nullary relation that unconditionally always fails.
-    class Succeed < NullaryRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Succeed
+  module MiniKraken
+    module Core
+      # A nullary relation that unconditionally always fails.
+      class Succeed < NullaryRelation
+        include Singleton
 
-      def initialize
-        super('succeed', '#s')
-      end
+        def initialize
+          super('succeed', '#s')
+        end
 
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:success)
-      end
-    end # class
+        def solver_for(_actuals, _env)
+          DuckFiber.new(:success)
+        end
+      end # class
+
+      Succeed.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/vocabulary.rb

@@ -67,20 +67,22 @@ module MiniKraken
 
         raise StandardError unless orphan
 
+        rank = nil
         if orphan.rankings.include?(aName)
-          orphan.rankings[aName]
+          rank = orphan.rankings[aName]
         else
           other = alternate_names.find do |a_name|
-            orphan.rankings.include?(a_name)
+            rank = orphan.rankings.include?(a_name)
           end
           if other
-            get_rank(other)
+            rank = get_rank(other)
           else
             rank = orphan.rankings.keys.size
             orphan.rankings[aName] = rank
-            rank
           end
         end
+
+        rank
       end
 
       # Record an association between a variable with given user-defined name

data/lib/mini_kraken/version.rb

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

data/spec/core/conj2_spec.rb

@@ -66,15 +66,14 @@ module MiniKraken
         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)
+          # 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

data/spec/core/disj2_spec.rb

@@ -93,51 +93,6 @@ module MiniKraken
           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

data/spec/core/duck_fiber_spec.rb

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

data/spec/glue/run_star_expression_spec.rb

@@ -43,6 +43,7 @@ module MiniKraken
         let(:meal) { k_symbol(:meal) }
         let(:oil) { k_symbol(:oil) }
         let(:olive) { k_symbol(:olive) }
+        let(:virgin) { k_symbol(:virgin) }
         let(:ref_q) { Core::VariableRef.new('q') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
@@ -88,8 +89,7 @@ module MiniKraken
         end
 
         it 'should return a null list with the succeed goal' do
-          success = Core::Goal.new(Core::Succeed.instance, [])
-          instance = RunStarExpression.new('q', success)
+          instance = RunStarExpression.new('q', succeeds)
 
           # (display (run* q succeed)) ;; => (_0)
           # Reasoned S2, frame 1:16
@@ -327,16 +327,16 @@ module MiniKraken
         end
 
         # TODO: fix erratic RSpec failure
-        # it 'should support conjunction of one succeed and a successful goal' do
-          # subgoal = equals_goal(corn, ref_q)
-          # goal = conj2_goal(succeeds, subgoal)
-          # instance = RunStarExpression.new('q', goal)
+        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
+          # 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)
@@ -480,6 +480,30 @@ module MiniKraken
           expect(result.car).to eq(oil)
           expect(result.cdr.car).to eq(olive)
         end
+
+        it 'should accept nesting of disj2 and conj2 (IV)' do
+          oil_goal = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          disja = disj2_goal(succeeds, oil_goal)
+          olive_goal = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          disjb = disj2_goal(olive_goal, disja)
+          virgin_goal = Core::Goal.new(Core::Equals.instance, [virgin, ref_x])
+          conjunction = conj2_goal(virgin_goal, fails)
+          goal = disj2_goal(conjunction, disjb)
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:65
+          # (run* x (disj2
+          #           (conj2(== 'virgin x) fails)
+          #           (disj2
+          #             (== 'olive x)
+          #             (dis2
+          #               succeeds
+          #               (== 'oil x))))) ;; => (olive _0 oil)
+          result = instance.run
+          expect(result.car).to eq(olive)
+          expect(result.cdr.car).to eq(any_value(0))
+          expect(result.cdr.cdr.car).to eq(oil)
+        end
       end # context
     end # describe
   end # module

data/spec/mini_kraken_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../lib/mini_kraken/version/'
+
 RSpec.describe MiniKraken do
   it 'has a version number' do
     expect(MiniKraken::VERSION).not_to be nil

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
 require 'rspec' # Use the RSpec framework
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.07
+  version: 0.1.08
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-23 00:00:00.000000000 Z
+date: 2020-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler