totally_lazy 0.0.20 → 0.1.0

data/spec/sequence_spec.rb

@@ -1,230 +1,300 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require_relative 'spec_helper'
 
 describe 'Sequence' do
-
   it 'should create empty sequence when iterable is nil' do
     expect(sequence(nil)).to eq(empty)
   end
 
-  it 'should support transpose' do
-    expect(sequence(sequence(1, 2), sequence(3, 4), sequence(5, 6)).transpose).to include(sequence(1, 3, 5), sequence(2, 4, 6))
-    expect { empty.transpose.entries }.to raise_error(NoSuchElementException)
+  it 'should support head' do
+    expect(sequence(1, 2).head).to eq(1)
   end
 
-  it 'should eagerly return the first element of a sequence, returns NoSuchElementException if empty' do
+  it 'should return same result when head called many times' do
+    expect(sequence(1, 2).head).to eq(1)
     expect(sequence(1, 2).head).to eq(1)
-    expect { empty.head }.to raise_error(NoSuchElementException)
   end
 
-  it 'should eagerly return the first element of a sequence wrapped in a some, returns none if empty' do
-    expect(sequence(1, 2).head_option).to eq(some(1))
+  it 'should support head_option' do
+    expect(sequence(1).head_option).to eq(some(1))
     expect(empty.head_option).to eq(none)
   end
 
-  it 'should eagerly return the last element of a finite sequence, throws NoSuchElementException if empty' do
-    expect(sequence(1, 2).last).to eq(2)
-    expect { empty.last }.to raise_error(NoSuchElementException)
+  it 'should support reverse' do
+    expect(sequence(1, 2, 3).reverse).to eq(sequence(3, 2, 1))
+  end
+
+  it 'should support last' do
+    expect(sequence(1, 2, 3).last).to eq(3)
   end
 
-  it 'should eagerly return the last element of a finite sequence wrapped in a some, returns none if empty' do
-    expect(sequence(1, 2).last_option).to eq(some(2))
+  it 'should support last_option' do
+    expect(sequence(1, 2, 3).last_option).to eq(some(3))
     expect(empty.last_option).to eq(none)
   end
 
-  it 'should lazily return the elements except the last one - throws NoSuchElementException if empty. Works with infinite sequences' do
+  it 'should support tail' do
     expect(sequence(1, 2, 3).tail).to eq(sequence(2, 3))
-    expect { empty.tail.first }.to raise_error(NoSuchElementException)
   end
 
-  it 'should lazily return the elements except the first one - throws NoSuchElementException if empty' do
-    expect(sequence(1, 2, 3).init).to eq(sequence(1, 2))
-    expect { empty.init.first }.to raise_error(NoSuchElementException)
+  it 'should lazily return tail' do
+    expect(Sequence.new((1..Float::INFINITY).lazy).tail.head).to eq(2)
+    expect(range_from(100).tail.head).to eq(101)
   end
 
-  it 'should lazily shuffle the elements - throws NoSuchElementException if empty' do
-    expect(sequence((1..50).to_a).flatten.shuffle.entries).not_to eq(sequence((1..50).to_a).flatten.entries)
-    expect { empty.shuffle.first }.to raise_error(NoSuchElementException)
+  it 'should return empty tail on sequence with 1 item' do
+    expect(sequence(1).tail).to eq(empty)
   end
 
-  it 'should flatten the content if possible' do
-    expect(sequence([1,2,3,[4,5,6]],[7,8,9]).flatten).to eq(sequence(1,2,3,4,5,6,7,8,9))
-    expect(sequence({:name => 'a', :age => 1},{:up => 2 }).flatten).to eq(sequence(:name,'a',:age,1,:up,2))
+  it 'should raise NoSuchElementException when getting a tail of empty' do
+    expect { empty.tail }.to raise_error(NoSuchElementException)
   end
 
-  it 'should lazily join sequences together' do
-    expect(sequence(1, 2, 3).join(sequence(4, 5, 6))).to eq(sequence(1, 2, 3, 4, 5, 6))
-    expect(empty.join(sequence(1, 2))).to eq(sequence(1, 2))
+  it 'should support init' do
+    expect(sequence(1, 2, 3).init).to eq(sequence(1, 2))
   end
 
