micro_kanren 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56f3ef35a8ec5353160ad27cc8f00f6515a8f02c
-  data.tar.gz: 12def3bc0db39c98206386359ae92707209abca2
+  metadata.gz: 2a030efb3f7fd274fb7d90dc8d7b6f41c41afa28
+  data.tar.gz: 029ae9516a117f18ca88d6b864c9fadfbb7929e3
 SHA512:
-  metadata.gz: e82a29102bc5b11474280e2320a8ca3771208859167595dd10b16e1897c705001257bb92006057729f2900f1702974fe9a1eaf3eb2c5c9213bf5d415c4e4f711
-  data.tar.gz: c09e905aab95d68c69dd2576d39ebc985d53bf9947c36120143b2d00a18a9ad321bc58fa2ab4b30d9f5c57d765c77127c958543a4176d3dbaa360d3057caf640
+  metadata.gz: 09d106357a9d89c2015521c5b56561f84cf5dd070c0e95940c73a1832ba46d45c80a92db6d41c480f15fc08aed00b55bb27891aca4c3b2d96fa7956807f4be8a
+  data.tar.gz: b282d76b1435bff2969d2de701795c5c2da4ab6003422c362678e08bbf5acaaa090a783499468e7926fe4cea823b6d64e3921622558bd3a1d7fa5af466eb3d5e

data/.travis.yml

@@ -2,5 +2,3 @@ language: ruby
 rvm:
   - 2.1.0
   - 2.0.0
-  - ruby-head
-  - jruby-head

data/README.md

@@ -2,6 +2,13 @@
 
 A port of microKanren, a minimalistic logic programming language, to Ruby.
 
+## Description
+
+This is a port of [microKanren](http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf)
+to Ruby. It is an almost exact translation of
+[the original implementation](https://github.com/jasonhemann/microKanren),
+which was written for [Petite Chez Scheme](http://www.scheme.com/petitechezscheme.html).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -18,16 +25,23 @@ Or install it yourself as:
 
 ## Usage
 
-```ruby
-require 'micro_kanren'
-include MicroKanren::Core
+The following example demonstrates how MicroKanren can be used from the console:
 
-call_fresh(-> (q) { eq(q, 5) }).call(empty_state)
+```ruby
+> require 'micro_kanren'
+> include MicroKanren::Core
+> include MicroKanren::MiniKanrenWrappers
 
-# The result is a set of nested lambda cons cells equivalent to ((([0] . 5 )) . 1)).
+> res = call_fresh(-> (q) { eq(q, 5) }).call(empty_state)
+> puts lprint(res)
+(((([0] . 5)) . 1))
 ```
 
-See the language_spec for more examples.
+See the
+[spec file](https://github.com/jsl/ruby_ukanren/blob/master/spec/micro_kanren/core_spec.rb)
+for more examples. The spec file is almost an exact port of the [microKanren tests
+written in Scheme](https://github.com/jasonhemann/microKanren/blob/master/microKanren-test.scm).
+
 ## Credits
 
 The code in this gem is closely based on the following sources:
@@ -40,8 +54,6 @@ The code in this gem is closely based on the following sources:
   [Scott Vokes' port of microKanren to Lua](https://github.com/silentbicycle/lua-ukanren).
   It was great to have the Lua code as a second example of the implementation in
   the paper, and it made my job especially easy since Lua is so similar to Ruby.
-* Finally, I used the [microKanren examples in Scheme](https://github.com/jasonhemann/microKanren)
-  to see if this port worked as expected.
 
 ## Dependencies
 

data/lib/micro_kanren.rb

@@ -1,3 +1,5 @@
 require "micro_kanren/version"
 require "micro_kanren/lisp"
 require "micro_kanren/core"
+require "micro_kanren/var"
+require "micro_kanren/mini_kanren_wrappers"

data/lib/micro_kanren/core.rb

@@ -2,23 +2,46 @@ module MicroKanren
   module Core
     include Lisp
 
-    def var(*c)       ; Array.new(c)   ; end
-    def var?(x)       ; x.is_a?(Array) ; end
+    def var(*c)       ; Var.new(c)   ; end
+    def var?(x)       ; x.is_a?(Var) ; end
 
-    def vars_eq?(x1, x2) ; x1 == x2    ; end
+    # var=? in Scheme implementation.
+    def vars_eq?(x1, x2) ; x1[0] == x2[0]  ; end
 
-    def mzero ; nil ; end
+    # Walk environment S and look up value of U, if present.
+    def walk(u, s)
+      if var?(u)
+        pr = assp(-> (v) { u == v }, s)
+        pr ? walk(cdr(pr), s) : u
+
+      else
+        u
+      end
+    end
 
     def ext_s(x, v, s)
       cons(cons(x, v), s)
     end
 
+    # Constrain u to be equal to v.
+    # == in Scheme implementation, ≡ in uKanren papers.
+    def eq(u, v)
+      ->(s_c) {
+        s = unify(u, v, car(s_c))
+        s ? unit(cons(s, cdr(s_c))) : mzero
+      }
+    end
+
+    def unit(s_c) ; cons(s_c, mzero) ; end
+    def mzero ; nil ; end
+
     def unify(u, v, s)
       u = walk(u, s)
       v = walk(v, s)
 
       if var?(u) && var?(v) && vars_eq?(u, v)
         s
+
       elsif var?(u)
         ext_s(u, v, s)
 
@@ -26,34 +49,12 @@ module MicroKanren
         ext_s(v, u, s)
 
       elsif pair?(u) && pair?(v)
-        if s = unify(car(u), car(v), s)
-          unify(cdr(u), cdr(v), s)
-        end
-      elsif u == v
-        s
-      end
-    end
-
-    def unit(s_c)
-      cons(s_c, mzero)
-    end
-
-    # Constrain u to be equal to v.
-    def eq(u, v)
-      ->(s_c) {
-        s = unify(u, v, car(s_c))
-        s ? unit(cons(s, cdr(s_c))) : mzero
-      }
-    end
-
-    # Walk environment S and look up value of U, if present.
-    def walk(u, s)
-      if var?(u)
-        pr = assp(-> (v) { u == v }, s)
-        pr ? walk(cdr(pr), s) : u
+        s = unify(car(u), car(v), s)
+        s && unify(cdr(u), cdr(v), s)
 
       else
-        u
+        # Object identity (equal?) seems closest to eqv? in Scheme.
+        u.equal?(v) && s
       end
     end
 
@@ -65,10 +66,18 @@ module MicroKanren
       }
     end
 
+    def disj(g1, g2)
+      -> (s_c) { mplus(g1.call(s_c), g2.call(s_c)) }
+    end
+
+    def conj(g1, g2)
+      -> (s_c) { bind(g1.call(s_c), g2) }
+    end
+
     def mplus(d1, d2)
       if d1.nil?
         d2
-      elsif d1.is_a?(Proc) && !cons_cell?(d1)
+      elsif procedure?(d1)
         -> { mplus(d2, d1.call) }
       else
         cons(car(d1), mplus(cdr(d1), d2))
@@ -78,27 +87,12 @@ module MicroKanren
     def bind(d, g)
       if d.nil?
         mzero
-      elsif d.is_a?(Proc) && !cons_cell?(d)
+      elsif procedure?(d)
         -> { bind(d.call, g) }
       else
         mplus(g.call(car(d)), bind(cdr(d), g))
       end
     end
 
-    def disj(g1, g2)
-      -> (s_c) {
-        mplus(g1.call(s_c), g2.call(s_c))
-      }
-    end
-
-    def conj(g1, g2)
-      -> (s_c) {
-        bind(g1.call(s_c), g2)
-      }
-    end
-
-    def empty_state
-      cons(mzero, 0)
-    end
   end
 end

data/lib/micro_kanren/lisp.rb

@@ -4,15 +4,30 @@ module MicroKanren
     # Returns a Cons cell that is also marked as such for later identification.
     def cons(x, y)
       -> (m) { m.call(x, y) }.tap do |func|
-        func.instance_eval{ def cons_cell? ; true ; end }
+        func.instance_eval{ def ccel? ; true ; end }
       end
     end
 
     def car(z)     ; z.call(-> (p, q) { p }) ; end
     def cdr(z)     ; z.call(-> (p, q) { q }) ; end
 
-    def cons_cell?(d)
-      d.respond_to?(:cons_cell?) && d.cons_cell?
+    def cons?(d)
+      d.respond_to?(:ccel?) && d.ccel?
+    end
+    alias :pair? :cons?
+
+    def map(func, list)
+      cons(func.call(car(list)), map(func, cdr(list))) if list
+    end
+
+    def length(list)
+      list.nil? ? 0 : 1 + length(cdr(list))
+    end
+
+    # We implement scheme cons cells as Procs. This function returns a boolean
+    # identically to the Scheme procedure? function to avoid false positives.
+    def procedure?(elt)
+      elt.is_a?(Proc) && !cons?(elt)
     end
 
     # Search association list by predicate function.
@@ -22,24 +37,57 @@ module MicroKanren
     # Additional reference for this function is scheme:
     # Ref for assp: http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-4.html
     def assp(func, alist)
-      if alist && hd = car(alist)
-        func.call(hd) ? hd : assp(func, cdr(alist))
+      if alist
+        first_pair  = car(alist)
+        first_value = car(first_pair)
+
+        if func.call(first_value)
+          first_pair
+        else
+          assp(func, cdr(alist))
+        end
+      else
+        false
       end
     end
 
-    # A nicer printed representation of nested cons cells represented by Ruby
-    # Procs.
-    def print_ast(node)
-      if cons_cell?(node)
-        ['(', print_ast(car(node)), ' . ', print_ast(cdr(node)), ')'].join
-      else
-        case node
-        when NilClass, Array, String
-          node.inspect
+    # Converts Lisp AST to a String. Algorithm is a recursive implementation of
+    # http://www.mat.uc.pt/~pedro/cientificos/funcional/lisp/gcl_22.html#SEC1238.
+    def lprint(node, cons_in_cdr = false)
+      if cons?(node)
+        str = cons_in_cdr ? '' : '('
+        str += lprint(car(node))
+
+        if cons?(cdr(node))
+          str += ' ' + lprint(cdr(node), true)
         else
-          node.to_s
+          str += ' . ' + lprint(cdr(node)) unless cdr(node).nil?
         end
+
+        cons_in_cdr ? str : str << ')'
+      else
+        atom_string(node)
+      end
+    end
+
+    def lists_equal?(a, b)
+      if cons?(a) && cons?(b)
+        lists_equal?(car(a), car(b)) && lists_equal?(cdr(a), cdr(b))
+      else
+        a == b
       end
     end
+
+    private
+
+    def atom_string(node)
+      case node
+      when NilClass, Array, String
+        node.inspect
+      else
+        node.to_s
+      end
+    end
+
   end
 end

data/lib/micro_kanren/mini_kanren_wrappers.rb

@@ -0,0 +1,63 @@
+module MicroKanren
+  module MiniKanrenWrappers
+    include Lisp
+
+    def empty_state
+      cons(mzero, 0)
+    end
+
+    # Advances a stream until it matures. Per microKanren document 5.2, "From
+    # Streams to Lists."
+    def pull(stream)
+      stream.is_a?(Proc) && !cons?(stream) ? pull(stream.call) : stream
+    end
+
+    def take(n, stream)
+      if n > 0
+        if cur = pull(stream)
+          cons(car(cur), take(n - 1, cdr(cur)))
+        end
+      end
+    end
+
+    def take_all(stream)
+      if cur = pull(stream)
+        cons(car(cur), take_all(cdr(cur)))
+      end
+    end
+
+    def reify_1st(s_c)
+      v = walk_star((var 0), car(s_c))
+      walk_star(v, reify_s(v, nil))
+    end
+
+    def reify_s(v, s)
+      v = walk(v, s)
+      if var?(v)
+        n = reify_name(length(s))
+        cons(cons(v, n), s)
+      elsif pair?(v)
+        reify_s(cdr(v), reify_s(car(v), s))
+      else
+        s
+      end
+    end
+
+    def reify_name(n)
+      "_.#{n}".to_sym
+    end
+
+    def walk_star(v, s)
+      v = walk(v, s)
+      if var?(v)
+        v
+      elsif pair?(v)
+        cons(walk_star(car(v), s),
+             walk_star(cdr(v), s))
+      else
+        v
+      end
+    end
+
+  end
+end

data/lib/micro_kanren/var.rb

@@ -0,0 +1,3 @@
+module MicroKanren
+  class Var < Array ; end
+end

data/lib/micro_kanren/version.rb

@@ -1,3 +1,3 @@
 module MicroKanren
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/micro_kanren/core_spec.rb

@@ -1,61 +1,112 @@
 require 'spec_helper'
 
 describe MicroKanren::Core do
+
   include MicroKanren::Core
+  include MicroKanren::MiniKanrenWrappers
+  include MicroKanren::Lisp
+
+  include MicroKanren::TestPrograms
+  include MicroKanren::TestSupport
+
+  # These tests follow the reference implementation in Scheme located at
+  # https://github.com/jasonhemann/microKanren/blob/master/microKanren-test.scm
+
+  it "second-set t1" do
+    res = car(call_fresh(-> (q) { eq(q, 5) }).call(empty_state))
+    lprint(res).must_equal '((([0] . 5)) . 1)'
+  end
+
+  it "second-set t2" do
+    res = call_fresh(-> (q) { eq(q, 5) }).call(empty_state)
+    cdr(res).must_be_nil
+  end
+
+  it "second-set t3" do
+    res = car(a_and_b.call(empty_state))
+    lprint(res).must_equal '((([1] . 5) ([0] . 7)) . 2)'
+  end
+
+  it "second set t3, take" do
+    res = take(1, (a_and_b.call(empty_state)))
+    lprint(res).must_equal '(((([1] . 5) ([0] . 7)) . 2))'
+  end
+
+  it "second set t4" do
+    res = car(cdr(a_and_b.call(empty_state)))
+    lprint(res).must_equal '((([1] . 6) ([0] . 7)) . 2)'
+  end
+
+  it "second set t5" do
+    cdr(cdr(a_and_b.call(empty_state))).must_be_nil
+  end
+
+  it "who cares" do
+    res = take(1, call_fresh(-> (q) { fives.call(q) }).call(empty_state))
+    lprint(res).must_equal '(((([0] . 5)) . 1))'
+  end
+
+  it "take 2 a_and_b stream" do
+    res = take(2, a_and_b.call(empty_state))
+
+    expected_ast_string =
+      "(((([1] . 5) ([0] . 7)) . 2) ((([1] . 6) ([0] . 7)) . 2))"
+
+    lprint(res).must_equal expected_ast_string
+  end
 
-  describe "#call_fresh" do
-    it "second-set t1" do
-      res = call_fresh(-> (q) { eq(q, 5) }).call(empty_state)
-
-      # The result should be ((([0] . 5 )) . 1)) following the reference
-      # implementation:
-      # https://github.com/jasonhemann/microKanren/blob/master/microKanren-test.scm#L6
-
-      # We don't have a pretty printer for our lambda-conses, so here goes:
-      car(car(car(car(res)))).must_equal [0]
-      cdr(car(res)).must_equal 1
-      cdr(car(car(car(res)))).must_equal 5
-    end
-
-    it "second-set t2" do
-      res = call_fresh(-> (q) { eq(q, 5) }).call(empty_state)
-
-      # Following reference implementation:
-      # https://github.com/jasonhemann/microKanren/blob/master/microKanren-test.scm#L11
-      cdr(res).must_be_nil
-    end
-
-    def a_and_b
-      a = -> (a) { eq(a, 7) }
-      b = -> (b) { disj(eq(b, 5), eq(b, 6)) }
-
-      conj(call_fresh(a), call_fresh(b))
-    end
-
-    it "second-set t3" do
-      res = a_and_b.call(empty_state)
-
-      # The result should be ((([1] . 5) ([0] . 7)) . 2)) following the reference
-      # implementation:
-      # https://github.com/jasonhemann/microKanren/blob/master/microKanren-test.scm#L13
-      car(car(car(car(res)))).must_equal [1]
-      cdr(car(car(car(res)))).must_equal 5
-      car(car(cdr(car(car(res))))).must_equal [0]
-      cdr(car(cdr(car(car(res))))).must_equal 7
-      cdr(car(res)).must_equal 2
-    end
-
-    def fives
-      -> (x) {
-        disj(eq(x, 5), -> (a_c) { -> { fives(x).call(a_c) } })
-      }
-    end
-
-    it "who cares" do # Apparently not the authors of the reference implementation...
-      skip("Create proper assertion for this test")
-      l = -> (q) { fives.call(q) }
-      res = call_fresh(l).call(empty_state)
-    end
+  it "take_all a_and_b stream" do
+    res = take_all(a_and_b.call(empty_state))
+
+    expected_ast_string =
+      "(((([1] . 5) ([0] . 7)) . 2) ((([1] . 6) ([0] . 7)) . 2))"
+
+    lprint(res).must_equal expected_ast_string
+  end
+
+  it "ground appendo" do
+    res = car(ground_appendo.call(empty_state).call)
+
+    # Expected result in scheme:
+    # (((#(2) b) (#(1)) (#(0) . a)) . 3)
+
+    expected_ast_string =
+      '((([2] b) ([1]) ([0] . a)) . 3)'
+
+    lprint(res).must_equal expected_ast_string
+  end
+
+  it "ground appendo2" do
+    res = lprint(car(ground_appendo2.call(empty_state).call))
+    res.must_equal '((([2] b) ([1]) ([0] . a)) . 3)'
+  end
+
+  it "appendo" do
+    res = lprint(take(2, call_appendo.call(empty_state)))
+    res.must_equal '(((([0] [1] [2] [3]) ([2] . [3]) ([1])) . 4) ((([0] [1] [2] [3]) ([2] . [6]) ([5]) ([3] [4] . [6]) ([1] [4] . [5])) . 7))'
+  end
+
+  it "appendo2" do
+    res = lprint(take(2, call_appendo2.call(empty_state)))
+    res.must_equal '(((([0] [1] [2] [3]) ([2] . [3]) ([1])) . 4) ((([0] [1] [2] [3]) ([3] [4] . [6]) ([2] . [6]) ([5]) ([1] [4] . [5])) . 7))'
+  end
+
+  it "reify-1st across appendo" do
+    res = map(method(:reify_1st).to_proc, take(2, call_appendo.call(empty_state)))
+
+    # Expected result in scheme:
+    # ((() _.0 _.0) ((_.0) _.1 (_.0 . _.1)))
+
+    lprint(res).must_equal '((nil _.0 _.0) ((_.0) _.1 (_.0 . _.1)))'
+  end
+
+  it "reify-1st across appendo2" do
+    res = map(method(:reify_1st).to_proc, take(2, call_appendo2.call(empty_state)))
+    lprint(res).must_equal '((nil _.0 _.0) ((_.0) _.1 (_.0 . _.1)))'
+  end
 
+  it "#many non-ans" do
+    res = take(1, many_non_ans.call(empty_state))
+    lprint(res).must_equal '(((([0] . 3)) . 1))'
   end
 end

data/spec/micro_kanren/lisp_spec.rb

@@ -22,32 +22,100 @@ describe MicroKanren::Lisp do
     end
   end
 
+  describe "#length" do
+    it "returns 0 for an empty list" do
+      length(nil).must_equal 0
+    end
+
+    it "returns the list length for a non-empty list" do
+      length(cons(1, cons(2, nil))).must_equal 2
+    end
+  end
+
+  describe "#map" do
+    it "maps a function over a list" do
+      func = -> (str) { str.upcase }
+      lprint(map(func, cons("foo", cons("bar", nil)))).must_equal '("FOO" "BAR")'
+    end
+  end
+
   describe "#assp" do
-    it "returns the first element for which the predicate function is true" do
-      alist = cons(1, cons(2, cons(3, 4)))
-      assp(->(i) { i == 3 }, alist).must_equal 3
+    it "returns the first pair for which the predicate function is true" do
+      al1 = cons(3, cons(:a, nil))
+      al2 = cons(1, cons(:b, nil))
+      al3 = cons(4, cons(:c, nil))
+
+      alist = cons(al1, cons(al2, cons(al3, nil)))
+
+      res = assp(->(i) { i.even? }, alist)
+      lists_equal?(res, cons(4, cons(:c, nil))).must_equal true
+    end
+
+    it "returns false if there is no matching element found" do
+      pair1 = cons(3, cons(:a, nil))
+      pair2 = cons(1, cons(:b, nil))
+      pair3 = cons(4, cons(:c, nil))
+
+      alist = cons(pair1, cons(pair2, cons(pair3, nil)))
+
+      res = assp(->(i) { i == 5 }, alist)
+      res.must_equal false
+    end
+  end
+
+  # http://download.plt-scheme.org/doc/html/reference/pairs.html#(def._((quote._~23~25kernel)._pair~3f))
+  describe "#pair?" do
+    it "is false for an integer" do
+      pair?(1).must_equal false
+    end
+
+    it "is true for a list with an int in the car and cdr" do
+      pair?(cons(1, 2)).must_equal true
+    end
+
+    it "is true for a proper list" do
+      pair?(cons(1, cons(2, nil))).must_equal true
+    end
+
+    it "is false for an empty list" do
+      pair?(nil).must_equal false
     end
   end
 
-  describe "#print_ast" do
+  describe "#lprint" do
+    it "prints an expression correctly" do
+      c = cons(1, cons(2, cons(cons(3, cons(4, nil)), cons(5, nil))))
+      lprint(c).must_equal "(1 2 (3 4) 5)"
+    end
+
     it "prints a cons cell representation of a simple cell" do
-      print_ast(cons('a', 'b')).must_equal '("a" . "b")'
+      lprint(cons('a', 'b')).must_equal '("a" . "b")'
     end
 
     it "represents Integers and Floats" do
-      print_ast(cons(1, 2)).must_equal '(1 . 2)'
+      lprint(cons(1, 2)).must_equal '(1 . 2)'
     end
 
     it "prints a nested expression" do
-      print_ast(cons('a', cons('b', 'c'))).must_equal '("a" . ("b" . "c"))'
+      lprint(cons('a', cons('b', 'c'))).must_equal '("a" "b" . "c")'
     end
 
     it "represents Arrays (in scheme, vectors) correctly in printed form" do
-      print_ast(cons('a', [])).must_equal '("a" . [])'
+      lprint(cons('a', [])).must_equal '("a" . [])'
     end
 
     it "represents nil elements (in scheme, '())" do
-      print_ast(cons('a', nil)).must_equal '("a" . nil)'
+      lprint(cons('a', nil)).must_equal '("a")'
+    end
+  end
+
+  describe "#lists_equal?" do
+    it "is true if the lists are equal" do
+      lists_equal?(cons(1, cons(2, nil)), cons(1, cons(2, nil))).must_equal true
+    end
+
+    it "is false if the lists contain different objects" do
+      lists_equal?(cons(1, cons(2, nil)), cons(1, nil)).must_equal false
     end
   end
 end

data/spec/micro_kanren/mini_kanren_wrappers_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe MicroKanren::MiniKanrenWrappers do
+  include MicroKanren::MiniKanrenWrappers
+  include MicroKanren::Lisp
+
+  describe "#pull" do
+    it "advances the stream until it matures" do
+      stream = -> { -> { 42 } }
+      pull(stream).must_equal 42
+    end
+
+    it "returns nil in the case of the empty stream" do
+      pull(nil).must_be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,3 +3,6 @@ require 'minitest/autorun'
 require "mocha"
 
 require "#{File.dirname(__FILE__)}/../lib/micro_kanren"
+
+require "#{File.dirname(__FILE__)}/test_programs"
+require "#{File.dirname(__FILE__)}/test_support"

data/spec/test_programs.rb

@@ -0,0 +1,100 @@
+module MicroKanren
+  module TestPrograms
+    def a_and_b
+      a = -> (a) { eq(a, 7) }
+      b = -> (b) { disj(eq(b, 5), eq(b, 6)) }
+
+      conj(call_fresh(a), call_fresh(b))
+    end
+
+    def fives
+      -> (x) {
+        disj(eq(x, 5), -> (a_c) { -> { fives(x).call(a_c) } })
+      }
+    end
+
+    def appendo
+      -> (l, s, out) {
+        disj(
+          conj(eq(nil, l), eq(s, out)),
+          call_fresh(-> (a) {
+            call_fresh(-> (d) {
+              conj(
+                eq(cons(a, d), l),
+                call_fresh(-> (res) {
+                  conj(
+                    eq(cons(a, res), out),
+                    -> (s_c) {
+                      -> {appendo.call(d, s, res).call(s_c)}})}))})}))}
+    end
+
+    def appendo2
+      -> (l, s, out) {
+        disj(
+          conj(eq(nil, l), eq(s, out)),
+          call_fresh(-> (a) {
+            call_fresh(-> (d) {
+              conj(
+                eq(cons(a, d), l),
+                call_fresh(-> (res) {
+                  conj(
+                    -> (s_c) {
+                      -> { appendo2.call(d, s, res).call(s_c) }
+                    },
+                    eq(cons(a, res), out))}))})}))}
+    end
+
+    def call_appendo
+      call_fresh(-> (q) {
+        call_fresh(-> (l) {
+          call_fresh(-> (s) {
+            call_fresh(-> (out) {
+              conj(
+                appendo.call(l, s, out),
+                eq(cons(l, cons(s, cons(out, nil))), q))})})})})
+    end
+
+    def call_appendo2
+      call_fresh(-> (q) {
+        call_fresh(-> (l) {
+          call_fresh(-> (s) {
+            call_fresh(-> (out) {
+              conj(
+                appendo2.call(l, s, out),
+                eq(cons(l, cons(s, cons(out, nil))), q))})})})})
+    end
+
+    def ground_appendo
+      appendo.call(cons(:a, nil), cons(:b, nil), cons(:a, cons(:b, nil)))
+    end
+
+    def ground_appendo2
+      appendo2.call(cons(:a, nil), cons(:b, nil), cons(:a, cons(:b, nil)))
+    end
+
+    def relo
+      -> (x) {
+        call_fresh(-> (x1) {
+          call_fresh(-> (x2) {
+            conj(
+              eq(x, cons(x1, x2)),
+              disj(
+                eq(x1, x2),
+                -> (s_c) {
+                  -> { relo.call(x).call(s_c) }
+                }
+              )
+            )
+          })
+        })
+      }
+    end
+
+    def many_non_ans
+      call_fresh(-> (x) {
+        disj(
+          relo.call(cons(5, 6)),
+          eq(x, 3))})
+    end
+  end
+end

data/spec/test_support.rb

@@ -0,0 +1,9 @@
+module MicroKanren
+  module TestSupport
+
+    # Shorthand for declaring a new logic variable.
+    def uvar(v)
+      MicroKanren::Var.new([v])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: micro_kanren
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Justin Leitgeb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-25 00:00:00.000000000 Z
+date: 2014-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,11 +68,16 @@ files:
 - lib/micro_kanren.rb
 - lib/micro_kanren/core.rb
 - lib/micro_kanren/lisp.rb
+- lib/micro_kanren/mini_kanren_wrappers.rb
+- lib/micro_kanren/var.rb
 - lib/micro_kanren/version.rb
 - micro_kanren.gemspec
 - spec/micro_kanren/core_spec.rb
 - spec/micro_kanren/lisp_spec.rb
+- spec/micro_kanren/mini_kanren_wrappers_spec.rb
 - spec/spec_helper.rb
+- spec/test_programs.rb
+- spec/test_support.rb
 homepage: http://github.com/jsl/ruby_ukanren
 licenses:
 - MIT
@@ -100,4 +105,7 @@ summary: uKanren in Ruby
 test_files:
 - spec/micro_kanren/core_spec.rb
 - spec/micro_kanren/lisp_spec.rb
+- spec/micro_kanren/mini_kanren_wrappers_spec.rb
 - spec/spec_helper.rb
+- spec/test_programs.rb
+- spec/test_support.rb