lazily 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTE1ODg4ZDgzNDFjMTc0YzlhMWE0ODU5MWRmNjcyYzQyMTNkMGNmYw==
+  data.tar.gz: !binary |-
+    MDlhZjZhMWI5ZDNiMDdmMzk3OWU4NGM4MGVmYzhlODUyMzEyYzg3Ng==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NWNkYWNkOTViODA2OWM0ZWM1NWJkNTlhY2Y2NWUwNmQ0NGQ1MjZiZjFkODgz
+    MGFiYjRlYmZjYTQzZDkyYjMyMzFhYjU1ZTE3Y2JmMTMwZWEwMzBhYWFhZDIw
+    Nzg3Y2I0MjUyYzQzOTJkOTg2MmI4NjdlZmQ0MTkwZTkzMzA2YTY=
+  data.tar.gz: !binary |-
+    OGQ5ZTBhZTgyNTUwOTc3NTEwOGE3MTgwMmM0OWFiZjBiZDY1ZGJjYWRlMDJl
+    YTM2NmY5ZmYzMGRhNDI3Yjk4NTgwYTU5MTdmYjllM2U4Y2M0ZDVlODM1ZTI1
+    MThmOTkyZDNhZDNjNDVkYWVkZjBmMDJmMGEwMGZjMGRiZTAxYzI=

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - jruby-18mode
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 10.0.0"
+gem "rspec", "~> 2.13.0"

data/Rakefile

@@ -0,0 +1,12 @@
+require "rake"
+
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--format", "nested"]
+end
+
+task "default" => "spec"

data/lazily.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "lazily/version"
+
+Gem::Specification.new do |s|
+
+  s.name          = "lazily"
+  s.version       = Lazily::VERSION.dup
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Mike Williams"]
+  s.email         = "mdub@dogbiscuit.org"
+  s.homepage      = "http://github.com/mdub/lazily"
+
+  s.summary       = %{Lazy Enumerables for everybody!}
+  s.description   = <<-EOT
+    Lazily implements "lazy" versions of many Enumerable methods,
+    allowing streamed processing of large (or even infinite) collections.
+
+    It's equivalent to Ruby-2.x's Enumerable#lazy, but is implemented in
+    pure Ruby, and works even in Ruby-1.8.x.
+  EOT
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+end

data/lib/lazily.rb

@@ -0,0 +1,4 @@
+require "lazily/combining"
+require "lazily/filtering"
+require "lazily/proxy"
+require "lazily/threading"

data/lib/lazily/combining.rb

@@ -0,0 +1,3 @@
+require "lazily/concatenating"
+require "lazily/merging"
+require "lazily/zipping"

data/lib/lazily/concatenating.rb

@@ -0,0 +1,37 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  class << self
+
+    def concat(*enumerables)
+      Concatenator.new(enumerables)
+    end
+
+  end
+
+  module Enumerable
+
+    def concat(*others)
+      Lazily.concat(self, *others)
+    end
+
+  end
+
+  class Concatenator
+
+    include Lazily::Enumerable
+
+    def initialize(enumerables)
+      @enumerables = enumerables
+    end
+
+    def each(&block)
+      @enumerables.each do |enumerable|
+        enumerable.each(&block)
+      end
+    end
+
+  end
+
+end

data/lib/lazily/enumerable.rb

@@ -0,0 +1,13 @@
+module Lazily
+
+  module Enumerable
+
+    include ::Enumerable
+
+    def lazy?
+      true
+    end
+
+  end
+
+end

data/lib/lazily/filtering.rb

@@ -0,0 +1,118 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  module Enumerable
+
+    def collect
+      Filter.new do |output|
+        each do |element|
+          output.call yield(element)
+        end
+      end
+    end
+
+    alias map collect
+
+    def select
+      Filter.new do |output|
+        each do |element|
+          output.call(element) if yield(element)
+        end
+      end
+    end
+
+    alias find_all select
+
+    def reject
+      Filter.new do |output|
+        each do |element|
+          output.call(element) unless yield(element)
+        end
+      end
+    end
+
+    def uniq
+      Filter.new do |output|
+        seen = Set.new
+        each do |element|
+          output.call(element) if seen.add?(element)
+        end
+      end
+    end
+
+    def uniq_by
+      Filter.new do |output|
+        seen = Set.new
+        each do |element|
+          output.call(element) if seen.add?(yield element)
+        end
+      end
+    end
+
+    def take(n)
+      Filter.new do |output|
+        if n > 0
+          each_with_index do |element, index|
+            output.call(element)
+            throw Lazily::Filter::DONE if index + 1 == n
+          end
+        end
+      end
+    end
+
+    def take_while
+      Filter.new do |output|
+        each do |element|
+          throw Lazily::Filter::DONE unless yield(element)
+          output.call(element)
+        end
+      end
+    end
+
+    def drop(n)
+      Filter.new do |output|
+        each_with_index do |element, index|
+          next if index < n
+          output.call(element)
+        end
+      end
+    end
+
+    def drop_while
+      Filter.new do |output|
+        take = false
+        each do |element|
+          take ||= !yield(element)
+          output.call(element) if take
+        end
+      end
+    end
+
+    def [](n)
+      drop(n).first
+    end
+
+  end
+
+  class Filter
+
+    include Lazily::Enumerable
+
+    def initialize(&generator)
+      @generator = generator
+    end
+
+    DONE = "Lazily::DONE".to_sym
+
+    def each
+      return to_enum unless block_given?
+      yielder = proc { |x| yield x }
+      catch DONE do
+        @generator.call(yielder)
+      end
+    end
+
+  end
+
+end

data/lib/lazily/merging.rb

@@ -0,0 +1,72 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  class << self
+
+    def merge(*enumerables)
+      Merger.new(enumerables)
+    end
+
+    def merge_by(*enumerables, &block)
+      Merger.new(enumerables, &block)
+    end
+
+  end
+
+  class Merger
+
+    include Lazily::Enumerable
+
+    def initialize(enumerables, &transformer)
+      @enumerables = enumerables
+      @transformer = transformer
+    end
+
+    def each(&block)
+      return to_enum unless block_given?
+      Generator.new(@enumerables.map(&:to_enum), @transformer).each(&block)
+    end
+
+    class Generator
+
+      def initialize(enumerators, transformer)
+        @enumerators = enumerators
+        @transformer = transformer
+      end
+
+      def each
+        loop do
+          discard_empty_enumerators
+          break if @enumerators.empty?
+          yield next_enumerator.next
+        end
+      end
+
+      private
+
+      def discard_empty_enumerators
+        @enumerators.delete_if do |e|
+          begin
+            e.peek
+            false
+          rescue StopIteration
+            true
+          end
+        end
+      end
+
+      def next_enumerator
+        @enumerators.min_by { |enumerator| transform(enumerator.peek) }
+      end
+
+      def transform(item)
+        return item unless @transformer
+        @transformer.call(item)
+      end
+
+    end
+
+  end
+
+end

data/lib/lazily/prefetching.rb

@@ -0,0 +1,43 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  module Enumerable
+
+    def prefetch(size)
+      Prefetcher.new(self, size)
+    end
+
+  end
+
+  class Prefetcher
+
+    include Lazily::Enumerable
+
+    def initialize(source, buffer_size)
+      @source = source.to_enum
+      @buffer_size = buffer_size
+    end
+
+    def each(&block)
+      return @source.each(&block) if @buffer_size <= 0
+      buffered_elements = []
+      i = 0
+      @source.each do |element|
+        slot = i % @buffer_size
+        if i >= @buffer_size
+          yield buffered_elements[slot]
+        end
+        buffered_elements[slot] = element
+        i += 1
+      end
+      buffered_elements.size.times do
+        slot = i % buffered_elements.size
+        yield buffered_elements[slot]
+        i += 1
+      end
+    end
+
+  end
+
+end

data/lib/lazily/proxy.rb

@@ -0,0 +1,32 @@
+require "lazily/enumerable"
+
+def Lazily(enumerable)
+  Lazily::Proxy.new(enumerable)
+end
+
+module ::Enumerable
+
+  def lazily
+    Lazily::Proxy.new(self)
+  end
+
+end
+
+module Lazily
+
+  class Proxy
+
+    include Lazily::Enumerable
+
+    def initialize(source)
+      @source = source
+    end
+
+    def each(&block)
+      return to_enum unless block
+      @source.each(&block)
+    end
+
+  end
+
+end

data/lib/lazily/threading.rb

@@ -0,0 +1,16 @@
+require "lazily/prefetching"
+
+module Lazily
+
+  module Enumerable
+
+    def in_threads(max_threads, &block)
+      collect do |item|
+        Thread.new { block.call(item) }
+      end.prefetch(max_threads - 1).collect do |thread|
+        thread.join; thread.value
+      end
+    end
+  end
+
+end

data/lib/lazily/version.rb

@@ -0,0 +1,3 @@
+module Lazily
+  VERSION = "0.0.1".freeze
+end

data/lib/lazily/zipping.rb

