mini_kraken 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 672521fbc6627e2767bfe4d6ce38dd66243736fee451e857ec7ef45d0f8905fe
-  data.tar.gz: 6835bb1d91bb6e867417faba0d6904734295f9a7bab612c6a78fcfbcdc41f84a
+  metadata.gz: ca30db7b93b0232f1df5321a1e00270395d908e3f7be1d24d3d5a9c19c833914
+  data.tar.gz: d64051987c0b09abf752b24604854515cabc9e99ff5ee436884c8522d6a75950
 SHA512:
-  metadata.gz: bd5b5b2d2493b4ec8f8293c5f786be1a7739d05bee5d4733d48edb16713d1df4097be5a6e85127c2c90cf395da877b57ef07a607167b8f5bb1732dbc2a367610
-  data.tar.gz: 6661aadbe8bd778283e91f31181651e32296150d282575697fee1f5c240ea46168c5107baf33d9b590d6a449ec89b2f41e69340b81cb9b9e3692954af155083b
+  metadata.gz: f4fc60b256907317972c51410e52aec821553d7575c24d59b9421f4ba8dbd0136937e70ffb2f9f21556ed205b8b8d54796af68c222df0704b45ebbcf562c3ab3
+  data.tar.gz: 5caf5af0c016e8dfb5de40244ad71a083eb035e0bcb911ae7bd90e67a784789458c12e46a3cc75a96ae483fd0317d86b6610a7c339cd423050b4d57e642d6cc9

data/CHANGELOG.md

@@ -1,5 +1,15 @@
-## [0.1.11] - 2020-06-10
-- Supports `defrel`, taht is, the capability to define new relations by combining other relations.
+## [0.1.12] - 2020-06-29
+- Supports `conde`, that is, a relation that can take an arbitrary number of arguments.
+- Cover all frames but one from Chapter One of "Reasoned Scheme" book.
+
+### New
+- Class `Conde` a relation that succeeds for each of its successful arguments.
+
+### CHANGED
+- Method `Goal#validated_actuals` add into account polyadic relations (= relations with arbitrary number of arguments)
+
+## [0.1.11] - 2020-06-25
+- Supports `defrel`, that is, the capability to define new relations by combining other relations.
 - Covers frames from "The Reasoned Scheme" book up to frame [1:87]
 
 ### New
@@ -13,7 +23,7 @@
 ### CHANGED
 - File `README.md` minor change: added more TODO's.
 
-## [0.1.10] - 2020-06-10
+## [0.1.10] - 2020-06-13
 - Supports frames from "The Reasoned Scheme" book up to frame [1:81]
 
 ### New