-  it 'should support select' do
-    expect(sequence(1, 2, 3).filter(even)).to eq(sequence(2))
-    expect(sequence(1, 2, 3).find_all(even)).to eq(sequence(2))
-    expect(sequence(1, 2, 3).select(even)).to eq(sequence(2))
-    expect(sequence(1, 2, 3).filter(&:even?)).to eq(sequence(2))
+  it 'should raise NoSuchElementException when getting init of an empty' do
+    expect { empty.init }.to raise_error(NoSuchElementException)
   end
 
   it 'should support map' do
-    expect(sequence(1, 2, 3).map(as_string)).to eq(sequence('1', '2', '3'))
-    expect(sequence(1, 2, 3).collect(as_string)).to eq(sequence('1', '2', '3'))
-    expect(sequence(1, 2, 3).map { |x| x.to_s }).to eq(sequence('1', '2', '3'))
+    expect(sequence(1, 2, 3).map(->(a) { a*2 })).to eq(sequence(2, 4, 6))
+    expect(sequence(1, 2, 3).map { |a| a*2 }).to eq(sequence(2, 4, 6))
   end
 
-  it 'should support reject' do
-    expect(sequence(1, 2, 3).reject(even)).to eq(sequence(1, 3))
-    expect(sequence(1, 2, 3).unfilter(even)).to eq(sequence(1, 3))
-    expect(sequence(1, 2, 3).reject(&:even?)).to eq(sequence(1, 3))
+  it 'should ensure map is lazy' do
+    result = sequence(returns(1), call_raises(RuntimeError.new)).map(call)
+    expect(result.head).to eq(1)
   end
 
-  it 'should support grep' do
-    expect(sequence('apple', 'pear', 'banana').grep(/p/)).to eq(sequence('apple', 'pear'))
+  it 'should support filter' do
+    expect(sequence(1, 2, 3, 4).filter(even)).to eq(sequence(2, 4))
+    expect(sequence(1, 2, 3, 4).filter { |value| even.(value) }).to eq(sequence(2, 4))
   end
 
-  it 'should support drop' do
-    expect(sequence(1, 2, 3).drop(1)).to eq(sequence(2, 3))
+  it 'should ensure filter is lazy' do
+    result = sequence(returns(1), returns(2), call_raises(RuntimeError.new)).map(call).filter(even)
+    expect(result.head).to eq(2)
   end
 
-  it 'should support drop_while' do
-    expect(sequence(1, 2, 5, 4, 3).drop_while { |n| n < 5 }).to eq(sequence(5, 4, 3))
+  it 'should support composite predicates' do
+    expect(sequence(1, 2, 3, 4).filter(Predicates::not(even))).to eq(sequence(1, 3))
   end
 
-  it 'should support take' do
-    expect(sequence(1, 2, 3).take(2)).to eq(sequence(1, 2))
+  it 'should support reject' do
+    expect(sequence(1, 2, 3, 4).reject(even)).to eq(sequence(1, 3))
+    expect(sequence(1, 2, 3, 4).reject { |value| even.(value) }).to eq(sequence(1, 3))
   end
 
-  it 'should support take_while' do
-    expect(sequence(1, 2, 5, 4, 3).take_while { |n| n < 5 }).to eq(sequence(1, 2))
+  it 'should support fold (aka fold_left)' do
+    expect(sequence(1, 2, 3).fold(0, sum)).to eq(6)
+    expect(sequence(1, 2, 3).fold(0) { |a, b| a + b }).to eq(6)
+    expect(sequence(1, 2, 3).fold_left(0, sum)).to eq(6)
+    expect(sequence(1, 2, 3).fold_left(0) { |a, b| a + b }).to eq(6)
+    expect(sequence('1', '2', '3').fold(0, join)).to eq('0123')
+    expect(sequence('1', '2', '3').fold_left(0, join)).to eq('0123')
   end
 
