immutable 0.2.0 → 0.3.0

data/test/immutable/test_deque.rb

@@ -0,0 +1,116 @@
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require_relative "../../lib/immutable/deque"
+}
+
+module Immutable
+  class TestDeque < Test::Unit::TestCase
+    def test_head
+      assert_raise(EmptyError) do
+        Deque[].head
+      end
+      assert_equal(1, Deque[1].head)
+      assert_equal(1, Deque[1, 2, 3].head)
+    end
+
+    def test_last
+      assert_raise(EmptyError) do
+        Deque[].last
+      end
+      assert_equal(1, Deque[1].last)
+      assert_equal(3, Deque[1, 2, 3].last)
+    end
+
+    def test_tail
+      assert_raise(EmptyError) do
+        Deque[].tail
+      end
+      assert(Deque[1].tail.empty?)
+      assert_equal(2, Deque[1, 2].tail.head)
+      assert_equal(2, Deque[1, 2, 3].tail.head)
+      assert_equal(3, Deque[1, 2, 3].tail.tail.head)
+    end
+
+    def test_init
+      assert_raise(EmptyError) do
+        Deque[].init
+      end
+      assert(Deque[1].init.empty?)
+      assert_equal(1, Deque[1, 2].init.last)
+      assert_equal(2, Deque[1, 2, 3].init.last)
+      assert_equal(1, Deque[1, 2, 3].init.init.last)
+    end
+
+    def test_cons
+      q1 = Deque.empty.cons(1)
+      assert_equal(1, q1.head)
+      assert(q1.tail.empty?)
+      q2 = q1.cons(2)
+      assert_equal(2, q2.head)
+      assert_equal(1, q2.tail.head)
+      assert(q2.tail.tail.empty?)
+      assert_equal(1, q1.head)
+      assert(q1.tail.empty?)
+
+      a = (1..1000).to_a.shuffle
+      q = a.inject(Deque.empty, :cons)
+      assert_equal(a.reverse, q.to_a)
+    end
+
+    def test_snoc
+      q1 = Deque.empty.snoc(1)
+      assert_equal(1, q1.head)
+      assert(q1.tail.empty?)
+      q2 = q1.snoc(2)
+      assert_equal(1, q2.head)
+      assert_equal(2, q2.tail.head)
+      assert(q2.tail.tail.empty?)
+      assert_equal(1, q1.head)
+      assert(q1.tail.empty?)
+
+      a = (1..1000).to_a.shuffle
+      q = a.inject(Deque.empty, :snoc)
+      assert_equal(a, q.to_a)
+    end
+
+    def test_invariants
+      a = (1..1000).to_a.shuffle
+      deque = a.inject(Deque.empty) { |d, i|
+        assert_deque_invariants(d)
+        if rand(2) == 0
+          d2 = d.snoc(i)
+        else
+          d2 = d.cons(i)
+        end
+        case rand(4)
+        when 0
+          d2.tail
+        when 1
+          d2.init
+        else
+          d2
+        end
+      }
+      assert_deque_invariants(deque)
+      until deque.empty?
+        if rand(2) == 0
+          deque = deque.tail
+        else
+          deque = deque.init
+        end
+        assert_deque_invariants(deque)
+      end
+    end
+
+    private
+
+    def assert_deque_invariants(d)
+      c = d.instance_variable_get(:@c)
+      front_len = d.instance_variable_get(:@front_len)
+      rear_len = d.instance_variable_get(:@rear_len)
+      assert(front_len <= c * rear_len + 1)
+      assert(rear_len <= c * front_len + 1)
+    end
+  end
+end

data/test/immutable/test_list.rb

@@ -1,7 +1,7 @@
 require_relative "../test_helper"
 
 with_tailcall_optimization {
-  require "immutable/list"
+  require_relative "../../lib/immutable/list"
 }
 
 module Immutable
@@ -18,7 +18,7 @@ module Immutable
     end
 
     def test_head
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].head
       end
       assert_equal(1, List[1].head)
@@ -26,7 +26,7 @@ module Immutable
     end
 
     def test_last
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].last
       end
       assert_equal(1, List[1].last)
@@ -34,7 +34,7 @@ module Immutable
     end
 
     def test_tail
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].tail
       end
       assert_equal(List[], List[1].tail)
@@ -42,7 +42,7 @@ module Immutable
     end
 
     def test_init
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].init
       end
       assert_equal(List[], List[1].init)
@@ -56,13 +56,24 @@ module Immutable
     end
 
     def test_each
+      list = List[]
       a = []
-      List[].each { |x| a << x }
+      assert_same(list, list.each { |x| a << x })
       assert_equal([], a)
-
+      
+      list = List[1, 2, 3]
       a = []
-      List[1, 2, 3].each { |x| a << x }
+      assert_same(list, list.each { |x| a << x })
       assert_equal([1, 2, 3], a)
+      
+      enum = List[1, 2, 3].each
+      assert_instance_of(Enumerator, enum)
+      assert_equal(1, enum.next)
+      assert_equal(2, enum.next)
+      assert_equal(3, enum.next)
+      assert_raise(StopIteration) do
+        enum.next
+      end
     end
 
     def test_foldr
@@ -75,7 +86,7 @@ module Immutable
     end
 
     def test_foldr1
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].foldr1(&:+)
       end
       assert_equal(1, List[1].foldr1(&:+))
@@ -94,7 +105,7 @@ module Immutable
     end
 
     def test_foldl1
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         List[].foldl1(&:+)
       end
       assert_equal(1, List[1].foldl1(&:+))
@@ -110,6 +121,7 @@ module Immutable
       assert(List[1] == List[1])
       assert(List[1] != List[2])
       assert(List[1] != [1])
+      assert(List[1] == List[1.0])
       assert(List["foo"] == List["foo"])
       assert(List["foo"] != List["bar"])
       assert(List[1, 2, 3] == List[1, 2, 3])
@@ -119,6 +131,20 @@ module Immutable
       assert(List[List[1, 2], List[3, 4]] != List[List[1, 2], List[3]])
     end
 
+    def test_eql
+      assert(List[].eql? List[])
+      assert(List[1].eql? List[1])
+      assert_same(List[1].eql?(List[1.0]), false)
+      assert(List["foo"].eql? List["foo"])
+      assert(List[1, 2, 3].eql? List[1, 2, 3])
+      assert(List[List[1, 2], List[3, 4]].eql? List[List[1, 2], List[3, 4]])
+    end
+    
+    def test_hash_key
+      assert_same({List[1] => true}[List[1.0]], nil)
+      assert_same({List[1] => true}[List[1]], true)
+    end
+
     def test_inspect
       assert_equal('List[]', List[].inspect)
       assert_equal('List[1]', List[1].inspect)
@@ -135,6 +161,15 @@ module Immutable
       assert_equal(100, List[*(1..100)].length)
     end
 
+    def test_cons
+      assert_equal(List[1], List[].cons(1))
+      assert_equal(List[1, 2, 3], List[2, 3].cons(1))
+      xs = List[1, 2, 3]
+      ys = xs.cons(0)
+      assert_equal(List[1, 2, 3], xs)
+      assert_equal(List[0, 1, 2, 3], ys)
+    end
+
     def test_plus
       assert_equal(List[], List[] + List[])
       assert_equal(List[1, 2, 3], List[] + List[1, 2, 3])
@@ -156,6 +191,11 @@ module Immutable
       assert_equal(List["1", "2", "3"], List[1, 2, 3].map(&:to_s))
     end
 
+    def test_rev_map
+      assert_equal(List[], List[].rev_map(&:to_s))
+      assert_equal(List["3", "2", "1"], List[1, 2, 3].rev_map(&:to_s))
+    end
+
     def test_flat_map
       assert_equal(List[], List[].flat_map {})
       assert_equal(List["1", "2", "3"], List[1, 2, 3].map(&:to_s))
@@ -165,6 +205,14 @@ module Immutable
       assert_equal(nil, List[].find(&:odd?))
       assert_equal(1, List[1, 2, 3, 4, 5].find(&:odd?))
       assert_equal(2, List[1, 2, 3, 4, 5].find(&:even?))
+      assert_equal(nil, List[1, 2, 3, 4, 5].find{|elm|elm < 0})
+      assert_raise(ArgumentError) do
+        List[1, 2, 3, 4, 5].find(->{raise ArgumentError}){|elm|elm < 0}
+      end
+      
+      enum = List[1, 2, 3, 4, 5].find
+      assert_instance_of(Enumerator, enum)
+      assert_equal(2, enum.each(&:even?))
     end
 
     def test_filter
@@ -268,9 +316,12 @@ module Immutable
       assert_equal(24, List[1, 2, 3, 4].product)
     end
 
-    def test_s_unfoldr
+    def test_unfoldr
       xs = List.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
       assert_equal(List[3, 2, 1], xs)
+    end
+
+    def test_s_unfoldr
       xs = List.unfoldr("foo,bar,baz") { |x|
         if x.empty?
           nil

data/test/immutable/test_map.rb

@@ -1,7 +1,8 @@
 require_relative "../test_helper"
 
 with_tailcall_optimization {
-  require "immutable/map"
+  require_relative "../../lib/immutable/list"
+  require_relative "../../lib/immutable/map"
 }
 
 module Immutable
@@ -97,16 +98,6 @@ module Immutable
       assert_equal(List[[:a, 1], [:b, 2], [:c, 3]], xs)
     end
 
-    def test_foldl_with_key
-      xs = Map[].foldl_with_key(List[]) { |ys, k, v| Cons[[k, v], ys] }
-      assert_equal(List[], xs)
-
-      xs = Map[a: 1, c: 3, b: 2].foldl_with_key(List[]) { |ys, k, v|
-        Cons[[k, v], ys]
-      }
-      assert_equal(List[[:c, 3], [:b, 2], [:a, 1]], xs)
-    end
-
     def test_map
       xs = Map[].map { |v| v.to_s }
       assert_equal(List[], xs)

data/test/immutable/test_promise.rb

@@ -1,8 +1,8 @@
 require_relative "../test_helper"
 
 with_tailcall_optimization {
-  require "immutable/promise"
-  require "immutable/list"
+  require_relative "../../lib/immutable/promise"
+  require_relative "../../lib/immutable/list"
 }
 
 module Immutable

data/test/immutable/test_queue.rb

@@ -1,13 +1,13 @@
 require_relative "../test_helper"
 
 with_tailcall_optimization {
-  require "immutable/queue"
+  require_relative "../../lib/immutable/queue"
 }
 
 module Immutable
-  class TestList < Test::Unit::TestCase
+  class TestQueue < Test::Unit::TestCase
     def test_head
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         Queue[].head
       end
       assert_equal(1, Queue[1].head)
@@ -15,7 +15,7 @@ module Immutable
     end
 
     def test_tail
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         Queue[].tail
       end
       assert(Queue[1].tail.empty?)
@@ -39,5 +39,32 @@ module Immutable
       q = a.inject(Queue.empty, :snoc)
       assert_equal(a, q.to_a)
     end
+
+    def test_invariant
+      a = (1..100).to_a.shuffle
+      queue = a.inject(Queue.empty) { |q, i|
+        assert_queue_invariant(q)
+        q2 = q.snoc(i)
+        if rand(3) == 0
+          q2.tail
+        else
+          q2
+        end
+      }
+      assert_queue_invariant(queue)
+      until queue.empty?
+        queue = queue.tail
+        assert_queue_invariant(queue)
+      end
+    end
+
+    private
+
+    def assert_queue_invariant(d)
+      front = d.instance_variable_get(:@front)
+      rear = d.instance_variable_get(:@rear)
+      schedule = d.instance_variable_get(:@schedule)
+      assert_equal(schedule.length, front.length - rear.length)
+    end
   end
 end

data/test/immutable/test_stream.rb

@@ -1,7 +1,7 @@
 require_relative "../test_helper"
 
 with_tailcall_optimization {
-  require "immutable/stream"
+  require_relative "../../lib/immutable/stream"
 }
 
 module Immutable
@@ -33,38 +33,40 @@ module Immutable
       assert_equal(Stream[1, 3, 5], Stream.from(1, 2).take(3))
     end
 
-    def test_prepend
-      assert_equal(Stream[1], Stream.null.prepend { 1 })
-      assert_equal(Stream[1, 2], Stream.null.prepend { 2 }.prepend { 1 })
+    def test_cons
+      assert_equal(Stream[1], Stream.empty.cons(1))
+      assert_equal(Stream[1, 2], Stream.empty.cons(2).cons(1))
+      assert_equal(Stream[1], Stream.empty.cons { 1 })
+      assert_equal(Stream[1, 2], Stream.empty.cons { 2 }.cons { 1 })
     end
 
     def test_head
-      assert_raise(List::EmptyError) do
-        Stream.null.head
+      assert_raise(EmptyError) do
+        Stream.empty.head
       end
       assert_equal(1, Stream[1].head)
       assert_equal(1, Stream[1, 2, 3].head)
     end
 
     def test_tail
-      assert_raise(List::EmptyError) do
-        Stream.null.tail
+      assert_raise(EmptyError) do
+        Stream.empty.tail
       end
-      assert(Stream[1].tail.null?)
+      assert(Stream[1].tail.empty?)
       assert_equal([2, 3], Stream[1, 2, 3].tail.to_a)
     end
 
     def test_last
-      assert_raise(List::EmptyError) do
-        Stream.null.last
+      assert_raise(EmptyError) do
+        Stream.empty.last
       end
       assert_equal(1, Stream[1].last)
       assert_equal(3, Stream[1, 2, 3].last)
     end
 
     def test_init
-      assert_raise(List::EmptyError) do
-        Stream.null.init.force
+      assert_raise(EmptyError) do
+        Stream.empty.init.force
       end
       assert_equal(Stream[], Stream[1].init)
       assert_equal(Stream[1], Stream[1, 2].init)
@@ -108,7 +110,7 @@ module Immutable
     end
 
     def test_foldr1
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         Stream[].foldr1(&:+)
       end
       assert_equal(1, Stream[1].foldr1(&:+))
@@ -127,7 +129,7 @@ module Immutable
     end
 
     def test_foldl1
-      assert_raise(List::EmptyError) do
+      assert_raise(EmptyError) do
         Stream[].foldl1(&:+)
       end
       assert_equal(1, Stream[1].foldl1(&:+))
@@ -307,9 +309,12 @@ module Immutable
       assert_equal(Stream[], Stream[1, 2, 3].drop_while { |x| x < 4 })
     end
 
-    def test_s_unfoldr
+    def test_unfoldr
       xs = Stream.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
       assert_equal(Stream[3, 2, 1], xs)
+    end
+
+    def test_s_unfoldr
       xs = Stream.unfoldr("foo,bar,baz") { |x|
         if x.empty?
           nil
@@ -355,5 +360,10 @@ module Immutable
       }
       assert_equal(Stream[0, 6, 12, 18], s)
     end
+
+    def test_to_list
+      assert_equal(List[], Stream[].to_list)
+      assert_equal(List[1, 2, 3], Stream.from(1).take(3).to_list)
+    end
   end
 end