lab42_streams 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d09f7787dde8a103ab385e107f3edfb91cab85cb
-  data.tar.gz: 2fcdf2c0ea44003310d0e05d7df2716a4d1d5ff5
+SHA256:
+  metadata.gz: e8f831b639a52dd52db85790b4fa4f7a558d4141b8deaf0ba7cd406f59970578
+  data.tar.gz: 58bfe3bfe2d31b694061a704ec6fbb30bbf901fe0e4134f91026edaceac22913
 SHA512:
-  metadata.gz: 3d87e2f2e764b300379b879ce4a2f7716abfab0d6b56d5894e25e13d7d663d8a571c8e9623a092c22de34315624b6398becac64e3ac29cfa9445453f46d6f999
-  data.tar.gz: df8e4190c2c63dfb1e238e6c60483af3c5b90385248a0117411f40cd77aed7c6f0a274ec102f89b5943caa5ee641e9dea7ef151fb7c4ae8ed8c7af24830baf0b
+  metadata.gz: 17bb41d95481d19badab24f90ec1935f4450c19b65435000ba93721b602934506c665a239f524241ab4cff7ef127a84b7cdf4312cba74bb7b4b0eab2ac4c3ba2
+  data.tar.gz: 726f43fcf1c28fc99de3b1792fda975bdb4b9d7ed349aa380b95192af53b048def7717193065d6917a7e235cbddf36eb4ad63e2aa617eceeaa74bb15bd873f00

data/README.md

@@ -1,16 +1,136 @@
+[![Build Status](https://travis-ci.org/RobertDober/lab42_streams.svg?branch=master)](https://travis-ci.org/RobertDober/lab42_streams)
+[![Code Climate](https://codeclimate.com/github/RobertDober/lab42_streams/badges/gpa.svg)](https://codeclimate.com/github/RobertDober/lab42_streams)
+[![Issue Count](https://codeclimate.com/github/RobertDober/lab42_streams/badges/issue_count.svg)](https://codeclimate.com/github/RobertDober/lab42_streams)
+[![Test Coverage](https://codeclimate.com/github/RobertDober/lab42_streams/badges/coverage.svg)](https://codeclimate.com/github/RobertDober/lab42_streams)
+[![Gem Version](https://badge.fury.io/rb/lab42_streams.svg)](http://badge.fury.io/rb/lab42_streams)
+
 # lab42\_streams
 
-Bringing Streams to Ruby
+## 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/)
 
-[![Build Status](https://travis-ci.org/RobertDober/lab42_streams.svg?branch=master)](https://travis-ci.org/RobertDober/lab42_streams)
-[![Code Climate](https://codeclimate.com/github/RobertDober/lab42_streams/badges/gpa.svg)](https://codeclimate.com/github/RobertDober/lab42_streams)
-[![Test Coverage](https://codeclimate.com/github/RobertDober/lab42_streams/badges/coverage.svg)](https://codeclimate.com/github/RobertDober/lab42_streams)
-[![Gem Version](https://badge.fury.io/rb/lab42_streams.svg)](http://badge.fury.io/rb/lab42_streams)
+## Basic Stream Tutorial
+
+Streams are lazy, immutable lists, or for the purists, lazy cons cells (well the tail/cdr is lazy, the head/car is not).
+
+A first example
+
+### Infinite Streams
+
+Given the following definition
+
+```ruby :include
+    def fibs a=0, b=1
+      cons_stream a do
+        fibs b, a+b
+      end
+    end
+```
+
+The following spec will be satisfied
+
+```ruby :example
+    expect(fibs.drop(1000).head).
+      to eq(43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875)
+```
+
+There are several things to remember here:
+
+* The tail of a stream is *always* provided as block or lambda, the only way in ruby to
+implement a normal order parameter.
+
+* The result of the tail (that is when the delay or promise the tail defines is forced or realised)
+must be a `Stream`. This has to be automated into your reasoning about `Streams` lest you will
+have difficulties to come up with stream based solutions.
+
+* When the promise of the tail is forced the stack frame of the `cons_stream` call is not active
+any more, there will be no stack overflow.
+
+
+### Transformation Chain
+
+One major advantage of streams (and lazy evaluation in general) is that transformations can be composed without any performance penality.
+
+While for example the following code would be terribly inefficent
+
+```ruby
+    elements = { 2 => "two", 4 => "four" }
+    list = 1..2 # but imagine a very large value of 2
+    list.map{ |x| x * 2 }.map{ |x| elements[x] }.map(&:reverse)
+```
+
+the following stream based code is not.
+
+```ruby
+
+     translation = { [true,true] => "fizzbuzz", [true, false] => "fizz", [false, true] => "buzz" }
+     integers    = Stream.iterate 0, :succ
+     fizzbuzz    = integers
+        .reject{ |x| (x%100).zero? }
+        .map{ |i| [(i%3).zero?,(i%5).zero?,i] }
+        .map{ |f,b,i| translation.fetch([f,b],i) }
+```
+
+The reason for this is that, up to now, no single computation has been done, but _promises_ for doing so
+have been registered. Only when we eventually force values these computations will be executed and then
+it will make little difference if we execute one complex computation or five simple ones.
+
+And as we operate on **infinite** streams it becomes obvious that the implementation must delay up to the end.
+
+### Memoization
+
+The fourth point to know about `Streams` is that:
+
+* All promises are **memoized**.
+
+
+
+Only for that reason the following naïve, but elegant implementation of the fibonacci sequence has O(N) runtime
+characteristics, and the result can be computed:
+
+```ruby :include
+
+    let(:fibs1) do 
+      cons_stream(0){
+        cons_stream(1){
+          combine_streams fibs1, fibs1.tail, :+
+        }
+      }
+    end
+```
+
+```ruby :example
+    expect(fibs1.drop(1000).head)
+      .to eq(43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875)
+    
+```
+
+
+## Finite Streams
+
+Finite Streams are implemented the same way LISP imlements lists, by providing an _End_Marker_. What is `nil` in LISP
+is `empty_stream` in Ruby. As a matter of fact the `empty_stream` method returns a singleton called `Lab42::Stream::Empty` which
+is also accessible via `EmptyStream` if you required the lib with `require 'lab42/stream/auto_import'` which is true for the demos.
+
+Here is an example of a finite stream
+
+```ruby :include
+    let(:digits){ finite_stream( 0..9 ) }
+```
+
+Now the following all hold
 
+```ruby :example
+    expect(digits.drop(9).head).to eq(9)
+```
 
+```ruby :example
+    expect(digits.drop(10)).to be_empty
+```
 
-Please see the [QED](http://rubyworks.github.io/qed/) demos [here](https://github.com/RobertDober/lab42_streams/blob/master/demo)
+or alternatively
 
-for details.
+```ruby :example
+    expect(digits.drop(10)).to eq(EmptyStream)
+```

data/lib/lab42/stream/auto_import.rb

@@ -4,8 +4,5 @@ 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/behavior.rb

@@ -0,0 +1,62 @@
+require 'lab42/core/hash'
+
+module Lab42
+  class Stream
+    class Behavior
+
+      def initialize( &blk )
+        @behavior = blk
+      end
+
+      def call( *args )
+        @behavior.( *args )
+      end
+
+      class << self
+
+        def const(const_rval)
+          __const_hash__.fetch!(const_rval, new{ |*_| const_rval})
+        end
+
+        def make(*args, &blk)
+          if blk
+            raise ArgumentError, "cannot specify behavior with block and args: #{args.inspect}" unless args.empty?
+            blk
+          else
+            _make_from_args( args )
+          end 
+        end
+
+        def make1(*args, &blk)
+          if blk
+            blk
+          else
+            _make_from_args( args )
+          end 
+        end
+        private
+
+        def _make_from_args( args )
+          if args.first.respond_to?( :call )
+            _curry( args )
+          else
+            -> (rcv, *a) do
+              rcv.send(*(args + a))
+            end 
+          end
+        end
+
+        def _curry(args)
+          -> ( *a ) do
+            args.first.(*(args.drop(1)+a))
+          end
+        end
+
+        def __const_hash__
+          @__const_hash__ ||= {}
+        end
+
+      end
+    end
+  end
+end

data/lib/lab42/stream/class_methods.rb

@@ -2,7 +2,7 @@ module Lab42
   class Stream
     module ClassMethods
       def iterate arg, beh=nil, &blk
-        beh = blk.make_behavior beh
+        beh = Behavior.make(beh, &blk)
         __iterate__ arg, beh
       end
 

data/lib/lab42/stream/core/enumerable.rb

@@ -1,17 +1,11 @@
 module Enumerable
-  def ordered_by *beh, &blk
-    raise ArgumentError, 'need exactly one of block and behavior' if !blk == beh.empty?
-    
-    beh = blk || (Symbol === beh.first ? sendmsg( *beh ) : beh.first )
+  def ordered_by beh
 
-    
     sort do | a, b |
       a == b ? 0 : (
         beh.(a, b) ? -1 : 1
     )
     end
-  end
 
-  def to_stream; finite_stream self end
+  end
 end
-

data/lib/lab42/stream/empty.rb

@@ -1,7 +1,4 @@
 require 'forwarder'
-
-require_relative 'empty/enumerable'
-
 module Lab42
   class Stream
     class Empty < Stream
@@ -36,20 +33,17 @@ module Lab42
       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 itself *; self end
 
-      def scan initial, *args, &blk
+      def scan( initial, * )
         [initial]
       end
 
-      def scan1 *args, &blk
+      def scan1( * )
         []
       end
 
 
-      private
-
       def self.new
         @__instance__ ||= allocate
       end

data/lib/lab42/stream/enumerable.rb

@@ -1,4 +1,5 @@
 require_relative 'core/enumerable'
+require_relative 'behavior'
 
 module Lab42
   class Stream
@@ -7,19 +8,17 @@ module Lab42
     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
+        bhv = Behavior.make( *bhv, &blk )
+        __drop_while__ bhv.not
       end
 
-      # N.B. Not implemented as drop_until( bhv.not )
-      # for performance reasons
       def drop_while *bhv, &blk
-        bhv = blk.make_behavior( *bhv )
+        bhv = Behavior.make( *bhv, &blk )
+        __drop_while__ bhv
+      end
+
+
+      def __drop_while__ bhv
         s = self
         loop do
           return s unless bhv.(s.head)
@@ -31,6 +30,7 @@ module Lab42
       def each
         t = self
         loop do
+          return if t.empty?
           yield t.head
           t = t.tail
         end
@@ -64,7 +64,7 @@ module Lab42
       end
 
       def lazy_take n=1
-        raise ArgumentError, "need a non negative Fixnum" if !(Fixnum === n) || n < 0
+        raise ArgumentError, "need a non negative Integer" if !(Integer === n) || n < 0
         __lazy_take__ n
       end
 
@@ -74,7 +74,7 @@ module Lab42
       end
 
       def lazy_take_until *bhv, &blk
-        bhv = blk.make_behavior( *bhv )
+        bhv = Behavior.make( *bhv, &blk )
         __lazy_take_until__ bhv
       end
 
@@ -86,7 +86,7 @@ module Lab42
       end
 
       def lazy_take_while *bhv, &blk
-        bhv = blk.make_behavior( *bhv )
+        bhv = Behavior.make( *bhv, &blk )
         __lazy_take_while__ bhv
       end
 
@@ -98,30 +98,30 @@ module Lab42
       end
 
       def reduce red=nil, &reducer
-        red = reducer.make_behavior( red )
+        red = Behavior.make( red, &reducer)
         tail.__inject__ head, red
       end
 
       def inject agg, *red, &reducer
-        __inject__ agg, reducer.make_behavior( *red )
+        __inject__ agg, Behavior.make( *red, &reducer )
       end
 
       def filter *args, &blk
-        __filter__ self, blk.make_behavior( *args )
+        __filter__ self, Behavior.make( *args, &blk )
       end
 
       def reject *args, &blk
-        __filter__ self, blk.make_behavior( *args ).not
+        __filter__ self, Behavior.make( *args, &blk ).not
       end
 
       def flatmap *args, &blk
-        __flatmap__ blk.make_behavior( *args )
+        __flatmap__ Behavior.make( *args, &blk )
       end
 
       def __flatmap__ a_proc
-        # require 'pry'
-        # binding.pry
         hh = a_proc.( head )
+        raise ArgumentError, "flatmap can only map on streams, use flatmap_with_each to map over streams and enumerables" unless
+          Lab42::Stream === hh
         if hh.empty?
           tail.__flatmap__ a_proc
         else
@@ -130,18 +130,18 @@ module Lab42
       end
 
       def flatmap_with_each *args, &blk
-        __flatmap_with_each__ blk.make_behavior( *args )
+        __flatmap_with_each__ Behavior.make( *args, &blk )
       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?
+        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
+        hh.respond_to? :each
 
         # Start a new expansion...
         # ... consider an empty expansion
@@ -153,10 +153,8 @@ module Lab42
 
       def scan initial, *args, &blk
         cons_stream initial do
-          __scan__ initial, blk.make_behavior( *args )
+          __scan__ initial, Behavior.make( *args, &blk )
         end.tap{ |r|
-          # require 'pry'
-          # binding.pry
         }
       end
 
@@ -170,16 +168,16 @@ module Lab42
       end
 
       def take_until *bhv, &blk
-        bhv = blk.make_behavior( *bhv )
-        x = []
-        each do | ele |
-          return x if bhv.( ele )
-          x << ele
-        end
-        x
+        bhv = Behavior.make( *bhv, &blk )
+        __take_while__ bhv.not
       end
+
       def take_while *bhv, &blk
-        bhv = blk.make_behavior( *bhv )
+        bhv = Behavior.make( *bhv, &blk )
+        __take_while__ bhv
+      end
+
+      def __take_while__ bhv
         x = []
         each do | ele |
           return x unless bhv.( ele )
@@ -189,8 +187,9 @@ module Lab42
       end
 
       def to_a
-        take_while :true
+        take_while Behavior.const( true ) 
       end
+
       alias_method :entries, :to_a
 
       def make_cyclic
@@ -200,9 +199,8 @@ module Lab42
       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 )
+        __map__ Behavior.make( *args, &blk )
       end
 
       def __map__ prc
@@ -216,7 +214,7 @@ module Lab42
       end
 
       def take n=1
-        raise ArgumentError, "need a non negative Fixnum" if !(Fixnum === n) || n < 0
+        raise ArgumentError, "need a non negative Integer" if !(Integer === n) || n < 0
         x = []
         each do | ele |
           return x if n.zero?
@@ -235,12 +233,12 @@ module Lab42
 
       def zip_as_ary *other_streamables
         zip( *other_streamables )
-          .map( &:entries )
+        .map( &:entries )
       end
 
       def __zip__ streams
-        cons_stream( [head] + streams.map(:head) ){
-          tail.__zip__ streams.map(:tail)
+        cons_stream( [head] + streams.map(&:head) ){
+          tail.__zip__ streams.map(&:tail)
         }
       end
 

data/lib/lab42/stream/higher_order.rb

@@ -1,16 +1,14 @@
+require_relative 'behavior'
 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????
+        op = Behavior.make1( op, &operation )
         __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)
@@ -23,7 +21,7 @@ module Lab42
         indexed = with_index
         n.times.map do | i |
           indexed
-            .filter{ |e, idx| idx % n == i }
+            .filter{ |_, idx| idx % n == i }
             .map( :first )
         end
       end

data/lib/lab42/stream/kernel.rb

@@ -1,4 +1,6 @@
 require 'lab42/core/kernel'
+require_relative 'behavior'
+
 module Kernel
   def binop_streams op, stream1, stream2
     combine_streams stream1, stream2 do |e1, e2|
@@ -33,18 +35,24 @@ module Kernel
   end
 
   def finite_stream enum
-    e = enum.lazy
-    cons_stream( e.peek ){ finite_stream e.drop( 1 ) }
-  rescue StopIteration
-    empty_stream
+    case enum
+    when Range
+      _finite_stream_from_range enum
+    when Array
+      _finite_stream_from_ary enum
+    when Hash
+      _finite_stream_from_hash enum
+    when Enumerator
+      _finite_stream_from_enumerator! enum.to_enum
+    else
+      raise TypeError, "cannot create a finite stream from type #{enum.class.inspect}"
+    end
   end
 
   def flatmap stream, *args, &blk
     stream.flatmap( *args, &blk )
   end
 
-  # TODO: Reimplement with a cursor into streams to avoid
-  # the (potentially) costly array arithm in the tail def
   def merge_streams *streams
     s = streams.reject( &:empty? )
     return empty_stream if s.empty?
@@ -54,7 +62,7 @@ module Kernel
   end
 
   def merge_streams_by *streams_and_beh, &blk
-    beh = blk || streams_and_beh.pop
+    beh = Lab42::Stream::Behavior.make1( blk || streams_and_beh.pop, &blk )
     __merge_streams_by__ beh, streams_and_beh
   end
 
@@ -69,27 +77,56 @@ module Kernel
 
   def iterate_without_block args
     rest = args.drop 1
-    if Method === rest.first 
+    if rest.first && rest.first.respond_to?( :call )
       cons_stream( args.first ){ iterate( rest.first.(*([args.first] + rest.drop(1))), *rest ) }
     else
-      cons_stream( args.first ){ iterate( sendmsg(*rest).(args.first), *rest ) }
+      cons_stream( args.first ){ iterate( args.first.send(*rest), *rest ) }
     end
   end
 
-private
-def __merge_streams_by__ beh, streams
-  still_there = streams.reject( &:empty? )
-  return empty_stream if still_there.empty?
-  __merge_streams_by_with_present__ beh, still_there, streams
-end 
+  private
 
-def __merge_streams_by_with_present__ beh, still_there, streams
-  ordered_heads = still_there
-  .map( &:head )
-  .ordered_by( beh )
+  def _finite_stream_from_ary ary
+      return empty_stream if ary.empty?
+      cons_stream(ary.first){ finite_stream(ary.drop(1)) }
+  end
 
-  cons_stream_n( *ordered_heads ){
-    __merge_streams_by__ beh, still_there.map( &:tail )
-  }
-end
+  def _finite_stream_from_boundaies fst, lst
+    return empty_stream if fst > lst 
+    cons_stream(fst){ _finite_stream_from_boundaies fst.succ, lst }
+  end
+  
+  def _finite_stream_from_hash hsh
+      return empty_stream if hsh.empty?
+      cons_stream(hsh.first){ finite_stream(hsh.without(hsh.first.first)) }
+  end
+
+  def _finite_stream_from_enumerator! enum
+    cons_stream( enum.next ){ _finite_stream_from_enumerator! enum }
+  rescue StopIteration
+    empty_stream
+  end
+
+  def _finite_stream_from_range range
+    fst = range.first
+    lst = range.last
+    lst = lst.pred if range.exclude_end?
+    _finite_stream_from_boundaies fst, lst
+  end
+
+  def __merge_streams_by__ beh, streams
+    still_there = streams.reject( &:empty? )
+    return empty_stream if still_there.empty?
+    __merge_streams_by_with_present__ beh, still_there
+  end 
+
+  def __merge_streams_by_with_present__ beh, still_there
+    ordered_heads = still_there
+    .map( &:head )
+    .ordered_by( beh )
+
+    cons_stream_n( *ordered_heads ){
+      __merge_streams_by__ beh, still_there.map( &:tail )
+    }
+  end
 end

data/lib/lab42/stream/proc.rb

@@ -12,28 +12,9 @@ class Proc
     }
   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

@@ -3,7 +3,7 @@ module Lab42
     module Utility
 
       def segment *args, &blk
-        __segment__ blk.make_behavior( *args )
+        __segment__ Behavior.make( *args, &blk )
       end
 
       def __segment__ beh

data/lib/lab42/stream/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   class Stream
-    Version = "0.1.3"
+    Version = "0.3.0"
   end # class Stream
 end # module Lab42

data/lib/lab42/stream.rb

@@ -5,12 +5,10 @@ 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
@@ -31,7 +29,7 @@ module Lab42
     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
+      __combine_streams__ Behavior.make( op, &operation), args
     end
 
     def drop n = 1
@@ -53,10 +51,10 @@ module Lab42
     def to_stream; self end
 
     def __combine_streams__ op, args
-      return empty_stream if args.any?(&sendmsg(:empty?))
+      return empty_stream if args.any?(&:empty?)
 
-      new_head = op.(head, *args.map(&sendmsg(:head)))
-      cons_stream( new_head ){ tail.__combine_streams__(op, args.map(&sendmsg(:tail))) }
+      new_head = op.(head, *args.map(&:head))
+      cons_stream( new_head ){ tail.__combine_streams__(op, args.map(&:tail)) }
     end
 
     private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_streams
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Robert Dober
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-05-09 00:00:00.000000000 Z
+date: 2024-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: forwarder2
@@ -30,98 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-- !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.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
-- !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: '3.1'
+        version: '0.4'
 description: Lazy Evaluation, Streams, Enumerator#Lazy
 email: robert.dober@gmail.com
 executables: []
@@ -133,13 +49,12 @@ files:
 - lib/lab42/stream.rb
 - lib/lab42/stream/array.rb
 - lib/lab42/stream/auto_import.rb
+- lib/lab42/stream/behavior.rb
 - lib/lab42/stream/class_methods.rb
 - lib/lab42/stream/core/enumerable.rb
 - lib/lab42/stream/delayed.rb
 - lib/lab42/stream/empty.rb
-- lib/lab42/stream/empty/enumerable.rb
 - lib/lab42/stream/enumerable.rb
-- lib/lab42/stream/hash.rb
 - lib/lab42/stream/higher_order.rb
 - lib/lab42/stream/kernel.rb
 - lib/lab42/stream/kernel/extensions.rb
@@ -150,7 +65,7 @@ homepage: https://github.com/RobertDober/lab42_streams
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -158,16 +73,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 3.3.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
-summary: Streams for Ruby 2.0
+summary: Streams for Ruby 3.3.5
 test_files: []

data/lib/lab42/stream/hash.rb

@@ -1,10 +0,0 @@
-class Hash
-  def to_stream
-    values = to_a
-    (0...values.size)
-    .to_stream
-    .map{ |i|
-      Hash[*values[i]]
-    }
-  end
-end