lab42_streams 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bccbce995004e65382114ca3073c25956bfd782d
-  data.tar.gz: f9e9ca8f5a32e2231bb159edb36054ac0f2d32b6
+  metadata.gz: 932f01cab1874c1a2f68148df75733d5ab33561b
+  data.tar.gz: 9ec01ace503ab4739c4070cfb9eaacf8ce399f4f
 SHA512:
-  metadata.gz: 6b5f37631aa89ad9a7bdec443adc34a3f2f8355247482eaa450cb7e3da159f0742b321060f78032510ef49dba44d3be5a71ca527640ac3952604168e993b6f9e
-  data.tar.gz: dd4b9c7b4a605103a184f0178218782c88dd040c05372b17a965fa21365aab34c859b4002aac818600487c39528cde2d769dc68fc23256751741f445b3f2be00
+  metadata.gz: f8e99130eac0f83c13737636ce55024f13d41e11698ee62370c493f9393b7a6ec78b3d9b047419ffc0b57320c5dfaa36c678b1ce69dcc85a1e815ba9c9c550a5
+  data.tar.gz: fd06621f258ec2d9c1f95b7ec1d8cac37c25d18f2b22d21a9e441dee6831efae36624b26432d8841697185f56ebc7a5712fb205ea91c9e292c5ed1f29257d1e6

data/README.md

@@ -1,3 +1,11 @@
 # lab42\_streams
 
-Bringing Streams to the much lazier Ruby 2.0
+Bringing Streams to Ruby
+
+An excellent introduction into `Streams` can be found [here](http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/6a-streams-part-1/)
+
+
+
+Please see the [QED](http://rubyworks.github.io/qed/) demos [here](https://github.com/RobertDober/lab42_streams/blob/master/demo)
+
+for details.

data/lib/lab42/stream/auto_import.rb

@@ -0,0 +1,11 @@
+require_relative '../stream'
+
+Stream = Lab42::Stream
+EmptyStream = Lab42::Stream::EmptyStream
+
+module Kernel
+  def iterate *args, &blk
+    Stream.iterate( *args, &blk )
+  end
+  alias_method :stream_by, :iterate
+end # module Kernel

data/lib/lab42/stream/class_methods.rb

@@ -0,0 +1,17 @@
+module Lab42
+  class Stream
+    module ClassMethods
+      def iterate arg, beh=nil, &blk
+        beh = blk.make_behavior beh
+        __iterate__ arg, beh
+      end
+
+      private
+      def __iterate__ arg, beh
+        cons_stream arg do
+          __iterate__ beh.( arg ), beh
+        end
+      end
+    end # module ClassMethods
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/empty.rb

@@ -1,7 +1,24 @@
+require 'forwarder'
+
+require_relative 'empty/enumerable'
+
 module Lab42
   class Stream
     class Empty < Stream
-      # TODO: Implement all self returning methods with Forwarder
+      extend Forwarder
+      # It is the nature of the EmptyStream instance to return itself for a plethora of methods
+      # this can be expressed as follows:
+      forward_all :combine, :__combine__,
+                  :drop, :drop_unitl, :drop_while, 
+                  :flatmap, :__flatmap__, :filter, :__filter__, 
+                  :inject_stream, :__inject__, 
+                  :lazy_take, :lazy_take_until, :lazy_take_while,
+                  :make_cyclic, :map, :__map__,
+                  :reduce,
+                  :segment, :__segment__, :__scan__, :split_by, :split_by_value,
+                  :zip, :__zip__,
+         to_object: :self, as: :itself
+
       def append other
         raise ArgumentError, "not a stream #{other}" unless self.class.superclass === other
         # ??? Is the to_stream message a good idea
@@ -11,23 +28,27 @@ module Lab42
 
       def empty?; true end
 
-      def filter *args, &blk; self end
 
       def head; raise StopIteration, "head called on empty stream" end
+      def tail; raise StopIteration, "tail called on empty stream" end
+
 
-      def make_cyclic; self end
-      def map *args, &blk; self end
-      # I believe that this definition is sound, although it is an obvious pitfall
-      # But falling into it once, means understanding streams better, well that is
-      # my opinion now, we will see what promises the future will bring...
-      def tail; self end
+      def inject *args; args.first end
+      alias_method :__inject__, :inject
 
+      # TODO: Move this into lab42/core as Object#itself
+      def itself *args, &blk; self end
+
+      def scan initial, *args, &blk
+        [initial]
+      end
+
+      def scan1 *args, &blk
+        []
+      end
 
-      def flatmap *args, &blk; self end
-      def __flatmap__ a_proc; self end
 
       private
-      def initialize; end
 
       def self.new
         @__instance__ ||= allocate
@@ -37,6 +58,7 @@ module Lab42
 
     module ::Kernel
       def empty_stream; Empty.new end
+      Lab42::Stream::EmptyStream = empty_stream
     end # module ::Kernel
   end # class Stream
 end # module Lab42

data/lib/lab42/stream/enumerable.rb

@@ -1,3 +1,276 @@
 module Enumerable
   def to_stream; finite_stream self end
 end
+
+module Lab42
+  class Stream
+    IllegalState = Class.new RuntimeError
+
+    module Enumerable
+
+      def drop_until *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        s = self
+        loop do
+          return s if bhv.(s.head)
+          s = s.tail
+        end
+        empty_stream
+      end
+
+      # N.B. Not implemented as drop_until( bhv.not )
+      # for performance reasons
+      def drop_while *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        s = self
+        loop do
+          return s unless bhv.(s.head)
+          s = s.tail
+        end
+        empty_stream
+      end
+
+      def each
+        t = self
+        loop do
+          yield t.head
+          t = t.tail
+        end
+      end
+
+      def each_without_loops
+        visited = {}
+        t = self
+        loop do
+          h = t.head
+          yield h
+          visited[ t.object_id ] = true
+          t = t.tail
+          return if visited[t.object_id]
+        end
+      end
+
+      def force_all cache={}
+        x = []
+        each_without_loops do | ele |
+          if self.class === ele
+            if ! cache[ele.object_id]
+              cache[ele.object_id] = true
+              x << ele.force_all( cache )
+            end
+          else
+            x << ele
+          end
+        end
+        x
+      end
+
+      def lazy_take n=1
+        raise ArgumentError, "need a non negative Fixnum" if !(Fixnum === n) || n < 0
+        __lazy_take__ n
+      end
+
+      def __lazy_take__ n
+        return empty_stream if n.zero?
+        cons_stream( head ){ tail.__lazy_take__ n.pred }
+      end
+
+      def lazy_take_until *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        __lazy_take_until__ bhv
+      end
+
+      def __lazy_take_until__ bhv
+        return empty_stream if bhv.(head)
+        cons_stream( head ){
+          tail.__lazy_take_until__ bhv
+        }
+      end
+
+      def lazy_take_while *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        __lazy_take_while__ bhv
+      end
+
+      def __lazy_take_while__ bhv
+        return empty_stream unless bhv.(head)
+        cons_stream( head ){
+          tail.__lazy_take_while__ bhv
+        }
+      end
+
+      def reduce red=nil, &reducer
+        red = reducer.make_behavior( red )
+        tail.__inject__ head, red
+      end
+
+      def inject agg, *red, &reducer
+        __inject__ agg, reducer.make_behavior( *red )
+      end
+
+      def filter *args, &blk
+        __filter__ blk.make_behavior( *args )
+      end
+
+      def reject *args, &blk
+        __filter__ blk.make_behavior( *args ).not
+      end
+
+      def flatmap *args, &blk
+        __flatmap__ blk.make_behavior( *args )
+      end
+
+      def __flatmap__ a_proc
+        # require 'pry'
+        # binding.pry
+        hh = a_proc.( head )
+        if hh.empty?
+          tail.__flatmap__ a_proc
+        else
+          cons_stream( hh.head ){ hh.tail + tail.__flatmap__( a_proc ) }
+        end
+      end
+
+      def flatmap_with_each *args, &blk
+        __flatmap_with_each__ blk.make_behavior( *args )
+      end
+
+      def __flatmap_with_each__ a_proc, rest_of_enum = []
+        # Process expanded values
+        return cons_stream( rest_of_enum.first ){ __flatmap_with_each__ a_proc, rest_of_enum.drop( 1 ) } unless
+          rest_of_enum.empty?
+
+        # Map a scalar value
+        hh = a_proc.( head )
+        return cons_stream( hh ){ tail.__flatmap_with_each__ a_proc } unless
+          hh.respond_to? :each
+
+        # Start a new expansion...
+        # ... consider an empty expansion
+        return tail.__flatmap__ a_proc if hh.empty?
+        # ... expand values
+        cons_stream( hh.first ){ tail.__flatmap_with_each__( a_proc, hh.drop( 1 ) ) }
+      end
+
+
+      def scan initial, *args, &blk
+        cons_stream initial do
+          __scan__ initial, blk.make_behavior( *args )
+        end.tap{ |r|
+          # require 'pry'
+          # binding.pry
+        }
+      end
+
+      def scan1 *args, &blk
+        tail.scan( head, *args, &blk )
+      end
+
+      def __scan__ initial, beh
+        h = beh.(initial, head)
+        cons_stream( h ){ tail.__scan__ h, beh }
+      end
+
+      def take_until *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        x = []
+        each do | ele |
+          return x if bhv.( ele )
+          x << ele
+        end
+        x
+      end
+      def take_while *bhv, &blk
+        bhv = blk.make_behavior( *bhv )
+        x = []
+        each do | ele |
+          return x unless bhv.( ele )
+          x << ele
+        end
+        x
+      end
+
+      def to_a
+        take_while :true
+      end
+      alias_method :entries, :to_a
+
+      def make_cyclic
+        cons_stream( head ){
+          tail.append( make_cyclic )
+        }
+      end
+
+      def map *args, &blk
+        # TODO: Get this check and a factory to create a proc for this into core/fn
+        raise ArgumentError, "use either a block or arguments" if args.empty? && !blk || !args.empty? && blk
+        __map__ blk.make_behavior( *args )
+      end
+
+      def __map__ prc
+        cons_stream( prc.(head) ){ tail.__map__ prc }
+      end
+
+
+      def reduce_while cond, red=nil, &reducer
+        red ||= reducer
+        tail.__inject_while__ head, cond, red
+      end
+
+      def take n=1
+        raise ArgumentError, "need a non negative Fixnum" if !(Fixnum === n) || n < 0
+        x = []
+        each do | ele |
+          return x if n.zero?
+          n -= 1
+          x << ele
+        end
+        x
+      end
+
+      def zip *other_streamables
+        streams = other_streamables.map{ |s|
+          self.class === s ? s : s.to_stream
+        }
+        __zip__ streams
+      end
+
+      def zip_as_ary *other_streamables
+        zip( *other_streamables )
+          .map( &:entries )
+      end
+
+      def __zip__ streams
+        cons_stream( [head] + streams.map(:head) ){
+          tail.__zip__ streams.map(:tail)
+        }
+      end
+
+      def __filter__ a_proc
+        if a_proc.( head )
+          cons_stream( head ){ tail.__filter__ a_proc } 
+        else
+          tail.__filter__ a_proc
+        end
+      end
+
+      def __inject__ agg, a_proc
+        new_agg = a_proc.(agg, head)
+        tail.__inject__ new_agg, a_proc
+      end
+
+      def __inject_while__ ival, cond, red
+        raise ConstraintError unless cond.(ival)
+        s = self
+        loop do
+          new_val = red.(ival, s.head)
+          return ival unless cond.(new_val)
+          ival = new_val
+          s = s.tail
+          return ival if s.empty?
+        end
+      end
+    end # module Enumerable
+    include Enumerable
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/higher_order.rb

@@ -0,0 +1,33 @@
+module Lab42
+  class Stream
+    module HigherOrder
+      def combine *streams_and_op, &operation
+        op = streams_and_op.pop unless self.class === streams_and_op.last
+        op = operation.make_behavior op
+        # TODO: Decide what to do if op.arity and streams_and_op.size.succ do not match????
+        __combine__( op, *streams_and_op )
+      end
+
+      def __combine__ op, *streams
+        # TODO: Decide if we can continue if one of the streams is empty iff op.arity < 0
+        #       for now no!
+        return empty_stream if streams.any?( &:empty? )
+        values = streams.map( &:head )
+        new_head = op.(head, *values)
+        cons_stream( new_head ){
+          tail.__combine__( op, *streams.map( &:tail ) )
+        }
+      end
+
+      def split_into n
+        indexed = with_index
+        n.times.map do | i |
+          indexed
+            .filter{ |e, idx| idx % n == i }
+            .map( :first )
+        end
+      end
+    end # module HigherOrder
+    include HigherOrder
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/kernel/extensions.rb

@@ -0,0 +1,7 @@
+
+module Kernel
+  def true; true end
+  def false; false end
+  def nil; nil end
+  def self; self end
+end # module Kernel

data/lib/lab42/stream/kernel.rb

@@ -6,12 +6,8 @@ module Kernel
     end
   end
 
-  def combine_streams s1, s2, op=nil, &operation
-    return empty_stream if s1.empty? || s2.empty?
-    op ||= operation
-    cons_stream op.(s1.head, s2.head) do
-      combine_streams( s1.tail, s2.tail, op)
-    end
+  def combine_streams stream, *streams_and_ops, &operation
+    stream.combine( *streams_and_ops, &operation )
   end
 
   def cons_stream head, &tail
@@ -24,7 +20,7 @@ module Kernel
 
   def cyclic_stream *args
     args = args.first if
-      args.size == 1 && Enumerable === args.first
+    args.size == 1 && Enumerable === args.first
 
     finite_stream( args ).make_cyclic
   end
@@ -50,16 +46,17 @@ module Kernel
     end
   end
 
-  def stream_by *args, &blk
+  def iterate *args, &blk
     if blk
-      cons_stream(*args){ stream_by( blk.(*args), &blk ) }
+      cons_stream(*args){ iterate( blk.(*args), &blk ) }
     else
       rest = args.drop 1
       if Method === rest.first 
-        cons_stream( args.first ){ stream_by( rest.first.(*([args.first] + rest.drop(1))), *rest ) }
+        cons_stream( args.first ){ iterate( rest.first.(*([args.first] + rest.drop(1))), *rest ) }
       else
-        cons_stream( args.first ){ stream_by( sendmsg(*rest).(args.first), *rest ) }
-    end
+        cons_stream( args.first ){ iterate( sendmsg(*rest).(args.first), *rest ) }
+      end
     end
   end
+  alias_method :stream_by, :iterate
 end

data/lib/lab42/stream/proc.rb

@@ -11,4 +11,29 @@ class Proc
       end
     }
   end
+
+  # TODO: Use this from core/fn as soon as available
+  def make_behavior *args
+    raise ArgumentError, "cannot specify behavior with block and args: #{args.inspect}" unless args.compact.empty?
+    self
+  end
+
+  def not
+    -> (*args, &blk) {
+      ! self.(*args, &blk)
+    }
+  end
+end
+
+class NilClass
+  # TODO: Use this from core/fn as soon as available
+  def make_behavior *args
+    return args.first if args.size == 1 && args.first.respond_to?( :call )
+
+    return ->(*a){
+      args.first(*(args.drop(1)+a))
+    } if args.first.respond_to?( :call )
+
+    sendmsg( *args )
+  end
 end

data/lib/lab42/stream/utility.rb

@@ -0,0 +1,27 @@
+module Lab42
+  class Stream
+    module Utility
+
+      def segment *args, &blk
+        __segment__ blk.make_behavior( *args )
+      end
+
+      def __segment__ beh
+        if beh.( head )
+          cons_stream( cons_stream( head ){  tail.lazy_take_until beh } ){
+            tail.drop_until( beh ).__segment__ beh
+          }
+        else
+          cons_stream( lazy_take_until beh ){
+            tail.drop_until( beh ).__segment__ beh
+          }
+        end
+      end
+
+      def with_index start=0
+        zip_as_ary iterate( start, :succ )
+      end
+    end # module Utility
+    include Utility
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   class Stream
-    Version = "0.1.0"
+    Version = "0.1.1"
   end # class Stream
 end # module Lab42

data/lib/lab42/stream.rb

@@ -1,16 +1,25 @@
-require 'lab42/stream/empty'
-require 'lab42/stream/delayed'
-require 'lab42/stream/kernel'
-require 'lab42/stream/array'
-require 'lab42/stream/enumerable'
-require 'lab42/stream/hash'
-require 'lab42/stream/proc'
+
+require_relative './stream/empty'
+require_relative './stream/delayed'
+require_relative './stream/kernel'
+require_relative './stream/array'
+require_relative './stream/enumerable'
+require_relative './stream/higher_order'
+require_relative './stream/hash'
+require_relative './stream/proc'
+require_relative './stream/class_methods'
+require_relative './stream/utility'
+
+# TODO: This should rather be implemented in lab_42/core/fn
+require_relative './stream/kernel/extensions'
 
 module Lab42
   class Stream
+    extend ClassMethods
+
     ConstraintError = Class.new RuntimeError
-    include Enumerable
     attr_reader :head, :promise
+    alias_method :first, :head
 
     def append other
       raise ArgumentError, "not a stream #{other}" unless self.class === other
@@ -18,6 +27,13 @@ module Lab42
     end
     alias_method :+, :append
 
+
+    def combine_streams *args, &operation
+      op = args.shift unless self.class === args.first
+      raise ArgumentError, "Missing stream parameters" if args.empty?
+      __combine_streams__ operation.make_behavior( op ), args
+    end
+
     def drop n = 1
       raise ArgumentError, "not a non negative number" if n < 0
       t = self
@@ -28,102 +44,33 @@ module Lab42
       end
     end
 
-    def each
-      t = self
-      loop do
-        yield t.head
-        t = t.tail
-      end
-    end
-
     def empty?; false end
 
