b-lazy 0.0.1

data/lib/b-lazy.rb

@@ -0,0 +1,192 @@
+
+
+# We really don't need to make any significant changes
+# to the Enumerator class itself.  We're just adding a
+# few convenient methods that can simplify looping constructs.
+class Enumerator
+
+  def has_next?
+    peek
+    true
+  rescue StopIteration
+    false
+  end
+  
+  def empty?
+    peek
+    false
+  rescue StopIteration
+    true
+  end
+  
+end
+
+
+
+
+module Enumerable
+
+
+  def lmap(&blk)
+    Enumerator.new do |out|
+      self.each do |i|
+        out.yield blk.call(i)
+      end
+    end
+  end
+  
+  
+  def lselect(&blk)
+    Enumerator.new do |out|
+      self.each do |i|
+        out.yield i if blk.call(i)
+      end
+    end
+  end
+  
+  def lreject(&blk)
+    Enumerator.new do |out|
+      self.each do |i|
+        out.yield i unless blk.call(i)
+      end
+    end
+  end
+
+
+  # Start as soon as the condition becomes true
+  def start_when(&blk)
+    Enumerator.new do |out|
+      s = self.to_enum
+      loop do
+        break if blk.call(s.peek)
+        s.next
+      end
+      
+      loop do
+        out.yield s.next
+      end
+    end
+  end
+  
+  
+  # Start one element after the condition becomes true
+  def start_after(&blk)
+    Enumerator.new do |out|
+      s = self.to_enum
+      loop do
+        break if blk.call(s.next)
+      end
+      
+      loop do
+        out.yield s.next
+      end
+    end
+  end
+  
+
+  # Continue as long as the condition is true
+  def do_while(&blk)
+    s = self.to_enum
+    Enumerator.new do |out|
+      while s.has_next?
+        break unless blk.call(s.peek)
+        out.yield s.next
+      end
+    end
+  end
+
+
+  # Keep iterating until the condition becomes true
+  def do_until(&blk)
+    s = self.to_enum
+    Enumerator.new do |out|
+      until s.empty?
+        break if blk.call(s.peek)
+        out.yield s.next
+      end
+    end
+  end
+  alias :stop_before :do_until
+  
+  
+  # Returns all elements up to and including the element
+  # the causes the condition to become true.
+  def stop_when(&blk)
+    s = self.to_enum
+    Enumerator.new do |out|
+      while s.has_next?
+        out.yield s.peek
+        break if blk.call(s.next)
+      end
+    end
+  end
+
+
+  def skip(n = 1)
+    Enumerator.new do |out|
+      s = self.to_enum
+      begin
+        n.times {s.next}
+        loop do
+          out.yield s.next
+        end
+      end
+    end
+  end
+
+
+
+
+  def cons()
+    Enumerator.new do |out|
+      s  = self.to_enum
+      loop do
+        items = s.next.to_enum
+        loop do
+          out.yield items.next
+        end
+      end
+    end
+  end
+  
+  
+  # NOTE: This method should only be called on Enumerators
+  #       of Enumerators!  This is similar to cons, but it
+  #       instead takes the first item from each enumerator,
+  #       then the second item, etc.  This can be handy when
+  #       you have a finite number of enumerators, but each
+  #       one may hold an infinite number of items
+  def weave()
+    Enumerator.new do |out|
+      s = self.to_enum
+      enums = []
+      
+      
+      # The first time through, we will gradually collect all
+      # of self's enumerators into an Array.
+      self.each do |e|
+        if e.has_next?
+          enums << e
+          out.yield e.next
+        end
+      end
+      
+      
+      
+      # Now all the enumerators have been collected into an Array.
+      # Henceforth, we'll iterate through this Array
+      until enums.empty?
+        next_enums = []
+        enums.each do |e|
+          if e.has_next?
+            next_enums << e
+            out.yield e.next
+          end
+        end
+        enums = next_enums
+      end
+
+    end
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: b-lazy
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Lauber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-04 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Extends core Ruby objects to provide inherent support for lazy-evaluation.
+email: constructible.truth@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/b-lazy.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/hola
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 1
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: b-lazy
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Why work hard for lazy-evaluation?
+test_files: []
+