lazylist 0.2.2 → 0.3.0

data/CHANGES

@@ -1,7 +1,27 @@
+2007-04-03 * 0.3.0 * Major work on the implementation: 
+                      - Supports list comprehensions for infinite list like
+                        Haskell does by offering a simple DSL.
+                      - Added cartesian products to LazyList.
+                     Many thanks to Reginald Braithwaite <reg@braythwayt.com>
+                     for his interesting ideas & email discussion about this
+                     topic. Be sure to check out his blog under
+                     http://weblog.raganwald.com/, where he writes about all
+                     kinds of other interesting stuff.
+                   * A nice side effect of the changes necessary for the
+                     new implementation is that the first value of a list is
+                     not forced until requested. This also causes a bit of
+                     space&time waste, but hardware is getting better and
+                     cheaper, isn't it?
+                   * Now there is more than one Empty object, be careful not to
+                     use equal? to compare them. It's better to use LazyList#empty?
+                     for this.
+                   * Switched from the continuation based ReadQueue to a Thread
+                     based one, that should be a bit faster.
+                   * Better organization of the file structure.
+                   * Added version information.
 2005-12-23 * 0.2.2 * Added append and + (the binary append case) to append lazy
                      lists to each other.
-2005-12-05 * 0.2.1 * Fixed a documentation bug, reported by Gary Wright
-                     <at2002@mac.com>.
+2005-12-05 * 0.2.1 * Fixed a documentation bug, reported by Gary Wright <at2002@mac.com>.
                    * enable/disable index reference cache added.
                    * LazyList#sublist added to generate sublists that
                      share elements with their "super" lists.

data/Rakefile

@@ -5,15 +5,16 @@ include Config
 
 PKG_NAME = 'lazylist'
 PKG_VERSION = File.read('VERSION').chomp
-PKG_FILES = FileList['**/*'].exclude(/^doc/).exclude(/^CVS/).exclude(/^pkg/)
-
-task :default => :test
+PKG_FILES = FileList['**/*'].exclude(/^(doc|CVS|pkg|coverage)/)
 
 desc "Run unit tests"
 task :test  do
-  cd 'tests' do
-    ruby %{-I../ext runner.rb}
-  end
+  ruby %{-Ilib tests/runner.rb}
+end
+
+desc "Testing library with coverage"
+task :coverage do
+  sh 'rcov -x tests -Ilib tests/runner.rb'
 end
 
 desc "Installing library"
@@ -33,45 +34,25 @@ task :clean do
 end
 
 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 = ""
 
-  #### Dependencies and requirements.
-
-  #s.add_dependency('log4r', '> 1.0.4')
-  #s.requirements << ""
+  s.add_dependency('dslkit', '>= 0.2.2')
 
   s.files = PKG_FILES
 
-  #### C code extensions.
-
-  #s.extensions << "ext/extconf.rb"
-
-  #### Load-time details: library and application (you will need one or both).
-
-  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"
-
-  #### Documentation and testing.
+  s.require_path = 'lib'
 
   s.has_rdoc = true
-  s.extra_rdoc_files = [ 'lib/lazylist.rb' ]
+  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'
 
-  #### Author and project details.
-
   s.author = "Florian Frank"
   s.email = "flori@ping.de"
   s.homepage = "http://lazylist.rubyforge.org"
@@ -83,5 +64,24 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.package_files += PKG_FILES
 end
 
-task :release => [ :clean, :package ]
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', 'lazylist', 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+class LazyList
+  # LazyList version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+task :default => [ :version, :test ]
+
+task :release => [ :version, :clean, :package ]
   # vim: set et sw=2 ts=2:

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/examples/examples.rb

@@ -45,8 +45,22 @@ fib.each(10) { |x| print x, " " } ; puts
 p fib[100]
 puts
 
+fib = nil
+puts "Fibonacci lazy list with zip"
+fib = list(1, 1) { fib.zip(fib.drop) { |a, b| a + b } }
+fib.each(10) { |x| print x, " " } ; puts
+p fib[100]
+puts
+
+fib = nil
+puts "Fibonacci lazy list with a list and a build call"
+fib = list(1, 1) { build { a + b }.where(:a => fib, :b => fib.drop) }
+fib.each(10) { |x| print x, " " } ; puts
+p fib[100]
+puts
+
 puts "Sum up odd numbers lazylist to get a squares stream"
-odd = LazyList.tabulate(1) { |x| 2 * x - 1 }
+odd = LazyList[1..Infinity].select { |x| x % 2 == 1 }
 puts odd
 squares = LazyList.tabulate(0) do |x|
   (0..x).inject(0) { |s, i| s + odd[i] }

