lazylist 0.1.3 → 0.2.0

data/CHANGES

@@ -1,3 +1,12 @@
+2005-10-08 * 0.2.0 * Lots of changes (without backwards compatibility):
+                      - Now the usual methods from the Ruby Enumerable module
+                        should be much better supported.
+                      - In general there are more finite lazy lists returned
+                        from methods (for example: lazylist[a, b] or
+                        lazylist[a..b]) instead of arrays.
+                      - mapper, filter and combine methods give an 'obsoleted'
+                        warning now, you better use map, select, and zip from
+                        now on.
 2005-09-26 * 0.1.3 * Fixed some Ruby 1.9 incompatibilities.
                    * Added default arguments for drop&take.
                    * I've decided to pollute the Kernel module with the #list

data/Rakefile

@@ -18,8 +18,7 @@ end
 
 desc "Installing library"
 task :install  do
-  libdir = CONFIG["sitelibdir"]
-  install('lib/lazylist.rb', libdir)
+  ruby 'install.rb'
 end
 
 desc "Creating documentation"

data/TODO

@@ -0,0 +1,35 @@
+* adding better support for finite lazy lists  
+* this stuff
+  # XXX
+  def append(*elements)
+    return rest if empty?
+    s = self
+    loop do
+      if s.tail.empty?
+        break s
+      else
+        s = s.tail
+      end
+    end
+    s.tail = rest
+    self
+  end
+  alias << append
+
+  # XXX self should be finite
+  def +(other)
+    other.is_a? self.class or
+      raise TypeError, "other has to be a #{self.class}"
+    copy = LazyList[to_a]
+    s = copy
+    loop do
+      if s.tail.empty?
+        break s
+      else
+        s = s.tail
+      end
+    end
+    s.tail = LazyList[other.to_a]
+    copy
+  end
+

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/examples/examples.rb

@@ -7,21 +7,21 @@ def rand(s = 666)
 end
 r = rand(666)
 r.each(10) { |x| print x, " " } ; puts
-dice = rand(666).mapper { |x| 1 + x % 6 }
+dice = r.map { |x| 1 + x % 6 }
 dice.each(10) { |x| print x, " " } ; puts
-coin = rand(666).mapper { |x| x % 2 == 0 ? :head : :tail }
+coin = r.map { |x| x % 2 == 0 ? :head : :tail }
 coin.each(10) { |x| print x, " " } ; puts
 
-puts "Prime number lazy list with filter (10000..1000000)"
-prime = LazyList[10000..1000000].filter do |x|
+puts "Prime number lazy list with select (10000..1000000)"
+prime = LazyList[10000..1000000].select do |x|
   not (2..Math.sqrt(x).to_i).find { |d| x % d == 0 }
 end
 prime.each(10) { |x| print x, " " } ; puts
 p prime[1]
 puts
 
-puts "Squared prime numbers with mapper"
-prime.mapper { |x| x ** 2 }.each(5) { |x| print x, " " } ; puts
+puts "Squared prime numbers with map"
+prime.map { |x| x ** 2 }.each(5) { |x| print x, " " } ; puts
 puts
 
 puts "Lazy Lists from mathematical sequences"

data/examples/hamming.rb

@@ -1,11 +1,11 @@
 require 'lazylist'
 
-# Computes the hamming sequence: that is the sequence of natural numbers, that
-# are multiples of 2, 3, and 5.
+# Computes the hamming sequence: that is the sequence of natural numbers, whose
+# prime divisors are all <= 5.
 hamming = list(1) do
-  hamming.mapper { |x| 2 * x }.merge(
-    hamming.mapper { |x| 3 * x }.merge(
-      hamming.mapper { |x| 5 * x }))
+  hamming.map { |x| 2 * x }.merge(
+    hamming.map { |x| 3 * x }.merge(
+      hamming.map { |x| 5 * x }))
 end
 
 max = (ARGV.shift || 100).to_i

data/examples/sieve.rb

