lazily 0.1.2 → 0.2.0

data/README.md

@@ -41,14 +41,14 @@ See how it printed all the numbers from 1 to 10, indicating that the block given
     4
     => [1, 4, 9, 16]
 
-Same result, but notice how the block was only evaluated four times. 
+Same result, but notice how the block was only evaluated four times.
 
 Lazy pipelines
 --------------
 
 By combining two or more lazy operations, you can create an efficient "pipeline", e.g.
 
-    User.to_enum(:find_each).lazily.select do |u| 
+    User.to_enum(:find_each).lazily.select do |u|
       u.first_name[0] == u.last_name[0]
     end.collect(&:company).uniq.to_a
 
@@ -73,7 +73,7 @@ This is analogous to a Unix shell pipeline, though of course here we're talking
 Lazy multi-threaded processing
 ------------------------------
 
-The `#in_threads` method is a multi-threaded version of `#collect`, allowing multiple elements of a collection to be processed in parallel.  It requires a numeric argument specifying the maximum number of Threads to use. 
+The `#in_threads` method is a multi-threaded version of `#collect`, allowing multiple elements of a collection to be processed in parallel.  It requires a numeric argument specifying the maximum number of Threads to use.
 
     Benchmark.realtime do
       [1,2,3,4].lazily.in_threads(10) do |x|
@@ -82,7 +82,7 @@ The `#in_threads` method is a multi-threaded version of `#collect`, allowing mul
       end.to_a                  #=> [2,4,6,8]
     end.to_i                    #=> 1
 
-Outputs will be yielded in the expected order, making it a drop-in replacement for `#collect`. 
+Outputs will be yielded in the expected order, making it a drop-in replacement for `#collect`.
 
 Unlike some other "parallel map" implementations, the output of `#in_threads` is lazy (though it does need to pre-fetch elements from the source collection as required to start Threads).
 
@@ -116,10 +116,24 @@ A block can be provided to determine the sort-order.
     Lazily.merge(array1, array2) { |x| x.length }
                                         #=> %w(a dd eee cccc bbbbb)
 
+`Lazily.associate` matches up "like" elements from separate collections.  Again, it assumes it's inputs sorted.
+
+    fruit = %w(apple banana orange)
+    nautical_terms = %w(anchor boat flag)
+    Lazily.associate(:fruit => fruit, :nautical => nautical_terms) do |word|
+      word.chars.first
+    end
+    #=> [
+      { :fruit => ["apple"],  :nautical => ["anchor"] },
+      { :fruit => ["banana"], :nautical => ["boat"]   },
+      { :fruit => [],         :nautical => ["flag"]   },
+      { :fruit => ["orange"], :nautical => []         }
+    ]
+
 Same but different
 ------------------
 
-There are numerous similar implementations of lazy operations on Enumerables.  
+There are numerous similar implementations of lazy operations on Enumerables.
 
 ### Lazily vs. Enumerating
 

data/lib/lazily/associating.rb

@@ -0,0 +1,44 @@
+require "lazily/enumerable"
+
+module Lazily
+
+  class << self
+
+    # Associate "like" elements of two or more Enumerables.
+    #
+    # @param labelled_enumerables [Hash<key,Enumerable>]
+    # @return [Enumerable] a lazy collection of Hashes
+    #
+    # @example
+    #   Lazily.associate(a: [1,2,4], b: [1,3,4,4])
+    #     #=> [
+    #       { a: [1], b: [1] },
+    #       { a: [2] },
+    #       { b: [3] },
+    #       { a: [4], b: [4, 4] }
+    #     ]
+    #
+    def associate(source_map, &block)
+      labels = source_map.keys
+      tagged_element_sources = source_map.map do |label, enumerable|
+        enumerable.lazily.map do |value|
+          key = block ? block.call(value) : value
+          TaggedElement.new(key, value, label)
+        end
+      end
+      tagged_elements = Lazily.merge(*tagged_element_sources) { |te| te.key }
+      tagged_elements.chunk { |te| te.key }.map do |_, tagged_elements|
+        association = {}
+        labels.each { |label| association[label] = [] }
+        tagged_elements.each do |te|
+          association[te.label] << te.value
+        end
+        association
+      end
+    end
+
+    TaggedElement = Struct.new(:key, :value, :label)
+
+  end
+
+end

data/lib/lazily/combining.rb

@@ -1,3 +1,4 @@
+require "lazily/associating"
 require "lazily/concatenating"
 require "lazily/merging"
 require "lazily/zipping"

data/lib/lazily/version.rb

@@ -1,3 +1,3 @@
 module Lazily
-  VERSION = "0.1.2".freeze
+  VERSION = "0.2.0".freeze
 end