-    def filter *args, &blk
-      # TODO: Get this check and a factory to create a proc for this into core
-      raise ArgumentError, "use either a block or arguments" if args.empty? && !blk || !args.empty? && blk
-      filter_by_proc mk_proc( blk || args )
-    end
-
-    def filter_by_proc prc
-      if prc.(head)
-        cons_stream(head){ tail.filter_by_proc prc }
-      else
-        # TODO: Replace this with Delayed Stream (1 off)
-        tail.filter_by_proc prc 
-      end
-    end
-
-    def flatmap *args, &blk
-      if args.empty?
-        __flatmap__ blk
-      elsif args.size == 1 && args.first.respond_to?( :call )
-        __flatmap__ args.first
-      else
-        __flatmap__ sendmsg(*args)
-      end
-    end
-
-    def __inject_while__ ival, cond, red
-      raise ConstraintError unless cond.(ival)
-      s = self
-      loop do
-        new_val = red.(ival, s.head)
-        return ival unless cond.(new_val)
-        ival = new_val
-        s = s.tail
-        return ival if s.empty?
-      end
-    end
-
-    def make_cyclic
-      cons_stream( head ){
-        tail.append( make_cyclic )
-      }
-    end
-
-    def map *args, &blk
-      # TODO: Get this check and a factory to create a proc for this into core/fn
-      raise ArgumentError, "use either a block or arguments" if args.empty? && !blk || !args.empty? && blk
-      transform_by_proc mk_proc( blk || args )
-    end
-
-    def reduce_while cond, red=nil, &reducer
-      red ||= reducer
-      tail.__inject_while__ head, cond, red
-    end
-
     def tail
       promise.()
     end
 
     def to_stream; self end
 
-    def transform_by_proc prc
-      cons_stream( prc.(head) ){ tail.transform_by_proc prc }
-    end
+    def __combine_streams__ op, args
+      return empty_stream if args.any?(&sendmsg(:empty?))
 
-    def __flatmap__ a_proc
-      hh = a_proc.( head )
-      if hh.empty?
-        tail.__flatmap__ a_proc
-      else
-        cons_stream( hh.head ){ hh.tail + tail.__flatmap__( a_proc ) }
-      end
+      new_head = op.(head, *args.map(&sendmsg(:head)))
+      cons_stream( new_head ){ tail.__combine_streams__(op, args.map(&sendmsg(:tail))) }
     end
 
     private
     def initialize h, t=nil, &tail
-        @head    = h
-        @promise = ( t || tail ).memoized
+      @head    = h
+      @promise = ( t || tail ).memoized
     end
 
-    # TODO: Use this from core/fn as soon as available
-    def mk_proc args
-      return args if Proc === args
-      raise ArgumentError, "neither a Proc nor an array of args for Kernel#sendmsg" unless Array === args
-      return args.first if Proc === args.first || Method === args.first
-      sendmsg(*args)
-    end
+    # def mk_proc args
+    #   return args if Proc === args
+    #   raise ArgumentError, "neither a Proc nor an array of args for Kernel#sendmsg" unless Array === args
+    #   return args.first if Proc === args.first || Method === args.first
+    #   sendmsg(*args)
+    # end
 
   end # class Stream
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_streams
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-19 00:00:00.000000000 Z
+date: 2014-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: forwarder2
@@ -52,37 +52,99 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: '3.1'
 description: Lazy Evaluation, Streams, Enumerator#Lazy
 email: robert.dober@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/lab42/stream.rb
 - lib/lab42/stream/array.rb
-- lib/lab42/stream/version.rb
+- lib/lab42/stream/auto_import.rb
+- lib/lab42/stream/class_methods.rb
 - lib/lab42/stream/delayed.rb
-- lib/lab42/stream/hash.rb
 - lib/lab42/stream/empty.rb
-- lib/lab42/stream/proc.rb
-- lib/lab42/stream/kernel.rb
+- lib/lab42/stream/empty/enumerable.rb
 - lib/lab42/stream/enumerable.rb
-- LICENSE
-- README.md
+- lib/lab42/stream/hash.rb
+- lib/lab42/stream/higher_order.rb
+- lib/lab42/stream/kernel.rb
+- lib/lab42/stream/kernel/extensions.rb
+- lib/lab42/stream/proc.rb
+- lib/lab42/stream/utility.rb
+- lib/lab42/stream/version.rb
 homepage: https://github.com/RobertDober/lab42_streams
 licenses:
 - MIT
@@ -103,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Streams for Ruby 2.0