lazy_list 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05be4fd5637906c337d276bc9d212f0d4f0d5279
+  data.tar.gz: ba4f605c55a9abc7fbdca841fa21523c7da630d4
+SHA512:
+  metadata.gz: cff29d947649e827d2ecb19350a0ac2358addccf16b8b399a027688f94a33a9a7a1f7ef7db3e45027e3ba828aa244f9ee3a5a8b12274632119e18169e47c19c9
+  data.tar.gz: 8168ae2f4acfd9857db53263f49edf67eee423461ba4fb4d28dd3b1143a31bd536f8a4410da9577c1466f9612112ef13924c06f12c49fc0bbacd50e0c0ae51a5

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+ruby "2.0.0"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler"
+  gem "jeweler", "~> 1.8.4"
+  gem "rspec"
+  gem "simplecov"
+end

data/Gemfile.lock

@@ -0,0 +1,54 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    bourne (1.1.2)
+      mocha (= 0.10.5)
+    diff-lcs (1.2.1)
+    git (1.2.5)
+    i18n (0.6.4)
+    jeweler (1.8.4)
+      bundler (~> 1.3.0.pre)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    metaclass (0.0.1)
+    mocha (0.10.5)
+      metaclass (~> 0.0.1)
+    multi_json (1.6.1)
+    rake (10.0.3)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+    shoulda (3.3.2)
+      shoulda-context (~> 1.0.1)
+      shoulda-matchers (~> 1.4.1)
+    shoulda-context (1.0.2)
+    shoulda-matchers (1.4.2)
+      activesupport (>= 3.0.0)
+      bourne (~> 1.1.2)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler (~> 1.8.4)
+  rdoc (~> 3.12)
+  rspec
+  shoulda
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Thomas Chen
+
+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.markdown

@@ -0,0 +1,35 @@
+Lazy List for Ruby
+=
+SICP-friendly version of the notorious lazy list for Ruby2.0.0.
+
+One of the most badass things about Ruby2.0 is the Enumerator::Lazy,
+but using that guy on a regular boring Array is kind of a waste as it
+doesn't make it lazy enough. Thus lazy_list for ruby.
+
+Examples
+=
+1. Generic FizzBuzz (where divisble by 3 -> fizz, divisble by 5 -> buzz, divisible by 15 -> fizzbuzz) example
+```ruby
+  from_1 = LazyList::Stream.cycle(1).recur { |v| v + 1 } # [1, 2, 3, 4, 5...]
+  fizzes = from_1.lazy.map { |v| (v%3).zero? "fizz" : nil }
+  buzzes = from_1.lazy.map { |v| (v%5).zero? "buzz" : nil }
+  solution = fizzes.zip(buzzes).zip(from_1).map { |v| [v.last, "#{v[0]}#{v[1]}"] }.take(100).to_a
+```
+
+2. More examples coming up!
+
+Contributing to lazy_list
+= 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+=
+Copyright (c) 2013 Thomas Chen. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "lazy_list"
+  gem.homepage = "http://github.com/foxnewsnetwork/lazy_list"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby2.0 implementaiton of lazy lists as they were meant to be straight out of Structures and Interpretations of Computer Programs.}
+  gem.description = %Q{Ruby is not Haskell. It is NOT a functional language and it isn't meant to be lazy, and forcing it to be anything other than Ruby is stupid and inefficient... but that didn't stop me from building an ultra-lazy Ruby2.0 version of the lazy list}
+  gem.email = "foxnewsnetwork@gmail.com"
+  gem.authors = ["Thomas Chen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lazy_list #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/lazy_list.rb

@@ -0,0 +1,17 @@
+module LazyList
+  autoload :Base, File.join(File.dirname(__FILE__), "lazy_list", "base")
+  autoload :Stream, File.join(File.dirname(__FILE__), "lazy_list", "stream")
+  class << self
+    def cons(a=nil,b=nil)
+      lambda { |c| c.call(a,b) }
+    end
+
+    def cdr(list)
+      lambda { list.call( lambda { |a,b| b } ) }
+    end
+
+    def car(list)
+      lambda { list.call( lambda { |a,b| a } ) }
+    end
+  end
+end

data/lib/lazy_list/base.rb

@@ -0,0 +1,39 @@
+module LazyList
+  class Base
+    include Enumerable
+
+    def initialize(list=nil)
+      @list = list
+      @list ||= LazyList.cons
+    end
+
+    def empty?
+      @has_contents ||= false
+    end
+
+    def inspect
+      "[" + (map { |element| element.inspect }.join(", ")) + "]"
+    end
+
+    def prepend(a)
+      @has_contents = true
+      @list = LazyList.cons a, @list
+      self
+    end
+
+    def first
+      LazyList.car(@list).call
+    end
+
+    def rest
+      self.class.new LazyList.cdr(@list).call
+    end
+
+    def each(&block)
+      return if first.nil?
+      yield first
+      rest.each(&block)
+    end
+
+  end
+end

data/lib/lazy_list/stream.rb

@@ -0,0 +1,47 @@
+module LazyList
+  class Stream < Base
+
+    class << self
+      def cycle(a)
+        new.prepend(a).recur { |a| a }
+      end
+    end
+
+    def prepend(a)
+      @has_contents = true
+      f = lambda { a }
+      @list = LazyList.cons f, @list
+      self
+    end
+
+    def inspect
+      "[" + take(5).map(&:inspect).join(", ") + "...]"
+    end
+
+    def first
+      LazyList.car(@list).call.call
+    end
+
+    def rest
+      self.class.new LazyList.cdr(@list).call.call
+    end
+
+
+
+    def recur(&block)
+      @count = Float::INFINITY
+      @list = _recur( first, &block )
+      self
+    end
+
+    private
+
+    def _recur(element, &block)
+      f = lambda { element }
+      l = lambda do
+        _recur( yield(element), &block) 
+      end
+      LazyList.cons f,l
+    end
+  end
+end

data/spec/lazy_list/base_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe LazyList::Base do
+  let(:list) { LazyList::Base.new }
+
+  describe "#prepend" do
+    before :each do
+      list.prepend(1).prepend(2).prepend(3)
+    end
+
+    describe "#inspect" do
+      it "should return to me a reasonable string" do
+        list.inspect.should eq "[3, 2, 1]"
+      end
+    end
+
+    describe "#rest" do
+      it "should return to me another list that is different from the first list only by the head" do
+        list.rest.should be_a LazyList::Base
+        list.rest.should_not be_empty
+      end
+      it "should always return a LazyList::Base even if empty" do
+        list.rest.rest.rest.should be_a LazyList::Base
+      end
+    end
+
+    it "should get me a list of stuff" do
+      list.first.should eq 3
+      list.rest.first.should eq 2
+      list.rest.rest.first.should eq 1
+    end
+  end
+
+  
+end

data/spec/lazy_list/stream_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe LazyList::Stream do 
+  let(:api) { LazyList::Stream }
+  context "infinite streams" do
+    describe "::cycle" do
+      let(:stream) { api.cycle 1 }
+
+      describe "#recur" do
+        let(:infinite) { stream.recur { |v| v + 1 }.lazy }
+
+        context "enumerable" do
+
+          describe "#take" do
+            let(:ten) { infinite.take(10).to_a }
+            it "should be a finite array of 10 things" do
+              stream.take(10).should eq [1,1,1,1,1,1,1,1,1,1]
+              ten.should eq [1,2,3,4,5,6,7,8,9,10]
+            end
+          end
+
+          describe "#reject" do
+            let(:odds) { infinite.reject { |v| (v%2).zero? }.take(100).to_a }
+            it "should only have the odd numbers" do
+              odds.count.should eq 100
+              odds.each { |o| (0%2).should eq 0 }
+            end
+          end
+
+          describe "#map" do
+            let(:scaled) { infinite.map { |v| v * 2 }.take(5).to_a }
+
+            it "should give me a scaled version of the input array" do
+              scaled.should eq [2,4,6,8,10]
+            end
+          end
+
+          describe "#to_s" do
+            let(:string) { stream.inspect }
+
+            it "should give me a reasonable string" do
+              string.should eq "[1, 1, 1, 1, 1...]"
+            end
+          end
+        end
+      end
+    end
+    describe "#prepend" do
+      let(:stream) { api.new.prepend(2) }
+
+      describe "#recur" do
+        let(:infinite) { stream.recur { |value| value * 2 } }
+
+        describe "#first" do
+          let(:two) { infinite.first }
+          let(:four) { infinite.rest.first }
+          let(:eight) { infinite.rest.rest.first }
+          let(:sixteen) { infinite.rest.rest.rest.first }
+          it "should get me the correct values" do
+            two.should eq 2
+            four.should eq 4
+            eight.should eq 8
+            sixteen.should eq 16
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lazy_list_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe LazyList do
+  let(:api) { LazyList }
+  context "null usage" do
+    let(:list) { api.cons }
+
+    describe "::car" do
+      let(:nothing) { api.car( list).call }
+
+      it "give me nothing" do
+        nothing.should be_nil
+      end
+    end
+    describe "::cdr" do
+      let(:nothing) { api.cdr( list ).call }
+
+      it "should also be nothing" do
+        nothing.should be_nil
+      end
+    end
+  end
+
+  context "singleton usage" do
+    let(:list) { api.cons 1 }
+
+    describe "::car" do
+      let(:one) { api.car( list).call }
+
+      it "should give the first and only value in the singleton list" do
+        one.should eq 1
+      end
+    end
+    describe "::cdr" do
+      let(:nothing) { api.cdr( list).call }
+
+      it "should give me nothing" do
+        nothing.should be_nil
+      end
+    end
+  end
+
+  describe "::cons" do
+    let(:list) { api.cons 1, 2 }
+
+    it "should actually be a lambda" do
+      list.should be_a Proc
+    end
+
+    describe "::car" do
+      let(:one) { api.car(list).call }
+      it "should return the first element of the list" do
+        one.should eq 1
+      end
+    end
+
+    describe "::cdr" do
+      let(:two) { api.cdr( list).call }
+
+      it "should return the remaining elements of the list" do
+        two.should eq 2
+      end
+    end
+
+    context "chaining" do
+      let(:list2) { api.cons 0, list }
+
+      it "should still be a proc" do
+        list2.should be_a Proc
+      end
+
+      describe "::car" do
+        let(:zero) { api.car( list2).call }
+        it "should get the first element of the new list" do
+          zero.should eq 0
+        end
+      end
+
+      describe "::cdr" do
+        let(:one) { api.cdr( list2).call }
+        it "should fetch the rest of the list" do
+          one.should eq list
+          api.car(one).call.should eq 1
+        end
+        describe "::cdr" do
+          let(:two) { api.cdr( one).call }
+          it "should fetch out the final element in the lazy list" do
+            two.should eq 2
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require "rspec"
+require "simplecov"
+SimpleCov.start
+
+require File.expand_path("../../lib/lazy_list", __FILE__)

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'lazy_list'
+
+class Test::Unit::TestCase
+end

data/test/test_lazy_list.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestLazyList < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: lazy_list
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Thomas Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  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: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: simplecov
+  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'
+description: Ruby is not Haskell. It is NOT a functional language and it isn't meant
+  to be lazy, and forcing it to be anything other than Ruby is stupid and inefficient...
+  but that didn't stop me from building an ultra-lazy Ruby2.0 version of the lazy
+  list
+email: foxnewsnetwork@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/lazy_list.rb
+- lib/lazy_list/base.rb
+- lib/lazy_list/stream.rb
+- spec/lazy_list/base_spec.rb
+- spec/lazy_list/stream_spec.rb
+- spec/lazy_list_spec.rb
+- spec/spec_helper.rb
+- test/helper.rb
+- test/test_lazy_list.rb
+homepage: http://github.com/foxnewsnetwork/lazy_list
+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.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Ruby2.0 implementaiton of lazy lists as they were meant to be straight out
+  of Structures and Interpretations of Computer Programs.
+test_files: []