@@ -2,15 +2,10 @@ require 'lazylist'
 
 # Sieve or Eratosthenes with filters on Lazy Lists. It has a very nice
 # notation, but is a real memory and cpu hog. Enjoy!
-
-def from(n = 0)
-  list(n) { from(n + 1) }
-end
-
-def primes(l = from(2))
+def primes(l = LazyList.from(2))
   current, rest = l.head, l.tail
   list(current) do
-    primes rest.filter { |x| (x % current) != 0 }
+    primes rest.select { |x| (x % current) != 0 }
   end
 end
 

data/lib/lazylist.rb

@@ -25,7 +25,7 @@
 #
 # * http://rubyforge.org/frs?group_id=394
 #
-# Online Documentation should be located at
+# The homepage of this library is located at
 #
 # * http://lazylist.rubyforge.org
 # 
@@ -41,48 +41,53 @@
 #  sq.take(10)
 #      ==>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 #
-# To compute every square number and do something with it you can call the
-# "each" method:
+# To compute the first 10 square numbers and do something with them you can
+# call the each method with:
 #
-# sq.each { |x| puts x }
+#  sq.each(10) { |x| puts x }
 #
-# Notice that calls to each will not return if applied to infinite lazy lists.
+# To compute every square number and do something with them you can call the
+# "each" method without an argument:
 #
-# You can also use indices on lazy lists to get the values at a certain range:
+#  sq.each { |x| puts x }
+#
+# Notice that calls to each without an argument will not return if applied to
+# infinite lazy lists.
 #
-# sq[ 0..9 ] or sq[0, 10]
+# You can also use indices on lazy lists to get the values at a certain range:
 #
+#  sq[ 0..9 ] or sq[0, 10]
 #      ==>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 # 
 # To spare memory it's possible to throw away every element after it was
 # fetched:
 #
-# sq.take!(1) => [1]
-# sq.take!(1) => [4]
+#  sq.take!(1) => [1]
+#  sq.take!(1) => [4]
 #
 # Of course it's also possible to compute more complex lists like the Fibonacci
 # sequence:
 #
-# fib = LazyList.tabulate(0) { |x| x < 2 ? 1 : fib[x-2] + fib[x-1] }
+#  fib = LazyList.tabulate(0) { |x| x < 2 ? 1 : fib[x-2] + fib[x-1] }
 #
-# fib[100] => 573147844013817084101
+#  fib[100] => 573147844013817084101
 # computes the 99th Fibonacci number. (We always start with index 0.)
-# fib[101] => 927372692193078999176
+#  fib[101] => 927372692193078999176
 # computes the 100th Fibonacci number. The already computed values are reused
 # to compute this result. That's a very transparent way to get memoization for
 # sequences that require heavy computation.
 # 
-# You create LazyLists that are based on arbitrary Enumerables, so can
-# for example wrap your passwd file in one pretty easily:
+# You can create lazy lists that are based on arbitrary Enumerables, so can for
+# example wrap your passwd file in one pretty easily:
 #
-# pw = LazyList[ File.new("/etc/passwd") ]
+#  pw = LazyList[ File.new("/etc/passwd") ]
 # 
 # Call grep to find the users root and flori:
-# pw.grep /^(root|flori):/ => ["root:x:0:0:...\n", "flori:x:500:500...\n"]
+# pw.grep /^(root|flori):/ => ["root:x:0:0:...\n",... ]
 #
 # In this case the whole passwd file is slurped into the memory. If
 # you use 
-# pw.find { |x| x =~ /^root:/ } => "root:x:0:0:root:/root:/bin/bash\n"
+#  pw.find { |x| x =~ /^root:/ } => "root:x:0:0:root:/root:/bin/bash\n"
 # instead, only every line until the root line is loaded into the memory.
 #
 # == References
@@ -91,12 +96,126 @@
 # Structure and Interpretation of Computer Programs (SICP)
 # [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-24.html#%25_sec_3.5]
 # 
-
 class LazyList
+  module Enumerable
+    include ::Enumerable
+
+    # Returns two lazy lists, the first containing the elements of this lazy
+    # list for which the block evaluates to true, the second containing the
+    # rest.
+    def partition(&block)
+      accepted, rejected = to_a.partition(&block)
+      return LazyList.from_enum(accepted), LazyList.from_enum(rejected)
+    end
+
+    # Returns a sorted version of this lazy list. This method should only be
+    # called on finite lazy lists or it will never return. Also see
+    # Enumerable#sort.
+    def sort # :yields: a, b
+      LazyList.from_enum(super)
+    end
+
+    # Returns a sorted version of this lazy list. This method should only be
+    # called on finite lazy lists or it will never return. Also see
+    # Enumerable#sort_by.
+    def sort_by # :yields: obj
+      LazyList.from_enum(super)
+    end
+
+    # Calls _block_ with two arguments, the element and its index, for each
+    # element of this lazy list. If _block_ isn't given, the method returns a
+    # lazy list that consists of [ element, index ] pairs instead.
+    def each_with_index(&block)
+      if block
+        each_with_index.each { |x| block.call(x) }
+      else
+        i = -1
+        map { |x| [ x, i += 1 ] }
+      end
+    end
+
+    # Returns the lazy list, that contains all the given _block_'s return
+    # values, if it was called on every
+    #  self[i], others[0][i], others[1][i],... others[others.size - 1][i]
+    # for i in 0..Infinity. If _block_ wasn't given
+    # this result will be the array
+    #  [self[i], others[0][i], others[1][i],... ]
+    # and a lazy list of those arrays is returned.
+    def zip(*others, &block)
+      if empty? or others.any? { |o| o.empty? }
+        Empty
+      else
+        block ||= lambda { |*all| all }
+        list(block.call(head, *others.map { |o| o.head })) do
+          tail.zip(*others.map { |o| o.tail}, &block)
+        end
+      end
+    end
+
+    # obsoleted by #zip
+    def combine(other, &operator)
+      warn "method 'combine' is obsolete - use 'zip'"
+      zip(other, &operator)
+    end
+
+    # Returns a lazy list every element of this lazy list for which
+    # pattern ===  element is true. If the optional _block_ is supplied,
+    # each matching element is passed to it, and the block's result becomes
+    # an element of the returned lazy list.
+    def grep(pattern, &block)
+      result = select { |x| pattern === x }
+      block and result = result.map(&block)
+      result
+    end
+
+    # Returns a lazy list of all elements of this lazy list for which the block
+    # is false (see also +Lazylist#select+).
+    def reject
+      select { |obj| !yield(obj) }
+    end
+
+    # Returns a lazy list of all elements of this lazy list for which _block_
+    # is true.
+    def select(&block)
+      block = Identity unless block
+      s = self
+      until s.empty? or block[s.head] do
+        s = s.tail
+      end
+      return Empty if s.empty?
+      self.class.new(s.head) { s.tail.select(&block) }
+    end
+    alias find_all select
+
+    # obsoleted by #select
+    def filter(&p)
+      warn "method 'filter' is obsolete - use 'select'"
+      select(&p)
+    end
+
+    # Creates a new Lazylist that maps the block or Proc object f to every
+    # element in the old list.
+    def map(&f)
+      return Empty if empty?
+      f = Identity unless f
+      self.class.new(f[head]) { tail.map(&f) }
+    end
+    alias collect map
+
+    # obsoleted by #map
+    def mapper(&f)
+      warn "method 'mapper' is obsolete - use 'map'"
+      map(&f)
+    end
+  end
+  include LazyList::Enumerable
+
+  # Exceptions raised by the LazyList implementation.
+  class Exception < ::Exception; end
 
   # ReadQueue is the implementation of an read-only queue that only supports
   # #pop and #empty? methods.  It's used as a wrapper to encapsulate
-  # enumerables in LazyLists.
+  # enumerables in lazy lists.
   class ReadQueue
     # Creates an ReadQueue object from an enumerable.
     def initialize(enumerable)
