mini_kraken 0.1.08 → 0.1.09

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32a6f92773457338343dffa1343906883ffdbafbf7f8fd9ace170062cc34d345
-  data.tar.gz: cb7d3e6b88f8bea952bea7f214eaf73af97857de6958f65592a15b7ee7ef2510
+  metadata.gz: 10a0607b5621effb10eab26d64ff7f52228f93e9c7907b91488613c1d72469aa
+  data.tar.gz: 9b43c9b0d729f2c7944be72f6599decae48d977ea0be5257a365111508473ef9
 SHA512:
-  metadata.gz: db730590bcc99203f8983fe19b5e0d0b90c77819c07875bc34c100bc843c9b3e5e3e148833149d3264847a190cc9ce5bcf1fa31f74723b8c8e8006a56948d738
-  data.tar.gz: 4cb5cb8f327e7cb81028621ad67e36afecee8bc90beac1cd6449573b85092191d39d55dfbe2de9f52a5868a66bf4c8288a3223b41815528fb651eead36d3f4fa
+  metadata.gz: 32c14d82b93ddf21d2b369745b1e556faf1736b53fd7f1782809370777e059c498e1d8347806dc2135aab3bedf429c8d2b93b5f9be4b9b361f86926edb1be20f
+  data.tar.gz: 9b82b3afd53af4da54042f8a8852367250bc8225c1229b31486b4e8223ca533d55f3dcc6250c4de4c03d0d84b77a5e5cf737a6c151f734d7a08334ac442fa330

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.1.09] - 2020-06-06
+- Supports frames from "The Reasoned Scheme" book up to frame [1:76]
+
+### CHANGED
+- Method `FreshEnv#initialize`accepts an array of goals as second argument. This array is transformed into a conjunction of goals.
+- Method `RunStarExpression#initialize` accepts multiple multiple variable names and goals.
+- Method `RunStarExpression#run` can handle solutions with multiple variables.
+
 ## [0.1.08] - 2020-05-30
 - Fix of nasty bug (object aliasing) that caused flaky failures in specs.
 

data/lib/mini_kraken/core/conj2.rb

@@ -31,12 +31,11 @@ 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'
-          outcome1 = nil
-          outcome2 = nil
           if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
             Fiber.yield Outcome.new(:"#u", voc)
           else
+            outcome1 = nil
+            outcome2 = nil
             f1 = g1.attain(voc)
             loop do
               outcome1 = f1.resume

data/lib/mini_kraken/core/equals.rb

@@ -148,8 +148,8 @@ unless MiniKraken::Core.constants(false).include? :Equals
           result
         end
       end # class
-      
+
       Equals.instance.freeze
     end # module
   end # module
-end # unless
+end # unless

data/lib/mini_kraken/glue/fresh_env.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../core/environment'
+require_relative '../core/conj2'
 require_relative '../core/variable'
 
 module MiniKraken
   module Glue
+    # A combination of an Environment (= a scope for one or more variables)
+    # and a goal. It quacks like a Goal object: when receiving the attain message,
+    # it attempt to achieve its given goal.
     # (fresh (x) (== 'pea q))
     # Introduces the new variable 'x'
     # Takes a list of names and a goal-like object
@@ -13,11 +17,11 @@ module MiniKraken
       # @return [Goal]
       attr_reader :goal
 
-      # @param theNames [Array<String>]
-      # @param aGoal [Goal]
+      # @param theNames [Array<String>] The variable names
+      # @param aGoal [Goal, Array<Goal>] The goal to achieve or the conjunction of them.
       def initialize(theNames, aGoal)
         super()
-        @goal = aGoal
+        @goal = valid_goal(aGoal)
         theNames.each { |nm| add_var(Core::Variable.new(nm)) }
       end
 
@@ -28,6 +32,38 @@ module MiniKraken
         self.parent = aParent
         goal.attain(self)
       end