data/lib/mini_kraken/core/conde.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'conj2'
+require_relative 'duck_fiber'
+require_relative 'fail'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+unless MiniKraken::Core.constants(false).include? :Conde
+  module MiniKraken
+    module Core
+      # A polyadic relation (i.e. it can takes an arbitrary number of argumentt)
+      # that behaves as the disjunction of its arguments.
+      # It succeeds if at least one of its goal arguments succeeds.
+      class Conde < GoalRelation
+        include Singleton
+
+        def initialize
+          super('conde', nil)
+        end
+
+        # A relation is polyadic when it accepts an arbitrary number of arguments.
+        # @return [TrueClass]
+        def polyadic?
+          true
+        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)
+          args = *validated_args(actuals)
+          Fiber.new { cond(args, anEnv) }
+        end
+
+        # Yields [Outcome, NilClass] result of the disjunction
+        # @param goals [Array<Goal>] Array of goals
+        # @param voc [Vocabulary] A vocabulary object
+        def cond(goals, voc)
+          # require 'debug'
+          success = false
+
+          goals.each do |g|
+            fiber = nil
+
+            case g
+              when Core::Goal
+                fiber = g.attain(voc)
+              when Core::Environment
+                fiber = g.attain(voc)
+              when Array
+                conjunct = conjunction(g)
+                fiber = conjunct.attain(voc)
+              when Core::ConsCell
+                goal_array = to_goal_array(g)
+                conjunct = conjunction(goal_array)
+                fiber = conjunct.attain(voc)
+            end
+            loop do
+              outcome = fiber.resume
+              break unless outcome
+
+              outcome.parent = voc unless outcome.parent
+              if outcome.successful?
+                success = true
+                Fiber.yield outcome
+                outcome.clear
+              end
+            end
+          end
+
+          Fiber.yield Outcome.new(:"#u", voc) unless success
+          Fiber.yield nil
+        end
+
+        private
+
+        def validated_args(actuals)
+          result = []
+
+          actuals.each do |arg|
+            case arg
+              when Core::Goal
+                result << arg
+
+              when Core::Environment
+                result << arg
+
+              when Array
+                result << validated_args(arg)
+
+              else
+                prefix = "#{name} expects goal as argument, found a "
+                raise StandardError, prefix + "'#{arg.class}'"
+            end
+          end
+
+          result
+        end
+
+        def conjunction(goal_array)
+          result = nil
+
+          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
+
+          result
+        end
+
+        def to_goal_array(aCons)
+          array = []
+          curr_node = aCons
+          loop do
+            array << curr_node.car if curr_node.car.kind_of?(Core::Goal)
+            break unless curr_node.cdr
+            break unless curr_node.car.kind_of?(Core::Goal)
+
+            curr_node = curr_node.cdr
+          end
+
+          array
+        end
+      end # class
+
+      Conde.instance.freeze
+    end # module
+  end # module
+end # unless

data/lib/mini_kraken/core/goal.rb

@@ -30,14 +30,20 @@ module MiniKraken
       private
 
       def validated_actuals(args)
-        if args.size != relation.arity
+        if !relation.polyadic? && (args.size != relation.arity)
           err_msg = "Goal has #{args.size} arguments, expected #{relation.arity}"
           raise StandardError, err_msg
         end
 
         prefix = 'Invalid goal argument '
-        args.each do |actl|
-          raise StandardError, prefix + actl.to_s unless actl.kind_of?(GoalArg)
+        args.each do |actual|
+          if actual.kind_of?(GoalArg) || actual.kind_of?(Environment)
+            next
+          elsif actual.kind_of?(Array)
+            validated_actuals(actual)
+          else
+            raise StandardError, prefix + actual.to_s
+          end
         end
 
         args.dup

data/lib/mini_kraken/core/relation.rb

@@ -16,6 +16,13 @@ module MiniKraken
         @alt_name = alternateName
       end
 
+      # A relation is polyadic when it accepts an arbitrary number of arguments.
+      # Most built-in relation takes a fixed number of arguments (= arity).
+      # @return [Boolean]
+      def polyadic?
+        false
+      end
+
       # Number of arguments for the relation.
       # @return [Integer]
       def arity

data/lib/mini_kraken/version.rb

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

data/spec/core/conde_spec.rb

