rubylog 2.0.1 → 2.1.0

data/spec/rubylog/mixins/symbol_spec.rb

@@ -1,9 +1,11 @@
 require 'spec_helper'
 
-describe Symbol, :rubylog=>true do
-  it "can be asserted" do
-    predicate ":good"
-    :good.if { true }
-    true?(:good).should be_true
+module RubylogSpec
+  describe Symbol, :rubylog=>true do
+    it "can be asserted" do
+      predicate ":good"
+      :good.if { true }
+      true?(:good).should be_true
+    end
   end
 end

data/spec/rubylog/procedure_spec.rb

@@ -1,11 +1,13 @@
 require "spec_helper" 
 require "rubylog/procedure" 
 
-describe Rubylog::Procedure, rubylog:true do
-  describe "#inspect" do 
-    it "returns a human-readable output" do 
-      predicate_for String, ".likes()"
-      A.likes(B).predicate.inspect.should == ".likes(): []"
+module RubylogSpec
+  describe Rubylog::Procedure, rubylog:true do
+    describe "#inspect" do 
+      it "returns a human-readable output" do 
+        predicate_for String, ".likes()"
+        A.likes(B).predicate.inspect.should == ".likes(): []"
+      end 
     end 
   end 
-end 
+end

data/spec/rubylog/rule_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 require 'rubylog/rule'
 
-describe Rubylog::Rule, rubylog:true do
-  describe "#inspect" do 
-    it "returns a human-readable output" do 
-      predicate_for String, ".likes()"
-      A.likes(B).if B.is(:water)
+module RubylogSpec
+  describe Rubylog::Rule, rubylog:true do
+    describe "#inspect" do 
+      it "returns a human-readable output" do 
+        predicate_for String, ".likes()"
+        A.likes(B).if B.is(:water)
 
-      A.likes(B).predicate[0].inspect.should == "A.likes(B).if(B.is(:water))"
+        A.likes(B).predicate[0].inspect.should == "A.likes(B).if(B.is(:water))"
+      end
     end
-  end
-end 
+  end 
+end

data/spec/rubylog/structure_spec.rb

@@ -1,83 +1,85 @@
 require 'spec_helper'
 
-describe Rubylog::Structure, :rubylog=>true do
+module RubylogSpec
+  describe Rubylog::Structure, :rubylog=>true do
 
-  predicate_for Symbol, ".is_happy .likes()"
+    predicate_for Symbol, ".is_happy .likes()"
 
-  it "can be created" do
-    (:john.is_happy).should be_kind_of Rubylog::Term
-    (:john.likes :beer).should be_kind_of Rubylog::Term
-    (A.likes :beer).should be_kind_of Rubylog::Term
-    (:john.likes Drink).should be_kind_of Rubylog::Term
-    (:john.likes :drinking.in :bar).should be_kind_of Rubylog::Term
-  end
+    it "can be created" do
+      (:john.is_happy).should be_kind_of Rubylog::Term
+      (:john.likes :beer).should be_kind_of Rubylog::Term
+      (A.likes :beer).should be_kind_of Rubylog::Term
+      (:john.likes Drink).should be_kind_of Rubylog::Term
+      (:john.likes :drinking.in :bar).should be_kind_of Rubylog::Term
+    end
 
-  it "forbids non-declared names" do
-    lambda { :john.something_else }.should raise_error(NoMethodError)
-  end
+    it "forbids non-declared names" do
+      lambda { :john.something_else }.should raise_error(NoMethodError)
+    end
 
-  it "can be asked for their functor" do
-    (:john.is_happy).functor.should == :is_happy
-    (:john.likes :drinking.in :bar).functor.should == :likes
-  end
+    it "can be asked for their functor" do
+      (:john.is_happy).functor.should == :is_happy
+      (:john.likes :drinking.in :bar).functor.should == :likes
+    end
 
-  it "can be indexed" do
-    (:john.is_happy)[0].should == :john
-    (:john.likes :beer)[0].should == :john
-    (:john.likes :beer)[1].should == :beer
-    (:john.likes(:cold, :beer))[2].should == :beer
-    (:john.likes(:cold, :beer))[1..2].should == [:cold,:beer]
-    (:john.likes :drinking.in :bar)[1].should == (:drinking.in :bar)
-  end
+    it "can be indexed" do
+      (:john.is_happy)[0].should == :john
+      (:john.likes :beer)[0].should == :john
+      (:john.likes :beer)[1].should == :beer
+      (:john.likes(:cold, :beer))[2].should == :beer
+      (:john.likes(:cold, :beer))[1..2].should == [:cold,:beer]
+      (:john.likes :drinking.in :bar)[1].should == (:drinking.in :bar)
+    end
 