+
+      private
+
+      def valid_goal(aGoal)
+        result = nil
+
+        case aGoal
+          when Core::Goal
+            result = aGoal
+          when FreshEnv
+            result = aGoal
+          when Array # an Array of Goal?..
+            goal_array = aGoal
+            loop do
+              conjunctions = []
+              goal_array.each_slice(2) do |uno_duo|
+                if uno_duo.size == 2
+                  conjunctions << Core::Goal.new(Core::Conj2.instance, uno_duo)
+                else
+                  conjunctions << uno_duo[0]
+                end
+              end
+              if conjunctions.size == 1
+                result = conjunctions[0]
+                break
+              end
+              goal_array = conjunctions
+            end
+        end
+
+        result
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -9,19 +9,15 @@ module MiniKraken
     class RunStarExpression
       attr_reader :env
 
-      # @param var_name [String]
-      # @param goal [Core::Goal]
-      def initialize(var_name, goal)
-        @env = FreshEnv.new([var_name], goal)
-      end
-
-      def var
-        env.vars.values.first
+      # @param var_names [String, Array<String>] One variable name or an array of names
+      # @param goal [Core::Goal, Array<Core::Goal>] A single goal or an array of goals to conjunct
+      def initialize(var_names, goal)
+        vnames = var_names.kind_of?(String) ? [var_names] : var_names
+        @env = FreshEnv.new(vnames, goal)
       end
 
       def run
-        result = nil
-        next_result = nil
+        result = []
         solver = env.goal.attain(env)
         # require 'debug'
         loop do
@@ -30,24 +26,44 @@ module MiniKraken
           outcome = solver.resume
           break if outcome.nil?
 
-          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
-            next_result = result
-          end
+          env.propagate(outcome) if result.empty? && outcome.successful?
+          result << build_solution(outcome)
+        end
+
+        format_solutions(result)
+      end
+
+      private
+
+      # @return [Array] A vector of assignment for each variable
+      def build_solution(outcome)
+        sol = env.vars.values.map do |var|
+          outcome.successful? ? var.quote(outcome) : nil
+        end
+
+        sol
+      end
+
+      # Transform the solutions into sequence of conscells.
+      # @param solutions [Array<Array>] An array of solution.
+      # A solution is in itself an array of bindings (one per variable)
+      def format_solutions(solutions)
+        solutions_as_list = solutions.map { |sol| arr2list(sol, true) }
+        arr2list(solutions_as_list, false)
+      end
+
+      # Utility method. Transform an array into a ConsCell-based list.
+      # @param anArray [Array]
+      # @param simplify [Boolean]
+      def arr2list(anArray, simplify)
+        return anArray[0] if anArray.size == 1 && simplify
+
+        new_tail = nil
+        anArray.reverse_each do |elem|
+          new_tail = Core::ConsCell.new(elem, new_tail)
         end
 
-        result
+        new_tail
       end
     end # class
   end # module

data/lib/mini_kraken/version.rb

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

data/spec/glue/fresh_env_spec.rb

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

data/spec/glue/run_star_expression_spec.rb

@@ -21,16 +21,26 @@ module MiniKraken
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
       let(:sample_goal) { equals_goal(pea, pod) }
+      let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+      let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
       subject { RunStarExpression.new('q', sample_goal) }
 
       context 'Initialization:' do
-        it 'should be initialized with a name and a goal' do
+        it 'could be initialized with a name and a goal' do
           expect { RunStarExpression.new('q', sample_goal) }.not_to raise_error
         end
 
+        it 'could be initialized with multiple names and a goal' do
+          expect { RunStarExpression.new(%w[r x y], sample_goal) }.not_to raise_error
+        end
+
+        it 'could be initialized with multiple names and goals' do
+          expect { RunStarExpression.new(%w[r x y], [succeeds, succeeds]) }.not_to raise_error
+        end
+
         it 'should know its variables' do
           expect(subject.env.vars['q']).not_to be_nil
-          expect(subject.var.name).to eq('q')
+          expect(subject.env.vars.values[0].name).to eq('q')
         end
 
         it 'should know its goal' do
@@ -39,19 +49,22 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:bean) { k_symbol(:bean) }
         let(:corn) { k_symbol(:corn) }
         let(:meal) { k_symbol(:meal) }
         let(:oil) { k_symbol(:oil) }
         let(:olive) { k_symbol(:olive) }
+        let(:red) { k_symbol(:red) }
+        let(:soup) { k_symbol(:soup) }
+        let(:split) { k_symbol(:split) }
         let(:virgin) { k_symbol(:virgin) }
         let(:ref_q) { Core::VariableRef.new('q') }
+        let(:ref_r) { Core::VariableRef.new('r') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
         let(:ref_s) { Core::VariableRef.new('s') }
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
-        let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
-        let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -386,7 +399,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:56
-          # (run* q (disj2 (equals 'olive q) fail)) ;; => ('olive)
+          # (run* q (disj2 (== 'olive q) fail)) ;; => ('olive)
           result = instance.run
           expect(result.car).to eq(olive)
         end
@@ -397,7 +410,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:57
-          # (run* q (disj2 fail (equals 'oil q)) ;; => (oil)
+          # (run* q (disj2 fail (== 'oil q))) ;; => (oil)
           result = instance.run
           expect(result.car).to eq(oil)
         end
@@ -409,7 +422,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:58
-          # (run* q (disj2 (equals 'olive q) (equals 'oil q)) ;; => (olive oil)
+          # (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)
@@ -504,6 +517,151 @@ module MiniKraken
           expect(result.cdr.car).to eq(any_value(0))
           expect(result.cdr.cdr.car).to eq(oil)
         end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (I)' do
+          subgoal1 = equals_goal(split, ref_x)
+          expr1 = equals_goal(pea, ref_y)
+          expr2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          subgoal2 = conj2_goal(expr1, expr2)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:67
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #           (== 'split x)
+          #           (conj2
+          #             (== 'pea y)
+          #             (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept nesting fresh, disj2 and conj2 expressions (II)' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env_y = FreshEnv.new(['y'], goal)
+          fresh_env_x = FreshEnv.new(['x'], fresh_env_y)
+          instance = RunStarExpression.new('r', fresh_env_x)
+
+          # Reasoned S2, frame 1:68
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #         (conj2
+          #           (== 'split x)
+          #           (== 'pea y)
+          #         (== '(,x ,y) r)))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept fresh with multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          fresh_env = FreshEnv.new(%w[x y], goal)
+          instance = RunStarExpression.new('r', fresh_env)
+
+          # Reasoned S2, frame 1:70
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (conj2
+          #         (== 'split x)
+          #         (== 'pea y)
+          #       (== '(,x ,y) r))))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should accept multiple variables' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          subgoal2 = equals_goal(cons(ref_x, cons(ref_y)), ref_r)
+          goal = conj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[r x y], goal)
+
+          # Reasoned S2, frame 1:72
+          # (run* (r x y)
+          #   (conj2
+          #     (conj2
+          #       (== 'split x)
+          #       (== 'pea y))
+          #     (== '(,x ,y) r))) ;; => (((split pea) split pea))
+          #             o
+          #            / \
+          #            o  nil
+          #          /  \
+          #         /    \
+          #        /      \
+          #       /        \
+          #      /          \
+          #      o           o
+          #     / \         / \
+          # split  o   split   o
+          #       / \         / \
+          #    pea  nil     pea  nil
+          result = instance.run
+          expect(result.car.car.car).to eq(split)
+          expect(result.car.car.cdr.car).to eq(pea)
+          expect(result.car.car.cdr.cdr).to be_nil
+          expect(result.car.cdr.car).to eq(split)
+          expect(result.car.cdr.cdr.car).to eq(pea)
+          expect(result.car.cdr.cdr.cdr).to be_nil
+        end
+
+        it 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          goal = conj2_goal(expr1, expr2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:75
+          # (run* (x y)
+          #   (conj2
+          #     (== 'split x)
+          #     (== 'pea y))) ;; => ((split pea))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+        end
+
+        it 'should allow simplication of expressions' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          subgoal1 = conj2_goal(expr1, expr2)
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:76
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+        end
       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.08
+  version: 0.1.09
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-30 00:00:00.000000000 Z
+date: 2020-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler