laziest 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29f110db9af135c7252ca69456131c27bc35e299
+  data.tar.gz: 17b87349963fd750fce3f8c34b80db66d1eeac65
+SHA512:
+  metadata.gz: b92d11825b05e450eaf6ffe472c03f2400d7e8d481b8e0eed9aa394ca9eeb743ddda5c4397a648c29d6031ad5be194a1e299b16e50cbe173a0f147776ab95ab3
+  data.tar.gz: 13be6da5325bcef78f8da3580bd926903f9d4f378d47445abf6c2d876c388de4f039c9b2b81483474be22d7ba66eae8bc9d53c847acc6d4b6f6b4e78b3404c82

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lazy_count.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# Laziest
+
+Extends Enumerable#lazy (aka Enumerator::Lazy) with additional
+opportunities for lazy and especially *partial* evaluation.
+For example:
+
+    (1..Float::INFINITY).lazy.count > 10
+
+evaluates almost instantaneously.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'laziest'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install laziest
+
+## Usage
+
+Simply add this before working with any lazy enumerators:
+
+    require 'laziest'
+
+This will extend Enumerator::Lazy (and the Enumerable#lazy method)
+to have lazier versions of the following methods:
+
+ * chunk
+ * count
+ * entries
+ * group_by
+ * max
+ * min
+ * minmax
+ * partition
+ * slice_before
+ * to_a
+
+The somewhat ambitious goal is to defer as much as possible, while maintaining
+full compatibility with the existing API. Some more examples:
+
+    (1..Float::INFINITY).lazy.group_by{|x| x.to_s.length}[3].first(2)  # => [100, 101]
+    Prime.lazy.max > 1000  # => true
+    Prime.lazy.partition{|x| x%10 == 1}.all? {|x| x.count > 100} # => true
+
+As with any self-respecting Ruby laziness, proxy classes
+(specifically, Promises from the promise ("promising future") gem)
+are abused, to ensure that traditional, non-lazy usage is correct.
+
+    (1..5).lazy.group_by(&:even?)  # => {false=>[1, 3, 5], true=>[2, 4]}
+
+Not everything is as lazy as possible yet, but anything not lazy should still
+work, eventually, on anything finite.
+
+Warning: Be careful in IRB! Remember that IRB calls #inspect on the result
+of any expression you type. This will almost always force a complete
+evaluation. For example, if you type this:
+
+    evens, odds = (1..Float::INFINITY).lazy.partition(&:even?)
+
+This will attempt to #inspect the resulting arrays, and you have created an
+infinite loop. You can avoid this by adding a useless expression to the end:
+
+    evens, odds = (1..Float::INFINITY).lazy.partition(&:even?); nil
+    evens.first(10)
+
+Of course, abusing one-liners is the easiest way to avoid this:
+
+    (1..Float::INFINITY).lazy.group_by(&:even?)[true].first(10)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/laziest.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'laziest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'laziest'
+  spec.version       = Laziest::VERSION
+  spec.authors       = ['David Masover']
+  spec.email         = ['masover@iastate.edu']
+  spec.description   = 'The laziest possible enumerables and enumerators'
+  spec.summary       = <<-END
+                        When there's just no O(1) way to compute something, this gem provides
+                        both promises (lazy evaluation) and partial evaluation, along with
+                        implicit, softref-based memoization. For example, (foo.lazy.count > 5) will
+                        invoke the iterator at most six times.
+                      END
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'promise'
+  spec.add_dependency 'soft_reference'
+end

data/lib/laziest.rb

@@ -0,0 +1,14 @@
+autoload :Promise, 'promise'
+
+module Laziest
+  autoload :VERSION, 'laziest/version'
+  autoload :Counter, 'laziest/counter'
+  autoload :ArrayPromise, 'laziest/array'
+  autoload :Group, 'laziest/group'
+  autoload :MutexUtil, 'laziest/mutex_util'
+  autoload :MinMax, 'laziest/minmax'
+
+  require 'laziest/extensions'
+
+  Enumerator::Lazy.send :include, Extensions::LazyEnumerator
+end

data/lib/laziest/array.rb

@@ -0,0 +1,109 @@
+module Laziest
+  # This class is a lazily-evaluated array based on an enumerator.
+  # A contract: The enumerator is guaranteed to never be rewound.
+  class ArrayPromise < Promise
+    # Accepts 'array' to allow a partially-evaluated enumerator/array to initialize.
+    def initialize enumerator, array=[], nil_on_empty = false
+      @array = array
+      @enumerator = enumerator
+      @nil_on_empty = nil_on_empty
+      super() do
+        ::Kernel.loop do
+          @array << @enumerator.next
+        end
+        @enumerator = nil
+        # Needed for use in hashes, like group_by
+        (nil_on_empty && @array.empty?) ? nil : @array
+      end
+    end
+
+    def each(&block)
+      return super if __forced__?
+      return ::Enumerator.new{|y| each {|x| y << x}}.lazy unless ::Kernel.block_given?
+      index = 0
+      ::Kernel.loop do
+        __force_to__ index
+        break unless @array.length > index
+        yield @array[index]
+        index += 1
+      end
+    end
+
+    # Array-related laziness
+    def [] index, length=nil
+      return super if __forced__?
+      if length.nil?
+        if index.kind_of? ::Range
+          enum = ::Enumerator.new do |y|
+            index.each do |i|
+              y << self[i]
+            end
+          end
+          ArrayPromise.new enum
+        else
+          __force_to__ index
+          @array[index]
+        end
+      else
+        enum = ::Enumerator.new do |y|
+          i = index
+          length.times do
+            y << self[i]
+            i += 1
+          end
+        end
+        ArrayPromise.new enum
+      end
+    end
+
+    def __force_to__ index
+      begin
+        @mutex.synchronize do
+          while @array.length <= index
+            @array << @enumerator.next
+          end
+        end
+      rescue ::StopIteration
+      end
+    end
+
+    def __forced__?
+      if @nil_on_empty && @array.empty?
+        # Check if we're really empty.
+        __force_to__ 1
+        # Either we'll be empty (and finalized as nil), so we'll revert to
+        # calling super which forwards to nil and so on,
+        # or we'll be nonempty (and normal logic proceeds)
+      end
+      !(@result.equal?(NOT_SET) && @error.equal?(NOT_SET))
+    end
+
+    # Force all enumerable methods to be defined in terms of laziness.
+    %w(
+      all? any? chunk collect collect_concat count cycle detect drop
+      drop_while each_cons each_entry each_slice each_with_index
+      each_with_object entries find find_all find_index first flat_map grep
+      group_by include? inject lazy map max max_by member? min min_by minmax
+      minmax_by none? one? partition reduce reject reverse_each select
+      slice_before sort sort_by take take_while zip
+    ).map(&:to_sym).each do |name|
+      define_method name do |*args, &block|
+        return super if __forced__?
+        each.lazy.public_send name, *args, &block
+      end
+    end
+
+    %w(length size).map(&:to_sym).each do |name|
+      define_method name do
+        return super if __forced__?
+        each.lazy.count
+      end
+    end
+
+    # Except this one, make it a no-op. (Also should prevent infinite recursion.)
+    def to_a
+      return super if __forced__?
+      self
+    end
+  end
+end

data/lib/laziest/counter.rb

@@ -0,0 +1,44 @@
+module Laziest
+  class Counter < Promise
+    def initialize enumerator
+      @count = 0
+      @enumerator = enumerator
+      super() do
+        ::Kernel.loop do
+          @count += enumerator.next
+        end
+        @count
+      end
+    end
+
+    def __force_to__ value
+      if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+        @mutex.synchronize do
+          if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+            begin
+              while @count < value
+                @count += @enumerator.next
+              end
+            rescue ::StopIteration
+            end
+          end
+        end
+      end
+      ::Kernel.raise(@error) unless @error.equal?(NOT_SET)
+    end
+
+    %w(== eql? equal? <= > <=>).map(&:to_sym).each do |op|
+      define_method op do |value|
+        __force_to__ value+1
+        @count.public_send op, value
+      end
+    end
+
+    %w(< >=).map(&:to_sym).each do |op|
+      define_method op do |value|
+        __force_to__ value
+        @count.public_send op, value
+      end
+    end
+  end
+end

data/lib/laziest/extensions.rb

@@ -0,0 +1,157 @@
+module Laziest
+  module Extensions
+    module LazyEnumerator
+      def count
+        enum = Enumerator.new do |y|
+          each do |value|
+            if (!block_given?) || (yield value)
+              y << 1
+            end
+          end
+        end
+        Counter.new enum
+      end
+
+      def entries
+        ArrayPromise.new enum_for :each
+      end
+      alias_method :to_a, :entries
+
+      def group_by &block
+        return enum_for :group_by unless block_given?
+        Group.new enum_for(:each), &block
+      end
+
+      %w(min max).map(&:to_sym).each do |name|
+        klass = MinMax.const_get name.capitalize
+        define_method name do
+          if block_given?
+            # can't handle unnatural ordering
+            super
+          else
+            klass.new enum_for(&:each)
+          end
+        end
+      end
+
+      # Perfectly functional.
+      # TODO: Optimize by sharing an enumerator. As it stands,
+      # in the worst case, we enumerate everything twice, defeating the
+      # entire point of having a separate 'minmax' method.
+      def minmax
+        if block_given?
+          super
+        else
+          [min, max]
+        end
+      end
+
+      # Another functional-but-stub.
+      # TODO: Optimize away the hash, maybe?
+      def partition
+        return enum_for :partition unless block_given?
+        # Negate, forcing these to actual true/false values
+        groups = group_by{|*args| ! yield *args}
+        # No need to double-negate, the following is just inverted.
+        [groups[false], groups[true]]
+      end
+
+      # Implemented mainly in terms of slice_before.
+      # It's logically very similar, but has similar amounts of extra sugar.
+      def chunk state=nil
+        # Handle state, so we can forget about it.
+        unless state.nil?
+          return chunk {|value| yield value, state}
+        end
+
+        # Even though we could probably do everything with the lazy enum
+        # chaining -- and we do _almost_ everything that way -- we want
+        # to ensure that first_iteration is reset with each run. A brand
+        # new enumerator ensures #rewind and friends work correctly.
+
+        enum = Enumerator.new do |yield_array|
+          prev = nil
+          first_iteration = true
+
+          map {|value|
+            [value, (yield value)]
+          }.slice_before {|value, result|
+            if first_iteration
+              first_iteration = false
+              # return value doesn't matter
+            else
+              # start a new group when this one differs from prev, or is
+              # specifically requested as 'alone'.
+              result != prev || result == :_alone
+            end
+            prev = result
+          }.each do |value, result|
+            yield result unless value.nil? || value == :_separator
+          end
+        end
+
+        enum.lazy
+      end
+
+      # Chunk without laziness is actually good enough already for most uses.
+      # Generally, you're chunking a huge stream into small, manageable chunks.
+      # The standard enumerable will stream well enough there -- each chunk
+      # must be evaluated completely, but the entire stream is evaluated
+      # only as needed. The use case here is if any particular chunk is _very_
+      # large, and maybe infinite, but we actually don't need the entire chunk.
+      def slice_before state=nil
+        unless block_given?
+          # state is a pattern
+          return slice_before {|value| state === value}
+        end
+
+        unless state.nil?
+          # state is state, handle it here
+          return slice_before {|value| yield value, state}
+        end
+
+        enum = Enumerator.new do |yield_array|
+          ec = enum_for(:each)
+          array = nil
+          lazy_array = nil
+
+          begin
+            array = [ec.next]
+          rescue StopIteration
+            array = nil
+          end
+
+          loop do
+            break if array.nil?
+
+            array_promise_enum = Enumerator.new do |yield_element|
+              loop do
+                value = nil
+                begin
+                  value = ec.next
+                  if yield value
+                    array = [value]
+                    break
+                  end
+                rescue StopIteration
+                  array = nil
+                  lazy_array = nil
+                  break
+                end
+                yield_element << value
+              end
+            end
+
+            lazy_array = ArrayPromise.new array_promise_enum, array
+
+            yield_array << lazy_array
+
+            lazy_array.__force__
+          end
+        end
+
+        enum.lazy
+      end
+    end
+  end
+end

data/lib/laziest/group.rb

@@ -0,0 +1,93 @@
+require 'set'
+
+module Laziest
+  class Group < Promise
+    def initialize enumerator, &block
+      @hash = {}
+      @lazy_arrays = {}
+      @buffers = ::Hash.new{|h,k|h[k]=[]}
+      @enumerator = enumerator
+      @group_block = block
+      @enum_mutex = ::Mutex.new
+      super() do
+        # Any existing lazy arrays can simply be forced, since
+        # they're on a different mutex now:
+        @lazy_arrays.each do |arr|
+          arr.__force__
+        end
+        # And just in case there aren't any lazy arrays:
+        ::Kernel.loop do
+          val = enumerator.next
+          key = yield val
+          (@hash[key] ||= []) << val
+        end
+        # Strip out anything that turned out to be empty.
+        @hash.delete_if {|k,v| v.empty?}
+        # clear potentially-expensive GC-able stuff.
+        @lazy_arrays = nil
+        @buffers = nil
+        @group_block = nil
+        # safe because we already forced all existing lazy arrays, and we're
+        # holding the global mutex which prevents any new ones from being built
+        @enum_mutex = nil
+        @hash
+      end
+    end
+
+    def [] key
+      return super unless @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+      @mutex.synchronize do
+        @enum_mutex.synchronize do
+          # for good measure -- for once, we really _don't_ want to do _any_ of
+          # this once the hash's promise resolves.
+          return super unless @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+          if @lazy_arrays.has_key?(key)
+            @lazy_arrays[key]
+          else
+            # Note: This enumerator is only ever passed to ArrayPromise.
+            # It is not actually a valid enumerator, as it entirely lacks
+            # support for rewinding.
+            enum = ::Enumerator.new do |yielder|
+              @enum_mutex.synchronize do
+                buffer = @buffers[key]
+                ::Kernel.loop do
+                  if buffer.empty?
+                    # At this point, @enumerator.next may throw StopIteration.
+                    # Which will break the loop, which will end our iteration,
+                    # which is fine. (A call to our enumerator.each would also
+                    # result in a StopIteration.)
+                    v = @enumerator.next
+                    k = @group_block.call v
+                    if k == key
+                      # We shouldn't hold the lock when we yield.
+                      ::Laziest::MutexUtil.unsynchronize @enum_mutex do
+                        yielder << v
+                      end
+                    elsif @hash.has_key? k
+                      # Buffer data for the lazy array to read later
+                      if @lazy_arrays.has_key? k
+                        @buffers[k] << v
+                      else
+                        @hash[k] << v
+                      end
+                    else
+                      # We know a lazy array doesn't exist unless the hash exists
+                      @hash[k] = [v]
+                    end
+                  else
+                    v = buffer.shift
+                    ::Laziest::MutexUtil.unsynchronize @enum_mutex do
+                      yielder << v
+                    end
+                  end
+                end
+              end
+            end
+            @hash[key] = [] unless @hash.has_key? key
+            @lazy_arrays[key] = ArrayPromise.new enum, @hash[key], true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laziest/minmax.rb

@@ -0,0 +1,105 @@
+module Laziest
+  # Base class. Conceptually a max, but we can override it
+  # with min/max classes... but only for naturally-ordered elements!
+  # If we allow arbitrary comparators, we have no way of optimizing
+  # attempted comparisons against the max value itself.
+  class MinMax < Promise
+    def initialize enumerator, gtop
+      @enumerator = enumerator
+      # "Greater-Than" operation
+      @gtop = gtop
+      begin
+        @max = @enumerator.next
+      rescue ::StopIteration
+        @is_nil = true
+      end
+
+      super() do
+        ::Kernel.loop do
+          value = @enumerator.next
+          if value.public_send @gtop, @max
+            @max = value
+          end
+        end
+        @max
+      end
+    end
+
+    def __force_until__
+      if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+        @mutex.synchronize do
+          if @result.equal?(NOT_SET) && @error.equal?(NOT_SET) 
+            unless yield
+              ::Kernel.loop do
+                # StopIteration can stop the loop here
+                value = @enumerator.next
+                if value.public_send @gtop, @max
+                  @max = value
+                  break if yield
+                end
+              end
+            end
+          end
+        end
+      end
+      ::Kernel.raise(@error) unless @error.equal?(NOT_SET)
+    end
+
+    %w(== eql? equal?).map(&:to_sym).each do |name|
+      define_method name do |value|
+        # If it's _equal_ to our value, it can't be _greater_ than our value.
+        # So this can lazily return _false_ if the max is _greater_ than
+        # our value. Otherwise, we have to evaluate the whole sequence.
+        __force_until__ { @max.public_send @gtop, value }
+        @max.public_send name, value
+      end
+    end
+
+    # The individual Min and Max classes provide additional optimizations for
+    # naturally-ordered elements.
+    class Max < MinMax
+      def initialize enumerator
+        super(enumerator, :>)
+      end
+
+      %w(< >=).map(&:to_sym).each do |name|
+        define_method name do |value|
+          # If we find a max at least as large as value, then < is false,
+          # and >= is true. (Otherwise, we must enumerate everything.)
+          __force_until__ { @max >= value }
+          @max.public_send name, value
+        end
+      end
+
+      %w(<= <=> >).map(&:to_sym).each do |name|
+        define_method name do |value|
+          # If we find a max _larger_ than a value, then <= is false,
+          # > is true, and <=> can be evaluated directly.
+          __force_until__ { @max > value }
+          @max.public_send name, value
+        end
+      end
+    end
+
+    # Inverse of above.
+    class Min < MinMax
+      def initialize enumerator
+        super(enumerator, :<)
+      end
+
+      %w(> <=).map(&:to_sym).each do |name|
+        define_method name do |value|
+          __force_until__ { @max <= value }
+          @max.public_send name, value
+        end
+      end
+
+      %w(>= <=> <).map(&:to_sym).each do |name|
+        define_method name do |value|
+          __force_until__ { @max < value }
+          @max.public_send name, value
+        end
+      end
+    end
+  end
+end

data/lib/laziest/mutex_util.rb

@@ -0,0 +1,13 @@
+module Laziest
+  module MutexUtil
+    # opposite of Mutex#synchronize.
+    def self.unsynchronize mutex
+      mutex.unlock
+      begin
+        yield
+      ensure
+        mutex.lock
+      end
+    end
+  end
+end

data/lib/laziest/version.rb

@@ -0,0 +1,3 @@
+module Laziest
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: laziest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Masover
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: promise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: soft_reference
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The laziest possible enumerables and enumerators
+email:
+- masover@iastate.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- laziest.gemspec
+- lib/laziest.rb
+- lib/laziest/array.rb
+- lib/laziest/counter.rb
+- lib/laziest/extensions.rb
+- lib/laziest/group.rb
+- lib/laziest/minmax.rb
+- lib/laziest/mutex_util.rb
+- lib/laziest/version.rb
+homepage: ''
+licenses:
+- MIT
+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.3
+signing_key: 
+specification_version: 4
+summary: When there's just no O(1) way to compute something, this gem provides both
+  promises (lazy evaluation) and partial evaluation, along with implicit, softref-based
+  memoization. For example, (foo.lazy.count > 5) will invoke the iterator at most
+  six times.
+test_files: []