-  it "can be asked for their args" do
-    (:john.is_happy).args.should == [:john]
-    (:john.likes :beer).args.should == [:john, :beer]
-    (:john.likes(:cold, :beer)).args.should == [:john, :cold, :beer]
-    (:john.likes :drinking.in :bar).args.should == [:john, :drinking.in(:bar)]
-  end
-  it "support ==" do
-    (:john.is_happy).should == (:john.is_happy)
-    (:john.is_happy).should_not be_equal(:john.is_happy)
-    (:john.is_happy).should_not == nil
-    (:john.is_happy).should_not == 9
-    (:john.is_happy).should_not == :john
-    (:john.is_happy).should_not == Rubylog
-    (:john.likes :drinking.in :bar).should == (:john.likes :drinking.in :bar)
-  end
-  it "support eql?" do
-    (:john.is_happy).should be_eql(:john.is_happy)
-    (:john.is_happy).should_not be_eql nil
-    (:john.is_happy).should_not be_eql 9
-    (:john.is_happy).should_not be_eql :john
-    (:john.is_happy).should_not be_eql Rubylog
-    (:john.likes :drinking.in :bar).should be_eql(:john.likes :drinking.in :bar)
-  end
-  it "support hash" do
-    (:john.is_happy).hash.should == (:john.is_happy).hash
-    (:john.likes :drinking.in :bar).hash.should == 
-      (:john.likes :drinking.in :bar).hash
-  end
-  it "support inspect" do
-    (:john.is_happy).inspect.should == ":john.is_happy"
-    (:john.likes :beer).inspect.should == ":john.likes(:beer)"
-    (:john.likes :drinking,:beer).inspect.should == ":john.likes(:drinking, :beer)"
-    (:john.likes :drinking.in :bar).inspect.should == ":john.likes(:drinking.in(:bar))"
-  end
-  it "can tell their arity" do
-    (:john.is_happy).arity.should == 1
-    (:john.likes :beer).arity.should == 2
-    (:john.likes :drinking,:beer).arity.should == 3
-    (:john.likes :drinking.in :bar).arity.should == 2
-  end
+    it "can be asked for their args" do
+      (:john.is_happy).args.should == [:john]
+      (:john.likes :beer).args.should == [:john, :beer]
+      (:john.likes(:cold, :beer)).args.should == [:john, :cold, :beer]
+      (:john.likes :drinking.in :bar).args.should == [:john, :drinking.in(:bar)]
+    end
+    it "support ==" do
+      (:john.is_happy).should == (:john.is_happy)
+      (:john.is_happy).should_not be_equal(:john.is_happy)
+      (:john.is_happy).should_not == nil
+      (:john.is_happy).should_not == 9
+      (:john.is_happy).should_not == :john
+      (:john.is_happy).should_not == Rubylog
+      (:john.likes :drinking.in :bar).should == (:john.likes :drinking.in :bar)
+    end
+    it "support eql?" do
+      (:john.is_happy).should be_eql(:john.is_happy)
+      (:john.is_happy).should_not be_eql nil
+      (:john.is_happy).should_not be_eql 9
+      (:john.is_happy).should_not be_eql :john
+      (:john.is_happy).should_not be_eql Rubylog
+      (:john.likes :drinking.in :bar).should be_eql(:john.likes :drinking.in :bar)
+    end
+    it "support hash" do
+      (:john.is_happy).hash.should == (:john.is_happy).hash
+      (:john.likes :drinking.in :bar).hash.should == 
+        (:john.likes :drinking.in :bar).hash
+    end
+    it "support inspect" do
+      (:john.is_happy).inspect.should == ":john.is_happy"
+      (:john.likes :beer).inspect.should == ":john.likes(:beer)"
+      (:john.likes :drinking,:beer).inspect.should == ":john.likes(:drinking, :beer)"
+      (:john.likes :drinking.in :bar).inspect.should == ":john.likes(:drinking.in(:bar))"
+    end
+    it "can tell their arity" do
+      (:john.is_happy).arity.should == 1
+      (:john.likes :beer).arity.should == 2
+      (:john.likes :drinking,:beer).arity.should == 3
+      (:john.likes :drinking.in :bar).arity.should == 2
+    end
 
