lazylist 0.2.2 → 0.3.0

data/lib/lazylist/enumerable.rb

@@ -0,0 +1,112 @@
+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
+
+    # Returns a sorted version of this lazy list. This method should only be
+    # called on finite lazy lists or it will never return. Also see
+    # Enumerable#sort.
+    def sort # :yields: a, b
+      LazyList.from_enum(super)
+    end
+
+    # Returns a sorted version of this lazy list. This method should only be
+    # called on finite lazy lists or it will never return. Also see
+    # Enumerable#sort_by.
+    def sort_by # :yields: obj
+      LazyList.from_enum(super)
+    end
+
+    # Calls _block_ with two arguments, the element and its index, for each
+    # element of this lazy list. If _block_ isn't given, the method returns a
+    # lazy list that consists of [ element, index ] pairs instead.
+    def each_with_index(&block)
+      if block
+        each_with_index.each { |x| block[x] }
+      else
+        i = -1
+        map { |x| [ x, i += 1 ] }
+      end
+    end
+
+    # Returns the lazy list, that contains all the given _block_'s return
+    # values, if it was called on every
+    #  self[i], others[0][i], others[1][i],... others[others.size - 1][i]
+    # for i in 0..Infinity. If _block_ wasn't given
+    # this result will be the array
+    #  [self[i], others[0][i], others[1][i],... ]
+    # and a lazy list of those arrays is returned.
+    def zip(*others, &block)
+      if empty? or others.any? { |o| o.empty? }
+        empty
+      else
+        block ||= Tuple
+        self.class.new(delay { block[head, *others.map { |o| o.head }] }) do
+          tail.zip(*others.map { |o| o.tail }, &block)
+        end
+      end
+    end
+
+    # obsoleted by #zip
+    def combine(other, &operator)
+      warn "method 'combine' is obsolete - use 'zip'"
+      zip(other, &operator)
+    end
+
+    # Returns a lazy list every element of this lazy list for which
+    # pattern ===  element is true. If the optional _block_ is supplied,
+    # each matching element is passed to it, and the block's result becomes
+    # an element of the returned lazy list.
+    def grep(pattern, &block)
+      result = select { |x| pattern === x }
+      block and result = result.map(&block)
+      result
+    end
+
+    # Returns a lazy list of all elements of this lazy list for which the block
+    # is false (see also +Lazylist#select+).
+    def reject
+      select { |obj| !yield(obj) }
+    end
+
+    # Returns a lazy list of all elements of this lazy list for which _block_
+    # is true.
+    def select(&block)
+      block = All unless block
+      s = self
+      until s.empty? or block[s.head]
+        s = s.tail
+      end
+      return empty if s.empty?
+      self.class.new(delay { s.head }) { s.tail.select(&block) }
+    end
+    alias find_all select
+
+    # obsoleted by #select
+    def filter(&p)
+      warn "method 'filter' is obsolete - use 'select'"
+      select(&p)
+    end
+
+    # Creates a new Lazylist that maps the block or Proc object f to every
+    # element in the old list.
+    def map(&f)
+      return empty if empty?
+      f = Identity unless f
+      self.class.new(delay { f[head] }) { tail.map(&f) }
+    end
+    alias collect map
+
+    # obsoleted by #map
+    def mapper(&f)
+      warn "method 'mapper' is obsolete - use 'map'"
+      map(&f)
+    end
+  end
+end

data/lib/lazylist/list_builder.rb

