immutable 0.1.0 → 0.2.0

data/test/immutable/test_list.rb

@@ -1,5 +1,8 @@
-require "test/unit"
-require "immutable/list"
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require "immutable/list"
+}
 
 module Immutable
   class TestList < Test::Unit::TestCase
@@ -52,6 +55,16 @@ module Immutable
       assert(!List[1, 2, 3].empty?)
     end
 
+    def test_each
+      a = []
+      List[].each { |x| a << x }
+      assert_equal([], a)
+
+      a = []
+      List[1, 2, 3].each { |x| a << x }
+      assert_equal([1, 2, 3], a)
+    end
+
     def test_foldr
       assert_equal(0, List[].foldr(0, &:+))
       assert_equal(123, List[].foldr(123, &:+))
@@ -96,6 +109,7 @@ module Immutable
       assert(List[1] != List[])
       assert(List[1] == List[1])
       assert(List[1] != List[2])
+      assert(List[1] != [1])
       assert(List["foo"] == List["foo"])
       assert(List["foo"] != List["bar"])
       assert(List[1, 2, 3] == List[1, 2, 3])
@@ -159,6 +173,15 @@ module Immutable
       assert_equal(List[2, 4], List[1, 2, 3, 4, 5].filter(&:even?))
     end
 
+    def test_aref
+      assert_equal(nil, List[][0])
+      assert_equal(1, List[1, 2, 3][0])
+      assert_equal(nil, List[1, 2, 3][-1])
+      assert_equal(2, List[1, 2, 3][1])
+      assert_equal(3, List[1, 2, 3][2])
+      assert_equal(nil, List[1, 2, 3][3])
+    end
+
     def test_take
       assert_equal(List[], List[].take(1))
       assert_equal(List[], List[1, 2, 3].take(0))
@@ -226,6 +249,13 @@ module Immutable
                    List[List[1, 2, 3], List[4, 5]].transpose)
     end
 
+    def test_subsequences
+      assert_equal(List[List[]], List[].subsequences)
+      assert_equal(List[List[], List[1], List[2], List[1, 2],
+                        List[3], List[1, 3], List[2, 3], List[1, 2, 3]],
+                   List[1, 2, 3].subsequences)
+    end
+
     def test_sum
       assert_equal(0, List[].sum)
       assert_equal(1, List[1].sum)
@@ -251,5 +281,23 @@ module Immutable
       }
       assert_equal(List["foo", "bar", "baz"], xs)
     end
+
+    def test_zip
+      xs = List[0, 1, 2]
+      ys = List[0, 2, 4]
+      zs = List[0, 3, 6]
+      assert_equal(List[[0, 0, 0], [1, 2, 3], [2, 4, 6]],
+                   xs.zip(ys, zs))
+    end
+
+    def test_zip_with
+      xs = List[0, 1, 2]
+      ys = List[0, 2, 4]
+      zs = List[0, 3, 6]
+      l = xs.zip_with(ys, zs) { |x, y, z|
+        x + y + z
+      }
+      assert_equal(List[0, 6, 12], l)
+    end
   end
 end

data/test/immutable/test_map.rb

@@ -1,5 +1,8 @@
-require "test/unit"
-require "immutable/map"
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require "immutable/map"
+}
 
 module Immutable
   class TestMap < Test::Unit::TestCase
@@ -48,6 +51,16 @@ module Immutable
       end
     end
 
+    def test_each
+      a = []
+      Map[].each { |x| a << x }
+      assert_equal([], a)
+
+      a = []
+      Map[a: 1, c: 3, b: 2].each { |x| a << x }
+      assert_equal([[:a, 1], [:b, 2], [:c, 3]], a)
+    end
+
     def test_foldr
       xs = Map[].foldr(List[]) { |v, ys| Cons[v, ys] }
       assert_equal(List[], xs)

data/test/immutable/test_promise.rb

@@ -0,0 +1,202 @@
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require "immutable/promise"
+  require "immutable/list"
+}
+
+module Immutable
+  class TestPromise < Test::Unit::TestCase
+    COUNT = 10000
+
+    def test_eager
+      assert_equal(123, Promise.eager(123).force)
+    end
+
+    def test_delay
+      assert_equal(123, Promise.delay { 123 }.force)
+      count = 0
+      x = Promise.delay { count += 1; 123 }
+      assert_equal(0, count)
+      assert_equal(123, x.force)
+      assert_equal(1, count)
+    end
+
+    def test_memoization1
+      count = 0
+      s = Promise.delay { count += 1; 1 }
+      assert_equal(1, s.force)
+      assert_equal(1, s.force)
+      assert_equal(1, count)
+    end
+
+    def test_memoization2
+      count = 0
+      s = Promise.delay { count += 1; 2 }
+      assert_equal(4, s.force + s.force)
+      assert_equal(1, count)
+    end
+
+    def test_memoization3
+      count = 0
+      r = Promise.delay { count += 1; 1 }
+      s = Promise.lazy { r }
+      t = Promise.lazy { s }
+      assert_equal(1, t.force)
+      assert_equal(1, s.force)
+      assert_equal(1, count)
+    end
+
+    def test_memoization4
+      stream_drop = ->(s, index) {
+        Promise.lazy {
+          if index.zero?
+            s
+          else
+            stream_drop[s.force.tail, index - 1]
+          end
+        }
+      }
+      count = 0
+      ones = -> {
+        Promise.delay {
+          count += 1
+          Cons[1, ones[]]
+        }
+      }
+      s = ones[]
+      assert_equal(1, stream_drop[s, 4].force.head)
+      assert_equal(1, stream_drop[s, 4].force.head)
+      assert_equal(5, count)
+    end
+
+    def test_reentrancy1
+      count = 0
+      x = 5
+      p = Promise.delay {
+        count += 1
+        if count > x
+          count
+        else
+          p.force
+        end
+      }
+      assert_equal(6, p.force)
+      x = 10
+      assert_equal(6, p.force)
+    end
+
+    def test_reentrancy2
+      first = true
+      f = Promise.delay {
+        if first
+          first = false
+          f.force
+        else
+          :second
+        end
+      }
+      assert_equal(:second, f.force)
+    end
+
+    def test_reentrancy3
+      q = -> {
+        count = 5
+        get_count = -> { count }
+        p = Promise.delay {
+          if count <= 0
+            count
+          else
+            count -= 1
+            p.force
+            count += 2
+            count
+          end
+        }
+        [get_count, p]
+      }[]
+      get_count, p = q
+      assert_equal(5, get_count[])
+      assert_equal(0, p.force)
+      assert_equal(10, get_count[])
+    end
+
+    def nloop(n)
+      Promise.lazy { n <= 0 ? Promise.eager(0) : nloop(n - 1) }
+    end
+
+    def test_leak1
+      assert_equal(0, nloop(COUNT).force)
+    end
+
+    def test_leak2
+      s = nloop(COUNT)
+      assert_equal(0, s.force)
+    end
+
+    def from(n)
+      Promise.delay {
+        Cons[n, from(n + 1)]
+      }
+    end
+
+    def traverse(s, n)
+      Promise.lazy {
+        if n <= 0
+          s
+        else
+          traverse(s.force.tail, n - 1)
+        end
+      }
+    end
+
+    def test_leak3
+      assert_equal(COUNT, traverse(from(0), COUNT).force.head)
+    end
+
+    def test_leak4
+      s = traverse(from(0), COUNT)
+      assert_equal(COUNT, s.force.head)
+    end
+
+    def stream_filter(s, &block)
+      Promise.lazy {
+        xs = s.force
+        if xs.empty?
+          Promise.delay { List[] }
+        else
+          if yield(xs.head)
+            Promise.delay { Cons[xs.head, stream_filter(xs.tail, &block)] }
+          else
+            stream_filter(xs.tail, &block)
+          end
+        end
+      }
+    end
+
+    def test_leak5
+      stream_filter(from(0)) { |n| n == COUNT }.force
+    end
+
+    def stream_ref(s, index)
+      Promise.lazy {
+        xs = s.force
+        if xs.empty?
+          :error
+        else
+          if index.zero?
+            Promise.delay { xs.head }
+          else
+            stream_ref(xs.tail, index - 1)
+          end
+        end
+      }
+    end
+
+    def test_leak6
+      assert_equal(0, stream_ref(stream_filter(from(0), &:zero?), 0).force)
+      s = stream_ref(from(0), COUNT)
+      assert_equal(COUNT, s.force)
+    end
+  end
+end

data/test/immutable/test_queue.rb

@@ -0,0 +1,43 @@
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require "immutable/queue"
+}
+
+module Immutable
+  class TestList < Test::Unit::TestCase
+    def test_head
+      assert_raise(List::EmptyError) do
+        Queue[].head
+      end
+      assert_equal(1, Queue[1].head)
+      assert_equal(1, Queue[1, 2, 3].head)
+    end
+
+    def test_tail
+      assert_raise(List::EmptyError) do
+        Queue[].tail
+      end
+      assert(Queue[1].tail.empty?)
+      assert_equal(2, Queue[1, 2].tail.head)
+      assert_equal(2, Queue[1, 2, 3].tail.head)
+      assert_equal(3, Queue[1, 2, 3].tail.tail.head)
+    end
+
+    def test_snoc
+      q1 = Queue.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(Queue.empty, :snoc)
+      assert_equal(a, q.to_a)
+    end
+  end
+end

data/test/immutable/test_stream.rb

@@ -0,0 +1,359 @@
+require_relative "../test_helper"
+
+with_tailcall_optimization {
+  require "immutable/stream"
+}
+
+module Immutable
+  class TestStream < Test::Unit::TestCase
+    def test_s_from_enum
+      assert_equal([], Stream.from_enum([]).to_a)
+      assert_equal([1, 2, 3], Stream.from_enum([1, 2, 3]).to_a)
+      assert_equal(["a", "b", "c"],
+                   Stream.from_enum("abc".chars).to_a)
+    end
+
+    def test_s_from_enumerator
+      e = [1, 2, 3, 4, 5].each
+      s1 = Stream.from_enumerator(e)
+      s2 = Stream.from_enumerator(e)
+      assert_equal(1, s1.head)
+      assert_equal(2, s2.head)
+      assert_equal(1, s1.head)
+      assert_equal([1, 3], s1.take(2).to_a)
+      assert_equal(4, s2.drop(1).head)
+      assert_equal([1, 3, 5], s1.to_a)
+      assert_equal([2, 4], s2.to_a)
+    end
+
+    def test_s_from
+      s = Stream.from(1)
+      assert_equal(Stream[1], s.take(1))
+      assert_equal(Stream[1, 2, 3], s.take(3))
+      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 })
+    end
+
+    def test_head
+      assert_raise(List::EmptyError) do
+        Stream.null.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
+      end
+      assert(Stream[1].tail.null?)
+      assert_equal([2, 3], Stream[1, 2, 3].tail.to_a)
+    end
+
+    def test_last
+      assert_raise(List::EmptyError) do
+        Stream.null.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
+      end
+      assert_equal(Stream[], Stream[1].init)
+      assert_equal(Stream[1], Stream[1, 2].init)
+      assert_equal(Stream[1, 2], Stream[1, 2, 3].init)
+    end
+
+    def test_aref
+      s = Stream[1, 2, 3, 4, 5]
+      2.times do
+        assert_equal(nil, s[-1])
+        assert_equal(1, s[0])
+        assert_equal(5, s[4])
+        assert_equal(nil, s[5])
+        assert_equal(4, s[3])
+      end
+    end
+
+    def test_empty?
+      assert(Stream[].empty?)
+      assert(!Stream[1].empty?)
+      assert(!Stream[1, 2, 3].empty?)
+    end
+
+    def test_each
+      a = []
+      Stream[].each { |x| a << x }
+      assert_equal([], a)
+
+      a = []
+      Stream[1, 2, 3].each { |x| a << x }
+      assert_equal([1, 2, 3], a)
+    end
+
+    def test_foldr
+      assert_equal(0, Stream[].foldr(0, &:+))
+      assert_equal(123, Stream[].foldr(123, &:+))
+
+      assert_equal(6, Stream[1, 2, 3].foldr(0, &:+))
+      # 1 - (2 - (3 - 10))
+      assert_equal(-8, Stream[1, 2, 3].foldr(10, &:-))
+    end
+
+    def test_foldr1
+      assert_raise(List::EmptyError) do
+        Stream[].foldr1(&:+)
+      end
+      assert_equal(1, Stream[1].foldr1(&:+))
+      assert_equal(3, Stream[1, 2].foldr1(&:+))
+      assert_equal(6, Stream[1, 2, 3].foldr1(&:+))
+      assert_equal(2, Stream[1, 2, 3].foldr1(&:-))
+    end
+
+    def test_foldl
+      assert_equal(0, Stream[].foldl(0, &:+))
+      assert_equal(123, Stream[].foldl(123, &:+))
+
+      assert_equal(6, Stream[1, 2, 3].foldl(0, &:+))
+      # ((10 - 1) - 2) - 3
+      assert_equal(4, Stream[1, 2, 3].foldl(10, &:-))
+    end
+
+    def test_foldl1
+      assert_raise(List::EmptyError) do
+        Stream[].foldl1(&:+)
+      end
+      assert_equal(1, Stream[1].foldl1(&:+))
+      assert_equal(3, Stream[1, 2].foldl1(&:+))
+      assert_equal(6, Stream[1, 2, 3].foldl1(&:+))
+      assert_equal(-4, Stream[1, 2, 3].foldl1(&:-))
+    end
+
+    def test_eq
+      assert(Stream[] == Stream[])
+      assert(Stream[] != Stream[1])
+      assert(Stream[1] != Stream[])
+      assert(Stream[1] == Stream[1])
+      assert(Stream[1] != Stream[2])
+      assert(Stream["foo"] == Stream["foo"])
+      assert(Stream["foo"] != Stream["bar"])
+      assert(Stream[1, 2, 3] == Stream[1, 2, 3])
+      assert(Stream[1, 2, 3] != Stream[1, 2])
+      assert(Stream[1, 2, 3] != Stream[1, 2, 3, 4])
+      assert(Stream[Stream[1, 2], Stream[3, 4]] ==
+             Stream[Stream[1, 2], Stream[3, 4]])
+      assert(Stream[Stream[1, 2], Stream[3, 4]] !=
+             Stream[Stream[1, 2], Stream[3]])
+      assert(Stream[] != Stream.from(1))
+      assert(Stream.from(1) != Stream[])
+      assert(Stream[1] != Stream.from(1))
+      assert(Stream.from(1) != Stream[1])
+    end
+
+    def test_inspect
+      s = Stream[]
+      assert_equal('Stream[...]', s.inspect)
+      assert_equal(nil, s[0])
+      assert_equal('Stream[]', s.inspect)
+      s = Stream[1]
+      assert_equal('Stream[...]', s.inspect)
+      assert_equal(1, s[0])
+      assert_equal('Stream[1, ...]', s.inspect)
+      assert_equal(nil, s[1])
+      assert_equal('Stream[1]', s.inspect)
+      s = Stream["foo"]
+      assert_equal("foo", s[0])
+      assert_equal('Stream["foo", ...]', s.inspect)
+      assert_equal(nil, s[1])
+      assert_equal('Stream["foo"]', s.inspect)
+      s = Stream[1, 2, 3]
+      assert_equal('Stream[...]', s.inspect)
+      assert_equal(1, s[0])
+      assert_equal('Stream[1, ...]', s.inspect)
+      assert_equal(2, s[1])
+      assert_equal('Stream[1, 2, ...]', s.inspect)
+      assert_equal(3, s[2])
+      assert_equal('Stream[1, 2, 3, ...]', s.inspect)
+      assert_equal(nil, s[3])
+      assert_equal('Stream[1, 2, 3]', s.inspect)
+      s = Stream[1, 2, 3]
+      assert_equal(2, s[1])
+      assert_equal('Stream[?, 2, ...]', s.inspect)
+      s = Stream[Stream[1, 2], Stream[3, 4]]
+      assert_equal(Stream[1, 2], s[0])
+      assert_equal(Stream[3, 4], s[1])
+      assert_equal(nil, s[2])
+      assert_equal('Stream[Stream[1, 2], Stream[3, 4]]',
+                   s.inspect)
+    end
+
+    def test_length
+      assert_equal(0, Stream[].length)
+      assert_equal(1, Stream[1].length)
+      assert_equal(3, Stream[1, 2, 3].length)
+      assert_equal(100, Stream.from(1).take(100).length)
+    end
+
+    def test_plus
+      assert_equal(Stream[], Stream[] + Stream[])
+      assert_equal(Stream[1, 2, 3], Stream[] + Stream[1, 2, 3])
+      assert_equal(Stream[1, 2, 3], Stream[1, 2, 3] + Stream[])
+      assert_equal(Stream[1, 2, 3], Stream[1] + Stream[2, 3])
+      assert_equal(Stream[1, 2, 3], Stream[1, 2] + Stream[3])
+    end
+
+    def test_flatten
+      assert_equal(Stream[], Stream[].flatten)
+      assert_equal(Stream[1], Stream[Stream[1]].flatten)
+      assert_equal(Stream[Stream[1]],
+                   Stream[Stream[Stream[1]]].flatten)
+      assert_equal(Stream[1, 2, 3], Stream[Stream[1, 2], Stream[3]].flatten)
+      assert_equal(Stream[1, 2, 3],
+                   Stream[Stream[1], Stream[2], Stream[3]].flatten)
+    end
+
+    def test_map
+      assert_equal(Stream[], Stream[].map(&:to_s))
+      assert_equal(Stream["1", "2", "3"], Stream[1, 2, 3].map(&:to_s))
+    end
+
+    def test_reverse
+      assert_equal(Stream[], Stream[].reverse)
+      assert_equal(Stream[1], Stream[1].reverse)
+      assert_equal(Stream[2, 1], Stream[1, 2].reverse)
+      assert_equal(Stream[3, 2, 1], Stream[1, 2, 3].reverse)
+    end
+
+    def test_intersperse
+      assert_equal(Stream[], Stream[].intersperse(0))
+      assert_equal(Stream[1], Stream[1].intersperse(0))
+      assert_equal(Stream[1, 0, 2], Stream[1, 2].intersperse(0))
+      assert_equal(Stream[1, 0, 2, 0, 3], Stream[1, 2, 3].intersperse(0))
+      assert_equal(Stream[1, 0, 2, 0, 3],
+                   Stream.from(1).intersperse(0).take(5))
+    end
+
+    def test_intercalate
+      assert_equal(Stream[], Stream[].intercalate(Stream[0]))
+      assert_equal(Stream[1], Stream[Stream[1]].intercalate(Stream[0]))
+      xs = Stream[Stream[1, 2], Stream[3, 4], Stream[5, 6]].
+        intercalate(Stream[0])
+      assert_equal(Stream[1, 2, 0, 3, 4, 0, 5, 6], xs)
+      xs = Stream.from(1, 2).map { |x| Stream[x, x + 1] }.
+        intercalate(Stream[0]).take(8)
+      assert_equal(Stream[1, 2, 0, 3, 4, 0, 5, 6], xs)
+    end
+
+    def test_find
+      assert_equal(nil, Stream[].find(&:odd?))
+      assert_equal(1, Stream[1, 2, 3, 4, 5].find(&:odd?))
+      assert_equal(2, Stream[1, 2, 3, 4, 5].find(&:even?))
+      assert_equal(1, Stream.from(1).find(&:odd?))
+      assert_equal(2, Stream.from(1).find(&:even?))
+    end
+
+    def test_filter
+      assert_equal(Stream[], Stream[].filter(&:odd?))
+      assert_equal(Stream[1, 3, 5], Stream[1, 2, 3, 4, 5].filter(&:odd?))
+      assert_equal(Stream[2, 4], Stream[1, 2, 3, 4, 5].filter(&:even?))
+    end
+
+    def test_take
+      assert_equal(Stream[], Stream[].take(1))
+      assert_equal(Stream[], Stream[1, 2, 3].take(0))
+      assert_equal(Stream[], Stream[1, 2, 3].take(-1))
+      assert_equal(Stream[1], Stream[1, 2, 3].take(1))
+      assert_equal(Stream[1, 2], Stream[1, 2, 3].take(2))
+      assert_equal(Stream[1, 2, 3], Stream[1, 2, 3].take(3))
+      assert_equal(Stream[1, 2, 3], Stream[1, 2, 3].take(4))
+      assert_equal(Stream[], Stream.from(1).take(0))
+      assert_equal(Stream[1, 2, 3], Stream.from(1).take(3))
+      assert_equal(Stream[0, 2, 4], Stream.from(0, 2).take(3))
+    end
+
+    def test_take_while
+      assert_equal(Stream[], Stream[].take_while { true })
+      assert_equal(Stream[], Stream[1, 2, 3].take_while { |x| x < 1 })
+      assert_equal(Stream[1], Stream[1, 2, 3].take_while { |x| x < 2 })
+      assert_equal(Stream[1, 2], Stream[1, 2, 3].take_while { |x| x < 3 })
+      assert_equal(Stream[1, 2, 3],
+                   Stream[1, 2, 3].take_while { |x| x < 4 })
+    end
+
+    def test_drop
+      assert_equal(Stream[], Stream[].drop(1))
+      assert_equal(Stream[1, 2, 3], Stream[1, 2, 3].drop(0))
+      assert_equal(Stream[1, 2, 3], Stream[1, 2, 3].drop(-1))
+      assert_equal(Stream[2, 3], Stream[1, 2, 3].drop(1))
+      assert_equal(Stream[3], Stream[1, 2, 3].drop(2))
+      assert_equal(Stream[], Stream[1, 2, 3].drop(3))
+      assert_equal(Stream[], Stream[1, 2, 3].drop(4))
+      assert_equal(Stream[6, 7, 8], Stream.from(1).drop(5).take(3))
+    end
+
+    def test_drop_while
+      assert_equal(Stream[], Stream[].drop_while { false })
+      assert_equal(Stream[1, 2, 3],
+                   Stream[1, 2, 3].drop_while { |x| x < 1 })
+      assert_equal(Stream[2, 3], Stream[1, 2, 3].drop_while { |x| x < 2 })
+      assert_equal(Stream[3], Stream[1, 2, 3].drop_while { |x| x < 3 })
+      assert_equal(Stream[], Stream[1, 2, 3].drop_while { |x| x < 4 })
+    end
+
+    def test_s_unfoldr
+      xs = Stream.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
+      assert_equal(Stream[3, 2, 1], xs)
+      xs = Stream.unfoldr("foo,bar,baz") { |x|
+        if x.empty?
+          nil
+        else
+          y = x.slice(/([^,]*),?/, 1)
+          [y, $']
+        end
+      }
+      assert_equal(Stream["foo", "bar", "baz"], xs)
+      nats = Stream.unfoldr(0) { |x| [x, x + 1] }
+      assert_equal(Stream[0, 1, 2], nats.take(3))
+      assert_equal(Stream[0, 1, 2, 3, 4], nats.take(5))
+    end
+
+    def test_zip
+      s1 = Stream.from(0)
+      s2 = Stream.from(0, 2)
+      s3 = Stream.from(0, 3)
+      assert_equal(Stream[[0, 0, 0], [1, 2, 3], [2, 4, 6]],
+                   s1.zip(s2, s3).take(3))
+
+      s1 = Stream[0, 1, 2]
+      s2 = Stream.from(0, 2)
+      s3 = Stream.from(0, 3)
+      assert_equal(Stream[[0, 0, 0], [1, 2, 3], [2, 4, 6]],
+                   s1.zip(s2, s3))
+    end
+
+    def test_zip_with
+      s1 = Stream.from(0)
+      s2 = Stream.from(0, 2)
+      s3 = Stream.from(0, 3)
+      s = s1.zip_with(s2, s3) { |x, y, z|
+        x + y + z
+      }
+      assert_equal(Stream[0, 6, 12, 18], s.take(4))
+
+      s1 = Stream[0, 1, 2, 3]
+      s2 = Stream.from(0, 2)
+      s3 = Stream.from(0, 3)
+      s = s1.zip_with(s2, s3) { |x, y, z|
+        x + y + z
+      }
+      assert_equal(Stream[0, 6, 12, 18], s)
+    end
+  end
+end