lazy_stream 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 166defa34d053f972bbed9af3675bc3f4b6c3da0
+  data.tar.gz: 9f003140bb1e8bea9d54c32a15d36644a9d15dcc
+SHA512:
+  metadata.gz: 4302666af3e03ae2c8f7faa57431addd7b8c7598fa66c7587f86c64026b77168992f3af6bd8718faed5cd7bf1ac172aaa3d51a5113b488979b1b9059043417ed
+  data.tar.gz: d6e7f3d96e1715f5743d8a85a8349d2414b5957a66810c803a2dbdbf9d0b0d924380cc07ee87a8d23048c5583ee8827da72b7565f7924c7d58f5f1f8047c1a99

data/lib/lazy_stream.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+class LazyStream
+  def initialize(first=nil, &proc)
+    @first = first
+    @proc = block_given? ? proc : lambda { LazyStream.new }
+  end
+
+  attr_reader :first
+
+  def rest
+    @rest ||= @proc.call
+  end
+
+  def empty?
+    first.nil?
+  end
+
+  def at(n)
+    if empty?
+      nil
+    elsif n == 0
+      first
+    else
+      rest.at(n - 1)
+    end
+  end
+
+  def drop(n)
+    empty? || n < 1 ? self : rest.drop(n - 1)
+  end
+
+  def each(&proc)
+    unless empty?
+      proc.call(first)
+      rest.each(&proc)
+    end
+  end
+
+  def map(&proc)
+    empty? ? self : LazyStream.new(proc.call(first)) { rest.map(&proc) }
+  end
+
+  def reduce(initial=0, &proc)
+    empty? ? initial : rest.reduce(proc.call(initial, first), &proc)
+  end
+
+  def select(&pred)
+    if empty?
+      self
+    elsif pred.call(first)
+      LazyStream.new(first) { rest.select(&pred) }
+    else
+      rest.select(&pred)
+    end
+  end
+
+  def take(n)
+    empty? || n < 1 ? LazyStream.new :
+                      LazyStream.new(first) { rest.take(n - 1) }
+  end
+
+  def to_a
+    reduce([]) { |a, x| a << x }
+  end
+
+  def print
+    each { |x| puts x }
+  end
+
+  def scale(factor)
+    map { |x| x * factor }
+  end
+
+  def partial_sums(initial=0)
+    partial_sum = initial + first
+    LazyStream.new(partial_sum) { rest.partial_sums(partial_sum) }
+  end
+
+  def map_successive_pairs(&proc)
+    if empty? || rest.empty?
+      LazyStream.new
+    else
+      LazyStream.new(proc.call(first, rest.first)) do
+        rest.rest.map_successive_pairs(&proc)
+      end
+    end
+  end
+
+  def self.map(*streams, &proc)
+    if streams.first.empty?
+      LazyStream.new
+    else
+      LazyStream.new(proc.call(*streams.map(&:first))) do
+        map(*streams.map(&:rest), &proc)
+      end
+    end
+  end
+
+  def self.add(*streams)
+    map(*streams) { |*args| args.reduce(&:+) }
+  end
+
+  def self.interleave(s1, s2)
+    s1.empty? ? s2 : LazyStream.new(s1.first) { interleave(s2, s1.rest) }
+  end
+end
+
+module Kernel
+  def lazy_stream(first=nil, &rest)
+    LazyStream.new(first, &rest)
+  end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification
+name: lazy_stream
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Mingmin Xie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-02 00:00:00.000000000 Z
+dependencies: []
+description: Ruby infinite lazy stream
+email: melvinxie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lazy_stream.rb
+homepage: https://github.com/melvinxie/lazy_stream
+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.3
+signing_key: 
+specification_version: 4
+summary: lazy_stream
+test_files: []