@@ -0,0 +1,137 @@
+require 'dslkit'
+
+class LazyList
+  def do_build(lb, others) # :nodoc:
+    if empty? or others.any? { |o| o.empty? }
+      Empty
+    else
+      variables = [ head ].concat others.map { |o| o.head }
+      if lb.filter
+        if lb.filter[*variables]
+          self.class.new(lb.transform[*variables]) do
+            tail.do_build(lb, others.map { |o| o.tail })
+          end
+        else
+          tail.do_build(lb, others.map { |o| o.tail })
+        end
+      else
+        self.class.new(lb.transform[*variables]) do
+          tail.do_build(lb, others.map { |o| o.tail })
+        end
+      end
+    end
+  end
+
+  def do_comprehend(lb, others) # :nodoc:
+    if lb.filter
+      cartesian_product(*others).select do |variables|
+        lb.filter[*variables]
+      end.map do |variables|
+        lb.transform[*variables]
+      end
+    else
+      cartesian_product(*others).map do |variables|
+        lb.transform[*variables]
+      end
+    end
+  end
+
+  # This class encapsulates a list builder (ListBuilder), that can be transformed
+  # into a LazyList, by calling LazyList::ListBuilder#where.
+  class ListBuilder
+    # This class is a special kind of Proc object, that uses instance_eval to
+    # execute a code block.
+    class ListBuilderProc < Proc
+      include DSLKit::MethodMissingDelegator
+      include DSLKit::BlockSelf
+
+      # Creates a ListBuilderProc working on the list builder _lb_ using the Proc
+      # returned by lb.#{name}. _name_ has to be either :filter or :transform.
+      def initialize(lb, name, &block)
+        @name = name
+        @lb = lb
+        @method_missing_delegator = block_self(&block)
+        super(&@lb.__send__(@name))
+      end
+
+      # Call this ListBuilderProc instance with the arguments _args_, which have to be
+      # the ordered values of the variables.
+      def call(*args)
+        prepare_variables
+        @lb.variables.each_with_index do |var, i|
+          instance_variable_set "@#{var}", args[i]
+        end
+        instance_eval(&@lb.__send__(@name))
+      end
+      alias [] call
+
+      private
+
+      def prepare_variables
+        @variables_prepared and return
+        variables = @lb.variables
+        class << self; self; end.instance_eval do
+          attr_reader(*variables)
+        end
+        @variables_prepared = true
+      end
+    end
+
+    # Creates LazyList::ListBuilder instance. _mode_ has to be either :do_build
+    # or :do_comprehend.
+    def initialize(mode, &block)
+      @mode = mode
+      @transform = ListBuilderProc.new(self, :transform, &block)
+    end
+
+    # The variable names defined in this list builder.
+    attr_reader :variables
+
+    # The transform ListBuilderProc instance of this list builder.
+    attr_reader :transform
+
+    # The filter ListBuilderProc of this list builder or nil.
+    attr_reader :filter
+
+    # This method creates a LazyList instance from this list builder,
+    # using the _sources_ hash to fetch the variables from. _sources_ consists
+    # of the variable name and the values, that can be LazyList instances or
+    # otherwise they will be transformed into a LazyList with LazyList.[].
+    #
+    # It also takes a block, to filter the results by a boolean expression.
+    def where(sources = {}, &block)
+      @variables = []
+      generators = []
+      sources.each do |var, src|
+        @variables << var
+        generators << (src.is_a?(LazyList) ? src : LazyList[src])
+      end
+      if block_given?
+        @filter = ListBuilderProc.new(self, :filter, &block)
+      else
+        @filter = nil
+      end
+      generators.first.__send__(@mode, self, generators[1..-1])
+    end
+
+    # Return a (not much) nicer string representation of the list
+    # builder.
+    def to_s
+      "#<LazyList::ListBuilder>"
+    end
+    alias inspect to_s
+
+    class << self
+      # Used to support the build method
+      def create_build(&block)
+        new(:do_build, &block)
+      end
+
+      # Used to evaluate a list comprehension, usually if calling the list
+      # method with only a block.
+      def create_comprehend(&block)
+        new(:do_comprehend, &block)
+      end
+    end
+  end
+end

data/lib/lazylist/version.rb

@@ -0,0 +1,8 @@
+class LazyList
+  # LazyList version
+  VERSION         = '0.3.0'
+  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

data/make_doc.rb

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

data/tests/runner.rb

@@ -3,12 +3,7 @@
 require 'test/unit/ui/console/testrunner'
 require 'test/unit/testsuite'
 $:.unshift File.expand_path(File.dirname($0))
-$:.unshift 'lib'
-$:.unshift '../lib'
-begin
-  require 'coverage'
-rescue LoadError
-end
+$:.unshift 'tests'
 require 'test'
 require 'test_enumerable'
 

data/tests/test.rb

@@ -67,6 +67,7 @@ class TC_LazyList < Test::Unit::TestCase
     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
+    assert_equal @finite_span_generated, LazyList["A"..."K"].to_a
   end
 
   def test_size
@@ -84,6 +85,8 @@ class TC_LazyList < Test::Unit::TestCase
     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 ] * 10, @ones[0, 10].to_a
@@ -244,11 +247,16 @@ class TC_LazyList < Test::Unit::TestCase
     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)
   end
 
   def test_inspect
     l = LazyList[1..11]
     assert_equal "[]", Empty.inspect 
+    assert_equal "[... ]", l.inspect 
+    l[0]
     assert_equal "[1,... ]", l.inspect 
     l[1]
     assert_equal "[1, 2,... ]", l.inspect 
@@ -284,10 +292,12 @@ class TC_LazyList < Test::Unit::TestCase
     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 '[... ]', ones.inspect
     assert_equal 1, ones.head
     assert_equal '[1,... ]', ones.inspect
     assert_equal [ 1 ] * 10 , ones.take(10)
     assert_equal '[1,... ]', ones.inspect
+    assert_equal [:foo], LazyList[:foo].to_a
   end
 
   def test_sublist
@@ -324,5 +334,56 @@ class TC_LazyList < Test::Unit::TestCase
     assert_equal [1, 2, 3] + [5, 6, 7] + [9, 10, 11, 12],
       l1.append(l2, l3).take(10)
   end
+
+  def test_list_builder
+    lb = build { y * x }
+    assert_kind_of LazyList::ListBuilder, lb
+    assert_equal "#<LazyList::ListBuilder>", lb.to_s
+    l = lb.where :x => 1..10, :y => 'a'..'j' do
+      x % 2 == 0 && y < 'j'
+    end
+    assert_kind_of LazyList, l
+    assert_equal ["bb", "dddd", "ffffff", "hhhhhhhh"], l.to_a
+    l = build { y * x }.where :x => 1..10, :y => 'a'..'j'
+    assert_equal ["a", "bb", "ccc", "dddd", "eeeee", "ffffff", "ggggggg",
+      "hhhhhhhh", "iiiiiiiii", "jjjjjjjjjj"], l.to_a
+  end
+
+  def twice(x)
+    2 * x
+  end
+
+  def test_list_comprehend
+    f = LazyList[1..3]
+    g = LazyList[1..2]
+    assert_equal [ ], LazyList.mix(LazyList::Empty).to_a
+    assert_equal [ ], LazyList.mix(LazyList::Empty, LazyList::Empty).to_a
+    assert_equal [ 1 ], LazyList.mix(list(1), LazyList::Empty).to_a
+    assert_equal [ 1 ], LazyList.mix(LazyList::Empty, list(1)).to_a
+    assert_equal [ 1, 1, 2, 2, 3 ], LazyList.mix(f, g).to_a
+    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 [ [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,
+      2], [2, 2, 1], [2, 2, 2]], g.cartesian_product(g, g).to_a
+    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 
+    assert_equal [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ], l.to_a.sort
+    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
+    l = list { [ x, y ] }.where(:x => f, :y => f) {  x <= y }
+    assert_equal [ [1, 1], [1, 2], [1, 3], [2, 2], [2, 3], [3, 3] ], l.to_a.sort
+    test = list { x * y }.where :x => 1..4, :y => list(3, 5, 7, 9)
+    assert_equal [ 3, 5, 6, 7, 10, 14, 9, 9, 21, 27, 15, 18, 36, 12, 28, 20 ].sort, test.to_a.sort
+    test = list { x + twice(y) }.where :x => 1..4, :y => list(3, 5, 7, 9)
+    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: 

metadata

@@ -3,62 +3,79 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: lazylist
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2005-12-23 00:00:00 +01:00
+  version: 0.3.0
+date: 2007-05-05 00:00:00 +02:00
 summary: Implementation of lazy lists for Ruby
 require_paths: 
-  - lib
+- lib
 email: flori@ping.de
 homepage: http://lazylist.rubyforge.org
 rubyforge_project: lazylist
-description: ''
-autorequire: 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
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-  - Florian Frank
+- Florian Frank
 files: 
-  - examples
-  - install.rb
-  - GPL
-  - TODO
-  - Rakefile
-  - VERSION
-  - tests
-  - CHANGES
-  - lib
-  - make_doc.rb
-  - README.en
-  - examples/hamming.rb
-  - examples/sieve.rb
-  - examples/pi.rb
-  - examples/examples.rb
-  - tests/test.rb
-  - tests/test_enumerable.rb
-  - tests/runner.rb
-  - lib/lazylist.rb
+- VERSION
+- tests
+- GPL
+- README.en
+- install.rb
+- Rakefile
+- examples
+- lib
+- make_doc.rb
+- CHANGES
+- tests/runner.rb
+- tests/test.rb
+- tests/test_enumerable.rb
+- examples/pi.rb
+- examples/hamming.rb
+- examples/examples.rb
+- examples/sieve.rb
+- lib/lazylist.rb
+- lib/lazylist
+- lib/lazylist/list_builder.rb
+- lib/lazylist/enumerable.rb
+- lib/lazylist/version.rb
 test_files: 
-  - tests/test.rb
+- tests/test.rb
 rdoc_options: 
-  - "--title"
-  - "LazyList -- Infinite lists in Ruby"
-  - "--main"
-  - LazyList
-  - "--line-numbers"
+- --title
+- LazyList -- Infinite lists in Ruby
+- --main
+- LazyList
+- --line-numbers
 extra_rdoc_files: 
-  - lib/lazylist.rb
+- lib/lazylist.rb
+- lib/lazylist/list_builder.rb
+- lib/lazylist/enumerable.rb
+- lib/lazylist/version.rb
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+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: