lazylist 0.3.1 → 0.3.2

data/CHANGES

@@ -1,3 +1,7 @@
+2009-07-23 * 0.3.2 * Some cleanup.
+                   * Build a gemspec file.
+                   * Added end_list method to end a lazy list during the
+                     evaluation of a filter predicate.
 2007-11-27 * 0.3.1 * Comron Sattari <comron@gmail.com> reported a bug
                      concerning false values in a lazy list. This problem
                      should be corrected now.

data/{README.en → README}

@@ -5,15 +5,27 @@ Just type into the command line as root:
 
 # ruby install.rb
 
+Or if you prefer to use rake, try:
+
+# rake install
+
+Or if you want to use rubygems just type this and rubygems fetches the gem and
+installs it for you:
+
+# gem install lazylist
+
 Documentation
 =============
 
 The API documentatin of this library is can be produced by typing:
 $ ruby make_doc.rb
 
+Or with rake:
+$ rake doc
+
 You should also look into the files in the examples directory to get an idea
-how this library is used. It is also interesting to examine test.rb for this
-reason.
+how this library is used. It is also interesting to examine the tests directory
+for this reason.
 
 Author
 ======
@@ -23,5 +35,5 @@ Florian Frank <flori@ping.de>
 License
 =======
 
-GNU General Public License (GPL)
+GNU General Public License (GPL), Version 2
 

data/Rakefile

@@ -1,25 +1,15 @@
-# vim: set et sw=2 ts=2:
-
 begin
   require 'rake/gempackagetask'
 rescue LoadError
 end
+require 'rake/clean'
 require 'rbconfig'
 include Config
 
 PKG_NAME = 'lazylist'
 PKG_VERSION = File.read('VERSION').chomp
 PKG_FILES = FileList['**/*'].exclude(/^(doc|CVS|pkg|coverage)/)
-
-desc "Run unit tests"
-task :test  do
-  ruby %{-Ilib tests/runner.rb}
-end
-
-desc "Testing library with coverage"
-task :coverage do
-  sh 'rcov -x tests -Ilib tests/runner.rb'
-end
+CLEAN.include 'coverage', 'doc'
 
 desc "Installing library"
 task :install  do
@@ -31,39 +21,51 @@ task :doc do
   ruby 'make_doc.rb'
 end
 
-desc "Removing generated files"
-task :clean do
-  rm_rf 'doc'
-  rm_rf 'tests/coverage'
+desc "Run unit tests"
+task :test  do
+  ruby %{-Ilib tests/runner.rb}
+end
+
+desc "Testing library with coverage"
+task :coverage do
+  sh 'rcov -x tests -Ilib tests/runner.rb'
 end
 
 if defined? Gem
-  spec = Gem::Specification.new do |s|
-    s.name = 'lazylist'
-    s.version = PKG_VERSION
+  spec_src =<<GEM
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+    s.name = '#{PKG_NAME}'
+    s.version = '#{PKG_VERSION}'
     s.summary = "Implementation of lazy lists for Ruby"
     s.description = ""
 
-    s.add_dependency('dslkit', '>= 0.2.2')
+    s.add_dependency('dslkit', '~> 0.2')
 
-    s.files = PKG_FILES
+    s.files = #{PKG_FILES.to_a.sort.inspect}
 
     s.require_path = 'lib'
 
     s.has_rdoc = true
-    s.extra_rdoc_files = Dir['lib/**/*.rb']
-    s.rdoc_options <<
-      '--title' <<  'LazyList -- Infinite lists in Ruby' <<
-      '--main' << 'LazyList' <<
-      '--line-numbers'
-    s.test_files << 'tests/test.rb'
+    s.extra_rdoc_files << 'doc-main.txt'
+    s.rdoc_options << '--main' << 'doc-main.txt'
+    s.test_files << 'tests/runner.rb'
 
     s.author = "Florian Frank"
     s.email = "flori@ping.de"
-    s.homepage = "http://lazylist.rubyforge.org"
-    s.rubyforge_project = "lazylist"
+    s.homepage = "http://#{PKG_NAME}.rubyforge.org"
+    s.rubyforge_project = "#{PKG_NAME}"
+  end
+GEM
+
+  desc 'Create a gemspec file'
+  task :gemspec do
+    File.open("#{PKG_NAME}.gemspec", 'w') do |f|
+      f.puts spec_src
+    end
   end
 