data/examples/pi.rb

@@ -25,7 +25,7 @@ if $0 == __FILE__
   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:"
+  puts "Printing #{max ? "the first #{max}" : "all the "} digits of pi:" # vim-uff: "
   PI.each!(max) do |x|
     STDOUT.print x
     STDOUT.flush

data/install.rb

@@ -6,6 +6,9 @@ require 'fileutils'
 include FileUtils::Verbose
 
 libdir = CONFIG["sitelibdir"]
-file = "lib/lazylist.rb"
-install(file, libdir)
+install("lib/lazylist.rb", libdir)
+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/lib/lazylist.rb

@@ -35,6 +35,10 @@
 #
 #  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
 #
@@ -77,6 +81,14 @@
 # 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:
 #
@@ -90,6 +102,18 @@
 #  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
@@ -97,181 +121,173 @@
 # [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)
-      return select(&block), reject(&block)
-    end
+  require 'dslkit'
+  require 'lazylist/list_builder'
+  require 'lazylist/version'
 
+  require 'lazylist/enumerable'
+  include LazyList::Enumerable
 
-    # 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
+  # Exceptions raised by the LazyList implementation.
+  class Exception < ::StandardError; 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 ] }
+  # 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
 
-    # 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
+    # Extracts the top element from the queue or nil if the queue is
+    # empty.
+    def shift
+      if empty?
+        nil
       else
-        block ||= lambda { |*all| all }
-        list(block.call(head, *others.map { |o| o.head })) do
-          tail.zip(*others.map { |o| o.tail}, &block)
-        end
+        @data.shift
       end
     end
 
-    # obsoleted by #zip
-    def combine(other, &operator)
-      warn "method 'combine' is obsolete - use 'zip'"
-      zip(other, &operator)
-    end
+    alias pop shift # for backwards compatibility
 
-    # 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
+    # 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
 
-    # 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) }
+  Promise = DSLKit::BlankSlate.with :inspect, :to_s # :nodoc:
+  # A promise that can be evaluated on demand (if forced).
+  class Promise
+    def initialize(&block)
+      @block = block
     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
+    # Return the value of this Promise.
+    def __value__
+      case v = @block.call
+      when Promise
+        v.__value__
+      else
+        v
       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)
+    # Redirect all missing methods to the value of this Promise.
+    def method_missing( *args, &block )
+      __value__.__send__( *args, &block )
     end
+  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) }
+  # A promise that can be evaluated on demand (if forced), that caches its
+  # value.
+  class MemoPromise < Promise
+    # Return the value of this Promise and memoize it for later access.
+    def __value__
+      @value ||= super
     end
-    alias collect map
+  end  
 
-    # obsoleted by #map
-    def mapper(&f)
-      warn "method 'mapper' is obsolete - use 'map'"
-      map(&f)
+  # This module contains module functions, that are added to LazyList and it's
+  # instances.
+  module ModuleFunctions
+    # Delay the value of _block_ to a Promise.
+    def delay(&block)
+      MemoPromise.new(&block)
     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 lazy lists.
-  class ReadQueue
-    # Creates an ReadQueue object from an enumerable.
-    def initialize(enumerable)
-      @enumerable = enumerable
-      @break = proc {}
-      @enumerable.each do |x|
-        @current = x
-        callcc do |@continue|
-          @break.call
-          return
-        end
+    # Force the delayed _obj_ to evaluate to its value. 
+    def force(obj)
+      case obj
+      when Promise
+        force obj.__value__
+      else
+        obj
       end
-      @continue = false
-      @break.call
     end
 
-    # Extracts the top element from the queue or nil if the queue is
-    # empty.
-    def pop
-      top = @current
-      callcc { |@break| @continue.call } unless empty?
-      top
+    # Returns a LazyList, that consists of the mixed elements of the lists
+    # _lists without any special order.
+    def mix(*lists)
+      return empty if lists.empty?
+      first = lists.shift
+      if lists.empty?
+        first
+      elsif first.empty?
+        mix(*lists)
+      else
+        LazyList.new(first.head) do
+          t = first.tail
+          lists = lists.push delay { t } unless t.empty?
+          mix(*lists)
+        end
+      end
     end
+  end
+  extend ModuleFunctions
+  include ModuleFunctions
 
-    # Returns true if the queue is empty.
-    def empty?
-      @continue == false
-    end
+  # Returns an empty list.
+  def self.empty
+    new(nil, nil)
   end
 
-  # 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?
-      if LazyList.const_defined?(:Empty)
-        Empty
-      else
-        super
-      end
-    else
-      super
-    end
+  # Returns an empty list.
+  def empty
+    @klass ||= self.class
+    @klass.new(nil, nil)
   end
 
   # Creates a new LazyList element. The tail can be given either as
   # second argument or as block.
-  def initialize(head, tail = nil, &promise)
+  def initialize(head = nil, tail = nil, &block)
     @cached = true
     @ref_cache = {}
     if tail
-      promise and
+      if block
         raise LazyList::Exception,
           "Use block xor second argument for constructor"
+      end
       @head, @tail = head, tail
-    elsif promise
-      @head, @tail = head, promise
+    elsif block
+      @head, @tail = head, delay(&block)
+    else
+      @head, @tail = nil, nil
     end
   end
 
@@ -281,32 +297,45 @@ class LazyList
   attr_writer :cached
 
   # Returns true, if index references into the lazy list are cached for fast
-  # access to the referenceѕ elements.
+  # access to the referenced elements.
   def cached?
     !!@cached
   end
 
-  # Denotes the empty LazyList which is a guard at the end of finite
-  # lazy lists.
-  Empty = new(nil, nil)
+  # If the constant Empty is requested return a new empty list object.
+  def self.const_missing(id)
+    if id == :Empty
+      new(nil, nil)
+    else
+      super
+    end
+  end
 
   # Returns the value of this element.
-  attr_accessor :head
+  attr_writer :head
   protected :head=
 
+  # Returns the head of this list by computing its value.
+  def head
+    @head = force @head
+  end
+
+  # Returns the head of this list without forcing it.
+  def peek_head
+    @head
+  end
+  protected :peek_head
+
   # Writes a tail value.
   attr_writer :tail
   protected :tail=
 
   # Returns the next element by computing its value if necessary.
   def tail
-    if @tail.is_a? Proc
-      @tail = @tail[@head] || Empty
-    end
-    @tail
+    @tail = force @tail
   end
 
-  # Returns the tail of this list without evaluating.
+  # Returns the tail of this list without forcing it.
   def peek_tail
     @tail
   end
@@ -315,32 +344,67 @@ class LazyList
   # Identity lambda expression, mostly used as a default.
   Identity = lambda { |x| x }
 
+  # This block returns true.
+  All = lambda { |x| true }
+
+  # Create an array tuple from argument list.
+  Tuple = lambda { |*t| t }
+
+  # Returns true, if a less than b.
+  LessThan = lambda { |a, b| a < b }
+
+  # Swaps _you_ and _me_ and returns an Array tuple of both.
+  SwapTuple = lambda { |you, me| [ me, you ] }
+
   # Returns a lazy list which is generated from the Enumerable a or
   # LazyList.span(a, n), if n was given as an argument.
   def self.[](a, n = nil)
     case
     when n
       span(a, n)
-    when IO === a
-      io(a)
-    else
+    when a.respond_to?(:to_io)
+      io(a.to_io)
+    when a.respond_to?(:to_ary)
+      from_queue(a.to_ary)
+    when Range === a
+      from_range(a)
+    when a.respond_to?(:each)
       from_enum(a)
+    else
+      list(a)
     end
   end
 
   # Generates a lazy list 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 = proc do
-      if oq.empty?
-        Empty
+    from_queue ReadQueue.new(e)
+  end
+
+  # Generates a lazyx list by popping elements from a queue.
+  def self.from_queue(rq)
+    return empty if rq.empty?
+    new(delay { rq.shift }) { from_queue(rq) }
+  end
+
+  # Generates a lazy list from a Range instance _r_.
+  def self.from_range(r)
+    if r.exclude_end?
+      if r.begin >= r.end
+        empty
+      else
+        new(delay { r.begin }) { from_range(r.begin.succ...r.end) }
+      end
+    else
+      case
+      when r.begin > r.end
+        empty
+      when r.begin == r.end
+        new(delay { r.begin }) { empty }
       else
-        new(oq.pop, next_top)
+        new(delay { r.begin }) { from_range(r.begin.succ..r.end) }
       end
     end
-    new(oq.pop, next_top)
   end
 
   # Generates a finite lazy list beginning with element a and spanning
@@ -348,9 +412,9 @@ class LazyList
   # successor method succ.
   def self.span(a, n)
     if n > 0
-      new(a) { span(a.succ, n - 1) }
+      new(delay { a }) { span(a.succ, n - 1) }
     else
-      Empty
+      empty
     end
   end
 
@@ -359,10 +423,11 @@ class LazyList
   # If none is given the identity function is computed instead.
   def self.tabulate(n = 0, &f)
     f = Identity unless f