-  it 'should support flat_map' do
-    expect(sequence(sequence(1, 2), sequence(3, 4)).flat_map { |s| s+1 }).to eq(sequence(2, 3, 4, 5))
-    expect(sequence(sequence(1, 2), sequence(3, 4)).flat_map { |s| s }).to eq(sequence(1, 2, 3, 4))
-    expect(sequence(pair(1, 2), pair(3, 4)).flat_map { |s| s }).to eq(sequence(1, 2, 3, 4))
-    expect(sequence(some(1),none,some(2)).flat_map { |s| s }).to eq(sequence(1,2))
+  it 'should support reduce (aka reduce_left)' do
+    expect(sequence(1, 2, 3).reduce(sum)).to eq(6)
+    expect(sequence(1, 2, 3).reduce { |a, b| a + b }).to eq(6)
+    expect(sequence(1, 2, 3).reduce_left(sum)).to eq(6)
+    expect(sequence(1, 2, 3).reduce_left { |a, b| a + b }).to eq(6)
+    expect(sequence('1', '2', '3').reduce(join)).to eq('123')
+    expect(sequence('1', '2', '3').reduce_left(join)).to eq('123')
   end
 
-  it 'should support zip' do
-    expect(sequence(1, 2, 3).zip(sequence('a', 'b', 'c'))).to eq(sequence([1, 'a'], [2, 'b'], [3, 'c']))
-    expect(sequence(1, 2, 3).zip(sequence(4, 5, 6)) { |x| x.reduce(:+) }).to eq(sequence(5, 7, 9))
+  it 'should support fold_right' do
+    expect(empty.fold_right(4, sum)).to eq(4)
+    expect(sequence(1).fold_right(4, sum)).to eq(5)
+    expect(sequence(1, 2).fold_right(4, sum)).to eq(7)
+    expect(sequence(1, 2, 3).fold_right(4, sum)).to eq(10)
+    expect(sequence(1, 2, 3).fold_right(4) { |a, b| a + b }).to eq(10)
+    expect(empty.fold_right('4', join)).to eq('4')
+    expect(sequence('1').fold_right('4', join)).to eq('14')
+    expect(sequence('1', '2').fold_right('4', join)).to eq('124')
+    expect(sequence('1', '2', '3').fold_right('4', join)).to eq('1234')
   end
 
-  it 'should support item access with get' do
-    expect(sequence(1, 2, 3).get(2)).to eq(3)
-    expect(sequence(1, 2, 3)[2]).to eq(3)
+  it 'should support reduce_right' do
+    # expect(sequence().reduce_right(sum)).to eq(0)   <-- need a monoid to do this
+    expect(sequence(1).reduce_right(sum)).to eq(1)
+    expect(sequence(1, 2).reduce_right(sum)).to eq(3)
+    expect(sequence(1, 2, 3).reduce_right(sum)).to eq(6)
+    expect(sequence(1, 2, 3).reduce_right { |a, b| a+b }).to eq(6)
+    # expect(sequence().reduce_right(join)).to eq('')    <-- need a monoid to do this
+    expect(sequence('1').reduce_right(join)).to eq('1')
+    expect(sequence('1', '2').reduce_right(join)).to eq('12')
+    expect(sequence('1', '2', '3').reduce_right(join)).to eq('123')
   end
 
-  it 'should join the supplied sequence to the existing sequence' do
-    expect(sequence(1, 2, 3).join(sequence(4, 5, 6))).to eq(sequence(1, 2, 3, 4, 5, 6))
-    expect(sequence(1, 2, 3) << sequence(4, 5, 6)).to eq(sequence(1, 2, 3, 4, 5, 6))
+  it 'should support find' do
+    expect(empty.find(even)).to eq(none)
+    expect(sequence(1, 3, 5).find(even)).to eq(none)
+    expect(sequence(1, 2, 3).find(even)).to eq(some(2))
+    expect(sequence(1, 2, 3).find { |value| even.(value) }).to eq(some(2))
   end
 
-  it 'should append an item to the sequence (creates new sequence)' do
-    expect(sequence(1, 2, 3).append(4)).to eq(sequence(1, 2, 3, 4))
+  it 'should support find_index_of' do
+    expect(sequence(1, 3, 5).find_index_of(even)).to eq(none)
+    expect(sequence(1, 3, 6).find_index_of(even)).to eq(some(2))
+    expect(sequence(1, 3, 6).find_index_of { |value| even.(value) }).to eq(some(2))
   end
 
