b-lazy 0.0.3 → 0.0.4

data/lib/b-lazy.rb

@@ -18,6 +18,16 @@ class Enumerator
   rescue StopIteration
     true
   end
+
+
+  def grab(n)
+    retval = []
+    begin
+      n.times{retval << self.next}
+    rescue StopIteration
+    end
+    retval
+  end
   
 end
 
@@ -65,12 +75,15 @@ module Enumerable
       end
     end
   end
+  
+  
+
 
 
   # Start as soon as the condition becomes true
   def start_when(&blk)
     Enumerator.new do |out|
-      s = self.to_enum
+      s = self.ensure_enum
       loop do
         break if blk.call(s.peek)
         s.next
@@ -86,7 +99,7 @@ module Enumerable
   # Start one element after the condition becomes true
   def start_after(&blk)
     Enumerator.new do |out|
-      s = self.to_enum
+      s = self.ensure_enum
       loop do
         break if blk.call(s.next)
       end
@@ -100,7 +113,7 @@ module Enumerable
 
   # Continue as long as the condition is true
   def do_while(&blk)
-    s = self.to_enum
+    s = self.ensure_enum
     Enumerator.new do |out|
       while s.has_next?
         break unless blk.call(s.peek)
@@ -112,7 +125,7 @@ module Enumerable
 
   # Keep iterating until the condition becomes true
   def do_until(&blk)
-    s = self.to_enum
+    s = self.ensure_enum
     Enumerator.new do |out|
       until s.empty?
         break if blk.call(s.peek)
@@ -126,7 +139,7 @@ module Enumerable
   # Returns all elements up to and including the element
   # the causes the condition to become true.
   def stop_when(&blk)
-    s = self.to_enum
+    s = self.ensure_enum
     Enumerator.new do |out|
       while s.has_next?
         out.yield s.peek
@@ -138,24 +151,23 @@ module Enumerable
 
   def skip(n = 1)
     Enumerator.new do |out|
-      s = self.to_enum
+      s = self.ensure_enum
       begin
         n.times {s.next}
         loop do
           out.yield s.next
         end
+      rescue StopIteration
       end
     end
   end
 
 
-
-
   def cons()
     Enumerator.new do |out|
-      s  = self.to_enum
+      s  = self.ensure_enum
       loop do
-        items = s.next.to_enum
+        items = s.next.ensure_enum
         loop do
           out.yield items.next
         end
@@ -172,38 +184,71 @@ module Enumerable
   #       one may hold an infinite number of items
   def weave()
     Enumerator.new do |out|
-      s = self.to_enum
-      enums = []
-      
+      enums = self.ensure_enum.lmap(&:ensure_enum)
       
-      # The first time through, we will gradually collect all
-      # of self's enumerators into an Array.
-      s.lmap{|e| e.to_enum}.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
+      while enums.has_next? do
+        # We to_a each iteration to avoid creating a huge
+        # Enumerator stack.
+        enums = enums.lselect{|e| e.has_next?}.touch{|e| out.yield e.next}.to_a.ensure_enum
       end
+    end
+  end
 
+
+  def diagonalize()
+    Enumerator.new do |out|
+      s = self.ensure_enum
+      enums = []
+      while s.has_next? do
+        enums.unshift s.next.ensure_enum
+        enums = enums.lselect{|e| e.has_next?}.touch{|e| out.yield e.next}.to_a
+      end
+      
+      # Nothing else in s.  Just weave the remaining elements
+      enums.weave.each{|x| out.yield x}
     end
   end
   
   
   
+  def ltranspose()
+    Enumerator.new do |out|
+      catch(:nothing_to_do) do
+        # If any Enumerable is empty, then yield nothing
+        enums = self.lmap{|e| e.ensure_enum}.
+                     touch{|e| throw :nothing_to_do if e.empty?}.
+                     to_a
+        
+        loop do
+          out.yield enums.map{|e| e.next}
+        end
+      end
+    end
+  end
+
+
+  def groups_of(n)
+    Enumerator.new do |out|
+      s = self.ensure_enum
+      while s.has_next?
+        out.yield s.grab(n)
+      end
+    end
+  end
+
+
+
+  # When #to_enum is called on an Enumerator, it creates a copy
+  # and rewinds it (when possible).  Unfortunately, this is
+  # not actually the behavior that we want; we just want to make
+  # sure that we're operating on an Enumerator.  So, this method
+  # calls #to_enum only if it is necessary.
+  def ensure_enum()
+    if self.kind_of? Enumerator
+      self
+    else
+      self.to_enum
+    end
+  end
 
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Brian Lauber