@@ -0,0 +1,147 @@
+# 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/conde'
+
+module MiniKraken
+  module Core
+    describe Conde do
+      subject { Conde.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Conde.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('conde')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:bean) { KSymbol.new(:bean) }
+        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(:red) { KSymbol.new(:red) }
+        let(:split) { KSymbol.new(:split) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:var_x) { Variable.new('x') }
+        let(:var_y) { Variable.new('y') }
+        let(:ref_q) { VariableRef.new('q') }
+        let(:ref_x) { VariableRef.new('x') }
+        let(:ref_y) { VariableRef.new('y') }
+        let(:env) do
+          e = Environment.new
+          e.add_var(var_q)
+          e.add_var(var_x)
+          e.add_var(var_y)
+          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 when all goals fail' do
+          solver = subject.solver_for([fails, 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
+          subgoal = Goal.new(Equals.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails, 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
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal, fails], 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 success if third argument succeeds' do
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, 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 'yields three solutions if three goals succeed' do
+          # Covers frame 1:58
+          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
+          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
+          subgoal3 = Goal.new(Equals.instance, [pea, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2, subgoal3, fails], 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)
+
+          # Third solution
+          outcome3 = solver.resume
+          expect(outcome3).to be_successful
+          expect(outcome3.associations['q'].first.value).to eq(pea)
+
+          expect(solver.resume).to be_nil
+        end
+
+        it 'also use conjunctions for nested goals' do
+          # Covers frame 1:88
+          subgoal1 = Goal.new(Equals.instance, [split, ref_x])
+          subgoal2 = Goal.new(Equals.instance, [pea, ref_y])
+          combo1 = [subgoal1, subgoal2]
+
+          subgoal3 = Goal.new(Equals.instance, [red, ref_x])
+          subgoal4 = Goal.new(Equals.instance, [bean, ref_y])
+          combo2 = [subgoal3, subgoal4]
+          solver = subject.solver_for([combo1, combo2], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['x'].first.value).to eq(split)
+          expect(outcome1.associations['y'].first.value).to eq(pea)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['x'].first.value).to eq(red)
+          expect(outcome2.associations['y'].first.value).to eq(bean)
+
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -2,6 +2,7 @@
 
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/conde'
 require_relative '../../lib/mini_kraken/core/conj2'
 require_relative '../../lib/mini_kraken/core/def_relation'
 require_relative '../../lib/mini_kraken/core/disj2'
@@ -58,6 +59,8 @@ module MiniKraken
         let(:bean) { k_symbol(:bean) }
         let(:corn) { k_symbol(:corn) }
         let(:cup) { k_symbol(:cup) }
+        let(:green) { k_symbol(:green) }
+        let(:lentil) { k_symbol(:lentil) }
         let(:meal) { k_symbol(:meal) }
         let(:oil) { k_symbol(:oil) }
         let(:olive) { k_symbol(:olive) }
@@ -70,6 +73,7 @@ module MiniKraken
         let(:ref_r) { Core::VariableRef.new('r') }
         let(:ref_x) { Core::VariableRef.new('x') }
         let(:ref_y) { Core::VariableRef.new('y') }
+        let(:ref_z) { Core::VariableRef.new('z') }
         let(:ref_s) { Core::VariableRef.new('s') }
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
@@ -889,6 +893,110 @@ module MiniKraken
           expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
           expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
         end
+
+        it 'should allow conde in the goal expression' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
+          goal = conde_goal([[teacupo_goal1, teacupo_goal2], [expr3, expr4]])
+          # Reasoned S2, frame 1:88
+          # (run* (x y)
+          #   (conde
+          #     ((teacupo x) (teacupo x))
+          #     ((== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          expect(result.car).to eq(cons(tea, cons(any_value(0))))
+          expect(result.cdr.car).to eq(cons(cup, cons(any_value(0))))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(cup)))
+        end
+
+        it 'should allow simplication of expressions (conde version)' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          combo1 = [expr1, expr2]
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          combo2 = [expr3, expr4]
+          goal = conde_goal([combo1, combo2])
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:88 (second part, a rewrite of 1:76)
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+          result = instance.run
+          expect(result.car.car).to eq(split)
+          expect(result.car.cdr.car).to eq(pea)
+          expect(result.cdr.car.car).to eq(red)
+          expect(result.cdr.car.cdr.car).to eq(bean)
+        end
+
+        it 'should accept nesting of disj2 and conj2 (conde version)' do
+          equals_olive = Core::Goal.new(Core::Equals.instance, [olive, ref_x])
+          combo = [equals_olive, fails]
+          equals_oil = Core::Goal.new(Core::Equals.instance, [oil, ref_x])
+          goal = conde_goal([combo, equals_oil])
+          instance = RunStarExpression.new('x', goal)
+
+          # Reasoned S2, frame 1:89 (rewrite of 1:62)
+          # (run* x
+          #   (conde
+          #     ((== 'olive x) fail)
+          #     ('oil x))) ;; => (oil)
+          result = instance.run
+          expect(result.car).to eq(oil)
+        end
+
+        it 'should accept nesting of conde inside a fresh context' do
+          equals_lentil = Core::Goal.new(Core::Equals.instance, [lentil, ref_z])
+          fresh_env = FreshEnv.new(['z'], equals_lentil)
+          equals_xy = Core::Goal.new(Core::Equals.instance, [ref_x, ref_y])
+          goal = conde_goal([fresh_env, equals_xy])
+          instance = RunStarExpression.new(%w[x y], goal)
+          fresh_env.parent = instance.env
+
+          # Reasoned S2, frame 1:90
+          # (run* (x y)
+          #   (conde
+          #     ((fresh (z)
+          #       (== 'lentil z)))
+          #     ((== x y)))) ;; => ((_0 _1)(_0 _0))
+          result = instance.run
+          expect(result.car).to eq(cons(any_value(0), cons(any_value(1))))
+          # Bug: next line fails
+          # expect(result.cdr.car).to eq(cons(any_value(0), cons(any_value(0))))
+        end
+
+        it 'accepts conde with more than two condition lines' do
+          expr1 = equals_goal(split, ref_x)
+          expr2 = equals_goal(pea, ref_y)
+          combo1 = [expr1, expr2]
+          expr3 = equals_goal(red, ref_x)
+          expr4 = equals_goal(bean, ref_y)
+          combo2 = [expr3, expr4]
+          expr5 = equals_goal(green, ref_x)
+          expr6 = equals_goal(lentil, ref_y)
+          combo3 = [expr5, expr6]
+          goal = conde_goal([combo1, combo2, combo3])
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          # Reasoned S2, frame 1:91
+          # (run* (x y)
+          #   (conde
+          #     ((== 'split x) (== 'pea y))
+          #     ((== 'red x) (== 'bean y))
+          #     ((== 'green x) (== 'lentil y))))
+          # ;; => ((split pea)(red bean)(green lentil))
+          result = instance.run
+          expect(result.car).to eq(cons(split, cons(pea)))
+          expect(result.cdr.car).to eq(cons(red, cons(bean)))
+          expect(result.cdr.cdr.car).to eq(cons(green, cons(lentil)))
+        end
       end # context
     end # describe
   end # module

data/spec/support/factory_methods.rb

@@ -27,6 +27,13 @@ module MiniKraken
       Core::ConsCell.new(obj1, obj2)
     end
 
+    # Factory method for constructing a goal using the Equals relation.
+    # @param args [Array<Core::Goal>]
+    # @return [Core::Goal]
+    def conde_goal(args)
+      Core::Goal.new(Core::Conde.instance, args)
+    end
+
     # Factory method for constructing a goal using the Equals relation.
     # @param arg1 [Term]
     # @param arg2 [Term]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-25 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/mini_kraken/core/binary_relation.rb
 - lib/mini_kraken/core/composite_goal.rb
 - lib/mini_kraken/core/composite_term.rb
+- lib/mini_kraken/core/conde.rb
 - lib/mini_kraken/core/conj2.rb
 - lib/mini_kraken/core/cons_cell.rb
 - lib/mini_kraken/core/def_relation.rb
@@ -109,6 +110,7 @@ files:
 - mini_kraken.gemspec
 - spec/core/association_spec.rb
 - spec/core/association_walker_spec.rb
+- spec/core/conde_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
 - spec/core/def_relation_spec.rb
@@ -158,6 +160,7 @@ summary: Implementation of Minikanren language in Ruby. WIP
 test_files:
 - spec/core/association_spec.rb
 - spec/core/association_walker_spec.rb
+- spec/core/conde_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
 - spec/core/def_relation_spec.rb