-  it 'should add any item to the sequence (creates new sequence)' do
-    expect(sequence(1, 2, 3).add(sequence(4, 5, 6))).to eq(sequence(1, 2, 3, 4, 5, 6))
-    expect(sequence(1, 2, 3) + sequence(4, 5, 6)).to eq(sequence(1, 2, 3, 4, 5, 6))
+  it 'should support finding the first some' do
+    expect(sequence(none, some(2), some(3)).flat_map(identity).head_option).to eq(some(2))
   end
 
-  it 'should convert a sequence of sequences into a single flattened sequence' do
-    expect(sequence(sequence(1,2,3), sequence(4), sequence(5,6,7)).to_seq).to eq(sequence(1, 2, 3, 4, 5, 6,7))
-    expect{ sequence(1,2,3).to_seq.entries }.to raise_error(UnsupportedTypeException)
+  it 'should support zip_with_index' do
+    expect(sequence('Dan', 'Kings', 'Raymond').zip_with_index).to eq(sequence(pair(0, 'Dan'), pair(1, 'Kings'), pair(2, 'Raymond')))
   end
 
-  it 'should create a sequence of sequences from a sequence of pairs' do
-    expect(sequence(pair(1,2),pair(3,4),pair(5,6)).from_pairs).to eq(sequence(1, 2, 3, 4, 5, 6))
-    expect {sequence({1=>2}).from_pairs.entries}.to raise_error(UnsupportedTypeException)
+  it 'should support zip' do
+    sequence = sequence(1, 3, 5)
+    expect(sequence.zip(sequence(2, 4, 6, 8))).to eq(sequence(pair(1, 2), pair(3, 4), pair(5, 6)))
+    expect(sequence.zip(sequence(2, 4, 6))).to eq(sequence(pair(1, 2), pair(3, 4), pair(5, 6)))
+    expect(sequence.zip(sequence(2, 4))).to eq(sequence(pair(1, 2), pair(3, 4)))
   end
 
-  it 'should convert a sequence to an array' do
-    expect(sequence(1, 2, 3).to_a).to eq([1,2,3])
-    expect(sequence(pair(1,2),pair(3,4)).to_a).to eq([{1=>2},{3=>4}])
-    expect(empty.to_a).to eq([])
+  it 'should support take' do
+    sequence = sequence(1, 2, 3).take(2)
+    expect(sequence).to eq(sequence(1, 2))
+    expect(sequence(1).take(2)).to eq(sequence(1))
+    expect(empty.take(2)).to eq(empty)
   end
 
-  it 'should get or else the value at an index' do
-    expect(sequence(1, 2, 3).get_or_else(0,99)).to eq(1)
-    expect(sequence(1, 2, 3).get_or_else(99,1)).to eq(1)
+  it 'should not take more than it needs' do
+    sequence = repeat_fn(-> { raise RuntimeError }).take(0)
+    expect(sequence.is_empty?).to eq(true)
+    expect(sequence.size).to eq(0)
   end
 
-  it 'should get or else the value at an index' do
-     expect(sequence(1, 2, 3).get_or_throw(1,Exception,'oops')).to eq(2)
-     expect {sequence(1, 2, 3).get_or_throw(99,Exception,'oops')}.to raise_error(Exception)
-   end
-
-  it 'should get an option at an index' do
-    expect(sequence(1, 2, 3).get_option(1)).to eq(some(2))
-    expect(sequence(1, 2, 3).get_option(99)).to eq(none)
+  it 'should support take_while' do
+    sequence = sequence(1, 3, 5, 6, 8, 1, 3)
+    expect(sequence.take_while(odd)).to eq(sequence(1, 3, 5))
+    expect(sequence.take_while { |value| odd.(value) }).to eq(sequence(1, 3, 5))
+    expect(sequence(1).take_while(odd)).to eq(sequence(1))
+    expect(empty.take_while(odd)).to eq(empty)
   end
 
-  it 'should return all as flattened array' do
-    expect(sequence(sequence(1, 2, 3),sequence(4,5,6)).all).to eq([1,2,3,4,5,6])
+
+  it 'should support size' do
+    expect(range(10000000000, 10000000099).size).to eq(100)
   end
 
-  it 'should iterate empty' do
-    expect(empty.each{|i| i}).to eq([])
-    expect(Empty.new([1,2]).each{|i| i}).to eq([1,2])
-    expect(Empty.new([1,2]){|a| a}).to eq(empty)
+  it 'should support repeat' do
+    expect(Sequences.repeat(10).take(5)).to eq(sequence(10, 10, 10, 10, 10))
+    expect(Sequences.repeat_fn(returns(20)).take(5)).to eq(sequence(20, 20, 20, 20, 20))
   end
 
-  it 'should support from_arrays' do
-    expect(sequence([1,2,3,4,5],[6,7]).from_arrays).to eq(sequence(1,2,3,4,5,6,7))
+  it 'should support is_empty?' do
+    expect(empty.is_empty?).to be(true)
+    expect(sequence(1).is_empty?).to be(false)
   end
 
-  it 'should support from_sets' do
-    expect(sequence(Set.new([1,2,3,4,5]),Set.new([6,7])).from_sets.entries).to eq(sequence(1,2,3,4,5,6,7).entries)
+  it 'should support flat_map' do
+    expect(sequence('Hello').flat_map(to_characters)).to eq(sequence('H', 'e', 'l', 'l', 'o'))
+    expect(sequence(sequence(1, 2), sequence(3, 4)).flat_map { |s| s.map { |v| v+1 } }).to eq(sequence(2, 3, 4, 5))
+    expect(sequence(sequence(1, 2), sequence(3, 4)).flat_map { |s| s }).to eq(sequence(1, 2, 3, 4))
+    expect(sequence(pair(1, 2), pair(3, 4)).flat_map { |s| s }).to eq(sequence(1, 2, 3, 4))
+    expect(sequence(some(1), none, some(2)).flat_map { |s| s }).to eq(sequence(1, 2))
+  end
+
+  it 'should raise exception if you try to use both lambda and block' do
+    expect { empty.map(->(a) { a+1 }) { |b| b+2 } }.to raise_error(RuntimeError)
+    expect { empty.map_concurrently(->(a) { a+1 }) { |b| b+2 } }.to raise_error(RuntimeError)
+    expect { empty.flat_map(->(a) { a+1 }) { |b| b+2 } }.to raise_error(RuntimeError)
+    expect { empty.fold(0, ->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.fold_left(0, ->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.fold_right(0, ->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.reduce(->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.reduce_left(->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.reduce_right(->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
+    expect { empty.find(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.find_index_of(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.take_while(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.drop_while(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.exists?(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.for_all?(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.filter(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.reject(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.group_by(->(_) { true }) { |_| true } }.to raise_error(RuntimeError)
+    expect { empty.each(->(v) { puts(v) }) { |v| puts(v) } }.to raise_error(RuntimeError)
+  end
+
+  it 'should support flatten' do
+    expect(sequence('Hello').map(to_characters).flatten).to eq(sequence('H', 'e', 'l', 'l', 'o'))
+    expect(sequence(some(1), none, some(3)).flatten).to eq(sequence(1, 3))
   end
 
-  it 'should map concurrently' do
-    expect(sequence(1,2,3,4,5).map_concurrently(even)).to eq(sequence(2,4))
-    expect(sequence(1,2,3,4,5).map_concurrently{|i| i+1}).to eq(sequence(2,3,4,5,6))
-    expect(sequence(1,2,3,4,5).map_concurrently(even,in_threads:2)).to eq(sequence(2,4))
-    expect(sequence(1,2,3,4,5).map_concurrently(where(is even),in_processes:2)).to eq(sequence(2,4))
-    expect(sequence(1,2,3,4,5).map_concurrently(nil,in_threads:2){|i| i+1}).to eq(sequence(2,3,4,5,6))
+  it 'should support drop' do
+    expect(sequence(1, 2, 3).drop(2)).to eq(sequence(3))
+    expect(sequence(1).drop(2)).to eq(empty)
+    expect(empty.drop(1)).to eq(empty)
   end
 
-  it 'should each concurrently' do
-    expect(sequence(1,2,3).each_concurrently{|i| i }).to eq([1,2,3])
+  it 'should support drop_while' do
+    sequence = sequence(1, 3, 5, 6, 8, 1, 3)
+    expect(sequence.drop_while(odd)).to eq(sequence(6, 8, 1, 3))
+    expect(sequence.drop_while { |value| odd.(value) }).to eq(sequence(6, 8, 1, 3))
+    expect(sequence(1).drop_while(odd)).to eq(empty)
+    expect(empty.drop_while(odd)).to eq(empty)
   end
 
-  it 'should drop nils' do
-    expect(sequence(1,nil,2,nil,3).drop_nil).to eq(sequence(1,2,3))
+  it 'should support sort' do
+    expect(sort(sequence(5, 6, 1, 3, 4, 2))).to eq(sequence(1, 2, 3, 4, 5, 6))
+    expect(sort(sequence('Matt', 'Dan', 'Bob'))).to eq(sequence('Bob', 'Dan', 'Matt'))
   end
 
-  it 'should cycle' do
-    expect(sequence(1,2,3).cycle.take(6)).to eq(sequence(1,2,3,1,2,3))
+  it 'should support sort descending' do
+    expect(sort(sequence(5, 6, 1, 3, 4, 2), descending)).to eq(sequence(6, 5, 4, 3, 2, 1))
+    expect(sequence(5, 6, 1, 3, 4, 2).sort_by(descending)).to eq(sequence(6, 5, 4, 3, 2, 1))
+    expect(sort(sequence('Bob', 'Dan', 'Matt'), descending)).to eq(sequence('Matt', 'Dan', 'Bob'))
+    expect(sequence('Bob', 'Dan', 'Matt').sort_by(descending)).to eq(sequence('Matt', 'Dan', 'Bob'))
   end
 
-  it 'should get pairs from sequence' do
-    expect(sequence(:name,'kings',:age,39).in_pairs.to_a).to eq(sequence(pair(:name,'kings'),pair(:age,39)).to_a)
+  it 'should support contains' do
+    expect(sequence(1, 3, 5).contains?(2)).to eq(false)
+    expect(sequence(1, 2, 3).contains?(2)).to eq(true)
   end
 
-  it 'should update items in a sequence' do
-    expect(Seq.repeat(->{OpenStruct.new(name:Any.string(5),age:Any.int(2))}).take(100000).update(age:11,name:'woops').take(10).map{|s| [s.name,s.age]}.head).to eq(['woops',11])
-    expect(Seq.range(1,10).filter(odd).update(2)).to eq(sequence(2,2,2,2,2))
+  it 'should support exists' do
+    expect(sequence(1, 3, 5).exists?(even)).to eq(false)
+    expect(sequence(1, 3, 5).exists? { |value| even.(value) }).to eq(false)
+    expect(sequence(1, 2, 3).exists?(even)).to eq(true)
   end
 
-  it 'should sort by attributes' do
-    expect(sequence(pair(:a,1),pair(:d,4),pair(:c,3),pair(:b,2)).sorting_by{|e| e.value }.to_a).to eq([{:a=>1}, {:b=>2}, {:c=>3}, {:d=>4}])
-    expect(sequence(pair(:a,1),pair(:d,4),pair(:c,3),pair(:b,2)).sorting_by(:value).to_a).to eq([{:a=>1}, {:b=>2}, {:c=>3}, {:d=>4}])
-    expect(sequence(
-        OpenStruct.new(first_name:'David',age:19,job:'computers'),
-        OpenStruct.new(first_name:'Chris',age:19,job:'art'),
-        OpenStruct.new(first_name:'Andrew',age:32,job:'dancing'),
-        OpenStruct.new(first_name:'Andrew',age:18,job:'dancing'),
-           ).sorting_by{|e| [e.first_name,e.age] }.map{|e| [e.first_name,e.age,e.job]}.to_a).to eq([['Andrew', 18, 'dancing'], ['Andrew', 32, 'dancing'], ['Chris', 19, 'art'], ['David', 19, 'computers']])
+  it 'should support for_all' do
+    expect(sequence(1, 3, 5).for_all?(odd)).to eq(true)
+    expect(sequence(1, 3, 5).for_all? { |value| odd.(value) }).to eq(true)
+    expect(sequence(1, 2, 3).for_all?(odd)).to eq(false)
   end
 
-  it 'should sort' do
-    expect(sequence(5,2,3,1,4).sorting).to eq(sequence(1,2,3,4,5))
+  it 'should support group_by and preserve order' do
+    groups_fn = sequence(1, 2, 3, 4).group_by(mod(2))
+    expect(groups_fn.first).to eq(group(1, sequence(1, 3).enumerator))
+    expect(groups_fn.second).to eq(group(0, sequence(2, 4).enumerator))
+
+    groups_block = sequence(1, 2, 3, 4).group_by { |value| mod(2).(value) }
+    expect(groups_block.first).to eq(group(1, sequence(1, 3).enumerator))
+    expect(groups_block.second).to eq(group(0, sequence(2, 4).enumerator))
   end
 
-  it 'should convert sequence to a map' do
-    expect(sequence('apple',1,'pear',2).to_map).to eq({apple:1,pear:2})
+  it 'should support each' do
+    sum = 0
+    sequence(1, 2).each(->(value) { sum = sum + value })
+    expect(sum).to eq(3)
+
+    sequence(3, 4).each { |value| sum = sum + value }
+    expect(sum).to eq(10)
   end
 
-  it 'should convert from an array to a seq' do
-    expect([1,2,3].to_seq).to eq(sequence(1,2,3))
+  it 'should support map_concurrently' do
+    strings = sequence(1, 2).map_concurrently(to_string)
+    expect(strings).to eq(sequence('1', '2'))
+
+    strings_block = sequence(1, 2).map_concurrently { |value| to_string.(value) }
+    expect(strings_block).to eq(sequence('1', '2'))
   end
 
 

data/spec/spec_helper.rb

@@ -1,16 +1,3 @@
-require 'coveralls'
-Coveralls.wear!
-
-require 'simplecov'
-
-SimpleCov.configure do
-  load_profile 'test_frameworks'
-end
-
-ENV["COVERAGE"] && SimpleCov.start do
-  add_filter "/.rvm/"
-  add_filter "parallel"
-end
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 

data/totally_lazy.iml

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="gem" name="Ruby Gem">
+      <configuration>
+        <option name="GEM_APP_ROOT_PATH" value="" />
+        <option name="GEM_APP_TEST_PATH" value="" />
+        <option name="GEM_APP_LIB_PATH" value="" />
+      </configuration>
+    </facet>
+  </component>
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/lib" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/spec" isTestSource="true" />
+    </content>
+    <orderEntry type="jdk" jdkName="RVM: ruby-2.1.4 [global]" jdkType="RUBY_SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="activesupport (v4.2.5.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="addressable (v2.4.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="builder (v3.2.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v1.11.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="coderay (v1.1.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="concurrent-ruby (v1.0.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="concurrent-ruby-edge (v0.2.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="descendants_tracker (v0.0.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="diff-lcs (v1.2.5, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="faraday (v0.9.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="ffi (v1.9.10, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="formatador (v0.2.5, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="git (v1.2.9.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="github_api (v0.13.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="guard (v2.13.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="guard-compat (v1.2.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="guard-rspec (v4.6.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="hashie (v3.4.3, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="highline (v1.7.8, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="i18n (v0.7.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="jeweler (v2.0.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="json (v1.8.3, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="jwt (v1.5.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="listen (v3.0.6, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="lumberjack (v1.0.10, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="method_source (v0.8.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="mini_portile2 (v2.0.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="minitest (v5.8.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="multi_json (v1.11.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="multi_xml (v0.5.5, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="multipart-post (v2.0.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="nenv (v0.3.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="nokogiri (v1.6.7.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="notiffany (v0.0.8, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="oauth2 (v1.1.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="pry (v0.10.3, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rack (v1.6.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v10.3.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rb-fsevent (v0.9.7, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rb-inotify (v0.9.7, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rdoc (v4.2.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rouge (v1.10.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec (v3.0.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-core (v3.0.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-expectations (v3.0.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-mocks (v3.0.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-support (v3.0.4, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec_html_formatter (v0.3.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="shellany (v0.0.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="slop (v3.6.0, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="thor (v0.19.1, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="thread_safe (v0.3.5, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tzinfo (v1.2.2, RVM: ruby-2.1.4 [global]) [gem]" level="application" />
+  </component>
+</module>