lab42_streams 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bccbce995004e65382114ca3073c25956bfd782d
+  data.tar.gz: f9e9ca8f5a32e2231bb159edb36054ac0f2d32b6
+SHA512:
+  metadata.gz: 6b5f37631aa89ad9a7bdec443adc34a3f2f8355247482eaa450cb7e3da159f0742b321060f78032510ef49dba44d3be5a71ca527640ac3952604168e993b6f9e
+  data.tar.gz: dd4b9c7b4a605103a184f0178218782c88dd040c05372b17a965fa21365aab34c859b4002aac818600487c39528cde2d769dc68fc23256751741f445b3f2be00

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Robert Dober
+
+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,3 @@
+# lab42\_streams
+
+Bringing Streams to the much lazier Ruby 2.0

data/lib/lab42/stream/array.rb

@@ -0,0 +1,3 @@
+class Array
+  def to_stream; finite_stream self end
+end

data/lib/lab42/stream/delayed.rb

@@ -0,0 +1,8 @@
+module Lab42
+  class Stream
+    class Delayed < Stream
+      def head; tail.head end
+      def tail; super.tail end
+    end # class Delayed
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/empty.rb

@@ -0,0 +1,42 @@
+module Lab42
+  class Stream
+    class Empty < Stream
+      # TODO: Implement all self returning methods with Forwarder
+      def append other
+        raise ArgumentError, "not a stream #{other}" unless self.class.superclass === other
+        # ??? Is the to_stream message a good idea
+        other.to_stream
+      end
+      alias_method :+, :append
+
+      def empty?; true end
+
+      def filter *args, &blk; self end
+
+      def head; raise StopIteration, "head 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 flatmap *args, &blk; self end
+      def __flatmap__ a_proc; self end
+
+      private
+      def initialize; end
+
+      def self.new
+        @__instance__ ||= allocate
+      end
+
+    end # class Empty
+
+    module ::Kernel
+      def empty_stream; Empty.new end
+    end # module ::Kernel
+  end # class Stream
+end # module Lab42

data/lib/lab42/stream/enumerable.rb

@@ -0,0 +1,3 @@
+module Enumerable
+  def to_stream; finite_stream self end
+end

data/lib/lab42/stream/hash.rb

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

data/lib/lab42/stream/kernel.rb

@@ -0,0 +1,65 @@
+require 'lab42/core/kernel'
+module Kernel
+  def binop_streams op, stream1, stream2
+    combine_streams stream1, stream2 do |e1, e2|
+      e1.send op, e2
+    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
+  end
+
+  def cons_stream head, &tail
+    Lab42::Stream.new head, tail
+  end
+
+  def const_stream const
+    c = cons_stream( const ){ c }
+  end
+
+  def cyclic_stream *args
+    args = args.first if
+      args.size == 1 && Enumerable === args.first
+
+    finite_stream( args ).make_cyclic
+  end
+
+  def finite_stream enum
+    e = enum.lazy
+    cons_stream( e.peek ){ finite_stream e.drop( 1 ) }
+  rescue StopIteration
+    empty_stream
+  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?
+    cons_stream s.first.head do
+      merge_streams(*(s.drop(1) + [s.first.tail]))
+    end
+  end
+
+  def stream_by *args, &blk
+    if blk
+      cons_stream(*args){ stream_by( 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 ) }
+      else
+        cons_stream( args.first ){ stream_by( sendmsg(*rest).(args.first), *rest ) }
+    end
+    end
+  end
+end

data/lib/lab42/stream/proc.rb

@@ -0,0 +1,14 @@
+class Proc
+  def memoized
+    already_run = false
+    result      = nil
+    ->{
+      if already_run
+        result
+      else
+        already_run = true
+        result = call()
+      end
+    }
+  end
+end

data/lib/lab42/stream/version.rb

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

data/lib/lab42/stream.rb

@@ -0,0 +1,130 @@
+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'
+
+module Lab42
+  class Stream
+    ConstraintError = Class.new RuntimeError
+    include Enumerable
+    attr_reader :head, :promise
+
+    def append other
+      raise ArgumentError, "not a stream #{other}" unless self.class === other
+      cons_stream( head ){ tail.append other }
+    end
+    alias_method :+, :append
+
+    def drop n = 1
+      raise ArgumentError, "not a non negative number" if n < 0
+      t = self
+      loop do
+        return t if n.zero?
+        n -=1
+        t = t.tail
+      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 __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
+    end
+
+    private
+    def initialize h, t=nil, &tail
+        @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
+
+  end # class Stream
+
+end # module Lab42

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: lab42_streams
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Dober
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: forwarder2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: lab42_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: Lazy Evaluation, Streams, Enumerator#Lazy
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lab42/stream.rb
+- lib/lab42/stream/array.rb
+- lib/lab42/stream/version.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/enumerable.rb
+- LICENSE
+- README.md
+homepage: https://github.com/RobertDober/lab42_streams
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: Streams for Ruby 2.0
+test_files: []