-    new(f[n]) { tabulate(n.succ, &f) }
+    new(delay { f[n] }) { tabulate(n.succ, &f) }
   end
 
-  # Returns a list of all elements succeeding _n_ and starting from _n_.
+  # Returns a list of all elements succeeding _n_ (that is created by calling
+  # the #succ method) and starting from _n_.
   def self.from(n = 0)
     tabulate(n)
   end
@@ -370,16 +435,16 @@ class LazyList
   # 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) }
+    new(delay { i }) { iterate(f[i], &f) }
   end
 
   # Generates a lazy list of a give IO-object using a given
   # block or Proc object to read from this object.
   def self.io(input, &f)
     if f
-      input.eof? ? Empty : new(f[input]) { io(input, &f) }
+      input.eof? ? empty : new(delay { f[input] }) { io(input, &f) }
     else
-      input.eof? ? Empty : new(input.readline) { io(input) }
+      input.eof? ? empty : new(delay { input.readline }) { io(input) }
     end
   end
 
@@ -403,9 +468,9 @@ class LazyList
       sublist_span(0, n)
     elsif m > 0
       l = ref(n)
-      self.class.new(l.head) { l.tail.sublist_span(0, m - 1) }
+      self.class.new(delay { l.head }) { l.tail.sublist_span(0, m - 1) }
     else
-      Empty
+      empty
     end
   end
 
@@ -436,23 +501,25 @@ class LazyList
       if s.empty?
         return set_ref(n, self)
       end
+      s.head # force the head
       s = s.tail
       i -= 1
     end
     set_ref(n, s)
   end
-  private :ref
+  protected :ref
 
   # If n is a Range every element in this range is returned.
   # If n isn't a Range object the element at index n is returned.
   # If m is given the next m elements beginning the n-th element are
   # returned.
   def [](n, m = nil)
-    if n.is_a? Range
+    case
+    when Range === n
       sublist(n)
-    elsif n < 0
+    when n < 0
       nil
-    elsif m
+    when m
       sublist(n, m)
     else
       ref(n).head
@@ -464,23 +531,40 @@ class LazyList
   # elements to iterate over.
   def each(n = nil)
     s = self
-    while (n.nil? or n > 0) and not s.empty? do
-      yield s.head
-      s = s.tail
-      n -= 1 unless n.nil?
+    if n
+      until n <= 0 or s.empty?
+        yield s.head
+        s = s.tail
+        n -= 1 unless n.nil?
+      end
+    else
+      until s.empty?
+        yield s.head
+        s = s.tail
+        n -= 1 unless n.nil?
+      end
     end
     s
   end
 
-  # Similar to LazyList#each but destroys elements from past
-  # iterations perhaps saving some memory.
+  # Similar to LazyList#each but destroys elements from past iterations perhaps
+  # saving some memory. Try to call GC.start from time to time in your block.
   def each!(n = nil)
     s = self
-    while (n.nil? or n > 0) and not s.empty? do
-      yield s.head
-      s = s.tail
-      n -= 1 unless n.nil?
-      @head, @tail = s.head, s.tail
+    if n
+      until n <= 0 or s.empty?
+        yield s.head
+        s = s.tail
+        n -= 1 unless n.nil?
+        @head, @tail = s.head, s.tail
+      end
+    else
+      until s.empty?
+        yield s.head
+        s = s.tail
+        n -= 1 unless n.nil?
+        @head, @tail = s.head, s.tail
+      end
     end
     self
   end
@@ -489,12 +573,15 @@ class LazyList
   # 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
-    return other if empty?
-    return self if other.empty?
-    if compare[head, other.head]
+    compare ||= LessThan
+    case
+    when empty?
+      other
+    when other.empty?
+      self
+    when compare[head, other.head]
       self.class.new(head) { tail.merge(other, &compare) }
-    elsif compare[other.head, head]
+    when compare[other.head, head]
       self.class.new(other.head) { merge(other.tail, &compare) }
     else
       self.class.new(head) { tail.merge(other.tail, &compare) }
@@ -508,12 +595,12 @@ class LazyList
   def append(*other)
     if empty?
       if other.empty?
-        Empty
+        empty
       else
         other.first.append(*other[1..-1])
       end
     else
-      list(head) { tail.append(*other) }
+      self.class.new(delay { head }) { tail.append(*other) }
     end
   end
 
@@ -569,7 +656,7 @@ class LazyList
 
   # Returns true if this is the empty lazy list.
   def empty?
-    self.equal? Empty
+    self.peek_head == nil && self.peek_tail == nil
   end
 
   # Returns true, if this lazy list and the other lazy list consist of only
@@ -586,61 +673,156 @@ class LazyList
   # Inspects the list as far as it has been computed by returning
   # a string of the form [1, 2, 3,... ].
   def inspect
-    result = "["
+    return '[]' if empty?
+    result = '['
+    first = true
     s = self
-    until s.empty?
-      pt = s.peek_tail
-      case 
-      when pt.equal?(Empty) # to avoid calling == on pt
-        result << s.head.inspect
-        break
-      when Proc === pt
-        result << s.head.inspect << ",... "
-        break
+    seen = {}
+    until s.empty? or Promise === s.peek_head or seen[s.__id__]
+      seen[s.__id__] = true
+      if first
+        first = false
       else
-        t = s.tail
-        if t.equal? self
-          result << s.head.inspect << ",... "
-          break
+        result << ', '
+      end
+      result << s.head.inspect
+      Promise === s.peek_tail and break
+      s = s.tail
+    end
+    unless empty?
+      if first
+        result << '... '
+      elsif !s.empty?
+        result << ',... '
+      end
+    end
+    result << ']'
+  end
+
+  alias to_s inspect
+
+  # Returns one "half" of the product of this LazyList and the _other_:
+  #  list(1,2,3).half_product(list(1,2)).to_a # => [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2]]
+  # _block_ can be used to yield to every pair generated and create a new list
+  # element out of it. It defaults to Tuple.
+  def half_product(other, &block)
+    block ||= Tuple
+    if empty? or other.empty?
+      empty
+    else
+      mix(
+        delay { zip(other, &block) },
+        delay { tail.half_product(other, &block) }
+      )
+    end
+  end
+
+  def swap(block) # :nodoc:
+    lambda { |you, me| block[me, you] }
+  end
+  private :swap
+
+  # Returns the (cartesian) product of this LazyList instance and the _other_.
+  # _block_ can be used to yield to every pair generated and create a new list
+  # element out of it, but it's useful to at least return the default Tuple
+  # from the block.
+  def product(other, &block)
+    if empty? or other.empty?
+      empty
+    else
+      other_block =
+        if block
+          swap block
         else
-          result << s.head.inspect << ", "
-          s = t
+          block = Tuple
+          SwapTuple
+        end
+      mix(
+        delay { half_product(other, &block)},
+        delay { other.tail.half_product(self, &other_block) }
+      )
+    end
+  end
+  alias * product
+
+  # Returns the cartesian_product of this LazyList and the others as a LazyList
+  # of Array tuples. A block can be given to yield to all the created tuples
+  # and create a LazyList out of the block results.
+  def cartesian_product(*others) # :yields: tuple
+    case
+    when empty?
+      self
+    when others.empty?
+      block_given? ? map(&Proc.new) : map
+    else
+      product = others[1..-1].inject(product(others[0])) do |intermediate, list| 
+        intermediate.product(list) do |existing, new_element|
+          existing + [ new_element ]
         end
       end
+      if block_given?
+        block = Proc.new
+        product.map { |tuple| block[*tuple] }
+      else
+        product
+      end
     end
-    result << "]"
   end
 
-  alias to_s inspect
-end
+  # This module contains methods that are included into Ruby's Kernel module.
+  module ObjectMethods
+    # 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 / y } returns a LazyList::ListBuilder object for a list
+    #   comprehension, that can be transformed into a LazyList by calling the
+    #   LazyList::ListBuilder#where method.
+    # - 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, &block)
+      values_empty = values.empty?
+      result = LazyList[values]
+      if block_given?
+        if values_empty
+          result = LazyList::ListBuilder.create_comprehend(&block)
+        else
+          result.instance_eval do
+            ref(values.size - 1)
+          end.instance_variable_set(:@tail, LazyList.delay(&block))
+        end
+      end
+      result
+    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,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
+    # This method returns a Lazylist::ListBuilder instance for tuplewise building
+    # of lists like the zip method does. This method call
+    #
+    #  build { x + y }.where(:x => 1..3, :y => 1..3)
+    #
+    # returns the same list [ 2, 4, 6 ] as this expression does
+    #
+    #  LazyList[1..3].zip(LazyList[1..3]) { |x, y| x + y }
+    def build(&block)
+      LazyList::ListBuilder.create_build(&block)
     end
-    result
+  end
+
+  class ::Object
+    unless const_defined? :Infinity
+      Infinity = 1 / 0.0
+    end
+
+    include LazyList::ObjectMethods
   end
 end
   # vim: set et sw=2 ts=2: