mini_kraken 0.1.13 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79ea33dd475e6dfbed71915177b1581abb5e1ca9a60db04133d11cda7dca9d42
-  data.tar.gz: 249bea4319183c929e4c291785c6b74e10606889c789c5e0f2b211197cc6f288
+  metadata.gz: 4bbfe3d58d4c7271a5c8a54486a743c51d6fddcb3b068095cad44cacad575c83
+  data.tar.gz: 012b412a95752592b5be70859e00d94b379e2c4c564d37d932a300a03cbc9716
 SHA512:
-  metadata.gz: '086bf0b30750e908dfee1b7e95eb3b0c0e54dff4f7bd700d54bbf28091aaf02080d458c14508ddcaa580248e0234d1da23553869480e3bea930d46708c115d82'
-  data.tar.gz: d3ada8d056819b2ae1af0d442056008600f82633ee52ca8aa672708943fdf517adb60522bfff6673f9cea86985c1bf5ce2a7a3ea73f07504945e660f31ebee49
+  metadata.gz: 952d93b01de392c7168e7cfb4a3cc911e4d1b53be11a4a10d67012bb4ab4a8f69aa42f41bf13a756f89a6d09eb775a5594174d73334c57c2230039b7991e89fd
+  data.tar.gz: a60adbd5da627495badab63de355336f131a5e599c40226931366a7c1b4a349b2542ccb55cf30ef8e60990341c1f5d8547804b1552fbbbc504bd1bed40a36d9e

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.2.00] - 2020-07-12
+- First release of DSL (Domain Specific Language)
+- Fix defect for fused variables that remain fresh
+
+### NEW
+- Mix-in module `Glue::DSL` hosting methods for implementing the DSL.
+- Method `ConsCell#to_s` uses the Lisp convention for representing lists.
+
+### CHANGED
+- File `README.md` Added a couple of examples of DSL use.
+- Method `AnyValue#==` can compare with symbols with format '_' + integer literal (e.g. :_0).
+
 ## [0.1.13] - 2020-07-01
 - Cover all frames from Chapter One of "Reasoned Scheme" book.
 - Fix defect for fused variables that remain fresh

data/README.md

@@ -4,22 +4,29 @@
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/mini_kraken/blob/master/LICENSE.txt)
 
 ### What is __mini_kraken__ ?   
