mini_kraken 0.1.09 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10a0607b5621effb10eab26d64ff7f52228f93e9c7907b91488613c1d72469aa
-  data.tar.gz: 9b43c9b0d729f2c7944be72f6599decae48d977ea0be5257a365111508473ef9
+  metadata.gz: ec7b984a9f0c857f74c8a8989c5da2072398775573b7ca6679d99f96ef13eac1
+  data.tar.gz: cdebdebae82c424b9ae701f959765f0905322798a371e2aec42ed9a229e35a4f
 SHA512:
-  metadata.gz: 32c14d82b93ddf21d2b369745b1e556faf1736b53fd7f1782809370777e059c498e1d8347806dc2135aab3bedf429c8d2b93b5f9be4b9b361f86926edb1be20f
-  data.tar.gz: 9b82b3afd53af4da54042f8a8852367250bc8225c1229b31486b4e8223ca533d55f3dcc6250c4de4c03d0d84b77a5e5cf737a6c151f734d7a08334ac442fa330
+  metadata.gz: 2ce3553527adeebef7adc69ec5a861fe65f9f451e54a81e23f00769923ced6b6a6011846ae3e9a673c8b9094a7dcce6ea6f8d263d55c8f543ef0de309e34c11c
+  data.tar.gz: 90b45061cde1119ad648359063682f411f9e5705a294340976bd027561b1d94da7afbfc9d0d27dce67942e1407d4d4ea40df85cf3fe67c9fca998d22052b6187

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.1.10] - 2020-06-10
+- Supports frames from "The Reasoned Scheme" book up to frame [1:81]
+
+### New
+- Factory methods `Outcome#failure`, `Outcome#success`
+- Method `Vocabulary#inspect`
+- File `outcome_spec.rb`
+
+### FIXED
+- `Conj2#conjunction` vocabulary wasn't cleared when outcome2 was nil.
+
 ## [0.1.09] - 2020-06-06
 - Supports frames from "The Reasoned Scheme" book up to frame [1:76]
 

data/lib/mini_kraken/core/conj2.rb

@@ -31,6 +31,7 @@ unless MiniKraken::Core.constants(false).include? :Conj2
         # @param g2 [Goal] Second goal argument
         # @param voc [Vocabulary] A vocabulary object
         def conjunction(g1, g2, voc)
+          # require 'debug'
           if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
             Fiber.yield Outcome.new(:"#u", voc)
           else
@@ -62,7 +63,9 @@ unless MiniKraken::Core.constants(false).include? :Conj2
               else
                 Fiber.yield outcome1
               end
-              voc.clear if outcome1&.successful? && outcome2&.successful?
+              if outcome1.successful? && (outcome2&.successful? || outcome2.nil?)
+                voc.clear
+              end
             end
           end
 

data/lib/mini_kraken/core/equals.rb

@@ -31,9 +31,9 @@ unless MiniKraken::Core.constants(false).include? :Equals
           arg2_nil = arg2.nil?
           if arg1_nil || arg2_nil
             if arg1_nil && arg2_nil
-              result = Outcome.new(:"#s", anEnv)
+              result = Outcome.success(anEnv)
             else
-              result = Failure
+              result = Outcome.failure(anEnv)
             end
             return result
           end
@@ -46,6 +46,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
 
         private
 
+
         # table: Unification
         # | arg1               | arg2               | Criterion                                 || Unification              |
         # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
@@ -70,12 +71,12 @@ unless MiniKraken::Core.constants(false).include? :Equals
         # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
         def do_unification(arg1, arg2, anEnv)
           # require 'debug'
-          return Outcome.new(:"#s", anEnv) if arg1.equal?(arg2)
+          return Outcome.success(anEnv) if arg1.equal?(arg2)
 
-          result = Outcome.new(:"#u", anEnv) # default case
+          result = Outcome.failure(anEnv) # default case
 
           if arg1.kind_of?(AtomicTerm)
-            result = BasicSuccess if arg1.eql?(arg2)
+            result = Outcome.success(anEnv) 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)
@@ -84,14 +85,14 @@ unless MiniKraken::Core.constants(false).include? :Equals
             arg1_freshness = arg1.freshness(anEnv)
             if arg2.kind_of?(AtomicTerm)
               if arg1_freshness.degree == :fresh
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 arg1.associate(arg2, result)
               else
-                result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+                result = Outcome.success(anEnv) if arg1.value(anEnv).eql?(arg2)
               end
             elsif arg2.kind_of?(CompositeTerm)
               if arg1_freshness.degree == :fresh
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 arg1.associate(arg2, result)
               else
                 # Ground case...
@@ -103,11 +104,14 @@ unless MiniKraken::Core.constants(false).include? :Equals
               when [false, false] # TODO: confirm this...
                 result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
               when [true, true]
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 if arg1.var_name != arg2.var_name
                   arg1.associate(arg2, result)
                   arg2.associate(arg1, result)
                 end
+              when [true, false]
+                result = Outcome.success(anEnv)
+                arg1.associate(arg2, result)
               else
                 raise StandardError, "Unsupported freshness combination #{freshness}"
               end
@@ -123,7 +127,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
         # @return [Freshness]
         def unify_composite_terms(arg1, arg2, anEnv)
           # require 'debug'
-          result = Outcome.new(:"#u", anEnv)
+          result = Outcome.failure(anEnv)
           children1 = arg1.children
           children2 = arg2.children
 
@@ -136,7 +140,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
             end
             total_success = subresults.all?(&:successful?)
             if total_success
-              memo = Outcome.new(:"#s", anEnv)
+              memo = Outcome.success(anEnv)
               associations = subresults.reduce(memo) do |sub_total, outcome|
                 sub_total.merge(outcome)
                 sub_total