-  it "can tell their indicator" do
-    (:john.is_happy).indicator.should == [:is_happy,1]
-    (:john.likes :beer).indicator.should == [:likes,2]
-    (:john.likes :drinking,:beer).indicator.should == [:likes,3]
-    (:john.likes :drinking.in :bar).indicator.should == [:likes,2]
-  end
+    it "can tell their indicator" do
+      (:john.is_happy).indicator.should == [:is_happy,1]
+      (:john.likes :beer).indicator.should == [:likes,2]
+      (:john.likes :drinking,:beer).indicator.should == [:likes,3]
+      (:john.likes :drinking.in :bar).indicator.should == [:likes,2]
+    end
 
 
-end
+  end
 
+end 

data/spec/rubylog/term_spec.rb

@@ -1,7 +1,9 @@
 require "spec_helper"
 
-describe "unification", :rubylog=>true do
-  it "uses eql?" do
-    check 5.is_not 5.0
+module RubylogSpec
+  describe "unification", :rubylog=>true do
+    it "uses eql?" do
+      check 5.is_not 5.0
+    end
   end
 end

data/spec/rubylog/tracing_spec.rb

@@ -1,44 +1,46 @@
 require "spec_helper"
 
-describe Rubylog::Tracing, :rubylog=>true do
-  before do
-    @old_argv = ARGV.dup
-    ARGV.replace ["spec/rubylog/tracing_spec.input"]
-    @old_stdout = $stdout
-    $stdout = @output = StringIO.new
-  end
-
-  after do
-    Rubylog.trace?.should == false
-    $stdout = @old_stdout
-    ARGV.replace @old_argv
-  end
-
-  it "can be called with true/false" do
-    Rubylog.trace true
-    1.is(A).solve
-    Rubylog.trace false
-    @output.string.should include "1.is(A).prove()"
-  end
+module RubylogSpec
+  describe Rubylog::Tracing, :rubylog=>true do
+    before do
+      @old_argv = ARGV.dup
+      ARGV.replace ["spec/rubylog/tracing_spec.input"]
+      @old_stdout = $stdout
+      $stdout = @output = StringIO.new
+    end
 
-  it "can be called without true" do
-    Rubylog.trace 
-    1.is(A).solve
-    Rubylog.trace false
-    @output.string.should include "1.is(A).prove()"
-  end
+    after do
+      Rubylog.trace?.should == false
+      $stdout = @old_stdout
+      ARGV.replace @old_argv
+    end
 
-  it "can be called with a block" do
-    Rubylog.trace do
+    it "can be called with true/false" do
+      Rubylog.trace true
       1.is(A).solve
+      Rubylog.trace false
+      @output.string.should include "1.is(A).prove()"
     end
-    @output.string.should include "1.is(A).prove()"
-  end
 
-  it "traces unifications" do
-    Rubylog.trace do
+    it "can be called without true" do
+      Rubylog.trace 
       1.is(A).solve
+      Rubylog.trace false
+      @output.string.should include "1.is(A).prove()"
+    end
+
+    it "can be called with a block" do
+      Rubylog.trace do
+        1.is(A).solve
+      end
+      @output.string.should include "1.is(A).prove()"
+    end
+
+    it "traces unifications" do
+      Rubylog.trace do
+        1.is(A).solve
+      end
+      @output.string.should include "A.bind_to(1)"
     end
-    @output.string.should include "A.bind_to(1)"
   end
 end

data/spec/rubylog/variable_spec.rb

@@ -1,310 +1,312 @@
 require "spec_helper"
 
-describe Rubylog::Variable, :rubylog=>true do
-  it "is created when an undefined constant name appears" do 
-    [A, SomethingLong].each{|x|x.should be_kind_of Rubylog::Variable}
-  end
-
-  it "supports ==" do 
-    A.should == A
-  end
+module RubylogSpec
+  describe Rubylog::Variable, :rubylog=>true do
+    it "is created when an undefined constant name appears" do 
+      [A, SomethingLong].each{|x|x.should be_kind_of Rubylog::Variable}
+    end
 
-  it "supports eql?" do
-    A.should be_eql A
-  end
+    it "supports ==" do 
+      A.should == A
+    end
 
-  it "returns different instances" do
-    A.should_not be_equal A
-  end
+    it "supports eql?" do
+      A.should be_eql A
+    end
 
-  describe "dont-care variables" do 
-    specify "start with ANY or Any or AnY" do
-      [ANY, Anything, AnYTIME].each{|x|x.should be_kind_of Rubylog::Variable; x.should be_dont_care}
-      [NOBODY, EVERYBODY, SOMEBODY].each{|x|x.should be_kind_of Rubylog::Variable; x.should_not be_dont_care}
+    it "returns different instances" do
+      A.should_not be_equal A
     end
-  end
 
-  describe "#value" do
-    it "returns the value if bound" do
-      a = A
-      a.send :bind_to, 5 do
-        a.value.should == 5
+    describe "dont-care variables" do 
+      specify "start with ANY or Any or AnY" do
+        [ANY, Anything, AnYTIME].each{|x|x.should be_kind_of Rubylog::Variable; x.should be_dont_care}
+        [NOBODY, EVERYBODY, SOMEBODY].each{|x|x.should be_kind_of Rubylog::Variable; x.should_not be_dont_care}
       end
     end
 
-    it "returns nil if unbound" do
-      a = A
-      a.send :bind_to, 5 do
+    describe "#value" do
+      it "returns the value if bound" do
+        a = A
+        a.send :bind_to, 5 do
+          a.value.should == 5
+        end
       end
-      a.value.should == nil
-    end
-  end
 
-  describe "unification" do
-    it "unifies with non-var" do
-      a=A
-      a.rubylog_unify(4) do
-        a.should be_bound
-        a.value.should eql 4
+      it "returns nil if unbound" do
+        a = A
+        a.send :bind_to, 5 do
+        end
+        a.value.should == nil
       end
     end
 
-    it "unifies with non-var (reversed)" do
-      a=A
-      4.rubylog_unify(a) do
-        a.should be_bound
-        a.value.should eql 4
+    describe "unification" do
+      it "unifies with non-var" do
+        a=A
+        a.rubylog_unify(4) do
+          a.should be_bound
+          a.value.should eql 4
+        end
       end
-    end
 
-    it "unifies with another unbound variable with getting bound" do
-      a=A
-      b=B
-      a.rubylog_unify(b) do
-        a.should be_bound
-        a.value.should equal b
-        b.should_not be_bound
+      it "unifies with non-var (reversed)" do
+        a=A
+        4.rubylog_unify(a) do
+          a.should be_bound
+          a.value.should eql 4
+        end
       end
-    end
 
-    it "unifies with a bound variable" do
-      a=A
-      b=B
-      b.send(:bind_to, 4) do
+      it "unifies with another unbound variable with getting bound" do
+        a=A
+        b=B
         a.rubylog_unify(b) do
-          a.value.should == 4
+          a.should be_bound
+          a.value.should equal b
+          b.should_not be_bound
         end
       end
-    end
 
-    it "when bound, unifies with an unbound variable" do
-      a=A
-      b=B
-      a.send(:bind_to, 4) do
-        a.rubylog_unify(b) do
-          b.value.should == 4
+      it "unifies with a bound variable" do
+        a=A
+        b=B
+        b.send(:bind_to, 4) do
+          a.rubylog_unify(b) do
+            a.value.should == 4
+          end
+        end
+      end
+
+      it "when bound, unifies with an unbound variable" do
+        a=A
+        b=B
+        a.send(:bind_to, 4) do
+          a.rubylog_unify(b) do
+            b.value.should == 4
+          end
         end
       end
-    end
 
-    it "unifies with self" do
-      a=A
-      a.rubylog_unify(a) do
-        a.should_not be_bound
+      it "unifies with self" do
+        a=A
+        a.rubylog_unify(a) do
+          a.should_not be_bound
+        end 
       end 
-    end 
 
-    it "unifies with another bound to self" do
-      a=A
-      b=B
-      a.rubylog_unify(b) do
-        b.rubylog_unify(a) do
-          b.should_not be_bound
+      it "unifies with another bound to self" do
+        a=A
+        b=B
+        a.rubylog_unify(b) do
+          b.rubylog_unify(a) do
+            b.should_not be_bound
+          end
         end
       end
     end
-  end
 
-  describe "dereferencing" do
-    predicate_for Integer, ".divides()"
+    describe "dereferencing" do
+      predicate_for Integer, ".divides()"
 
-    check { A.is_a? Rubylog::Variable }
-    check { A.rubylog_deep_dereference == A }
+      check { A.is_a? Rubylog::Variable }
+      check { A.rubylog_deep_dereference == A }
 
-    a = A
-    check { a.rubylog_deep_dereference.equal? a }
+      a = A
+      check { a.rubylog_deep_dereference.equal? a }
 
-    check { not a.bound? }
+      check { not a.bound? }
 
-    specify do
-      a.rubylog_unify(4) do
-        check { a.bound? }
-        check { a.rubylog_deep_dereference == 4 }
-        check { [1,a].rubylog_deep_dereference == [1,4] }
-        check { a.divides(16).rubylog_deep_dereference == 4.divides(16) }
+      specify do
+        a.rubylog_unify(4) do
+          check { a.bound? }
+          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
       end
-    end
 
-    b = []
-    check { not b.rubylog_deep_dereference.equal? b }
+      b = []
+      check { not b.rubylog_deep_dereference.equal? b }
 
-    c = Object.new
-    check { c.rubylog_deep_dereference.equal? c }
-  end
-
-  describe "dont-care variables are case insensitive ANY* and _*" do
-    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
-  end
+      c = Object.new
+      check { c.rubylog_deep_dereference.equal? c }
+    end
 
-  describe "variables support recursion" do
-    predicate_for Integer, ".factorial()"
-    0.factorial! 1
-    N[thats > 0].factorial(K).if 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
+    describe "dont-care variables are case insensitive ANY* and _*" do
+      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
+    end
 
+    describe "variables support recursion" do
+      predicate_for Integer, ".factorial()"
+      0.factorial! 1
+      N[thats > 0].factorial(K).if 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
 
-  describe "dont-care variables support recursion" do
-    predicate_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
 
-  describe "calling" do
-    describe "precompiled" do
-      check B.is(4).and A.is(B.is(C).and C.is(4)).and A
-      check((B.is(4).and A.is(B.is(C).and C.is(3)).and A).false)
+    describe "dont-care variables support recursion" do
+      predicate_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
 
-    describe "compiled run-time" do
-      check B.is(4).and A.is{B.is(C).and C.is(4)}.and A
-      check((B.is(4).and A.is{B.is(C).and C.is(3)}.and A).false)
-    end
+    describe "calling" do
+      describe "precompiled" do
+        check B.is(4).and A.is(B.is(C).and C.is(4)).and A
+        check((B.is(4).and A.is(B.is(C).and C.is(3)).and A).false)
+      end
 
-  end
+      describe "compiled run-time" do
+        check B.is(4).and A.is{B.is(C).and C.is(4)}.and A
+        check((B.is(4).and A.is{B.is(C).and C.is(3)}.and A).false)
+      end
 
-  describe "guards", :rubylog=>true do
-
-    describe "class guard" do
-      predicate_for [Integer,Float], ".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
     end
 
-    describe "union of guards at compile" do
-      predicate_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
-    end
+    describe "guards", :rubylog=>true do
+
+      describe "class guard" do
+        predicate_for [Integer,Float], ".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
+      end
 
-    describe "union of guards at compile (dont-care)" do
-      predicate_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
-    end
+      describe "union of guards at compile" do
+        predicate_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
+      end
 
-    describe "union of guards at unification" do
-      predicate_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
-    end
+      describe "union of guards at compile (dont-care)" do
+        predicate_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
+      end
 
-    describe "union of guards at unification (reversed)" do
-      predicate_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
-    end
+      describe "union of guards at unification" do
+        predicate_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
+      end
 
+      describe "union of guards at unification (reversed)" do
+        predicate_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
+      end
 
-    describe "proc guards" do
-      predicate_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
-    end
 
-    describe "hash guards" do
-      predicate_for String, ".char"
-      S[length: 1].char!
-      check "a".char
-      check " ".char
-      check "".char.false
-      check "af".char.false
-      check "Hello".char.false
-    end
+      describe "proc guards" do
+        predicate_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
+      end
 
-    describe "list hash guards" do
-      predicate_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
-    end
+      describe "hash guards" do
+        predicate_for String, ".char"
+        S[length: 1].char!
+        check "a".char
+        check " ".char
+        check "".char.false
+        check "af".char.false
+        check "Hello".char.false
+      end
+
+      describe "list hash guards" do
+        predicate_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
+      end
 
 
-    describe "chained hash guards" do
-      predicate_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
+      describe "chained hash guards" do
+        predicate_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
 
 
 
+    end
   end
-end
 
+end