@@ -0,0 +1,46 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  class << self
+
+    def zip(*enumerables)
+      Zipper.new(enumerables)
+    end
+
+  end
+
+  module Enumerable
+
+    def zip(*others)
+      Lazily.zip(self, *others)
+    end
+
+  end
+
+  class Zipper
+
+    include Lazily::Enumerable
+
+    def initialize(enumerables)
+      @enumerables = enumerables
+    end
+
+    def each
+      enumerators = @enumerables.map(&:to_enum)
+      while true
+        chunk = enumerators.map do |enumerator|
+          begin
+            enumerator.next
+          rescue StopIteration
+            nil
+          end
+        end
+        break if chunk.all?(&:nil?)
+        yield chunk
+      end
+    end
+
+  end
+
+end

data/spec/lazily/concatenating_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Lazily, "concatenating" do
+
+  describe ".concat" do
+
+    let(:array1) { [1,5,3] }
+    let(:array2) { [2,9,4] }
+
+    it "concatenates multiple Enumerables" do
+      result = Lazily.concat([1,5,3], [2,9,4])
+      result.to_a.should == [1,5,3,2,9,4]
+    end
+
+    it "is lazy" do
+      result = Lazily.concat([3,4], [1,2].with_time_bomb)
+      result.take(3).to_a.should == [3,4,1]
+    end
+
+  end
+
+  describe "#concat" do
+
+    let(:array1) { [1,5,3] }
+    let(:array2) { [2,9,4] }
+
+    it "concatenates multiple Enumerables" do
+      result = [1,5,3].lazily.concat([2,9,4])
+      result.to_a.should == [1,5,3,2,9,4]
+    end
+
+    it "is lazy" do
+      result = [3,4].lazily.concat([1,2].with_time_bomb)
+      result.take(3).to_a.should == [3,4,1]
+    end
+
+  end
+
+end

data/spec/lazily/filtering_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+describe Lazily, "filter" do
+
+  describe "#collect" do
+
+    it "transforms items" do
+      [1,2,3].lazily.collect { |x| x * 2 }.to_a.should == [2,4,6]
+    end
+
+    it "is lazy" do
+      [1,2,3].with_time_bomb.lazily.collect { |x| x * 2 }.first.should == 2
+    end
+
+  end
+
+  describe "#select" do
+
+    it "excludes items that don't pass the predicate" do
+      (1..6).lazily.select { |x| x%2 == 0 }.to_a.should == [2,4,6]
+    end
+
+    it "is lazy" do
+      (1..6).with_time_bomb.lazily.select { |x| x%2 == 0 }.first == 2
+    end
+
+  end
+
+  describe "#reject" do
+
+    it "excludes items that do pass the predicate" do
+      (1..6).lazily.reject { |x| x%2 == 0 }.to_a.should == [1,3,5]
+    end
+
+    it "is lazy" do
+      (1..6).with_time_bomb.lazily.reject { |x| x%2 == 0 }.first == 1
+    end
+
+  end
+
+  describe "#uniq" do
+
+    it "removes duplicates" do
+      [1,3,2,4,3,5,4,6].lazily.uniq.to_a.should == [1,3,2,4,5,6]
+    end
+
+    it "is lazy" do
+      [1,2,3].with_time_bomb.lazily.uniq.first.should == 1
+    end
+
+  end
+
+  describe "#uniq_by" do
+
+    it "uses the block to derive identity" do
+      @array = %w(A1 A2 B1 A3 C1 B2 C2)
+      @array.lazily.uniq_by { |s| s[0,1] }.to_a.should == %w(A1 B1 C1)
+    end
+
+  end
+
+  describe "#take" do
+
+    it "includes the specified number" do
+      @array = [1,2,3,4]
+      @array.lazily.take(3).to_a.should == [1,2,3]
+    end
+
+    it "is lazy" do
+      [1,2].with_time_bomb.lazily.take(2).to_a.should == [1,2]
+    end
+
+    it "copes with 0" do
+      [].with_time_bomb.lazily.take(0).to_a.should == []
+    end
+
+  end
+
+  describe "#take_while" do
+
+    it "takees elements as long as the predicate is true" do
+      @array = [2,4,6,3]
+      @array.lazily.take_while(&:even?).to_a.should == [2,4,6]
+    end
+
+    it "is lazy" do
+      [2,3].with_time_bomb.lazily.take_while(&:even?).to_a.should == [2]
+    end
+
+  end
+
+  describe "#drop" do
+
+    it "excludes the specified number" do
+      @array = [1,2,3,4]
+      @array.lazily.drop(2).to_a.should == [3,4]
+    end
+
+    it "is lazy" do
+      [1,2,3,4].with_time_bomb.lazily.drop(2).lazily.take(1).to_a.should == [3]
+    end
+
+  end
+
+  describe "#drop_while" do
+
+    it "drops elements as long as the predicate is true" do
+      @array = [2,4,6,3,4]
+      @array.lazily.drop_while(&:even?).to_a.should == [3,4]
+    end
+
+    it "is lazy" do
+      [2,3].with_time_bomb.lazily.drop_while(&:even?).lazily.take(1).to_a.should == [3]
+    end
+
+  end
+
+  describe "#[]" do
+
+    before do
+      @evens = [1,2,3,4,5].lazily.collect { |x| x * 2 }
+    end
+
+    it "finds the specified element" do
+      @evens.lazily[2].should == 6
+    end
+
+    it "is lazy" do
+      @evens.with_time_bomb.lazily[3].should == 8
+    end
+
+  end
+
+end

data/spec/lazily/merging_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Lazily, :needs_enumerators => true do
+
+  describe ".merge" do
+
+    it "merges multiple Enumerators" do
+      @array1 = [1,3,6]
+      @array2 = [2,4,7]
+      @array3 = [5,8]
+      @merge = Lazily.merge(@array1, @array2, @array3)
+      @merge.to_a.should == [1,2,3,4,5,6,7,8]
+    end
+
+    it "is lazy" do
+      @enum1 = [1,3,6]
+      @enum2 = [2,4,7].with_time_bomb
+      @merge = Lazily.merge(@enum1, @enum2)
+      @merge.take(4).to_a.should == [1,2,3,4]
+    end
+
+  end
+
+  describe ".merge_by" do
+
+    it "uses the block to determine order" do
+      @array1 = %w(cccc dd a)
+      @array2 = %w(eeeee bbb)
+      @merge = Lazily.merge_by(@array1, @array2) { |s| -s.length }
+      @merge.to_a.should == %w(eeeee cccc bbb dd a)
+    end
+
+  end
+
+end

data/spec/lazily/prefetching_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Lazily do
+
+  Counter = Class.new do
+
+    include Enumerable
+
+    def initialize(source)
+      @source = source
+      @number_yielded = 0
+    end
+
+    def each
+      @source.each do |item|
+        @number_yielded += 1
+        yield item
+      end
+    end
+
+    attr_reader :number_yielded
+
+  end
+
+  describe "#prefetch" do
+
+    let(:source) { [1, 2, 3, 4, nil, false, 7] }
+
+    it "yields all items" do
+      source.lazily.prefetch(2).to_a.should eq(source)
+      source.lazily.prefetch(3).to_a.should eq(source)
+    end
+
+    it "is stateless" do
+      source.lazily.prefetch(2).first.should eq(source.first)
+      source.lazily.prefetch(2).first.should eq(source.first)
+    end
+
+    it "is lazy" do
+      source.with_time_bomb.lazily.prefetch(2).first.should eq(source.first)
+    end
+
+    it "pre-computes the specified number of elements" do
+      counter = Counter.new(source)
+      counter.lazily.prefetch(2).first
+      counter.number_yielded.should eq(3)
+    end
+
+    context "with a buffer size of zero" do
+
+      it "does not pre-fetch anything" do
+        counter = Counter.new(source)
+        counter.lazily.prefetch(0).first
+        counter.number_yielded.should eq(1)
+      end
+
+    end
+
+    context "with a buffer bigger than the source Enumerable" do
+
+      it "yields all items" do
+        source.lazily.prefetch(20).to_a.should eq(source)
+      end
+
+    end
+
+  end
+
+end

data/spec/lazily/threading_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Lazily, "threading" do
+
+  describe "#in_threads" do
+
+    it "acts like #collect" do
+      [1,2,3].lazily.in_threads(5) { |x| x * 2 }.to_a.should == [2,4,6]
+    end
+
+    it "runs things in separate threads" do
+      [1,2,3].lazily.in_threads(5) { Thread.current.object_id }.to_a.uniq.size.should eq(3)
+    end
+
+    it "is lazy" do
+      [1,2,3].with_time_bomb.lazily.in_threads(2) { |x| x * 2 }.first.should == 2
+    end
+
+    def round(n, accuracy = 0.02)
+      (n / accuracy).round.to_f * accuracy
+    end
+
+    it "runs the specified number of threads in parallel" do
+      delays = [0.03, 0.03, 0.03]
+      start = Time.now
+      delays.lazily.in_threads(2) do |delay|
+        sleep(delay)
+      end.to_a
+      round(Time.now - start).should eq(0.06)
+    end
+
+    it "acts as a sliding window" do
+      delays = [0.1, 0.08, 0.06, 0.04, 0.02]
+      start = Time.now
+      elapsed_times = delays.lazily.in_threads(3) do |delay|
+        sleep(delay)
+        round(Time.now - start)
+      end
+      elapsed_times.to_a.should eq([0.1, 0.08, 0.06, 0.14, 0.12])
+    end
+
+    it "surfaces exceptions" do
+      lambda do
+        [1,2,3].lazily.in_threads(5) { raise "hell" }.to_a
+      end.should raise_error(RuntimeError, "hell")
+    end
+
+  end
+
+end

