totally_lazy 0.0.20 → 0.1.0

data/lib/sequence.rb

@@ -1,642 +1,287 @@
 class NoSuchElementException < RuntimeError
 end
 
-class UnsupportedTypeException < RuntimeError
-end
-
-class UnsupportedMethodException < RuntimeError
-end
-
-# Array pimps
-class Array
-  def to_seq
-    sequence(self).flatten
-  end
-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, Array, Set].include?(items.first.class)
-  #       Sequence.new(items.first)
-  #     elsif items.first.nil?
-  #       empty
-  #     else
-  #       Sequence.new(items)
-  #     end
-  #   else
-  #     Sequence.new(items)
-  #   end
-  # end
+  def empty
+    EMPTY
+  end
 
   def sequence(*items)
     if items.first.nil?
       empty
     else
-      Sequence.new(items)
+      Sequence.new(items.lazy)
     end
   end
 
-  def flatten
-    Sequence.new(entries.map do |entry|
-     if entry.respond_to?(:flatten)
-       entry.flatten
-     else
-       raise UnsupportedMethodException.new, "flatten is not supported by: #{self.entries.class}"
-     end
-   end.flatten)
+  def zip(left, right)
+    left.zip(right)
   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
+  def take(sequence, count)
+    Sequence.new(sequence.enumerator.take(count))
   end
 
-  def deserialize(data)
-    sequence(data).deserialize
+  def drop(sequence, count)
+    Sequence.new(sequence.enumerator.drop(count))
   end
 
-  class Sequence < Enumerator
-
-    include Comparable
-
-    def initialize(obj, &block)
-      super() { |yielder|
-        begin
-          obj.each { |x|
-            if block
-              block.call(yielder, x)
-            else
-              yielder << x
-            end
-          }
-        rescue StopIteration
-        end
-      }
-    end
-
-    def <=>(object)
-      self.entries <=> object.entries
-    end
-
-    def flat_map(predicate=nil, &block)
-      if predicate
-        Sequence.new(self) { |yielder, val|
-          val.each {|x|
-            v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(x).apply(predicate.predicates) : predicate.exec.call(x)
-            yielder << v unless v.nil?
-          }
-        }
-      else
-        Sequence.new(self) { |yielder, val|
-           val.each {|e|
-             yielder << block.call(e)
-           }
-        }
-      end
-    end
-    alias collect_concat flat_map
-
-    def map(predicate=nil, &block)
-      if predicate
-        Sequence.new(self) { |yielder, val|
-          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.exec.call(val)
-          yielder << v unless v.nil?
-        }
-      else
-        Sequence.new(self) { |yielder, val|
-          yielder << block.call(val)
-        }
-      end
-    end
+  def repeat(item)
+    Sequence.new(repeat_enumerator(item))
+  end
 
-    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.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.exec.call(val)
-          yielder << v unless v.nil?
-        }
-      else
-        Sequence.new(self) { |yielder, val|
-          if block.call(val)
-            yielder << val
-          end
-        }
-      end
-    end
+  def repeat_fn(item)
+    Sequence.new(repeat_fn_enumerator(item))
+  end
 
-    alias find_all select
-    alias filter select
-
-    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.exec.call(val, :self, true)
-          yielder << v unless v.nil?
-        }
-      else
-        Sequence.new(self) { |yielder, val|
-          unless block.call(val)
-            yielder << val
-          end
-        }
-      end
-    end
+  def sort(sequence, comparator=ascending)
+    Sequence.new(sequence.enumerator.sort { |a, b| comparator.(a, b) }.lazy)
+  end
 
-    alias unfilter reject
+  def map_concurrently(sequence, fn=nil, &block)
+    call_concurrently(sequence.map(defer_return(block_given? ? ->(value) { block.call(value) } : fn)))
+  end
 
-    def grep(pattern)
-      Sequence.new(self) { |yielder, val|
-        if pattern === val
-          yielder << val
-        end
-      }
-    end
+  # noinspection RubyTooManyMethodsInspection
+  class Sequence
+    include Comparable
+    attr_reader :enumerator
 
-    def drop(n)
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.each_with_index do |v, i|
-                       unless i < n
-                         g.yield v
-                       end
-                     end
-                   end)
-    end
-
-    def drop_while(&block)
-      dropping = true
-      Sequence.new(self) { |yielder, val|
-        if dropping
-          if not block.call(val)
-            yielder << val
-            dropping = false
-          end
-        else
-          yielder << val
-        end
-      }
+    def initialize(enumerator)
+      raise "Sequence only accepts Enumerator::Lazy, not #{enumerator.class}" unless (enumerator.class == Enumerator::Lazy)
+      @enumerator = enumerator
     end
 
-    def take(n)
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.each_with_index do |v, i|
-                       if i < n
-                         g.yield v
-                       else
-                         raise StopIteration
-                       end
-                     end
-                   end)
-    end
-
-    def take_while(&block)
-      Sequence.new(self) { |yielder, val|
-        if block.call(val)
-          yielder << val
-        else
-          raise StopIteration
-        end
-      }
+    def is_empty?
+      @enumerator.rewind
+      begin
+        @enumerator.peek
+        false
+      rescue
+        true
+      end
     end
 
-    def zip(*args, &block)
-      enums = [self] + args
-      Sequence.new(self) { |yielder, val|
-        ary = enums.map { |e| e.next }
-        if block
-          yielder << block.call(ary)
-        else
-          yielder << ary
-        end
-      }
+    def size
+      @enumerator.count
     end
 
-    def [](n)
-      Sequence.new(self).entries[n]
+    def head
+      @enumerator.first
     end
 
-    alias get []
+    alias first head
 
-    def empty?
-      begin
-        sequence.peek_values.empty?
-      rescue StopIteration
-        true
-      end
-    end
-
-    def head
-      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.entries.first
+    def second
+      tail.head
     end
 
     def head_option
-      sequence.empty? ? none : some(sequence.first)
+      option(head)
     end
 
     def last
-      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.entries.last
+      reverse.head
     end
 
     def last_option
-      sequence.empty? ? none : some(sequence.entries.last)
+      reverse.head_option
     end
 
-    def contains?(value)
-      sequence.empty? ? false : sequence.entries.include?(value)
+    def reverse
+      Sequence.new(Enumerators::reverse(@enumerator))
     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 }
-                   end)
+      unless has_next(@enumerator)
+        raise NoSuchElementException.new
+      end
+      Sequence.new(@enumerator.drop(1))
     end
 
     def init
-      Sequence.new(Sequence::Generator.new do |g|
-                     size = self.count
-                     self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.first(size-1).each { |i| g.yield i }
-                   end)
+      reverse.tail.reverse
     end
 
-    def shuffle
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.entries.shuffle.each { |i| g.yield i }
-                   end)
+    def map(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      Sequence.new(@enumerator.map { |value|
+        block_given? ? block.call(value) : fn.(value)
+      })
     end
 
-    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 = 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
-                     result.each { |i| g.yield i }
-                   end)
-    end
-
-    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)
-                     self.entries.push(target_sequence.entries).flatten.each { |i| g.yield i unless i.is_a?(Empty) }
-                   end)
-    end
-
-    alias << join
-
-    def add(target_sequence)
-      Sequence.new(Sequence::Generator.new do |g|
-                     (self.entries + target_sequence.entries).each { |i| g.yield i }
-                   end)
-    end
-
-    alias + add
-
-    def append(item)
-      Sequence.new(Sequence::Generator.new do |g|
-                     elements = self.entries
-                     elements = elements.reject { |i| i.is_a?(Empty) }
-                     (elements << item).each { |i| g.yield i }
-                   end)
-    end
-
-    def to_seq
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.entries.map { |e| Type.responds(e, :entries); e.entries }.flatten.each { |i| g.yield i }
-                   end)
-    end
-
-    def to_maps(symbolize=true)
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.each_slice(2) do |k, v|
-                       if symbolize
-                         g.yield k.to_s.to_sym => v
-                       else
-                         g.yield k => v
-                       end
-                     end
-                   end)
-    end
-
-    def to_map(symbolize=true)
-      Maps.merge(to_maps(symbolize))
+    def fold(seed, fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      @enumerator.inject(seed) { |accumulator, value|
+        block_given? ? block.call(accumulator, value) : fn.(accumulator, value)
+      }
     end
 
-    def from_pairs
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.entries.map { |e| Type.check(e, Pair::Pair); [e.key, e.value] }.flatten.each { |i| g.yield i }
-                   end)
-    end
+    alias fold_left fold
 
-    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)
+    def fold_right(seed, fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      Enumerators::reverse(@enumerator).inject(seed) { |accumulator, value|
+        block_given? ? block.call(value, accumulator) : fn.(value, accumulator)
+      }
     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)
+    def reduce(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      @enumerator.inject { |accumulator, value|
+        block_given? ? block.call(accumulator, value) : fn.(accumulator, value)
+      }
     end
 
-    def in_pairs
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.each_slice(2) { |k, v| g.yield pair(k, v) }
-                   end)
-    end
+    alias reduce_left reduce
 
-    def to_a
-      execution = {
-          Sequences::Sequence => -> { self.entries.map { |s| s.entries } },
-          Pair::Pair => -> { self.entries.map { |pair| pair.to_map } }
+    def reduce_right(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      Enumerators::reverse(@enumerator).inject { |accumulator, value|
+        block_given? ? block.call(value, accumulator) : fn.(value, accumulator)
       }
-      if self.empty?
-        self.entries
-      else
+    end
 
-        first_item = self.peek_values.first.class
-        execution[first_item].nil? ? self.entries : execution[first_item].call
+    def find(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      @enumerator.rewind
+      while has_next(@enumerator)
+        item = @enumerator.next
+        result = block_given? ? block_pred.call(item) : fn_pred.(item)
+        if result
+          return(some(item))
+        end
       end
+      none
     end
 
-    def update(item)
-      Sequence.new(Sequence::Generator.new do |g|
-                     if item.is_a?(Hash)
-                       self.map do |e|
-                         item.map { |k, v|
-                           raise(UnsupportedMethodException.new, "Tried to call method: #{k} on #{e.class} but method not supported") unless e.respond_to?(k) or e.respond_to?(":#{k}=")
-                           begin
-                             e.send(k, v) if e.respond_to?(k); e
-                           rescue
-                             e.send("#{k}=", v) if e.respond_to?("#{k}="); e
-                           end
-                         }.first
-                       end
-                     else
-                       self.map { item }
-                     end.each { |i| g.yield i }
-                   end)
+    def zip(other)
+      Sequence.new(pair_enumerator(@enumerator, other.enumerator))
     end
 
-    def marshal_dump
-      serialize
+    def zip_with_index
+      Sequences.zip(range_from(0), self)
     end
 
-    def marshal_load(data)
-      Sequence.new(data).deserialize
+    def find_index_of(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      zip_with_index.find(->(pair) { block_given? ? block_pred.call(pair.second) : fn_pred.(pair.second) }).map(->(pair) { pair.first })
     end
 
-    def serialize
-      c = []
-      serializer(c, self.entries)
-      c
+    def take(count)
+      Sequences::take(self, count)
     end
 
-    def deserialize
-      c = []
-      deserializer(c, self.entries)
-      Sequence.new(c)
+    def take_while(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      Sequence.new(@enumerator.take_while { |value| block_given? ? block_pred.call(value) : fn_pred.(value) })
     end
 
-    def all
-      to_a.flatten
+    def drop(count)
+      Sequences::drop(self, count)
     end
 
-    def sorting_by(*attr, &block)
-      if attr.empty?
-        Sequence.new(Sequence::Generator.new do |g|
-                       self.sort_by { |e| block.call(e) }.each { |i| g.yield i }
-                     end)
-      else
-        Sequence.new(Sequence::Generator.new do |g|
-                       self.sort_by { |e| attr.map { |v| e.send(v) } }.each { |i| g.yield i }
-                     end)
-      end
+    def drop_while(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      Sequence.new(@enumerator.drop_while { |value| block_given? ? block_pred.call(value) : fn_pred.(value) })
     end
 
-    def sorting
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.sort.each { |i| g.yield i }
-                   end)
+    def flat_map(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      map(block_given? ? ->(value) { block.call(value) } : fn).flatten
     end
 
-    def get_or_else(index, or_else)
-      blank?(sequence[index]) ? or_else : sequence[index]
+    def flatten
+      Sequence.new(flatten_enumerator(enumerator))
     end
 
-    def get_option(index)
-      blank?(sequence[index]) ? none : some(sequence[index])
+    def sort_by(comparator)
+      Sequences::sort(self, comparator)
     end
 
-    def get_or_throw(index, exception, message='')
-      blank?(sequence[index]) ? raise(exception, message) : sequence[index]
+    def contains?(value)
+      @enumerator.member?(value)
     end
 
-
-    def get_by(pair_key)
-      item = self.filter { |e| e.first == pair_key }.head_option
-      item.is_some? ? item.get.value : none
+    def exists?(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      @enumerator.any? { |value| block_given? ? block_pred.call(value) : fn_pred.(value) }
     end
 
-    def into_hash
-      raise(Exception.new, 'The sequence must contain pairs') unless self.head.kind_of?(Pair::Pair)
-      Maps.merge(self.map { |p| {p.key => p.value} })
+    def for_all?(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      @enumerator.all? { |value| block_given? ? block_pred.call(value) : fn_pred.(value) }
     end
 
-    def drop_nil
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.reject { |e| e.nil? }.each { |i| g.yield i }
-                   end)
+    def filter(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      Sequence.new(@enumerator.select { |value| block_given? ? block_pred.call(value) : fn_pred.(value) })
     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.exec.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
+    def reject(fn_pred=nil, &block_pred)
+      assert_funcs(fn_pred, block_given?)
+      filter(Predicates::not(block_given? ? ->(value) { block_pred.call(value) } : fn_pred))
     end
 
-    def each_concurrently(options={}, &block)
-      Parallel.each(self.entries, options) { |val| block.call(val) }
+    def group_by(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      groups = @enumerator.group_by { |value| block_given? ? block.call(value) : fn.(value) }
+      Sequence.new(groups.to_a.map { |group| Group.new(group[0], group[1].lazy) }.lazy)
     end
 
-    def cycle
-      Sequence.new(Sequence::Generator.new do |g|
-                     self.entries.cycle.each { |i| g.yield i }
-                   end)
+    def each(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      @enumerator.each { |value| block_given? ? block.call(value) : fn.(value) }
     end
 
-    protected
-
-    def sequence
-      Sequence.new(self)
+    def map_concurrently(fn=nil, &block)
+      assert_funcs(fn, block_given?)
+      Sequences::map_concurrently(self, block_given? ? ->(value) { block.call(value) } : fn)
     end
 
-    def blank?(item)
-      item.respond_to?(:empty?) ? item.empty? : !item
+    def realise
+      Sequence.new(@enumerator.to_a.lazy)
     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
+    def <=>(other)
+      @enumerator.entries <=> other.enumerator.entries
     end
 
-    def deserializer(container, data)
-      data.flatten.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
-            container << entry[:values].map{|e| {e[:values].first => e[:values].last } }.reduce({}) { |a, b| a.merge(b) }
-          else
-            container << entry[:type].send(:new, entry[:values])
-          end
-        else
-          container << entry
-        end
-      end
+    private
+    def assert_funcs(fn, block_given)
+      raise 'Cannot pass both lambda and block expressions' if !fn.nil? && block_given
     end
-
   end
 
-  class Empty < Sequence
-
-    def initialize(obj=[], &block)
-      super(obj) { |yielder|
-        begin
-          obj.each { |x|
-            if block
-              block.call(yielder, x)
-            else
-              yielder << x
-            end
-          }
-        rescue StopIteration
-        end
-      }
-    end
-
+  def group(key, enumerator)
+    Group.new(key, enumerator)
   end
 
-end
-
-
-
-
-
-
-
-
-
-
+  class Group < Sequence
+    include Comparable
+    attr_reader :key
 
+    def initialize(key, enumerator)
+      super(enumerator)
+      @key = key
+    end
 
+    def <=>(other)
+      (@key <=> other.key) <=> (enumerator.entries<=>(other.enumerator.entries))
+    end
+  end
 
+  private
 
+  EMPTY=Sequence.new([].lazy)
 
+  def pair_enumerator(left, right)
+    Enumerator.new do |y|
+      left.rewind
+      right.rewind
+      loop do
+        y << pair(left.next, right.next)
+      end
+    end.lazy
+  end
+end