+  spec = eval(spec_src)
   Rake::GemPackageTask.new(spec) do |pkg|
     pkg.need_tar = true
     pkg.package_files += PKG_FILES
@@ -73,7 +75,7 @@ end
 desc m = "Writing version information for #{PKG_VERSION}"
 task :version do
   puts m
-  File.open(File.join('lib', 'lazylist', 'version.rb'), 'w') do |v|
+  File.open(File.join('lib', PKG_NAME, 'version.rb'), 'w') do |v|
     v.puts <<EOT
 class LazyList
   # LazyList version
@@ -87,7 +89,8 @@ EOT
   end
 end
 
-task :default => [ :version, :test ]
+desc "Default"
+task :default => [ :version, :gemspec, :test ]
 
-task :release => [ :version, :clean, :package ]
-  # vim: set et sw=2 ts=2:
+desc "Prepare a release"
+task :release => [ :clean, :version, :gemspec, :package ]

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/doc-main.txt

@@ -0,0 +1,121 @@
+== LazyList - Implementation of lazy lists for Ruby
+
+=== Description
+
+This class implements lazy lists (or streams) for Ruby. Such lists avoid the
+computation of values which aren't needed for some computation. So it's
+possible to define infinite lists with a limited amount of memory. A value
+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
+
+The homepage of this library is located at
+
+* http://lazylist.rubyforge.org
+
+=== Example
+
+To compute the square numbers with a lazy list you can define one as
+
+ sq = LazyList.tabulate(1) { |x| x * x }
+
+or in the much nicer list builder syntax:
+
+ sq = list { x * x }.where :x => 1..Infinity
+
+Now it's possible to get the first 10 square numbers by calling
+LazyList#take
+
+ sq.take(10)
+     ===>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+
+To compute the first 10 square numbers and do something with them you can
+call the each method with:
+
+ sq.each(10) { |x| puts x }
+
+To compute every square number and do something with them you can call the
+"each" method without an argument:
+
+ sq.each { |x| puts x }
+
+Notice that calls to each without an argument 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:
+
+ 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]
+
+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[100] => 573147844013817084101
+computes the 99th Fibonacci number. (We always start with index 0.)
+ 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 can also use the zip method to create fib:
+
+ fib = list(1, 1) { fib.zip(fib.drop) { |a, b| a + b } }
+
+Another way to create the Fibonacci sequence with the build method is this:
+
+ fib = list(1, 1) { build { a + b }.where(:a => fib, :b => fib.drop(1)) }
+
+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") ]
+
+Call grep to find the users root and flori:
+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"
+instead, only every line until the root line is loaded into the memory.
+
+To create more complex lazy lists, you can build them from already existing
+lazy lists.
+
+Natural numbers:
+ naturals = LazyList.from(1)
+
+Odd Numbers > 100:
+ odds = list { x }.where(:x => naturals) { x % 2 === 1 && x > 100 }
+
+Alternative definition of square numbers:
+ squares = build { odds[0, x].inject(0) { |s, y| s + y } }.where :x => naturals
+
+=== References
+
+A very good introduction into lazy lists can be found in the scheme bible
+Structure and Interpretation of Computer Programs (SICP)
+[http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-24.html#%25_sec_3.5]

data/examples/examples.rb

@@ -84,13 +84,18 @@ p me[66]
 puts me.length
 puts
 
-puts "Proof that PI is the number of the beast"
+
 p PI.take(10)
 
 def window(l, n, m = 0)
   list([ l.take(n) * '', m ]) { window(l.drop, n, m + 1) }
 end
+
+w = window(PI, 6)
+index = w.find { |(x, i)| x == '999999' and break i }
+puts "Found Feynman point #{PI.take_span(index, 6)} at #{index}!"
+
+puts "Proof that PI is the number of the beast"
 w = window(PI, 3)
 index = w.find { |(x, i)| x == '666' and break i }
 puts "Found #{PI.take_span(index, 3)} at #{index}!"
-  # vim: set et sw=2 ts=2: 

data/examples/hamming.rb

@@ -15,4 +15,3 @@ hamming.each(max) do |x|
 end
 puts
 print hamming[1000], ", ", hamming[1001], "\n"
-  # vim: set et sw=2 ts=2: 

data/examples/pi.rb

@@ -32,4 +32,3 @@ if $0 == __FILE__
   end
   puts
 end
-  # vim: set et sw=2 ts=2: 

data/examples/sieve.rb

@@ -15,4 +15,3 @@ primes.each(max) do |x|
   STDOUT.flush
 end
 puts
-  # vim: set et sw=2 ts=2: 

data/install.rb

@@ -11,4 +11,3 @@ mkdir_p subdir = File.join(libdir, 'lazylist')
 for f in Dir['lib/lazylist/*.rb']
   install(f, subdir)
 end
-  # vim: set et sw=2 ts=2: 

data/lazylist.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+    s.name = 'lazylist'
+    s.version = '0.3.2'
+    s.summary = "Implementation of lazy lists for Ruby"
+    s.description = ""
+
+    s.add_dependency('dslkit', '~> 0.2')
+
+    s.files = ["CHANGES", "COPYING", "README", "Rakefile", "VERSION", "examples", "examples/examples.rb", "examples/hamming.rb", "examples/pi.rb", "examples/sieve.rb", "install.rb", "lazylist.gemspec", "lib", "lib/lazylist", "lib/lazylist.rb", "lib/lazylist/enumerable.rb", "lib/lazylist/enumerator_queue.rb", "lib/lazylist/list_builder.rb", "lib/lazylist/thread_queue.rb", "lib/lazylist/version.rb", "make_doc.rb", "tests", "tests/runner.rb", "tests/test.rb", "tests/test_enumerable.rb"]
+
+    s.require_path = 'lib'
+
+    s.has_rdoc = true
+    s.extra_rdoc_files << 'doc-main.txt'
+    s.rdoc_options << '--main' << 'doc-main.txt'
+    s.test_files << 'tests/runner.rb'
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://lazylist.rubyforge.org"
+    s.rubyforge_project = "lazylist"
+  end

data/lib/lazylist.rb

@@ -1,125 +1,3 @@
-# = lazylist.rb - Implementation of lazy lists for Ruby
-#
-# == Description
-#
-# This class implements lazy lists (or streams) for Ruby. Such lists avoid the
-# computation of values which aren't needed for some computation. So it's
-# possible to define infinite lists with a limited amount of memory. A value
-# 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
-#
-# The homepage of this library is located at
-#
-# * http://lazylist.rubyforge.org
-# 
-# == Example
-#
-# To compute the square numbers with a lazy list you can define one as
-#
-#  sq = LazyList.tabulate(1) { |x| x * x }
-#
-# or in the much nicer list builder syntax:
-#
-#  sq = list { x * x }.where :x => 1..Infinity
-#
-# Now it's possible to get the first 10 square numbers by calling
-# LazyList#take
-#
-#  sq.take(10)
-#      ==>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-#
-# To compute the first 10 square numbers and do something with them you can
-# call the each method with:
-#
-#  sq.each(10) { |x| puts x }
-#
-# To compute every square number and do something with them you can call the
-# "each" method without an argument:
-#
-#  sq.each { |x| puts x }
-#
-# Notice that calls to each without an argument 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:
-#
-#  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]
-#
-# 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[100] => 573147844013817084101
-# computes the 99th Fibonacci number. (We always start with index 0.)
-#  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 can also use the zip method to create fib:
-#
-#  fib = list(1, 1) { fib.zip(fib.drop) { |a, b| a + b } }
-#
-# Another way to create the Fibonacci sequence with the build method is this:
-#
-#  fib = list(1, 1) { build { a + b }.where(:a => fib, :b => fib.drop(1)) }
-#
-# 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") ]
-# 
-# Call grep to find the users root and flori:
-# 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"
-# instead, only every line until the root line is loaded into the memory.
-#
-# To create more complex lazy lists, you can build them from already existing
-# lazy lists.
-#
-# Natural numbers:
-#  naturals = LazyList.from(1)
-#
-# Odd Numbers > 100:
-#  odds = list { x }.where(:x => naturals) { x % 2 == 1 && x > 100 }
-#
-# Alternative definition of square numbers:
-#  squares = build { odds[0, x].inject(0) { |s, y| s + y } }.where :x => naturals
-#
-# == References
-#
-# A very good introduction into lazy lists can be found in the scheme bible
-# 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
   require 'dslkit'
   require 'lazylist/list_builder'
@@ -131,64 +9,10 @@ class LazyList
   # Exceptions raised by the LazyList implementation.
   class Exception < ::StandardError; end
 
-  # ReadQueue is the implementation of an read-only queue that only supports
-  # #shift and #empty? methods.  It's used as a wrapper to encapsulate
-  # enumerables in lazy lists.
-  class ReadQueue
-    # Creates an ReadQueue object from an enumerable.
-    def initialize(enumerable)
-      @data = []
-      @producer = Thread.new do
-        Thread.stop
-        begin
-          enumerable.each do |value|
-            old, Thread.critical = Thread.critical, true
-            begin
-              @data << value
-              @consumer.wakeup
-              Thread.stop
-            ensure
-              Thread.critical = old
-            end
-          end
-        rescue => e
-          @consumer.raise e
-        ensure
-          @consumer.wakeup
-        end
-      end
-      Thread.pass until @producer.stop?
-    end
-
-    # Extracts the top element from the queue or nil if the queue is
-    # empty.
-    def shift
-      if empty?
-        nil
-      else
-        @data.shift
-      end
-    end
-
-    alias pop shift # for backwards compatibility
-
-    # Returns true if the queue is empty.
-    def empty?
-      if @data.empty?
-        old, Thread.critical = Thread.critical, true
-        begin
-          @consumer = Thread.current
-          @producer.wakeup
-          Thread.stop
-        rescue ThreadError
-          ;
-        ensure
-          @consumer = nil
-          Thread.critical = old
-        end
-      end
-      @data.empty?
-    end
+  if defined?(::Enumerator)
+    require 'lazylist/enumerator_queue.rb'
+  else
+    require 'lazylist/thread_queue.rb'
   end
 
   Promise = DSLKit::BlankSlate.with :inspect, :to_s # :nodoc:
@@ -615,6 +439,8 @@ class LazyList
     result
   end
 
+  alias first take
+
   # Takes the _range_ indexes of elements from this lazylist and returns them
   # as an array.
   def take_range(range) 
@@ -648,6 +474,12 @@ class LazyList
     each!(n) { }
   end
 
+  # Return the last +n+ elements of the lazy list. This is only sensible if the
+  # lazy list is finite of course.
+  def last(n = 1)
+    to_a.last n
+  end
+
   # Returns the size. This is only sensible if the lazy list is finite
   # of course.
   def size
@@ -825,6 +657,6 @@ class LazyList
     end
 
     include LazyList::ObjectMethods
+    include LazyList::Enumerable::ObjectMethods
   end
 end
-  # vim: set et sw=2 ts=2:

data/lib/lazylist/enumerable.rb

@@ -80,11 +80,16 @@ class LazyList
     def select(&block)
       block = All unless block
       s = self
-      until s.empty? or block[s.head]
-        s = s.tail
+      ended = catch(:end_list) do
+        until s.empty? or block[s.head]
+          s = s.tail
+        end
+      end
+      if s.empty? or ended == :end_list
+        empty
+      else
+        self.class.new(delay { s.head }) { s.tail.select(&block) }
       end
-      return empty if s.empty?
-      self.class.new(delay { s.head }) { s.tail.select(&block) }
     end
     alias find_all select
 
@@ -108,5 +113,13 @@ class LazyList
       warn "method 'mapper' is obsolete - use 'map'"
       map(&f)
     end
+
+    module ObjectMethods
+      # This method can be used to end a list in a predicate that is used to
+      # filter the lazy list via the select, reject, or partition method.
+      def end_list
+        throw :end_list, :end_list
+      end
+    end
   end
 end

data/lib/lazylist/enumerator_queue.rb

@@ -0,0 +1,35 @@
+class LazyList
+  # ReadQueue is the implementation of an read-only queue that only supports
+  # #shift and #empty? methods.  It's used as a wrapper to encapsulate
+  # enumerables in lazy lists.
+  class ReadQueue
+    # Creates an ReadQueue object from an enumerable.
+    def initialize(enumerable)
+      @enum = enumerable.to_enum
+      @empty = false
+      shift
+    end
+
+    # Extracts the top element from the queue or nil if the queue is empty.
+    def shift
+      if @empty
+        nil
+      else
+        result = @next
+        @next = @enum.next
+        result
+      end
+    rescue StopIteration
+      @next = nil
+      @empty = true
+      result
+    end
+
+    alias pop shift # for backwards compatibility
+
+    # Returns true if the queue is empty.
+    def empty?
+      !@next and @empty
+    end
+  end
+end

data/lib/lazylist/thread_queue.rb

@@ -0,0 +1,61 @@
+class LazyList
+  # ReadQueue is the implementation of an read-only queue that only supports
+  # #shift and #empty? methods.  It's used as a wrapper to encapsulate
+  # enumerables in lazy lists.
+  class ReadQueue
+    # Creates an ReadQueue object from an enumerable.
+    def initialize(enumerable)
+      @data = []
+      @producer = Thread.new do
+        Thread.stop
+        begin
+          enumerable.each do |value|
+            old, Thread.critical = Thread.critical, true
+            begin
+              @data << value
+              @consumer.wakeup
+              Thread.stop
+            ensure
+              Thread.critical = old
+            end
+          end
+        rescue => e
+          @consumer.raise e
+        ensure
+          @consumer.wakeup
+        end
+      end
+      Thread.pass until @producer.stop?
+    end
+
+    # Extracts the top element from the queue or nil if the queue is
+    # empty.
+    def shift
+      if empty?
+        nil
+      else
+        @data.shift
+      end
+    end
+
+    alias pop shift # for backwards compatibility
+
+    # Returns true if the queue is empty.
+    def empty?
+      if @data.empty?
+        old, Thread.critical = Thread.critical, true
+        begin
+          @consumer = Thread.current
+          @producer.wakeup
+          Thread.stop
+        rescue ThreadError
+          ;
+        ensure
+          @consumer = nil
+          Thread.critical = old
+        end
+      end
+      @data.empty?
+    end
+  end
+end

data/lib/lazylist/version.rb

@@ -1,6 +1,6 @@
 class LazyList
   # LazyList version
-  VERSION         = '0.3.1'
+  VERSION         = '0.3.2'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/make_doc.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
 
 puts "Creating documentation."
-system "rdoc -d #{Dir['lib/**/*.rb'] * ' '}"
-  # vim: set et sw=2 ts=2:
+system "rdoc -m doc-main.txt doc-main.txt #{Dir['lib/**/*.rb'] * ' '}"

data/tests/runner.rb

@@ -1,8 +1,12 @@
 #!/usr/bin/env ruby
 
-require 'test/unit/ui/console/testrunner'
-require 'test/unit/testsuite'
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
 $:.unshift File.expand_path(File.dirname($0))
+$:.unshift 'lib'
 $:.unshift 'tests'
 require 'test'
 require 'test_enumerable'
@@ -14,5 +18,3 @@ class TS_AllTests
     suite << TC_LazyEnumerable.suite
   end
 end
-Test::Unit::UI::Console::TestRunner.run(TS_AllTests)
-  # vim: set et sw=2 ts=2:

data/tests/test.rb

@@ -82,40 +82,40 @@ class TC_LazyList < Test::Unit::TestCase
   end
 
   def test_select
-    assert_equal 1, @odd[0] 
-    assert_equal 3, @odd[1] 
-    assert_equal 5, @odd[2] 
+    assert_equal 1, @odd[0]
+    assert_equal 3, @odd[1]
+    assert_equal 5, @odd[2]
     assert_equal [3, 5, 7], @odd.take_range(1..3)
     assert_equal [3, 5, 7, 9], @odd.take_span(1, 4)
-    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..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.select { |x| x[-1] == ?a }
     assert_equal ends_with_a[0, 27].to_a,
-      [ "a", ("a".."z").map { |x| x + "a" }  ].flatten 
+      [ "a", ("a".."z").map { |x| x + "a" }  ].flatten
   end
 
   def test_map
     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].to_a 
-    assert_equal (1..10).to_a, @natural[0, 10].to_a 
+    assert_equal 1, id[0]
+    assert_equal 2, id[1]
+    assert_equal 3, id[2]
+    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.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].to_a 
-    assert_equal (1..10).to_a, @natural[0, 10].to_a 
-    strangef = lambda { |x| x * (x[0] - ?a + 1) }
+    assert_equal 1, squared[0]
+    assert_equal 4, squared[1]
+    assert_equal 9, squared[2]
+    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.unpack('c').first - 'a'.unpack('c').first + 1) }
     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].to_a 
-    assert_equal ("a".."z").to_a, @strings[0, 26].to_a 
+    assert_equal "a", strange[0]
+    assert_equal "bb", strange[1]
+    assert_equal "ccc", strange[2]
+    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
@@ -123,23 +123,23 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal nil, Empty[0]
     assert_equal nil, Empty[1]
     assert @natural.cached?
-    assert_equal nil, @natural[-1] 
-    assert_equal nil, @natural[-1] 
-    assert_equal 1, @natural[0] 
-    assert_equal 1, @natural[0] 
-    assert_equal 2, @natural[1] 
-    assert_equal 2, @natural[1] 
-    assert_equal nil, @natural[-1, 10] 
-    assert_equal (1..10).to_a, @natural[0, 10].to_a 
-    assert_equal (6..15).to_a, @natural[5, 10].to_a 
-    assert_equal (1..1).to_a, @natural[0..0].to_a 
-    assert_equal (1..0).to_a, @natural[0..-1].to_a 
-    assert_equal (1...1).to_a, @natural[0...0].to_a 
-    assert_equal (1...0).to_a, @natural[0...-1].to_a 
-    assert_equal (1..10).to_a, @natural[0..9].to_a 
-    assert_equal (6..15).to_a, @natural[5..14].to_a 
-    assert_equal (1..10).to_a, @natural[0...10].to_a 
-    assert_equal (6..15).to_a, @natural[5...15].to_a 
+    assert_equal nil, @natural[-1]
+    assert_equal nil, @natural[-1]
+    assert_equal 1, @natural[0]
+    assert_equal 1, @natural[0]
+    assert_equal 2, @natural[1]
+    assert_equal 2, @natural[1]
+    assert_equal nil, @natural[-1, 10]
+    assert_equal((1..10).to_a, @natural[0, 10].to_a)
+    assert_equal((6..15).to_a, @natural[5, 10].to_a)
+    assert_equal((1..1).to_a, @natural[0..0].to_a)
+    assert_equal((1..0).to_a, @natural[0..-1].to_a)
+    assert_equal((1...1).to_a, @natural[0...0].to_a)
+    assert_equal((1...0).to_a, @natural[0...-1].to_a)
+    assert_equal((1..10).to_a, @natural[0..9].to_a)
+    assert_equal((6..15).to_a, @natural[5..14].to_a)
+    assert_equal((1..10).to_a, @natural[0...10].to_a)
+    assert_equal((6..15).to_a, @natural[5...15].to_a)
   end
 
   def test_index_without_cache
