rubylog 1.0.0 → 2.0pre1

data/logic/builtins/reflection_logic.rb

@@ -1,40 +0,0 @@
-require "./lib/rubylog/builtins/reflection.rb"
-
-theory do
-  functor_for String, :likes, :drinks
-
-  # fact
-  "John".likes! "beer"
-  check "John".likes("beer").fact
-  check { A.likes(B).fact.map{A.likes(B)} == ["John".likes("beer")] }
-
-  # follows_from
-  A.drinks(B).if A.likes(B)
-  check A.drinks(B).follows_from A.likes(B)
-  check {A.drinks(B).follows_from(K).map{K} == [A.likes(B)] }
-
-  # structure
-  check A.likes(B).structure(:likes, [A,B])
-  check { A.likes(B).structure(X,Y).map{[X,Y]} == [[:likes, [A,B]]] }
-
-  # structures with variable functor and partial argument list
-  check { K.structure(:drinks, ["John", "beer"]).map{K} == ["John".drinks("beer")] }
-  check { K.structure(A,[*B]).
-    and(A.is(:drinks)).
-    and(B.is(["John","beer"])).
-    map{K} == ["John".drinks("beer")] }
-
-  # variable
-  # Removed because of the "every built-in prediate is pure logical" principle
-  #check A.variable("A")
-  #check A.variable("B").false
-  #check { A.variable(B).map{B} == ["A"] }
-  # You can use the fact that automatic variable resolution yields nil if the
-  # variable is undefined:
-  #
-  #     check A.is(ANY).and{ A }.false
-  #     check A.is(ANY).and{ not A }
-  #
-
-
-end

data/logic/dereference_logic.rb

@@ -1,23 +0,0 @@
-theory do
-  functor_for Integer, :divides
-
-  check { A.is_a? Rubylog::Variable }
-  check { A.rubylog_deep_dereference == A }
-
-  a = A
-  check { a.rubylog_deep_dereference.equal? a }
-
-  a.rubylog_unify(4) do
-    check { a.rubylog_deep_dereference == 4 }
-    check { [1,a].rubylog_deep_dereference == [1,4] }
-    check { a.divides(16).rubylog_deep_dereference == 4.divides(16) }
-  end
-
-  b = []
-  check { not b.rubylog_deep_dereference.equal? b }
-
-  c = Object.new
-  check { c.rubylog_deep_dereference.equal? c }
-end
-
-

data/logic/dsl_logic.rb

@@ -1,29 +0,0 @@
-theory do
-
-  # prefix functors
-
-  prefix_functor :we_have
-  we_have! :weapons
-  we_have! :sunglasses
-  we_have! :rustling_leather_coats
-
-  check we_have :sunglasses
-  check { we_have? :rustling_leather_coats }
-
-  
-  # built-in prefix functors
-  
-  check all X.is(4).and(Y.is(X)), Y.is(4)
-  check any X.is(4)
-  check one(X.in([1,2,3])) { X % 2  == 0 }
-  check none X.in([1,2,3]), X.is(5)
-
-  check { all?(X.is(4)) { X < 5 } }
-
-  # variables
-  check A.is(ANY).and{ A == nil }
-  check A.is(4)  .and{ A == 4 }
-  check B.is(4)  .and{ A.is_a? Rubylog::Variable }
-  check B.is(ANY).and{ A.is_a? Rubylog::Variable }
-
-end

data/logic/errors_logic.rb

@@ -1,9 +0,0 @@
-theory do
-  functor_for String, :happy, :has
-
-  # syntax error
-  check { begin "John".happy.if; rescue Rubylog::SyntaxError; true else false end }
-  check { begin "John".happy.if!; rescue Rubylog::SyntaxError; true else false end }
-  check { begin "John".happy.unless; rescue Rubylog::SyntaxError; true else false end }
-
-end

data/logic/guard_logic.rb