@@ -127,12 +246,7 @@ class LazyList
     end
   end
 
-  include Enumerable
-
-  # Exceptions raised by the LazyList implementation.
-  class Exception < ::Exception; end
-
-  # Returns a new LazyList, unless head and tail are nil. In the latter case
+  # Returns a new lazy list, unless head and tail are nil. In the latter case
   # LazyList::Empty is returned.
   def self.new(head, tail = nil, &promise)
     if head.nil? and tail.nil?
@@ -161,7 +275,7 @@ class LazyList
   end
 
   # Denotes the empty LazyList which is a guard at the end of finite
-  # LazyLists.
+  # lazy lists.
   Empty = new(nil, nil)
 
   # Returns the value of this element.
@@ -189,17 +303,20 @@ class LazyList
   # Identity lambda expression, mostly used as a default.
   Identity = lambda { |x| x }
 
-  # Returns a LazyList which is generated by LazyList.from_enum or
-  # LazyList.span. (See below.)
+  # Returns a lazy list which is generated by LazyList.from_enum or
+  # LazyList.span.
   def self.[](a, n = nil)
-    if n
+    case
+    when n
       span(a, n)
+    when IO === a
+      io(a)
     else
       from_enum(a)
     end
   end
 
-  # Generates a LazyList from any data structure e which
+  # Generates a lazy list from any data structure e which
   # responds to the #each method. 
   def self.from_enum(e)
     oq = ReadQueue.new(e)
@@ -214,7 +331,7 @@ class LazyList
     new(oq.pop, next_top)
   end
 
-  # Generates a finite LazyList beginning with element a and spanning
+  # Generates a finite lazy list beginning with element a and spanning
   # n elements. The data structure members have to support the
   # successor method succ.
   def self.span(a, n)
@@ -225,7 +342,7 @@ class LazyList
     end
   end
 
-  # Generates a LazyList which tabulates every element beginning with n
+  # Generates a lazy list which tabulates every element beginning with n
   # and succeding with succ by calling the Proc object f or the given block.
   # If none is given the identity function is computed instead.
   def self.tabulate(n = 0, &f)
@@ -233,16 +350,25 @@ class LazyList
     new(f[n]) { tabulate(n.succ, &f) }
   end
 
-  # Generates a LazyList which iterates over its previous values
+  # Returns a list of all elements succeeding _n_ and starting from _n_.
+  def self.from(n = 0)
+    tabulate(n)
+  end
+  
+  # Generates a lazy list which iterates over its previous values
   # computing something like: f(i), f(f(i)), f(f(f(i))), ...
   def self.iterate(i = 0, &f)
     new(i) { iterate(f[i], &f) }
   end
 
-  # Generates a LazyList of a give IO-object using a given
+  # Generates a lazy list of a give IO-object using a given
   # block or Proc object to read from this object.
-  def self.io(io, &f)
-    io.eof? ? Empty : new(f[io]) { io(io, &f) }
+  def self.io(input, &f)
+    if f
+      input.eof? ? Empty : new(f[input]) { io(input, &f) }
+    else
+      input.eof? ? Empty : new(input.readline) { io(input) }
+    end
   end
 
   # Returns the n-th LazyList-Object.
@@ -269,19 +395,18 @@ class LazyList
   # returned.
   def [](n, m = nil)
     if n.is_a? Range
-      n.map { |i| ref(i).head }
+      LazyList[take_range(n)]
     elsif n < 0
       nil
     elsif m
-      s = ref(n)
-      s ? s.take(m) : nil
+      LazyList[take_span(n, m)]
     else
       ref(n).head rescue nil
     end
   end
 
   # Iterates over all elements. If n is given only n iterations are done.
-  # If self is a finite LazyList each returns also if there are no more
+  # If self is a finite lazy list each returns also if there are no more
   # elements to iterate over.
   def each(n = nil)
     s = self
@@ -306,30 +431,11 @@ class LazyList
     self
   end
 
-  # Filters only elements for which predicate p is true.
-  def filter(&p)
-    p = Identity unless p
-    s = self
-    until s.empty? or p[s.head] do
-      s = s.tail
-    end
-    return Empty if s.empty?
-    self.class.new(s.head) { s.tail.filter(&p) }
-  end
-
-  # Creates a new Lazylist that maps the block or Proc object f to every
-  # element in the old list.
-  def mapper(&f)
-    return Empty if empty?
-    f = Identity unless f
-    self.class.new(f[head]) { tail.mapper(&f) }
-  end
-
-  # Merges this LazyList with the other. It uses the &compare block to decide
-  # which elements to place first in the result LazyList. If no compare block
+  # Merges this lazy list with the other. It uses the &compare block to decide
+  # which elements to place first in the result lazy list. If no compare block
   # is given lambda { |a,b| a < b } is used as a default value.
   def merge(other, &compare)
-    compare = lambda { |a,b| a < b } unless compare
+    compare = lambda { |a, b| a < b } unless compare
     return other if empty?
     return self if other.empty?
     if compare[head, other.head]
@@ -341,17 +447,6 @@ class LazyList
     end
   end
 
-  # Combines this LazyList with the other to a new LazyList.
-  # The elements of the resulting lists are computed
-  # by calling the binary operator block on the two elemnts
-  # of the input lists. E.g. lambda { |x, y| x + y } adds
-  # the two input lists.
-  def combine(other, &operator)
-    self.class.new(operator.call(head, other.head)) do
-      tail.combine(other.tail, &operator)
-    end
-  end
-
   # Takes the next n elements and returns them as an array.
   def take(n = 1)
     result = []
@@ -359,27 +454,40 @@ class LazyList
     result
   end
 
+  # Takes the _range_ indexes of elements from this lazylist and returns them
+  # as an array.
+  def take_range(range) 
+    range.map { |i| ref(i).head }
+  end
+
+  # Takes the m elements starting at index n of this lazy list and returns them
+  # as an array.
+  def take_span(n, m)
+    s = ref(n)
+    s ? s.take(m) : nil
+  end
+
   # Takes the next n elements and returns them as an array. It destroys these
-  # elements in the LazyList.
+  # elements in this lazy list. Also see #each! .
   def take!(n = 1)
     result = []
     each!(n) { |x| result << x }
     result
   end
 
-  # Drops the next n elements and returns the rest of this LazyList. n
+  # Drops the next n elements and returns the rest of this lazy list. n
   # defaults to 1.
   def drop(n = 1)
     each(n) { }
   end
 
-  # Drops the next n elements, destroys them in the LazyList and
-  # returns the rest of this LazyList.
+  # Drops the next n elements, destroys them in the lazy list and
+  # returns the rest of this lazy list. Also see #each! .
   def drop!(n = 1)
     each!(n) { }
   end
 
-  # Returns the size. This is only sensible if the LazyList is finite
+  # Returns the size. This is only sensible if the lazy list is finite
   # of course.
   def size
     inject(0) { |s,| s += 1 }
@@ -387,7 +495,7 @@ class LazyList
 
   alias length size
 
-  # Returns true if this is the empty LazyList.
+  # Returns true if this is the empty lazy list.
   def empty?
     self.equal? Empty
   end
@@ -398,7 +506,7 @@ class LazyList
   def eql?(other)
     other.is_a? self.class or return false
     size == other.size or return false
-    zip(other) { |x,y| x == y or return false }
+    to_a.zip(other.to_a) { |x, y| x == y or return false }
     true
   end
   alias == eql?
@@ -439,19 +547,28 @@ module Kernel
   # cannot be described well with LazyList#iterate or LazyList#tabulate.
   #
   # - list without any arguments, returns the empty lazy list LazyList::Empty.
-  # - list(x) returns the lazy list with only the element x as a member.
-  # - list(x) { l } returns the lazy list with the element x as a head
-  #   element, and that is continued with the lazy list l as tail. To define an
-  #   infinite lazy list of 1s you can do: ones = list(1) { ones }.
-  def list(value = LazyList::Empty, &promise)
-    if block_given?
-      LazyList.new(value, &promise)
-    elsif value.equal? LazyList::Empty
-      value
-    else
-      LazyList.new(value) { LazyList::Empty }
+  # - list(x) returns the lazy list with only the element x as a member,
+  #   list(x,y) returns the lazy list with only the elements x and y as a
+  #   members, and so on.
+  # - list(x) { xs } returns the lazy list with the element x as a head
+  #   element, and that is continued with the lazy list xs as tail. To define an
+  #   infinite lazy list of 1s you can do:
+  #    ones = list(1) { ones } # => [1,... ]
+  #   To define all even numbers directly, you can do:
+  #    def even(n = 0) list(n) { even(n + 2) } end
+  #   and then:
+  #    e = even # => [0,... ]
+  def list(*values, &promise)
+    result = LazyList::Empty
+    last = nil
+    values.reverse_each do |v|
+      result = LazyList.new(v, result)
+      last ||= result
+    end
+    if last and block_given?
+      last.instance_variable_set :@tail, promise
     end
+    result
   end
 end
-
   # vim: set et sw=2 ts=2:

data/make_doc.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-$outdir = 'doc/'
-puts "Creating documentation in '#$outdir'."
-system "rdoc -o #$outdir lib/lazylist.rb"
+puts "Creating documentation."
+system "rdoc -d lib/lazylist.rb"
   # vim: set et sw=2 ts=2:

data/tests/runner.rb

@@ -5,13 +5,18 @@ require 'test/unit/testsuite'
 $:.unshift File.expand_path(File.dirname($0))
 $:.unshift 'lib'
 $:.unshift '../lib'
-#require 'coverage'
+begin
+  #require 'coverage'
+rescue LoadError
+end
 require 'test'
+require 'test_enumerable'
 
 class TS_AllTests
   def self.suite
-    suite = Test::Unit::TestSuite.new
+    suite = Test::Unit::TestSuite.new 'All tests'
     suite << TC_LazyList.suite
+    suite << TC_LazyEnumerable.suite
   end
 end
 Test::Unit::UI::Console::TestRunner.run(TS_AllTests)

data/tests/test.rb

@@ -22,10 +22,10 @@ class TC_LazyList < Test::Unit::TestCase
     @natural = LazyList.tabulate(1)
     @ones = LazyList.iterate(1) { 1 }
     @oddp = lambda { |x| x % 2 == 1 }
-    @odd = @natural.filter(&@oddp)
+    @odd = @natural.select(&@oddp)
     @evenp = lambda { |x| x % 2 == 0 }
-    @boolean = @natural.mapper { |x| x % 2 == 0}
-    @even = @natural.filter(&@evenp)
+    @boolean = @natural.map { |x| x % 2 == 0}
+    @even = @natural.select(&@evenp)
     @finite_inner0 = MyEnum.new(0)
     @finite0 = LazyList[@finite_inner0]
     @finite_inner1 = MyEnum.new(1)
@@ -78,39 +78,39 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal(10, @finite_span.length)
   end
 
-  def test_filter
+  def test_select
     assert_equal(1, @odd[0])
     assert_equal(3, @odd[1])
     assert_equal(5, @odd[2])
-    assert_equal((1..19).select(&@oddp), @odd[0, 10])
-    assert_equal((1..10).to_a, @natural[0, 10])
+    assert_equal((1..19).select(&@oddp), @odd[0, 10].to_a)
+    assert_equal((1..10).to_a, @natural[0, 10].to_a)
     assert_equal([ 1 ] * 10, @ones[0, 10].to_a)
-    ends_with_a = @strings.filter { |x| x[-1] == ?a }
-    assert(ends_with_a[0, 27] ==
+    ends_with_a = @strings.select { |x| x[-1] == ?a }
+    assert(ends_with_a[0, 27].to_a ==
       [ "a", ("a".."z").map { |x| x + "a" }  ].flatten)
   end
 
   def test_map
-    id = @natural.mapper
+    id = @natural.map
     assert_equal(1, id[0])
     assert_equal(2, id[1])
     assert_equal(3, id[2])
-    assert_equal((1..10).to_a, id[0, 10])
-    assert_equal((1..10).to_a, @natural[0, 10])
+    assert_equal((1..10).to_a, id[0, 10].to_a)
+    assert_equal((1..10).to_a, @natural[0, 10].to_a)
     squaredf = lambda { |x| x ** 2 }
-    squared = @natural.mapper(&squaredf)
+    squared = @natural.map(&squaredf)
     assert_equal(1, squared[0])
     assert_equal(4, squared[1])
     assert_equal(9, squared[2])
-    assert_equal((1..10).map(&squaredf), squared[0, 10])
-    assert_equal((1..10).to_a, @natural[0, 10])
+    assert_equal((1..10).map(&squaredf), squared[0, 10].to_a)
+    assert_equal((1..10).to_a, @natural[0, 10].to_a)
     strangef = lambda { |x| x * (x[0] - ?a + 1) }
-    strange = @strings.mapper(&strangef)
+    strange = @strings.map(&strangef)
     assert_equal("a", strange[0])
     assert_equal("bb", strange[1])
     assert_equal("ccc", strange[2])
-    assert_equal(("a".."z").map(&strangef), strange[0, 26])
-    assert_equal(("a".."z").to_a, @strings[0, 26])
+    assert_equal(("a".."z").map(&strangef), strange[0, 26].to_a)
+    assert_equal(("a".."z").to_a, @strings[0, 26].to_a)
   end
 
   def test_index
@@ -118,7 +118,8 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal(1, @natural[0])
     assert_equal(2, @natural[1])
     assert_equal(nil, @natural[-1, 10])
-    assert_equal((1..10).to_a, @natural[0, 10])
+    assert_equal(LazyList[1..10], @natural[0, 10])
+=begin
     assert_equal((6..15).to_a, @natural[5, 10])
     assert_equal((1..1).to_a, @natural[0..0])
     assert_equal((1..0).to_a, @natural[0..-1])
@@ -128,6 +129,7 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal((6..15).to_a, @natural[5..14])
     assert_equal((1..10).to_a, @natural[0...10])
     assert_equal((6..15).to_a, @natural[5...15])
+=end
   end
 
   def test_merge
@@ -137,7 +139,7 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal(@natural[0, 10].to_a, natural[0, 10].to_a)
     double_list = @natural.merge(@natural) { |a,b| a <= b }
     assert(double_list[0, 10].to_a, (1..5).map { |x| [x, x] }.flatten)
-    odd2 = @natural.filter(&@oddp).drop(1)
+    odd2 = @natural.select(&@oddp).drop(1)
     some = @even.merge(odd2)
     assert_equal(@natural[1, 9].to_a, some[0, 9].to_a)
   end
@@ -207,7 +209,7 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal(nil, f[-1])
     assert_equal(5, f[0])
     assert_equal(26, f[1])
-    assert_equal([5, 26, 13, 66, 33, 166, 83, 416], f[0, 8])
+    assert_equal([5, 26, 13, 66, 33, 166, 83, 416], f[0, 8].to_a)
   end
 
   def test_inpsect
@@ -224,10 +226,10 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", l.inspect)
   end
 
-  def test_combine
-    combined = @natural.combine(@ones) { |x, y| x + y }
-    assert_equal (12..21).to_a, combined[10,10]
-    assert_equal (2..11).to_a, combined[0,10]
+  def test_zip
+    combined = @natural.zip(@ones) { |x, y| x + y }
+    assert_equal (12..21).to_a, combined[10,10].to_a
+    assert_equal (2..11).to_a, combined[0,10].to_a
   end
 
   def from(n = 0)
@@ -235,7 +237,7 @@ class TC_LazyList < Test::Unit::TestCase
   end
 
   def odd
-    from(1).filter { |x| x % 2 == 1 }
+    from(1).select { |x| x % 2 == 1 }
   end
 
   def test_list

data/tests/test_enumerable.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'lazylist'
+
+class TC_LazyEnumerable < Test::Unit::TestCase
+  def setup
+    @a = LazyList[%w[abc cdef aab efgh eefgh hijkl]]
+    @o = list(1) { @o }
+    @n = LazyList.from(1)
+    @l = LazyList[1..5]
+    @m = LazyList[5..8]
+    @r = [5, -2, 3, 13, 0]
+    @s = LazyList[@r]
+  end
+
+  def test_zip
+    l = @l.zip @m
+    assert_kind_of LazyList, l
+    assert_equal [[1, 5], [2, 6], [3, 7], [4, 8]], l.to_a
+  end
+
+  def test_zip_and_block
+    l = @l.zip(@m) { |x,y| x + y }
+    assert_kind_of LazyList, l
+    assert_equal [6, 8, 10, 12], l.to_a
+    zipped = @n.zip(@o) { |x, y| x + y }
+    assert_kind_of LazyList, zipped
+    assert_equal (12..21).to_a, zipped[10,10].to_a
+    assert_equal (2..11).to_a, zipped[0,10].to_a
+  end
+
+  def test_zip_multiple_and_block
+    zipped = @n.zip(@o, @m) { |x, y, z| x * z + y }
+    assert_kind_of LazyList, zipped
+    assert_equal [6, 13, 22, 33], zipped.to_a
+  end
+
+  def test_each_with_index
+    l = @m.each_with_index
+    assert_kind_of LazyList, l
+    assert_equal l.to_a, [ [5, 0], [6, 1], [7, 2], [8, 3] ]
+  end
+
+  def test_each_with_index_and_block
+    @m.each_with_index { |x, i| assert_equal x - 5, i }
+  end
+
+  def test_sort
+    l = @s.sort
+    assert_kind_of LazyList, l
+    assert @r.sort, l
+  end
+
+  def test_sort_by
+    l = @s.sort_by { |x| -x }
+    assert_kind_of LazyList, l
+    assert @r.sort_by { |x| -x }, l
+  end
+
+  def test_grep
+    l = @a.grep /e/
+    assert_kind_of LazyList, l
+    assert_equal %w[cdef efgh eefgh], l.to_a
+  end
+
+  def test_grep_with_block
+    expected = %w[cdef efgh eefgh]
+    i = 0 
+    l = @a.grep(/e/) do |x|
+      assert_equal expected[i], x
+    end
+  end
+
+  def test_reject
+    odd = @n.select { |x| x % 2 == 1 }
+    assert_kind_of LazyList, odd
+    assert_equal [1, 3, 5, 7, 9], odd.take(5)
+  end
+
+  def test_reject
+    odd = @n.reject { |x| x % 2 == 0 }
+    assert_kind_of LazyList, odd
+    assert_equal [1, 3, 5, 7, 9], odd.take(5)
+  end
+
+  def test_partition
+    even, odd = @l.partition { |x| x % 2 == 0 }
+    assert_kind_of LazyList, odd
+    assert_kind_of LazyList, even
+    assert_equal [2, 4], even.take(5)
+    assert_equal [1, 3, 5], odd.take(5)
+  end
+end
+  # vim: set et sw=2 ts=2: 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: lazylist
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
-date: 2005-10-03 00:00:00 +02:00
+  version: 0.2.0
+date: 2005-10-08 00:00:00 +02:00
 summary: Implementation of lazy lists for Ruby
 require_paths: 
   - lib
@@ -32,6 +32,7 @@ files:
   - examples
   - install.rb
   - GPL
+  - TODO
   - Rakefile
   - VERSION
   - tests
@@ -44,6 +45,7 @@ files:
   - examples/pi.rb
   - examples/examples.rb
   - tests/test.rb
+  - tests/test_enumerable.rb
   - tests/runner.rb
   - lib/lazylist.rb
 test_files: