totally_lazy 0.0.4 → 0.0.5

data/lib/sequence.rb

@@ -6,9 +6,30 @@ end
 
 module Sequences
 
+  # Creates a sequence
+  #
+  # == Parameters:
+  # items::
+  #   Varargs - any valid ruby objects can be supplied
+  #
+  # == Returns:
+  # A sequence
+  #
+  # == Examples
+  #
+  #   sequence(1,2,3,4).filter(even) # lazily returns 2,4
+  #   sequence(1,2).map(as_string) # lazily returns "1","2"
+  #   sequence(1, 2).map_concurrently(to_string) # lazily distributes the work to background threads
+  #   sequence(1,2,3).take(2) # lazily returns 1,2
+  #   sequence(1,2,3).drop(2) # lazily returns 3
+  #   sequence(1,2,3).tail # lazily returns 2,3
+  #   sequence(1,2,3).head # eagerly returns 1
+  #   sequence(1,2,3).head_option # eagerly returns an option
+  #   some(sequence(1,2,3)).get_or_else(empty) # eagerly returns value or else empty sequence
+  #   sequence(1, 2, 3, 4, 5).filter(where(is greater_than 2).and(is odd)) # lazily returns 3,5
   def sequence(*items)
     if items.size == 1
-      if [Range, Hash].include?(items.first.class)
+      if [Range, Hash, Array, Set].include?(items.first.class)
         Sequence.new(items.first)
       elsif items.first.nil?
         empty
@@ -20,10 +41,23 @@ module Sequences
     end
   end
 
+  # Creates an empty sequence
+  #
+  # == Returns:
+  # An empty sequence
+  #
+  # == Examples
+  #
+  #   empty
+  #   some(sequence(1,2,3)).get_or_else(empty) # eagerly returns value or else empty sequence
   def empty
     Empty.new
   end
 
+  def deserialize(data)
+    sequence(data).deserialize
+  end
+
   class Sequence < Enumerator
 
     include Comparable
@@ -50,7 +84,7 @@ module Sequences
     def map(predicate=nil, &block)
       if predicate
         Sequence.new(self) { |yielder, val|
-          v = predicate.call(val)
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
           yielder << v unless v.nil?
         }
       else
@@ -62,10 +96,32 @@ module Sequences
 
     alias collect map
 
+    # def reduce(operation_or_value=nil)
+    #   case operation_or_value
+    #     when Symbol
+    #       # convert things like reduce(:+) into reduce { |s,e| s + e }
+    #       return reduce { |s,e| s.send(operation_or_value, e) }
+    #     when nil
+    #       acc = nil
+    #     else
+    #       acc = operation_or_value
+    #   end
+    #
+    #   each do |a|
+    #     if acc.nil?
+    #       acc = a
+    #     else
+    #       acc = yield(acc, a)
+    #     end
+    #   end
+    #
+    #   return acc
+    # end
+
     def select(predicate=nil, &block)
       if predicate
         Sequence.new(self) { |yielder, val|
-          v = predicate.call(val)
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
           yielder << v unless v.nil?
         }
       else
@@ -80,14 +136,23 @@ module Sequences
     alias find_all select
     alias filter select
 
-    def reject(&block)
-      Sequence.new(self) { |yielder, val|
-        if not block.call(val)
-          yielder << val
-        end
-      }
+    def reject(predicate=nil, &block)
+      if predicate
+        Sequence.new(self) { |yielder, val|
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates, true) : predicate.call(val, :self, true)
+          yielder << v unless v.nil?
+        }
+      else
+        Sequence.new(self) { |yielder, val|
+          unless block.call(val)
+            yielder << val
+          end
+        }
+      end
     end
 
+    alias unfilter reject
+
     def grep(pattern)
       Sequence.new(self) { |yielder, val|
         if pattern === val
@@ -146,7 +211,6 @@ module Sequences
     def flat_map(&block)
       Sequence.new(self) { |yielder, val|
         ary = block.call(val)
-        # TODO: check ary is an Array
         ary.each { |x|
           yielder << x
         }
@@ -197,6 +261,10 @@ module Sequences
       sequence.empty? ? none : some(sequence.entries.last)
     end
 
+    def contains?(value)
+      sequence.empty? ? false : sequence.entries.include?(value)
+    end
+
     def tail
       Sequence.new(Sequence::Generator.new do |g|
         self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.drop(1).each { |i| g.yield i }
@@ -218,18 +286,19 @@ module Sequences
 
     def transpose
       Sequence.new(Sequence::Generator.new do |g|
+        if self.empty?
+          raise(NoSuchElementException.new, 'The sequence was empty')
+        else
+          raise(Exception.new, 'The subject of transposition must be multidimensional') unless self.to_a.first.is_a?(Array)
+        end
         result = []
-        max_size = self.to_a.max { |a, b| a.size <=> b.size }.size
+        max = option(self.to_a.max { |a, b| a.size <=> b.size })
+        max_size = max.get_or_throw(NoSuchElementException, 'The option was empty').size
         max_size.times do |i|
           result[i] = [self.to_a.first.size]
           self.to_a.each_with_index { |r, j| result[i][j] = r[i] }
         end
         result
-        if self.empty?
-          raise(NoSuchElementException.new, 'The sequence was empty')
-        else
-          raise(Exception.new, 'The subject of transposition must be multidimensional') unless self.to_a.first.is_a?(Array)
-        end
         result.each { |i| g.yield i }
       end)
     end
@@ -237,9 +306,7 @@ module Sequences
     def join(target_sequence)
       Sequence.new(Sequence::Generator.new do |g|
         raise(Exception.new, 'The target (right side) must be a sequence') unless target_sequence.kind_of?(Sequences::Sequence)
-        elements = self.entries
-        elements = elements.reject { |i| i.is_a?(Empty) }
-        (elements << target_sequence.entries).flatten.each { |i| g.yield i }
+        self.entries.push(target_sequence.entries).flatten.each { |i| g.yield i unless i.is_a?(Empty) }
       end)
     end
 
@@ -263,7 +330,7 @@ module Sequences
 
     def to_seq
       Sequence.new(Sequence::Generator.new do |g|
-        self.entries.map { |e| Type.check(e, Sequences::Sequence); e.entries }.flatten.each { |i| g.yield i }
+        self.entries.map { |e| Type.responds(e, :entries); e.entries }.flatten.each { |i| g.yield i }
       end)
     end
 
@@ -273,6 +340,24 @@ module Sequences
       end)
     end
 
+    def from_arrays
+      Sequence.new(Sequence::Generator.new do |g|
+        self.entries.map { |e| Type.check(e, Array); e }.flatten.each { |i| g.yield i }
+      end)
+    end
+
+    def from_sets
+      Sequence.new(Sequence::Generator.new do |g|
+        self.entries.map { |e| Type.check(e, Set); e.to_a }.flatten.each { |i| g.yield i }
+      end)
+    end
+
+    def in_pairs
+      Sequence.new(Sequence::Generator.new do |g|
+        self.each_slice(2) { |k, v| g.yield pair(k, v) }
+      end)
+    end
+
     def to_a
       execution = {
           Sequences::Sequence => -> { self.entries.map { |s| s.entries } },
@@ -287,6 +372,26 @@ module Sequences
       end
     end
 
+    def marshal_dump
+      serialize
+    end
+
+    def marshal_load(data)
+      Sequence.new(data).deserialize
+    end
+
+    def serialize
+      c = []
+      serializer(c, self.entries)
+      c
+    end
+
+    def deserialize
+      c = []
+      deserializer(c, self.entries)
+      Sequence.new(c)
+    end
+
     def all
       to_a.flatten
     end
@@ -299,8 +404,42 @@ module Sequences
       blank?(sequence[index]) ? none : some(sequence[index])
     end
 
+    def get_or_throw(index, exception, message='')
+      blank?(sequence[index]) ? raise(exception, message) : sequence[index]
+    end
+
+    def drop_nil
+      Sequence.new(Sequence::Generator.new do |g|
+        self.reject { |e| e.nil? }.each { |i| g.yield i }
+      end)
+    end
+
+    def map_concurrently(predicate=nil, options={}, &block)
+      if predicate
+        Sequence.new(Sequence::Generator.new do |g|
+          Parallel.map(self.entries, options) { |val|
+            predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
+          }.each { |i| g.yield i unless i.nil? }
+        end)
+      else
+        Sequence.new(Sequence::Generator.new do |g|
+          Parallel.map(self.entries, options) { |val| block.call(val) }.each { |i| g.yield i }
+        end)
+      end
+    end
+
+    def each_concurrently(options={}, &block)
+      Parallel.each(self.entries, options) { |val| block.call(val) }
+    end
+
+    def cycle
+      Sequence.new(Sequence::Generator.new do |g|
+        self.entries.cycle.each { |i| g.yield i }
+      end)
+    end
+
+    protected
 
-    private
     def sequence
       Sequence.new(self)
     end
@@ -309,6 +448,63 @@ module Sequences
       item.respond_to?(:empty?) ? item.empty? : !item
     end
 
+    def serializer(container, entries)
+      entries.each do |entry|
+        if entry.is_a?(Sequences::Sequence)
+          data = []
+          serializer(data, entry)
+          container << {type: :sequence, values: data}
+        elsif entry.is_a?(Pair::Pair)
+          if entry.second.is_a?(Sequences::Sequence)
+            data = []
+            serializer(data, entry)
+            container << {type: :pair, values: data}
+          else
+            container << {type: :pair, values: entry.to_map}
+          end
+        elsif entry.is_a?(Option::Some)
+          container << {type: :some, values: entry.value}
+        elsif entry.is_a?(Option::None)
+          container << {type: :none, values: nil}
+        elsif entry.respond_to?(:each)
+          data = []
+          serializer(data, entry)
+          container << {type: entry.class, values: data}
+        else
+          container << entry
+        end
+      end
+    end
+
+    def deserializer(container, data)
+      data.each do |entry|
+        if entry.is_a?(Hash)
+          if entry[:type] == :sequence
+            data = []
+            deserializer(data, entry[:values])
+            container << Sequence.new(data)
+          elsif entry[:type] == :pair
+            if entry[:values].is_a?(Array)
+              container << pair(entry[:values].first, Sequence.new(entry[:values][1][:values]))
+            else
+              container << pair(entry[:values].keys.first, entry[:values].values.first)
+            end
+          elsif entry[:type] == :some
+            container << some(entry[:values])
+          elsif entry[:type] == :none
+            container << none
+          elsif entry[:type] == Hash
+            h = entry[:values].map { |e| [e[:values]].to_h }.reduce({}) { |a, b| a.merge(b) }
+            container << h
+          else
+            container << entry[:type].send(:new, entry[:values])
+          end
+        else
+          container << entry
+        end
+      end
+    end
+
   end
 
   class Empty < Sequence

data/lib/totally_lazy.rb

@@ -1,15 +1,138 @@
 require_relative 'type_check'
+require 'set'
+require 'prime'
 require_relative 'sequence'
 require_relative 'pair'
 require_relative 'option'
 require_relative 'functor'
-require_relative 'predicates'
+require_relative 'predicates/predicates'
+require_relative 'predicates/compare'
+require_relative 'predicates/conversions'
+require_relative 'predicates/numbers'
+require_relative 'predicates/where'
+require_relative 'predicates/where_processor'
+require_relative 'parallel/parallel'
+require_relative 'generators'
+require_relative 'any'
 
 include Sequences
 include Option
 include Pair
+include Predicates
 include Predicates::Numbers
 include Predicates::Conversions
+include Predicates::Compare
+include Predicates::Where
+include Generators
+include Any
+
+
+# p sequence(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).filter(
+#       where( is(greater_than 2).or(is equal_to 5) )
+#       ).entries
+#
+# sequence.filter(where.is(greater_than 2))
+
+
+
+# p sequence(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).filter(where(is greater_than 2).or(is less_than 8 ).and(is odd)).entries
+
+# p sequence(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).filter(where(is greater_than 2).and(is less_than 8 ).and(is even)).entries
+
+# p sequence(pair(1, 2), pair(3, 4)).filter(where(key:odd)).entries
+
+# p sequence(1,2,3,4,5,6).map_concurrently(as_string,in_threads:10).entries
+# p sequence(1,2,3,4,5,6).map_concurrently{|i| i+5 }.entries
+
+# sequence(1,2,3,4,5).each_concurrently{|i| sleep rand(10); p i }
+
+
+
+# p Seq.repeat('car').take(10).entries
+# p Seq.range(1,1000000000000000000000000000).take(20).entries
+
+# p Seq.iterate(:*,2).take(10).entries
+# p Seq.fibonacci.take(20).entries
+# p Iter.fibonacci.take(20).entries
+# p Iter.primes.take(10).entries
+
+# p Seq.powers_of(3).take(10).entries
+# p Iter.powers_of(3).take(10).entries
+
+# p Seq.iterate(:+,1,0).take(10).entries
+
+# p Seq.range(1,4).cycle.take(20).entries
+# p Iter.range(1,4).cycle.take(20).entries
+
+# p Seq.iterate(:+, 1).filter(even).take(2).reduce(:+)
+
+#
+# class Person
+#   attr_accessor :first_name,:last_name,:age
+#   def initialize(first_name,last_name,age)
+#     @first_name = first_name
+#     @last_name = last_name
+#     @age = age
+#   end
+#
+#   def name
+#     @first_name
+#   end
+#
+# end
+#
+# people = Seq.repeat(-> {Person.new(Any.string,Any.string,Any.string)}).take(10)
+#
+# p people.filter(where(first_name:matches(/s/))).map(&:first_name).entries
+
+# p sequence(pair('apples','pairs'),pair('banana','orange'),pair('apples','melon')).filter(where key:matches(/app/)).entries
+
+# p Seq.repeat(-> { rand(9)}).take(10).to_a.join.to_i
+
+# p  Seq.range(1,100000000000000).shuffle.take(10).to_a
+
+# a = sequence(pair(7,8),sequence(1,2),sequence(3,sequence(5,6)),sequence(pair(:apple,99), option(1),none),[10,11],{:apple => 8,:pear => 9}).serialize
+#
+# p a
+# p deserialize(a)[5]
+
+# p sequence(pair(1,2))[0]
+
+# p empty.gan(ser).entries
+
+# def countdown(c,n)
+#   return if n.zero? # base case
+#   c << n
+#   countdown(c,n-1)    # getting closer to base case
+# end
+#
+#
+# a = []
+# countdown(a,5)
+# p a
+
+
+# s1 = Seq.range(1,3000000)
+# s2 = Seq.range(1,3000000)
+#
+# s = Time.now
+# p s1.join2(s2).head
+# f = Time.now
+# p f - s
+#
+#
+# s = Time.now
+# p s1.join(s2).head
+# f = Time.now
+# p f - s
+
+
+
+
+
+
+
+
 
 
 

data/spec/functor_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Functor' do
+
+    it 'should create a new functor' do
+      fc = Functor.new do |op, *a, &b|
+        [op, a, b]
+      end
+      expect(fc+1).to eq([:+, [1], nil])
+    end
+
+    it 'should support class method' do
+      fc = Functor.new do |op, *a, &b|
+        [op, a, b]
+      end
+      expect( fc.__class__).to eq(Functor)
+    end
+
+    it 'should support to proc' do
+      f = Functor.new do |op, *a|
+        [op, *a]
+      end
+      p = f.to_proc
+      expect(p.class).to eq(Proc)
+      expect(p.call(:+,1,2,3)).to eq([:+,1,2,3])
+    end
+
+    it 'should cache a new functor' do
+      Functor.cache(:cached) do |op, *a, &b|
+          [op, a, b]
+        end
+      expect(Functor.cache(:cached) + 1).to eq([:+, [1], nil])
+     end
+
+end

data/spec/generators_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Generators' do
+
+  it 'should support repeat' do
+    expect(Seq.repeat('car').take(2)).to eq(sequence('car', 'car'))
+    expect(Iter.repeat('car').take(2).entries).to eq(%w(car car))
+  end
+
+  it 'should support range' do
+    expect(Seq.range(1, 4)).to eq(sequence(1, 2, 3, 4))
+    expect(Iter.range(1, 4).entries).to eq([1, 2, 3, 4])
+  end
+
+  it 'should support iterate' do
+    expect(Seq.iterate(:+, 1).take(4)).to eq(sequence(1, 2, 3, 4))
+    expect(Iter.iterate(:+, 1).take(4).entries).to eq([1, 2, 3, 4])
+    expect(Seq.iterate(:+, 1, 5).take(4)).to eq(sequence(5, 6, 7, 8))
+    expect(Iter.iterate(:+, 1, 5).take(4).entries).to eq([5, 6, 7, 8])
+  end
+
+  it 'should support primes' do
+    expect(Seq.primes.take(3)).to eq(sequence(2, 3, 5))
+    expect(Iter.primes.take(3).entries).to eq([2, 3, 5])
+  end
+
+  it 'should support fibonacci' do
+    expect(Seq.fibonacci.take(3)).to eq(sequence(1, 1, 2))
+    expect(Iter.fibonacci.take(3).entries).to eq([1, 1, 2])
+  end
+
+  it 'should support powers_of' do
+    expect(Seq.range(1, 4)).to eq(sequence(1, 2, 3, 4))
+    expect(Iter.range(1, 4).entries).to eq([1, 2, 3, 4])
+  end
+
+end

data/spec/option_spec.rb

@@ -1,5 +1,4 @@
-require 'rspec'
-require_relative '../lib/totally_lazy'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe 'Option' do
 
@@ -45,5 +44,77 @@ describe 'Option' do
     expect { option(empty).get_or_throw(Exception) }.to raise_error(Exception)
   end
 
+  it 'should return boolean for empty?' do
+    expect(option(1).empty?).to eq(false)
+    expect(option(empty).empty?).to eq(true)
+  end
+
+  it 'should return boolean for defined?' do
+    expect(option(1).defined?).to eq(true)
+    expect(option('').defined?).to eq(false)
+  end
+
+  it 'should convert to sequence' do
+    expect(option(1).to_seq).to eq(sequence(option(1)))
+  end
+
+  it 'should raise empty exception when calling get on none' do
+    expect { option(empty).get }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should raise empty exception when calling value on none' do
+    expect { option(empty).value }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should return true for empty on none' do
+    expect(option(empty).empty?).to eq(true)
+  end
+
+  it 'should return false for defined on none' do
+    expect(option(empty).defined?).to eq(false)
+  end
+
+  it 'should return the else in get_or_else for none' do
+    expect(option(empty).get_or_else(1)).to eq(1)
+  end
+
+  it 'should return nil in get_or_nil for none' do
+    expect(option(empty).get_or_nil).to eq(nil)
+  end
+
+  it 'should raise exception in get_or_throw for none' do
+    expect { option(empty).get_or_throw(Exception, 'oops') }.to raise_error(Exception)
+  end
+
+  it 'should return sequence for none' do
+    expect(option(empty).to_seq).to eq(sequence(none))
+  end
+
+  it 'should return false for contains for none' do
+     expect(option(empty).contains('ooo')).to eq(false)
+  end
+
+  it 'should return false for exists for none' do
+    pending('needs work')
+    pass
+  end
+
+  it 'should return false for contains for none' do
+     expect(option(empty).contains('ooo')).to eq(false)
+  end
+
+  it 'should return original sequence for join on none' do
+    expect(option(empty).join(sequence(1,2))).to eq(sequence(1,2))
+    expect(option(empty).join([1,2])).to eq(sequence([1,2]))
+  end
+
+  it 'should know the type' do
+    expect(option(empty).is_none?).to be(true)
+    expect(option(empty).is_some?).to be(false)
+    expect(option(1).is_none?).to be(false)
+    expect(option(1).is_some?).to be(true)
+  end
+
+
 
 end

data/spec/pair_spec.rb

@@ -1,5 +1,4 @@
-require 'rspec'
-require_relative '../lib/totally_lazy'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe 'Pair' do
 
@@ -37,4 +36,8 @@ describe 'Pair' do
     expect(pair('1', '2').to_f).to eq({1.0 => 2.0})
   end
 
+  it 'should support each' do
+    expect(pair(1,2).each{|x| x }).to eq([1,2])
+  end
+
 end