data/lib/mini_kraken/core/outcome.rb

@@ -16,6 +16,14 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           @resultant = aResult
         end
 
+        def self.failure(aParent = nil)
+          new(:"#u", aParent)
+        end
+
+        def self.success(aParent = nil)
+          new(:"#s", aParent)
+        end
+
         def successful?
           resultant == :"#s"
         end
@@ -30,6 +38,12 @@ unless MiniKraken::Core.constants(false).include? :Outcome
 
           are_equal
         end
+
+        protected
+
+        def introspect
+          ", @resultant=#{resultant}"
+        end
       end # class
 
       Failure = Outcome.new(:"#u")

data/lib/mini_kraken/core/vocabulary.rb

@@ -394,6 +394,18 @@ module MiniKraken
         name2var(aVarName) ? true : false
       end
 
+      def inspect
+        result = +"#<#{self.class.name}:#{object_id.to_s(16)} @parent="
+        if parent
+          result << "#<#{parent.class.name}:#{parent.object_id.to_s(16)}>"
+        else
+          result << nil
+        end
+        result << introspect
+        result << '>'
+        result
+      end
+
       protected
 
       def validated_parent(aParent)
@@ -420,6 +432,10 @@ module MiniKraken
           assc
         end
       end
+
+      def introspect
+        ''
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/fresh_env.rb

@@ -33,6 +33,12 @@ module MiniKraken
         goal.attain(self)
       end
 
+      protected
+
+      def introspect
+        +", @vars=[#{vars.keys.join(', ')}]"
+      end
+
       private
 
       def valid_goal(aGoal)

data/lib/mini_kraken/version.rb

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

data/spec/core/equals_spec.rb

@@ -275,9 +275,9 @@ module MiniKraken
 
         it 'should unify composite terms with variables' do
           # Reasoned S2, frame 1:36
-          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
-          expr1 = cons(cons(ref_q), ref_x)
-          expr2 = cons(cons(ref_x), pod)
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(cons(ref_q)), ref_x)
+          expr2 = cons(cons(cons(ref_x)), pod)
 
           result = solve_for(expr1, expr2)
           # require 'debug'

data/spec/core/outcome_spec.rb

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

data/spec/core/vocabulary_spec.rb

@@ -207,6 +207,12 @@ module MiniKraken
           expect(subject.get_rank('z')).to eq(0)
           expect(subject.get_rank('a')).to eq(1)
         end
+
+        it 'should provide a String representation of itself' do
+          expectation = +"#<#{subject.class}:#{subject.object_id.to_s(16)} @parent="
+          expectation << "#<#{subject.parent.class}:#{subject.parent.object_id.to_s(16)}>>"
+          expect(subject.inspect).to eq(expectation)
+        end
       end # context
     end # describe
   end # module

data/spec/glue/run_star_expression_spec.rb

@@ -65,6 +65,7 @@ module MiniKraken
         let(:ref_s) { Core::VariableRef.new('s') }
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
+        let(:ref_z) { Core::VariableRef.new('z') }
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -662,6 +663,124 @@ module MiniKraken
           expect(result.cdr.car.car).to eq(red)
           expect(result.cdr.car.cdr.car).to eq(bean)
         end
+
+        it 'should allow nesting a disjunction inside of conjunction' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(red, ref_x)
+          subgoal1 = disj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(ref_x, ref_y)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # (display (run* (x y)
+          #   (conj2
+          #     (disj2
+          #       (== 'split x)
+          #       (== 'red x))
+          #     (== x y)))) ;; => ((split split) (red red))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(split)
+          expect(result.cdr.car.cdr.car).to eq(red)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          subgoal3 = disj2_goal(subgoal1, subgoal2)
+          subgoal4 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          goal = conj2_goal(subgoal3, subgoal4)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:77
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (disj2
+          #         (conj2 (== 'split x) (== 'pea y))
+          #         (conj2 (== 'red x) (== 'bean y)))
+          #       (== '(,x ,y soup) r)))) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow fresh with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(cons(ref_x, cons(ref_y, cons(soup))), ref_r)
+          fresh_env = FreshEnv.new(%w[x y], [goal1, goal2])
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:78
+          # (run* r
+          #   (fresh (x y)
+          #     (disj2
+          #       (conj2 (== 'split x) (== 'pea y))
+          #       (conj2 (== 'red x) (== 'bean y)))
+          #     (== '(,x ,y soup) r))) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow run* with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal1 = disj2_goal(subgoal1, subgoal2)
+          goal2 = equals_goal(soup, ref_z)
+          instance = RunStarExpression.new(%w[x y z], [goal1, goal2])
+
+          # Reasoned S2, frame 1:80
+          # (run* (x y z)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))
+          #   (== 'soup z)) ;; => ((split pea soup) (red bean soup))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.car).to eq(soup)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+          expect(result.cdr.car.cdr.cdr.car).to eq(soup)
+        end
+
+        it 'should allow simplified expressions with multiple goals' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          instance = RunStarExpression.new(%w[x y], [expr1, expr2])
+
+          # Reasoned S2, frame 1:81
+          # (run* (x y)
+          #   (== 'split x)
+          #   (== 'pea y)) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.09
+  version: 0.1.10
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-06 00:00:00.000000000 Z
+date: 2020-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,6 +112,7 @@ files:
 - spec/core/fail_spec.rb
 - spec/core/goal_spec.rb
 - spec/core/k_symbol_spec.rb
+- spec/core/outcome_spec.rb
 - spec/core/succeed_spec.rb
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb
@@ -157,6 +158,7 @@ test_files:
 - spec/core/fail_spec.rb
 - spec/core/goal_spec.rb
 - spec/core/k_symbol_spec.rb
+- spec/core/outcome_spec.rb
 - spec/core/succeed_spec.rb
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb