lazylist 0.1.2 → 0.1.3

data/CHANGES

@@ -1,8 +1,12 @@
+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
+                     method. Sorry, if you don't like it. ;)
 2004-09-30 * 0.1.2 * Added combine method.
                    * The ref method now uses a hash to cache return values.
-		     This is not what I would still call a list datastructure.
+                     This is not what I would still call a list datastructure.
                      It increases memory consumption (as if that would matter
-		     anymore), too. But it speeds up things a great deal, if
+                     anymore), too. But it speeds up things a great deal, if
                      you persist on using indexes into a list.
                    * Rakefile added
                    * Supports Rubygems now

data/GPL

@@ -1,12 +1,12 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                        59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -56,7 +56,7 @@ patent must be licensed for everyone's free use or not licensed at all.
   The precise terms and conditions for copying, distribution and
 modification follow.
 
-		    GNU GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-			    NO WARRANTY
+                            NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-		     END OF TERMS AND CONDITIONS
+                     END OF TERMS AND CONDITIONS
 
-	    How to Apply These Terms to Your New Programs
+            How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it

data/Rakefile

@@ -1,5 +1,3 @@
-# Rakefile for File::Tail  -*- ruby -*-
-
 require 'rake/gempackagetask'
 require 'rbconfig'
 
@@ -8,64 +6,75 @@ include Config
 PKG_NAME = 'lazylist'
 PKG_VERSION = File.read('VERSION').chomp
 PKG_FILES = Dir.glob("**/*").delete_if { |item|
-    item.include?("CVS") or item.include?("pkg")
+  item.include?("CVS") or item.include?("pkg")
 }
 
+desc "Run unit tests"
+task(:test) do
+  cd 'tests' do
+    ruby %{-I../ext runner.rb}
+  end
+end
+
 desc "Installing library"
 task :install  do
-    libdir = CONFIG["sitelibdir"]
-    install('lib/lazylist.rb', libdir)
+  libdir = CONFIG["sitelibdir"]
+  install('lib/lazylist.rb', libdir)
 end
 
-spec = Gem::Specification.new do |s|
+desc "Creating documentation"
+task :doc do
+  ruby 'make_doc.rb'
+end
 
-    #### Basic information.
+spec = Gem::Specification.new do |s|
+  #### Basic information.
 
-    s.name = 'lazylist'
-    s.version = PKG_VERSION
-    s.summary = "Implementation of lazy lists for Ruby"
-    s.description = ""
+  s.name = 'lazylist'
+  s.version = PKG_VERSION
+  s.summary = "Implementation of lazy lists for Ruby"
+  s.description = ""
 
-    #### Dependencies and requirements.
+  #### Dependencies and requirements.
 
-    #s.add_dependency('log4r', '> 1.0.4')
-    #s.requirements << ""
+  #s.add_dependency('log4r', '> 1.0.4')
+  #s.requirements << ""
 
-    s.files = PKG_FILES
+  s.files = PKG_FILES
 
-    #### C code extensions.
+  #### C code extensions.
 
-    #s.extensions << "ext/extconf.rb"
+  #s.extensions << "ext/extconf.rb"
 
-    #### Load-time details: library and application (you will need one or both).
+  #### Load-time details: library and application (you will need one or both).
 
-    s.require_path = 'lib'                         # Use these for libraries.
-    s.autorequire = 'lazylist'
+  s.require_path = 'lib'             # Use these for libraries.
+  s.autorequire = 'lazylist'
 
-    #s.bindir = "bin"                               # Use these for applications.
-    #s.executables = ["bla.rb"]
-    #s.default_executable = "bla.rb"
+  #s.bindir = "bin"                 # Use these for applications.
+  #s.executables = ["bla.rb"]
+  #s.default_executable = "bla.rb"
 
-    #### Documentation and testing.
+  #### Documentation and testing.
 
-    s.has_rdoc = true
-    #s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
-    #s.rdoc_options <<
-    #  '--title' <<  'Rake -- Ruby Make' <<
-    #  '--main' << 'README' <<
-    #  '--line-numbers'
-    s.test_files << 'tests/test.rb'
+  s.has_rdoc = true
+  #s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+  #s.rdoc_options <<
+  #  '--title' <<  'Rake -- Ruby Make' <<
+  #  '--main' << 'README' <<
+  #  '--line-numbers'
+  s.test_files << 'tests/test.rb'
 
-    #### Author and project details.
+  #### Author and project details.
 
-    s.author = "Florian Frank"
-    s.email = "flori@ping.de"
-    s.homepage = "http://lazylist.rubyforge.org"
-    s.rubyforge_project = "lazylist"
+  s.author = "Florian Frank"
+  s.email = "flori@ping.de"
+  s.homepage = "http://lazylist.rubyforge.org"
+  s.rubyforge_project = "lazylist"
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_tar = true
-    pkg.package_files += PKG_FILES
+  pkg.need_tar = true
+  pkg.package_files += PKG_FILES
 end
-    # vim: set et sw=4 ts=4:
+  # vim: set et sw=2 ts=2:

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/examples/examples.rb

@@ -1,15 +1,20 @@
 require 'lazylist'
 
-puts "Random number lazy list"
-rand = lambda { |s| ((s * 1103515245 + 12345) / 65536) % 32768 }
-r = LazyList.iterate(rand[666], &rand)
-r.each(10) { |x| print x, " " } ; puts
-r = LazyList.iterate(rand[666], &rand).mapper { |x| 1 + x % 6 }
+puts "Random number lazy list (infinite)"
+def rand(s = 666)
+  current = ((s * 1103515245 + 12345) / 65536) % 32768 
+  list(current) { rand(current) }
+end
+r = rand(666)
 r.each(10) { |x| print x, " " } ; puts
+dice = rand(666).mapper { |x| 1 + x % 6 }
+dice.each(10) { |x| print x, " " } ; puts
+coin = rand(666).mapper { |x| x % 2 == 0 ? :head : :tail }
+coin.each(10) { |x| print x, " " } ; puts
 
-puts "Prime number lazy list with filter"
+puts "Prime number lazy list with filter (10000..1000000)"
 prime = LazyList[10000..1000000].filter do |x|
-	not (2..Math.sqrt(x).to_i).find { |d| x % d == 0 }
+  not (2..Math.sqrt(x).to_i).find { |d| x % d == 0 }
 end
 prime.each(10) { |x| print x, " " } ; puts
 p prime[1]
@@ -26,8 +31,8 @@ hailstone = LazyList.iterate(7) { |x| x % 2 == 0 ? x / 2 : 3 * x + 1 }
 hailstone.each(20) { |x| print x, " " } ; puts
 terras = LazyList.iterate(7) { |x| x % 2 == 0 ? x / 2 : (3 * x + 1) / 2 }
 terras.each(20) { |x| print x, " " } ; puts
-wolfram = LazyList.iterate(7) do |x|
-	((3.0 / 2) * (x % 2 == 0 ? x : x + 1)).to_i
+wolfram = LazyList.iterate(1) do |x|
+  ((3.0 / 2) * (x % 2 == 0 ? x : x + 1)).to_i
 end
 wolfram.each(15) { |x| print x, " " } ; puts
 puts
@@ -42,7 +47,7 @@ puts "Sum up odd numbers lazylist to get a squares stream"
 odd = LazyList.tabulate(1) { |x| 2 * x - 1 }
 puts odd
 squares = LazyList.tabulate(0) do |x|
-	(0..x).inject(0) { |s, i| s + odd[i] }
+  (0..x).inject(0) { |s, i| s + odd[i] }
 end
 puts squares
 squares.each(10) { |x| print x, " " } ; puts
@@ -53,12 +58,12 @@ puts
 puts "Lazy lists from io objects"
 me = LazyList.io(File.new($0)) { |io| io.readline }
 me.each(6) { |line| puts line }
-p me[55]
+p me[60]
 puts me.length
 puts
 
 me = LazyList[File.new($0)]
 me.each(6) { |line| puts line }
-p me[61]
+p me[66]
 puts me.length
-	# vim: set noet sw=4 ts=4: 
+  # vim: set et sw=2 ts=2: 

data/examples/hamming.rb

@@ -1,18 +1,18 @@
 require 'lazylist'
 
-# Computes the hamming sequence: that is the sequence of natural numbers that
-# are dividable only by 1, 2, 3 or 5.
-hamming = LazyList.new(1) do
-	hamming.mapper { |x| 2 * x }.merge(
-		hamming.mapper { |x| 3 * x }.merge(
-			hamming.mapper { |x| 5 * x }))
+# Computes the hamming sequence: that is the sequence of natural numbers, that
+# are multiples of 2, 3, and 5.
+hamming = list(1) do
+  hamming.mapper { |x| 2 * x }.merge(
+    hamming.mapper { |x| 3 * x }.merge(
+      hamming.mapper { |x| 5 * x }))
 end
 
 max = (ARGV.shift || 100).to_i
 hamming.each(max) do |x|
-	print x, " "
-	STDOUT.flush
+  print x, " "
+  STDOUT.flush
 end
 puts
 print hamming[1000], ", ", hamming[1001], "\n"
-	# vim: set noet sw=4 ts=4: 
+  # vim: set et sw=2 ts=2: 

data/examples/pi.rb

@@ -9,24 +9,27 @@ require 'lazylist'
 #
 
 def f(q,r,t, k)
-	n = (3 * q + r) / t
-	if n == (4 * q + r) / t
-		LazyList.new(n) { f(10 * q, 10 * (r - n * t), t, k) }
-	else
-		f(q * k, q * (4 * k + 2) + r * (2 * k + 1), t * (2 * k + 1), k + 1)
-	end
+  n = (3 * q + r) / t
+  if n == (4 * q + r) / t
+    list(n) { f(10 * q, 10 * (r - n * t), t, k) }
+  else
+    f(q * k, q * (4 * k + 2) + r * (2 * k + 1), t * (2 * k + 1), k + 1)
+  end
 end
 
-max = ARGV.empty? ? nil : ARGV.shift.to_i
-pi = f(1, 0, 1, 1)	# Setup my lazy list
-sum = pi[0, 1000].inject(0) do |s, i| s += i end
-puts "Sum of the first 1000 digitis of pi: #{sum}"
-puts "500th digit using memoized computation: #{pi[499]}"
+PI = f(1, 0, 1, 1)  # Setup my lazy list
 
-puts "Printing #{max ? "the first #{max}" : "all the "} digits of pi:"
-pi.each!(max) do |x|
-	STDOUT.print x
-	STDOUT.flush
+if $0 == __FILE__
+  max = ARGV.empty? ? nil : ARGV.shift.to_i
+  sum = PI[0, 1000].inject(0) do |s, i| s += i end
+  puts "Sum of the first 1000 digitis of pi: #{sum}"
+  puts "500th digit using memoized computation: #{PI[499]}"
+
+  puts "Printing #{max ? "the first #{max}" : "all the "} digits of pi:"
+  PI.each!(max) do |x|
+    STDOUT.print x
+    STDOUT.flush
+  end
+  puts
 end
-puts
-	# vim: set noet sw=4 ts=4: 
+  # vim: set et sw=2 ts=2: 

data/examples/sieve.rb

@@ -3,20 +3,21 @@ 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!
 
-class LazyList
-
-	def prime_filter
-		LazyList.new(head) do
-			tail.filter { |x| x % head != 0 }.prime_filter
-		end
-	end
+def from(n = 0)
+  list(n) { from(n + 1) }
+end
 
+def primes(l = from(2))
+  current, rest = l.head, l.tail
+  list(current) do
+    primes rest.filter { |x| (x % current) != 0 }
+  end
 end
 
 max = (ARGV.shift || 100).to_i
-LazyList.tabulate(2) { |x| x }.prime_filter.each(max) do |x|
-	print x, " "
-	STDOUT.flush
+primes.each(max) do |x|
+  print x, " "
+  STDOUT.flush
 end
 puts
-	# vim: set noet sw=4 ts=4: 
+  # vim: set et sw=2 ts=2: 

data/lib/lazylist.rb

@@ -1,9 +1,5 @@
 # = lazylist.rb - Implementation of lazy lists for Ruby
 #
-# == Author
-#
-# Florian Frank mailto:flori@ping.de
-#
 # == Description
 #
 # This class implements lazy lists (or streams) for Ruby. Such lists avoid the
@@ -12,6 +8,26 @@
 # that hasn't been used yet is calculated on the fly and saved into the list.
 # A value which is used for a second time is computed only once and just read
 # out of memory for the second usage.
+#
+# == Author
+#
+# Florian Frank mailto:flori@ping.de
+#
+# == License
+#
+# This is free software; you can redistribute it and/or modify it under the
+# terms of the GNU General Public License Version 2 as published by the Free
+# Software Foundation: www.gnu.org/copyleft/gpl.html
+#
+# == Download
+#
+# The latest version of this library can be downloaded at
+#
+# * http://rubyforge.org/frs?group_id=394
+#
+# Online Documentation should be located at
+#
+# * http://lazylist.rubyforge.org
 # 
 # == Example
 #
@@ -30,7 +46,7 @@
 #
 # sq.each { |x| puts x }
 #
-# Notice that calls to each will not return if applied to infinite lazylists.
+# Notice that calls to each will not return if applied to infinite lazy lists.
 #
 # You can also use indices on lazy lists to get the values at a certain range:
 #
@@ -82,11 +98,19 @@ class LazyList
   # #pop and #empty? methods.  It's used as a wrapper to encapsulate
   # enumerables in LazyLists.
   class ReadQueue
-
     # Creates an ReadQueue object from an enumerable.
     def initialize(enumerable)
       @enumerable = enumerable
-      prepare
+      @break = proc {}
+      @enumerable.each do |x|
+        @current = x
+        callcc do |@continue|
+          @break.call
+          return
+        end
+      end
+      @continue = false
+      @break.call
     end
 
     # Extracts the top element from the queue or nil if the queue is
@@ -101,42 +125,45 @@ class LazyList
     def empty?
       @continue == false
     end
-
-    private 
-
-    def prepare
-      @break = lambda {}
-      @enumerable.each do |x|
-        @current = x
-        callcc do |@continue|
-          @break.call
-          return
-        end
-      end
-      @continue = false
-      @break.call
-    end
-
   end
 
-  include Enumerable  # OK. Infinite lazy lists aren't really enumerable...
+  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
+  # LazyList::Empty is returned.
+  def self.new(head, tail = nil, &promise)
+    if head.nil? and tail.nil?
+      if LazyList.const_defined?(:Empty)
+        Empty
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
   # Creates a new LazyList element. The tail can be given either as
   # second argument or as block.
-  def initialize(head, tail = nil, &block_tail)
+  def initialize(head, tail = nil, &promise)
     @ref_cache = {}
     if tail
-      raise LazyList::Exception.new(
-        "Use block xor second argument for constructor") if block_tail
+      promise and
+        raise LazyList::Exception,
+          "Use block xor second argument for constructor"
       @head, @tail = head, tail
-    elsif block_tail
-      @head, @tail = head, block_tail
+    elsif promise
+      @head, @tail = head, promise
     end
   end
 
+  # Denotes the empty LazyList which is a guard at the end of finite
+  # LazyLists.
+  Empty = new(nil, nil)
+
   # Returns the value of this element.
   attr_accessor :head
   protected :head=
@@ -148,25 +175,21 @@ class LazyList
   # Returns the next element by computing its value if necessary.
   def tail
     if @tail.is_a? Proc
-      @tail = @tail[@head]
+      @tail = @tail[@head] || Empty
     end
     @tail
   end
 
-  # Returns the tail of this list without dooing evaluation.
+  # Returns the tail of this list without evaluating.
   def peek_tail
     @tail
   end
   protected :peek_tail
 
-  # Denotes the empty LazyList which is a guard at the end of finite
-  # LazyLists.
-  Empty = new(nil, nil)
-
   # Identity lambda expression, mostly used as a default.
   Identity = lambda { |x| x }
 
-  # Returns a finite LazyList which is generated by LazyList.from_enum or
+  # Returns a LazyList which is generated by LazyList.from_enum or
   # LazyList.span. (See below.)
   def self.[](a, n = nil)
     if n
@@ -176,12 +199,12 @@ class LazyList
     end
   end
 
-  # Generates a finite LazyList from any datastructure e which
+  # Generates a LazyList from any data structure e which
   # responds to the #each method. 
   def self.from_enum(e)
     oq = ReadQueue.new(e)
     return Empty if oq.empty?
-    next_top = lambda do
+    next_top = proc do
       if oq.empty?
         Empty
       else
@@ -192,7 +215,7 @@ class LazyList
   end
 
   # Generates a finite LazyList beginning with element a and spanning
-  # n elements. The datastructure members have to support the
+  # n elements. The data structure members have to support the
   # successor method succ.
   def self.span(a, n)
     if n > 0
@@ -205,14 +228,14 @@ class LazyList
   # Generates a LazyList 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, &f)
+  def self.tabulate(n = 0, &f)
     f = Identity unless f
     new(f[n]) { tabulate(n.succ, &f) }
   end
 
   # Generates a LazyList which iterates over its previous values
   # computing something like: f(i), f(f(i)), f(f(f(i))), ...
-  def self.iterate(i, &f)
+  def self.iterate(i = 0, &f)
     new(i) { iterate(f[i], &f) }
   end
 
@@ -330,7 +353,7 @@ class LazyList
   end
 
   # Takes the next n elements and returns them as an array.
-  def take(n)
+  def take(n = 1)
     result = []
     each(n) { |x| result << x }
     result
@@ -338,7 +361,7 @@ class LazyList
 
   # Takes the next n elements and returns them as an array. It destroys these
   # elements in the LazyList.
-  def take!(n)
+  def take!(n = 1)
     result = []
     each!(n) { |x| result << x }
     result
@@ -346,13 +369,13 @@ class LazyList
 
   # Drops the next n elements and returns the rest of this LazyList. n
   # defaults to 1.
-  def drop(n)
+  def drop(n = 1)
     each(n) { }
   end
 
   # Drops the next n elements, destroys them in the LazyList and
   # returns the rest of this LazyList.
-  def drop!(n)
+  def drop!(n = 1)
     each!(n) { }
   end
 
@@ -366,31 +389,69 @@ class LazyList
 
   # Returns true if this is the empty LazyList.
   def empty?
-    self == Empty
+    self.equal? Empty
   end
 
+  # Returns true, if this lazy list and the other lazy list consist of only
+  # equal elements. This is only sensible, if the lazy lists are finite and you
+  # can spare the memory.
+  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 }
+    true
+  end
+  alias == eql?
+
   # Inspects the list as far as it has been computed by returning
   # a string of the form [1, 2, 3,... ].
   def inspect
     result = "["
     s = self
     until s.empty?
-      case s.peek_tail
-      when Empty
+      pt = s.peek_tail
+      case 
+      when pt.equal?(Empty) # to avoid calling == on pt
         result << s.head.inspect
         break
-      when Proc
+      when Proc === pt
         result << s.head.inspect << ",... "
         break
       else
-        result << s.head.inspect << ", "
-        s = s.tail
+        t = s.tail
+        if t.equal? self
+          result << s.head.inspect << ",... "
+          break
+        else
+          result << s.head.inspect << ", "
+          s = t
+        end
       end
     end
     result << "]"
   end
 
   alias to_s inspect
+end
 
+module Kernel
+  # A method to improve the user friendliness for creating new lazy lists, that
+  # 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 }
+    end
+  end
 end
+
   # vim: set et sw=2 ts=2:

data/tests/runner.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'test/unit/ui/console/testrunner'
+require 'test/unit/testsuite'
+$:.unshift File.expand_path(File.dirname($0))
+$:.unshift 'lib'
+$:.unshift '../lib'
+#require 'coverage'
+require 'test'
+
+class TS_AllTests
+  def self.suite
+    suite = Test::Unit::TestSuite.new
+    suite << TC_LazyList.suite
+  end
+end
+Test::Unit::UI::Console::TestRunner.run(TS_AllTests)
+  # vim: set et sw=2 ts=2:

data/tests/test.rb

@@ -5,231 +5,253 @@ require 'lazylist'
 require 'tempfile'
 
 class MyEnum
+  include Enumerable
 
-	include Enumerable
-
-	def initialize(n)
-		@n = n
-	end
-
-	def each(&block) (1..@n).each(&block) end
+  def initialize(n)
+    @n = n
+  end
 
+  def each(&block)
+    (1..@n).each(&block)
+  end
 end
 
 class TC_LazyList < Test::Unit::TestCase
+  def setup
+    @strings = LazyList.tabulate("a")
+    @natural = LazyList.tabulate(1)
+    @ones = LazyList.iterate(1) { 1 }
+    @oddp = lambda { |x| x % 2 == 1 }
+    @odd = @natural.filter(&@oddp)
+    @evenp = lambda { |x| x % 2 == 0 }
+    @boolean = @natural.mapper { |x| x % 2 == 0}
+    @even = @natural.filter(&@evenp)
+    @finite_inner0 = MyEnum.new(0)
+    @finite0 = LazyList[@finite_inner0]
+    @finite_inner1 = MyEnum.new(1)
+    @finite1 = LazyList[@finite_inner1]
+    @finite_inner10 = MyEnum.new(10)
+    @finite10 = LazyList[@finite_inner10]
+    @finite_span = LazyList.span("A", 10)
+    @finite_span_generated = ("A".."J").to_a
+  end
+
+  def test_constructor
+    ll1 = LazyList.new(:foo, LazyList::Empty)
+    assert(!ll1.empty?)
+    ll2 = LazyList.new(:foo) { Empty }
+    assert(!ll2.empty?)
+    assert_raises(LazyList::Exception) do
+       ll3 = LazyList.new(:foo, :argh) { Empty }
+    end
+  end
+
+  def test_read_queue
+    @read_queue0 = LazyList::ReadQueue.new(1..0)
+    @read_queue1 = LazyList::ReadQueue.new(1..1)
+    @read_queue10 = LazyList::ReadQueue.new(1..10)
+    assert(@read_queue0.empty?)
+    assert_equal(nil, @read_queue0.pop)
+    assert(!@read_queue1.empty?)
+    assert_equal(1, @read_queue1.pop)
+    assert(!@read_queue10.empty?)
+    for i in 1..10 do
+      assert_equal(i, @read_queue10.pop)
+    end
+  end
+
+  def test_finite
+    assert_equal(@finite_inner0.to_a, @finite0.to_a)
+    assert_equal(@finite_inner1.to_a, @finite1.to_a)
+    assert_equal(@finite_inner10.to_a, @finite10.to_a)
+    assert_equal(@finite_span_generated, @finite_span.to_a)
+  end
+
+  def test_size
+    assert_equal(0, @finite0.size)
+    assert_equal(1, @finite1.size)
+    assert_equal(10, @finite10.size)
+    assert_equal(10, @finite_span.size)
+    assert_equal(0, @finite0.length)
+    assert_equal(1, @finite1.length)
+    assert_equal(10, @finite10.length)
+    assert_equal(10, @finite_span.length)
+  end
+
+  def test_filter
+    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 ] * 10, @ones[0, 10].to_a)
+    ends_with_a = @strings.filter { |x| x[-1] == ?a }
+    assert(ends_with_a[0, 27] ==
+      [ "a", ("a".."z").map { |x| x + "a" }  ].flatten)
+  end
+
+  def test_map
+    id = @natural.mapper
+    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])
+    squaredf = lambda { |x| x ** 2 }
+    squared = @natural.mapper(&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])
+    strangef = lambda { |x| x * (x[0] - ?a + 1) }
+    strange = @strings.mapper(&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])
+  end
+
+  def test_index
+    assert_equal(nil, @natural[-1])
+    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((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])
+    assert_equal((1...1).to_a, @natural[0...0])
+    assert_equal((1...0).to_a, @natural[0...-1])
+    assert_equal((1..10).to_a, @natural[0..9])
+    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
+
+  def test_merge
+    natural = @even.merge(@odd)
+    assert_equal(@natural[0, 10].to_a, natural[0, 10].to_a)
+    natural = @odd.merge(@even)
+    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)
+    some = @even.merge(odd2)
+    assert_equal(@natural[1, 9].to_a, some[0, 9].to_a)
+  end
+
+  def test_take_drop
+    assert_equal([ ], @odd.take(0))
+    assert_equal([ 1, 3, 5 ], @odd.take(3))
+    assert_equal([ 1, 3, 5 ], @odd.take(3))
+    assert_equal([ ], @odd.take!(0))
+    assert_equal([ 1 ], @odd.take(1))
+    assert_equal([ 1 ], @odd.take!(1))
+    assert_equal([ 3, 5, 7 ], @odd.take(3))
+    assert_equal([ 3, 5 ], @odd.take!(2))
+    assert_equal([ 7, 9, 11 ], @odd.take(3))
+    assert_equal([ 7, 9, 11 ], @odd.drop(0).take(3))
+    assert_equal([ 7, 9, 11 ], @odd.take(3))
+    assert_equal([ 9, 11, 13 ], @odd.drop(1).take(3))
+    assert_equal([ 7, 9, 11 ], @odd.take(3))
+    assert_equal([ 11, 13, 15 ], @odd.drop(2).take(3))
+    assert_equal([ 7, 9, 11 ], @odd.take(3))
+    @odd.drop!(0)
+    assert_equal([ 7, 9, 11 ], @odd.take(3))
+    @odd.drop!(1)
+    assert_equal([ 9, 11, 13 ], @odd.take(3))
+    @odd.drop!(2)
+    assert_equal([ 13, 15, 17 ], @odd.take(3))
+  end
+
+  def test_io
+    @tempfile0 = Tempfile.new("test")
+    1.upto(0) do |i|
+      @tempfile0.puts i
+    end
+    @tempfile0.close
+    @tempfile0_list = LazyList[File.new(@tempfile0.path)]
+    @tempfile10 = Tempfile.new("test")
+    1.upto(10) do |i|
+      @tempfile10.puts i
+    end
+    @tempfile10.close
+    @tempfile10_list = LazyList[File.new(@tempfile10.path)]
+    assert_equal(0, @tempfile0_list.size)
+    assert_equal([], @tempfile0_list.to_a)
+    assert_equal(10, @tempfile10_list.size)
+    assert_equal((1..10).map { |x| x.to_s + "\n" },
+      @tempfile10_list.to_a)
+    temp = LazyList.io(File.new(@tempfile0.path)) do |io|
+      io.readline
+    end
+    content = temp.inject([]) { |c, line| c << line }
+    assert_equal([], content)
+    temp = LazyList.io(File.new(@tempfile10.path)) do |io|
+      io.readline
+    end
+    content = temp.inject([]) { |c, line| c << line }
+    assert_equal((1..10).map { |x| x.to_s + "\n" }, content)
+  end
+
+  def test_iterate
+    f = LazyList.iterate(5) do |x|
+      if x % 2 == 0
+        x / 2
+      else
+        5 * x + 1
+      end
+    end
+    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])
+  end
+
+  def test_inpsect
+    l = LazyList[1..11]
+    assert_equal("[]", LazyList::Empty.inspect)
+    assert_equal("[1,... ]", l.inspect)
+    l[1]
+    assert_equal("[1, 2,... ]", l.inspect)
+    l[2]
+    assert_equal("[1, 2, 3,... ]", l.inspect)
+    l[9]
+    assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,... ]", l.inspect)
+    l.to_a
+    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]
+  end
+
+  def from(n = 0)
+    list(n) { from(n + 1) }
+  end
 
-	def setup
-		@strings = LazyList.tabulate("a")
-		@natural = LazyList.tabulate(1)
-		@ones = LazyList.iterate(1) { 1 }
-		@oddp = lambda { |x| x % 2 == 1 }
-		@odd = @natural.filter(&@oddp)
-		@evenp = lambda { |x| x % 2 == 0 }
-		@boolean = @natural.mapper { |x| x % 2 == 0}
-		@even = @natural.filter(&@evenp)
-		@finite_inner0 = MyEnum.new(0)
-		@finite0 = LazyList[@finite_inner0]
-		@finite_inner1 = MyEnum.new(1)
-		@finite1 = LazyList[@finite_inner1]
-		@finite_inner10 = MyEnum.new(10)
-		@finite10 = LazyList[@finite_inner10]
-		@finite_span = LazyList.span("A", 10)
-		@finite_span_generated = ("A".."J").to_a
-	end
-
-	def test_constructor
-		ll1 = LazyList.new(:foo, LazyList::Empty)
-		assert(!ll1.empty?)
-		ll2 = LazyList.new(:foo) { Empty }
-		assert(!ll2.empty?)
-		assert_raises(LazyList::Exception) do
-			 ll3 = LazyList.new(:foo, :argh) { Empty }
-		end
-	end
-
-	def test_read_queue
-		@read_queue0 = LazyList::ReadQueue.new(1..0)
-		@read_queue1 = LazyList::ReadQueue.new(1..1)
-		@read_queue10 = LazyList::ReadQueue.new(1..10)
-		assert(@read_queue0.empty?)
-		assert_equal(nil, @read_queue0.pop)
-		assert(!@read_queue1.empty?)
-		assert_equal(1, @read_queue1.pop)
-		assert(!@read_queue10.empty?)
-		for i in 1..10 do
-			assert_equal(i, @read_queue10.pop)
-		end
-	end
-
-	def test_finite
-		assert_equal(@finite_inner0.to_a, @finite0.to_a)
-		assert_equal(@finite_inner1.to_a, @finite1.to_a)
-		assert_equal(@finite_inner10.to_a, @finite10.to_a)
-		assert_equal(@finite_span_generated, @finite_span.to_a)
-	end
-
-	def test_size
-		assert_equal(0, @finite0.size)
-		assert_equal(1, @finite1.size)
-		assert_equal(10, @finite10.size)
-		assert_equal(10, @finite_span.size)
-		assert_equal(0, @finite0.length)
-		assert_equal(1, @finite1.length)
-		assert_equal(10, @finite10.length)
-		assert_equal(10, @finite_span.length)
-	end
-
-	def test_filter
-		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 ] * 10, @ones[0, 10].to_a)
-		ends_with_a = @strings.filter { |x| x[-1] == ?a }
-		assert(ends_with_a[0, 27] ==
-			[ "a", ("a".."z").map { |x| x + "a" }  ].flatten)
-	end
-
-	def test_map
-		id = @natural.mapper
-		assert_equal(1, id[0])
-		assert_equal(2, id[1])
-		assert_equal(3, id[2])
-		assert_equal((1..10).map, id[0, 10])
-		assert_equal((1..10).to_a, @natural[0, 10])
-		squaredf = lambda { |x| x ** 2 }
-		squared = @natural.mapper(&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])
-		strangef = lambda { |x| x * (x[0] - ?a + 1) }
-		strange = @strings.mapper(&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])
-	end
-
-	def test_index
-		assert_equal(nil, @natural[-1])
-		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((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])
-		assert_equal((1...1).to_a, @natural[0...0])
-		assert_equal((1...0).to_a, @natural[0...-1])
-		assert_equal((1..10).to_a, @natural[0..9])
-		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
-
-	def test_merge
-		natural = @even.merge(@odd)
-		assert_equal(@natural[0, 10].to_a, natural[0, 10].to_a)
-		natural = @odd.merge(@even)
-		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)
-		some = @even.merge(odd2)
-		assert_equal(@natural[1, 9].to_a, some[0, 9].to_a)
-	end
-
-	def test_take_drop
-		assert_equal([ ], @odd.take(0))
-		assert_equal([ 1, 3, 5 ], @odd.take(3))
-		assert_equal([ 1, 3, 5 ], @odd.take(3))
-		assert_equal([ ], @odd.take!(0))
-		assert_equal([ 1 ], @odd.take(1))
-		assert_equal([ 1 ], @odd.take!(1))
-		assert_equal([ 3, 5, 7 ], @odd.take(3))
-		assert_equal([ 3, 5 ], @odd.take!(2))
-		assert_equal([ 7, 9, 11 ], @odd.take(3))
-		assert_equal([ 7, 9, 11 ], @odd.drop(0).take(3))
-		assert_equal([ 7, 9, 11 ], @odd.take(3))
-		assert_equal([ 9, 11, 13 ], @odd.drop(1).take(3))
-		assert_equal([ 7, 9, 11 ], @odd.take(3))
-		assert_equal([ 11, 13, 15 ], @odd.drop(2).take(3))
-		assert_equal([ 7, 9, 11 ], @odd.take(3))
-		@odd.drop!(0)
-		assert_equal([ 7, 9, 11 ], @odd.take(3))
-		@odd.drop!(1)
-		assert_equal([ 9, 11, 13 ], @odd.take(3))
-		@odd.drop!(2)
-		assert_equal([ 13, 15, 17 ], @odd.take(3))
-	end
-
-	def test_io
-		@tempfile0 = Tempfile.new("test")
-		1.upto(0) do |i|
-			@tempfile0.puts i
-		end
-		@tempfile0.close
-		@tempfile0_list = LazyList[File.new(@tempfile0.path)]
-		@tempfile10 = Tempfile.new("test")
-		1.upto(10) do |i|
-			@tempfile10.puts i
-		end
-		@tempfile10.close
-		@tempfile10_list = LazyList[File.new(@tempfile10.path)]
-		assert_equal(0, @tempfile0_list.size)
-		assert_equal([], @tempfile0_list.to_a)
-		assert_equal(10, @tempfile10_list.size)
-		assert_equal((1..10).map { |x| x.to_s + "\n" },
-			@tempfile10_list.to_a)
-		temp = LazyList.io(File.new(@tempfile0.path)) do |io|
-			io.readline
-		end
-		content = temp.inject([]) { |c, line| c << line }
-		assert_equal([], content)
-		temp = LazyList.io(File.new(@tempfile10.path)) do |io|
-			io.readline
-		end
-		content = temp.inject([]) { |c, line| c << line }
-		assert_equal((1..10).map { |x| x.to_s + "\n" }, content)
-	end
-
-	def test_iterate
-		f = LazyList.iterate(5) do |x|
-			if x % 2 == 0
-				x / 2
-			else
-				5 * x + 1
-			end
-		end
-		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])
-	end
-
-	def test_inpsect
-		list = LazyList[1..11]
-		assert_equal("[]", LazyList::Empty.inspect)
-		assert_equal("[1,... ]", list.inspect)
-		list[1]
-		assert_equal("[1, 2,... ]", list.inspect)
-		list[2]
-		assert_equal("[1, 2, 3,... ]", list.inspect)
-		list[9]
-		assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,... ]", list.inspect)
-		list.to_a
-		assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", list.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])
-	end
+  def odd
+    from(1).filter { |x| x % 2 == 1 }
+  end
 
+  def test_list
+    assert_equal LazyList::Empty, list
+    assert_equal [], list.to_a
+    assert_equal LazyList.new(1) { LazyList::Empty }, list(1)
+    assert_equal [1], list(1).to_a
+    assert_equal LazyList::Empty, list
+    o = odd
+    assert_equal [1, 3, 5, 7, 9, 11, 13, 15, 17, 19], o.take(10)
+    assert_equal @odd.take(10), o.take(10)
+    ones = list(1) { ones }
+    assert_equal 1, ones.head
+    assert_equal '[1,... ]', ones.inspect
+    assert_equal [ 1 ] * 10 , ones.take(10)
+    assert_equal '[1,... ]', ones.inspect
+  end
 end
-	# vim: set noet sw=4 ts=4: 
+  # vim: set et sw=2 ts=2: 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.1
+rubygems_version: 0.8.11
 specification_version: 1
 name: lazylist
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2004-09-30
+  version: 0.1.3
+date: 2005-10-03 00:00:00 +02:00
 summary: Implementation of lazy lists for Ruby
 require_paths: 
   - lib
-author: Florian Frank
 email: flori@ping.de
 homepage: http://lazylist.rubyforge.org
 rubyforge_project: lazylist
@@ -25,23 +24,28 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Florian Frank
 files: 
-  - README.en
-  - CHANGES
-  - GPL
   - examples
+  - install.rb
+  - GPL
   - Rakefile
   - VERSION
-  - install.rb
-  - make_doc.rb
-  - lib
   - tests
-  - examples/examples.rb
+  - CHANGES
+  - lib
+  - make_doc.rb
+  - README.en
   - examples/hamming.rb
-  - examples/pi.rb
   - examples/sieve.rb
-  - lib/lazylist.rb
+  - examples/pi.rb
+  - examples/examples.rb
   - tests/test.rb
+  - tests/runner.rb
+  - lib/lazylist.rb
 test_files: 
   - tests/test.rb
 rdoc_options: []