-An implemention of the [miniKanren](http://minikanren.org/) relational programming language in Ruby.
+A library containing an implementation 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.   
 Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason Hemann: "The Reasoned Schemer", Second Edition,
 ISBN: 9780262535519, (2018), MIT Press.
 
 ### Features
+- Pure Ruby implementation, not a port from another language
+- Object-Oriented design
+- No runtime dependencies
+
+### miniKanren Features
 - [X] ==  
 - [X] run\*  
-- [X] fresh 
+- [X] fresh
+- [X] conde
 - [X] conj2  
 - [X] disj2
 - [X] defrel   
 
 ### TODO
-- [ ] conde  
+
 - [ ] Occurs check
 
 List-centric relations from Chapter 2
@@ -46,9 +53,82 @@ Or install it yourself as:
 
     $ gem install mini_kraken
 
-## Usage
+## Examples
+
+The following __MiniKraken__ examples use its DSL (Domain Specific Language).
+
+### Example 1
+Let's first begin with a rather simplistic example.   
+
+```ruby
+require 'mini_kraken' # Load MiniKraken library
+
+extend(MiniKraken::Glue::DSL) # Add DSL method to self (object in context)
+
+result = run_star('q', equals(q, :pea))
+puts result # => (:pea)
+```
+
+The two first lines in the above code snippet are pretty standard:  
+- The first line loads the `mini_kraken` library.
+- The second line add the DSL methods to the current object.
+
+The next line constitutes a trivial `miniKanren` program.
+The aim of a `miniKanren` program is to find one or more solutions involving provided variable(s)
+and satisfying one or more goals.
+In our example, the `run_star` method instructs `MiniKraken` to find all solutions,  
+knowing that each successful solution:
+- binds a value to the provided variable `q` and
+- meets the goal `equals(q, :pea)`.
+
+The goal `equals(q, :pea)` succeeds because the logical variable `q` is _fresh_ (that is,
+  not yet bound to a value) and will be bound to the symbol `:pea` as a side effect
+  of the goal `equals`.
+
+So the above program succeeds and the only found solution is obtained by binding
+ the variable `q` to the value :pea. Hence the result of the `puts` method.
+
+### Example 2
+ The next example illustrates the behavior of a failing `miniKanren` program.
+
+ ```ruby
+ require 'mini_kraken' # Load MiniKraken library
+
+ extend(MiniKraken::Glue::DSL) # Add DSL method to self (object in context)
+
+ # Following miniKanren program fails
+ result = run_star('q', [equals(q, :pea), equals(q, :pod)])
+ puts result # => ()
+ ```
+In this example, we learn that `run_star` can take multiple goals placed in an array.
+The program fails to find a solution since it is not possible to satisfy the two `equals` goals simultaneously. In that case, the `run_star` return an empty list represented as `()` in the output.
+
+
+### Example 3
+ The next example shows the use two logical variables.
+
+```ruby
+# In this example and following, one assumes that DSL is loaded as shown in Example 1
+
+result = run_star(['x', 'y'], [equals(:hello, x), equals(y, :world)])
+puts result # => ((:hello :world))
+```
 
-TODO: Write usage instructions here
+This time, `run_star` takes two logical variables -`x` and `y`- and successfully finds the solution `x = :hello, y = :world`.
+
+### Example 4
+ The next example shows the use of `disj2` goals.
+ ```ruby
+ result = run_star(['x', 'y'],
+                   [
+                     disj2(equals(x, :blue), equals(x, :red)),
+                     disj2(equals(y, :sea), equals(:mountain, y))
+                   ])
+ puts result # => ((:blue :sea) (:blue :mountain) (:red :sea) (:red :mountain))
+ ```
+
+ Here, `run_star` takes two logical variables and two `disj2` goals. A `disj2` succeeds if any of its arguments succeeds.
+ This program finds four distinct solutions for x, y pairs.
 
 ## Development
 

data/lib/mini_kraken.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
-require 'mini_kraken/version'
+# This file acts as a jumping-off point for loading dependencies expected
+# for a MiniKraken client.
+
+require_relative './mini_kraken/version'
+require_relative './mini_kraken/glue/dsl'
+
+
+# End of file
 
 module MiniKraken
   class Error < StandardError; end

data/lib/mini_kraken/core/any_value.rb

@@ -12,7 +12,11 @@ module MiniKraken
       end
 
       def ==(other)
-        rank == other.rank
+        if other.is_a?(AnyValue)
+          rank == other.rank
+        elsif other.id2name =~ /_\d+/
+          rank == other.id2name.sub(/_/, '').to_i
+        end
       end
 
       # Use same text representation as in Reasoned Schemer.

data/lib/mini_kraken/core/cons_cell.rb

@@ -11,7 +11,11 @@ unless MiniKraken::Core.constants(false).include? :ConsCell
 
         def initialize(obj1, obj2 = nil)
           @car = obj1
-          @cdr = obj2
+          if obj2.kind_of?(ConsCell) && obj2.null?
+            @cdr = nil
+          else
+            @cdr = obj2
+          end
         end
 
         def children
@@ -42,9 +46,32 @@ unless MiniKraken::Core.constants(false).include? :ConsCell
           ConsCell.new(new_car, new_cdr)
         end
 
+        # Use the list notation from Lisp as a text representation.
+        def to_s
+          return '()' if null?
+
+          "(#{pair_to_s})"
+        end
+
         def append(another)
           @cdr = another
         end
+
+        protected
+
+        def pair_to_s
+          result = +car.to_s
+          if cdr
+            result << ' '
+            if cdr.kind_of?(ConsCell)
+              result << cdr.pair_to_s
+            else
+              result << ". #{cdr}"
+            end
+          end
+
+          result
+        end
       end # class
 
       # Constant representing the null (empty) list.

data/lib/mini_kraken/core/goal.rb

@@ -35,14 +35,15 @@ module MiniKraken
           raise StandardError, err_msg
         end
 
-        prefix = 'Invalid goal argument '
+        prefix = "Invalid goal argument '"
         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
+            actual_display = actual.nil? ? 'nil' : actual.to_s
+            raise StandardError, prefix + actual_display + "'"
           end
         end
 

data/lib/mini_kraken/core/k_symbol.rb

@@ -11,6 +11,17 @@ module MiniKraken
       def initialize(aValue)
         super(aValue)
       end
+
+      # Returns the name or string corresponding to value.
+      # @return [String]
+      def id2name
+        value.id2name
+      end
+
+      # Returns a string representing the MiniKraken symbol.
+      def to_s
+        ':' + id2name
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/dsl.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../core/any_value'
+require_relative '../core/conj2'
+require_relative '../core/cons_cell'
+require_relative '../core/disj2'
+require_relative '../core/equals'
+require_relative '../core/fail'
+require_relative '../core/k_symbol'
+require_relative '../core/succeed'
+require_relative '../core/variable_ref'
+require_relative 'fresh_env'
+require_relative 'run_star_expression'
+
+
+module MiniKraken
+  module Glue
+    module DSL
+      # @return [Core::ConsCell] A list of solutions
+      def run_star(var_names, goal)
+        program = RunStarExpression.new(var_names, goal)
+        program.run
+      end
+
+      def conj2(arg1, arg2)
+        Core::Goal.new(Core::Conj2.instance, [convert(arg1), convert(arg2)])
+      end
+
+      def cons(car_item, cdr_item = nil)
+        Core::ConsCell.new(convert(car_item), convert(cdr_item))
+      end
+
+      def disj2(arg1, arg2)
+        Core::Goal.new(Core::Disj2.instance, [convert(arg1), convert(arg2)])
+      end
+
+      def _fail
+        Core::Goal.new(Core::Fail.instance, [])
+      end
+
+      def equals(arg1, arg2)
+        Core::Goal.new(Core::Equals.instance, [convert(arg1), convert(arg2)])
+      end
+
+      def fresh(var_names, goal)
+        vars = nil
+
+        if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
+          vars = [var_names]
+        elsif
+
+          vars = var_names
+        end
+        FreshEnv.new(vars, goal)
+      end
+
+      def null
+        Core::ConsCell.new(nil, nil)
+      end
+
+      def succeed
+        Core::Goal.new(Core::Succeed.instance, [])
+      end
+
+      private
+
+      def convert(anArgument)
+        converted = nil
+
+        case anArgument
+          when Symbol
+            if anArgument.id2name =~ /_\d+/
+              rank = anArgument.id2name.slice(1..-1).to_i
+              any_val = Core::AnyValue.allocate
+              any_val.instance_variable_set(:@rank, rank)
+              converted = any_val
+            else
+              converted = Core::KSymbol.new(anArgument)
+            end
+          when Core::Goal
+            converted = anArgument
+          when Core::VariableRef
+            converted = anArgument
+          when Core::ConsCell
+            converted = anArgument
+        end
+
+        converted
+      end
+
+      def method_missing(mth, *args)
+        result = nil
+
+        begin
+          result = super(mth, *args)
+        rescue NameError
+          result = Core::VariableRef.new(mth.id2name)
+        end
+
+        result
+      end
+    end # module
+  end # module
+end # module

data/lib/mini_kraken/version.rb

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

data/spec/core/cons_cell_spec.rb

@@ -11,6 +11,7 @@ module MiniKraken
     describe ConsCell do
       let(:pea) { KSymbol.new(:pea) }
       let(:pod) { KSymbol.new(:pod) }
+      let(:corn) { KSymbol.new(:corn) }
       subject { ConsCell.new(pea, pod) }
 
       context 'Initialization:' do
@@ -39,6 +40,12 @@ module MiniKraken
           expect(ConsCell.new(nil, nil)).to be_null
           expect(NullList).to be_null
         end
+
+        it 'simplifies cdr if its referencing a null list' do
+          instance = ConsCell.new(pea, NullList)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to be_nil
+        end
       end # context
 
       context 'Provided services:' do
@@ -66,6 +73,34 @@ module MiniKraken
           expect(instance.car).to eq(pea)
           expect(instance.cdr).to eq(trail)
         end
+
+        it 'should provide a list representation of itself' do
+          # Case of null list
+          expect(NullList.to_s).to eq '()'
+
+          # Case of one element proper list
+          cell = ConsCell.new(pea)
+          expect(cell.to_s).to eq '(:pea)'
+
+          # Case of two elements proper list
+          cell = ConsCell.new(pea, ConsCell.new(pod))
+          expect(cell.to_s).to eq '(:pea :pod)'
+
+          # Case of two elements improper list
+          expect(subject.to_s).to eq '(:pea . :pod)'
+
+          # Case of three elements proper list
+          cell = ConsCell.new(pea, ConsCell.new(pod, ConsCell.new(corn)))
+          expect(cell.to_s).to eq '(:pea :pod :corn)'
+
+          # Case of three elements improper list
+          cell = ConsCell.new(pea, ConsCell.new(pod, corn))
+          expect(cell.to_s).to eq '(:pea :pod . :corn)'
+
+          # Case of a nested list
+          cell = ConsCell.new(ConsCell.new(pea), ConsCell.new(pod))
+          expect(cell.to_s).to eq '((:pea) :pod)'
+        end
       end # context
     end # describe
   end # module

data/spec/core/k_symbol_spec.rb

@@ -65,6 +65,10 @@ module MiniKraken
           # Default Ruby representation, different value
           expect(subject == :pod).to be_falsy
         end
+        
+        it 'should provide a string representation of itself' do
+          expect(subject.to_s).to eq(':pea')
+        end
       end # context
     end # describe
   end # module

data/spec/glue/dsl_chap1_spec.rb

@@ -0,0 +1,498 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/glue/dsl'
+
+
+module MiniKraken
+  module Glue
+    describe 'DSL (Chap 1)' do
+      include DSL
+
+      context 'Chapter 1 examples:' do
+        it 'passes frame 1:7' do
+          # Reasoned S2, frame 1:7
+          # (run* q #u) ;; => ()
+
+          result = run_star('q', _fail)
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:10' do
+          # Reasoned S2, frame 1:10
+          # (run* q (== 'pea 'pod) ;; => ()
+
+          result = run_star('q', equals(:pea, :pod))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:11' do
+          # Reasoned S2, frame 1:11
+          # (run* q (== q 'pea) ;; => (pea)
+
+          result = run_star('q', equals(q, :pea))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:12' do
+          # Reasoned S2, frame 1:12
+          # (run* q (== 'pea q) ;; => (pea)
+
+          result = run_star('q', equals(:pea, q))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:17' do
+          # Reasoned S2, frame 1:17
+          # (run* q succeed) ;; => (_0)
+
+          result = run_star('q', succeed)
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:19' do
+          # Reasoned S2, frame 1:19
+          # (run* q (== 'pea 'pea)) ;; => (_0)
+
+          result = run_star('q', equals(:pea, :pea))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:20' do
+          # Reasoned S2, frame 1:20
+          # (run* q (== q q)) ;; => (_0)
+
+          result = run_star('q', equals(q, q))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:21' do
+          # Reasoned S2, frame 1:21
+          # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
+
+          result = run_star('q', fresh('x', equals(:pea, q)))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:25' do
+          # Reasoned S2, frame 1:25
+          # (run* q (fresh (x) (== (cons x '()) q))) ;; => ((_0))
+          # require 'debug' Invalid goal argument
+          result = run_star('q', fresh('x', equals(cons(x, null), q)))
+          expect(result.car).to eq(cons(:_0))
+        end
+
+        it 'passes frame 1:31' do
+          # Reasoned S2, frame 1:31
+          # (run* q (fresh (x) (== x q))) ;; => (_0)
+
+          result = run_star('q', fresh('x', equals(x, q)))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:32' do
+          # Reasoned S2, frame 1:32
+          # (run* q (==  '(((pea)) pod) '(((pea)) pod))) ;; => (_0)
+
+          result = run_star('q', equals(cons(cons(:pea), :pod), cons(cons(:pea), :pod)))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:33' do
+          # Beware: quasiquoting
+          # Reasoned S2, frame 1:33
+          # (run* q (==  '(((pea)) pod) '(((pea)) ,q))) ;; => ('pod)
+
+          result = run_star('q', equals(cons(cons(:pea), :pod), cons(cons(:pea), q)))
+          expect(result.car).to eq(:pod)
+        end
+
+        it 'passes frame 1:34' do
+          # Reasoned S2, frame 1:34
+          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
+
+          result = run_star('q', equals(cons(cons(q), :pod), cons(cons(:pea), q)))
+          expect(result.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:35' do
+          # Reasoned S2, frame 1:35
+          # (run* q (fresh (x) (==  '(((,q)) pod) `(((,x)) pod)))) ;; => (_0)
+
+          result = run_star('q', fresh('x', equals(cons(cons(q), :pod), cons(cons(x), :pod))))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:36' do
+          # Reasoned S2, frame 1:36
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
+
+          result = run_star('q', fresh('x', equals(cons(cons(cons(q)), x), cons(cons(cons(x)), :pod))))
+          expect(result.car).to eq(:pod)
+        end
+
+        it 'passes frame 1:37' do
+          # Reasoned S2, frame 1:37
+          # (run* q (fresh (x) (==  '( ,x ,x) q))) ;; => (_0 _0)
+
+          result = run_star('q', fresh('x', equals(cons(x, cons(x)), q)))
+          expect(result.car).to eq(cons(:_0, cons(:_0)))
+        end
+
+        it 'passes frame 1:38' do
+          # Reasoned S2, frame 1:38
+          # (run* q (fresh (x) (fresh (y) (==  '( ,q ,y) '((,x ,y) ,x))))) ;; => (_0 _0)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(q, cons(y)), cons(cons(x, cons(y)), cons(x))))))
+          expect(result.car).to eq(cons(:_0, cons(:_0)))
+        end
+
+        it 'passes frame 1:41' do
+          # Reasoned S2, frame 1:41
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y) q)))) ;; => (_0 _1)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(x, cons(y)), q))))
+          # q should be bound to '(,x ,y)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:42' do
+          # Reasoned S2, frame 1:42
+          # (run* s (fresh (t) (fresh (u) (==  '( ,t ,u) s)))) ;; => (_0 _1)
+
+          result = run_star('s', fresh('t', fresh('u', equals(cons(t, cons(u)), s))))
+          # s should be bound to '(,t ,u)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:43' do
+          # Reasoned S2, frame 1:43
+          # (run* q (fresh (x) (fresh (y) (==  '( ,x ,y ,x) q)))) ;; => (_0 _1 _0)
+
+          result = run_star('q', fresh('x', fresh('y', equals(cons(x, cons(y, cons(x))), q))))
+          # q should be bound to '(,x ,y, ,x)
+          expect(result.car).to eq(cons(:_0, cons(:_1, cons(:_0))))
+        end
+
+        it 'passes frame 1:50' do
+          # Reasoned S2, frame 1:50
+          # (run* q (conj2 succeed succeed)) ;; => (_0)
+
+          result = run_star('q', conj2(succeed, succeed))
+          expect(result.car).to eq(:_0)
+        end
+
+        it 'passes frame 1:51' do
+          # Reasoned S2, frame 1:51
+          # (run* q (conj2 succeed (== 'corn q)) ;; => ('corn)
+
+          result = run_star('q', conj2(succeed, equals(:corn, q)))
+          expect(result.car).to eq(:corn)
+        end
+
+        it 'passes frame 1:52' do
+          # Reasoned S2, frame 1:52
+          # (run* q (conj2 fail (== 'corn q)) ;; => ()
+
+          result = run_star('q', conj2(_fail, equals(:corn, q)))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:53' do
+          # Reasoned S2, frame 1:53
+          # (run* q (conj2 (== 'corn q)(== 'meal q)) ;; => ()
+
+          result = run_star('q', conj2(equals(:corn, q), equals(:meal, q)))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:54' do
+          # Reasoned S2, frame 1:54
+          # (run* q (conj2 (== 'corn q)(== 'corn q)) ;; => ('corn)
+
+          result = run_star('q', conj2(equals(:corn, q), equals(:corn, q)))
+          expect(result.car).to eq(:corn)
+        end
+
+        it 'passes frame 1:55' do
+          # Reasoned S2, frame 1:55
+          # (run* q (disj2 fail fail)) ;; => ()
+
+          result = run_star('q', disj2(_fail, _fail))
+          expect(result).to be_null
+        end
+
+        it 'passes frame 1:56' do
+          # Reasoned S2, frame 1:56
+          # (run* q (disj2 (== 'olive q) fail)) ;; => ('olive)
+
+          result = run_star('q', disj2(equals(:olive, q), _fail))
+          expect(result.car).to eq(:olive)
+        end
+
+        it 'passes frame 1:57' do
+          # Reasoned S2, frame 1:57
+          # (run* q (disj2 fail (== 'oil q))) ;; => (oil)
+
+          result = run_star('q', disj2(_fail, equals(:oil, q)))
+          expect(result.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:58' do
+          # Reasoned S2, frame 1:58
+          # (run* q (disj2 (== 'olive q) (== 'oil q))) ;; => (olive oil)
+
+          result = run_star('q', disj2(equals(:olive, q), equals(:oil, q)))
+          expect(result.car).to eq(:olive)
+          expect(result.cdr.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:59' do
+          # Reasoned S2, frame 1:59
+          # (run* q (fresh (x) (fresh (y) (disj2  (== '( ,x ,y ) q) (== '( ,x ,y ) q)))))
+          # ;; => ((_0 _1) (_0 _1))
+
+          result = run_star('q', fresh('x', (fresh 'y', disj2(equals(cons(x, cons(y)), q), equals(cons(x, cons(y)), q)))))
+          # q should be bound to '(,x ,y), then to '(,y ,x)
+          expect(result.car).to eq(cons(:_0, cons(:_1)))
+          expect(result.cdr.car).to eq(cons(:_0, cons(:_1)))
+        end
+
+        it 'passes frame 1:62' do
+          # Reasoned S2, frame 1:62
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) fail)
+          #           (== 'oil x))) ;; => (oil)
+
+          result = run_star('x', disj2(conj2(equals(:olive, x), _fail), equals(:oil, x)))
+          expect(result.car).to eq(:oil)
+        end
+
+        it 'passes frame 1:63' do
+          # Reasoned S2, frame 1:63
+          # (run* x (disj2
+          #           (conj2 (== 'olive x) succeed)
+          #           ('oil x))) ;; => (olive oil)
+
+          result = run_star('x', disj2(conj2(equals(:olive, x), succeed), equals(:oil, x)))
+          expect(result).to eq(cons(:olive, cons(:oil)))
+        end
+
+        it 'passes frame 1:64' do
+          # Reasoned S2, frame 1:64
+          # (run* x (disj2
+          #           (== 'oil x)
+          #           (conj2 (== 'olive x) succeed))) ;; => (oil olive)
+
+          result = run_star('x', disj2(equals(:oil, x), conj2(equals(:olive, x), succeed)))
+          expect(result).to eq(cons(:oil, cons(:olive)))
+        end
+
+        it 'passes frame 1:65' do
+          # Reasoned S2, frame 1:65
+          # (run* x (disj2
+          #           (conj2(== 'virgin x) fail)
+          #           (disj2
+          #             (== 'olive x)
+          #             (dis2
+          #               succeed
+          #               (== 'oil x))))) ;; => (olive _0 oil)
+
+          result = run_star('x', disj2(conj2(equals(:virgin, x), _fail),
+                            disj2(equals(:olive, x), disj2(succeed, equals(:oil, x)))))
+          expect(result).to eq(cons(:olive, cons(:_0, cons(:oil))))
+        end
+
+        it 'passes frame 1:67' do
+          # Reasoned S2, frame 1:67
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #           (== 'split x)
+          #           (conj2
+          #             (== 'pea y)
+          #             (== '(,x ,y) r)))))) ;; => ((split pea))
+
+          result = run_star('r', fresh('x', fresh('y',
+            conj2(equals(:split, x), conj2(
+              equals(:pea, y), equals(cons(x, cons(y)), r))))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:68' do
+          # Reasoned S2, frame 1:68
+          # (run* r
+          #   (fresh x
+          #     (fresh y
+          #       (conj2
+          #         (conj2
+          #           (== 'split x)
+          #           (== 'pea y)
+          #         (== '(,x ,y) r)))))) ;; => ((split pea))
+
+          result = run_star('r', fresh('x', fresh('y',
+            conj2(conj2(equals(:split, x), equals(:pea, y)),
+              equals(cons(x, cons(y)), r)))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:70' do
+          # Reasoned S2, frame 1:70
+          # (run* r
+          #   (fresh (x y)
+          #     (conj2
+          #       (conj2
+          #         (== 'split x)
+          #         (== 'pea y)
+          #       (== '(,x ,y) r))))) ;; => ((split pea))
+
+          result = run_star('r', fresh(%w[x y], conj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            equals(cons(x, cons(y)), r))))
+          expect(result).to eq(cons(cons(:split, cons(:pea))))
+        end
+
+        it 'passes frame 1:72' do
+          # 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 = run_star(%w[r x y], conj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            equals(cons(x, cons(y)), r)))
+          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 'passes frame 1:75' do
+          # Reasoned S2, frame 1:75
+          # (run* (x y)
+          #   (conj2
+          #     (== 'split x)
+          #     (== 'pea y))) ;; => ((split pea))
+
+          result = run_star(%w[x y], conj2(equals(:split, x), equals(:pea, y)))
+          expect(result.car.car).to eq(:split)
+          expect(result.car.cdr.car).to eq(:pea)
+        end
+
+        it 'passes frame 1:76' do
+          # Reasoned S2, frame 1:76
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (== 'split x) (== 'pea y))
+          #     (conj2 (== 'red x) (== 'bean y)))) ;; => ((split pea)(red bean))
+
+          result = run_star(%w[x y], disj2(
+            conj2(equals(:split, x), equals(:pea, y)),
+            conj2(equals(:red, x), equals(:bean, y))))
+          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 'passes frame 1:77' do
+          # 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 = run_star('r',
+            fresh(%w[x y], conj2(
+              disj2(
+                conj2(equals(:split, x), equals(:pea, y)),
+                conj2(equals(:red, x), equals(:bean, y))),
+              equals(cons(x, cons(y, cons(:soup))), r))))
+          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 'passes frame 1:78' do
+          # 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 = run_star('r',
+            fresh(%w[x y], [disj2(
+                conj2(equals(:split, x), equals(:pea, y)),
+                conj2(equals(:red, x), equals(:bean, y))),
+              equals(cons(x, cons(y, cons(:soup))), r)]))
+          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 'passes frame 1:80' do
+          # 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 = run_star(%w[x y z], [disj2(
+                conj2(equals(:split, x), equals(:pea, y)),
+                conj2(equals(:red, x), equals(:bean, y))),
+              equals(:soup, z)])
+          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 'passes frame 1:81' do
+          # Reasoned S2, frame 1:81
+          # (run* (x y)
+          #   (== 'split x)
+          #   (== 'pea y)) ;; => ((split pea))
+
+          result = run_star(%w[x y], [equals(:split, x), equals(:pea, y)])
+          expect(result.car.car).to eq(:split)
+          expect(result.car.cdr.car).to eq(:pea)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -244,7 +244,7 @@ module MiniKraken
           instance = RunStarExpression.new('q', goal)
 
           # Reasoned S2, frame 1:34
-          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pod)
+          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pea)
           result = instance.run
           expect(result.car).to eq(pea)
         end
@@ -363,7 +363,6 @@ module MiniKraken
           expect(result.car).to eq(any_value(0))
         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)
@@ -481,7 +480,7 @@ module MiniKraken
           # Reasoned S2, frame 1:62
           # (run* x (disj2
           #           (conj2 (== 'olive x) fail)
-          #           ('oil x))) ;; => (oil)
+          #           (== 'oil x))) ;; => (oil)
           result = instance.run
           expect(result.car).to eq(oil)
         end
@@ -511,7 +510,7 @@ module MiniKraken
 
           # Reasoned S2, frame 1:64
           # (run* x (disj2
-          #           ('oil x)
+          #           (== 'oil x)
           #           (conj2 (== 'olive x) succeed))) ;; => (oil olive)
           result = instance.run
           expect(result.car).to eq(oil)
@@ -530,11 +529,11 @@ module MiniKraken
 
           # Reasoned S2, frame 1:65
           # (run* x (disj2
-          #           (conj2(== 'virgin x) fails)
+          #           (conj2(== 'virgin x) fail)
           #           (disj2
           #             (== 'olive x)
           #             (dis2
-          #               succeeds
+          #               succeed
           #               (== 'oil x))))) ;; => (olive _0 oil)
           result = instance.run
           expect(result.car).to eq(olive)
@@ -649,7 +648,7 @@ module MiniKraken
           expect(result.car.cdr.cdr.cdr).to be_nil
         end
 
-        it 'should allow simplication of expressions' do
+        it 'should allow simplification of expressions' do
           expr1 = equals_goal(split, ref_x)
           expr2 = equals_goal(pea, ref_y)
           goal = conj2_goal(expr1, expr2)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.2.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2020-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,6 +104,7 @@ files:
 - lib/mini_kraken/core/variable.rb
 - lib/mini_kraken/core/variable_ref.rb
 - lib/mini_kraken/core/vocabulary.rb
+- lib/mini_kraken/glue/dsl.rb
 - lib/mini_kraken/glue/fresh_env.rb
 - lib/mini_kraken/glue/run_star_expression.rb
 - lib/mini_kraken/version.rb
@@ -128,6 +129,7 @@ files:
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb
 - spec/core/vocabulary_spec.rb
+- spec/glue/dsl_chap1_spec.rb
 - spec/glue/fresh_env_spec.rb
 - spec/glue/run_star_expression_spec.rb
 - spec/mini_kraken_spec.rb
@@ -178,6 +180,7 @@ test_files:
 - spec/core/variable_ref_spec.rb
 - spec/core/variable_spec.rb
 - spec/core/vocabulary_spec.rb
+- spec/glue/dsl_chap1_spec.rb
 - spec/glue/fresh_env_spec.rb
 - spec/glue/run_star_expression_spec.rb
 - spec/mini_kraken_spec.rb