data/spec/lazily/zipping_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Lazily, "zipping", :needs_enumerators => true do
+
+  let(:array1) { [1,3,6] }
+  let(:array2) { [2,4,7] }
+  let(:array3) { [5,8] }
+
+  describe ".zip" do
+
+    it "zips together multiple Enumerables" do
+      zip = Lazily.zip(array1, array2, array3)
+      zip.to_a.should == [[1,2,5], [3,4,8], [6,7,nil]]
+    end
+
+    it "is lazy" do
+      zip = Lazily.zip(%w(a b c), [1,2].with_time_bomb)
+      zip.take(2).to_a.should == [["a", 1], ["b", 2]]
+    end
+
+  end
+
+  describe "#zip" do
+
+    it "zips an Enumerable with multiple others" do
+      zip = array1.lazily.zip(array2, array3)
+      zip.to_a.should == [[1,2,5], [3,4,8], [6,7,nil]]
+    end
+
+    it "is lazy" do
+      zip = %w(a b c).lazily.zip([1,2].with_time_bomb)
+      zip.take(2).to_a.should == [["a", 1], ["b", 2]]
+    end
+
+  end
+
+end

data/spec/lazily_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Lazily", "method" do
+
+  it "returns a lazy proxy" do
+    Lazily([1,2,3]).should be_lazy
+  end
+
+end
+
+describe "Enumerable", "#lazily" do
+
+  it "returns a lazy proxy" do
+    [1,2,3].lazily.should be_lazy
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require "lazily"
+
+class NotLazyEnough < StandardError; end
+
+class WithTimeBomb
+
+  include Enumerable
+
+  def initialize(source)
+    @source = source
+  end
+
+  def each(&block)
+    @source.each(&block)
+    raise NotLazyEnough
+  end
+
+end
+
+module Enumerable
+
+  # extend an Enumerable to throw an exception after last element
+  def with_time_bomb
+    WithTimeBomb.new(self)
+  end
+
+  unless method_defined?(:first)
+    def first
+      each do |first_item|
+        return first_item
+      end
+    end
+  end
+
+end
+
+RSpec.configure do |config|
+  unless defined?(::Enumerator)
+    config.filter_run_excluding :needs_enumerators => true
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lazily
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mike Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-19 00:00:00.000000000 Z
+dependencies: []
+description: ! "    Lazily implements \"lazy\" versions of many Enumerable methods,\n
+  \   allowing streamed processing of large (or even infinite) collections.\n\n    It's
+  equivalent to Ruby-2.x's Enumerable#lazy, but is implemented in\n    pure Ruby,
+  and works even in Ruby-1.8.x.\n"
+email: mdub@dogbiscuit.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Rakefile
+- lazily.gemspec
+- lib/lazily.rb
+- lib/lazily/combining.rb
+- lib/lazily/concatenating.rb
+- lib/lazily/enumerable.rb
+- lib/lazily/filtering.rb
+- lib/lazily/merging.rb
+- lib/lazily/prefetching.rb
+- lib/lazily/proxy.rb
+- lib/lazily/threading.rb
+- lib/lazily/version.rb
+- lib/lazily/zipping.rb
+- spec/lazily/concatenating_spec.rb
+- spec/lazily/filtering_spec.rb
+- spec/lazily/merging_spec.rb
+- spec/lazily/prefetching_spec.rb
+- spec/lazily/threading_spec.rb
+- spec/lazily/zipping_spec.rb
+- spec/lazily_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/mdub/lazily
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Lazy Enumerables for everybody!
+test_files:
+- spec/lazily/concatenating_spec.rb
+- spec/lazily/filtering_spec.rb
+- spec/lazily/merging_spec.rb
+- spec/lazily/prefetching_spec.rb
+- spec/lazily/threading_spec.rb
+- spec/lazily/zipping_spec.rb
+- spec/lazily_spec.rb
+- spec/spec_helper.rb