@@ -1,115 +0,0 @@
-theory do
-  
-  # class guard
-  functor_for Numeric, :divides
-  A[Integer].divides(B[Integer]).if { B % A == 0 }
-  A[Float].divides!(B[Float])
-  check 2.divides(10)
-  check 2.divides(9).false
-  check 2.divides(1).false
-  check 2.divides(0)
-  check 2.12.divides(4.5)
-  check -0.31.divides(-1.5)
-  check 0.3.divides(3).false
-  check 2.0.divides(10).false
-  check 2.divides(10.0).false
-  check 2.divides(9.0).false
-
-  # union of guards at compile
-  functor_for Numeric, :small
-  A[0...100].small.if ANY.is A[Integer]
-  check 0.small
-  check 10.small
-  check -1.small.false
-  check 0.0.small.false
-  check 99.small
-  check 99.0.small.false
-  check 99.9.small.false
-  check 100.small.false
-  check 100.0.small.false
-
-  # union of guards at compile (dont-care)
-  functor_for Numeric, :small
-  A[0...100].small.if A.is ANY[Integer]
-  check 0.small
-  check 10.small
-  check -1.small.false
-  check 0.0.small.false
-  check 99.small
-  check 99.0.small.false
-  check 99.9.small.false
-  check 100.small.false
-  check 100.0.small.false
-  
-  # union of guards at unification
-  self[[:small,1]].clear
-  functor_for Numeric, :small
-  A[0...100].small.if A.is B[Integer]
-  check 0.small
-  check 10.small
-  check -1.small.false
-  check 0.0.small.false
-  check 99.small
-  check 99.0.small.false
-  check 99.9.small.false
-  check 100.small.false
-  check 100.0.small.false
-
-  # union of guards at unification (reversed)
-  self[[:small,1]].clear
-  functor_for Numeric, :small
-  A[0...100].small.if B[Integer].is A
-  check 0.small
-  check 10.small
-  check -1.small.false
-  check 0.0.small.false
-  check 99.small
-  check 99.0.small.false
-  check 99.9.small.false
-  check 100.small.false
-  check 100.0.small.false
-
-
-  # proc guards
-  functor_for Numeric, :big
-  A[proc{|a|a > 20}].big!
-  check -100.big.false
-  check 0.big.false
-  check 10.big.false
-  check 20.big.false
-  check 21.big
-  check 200.big
-
-  # hash guards
-  functor_for String, :char
-  S[length: 1].char!
-  check "a".char
-  check " ".char
-  check "".char.false
-  check "af".char.false
-  check "Hello".char.false
-
-  # list hash guards
-  functor_for String, :capitalized
-  S[[:[],0] => /[A-Z]/].capitalized!
-  check "a".capitalized.false
-  check " ".capitalized.false
-  check "".capitalized.false
-  check "af".capitalized.false
-  check "A".capitalized
-  check "Hello".capitalized
-
-
-  # chained hash guards
-  functor_for String, :funny
-  S[upcase: {[:[],1..-2] => "ELL"}].funny!
-  check "hello".funny
-  check "Bell!".funny
-  check "BELL!".funny
-  check "DELL".funny.false
-  check "help!".funny.false
-  check "hello!".funny.false
-
-
-
-end

data/logic/list_logic.rb

@@ -1,55 +0,0 @@
-theory do
-  check [1,2,3].is [1,2,3]
-  check {[1,2,3].is([A,B,C]).map{[A,B,C]} == [[1,2,3]]}
-  check [].is []
-
-  check [1,2,3].is_not [1,2,4]
-  check [1,2,3].is_not [1,2]
-  check [1,2,3].is_not [1,ANY]
-  check [1,2,3].is [1,2,ANY]
-
-  # splats
-  check { [1,2,3].is([1,*A]).map{A} == [[2,3]] }
-  check [].is_not [A,*ANY]
-  check [].is [*ANY]
-  check [2].is [2, *ANY]
-  check [2, *ANY].is [2]
-  check [1,2].is([A,*B]).and A.is(1).and B.is([2])
-
-  # [*A] = [*B]
-  check {[*A].is([*B]).and A.is([1,2]).map{B} == [[1,2]]}
-  check [*A].is [*B]
-  check { [*A].is([*B]).each { } } # no infinite recursion
-
-
-  # append
-  check {[1,2,3].is([*A,*B]).map{[A,B]} == [[[],[1,2,3]],[[1],[2,3]],[[1,2],[3]],[[1,2,3],[]]] }
-  check [1,2,3].is [Rubylog::DSL::ArraySplat.new([1,2]),*ANY]
-  check [1,2,3].is [Rubylog::DSL::ArraySplat.new([1,2,3]),*ANY]
-  check [1,2,3].is_not [Rubylog::DSL::ArraySplat.new([1,2,3,B]),*ANY]
-  
-  # member
-  check [1,2,3].is [*ANY,2,*ANY]
-  check X.is([1,2,3]).and A.in(X).all X.is [*ANY,A,*ANY]
-
-  # palindromes
-  functor_for Array, :palindrome
-  [].palindrome!
-  [ANY].palindrome!
-  [A,*X,A].palindrome.if X.palindrome
-  check X.in([[], [1], [1,1], [1,2,1], [1,2,2,1], [1,2,3,2,1], [1,2,3,3,2,1]]).all X.palindrome
-  check X.in([[1,2], [1,3,4,1], [2,2,5]]).none X.palindrome
-
-  # legacy syntax
-  check { [1,2,3].is([1]+A).map{A} == [[2,3]] }
-  check [].is_not [A]+ANY
-  check [].is []+ANY
-  check [2].is [2]+ANY
-  check(([2]+ANY).is [2])
-  check [1,2].is([A]+B).and A.is(1).and B.is([2])
-  check {([]+A).is([]+B).and A.is([1,2]).map{B} == [[1,2]]}
-  check(([]+A).is([]+B))
-  check {([]+A).is([]+B).each { } }
-  check {[1,2,3].is([]+A+B).map{[A,B]} == [[[],[1,2,3]],[[1],[2,3]],[[1,2],[3]],[[1,2,3],[]]] }
-  check X.is([1,2,3]).and A.in(X).all X.is []+ANY+[A]+ANY
-end

data/logic/map_logic.rb

@@ -1,15 +0,0 @@
-theory "Rubylog::MapLogic" do
-  functor :likes
-  subject Symbol
-
-  # inriausite^findall
-  check S.is{X.is(1).or(X.is(2)).map{X}}.and{S == [1,2]}
-  check S.is{X.is(:john).map{X.likes(Y)}}.and{S == [:john.likes(Y)]}
-  check G.is(:fail.or :fail).and L.is{G.map{X}}.and{L == []}
-  check S.is{X.is(1).or(X.is(1)).map{X}}.and{S == [1,1]}
-  check [1,2].is{X.is(2).or(X.is(1)).map{X}}.false
-  check [X,Y].is{A.is(1).or(A.is(2)).map{A}}.and{X == 1}.and{Y == 2}
-  (S.is {Goal.map{X}}).solve and check :fail rescue NoMethodError
-  (S.is {4.map{X}}).solve and check :fail rescue NoMethodError
-end
-

data/logic/multitheory.rb

@@ -1,23 +0,0 @@
-load "lib/rubylog/theory.rb"
-A = theory do
-  functor_for Symbol, :good
-
-  :x.good!
-end
-
-B = theory do
-  :y.good!
-end
-
-theory do
-  multitheory [:good,1]
-
-  check { self[[:good,1]].multitheory? }
-
-  include A
-  include B
-
-  check { self[[:good,1]].multitheory? }
-
-  check {X.good.map{X} == [:x,:y]}
-end

data/logic/recursion_logic.rb

@@ -1,12 +0,0 @@
-theory do
-  functor_for Integer, :factorial 
-  0.factorial! 1
-  N.factorial(K).if proc{N > 0}.and N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }
-
-  check 0.factorial 1
-  check 1.factorial 1
-  check 2.factorial 2
-  check 3.factorial 6
-  check 4.factorial 24
-  check 7.factorial 5040
-end

data/logic/string_logic.rb

@@ -1,41 +0,0 @@
-theory do
-  check "asdf".is "asdf"
-  check { "abc#{S}def" =~ /abc.S\[\].def/ }
-  check { "abc#{S[length: 1]}def" =~ /abc.S\[\d+\].def/ }
-  check { "h#{S}o".is("hello").map{S} == ["ell"] }
-  check { "#{Base}.#{Ext}".is("hello.rb").map{Base} == ["hello"] }
-  
-  check { "#{Base}.#{Ext}".is("hello.rb").map{Ext} == ["rb"] }
-  check { "h#{S}o".is("auto").map{S} == [] }
-
-  # backtracked matches
-  check { "abc".is("#{A}#{B}").map{"#{A}:#{B}"} == [":abc","a:bc","ab:c","abc:"] }
-  check { "www.google.com".is("#{A}.#{B}").map{[A,B]} == [["www", "google.com"],["www.google", "com"]] }
-  check { "a".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == ["::a",":a:","a::"] }
-  check { "ab".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == %w(::ab :a:b :ab: a::b a:b: ab::) }
-
-  # guards
-  check { "abc".is("#{A[/\A.\z/]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
-  check { "abc".is("#{A[length: 1]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
-
-
-  # palindromes
-  functor_for String, :palindrome
-
-  S[empty?: true].palindrome!
-  S[length: 1].palindrome!
-  S[lambda{|s|s.length > 1}].palindrome.if S.is("#{A[length: 1]}#{B}#{A}").and B.palindrome
-
-  check "".palindrome
-  check "dd".palindrome
-  check "aba".palindrome
-  check "faaf".palindrome
-  check "ffaaff".palindrome
-  check "rererer".palindrome
-  check "lol".palindrome
-  check "ji".palindrome.false
-  check "doo".palindrome.false
-  check "taaaz".palindrome.false
-  check "faad".palindrome.false
-  check "rerere".palindrome.false
-end

data/logic/thats_logic.rb

@@ -1,51 +0,0 @@
-require "./lib/rubylog/builtins/file_system"
-
-theory do
-  functor_for Integer, :factorial
-
-  # one level
-  check 4.is(ANY[Integer,thats < 10])
-  check 4.is(ANY[Integer,thats < 5])
-  check 4.is(ANY[Integer,thats < 4]).false
-  check 4.is(ANY[Integer,thats < 2]).false
-
-  # question mark
-  check "".is(ANY[thats.empty?])
-  check "a".is(ANY[thats.empty?]).false
-
-  # two levels
-  check "hello".is(ANYTHING[thats.reverse == "olleh"])
-  check "hello".is(ANYTHING[thats.reverse == "olle"]).false
-
-  # four levels
-  check "hello".is(ANY[thats.upcase.partition("E")[0] == "H"])
-  check "hello".is(ANY[thats.upcase.partition("E")[1] == "E"])
-  check "hello".is(ANY[thats.upcase.partition("E")[2] == "LLO"])
-  check "hello".is(ANY[thats.upcase.partition("E")[1] == "H"]).false
-  check "hello".is(ANY[thats.upcase.partition("E")[0] == "h"]).false
-  check "hello".is(ANY[thats.upcase.partition("L")[0] == "H"]).false
-  check "hello".is(ANY[thats.upcase.partition("e")[0] == "H"]).false
-
-  # files
-  check {     "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
-  check { not "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? "lib" }
-  check { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S} == ["rubylog.rb"] }
-
-  # factorial
-  0.factorial! 1
-  K[thats > 0].factorial(N).if K0.is{K-1}.and K0.factorial(N0).and N.is{N0*K}
-
-  # palindrome
-  functor_for String, :palindrome 
-  S[String, thats.length <= 1].palindrome!
-  "#{A[thats.length == 1]}#{B}#{A}".palindrome.if B.palindrome
-
-  check "a".palindrome
-  check "aa".palindrome
-  check "aga".palindrome
-  check "aaa".palindrome
-  check "avava".palindrome
-  check "ab".palindrome.false
-  check "abb".palindrome.false
-  check "abab".palindrome.false
-end

data/logic/variable_logic.rb

@@ -1,24 +0,0 @@
-theory do
-  # dont-care variables case insensitive ANY* and _*
-  check 3.is(ANY).and 3.is(ANY)
-  check 3.is(ANY).and 4.is(ANY)
-  check 3.is(ANYTHING).and 3.is(ANYTHING)
-  check 3.is(ANYTHING).and 4.is(ANYTHING)
-  check 3.is(Anything).and 3.is(Anything)
-  check 3.is(Anything).and 4.is(Anything)
-  check 3.is(Rubylog::Variable.new(:_var1)).and(3.is(Rubylog::Variable.new(:_var1)))
-  check 3.is(Rubylog::Variable.new(:_var1)).and(4.is(Rubylog::Variable.new(:_var1)))
-  check 3.is(Rubylog::Variable.new(:var1 )).and(3.is(Rubylog::Variable.new(:var1 )))
-  check 3.is(Rubylog::Variable.new(:var1 )).and(4.is(Rubylog::Variable.new(:var1 ))).false
-
-  # dont-care variables support recursion
-  functor_for Integer, :factorial 
-  0.factorial! 1
-  N.factorial(K).if proc{N > 0}.and N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }.and K.is(ANY1).and N.is(ANY2)
-  check 0.factorial 1
-  check 1.factorial 1
-  check 2.factorial 2
-  check 3.factorial 6
-  check 4.factorial 24
-  check 7.factorial 5040
-end

data/spec/bartak_guide_spec.rb

@@ -1,86 +0,0 @@
-#!/usr/bin/env ruby
-# These are the rubylog transcripts of prolog codes from Roman Barták's Prolog
-# guide: http://kti.mff.cuni.cz/~bartak/prolog/
-
-require 'rubylog'
-
-
-theory "Genealogy" do
-  subject Symbol
-  functor :man, :woman
-
-  :adam.man!
-  :peter.man!
-  :paul.man!
-
-  :marry.woman!
-  :eve.woman!
-end
-
-__END__
-theory "Lists" do
-  functor_for Object, :head_of
-  functor_for Array, :tail_of
-
-  H.head_of(A).if A.splits_to(H,ANY)
-  T.tail_of(A).if A.splits_to(ANY,T)
-
-  2.should be_head_of [2,3,4]
-  2.should be_head_of [2]
-  2.should_not be_head_of [1]
-  2.should_not be_head_of []
-
-  [3,4].should be_tail_of [2,3,4]
-  [].   should be_tail_of [1]
-
-  Object.rubylog_functor :member_of
-
-  M.member_of(A).if A.splits_to(M,ANY)
-  M.member_of(A).if A.splits_to(ANY,T).and M.member_of(T)
-
-  0.should_not be_member_of [1,2,3]
-  1.should     be_member_of [1,2,3]
-  2.should     be_member_of [1,2,3]
-  3.should     be_member_of [1,2,3]
-  4.should_not be_member_of [1,2,3]
-
-  Object.rubylog_functor :first_of, :last_of
-
-  F.first_of(A).if A.splits_to(F,ANY)
-  L.last_of(A).if A.splits_to(L,[])
-  L.last_of(A).if A.splits_to(H,T).and L.last_of(T)
-
-  1.should be_first_of [1,2,3]
-  3.should_not be_last_of  []
-  3.should be_last_of  [3]
-  3.should be_last_of  [2,3]
-  3.should be_last_of  [1,2,3]
-  1.should_not be_last_of [1,2,3]
-
-  Array.rubylog_functor :prefix_of
-
-  [].prefix_of! ANY_LIST
-  A.prefix_of(B).if A.splits_to(H,TA).and B.splits_to(H,TB).and TA.prefix_of(TB)
-
-  [1,2,3].should be_prefix_of [1,2,3]
-end
-
-
-describe "How does it work?" do
-
-  specify "declarative character" do
-    (1.in? [1,2,3]).should be_true
-    (X.in [1,2,3]).to_a.should == [1,2,3]
-    (1.in [X,Y]).to_a.should == [[1,nil], [nil,1]]
-    lists = []
-    (1.in L).each do |l|
-      lists << l
-      break if lists.size == 3
-    end
-    #lists.should == [[1], [nil,1], [nil,nil,1]]
-  end
-end
-
-end
-end
-

data/spec/builtins/all_spec.rb

@@ -1,99 +0,0 @@
-
-      describe "all,any,one,none" do
-        before do
-          :john.likes! :water
-          :john.likes! :beer
-
-          :jane.likes! :water
-          :jane.likes! :milk
-          :jane.likes! :beer
-
-          :jeff.likes! :water
-          :jeff.likes! :absinth
-
-          :todd.likes! :milk
-
-          @predicates = [:all, :any, :one, :none]
-          @names = :john, :jane, :jeff, :todd
-          @good =
-            [
-              [[1,1,0,0], [0,1,0,0], [0,0,1,0], [0,1,0,1]], # all
-              [[1,1,1,0], [1,1,1,1], [1,1,1,0], [0,1,0,1]], # any
-              [[0,0,1,0], [0,0,1,1], [1,1,0,0], [0,1,0,1]], # one
-              [[0,0,0,1], [0,0,0,0], [0,0,0,1], [1,0,1,0]]  # none
-            ]
-        end
-
-        it "work" do
-          @predicates.map{|p| @names.map{|n| @names.map{|m| 
-            (n.likes(K).send p, m.likes(K)).true? ? 1 : 0
-          }}}.should == @good
-        end
-
-        it "mimic well enumerators' predicates" do
-          @predicates.map{|p| @names.map{|n| @names.map{|m|
-            n.likes(K).to_a.send(:"#{p}?"){|x| m.likes?(x) } ? 1 : 0
-          }}}.should == @good
-        end
-
-
-        
-        it "all works" do
-          (:john.likes(X).all(:john.likes(X))).should stand
-          (:john.likes(X).all(:jane.likes(X))).should stand
-          (:john.likes(X).all(:jeff.likes(X))).should_not stand
-          (:john.likes(X).all(:todd.likes(X))).should_not stand
-
-          (:jane.likes(X).all(:john.likes(X))).should_not stand
-          (:jane.likes(X).all(:jane.likes(X))).should stand
-          (:jane.likes(X).all(:jeff.likes(X))).should_not stand
-          (:jane.likes(X).all(:todd.likes(X))).should_not stand
-
-          (:jeff.likes(X).all(:john.likes(X))).should_not stand
-          (:jeff.likes(X).all(:jane.likes(X))).should_not stand
-          (:jeff.likes(X).all(:jeff.likes(X))).should stand
-          (:jeff.likes(X).all(:todd.likes(X))).should_not stand
-
-          (:todd.likes(X).all(:john.likes(X))).should_not stand
-          (:todd.likes(X).all(:jane.likes(X))).should stand
-          (:todd.likes(X).all(:jeff.likes(X))).should_not stand
-          (:todd.likes(X).all(:todd.likes(X))).should stand
-        end
-
-        it "can be called with global functor syntax" do
-          extend Rubylog::DSL::GlobalFunctors
-          all(:john.likes(X), :jane.likes(X)).should stand
-          all(:jane.likes(X), :john.likes(X)).should_not stand
-          any(:jane.likes(X), :todd.likes(X)).should stand
-          any(:john.likes(X), :todd.likes(X)).should_not stand
-        end
-
-        it "can be called unarily" do
-          extend Rubylog::DSL::GlobalFunctors
-          one(:john.likes(X)).should_not stand
-          one(:jane.likes(X)).should_not stand
-          one(:jeff.likes(X)).should_not stand
-          one(:todd.likes(X)).should stand
-          one(:jim.likes(X)).should_not stand
-
-          any(:john.likes(X)).should stand
-          any(:jane.likes(X)).should stand
-          any(:jeff.likes(X)).should stand
-          any(:todd.likes(X)).should stand
-          any(:jim.likes(X)).should_not stand
-
-          all(:john.likes(X)).should stand
-          all(:jane.likes(X)).should stand
-          all(:jeff.likes(X)).should stand
-          all(:todd.likes(X)).should stand
-          all(:jim.likes(X)).should stand
-
-          none(:john.likes(X)).should_not stand
-          none(:jane.likes(X)).should_not stand
-          none(:jeff.likes(X)).should_not stand
-          none(:todd.likes(X)).should_not stand
-          none(:jim.likes(X)).should stand
-        end
-      end
-
-    end

data/spec/builtins/and_spec.rb

@@ -1,22 +0,0 @@
-
-      describe "and" do
-        it "works 1" do
-          :john.happy.if :fail.and :true
-          :john.should_not be_happy
-        end
-
-        it "works 2" do
-          :john.happy.if :true.and :fail
-          :john.should_not be_happy
-        end
-
-        it "works 3" do
-          :john.happy.if :fail.and :fail
-          :john.should_not be_happy
-        end
-
-        it "works 4" do
-          :john.happy.if :true.and :true
-          :john.should be_happy
-        end
-      end

data/spec/builtins/array_spec.rb

@@ -1,16 +0,0 @@
-
-    describe "Array" do
-      it "can be unified" do
-        result = false
-        [A,B].rubylog_unify(12) { result = true }
-        result.should == false
-
-        result = false
-        [A,B].rubylog_unify([12,13]) { result = true }
-        result.should == true
-
-        result = false
-        [14,B].rubylog_unify([12,13]) { result = true }
-        result.should == false
-      end
-    end