@@ -149,25 +149,25 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal nil, Empty[1]
     @natural.cached = false
     assert !@natural.cached?
-    assert_equal nil, @natural[-1] 
-    assert_equal nil, @natural[-1] 
-    assert_equal 1, @natural[0] 
-    assert_equal 1, @natural[0] 
-    assert_equal 2, @natural[1] 
-    assert_equal 2, @natural[1] 
-    assert_equal nil, @natural[-1, 10] 
+    assert_equal nil, @natural[-1]
+    assert_equal nil, @natural[-1]
+    assert_equal 1, @natural[0]
+    assert_equal 1, @natural[0]
+    assert_equal 2, @natural[1]
+    assert_equal 2, @natural[1]
+    assert_equal nil, @natural[-1, 10]
   end
 
   def test_merge
     natural = @even.merge(@odd)
-    assert_equal @natural[0, 10].to_a, natural[0, 10].to_a 
+    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 
+    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 
+    assert double_list[0, 10].to_a, (1..5).map { |x| [x, x] }.flatten
     odd2 = @natural.select(&@oddp).drop(1)
     some = @even.merge(odd2)
-    assert_equal @natural[1, 9].to_a, some[0, 9].to_a 
+    assert_equal @natural[1, 9].to_a, some[0, 9].to_a
     more_ones = @ones.merge(@ones)
     assert_equal [1] * 10, more_ones.take(10)
   end
@@ -183,17 +183,19 @@ class TC_LazyList < Test::Unit::TestCase
     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) 
+    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) 
+    assert_equal [ 7, 9, 11 ], @odd.take(3)
     @odd.drop!(1)
-    assert_equal [ 9, 11, 13 ], @odd.take(3) 
+    assert_equal [ 9, 11, 13 ], @odd.take(3)
     @odd.drop!(2)
-    assert_equal [ 13, 15, 17 ], @odd.take(3) 
+    assert_equal [ 13, 15, 17 ], @odd.take(3)
+    assert_equal [ 13, 15, 17 ], @odd.first(3)
+    assert_equal [ 8, 9, 10 ], @finite10.last(3)
   end
 
   def test_io
@@ -209,30 +211,29 @@ class TC_LazyList < Test::Unit::TestCase
     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 
+    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 
+    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 
+    assert_equal((1..10).map { |x| x.to_s + "\n" }, content)
   end
 
   def test_construct_ref
     assert_equal Empty, LazyList[0, -1]
     assert_equal [0], LazyList[0, 1].to_a
-    assert_equal (0..9).to_a, LazyList[0, 10].to_a
+    assert_equal((0..9).to_a, LazyList[0, 10].to_a)
     assert_equal Empty, LazyList[0..-1]
     assert_equal [0], LazyList[0..0].to_a
-    assert_equal (0..9).to_a, LazyList[0..9].to_a
+    assert_equal((0..9).to_a, LazyList[0..9].to_a)
   end
 
   def test_iterate
@@ -243,10 +244,10 @@ class TC_LazyList < Test::Unit::TestCase
         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].to_a 
+    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].to_a
     a196 = LazyList.iterate(35) { |x| x + x.to_s.reverse.to_i }
     assert_equal [35, 88, 176, 847, 1595, 7546, 14003, 44044, 88088, 176176],
       a196.take(10)
@@ -254,24 +255,24 @@ class TC_LazyList < Test::Unit::TestCase
 
   def test_inspect
     l = LazyList[1..11]
-    assert_equal "[]", Empty.inspect 
-    assert_equal "[... ]", l.inspect 
+    assert_equal "[]", Empty.inspect
+    assert_equal "[... ]", l.inspect
     l[0]
-    assert_equal "[1,... ]", l.inspect 
+    assert_equal "[1,... ]", l.inspect
     l[1]
-    assert_equal "[1, 2,... ]", l.inspect 
+    assert_equal "[1, 2,... ]", l.inspect
     l[2]
-    assert_equal "[1, 2, 3,... ]", l.inspect 
+    assert_equal "[1, 2, 3,... ]", l.inspect
     l[9]
-    assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,... ]", l.inspect 
+    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 
+    assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", l.inspect
   end
 
   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
+    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)
@@ -304,10 +305,10 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal Empty, @natural.sublist(-1)
     assert_equal Empty, @natural.sublist(0)
     assert_equal [1], @natural.sublist(1).to_a
-    assert_equal (1..10).to_a, @natural.sublist(10).to_a
-    assert_equal (6..15).to_a, @natural[5, 10].to_a
-    assert_equal (6..15).to_a, @natural[5..14].to_a
-    assert_equal (6..14).to_a, @natural[5...14].to_a
+    assert_equal((1..10).to_a, @natural.sublist(10).to_a)
+    assert_equal((6..15).to_a, @natural[5, 10].to_a)
+    assert_equal((6..15).to_a, @natural[5..14].to_a)
+    assert_equal((6..14).to_a, @natural[5...14].to_a)
     assert_equal nil, @natural.sublist(10)[10]
     assert_equal 10, @natural.sublist(10)[9]
   end
@@ -364,7 +365,7 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal list, list * list
     assert_equal list, list * list(1)
     assert_equal list, list(1) * list
-    assert_equal list, list.cartesian_product 
+    assert_equal list, list.cartesian_product
     assert_equal [ [1, 1], [1, 2], [2, 1], [2, 2], [3, 1], [3, 2] ],
       f.cartesian_product(g).to_a
     assert_equal [[1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 2, 2], [2, 1, 1], [2, 1,
@@ -372,9 +373,9 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal [1, 2, 2, 4, 2, 4, 4, 8],
       g.cartesian_product(g, g, &lambda { |x,y,z| x * y * z }).to_a
     assert_equal g.map { |x| x * x }, g.cartesian_product { |x| x * x }
-    l = list { [ x, y ] }.where :x => g, :y => g 
+    l = list { [ x, y ] }.where :x => g, :y => g
     assert_equal [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ], l.to_a.sort
-    l = list { [ x, y ] }.where :x => f, :y => g 
+    l = list { [ x, y ] }.where :x => f, :y => g
     assert_equal [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ], [ 3, 1 ], [ 3, 2 ] ], l.to_a.sort
     l = list { [ x, y ] }.where(:x => f, :y => f) {  x > y }
     assert_equal [ [ 2, 1 ], [ 3, 1 ], [ 3, 2 ] ], l.to_a.sort
@@ -386,4 +387,3 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal [ 7, 11, 8, 15, 12, 16, 9, 19, 17, 21, 13, 20, 22, 10, 18, 14 ].sort, test.to_a.sort
   end
 end
-  # vim: set et sw=2 ts=2: 

data/tests/test_enumerable.rb

@@ -91,5 +91,14 @@ class TC_LazyEnumerable < Test::Unit::TestCase
     assert_equal [2, 4], even.take(5)
     assert_equal [1, 3, 5], odd.take(5)
   end
+
+  def test_select
+    fib = list(1, 1) { build { a + b }.where(:a => fib, :b => fib.drop(1)) }
+    fib_small = fib.select { |x| x <= 4_000_000 or end_list }
+    even_fib_small = fib_small.select { |x| x % 2 == 0 }
+    assert_equal [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ], fib_small.first(10)
+    assert_equal [ 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418, 832040 ], even_fib_small.first(10)
+    assert_equal [ 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418, 832040, 3524578 ], even_fib_small.first(11)
+    assert_equal [ 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418, 832040, 3524578 ], even_fib_small.first(12)
+  end
 end
-  # vim: set et sw=2 ts=2: 

metadata

@@ -1,82 +1,86 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: lazylist
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-11-27 00:00:00 +01:00
-summary: Implementation of lazy lists for Ruby
-require_paths: 
-- lib
-email: flori@ping.de
-homepage: http://lazylist.rubyforge.org
-rubyforge_project: lazylist
-description: ""
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.3.2
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Florian Frank
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dslkit
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.2"
+    version: 
+description: ""
+email: flori@ping.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- doc-main.txt
 files: 
+- CHANGES
+- COPYING
+- README
+- Rakefile
+- VERSION
+- examples/examples.rb
+- examples/hamming.rb
+- examples/pi.rb
+- examples/sieve.rb
 - install.rb
-- lib
-- lib/lazylist
-- lib/lazylist/list_builder.rb
+- lazylist.gemspec
+- lib/lazylist.rb
 - lib/lazylist/enumerable.rb
+- lib/lazylist/enumerator_queue.rb
+- lib/lazylist/list_builder.rb
+- lib/lazylist/thread_queue.rb
 - lib/lazylist/version.rb
-- lib/lazylist.rb
 - make_doc.rb
-- CHANGES
-- README.en
-- VERSION
-- tests
 - tests/runner.rb
 - tests/test.rb
 - tests/test_enumerable.rb
-- Rakefile
-- GPL
-- examples
-- examples/pi.rb
-- examples/sieve.rb
-- examples/hamming.rb
-- examples/examples.rb
-test_files: 
-- tests/test.rb
+- doc-main.txt
+has_rdoc: true
+homepage: http://lazylist.rubyforge.org
+licenses: []
+
+post_install_message: 
 rdoc_options: 
-- --title
-- LazyList -- Infinite lists in Ruby
 - --main
-- LazyList
-- --line-numbers
-extra_rdoc_files: 
-- lib/lazylist/list_builder.rb
-- lib/lazylist/enumerable.rb
-- lib/lazylist/version.rb
-- lib/lazylist.rb
-executables: []
-
-extensions: []
-
+- doc-main.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: dslkit
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.2.2
-    version: 
+rubyforge_project: lazylist
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: Implementation of lazy lists for Ruby
+test_files: 
+- tests/runner.rb