mini_kraken 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec7b984a9f0c857f74c8a8989c5da2072398775573b7ca6679d99f96ef13eac1
-  data.tar.gz: cdebdebae82c424b9ae701f959765f0905322798a371e2aec42ed9a229e35a4f
+  metadata.gz: 672521fbc6627e2767bfe4d6ce38dd66243736fee451e857ec7ef45d0f8905fe
+  data.tar.gz: 6835bb1d91bb6e867417faba0d6904734295f9a7bab612c6a78fcfbcdc41f84a
 SHA512:
-  metadata.gz: 2ce3553527adeebef7adc69ec5a861fe65f9f451e54a81e23f00769923ced6b6a6011846ae3e9a673c8b9094a7dcce6ea6f8d263d55c8f543ef0de309e34c11c
-  data.tar.gz: 90b45061cde1119ad648359063682f411f9e5705a294340976bd027561b1d94da7afbfc9d0d27dce67942e1407d4d4ea40df85cf3fe67c9fca998d22052b6187
+  metadata.gz: bd5b5b2d2493b4ec8f8293c5f786be1a7739d05bee5d4733d48edb16713d1df4097be5a6e85127c2c90cf395da877b57ef07a607167b8f5bb1732dbc2a367610
+  data.tar.gz: 6661aadbe8bd778283e91f31181651e32296150d282575697fee1f5c240ea46168c5107baf33d9b590d6a449ec89b2f41e69340b81cb9b9e3692954af155083b

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.1.11] - 2020-06-10
+- Supports `defrel`, taht is, the capability to define new relations by combining other relations.
+- Covers frames from "The Reasoned Scheme" book up to frame [1:87]
+
+### New
+- Class `BaseArg` a generalization of goal or goal template argument.
+- Class `DefRelation` A specialization of `Relation` class aimed for user-defined relation.
+- Class `FormalArg` to represent goal template argument(s).
+- Class `FormalRef` an allusion to a formal argument in a goal template.
+- Class `GoalTemplate` a representation of a goal parametrized with formal arguments.
+- Class `KBoolean` a MiniKraken representation of a boolean value.
+
+### CHANGED
+- File `README.md` minor change: added more TODO's.
+
 ## [0.1.10] - 2020-06-10
 - Supports frames from "The Reasoned Scheme" book up to frame [1:81]
 

data/README.md

@@ -6,7 +6,7 @@
 ### What is __mini_kraken__ ?   
 An implemention of the [miniKanren](http://minikanren.org/) relational programming language in Ruby.
 *miniKanren* is a small language for relational (logic) programming.  
-Based on the reference implementation, in Scheme from the "The Reasoned Schemer" book.  
+Based on the reference implementation, in Scheme from the "The Reasoned Schemer" book.   
 Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason Hemann: "The Reasoned Schemer", Second Edition,
 ISBN: 9780262535519, (2018), MIT Press.
 
@@ -15,13 +15,21 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] run\*  
 - [X] fresh 
 - [X] conj2  
-- [X] disj2  
+- [X] disj2
+- [X] defrel   
 
 ### TODO
-- [ ] defrel 
 - [ ] conde  
 - [ ] Occurs check
 
+List-centric relations from Chapter 2
+- [ ] caro
+- [ ] cdro
+- [ ] conso
+- [ ] nullo
+- [ ] pairo
+- [ ] singletono
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/mini_kraken/core/association_walker.rb

@@ -2,7 +2,7 @@
 
 require 'set'
 require_relative 'atomic_term'
-require_relative 'composite_term'
+require_relative 'cons_cell'
 
 module MiniKraken
   module Core

data/lib/mini_kraken/core/base_arg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # Abstract class that is a generalization for goal actual arguments or
+    # for arguments of goal template.
+    class BaseArg
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/def_relation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'relation'
+
+module MiniKraken
+  module Core
+    # A relation that is parametrized with generic formal arguments
+    # and a goal template expression.
+    class DefRelation < Relation
+      # @return [Array<FormalArg>] formal arguments of this DefRelation
+      attr_reader :formals
+
+      # @return [GoalTemplate] goal template
+      attr_reader :goal_template
+
+      # @param aName [String] name of def relation
+      # @param aGoalTemplate [GoalTemplate]
+      def initialize(aName, aGoalTemplate, theFormals, alternateName = nil)
+        super(aName, alternateName)
+        @formals = validated_formals(theFormals)
+        @goal_template = validated_goal_template(aGoalTemplate)
+      end
+
+      # Number of arguments for the relation.
+      # @return [Integer]
+      def arity
+        formals.size
+      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)
+        goal = goal_template.instantiate(formals, actuals)
+        goal.attain(anEnv)
+      end
+
+      private
+
+      def validated_formals(theFormals)
+        theFormals
+      end
+
+      def validated_goal_template(aGoalTemplate)
+        aGoalTemplate
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/disj2.rb

@@ -2,6 +2,7 @@
 
 require 'singleton'
 require_relative 'duck_fiber'
+require_relative 'fail'
 require_relative 'goal'
 require_relative 'goal_relation'
 require_relative 'outcome'

data/lib/mini_kraken/core/formal_arg.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # The generalization of any iem that can be
+    # passed as arugement to a goal.
+    class FormalArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/formal_ref.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A formal reference represents the occurrence of a formal argument name in a
+    # goal template argument list.
+    class FormalRef < BaseArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/goal_arg.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'base_arg'
+
 module MiniKraken
   module Core
-    # The generalization of any iem that can be
-    # passed as arugement to a goal.
-    class GoalArg
+    # The generalization of any item that can be
+    # passed as arugement to a goal object
+    class GoalArg < BaseArg
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/goal_template.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A meta-goal that is parametrized with generic formal arguments.
+    # The individual goals are instantiated when the formal arguments
+    # are bound to goal arguments
+    class GoalTemplate < BaseArg
+      # @return [Array<BaseArg>}] Arguments of goal template.
+      attr_reader :args
+
+      # @return [Relation] Main relation for the goal template
+      attr_reader :relation
+
+      def initialize(aRelation, theArgs)
+        @relation = validated_relation(aRelation)
+        @args = validated_args(theArgs)
+      end
+
+      # @param formals [Array<FormalArg>] Array of formal arguments
+      # @param actuals [Array<GoalArg>] Array of actual arguments
+      # @return [Goal] instantiate a goal object given the actuals and environment
+      def instantiate(formals, actuals)
+        formals2actuals = {}
+        formals.each_with_index do |frml, i|
+          formals2actuals[frml.name] = actuals[i]
+        end
+
+        do_instantiate(formals2actuals)
+      end
+
+      private
+
+      def validated_relation(aRelation)
+        aRelation
+      end
+
+      def validated_args(theArgs)
+        theArgs
+      end
+
+      def do_instantiate(formals2actuals)
+        goal_args = []
+        args.each do |arg|
+          if arg.kind_of?(FormalRef)
+            goal_args << formals2actuals[arg.name]
+          elsif arg.kind_of?(GoalTemplate)
+            goal_args << arg.send(:do_instantiate, formals2actuals)
+          else
+            goal_args << arg
+          end
+        end
+
+        Goal.new(relation, goal_args)
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/k_boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'atomic_term'
+
+module MiniKraken
+  module Core
+    # A specialized atomic term that represents an boolean (true/false) value.
+    # in MiniKraken
+    class KBoolean < AtomicTerm
+      # @param aValue [Boolean, Symbol] Ruby representation of boolean value
+      def initialize(aValue)
+        super(validated_value(aValue))
+      end
+
+      private
+
+      def validated_value(aValue)
+        case aValue
+          when true, false
+            aValue
+          when :"#t", '#t'
+            true
+          when :"#f", '#f'
+            false
+          else
+            raise StandardError, "Invalid boolean literal '#{aValue}'"
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -7,6 +7,7 @@ require_relative 'fresh_env'
 module MiniKraken
   module Glue
     class RunStarExpression
+      # @return [FreshEnv] The environment in which run* variables will reside.
       attr_reader :env
 
       # @param var_names [String, Array<String>] One variable name or an array of names

data/lib/mini_kraken/version.rb

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

data/spec/core/def_relation_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/goal_template'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/def_relation'
+
+module MiniKraken
+  module Core
+    describe DefRelation do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:formal_t) { FormalArg.new('t') }
+      let(:t_ref) { FormalRef.new('t') }
+      let(:equals_tea) { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+      subject { DefRelation.new('teao', equals_tea, [formal_t]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name, a goal template, formal args' do
+          expect { DefRelation.new('teao', equals_tea, [formal_t]) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('teao')
+        end
+
+        it 'should know its goal template' do
+          expect(subject.goal_template).to eq(equals_tea)
+        end
+
+        it 'should know its formals' do
+          expect(subject.formals).to eq([formal_t])
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        let(:equals_cup) { GoalTemplate.new(Equals.instance, [cup, t_ref]) }
+        let(:g_template) { GoalTemplate.new(Disj2.instance, [equals_tea, equals_cup]) }
+        subject { DefRelation.new('teacup', g_template, [formal_t]) }
+        let(:env) { Environment.new }
+
+        it 'should provide solver for a single-node goal without var ref' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          solver = defrel.solver_for([tea], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+
+          solver = defrel.solver_for([cup], env)
+          outcome = solver.resume
+          expect(outcome).not_to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          env.add_var(Variable.new('x'))
+          solver = defrel.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          env.add_var(Variable.new('x'))
+          solver = subject.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(cup)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/goal_template_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+# require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/goal_template'
+
+
+module MiniKraken
+  module Core
+    describe GoalTemplate do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:t_ref) { FormalRef.new('t') }
+      subject { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a relation and args' do
+          expect { GoalTemplate.new(Equals.instance, [tea, t_ref]) }.not_to raise_error
+        end
+
+        it 'should know its relation' do
+          expect(subject.relation).to eq(Equals.instance)
+        end
+
+        it 'should know its arguments' do
+          expect(subject.args[0]).to eq(tea)
+          expect(subject.args[1]).to eq(t_ref)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:formal_t) { FormalArg.new('t') }
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        # let(:env) { Environment.new }
+
+        it 'should instantiate a single-node goal' do
+          expect(subject.instantiate([formal_t], [cup])).to be_kind_of(Goal)
+          goal = subject.instantiate([formal_t], [cup])
+          expect(goal.relation).to eq(Equals.instance)
+          expect(goal.actuals[0]).to eq(tea)
+          expect(goal.actuals[1]).to eq(cup)
+        end
+
+        it 'should instantiate a multiple-nodes goal' do
+          sub_tmp1 =  GoalTemplate.new(Equals.instance, [tea, t_ref])
+          sub_tmp2 =  GoalTemplate.new(Equals.instance, [cup, t_ref])
+          template =  GoalTemplate.new(Disj2.instance, [sub_tmp1, sub_tmp2])
+
+          goal = template.instantiate([formal_t], [ref_x])
+          expect(goal.relation).to eq(Disj2.instance)
+          subgoal1 = goal.actuals[0]
+          expect(subgoal1).to be_kind_of(Goal)
+          expect(subgoal1.relation).to eq(Equals.instance)
+          expect(subgoal1.actuals[0]).to eq(tea)
+          expect(subgoal1.actuals[1]).to eq(ref_x)
+          subgoal2 = goal.actuals[1]
+          expect(subgoal2).to be_kind_of(Goal)
+          expect(subgoal2.relation).to eq(Equals.instance)
+          expect(subgoal2.actuals[0]).to eq(cup)
+          expect(subgoal2.actuals[1]).to eq(ref_x)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/k_boolean_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'ostruct'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/k_boolean'
+
+module MiniKraken
+  module Core
+    describe KBoolean do
+      subject { KBoolean.new('#t') }
+
+      context 'Initialization:' do
+        it 'could be created with a Ruby true/false value' do
+          expect { KBoolean.new(true) }.not_to raise_error
+          expect { KBoolean.new(false) }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby Symbol value' do
+          expect { KBoolean.new(:"#t") }.not_to raise_error
+          expect { KBoolean.new(:"#f") }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby String value' do
+          expect { KBoolean.new('#t') }.not_to raise_error
+          expect { KBoolean.new('#f') }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(true)
+        end
+
+        it 'should know that it is a ground term' do
+          env = double('mock-env')
+          expect(subject.ground?(env)).to be_truthy
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it is equal to another instance' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new(:"#t")
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new('#t')
+          expect(subject).to be_eql(other)
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new(:"#f")
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new('#f')
+          expect(subject).not_to be_eql(another)
+
+          # Different type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject).not_to be_eql(yet_another)
+        end
+
+        it 'should know whether it has same value than other object' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new(:"#t")
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new('#t')
+          expect(subject == other).to be_truthy
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new(:"#f")
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new('#f')
+          expect(subject == another).to be_falsy
+
+          # Same duck type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject == yet_another).to be_truthy
+
+          # Different duck type, different value
+          still_another = OpenStruct.new(value: false)
+          expect(subject == still_another).to be_falsy
+
+          # Default Ruby representation, same value
+          expect(subject == true).to be_truthy
+
+          # Default Ruby representation, different value
+          expect(subject == false).to be_falsy
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -3,9 +3,13 @@
 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/def_relation'
 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/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal_template'
 require_relative '../../lib/mini_kraken/core/succeed'
 
 require_relative '../support/factory_methods'
@@ -49,14 +53,18 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:k_false) { k_boolean(false) }
+        let(:k_true) { k_boolean(true) }
         let(:bean) { k_symbol(:bean) }
         let(:corn) { k_symbol(:corn) }
+        let(:cup) { k_symbol(:cup) }
         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(:tea) { k_symbol(:tea) }
         let(:virgin) { k_symbol(:virgin) }
         let(:ref_q) { Core::VariableRef.new('q') }
         let(:ref_r) { Core::VariableRef.new('r') }
@@ -66,6 +74,16 @@ module MiniKraken
         let(:ref_t) { Core::VariableRef.new('t') }
         let(:ref_u) { Core::VariableRef.new('u') }
         let(:ref_z) { Core::VariableRef.new('z') }
+        let(:t_ref) { Core::FormalRef.new('t') }
+        let(:equals_tea) { Core::GoalTemplate.new(Core::Equals.instance, [tea, t_ref]) }
+        let(:equals_cup) { Core::GoalTemplate.new(Core::Equals.instance, [cup, t_ref]) }
+        let(:g_template) { Core::GoalTemplate.new(Core::Disj2.instance, [equals_tea, equals_cup]) }
+        let(:formal_t) { Core::FormalArg.new('t') }
+
+        # Reasoned S2, frame 1:82
+        # (defrel (teacupo t)
+        #   (disj2 (== 'tea t) (== 'cup t)))
+        let(:teacupo_rel) { Core::DefRelation.new('teacupo', g_template, [formal_t]) }
 
         it 'should return a null list with the fail goal' do
           # Reasoned S2, frame 1:7
@@ -781,6 +799,96 @@ module MiniKraken
           expect(result.car.car).to eq(split)
           expect(result.car.cdr.car).to eq(pea)
         end
+
+        it 'should solve expression with defrel' do
+          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
+
+          # Reasoned S2, frame 1:83
+          # (run* x
+          #   (teacupo x)) ;; => ((tea cup))
+          instance = RunStarExpression.new('x', teacupo_goal)
+
+          result = instance.run
+          expect(result.car).to eq(tea)
+          expect(result.cdr.car).to eq(cup)
+        end
+
+        it 'should solve expression with defrel and booleans' do
+          teacupo_goal = Core::Goal.new(teacupo_rel, [ref_x])
+          expr2 = equals_goal(k_true, ref_y)
+          subgoal1 = conj2_goal(teacupo_goal, expr2)
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = equals_goal(k_true, ref_y)
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          # Reasoned S2, frame 1:84
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (== #t y))
+          #     (conj2 (== #f x) (== #t y))) ;; => ((#f #t)(tea #t) (cup #t))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(tea, cons(true)))
+          expect(result.cdr.car).to eq(cons(cup, cons(true)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(true)))
+        end
+
+        it 'should solve expression with two variable and defrel' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_y])
+
+          # Reasoned S2, frame 1:85
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo y)) ;; => ((tea tea)(tea cup)(cup tea)(cup c))
+          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
+
+          result = instance.run
+          expect(result.car).to eq(cons(tea, cons(tea)))
+          expect(result.cdr.car).to eq(cons(tea, cons(cup)))
+          expect(result.cdr.cdr.car).to eq(cons(cup, cons(tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(cup, cons(cup)))
+        end
+
+        it 'should solve expression with two variable and defrel' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+
+          # Reasoned S2, frame 1:86
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo x)) ;; => ((tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], [teacupo_goal1, teacupo_goal2])
+
+          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))))
+        end
+
+        it 'should solve expression with defrel and booleans' do
+          teacupo_goal1 = Core::Goal.new(teacupo_rel, [ref_x])
+          teacupo_goal2 = Core::Goal.new(teacupo_rel, [ref_x])
+          subgoal1 = conj2_goal(teacupo_goal1, teacupo_goal2)
+          expr3 = equals_goal(k_false, ref_x)
+          expr4 = Core::Goal.new(teacupo_rel, [ref_y])
+          subgoal2 = conj2_goal(expr3, expr4)
+          goal = disj2_goal(subgoal1, subgoal2)
+          # Reasoned S2, frame 1:87
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (teacupo x))
+          #     (conj2 (== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+          instance = RunStarExpression.new(%w[x y], goal)
+
+          result = instance.run
+          # Order of solutions differs from RS book
+          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
       end # context
     end # describe
   end # module

data/spec/support/factory_methods.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../lib/mini_kraken/core/any_value'
 require_relative '../../lib/mini_kraken/core/cons_cell'
+require_relative '../../lib/mini_kraken/core/k_boolean'
 require_relative '../../lib/mini_kraken/core/k_symbol'
 require_relative '../../lib/mini_kraken/core/variable'
 require_relative '../../lib/mini_kraken/core/variable_ref'
@@ -50,6 +51,13 @@ module MiniKraken
       Core::Goal.new(Core::Disj2.instance, [g1, g2])
     end
 
+    # Factory method for constructing a KBoolean instance
+    # @param aValue [Boolean]
+    # @return [Core::KBoolean]
+    def k_boolean(aValue)
+      Core::KBoolean.new(aValue)
+    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.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-13 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,21 +72,27 @@ files:
 - lib/mini_kraken/core/association.rb
 - lib/mini_kraken/core/association_walker.rb
 - lib/mini_kraken/core/atomic_term.rb
+- lib/mini_kraken/core/base_arg.rb
 - 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/conj2.rb
 - lib/mini_kraken/core/cons_cell.rb
+- lib/mini_kraken/core/def_relation.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
 - lib/mini_kraken/core/fail.rb
+- lib/mini_kraken/core/formal_arg.rb
+- lib/mini_kraken/core/formal_ref.rb
 - lib/mini_kraken/core/freshness.rb
 - lib/mini_kraken/core/goal.rb
 - lib/mini_kraken/core/goal_arg.rb
 - lib/mini_kraken/core/goal_relation.rb
+- lib/mini_kraken/core/goal_template.rb
+- lib/mini_kraken/core/k_boolean.rb
 - lib/mini_kraken/core/k_integer.rb
 - lib/mini_kraken/core/k_symbol.rb
 - lib/mini_kraken/core/nullary_relation.rb
@@ -105,12 +111,15 @@ files:
 - spec/core/association_walker_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/def_relation_spec.rb
 - spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
 - spec/core/environment_spec.rb
 - spec/core/equals_spec.rb
 - spec/core/fail_spec.rb
 - spec/core/goal_spec.rb
+- spec/core/goal_template_spec.rb
+- spec/core/k_boolean_spec.rb
 - spec/core/k_symbol_spec.rb
 - spec/core/outcome_spec.rb
 - spec/core/succeed_spec.rb
@@ -151,12 +160,15 @@ test_files:
 - spec/core/association_walker_spec.rb
 - spec/core/conj2_spec.rb
 - spec/core/cons_cell_spec.rb
+- spec/core/def_relation_spec.rb
 - spec/core/disj2_spec.rb
 - spec/core/duck_fiber_spec.rb
 - spec/core/environment_spec.rb
 - spec/core/equals_spec.rb
 - spec/core/fail_spec.rb
 - spec/core/goal_spec.rb
+- spec/core/goal_template_spec.rb
+- spec/core/k_boolean_spec.rb
 - spec/core/k_symbol_spec.rb
 - spec/core/outcome_spec.rb
 - spec/core/succeed_spec.rb