data/spec/lazily/associating_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe Lazily, "associating" do
+
+  describe ".associate" do
+
+    context "with two identical Enumerables" do
+
+      let(:collectionA) { [2,4,6] }
+      let(:collectionB) { collectionA }
+
+      let(:result) do
+        Lazily.associate(:A => collectionA, :B => collectionB)
+      end
+
+      it "yields matched pairs" do
+        expect(result.to_a).to eq [
+          { :A => [2], :B => [2] },
+          { :A => [4], :B => [4] },
+          { :A => [6], :B => [6] }
+        ]
+      end
+
+    end
+
+    context "with three identical Enumerables" do
+
+      let(:collectionA) { [1,2]}
+      let(:collectionB) { collectionA }
+      let(:collectionC) { collectionA }
+
+      let(:result) do
+        Lazily.associate(:A => collectionA, :B => collectionB, :C => collectionC)
+      end
+
+      it "yields matched triples" do
+        expect(result.to_a).to eq [
+          { :A => [1], :B => [1], :C => [1] },
+          { :A => [2], :B => [2], :C => [2] }
+        ]
+      end
+
+    end
+
+    context "when elements are missing" do
+
+      let(:collectionA) { [1,2] }
+      let(:collectionB) { [2,3] }
+      let(:collectionC) { [1,3] }
+
+      let(:result) do
+        Lazily.associate(:A => collectionA, :B => collectionB, :C => collectionC)
+      end
+
+      it "returns an empty Array for the corresponding label" do
+        expect(result.to_a).to eq [
+          { :A => [1], :B => [ ], :C => [1] },
+          { :A => [2], :B => [2], :C => [ ] },
+          { :A => [ ], :B => [3], :C => [3] }
+        ]
+      end
+
+    end
+
+    context "with a block" do
+
+      let(:colours) { %w(blue red) }
+      let(:fruits)  { %w(apple banana cranberry) }
+      let(:shapes)  { %w(circle rectangle triangle) }
+
+      let(:result) do
+        Lazily.associate(:c => colours, :f => fruits, :s => shapes) do |word|
+          word.chars.first
+        end
+      end
+
+      it "uses the block to associate the elements" do
+        expect(result.to_a).to eq [
+          { :c => [], :f => ['apple'], :s => [] },
+          { :c => ['blue'], :f => ['banana'], :s => [] },
+          { :c => [], :f => ['cranberry'], :s => ['circle'] },
+          { :c => ['red'], :f => [], :s => ['rectangle'] },
+          { :c => [], :f => [], :s => ['triangle'] }
+        ]
+      end
+
+    end
+
+    it "is lazy" do
+      result = Lazily.associate(:a => [1,2].ecetera, :b => [3,4].ecetera )
+      expect(result.first).to eq(:a => [1], :b => [])
+    end
+
+  end
+
+end if ::Enumerable.method_defined?(:chunk)

data/spec/lazily/threading_spec.rb

@@ -16,27 +16,27 @@ describe Lazily, "threading" do
       [1,2,3].ecetera.lazily.in_threads(2) { |x| x * 2 }.should be_lazy
     end
 
-    def round(n, accuracy = 0.02)
-      (n / accuracy).round.to_f * accuracy
+    def round(n, accuracy = 20)
+      (n * accuracy).round.to_f / accuracy
     end
 
     it "runs the specified number of threads in parallel" do
-      delays = [0.03, 0.03, 0.03]
+      delays = [0.05, 0.05, 0.05]
       start = Time.now
       delays.lazily.in_threads(2) do |delay|
         sleep(delay)
       end.to_a
-      round(Time.now - start).should eq(0.06)
+      round(Time.now - start).should eq(0.1)
     end
 
     it "acts as a sliding window" do
-      delays = [0.1, 0.08, 0.06, 0.04, 0.02]
+      delays = [0.1, 0.15, 0.05, 0.05, 0.05]
       start = Time.now
       elapsed_times = delays.lazily.in_threads(3) do |delay|
         sleep(delay)
         round(Time.now - start)
       end
-      elapsed_times.to_a.should eq([0.1, 0.08, 0.06, 0.14, 0.12])
+      elapsed_times.to_a.should eq([0.1, 0.15, 0.05, 0.15, 0.2])
     end
 
     it "surfaces exceptions" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lazily
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-24 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies: []
 description: ! "    Lazily implements \"lazy\" versions of many Enumerable methods,\n
   \   allowing streamed processing of large (or even infinite) collections.\n\n    It's
@@ -30,6 +30,7 @@ files:
 - benchmarks/pipeline_bench.rb
 - lazily.gemspec
 - lib/lazily.rb
+- lib/lazily/associating.rb
 - lib/lazily/combining.rb
 - lib/lazily/concatenating.rb
 - lib/lazily/enumerable.rb
@@ -40,6 +41,7 @@ files:
 - lib/lazily/threading.rb
 - lib/lazily/version.rb
 - lib/lazily/zipping.rb
+- spec/lazily/associating_spec.rb
 - spec/lazily/bugs_spec.rb
 - spec/lazily/concatenating_spec.rb
 - spec/lazily/filtering_spec.rb
@@ -63,7 +65,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1657751678053576424
+      hash: 3722161259490547720
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -72,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1657751678053576424
+      hash: 3722161259490547720
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -80,6 +82,7 @@ signing_key:
 specification_version: 3
 summary: Lazy Enumerables for everybody!
 test_files:
+- spec/lazily/associating_spec.rb
 - spec/lazily/bugs_spec.rb
 - spec/lazily/concatenating_spec.rb
 - spec/lazily/filtering_spec.rb