totally_lazy 0.1.22 → 0.1.23

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWZiZTk0N2M1NTg1MjUxNjY2ODNlNWJhMDU4NjkyYTQzMzUwZTQ5Ng==
+    ZjQ0ZWZiYjdhYjFkODdjOTU3M2IzMTQ0MGY0YmYxMzUwMjI0OWQ0Ng==
   data.tar.gz: !binary |-
-    Nzc1ZjRlMjM0YzYxZTcyNzcxZGIxNmNlODE3MjkxN2ZkMmZjZDJhOQ==
+    Mzg2NzRhNzgwZDYzODE4M2M4ZmY4OTZlOWRkMjViNDNlY2M2NjA4OQ==
 SHA512:
   metadata.gz: !binary |-
-    MDAyYTdjNDMwNjU0MmIwOGVkYjZkNjA5ODdjNWRkODQzZjJjNmViYzM3OTAy
-    NDEyMTgzYTc4YTJmZDYxMDdlYzg2MjBiNTMyNGZkNTJkMjhiOGEwNGI1Yzc4
-    NTliZTZjNzkxZTQ0N2U2MTk1NmNlZGY4N2MxYjY2MTQ0MGRmNGU=
+    Y2M0MWVjYTEzOWFmZWI4MWQzNjFiMWI5MjkzNjY0NjkyYzMwYmE3MzM2YjNk
+    ZTgyOGU1MGY5NGQwNzk5ZTViMzFlZjc0NDE4YTIwNDg3ZjgwMjNiNzQwYTU5
+    NTc5NDBiNjM3MTdhZDM2MzQ2ODA4YzdjOWMyZDMwOWJkNTM0MGY=
   data.tar.gz: !binary |-
-    NjlhNjBmNDQ5Yjg4MzQzNTI5OTIwNjBlZTdmYWNmNzQ2YjQyY2MwMGU3Njk5
-    NDY4NjhhMDJiNWQzYTg3MTdmZTFhNGI4NWY1MWFiY2E5ZjQ0MmU0NmM3OGRl
-    N2M0MjdjYzBjZmYwODU4OTY1ZDQ3NDFjYzQzYzM2YjFkYjY3YWE=
+    ZjE3ZTJmMzg1NzViZjY0ZGNiMmJlNGU2MDIwZjY4MDJlY2NjYjBkM2U4YjNh
+    MDQ2ZWU5YmQ1ZjkwYTEzNDYzYWE0YjQ5MzYxZDdjNGZmMWJmZmU5NzdkMDNl
+    NGI1YjQ5YWIxMDZmYWNlMzFhYjdjZGY4ZGM0MTBjZDQwYzMyNmI=

data/Rakefile

@@ -36,7 +36,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = 'Port of java functional library totallylazy to ruby'
   gem.email = 'rbarlow@raymanoz.com'
   gem.authors = ['Raymond Barlow', 'Kingsley Hendrickse']
-  gem.required_ruby_version = '2.0.0'
+  gem.required_ruby_version = '>= 2.0.0'
 end
 Jeweler::RubygemsDotOrgTasks.new
 

data/lib/totally_lazy.rb

@@ -1,19 +1,19 @@
-require_relative 'comparators'
-require_relative 'enumerators'
-require_relative 'functions'
-require_relative 'numbers'
-require_relative 'option'
-require_relative 'pair'
-require_relative 'predicates'
-require_relative 'sequence'
-require_relative 'strings'
+require_relative 'totally_lazy/comparators'
+require_relative 'totally_lazy/enumerators'
+require_relative 'totally_lazy/functions'
+require_relative 'totally_lazy/numbers'
+require_relative 'totally_lazy/option'
+require_relative 'totally_lazy/pair'
+require_relative 'totally_lazy/predicates'
+require_relative 'totally_lazy/sequence'
+require_relative 'totally_lazy/strings'
 
 include Comparators
 include Enumerators
 include Functions
 include Numbers
-include Option
-include Pair
+include Options
+include Pairs
 include Predicates
 include Sequences
 include Strings

data/lib/{comparators.rb → totally_lazy/comparators.rb}

@@ -1,4 +1,5 @@
 module Comparators
+  private
   def ascending
     -> (a,b) { a <=> b }
   end

data/lib/{enumerators.rb → totally_lazy/enumerators.rb}

@@ -1,5 +1,6 @@
 module Enumerators
-  def reverse(e)
+  private
+  def reverse_enumerator(e)
     e.reverse_each
   end
 
@@ -12,7 +13,7 @@ module Enumerators
     end
   end
 
-  def enumerator(fn, init)
+  def enumerator_of(fn, init)
     Enumerator.new do |y|
       value = init
       y << value
@@ -23,10 +24,6 @@ module Enumerators
     end.lazy
   end
 
-  def repeat_enumerator(value)
-    Enumerators.repeat_fn_enumerator(returns(value))
-  end
-
   def repeat_fn_enumerator(fn)
     Enumerator.new do |y|
       loop do
@@ -35,6 +32,10 @@ module Enumerators
     end.lazy
   end
 
+  def repeat_enumerator(value)
+    repeat_fn_enumerator(returns(value))
+  end
+
   def character_enumerator(string)
     Enumerator.new do |y|
       index = 0

data/lib/{functions.rb → totally_lazy/functions.rb}

@@ -1,19 +1,8 @@
 require 'concurrent/executors'
 require 'concurrent/promise'
 
-class Proc
-  def optional
-    ->(value) {
-      begin
-        option(self.(value))
-      rescue
-        none
-      end
-    }
-  end
-end
-
 module Functions
+  private
   def monoid(fn, id)
     fn.define_singleton_method(:identity) do
       id
@@ -45,6 +34,8 @@ module Functions
     -> { raise e }
   end
 
+  alias call_throws call_raises
+
   def call
     ->(fn) { fn.() }
   end

data/lib/{numbers.rb → totally_lazy/numbers.rb}

@@ -1,4 +1,5 @@
 module Numbers
+  private
   def sum
     monoid(->(a, b) { a + b }, 0)
   end
@@ -28,7 +29,7 @@ module Numbers
   end
 
   def range_from(start)
-    Sequence.new(Enumerators::enumerator(increment, start))
+    Sequence.new(enumerator_of(increment, start))
   end
 
   def range(from, to)

data/lib/totally_lazy/option.rb

@@ -0,0 +1,191 @@
+require_relative 'lambda_block'
+
+class Proc
+  def optional
+    ->(value) {
+      begin
+        Option.option(self.(value))
+      rescue
+        Option.none
+      end
+    }
+  end
+end
+
+module Options
+  private
+  def option(value)
+    Option.option(value)
+  end
+
+  def some(value)
+    Option.some(value)
+  end
+
+  def none
+    Option.none
+  end
+end
+
+class Option
+  def self.option(value)
+    value.nil? ? none : some(value)
+  end
+
+  def self.some(value)
+    Some.new(value)
+  end
+
+  def self.none
+    NONE
+  end
+
+  def is_defined?
+    !is_empty?
+  end
+
+  def is?(fn_pred=nil, &block_pred)
+    assert_funcs(fn_pred, block_given?)
+    exists?(block_given? ? ->(value) { block_pred.call(value) } : fn_pred)
+  end
+
+  def flatten
+    flat_map(identity)
+  end
+end
+
+class Some < Option
+  include Comparable
+  include LambdaBlock
+
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def contains?(value)
+    @value == value
+  end
+
+  def exists?(fn_pred=nil, &block_pred)
+    assert_funcs(fn_pred, block_given?)
+    block_given? ? block_pred.call(@value) : fn_pred.(@value)
+  end
+
+  def map(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    option(block_given? ? block.call(@value) : fn.(@value))
+  end
+
+  def flat_map(fn=nil, &block) # function should return an option
+    assert_funcs(fn, block_given?)
+    block_given? ? block.call(@value) : fn.(@value)
+  end
+
+  def fold(seed, fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    block_given? ? block.call(seed, @value) : fn.(seed, @value)
+  end
+
+  alias fold_left fold
+
+  def is_empty?
+    false
+  end
+
+  def size
+    1
+  end
+
+  def get
+    @value
+  end
+
+  def get_or_else(value_or_fn=nil, &block)
+    assert_funcs(value_or_fn, block_given?)
+    get
+  end
+
+  alias or_else get_or_else
+
+  def enumerator
+    Enumerator.new { |y|
+      y << @value
+      raise StopIteration.new
+    }
+  end
+
+  def <=>(other)
+    @value <=> other.value
+  end
+
+  def to_s
+    "Some(#{value})"
+  end
+end
+
+class None < Option
+  include LambdaBlock
+
+  def is_empty?
+    true
+  end
+
+  def contains?(value)
+    false
+  end
+
+  def exists?(fn_pred=nil, &block_pred)
+    assert_funcs(fn_pred, block_given?)
+    false
+  end
+
+  def map(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    none
+  end
+
+  def flat_map(fn=nil, &block) # function should return an option
+    assert_funcs(fn, block_given?)
+    none
+  end
+
+  def fold(seed, fn=nil &block)
+    assert_funcs(fn, block_given?)
+    seed
+  end
+
+  alias fold_left fold
+
+  def size
+    0
+  end
+
+  def get
+    raise NoSuchElementException.new
+  end
+
+  def get_or_else(value_or_fn=nil, &block)
+    assert_funcs(value_or_fn, block_given?)
+    if (value_or_fn.respond_to? :call) || block_given?
+      block_given? ? block.call : value_or_fn.()
+    else
+      value_or_fn
+    end
+  end
+
+  alias or_else get_or_else
+
+  def enumerator
+    Enumerator.new { |y|
+      raise StopIteration.new
+    }
+  end
+
+  def to_s
+    'None'
+  end
+end
+
+NONE=None.new

data/lib/totally_lazy/pair.rb

@@ -0,0 +1,39 @@
+module Pairs
+  private
+  def pair(first, second)
+    Pair.new(first, second)
+  end
+end
+
+class Pair
+  include Comparable
+
+  def initialize(first, second)
+    @first = -> { first }
+    @second = -> { second }
+  end
+
+  def first
+    @first.()
+  end
+
+  def second
+    @second.()
+  end
+
+  def enumerator
+    Enumerator.new { |y|
+      y << first
+      y << second
+      raise StopIteration.new
+    }
+  end
+
+  def <=>(other)
+    (first <=> other.first) <=> (second <=> other.second)
+  end
+
+  def to_s
+    "(#{first}, #{second})"
+  end
+end

data/lib/{predicates.rb → totally_lazy/predicates.rb}

@@ -1,5 +1,6 @@
 module Predicates
-  def not(pred)
+  private
+  def _not(pred)
     -> (bool) { !pred.(bool) }
   end
 end

data/lib/totally_lazy/sequence.rb

@@ -0,0 +1,327 @@
+require_relative 'lambda_block'
+
+class NoSuchElementException < RuntimeError
+end
+
+module Sequences
+  def empty
+    Sequence.empty
+  end
+
+  def sequence(*items)
+    Sequence.sequence(*items)
+  end
+
+  def drop(sequence, count)
+    Sequence.drop(sequence, count)
+  end
+
+  def sort(sequence, comparator=ascending)
+    Sequence.sort(sequence, comparator)
+  end
+
+  def map_concurrently(sequence, fn=nil, &block)
+    Sequence.map_concurrently(sequence, block_given? ? ->(value) { block.call(value) } : fn)
+  end
+
+  def group(key, enumerator)
+    Group.new(key, enumerator)
+  end
+
+  def repeat(item)
+    Sequence.new(repeat_enumerator(item))
+  end
+
+  def repeat_fn(item)
+    Sequence.new(repeat_fn_enumerator(item))
+  end
+
+  private
+
+  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
+
+class Sequence
+  include Comparable
+  include LambdaBlock
+
+  attr_reader :enumerator
+
+  def self.map_concurrently(sequence, fn=nil, &block)
+    call_concurrently(sequence.map(defer_return(block_given? ? ->(value) { block.call(value) } : fn)))
+  end
+
+  def self.sort(sequence, comparator=ascending)
+    Sequence.new(sequence.enumerator.sort { |a, b| comparator.(a, b) }.lazy)
+  end
+
+  def self.drop(sequence, count)
+    Sequence.new(sequence.enumerator.drop(count))
+  end
+
+  def self.repeat(item)
+    Sequence.new(repeat_enumerator(item))
+  end
+
+  def self.repeat_fn(item)
+    Sequence.new(repeat_fn_enumerator(item))
+  end
+
+  def self.take(sequence, count)
+    Sequence.new(sequence.enumerator.take(count))
+  end
+
+  def self.zip(left, right)
+    left.zip(right)
+  end
+
+
+  def self.sequence(*items)
+    if items.first.nil?
+      empty
+    else
+      Sequence.new(items.lazy)
+    end
+  end
+
+  def self.empty
+    EMPTY
+  end
+
+  def initialize(enumerator)
+    raise "Sequence only accepts Enumerator::Lazy, not #{enumerator.class}" unless (enumerator.class == Enumerator::Lazy)
+    @enumerator = enumerator
+  end
+
+  def is_empty?
+    @enumerator.rewind
+    begin
+      @enumerator.peek
+      false
+    rescue
+      true
+    end
+  end
+
+  def size
+    @enumerator.count
+  end
+
+  def head
+    @enumerator.first
+  end
+
+  alias first head
+
+  def second
+    tail.head
+  end
+
+  def head_option
+    option(head)
+  end
+
+  def last
+    reverse.head
+  end
+
+  def last_option
+    reverse.head_option
+  end
+
+  def reverse
+    Sequence.new(reverse_enumerator(@enumerator))
+  end
+
+  def tail
+    unless has_next(@enumerator)
+      raise NoSuchElementException.new
+    end
+    Sequence.new(@enumerator.drop(1))
+  end
+
+  def init
+    reverse.tail.reverse
+  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 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
+
+  alias fold_left fold
+
+  def fold_right(seed, fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    reverse_enumerator(@enumerator).inject(seed) { |accumulator, value|
+      block_given? ? block.call(value, accumulator) : fn.(value, accumulator)
+    }
+  end
+
+  def reduce(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    _fn = block_given? ? ->(a, b) { block.call(a, b) } : fn
+    accumulator = seed(@enumerator, fn)
+    while has_next(@enumerator)
+      accumulator = _fn.(accumulator, @enumerator.next)
+    end
+    accumulator
+  end
+
+  alias reduce_left reduce
+
+  def reduce_right(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    _fn = block_given? ? ->(a, b) { block.call(a, b) } : fn
+    reversed = reverse_enumerator(@enumerator)
+    accumulator = seed(reversed, fn)
+    while has_next(reversed)
+      accumulator = _fn.(reversed.next, accumulator)
+    end
+    accumulator
+  end
+
+  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 zip(other)
+    Sequence.new(pair_enumerator(@enumerator, other.enumerator))
+  end
+
+  def zip_with_index
+    Sequence.zip(range_from(0), self)
+  end
+
+  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 take(count)
+    Sequence.take(self, count)
+  end
+
+  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 drop(count)
+    Sequence.drop(self, count)
+  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 flat_map(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    map(block_given? ? ->(value) { block.call(value) } : fn).flatten
+  end
+
+  def flatten
+    Sequence.new(flatten_enumerator(enumerator))
+  end
+
+  def sort_by(comparator)
+    Sequence.sort(self, comparator)
+  end
+
+  def contains?(value)
+    @enumerator.member?(value)
+  end
+
+  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 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 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 reject(fn_pred=nil, &block_pred)
+    assert_funcs(fn_pred, block_given?)
+    filter(_not(block_given? ? ->(value) { block_pred.call(value) } : fn_pred))
+  end
+
+  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 each(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    @enumerator.each { |value| block_given? ? block.call(value) : fn.(value) }
+  end
+
+  def map_concurrently(fn=nil, &block)
+    assert_funcs(fn, block_given?)
+    Sequence.map_concurrently(self, block_given? ? ->(value) { block.call(value) } : fn)
+  end
+
+  def realise
+    Sequence.new(@enumerator.to_a.lazy)
+  end
+
+  def <=>(other)
+    @enumerator.entries <=> other.enumerator.entries
+  end
+
+  private
+  def seed(enumerator, fn)
+    enumerator.rewind
+    !fn.nil? && fn.respond_to?(:identity) ? fn.identity : enumerator.next
+  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
+
+EMPTY=Sequence.new([].lazy)

data/lib/{strings.rb → totally_lazy/strings.rb}

@@ -1,4 +1,5 @@
 module Strings
+  private
   def join(separator='')
     monoid(->(a, b) { "#{a}#{separator}#{b}" }, '')
   end

data/spec/option_spec.rb

@@ -1,6 +1,7 @@
 require_relative 'spec_helper'
 
 describe 'Option' do
+
   it 'should support is_empty? & is_defined?' do
     expect(some(1).is_empty?).to eq(false)
     expect(some(1).is_defined?).to eq(true)
@@ -46,7 +47,7 @@ describe 'Option' do
 
   it 'should support flat_map' do
     expect(some(4).flat_map(divide(2).optional)).to eq(some(2))
-    expect(some(4).flat_map{ |v| divide(2).optional.(v) }).to eq(some(2))
+    expect(some(4).flat_map { |v| divide(2).optional.(v) }).to eq(some(2))
     expect(some(4).flat_map(divide(0).optional)).to eq(none)
     expect(none.flat_map(constant(none))).to eq(none)
     expect(none.flat_map(some(4))).to eq(none)
@@ -65,16 +66,26 @@ describe 'Option' do
 
   it 'should support get' do
     expect(some(1).get).to eq(1)
-    expect{none.get}.to raise_error(NoSuchElementException)
+    expect { none.get }.to raise_error(NoSuchElementException)
   end
 
-  it 'should support get_or_else (aka or_else)' do
-    expect(some(1).get_or_else(2)).to eq(1)
+  it 'should support get_or_else with value (aka or_else)' do
+    expect(Option::some(1).get_or_else(2)).to eq(1)
+    expect(some(1).or_else(2)).to eq(1)
     expect(none.get_or_else(2)).to eq(2)
     expect(option(1).get_or_else(2)).to eq(1)
     expect(option(nil).get_or_else(2)).to eq(2)
   end
 
+  it 'should support get_or_else with a function' do
+    expect(some(1).get_or_else(returns(2))).to eq(1)
+    expect(some(1).get_or_else { 2 }).to eq(1)
+    expect(none.get_or_else(returns(2))).to eq(2)
+    expect(option(1).get_or_else(returns(2))).to eq(1)
+    expect(option(nil).get_or_else(returns(2))).to eq(2)
+    expect { option(nil).get_or_else(call_raises(RuntimeError.new)) }.to raise_error(RuntimeError)
+  end
+
   it 'should raise exception if you try to use both lambda and block' do
     expect { some(1).exists?(->(a) { a == 1 }) { |b| b == 2 } }.to raise_error(RuntimeError)
     expect { none.exists?(->(a) { a == 1 }) { |b| b == 2 } }.to raise_error(RuntimeError)
@@ -86,7 +97,8 @@ describe 'Option' do
     expect { none.fold_left(0, ->(a, b) { a+b }) { |a, b| a+b } }.to raise_error(RuntimeError)
     expect { some(1).map(->(v) { v.to_s }) { |v| v.to_s } }.to raise_error(RuntimeError)
     expect { none.map(->(v) { v.to_s }) { |v| v.to_s } }.to raise_error(RuntimeError)
-    expect { some(4).flat_map(divide(2).optional){ |v| divide(2).optional.(v) } }.to raise_error(RuntimeError)
+    expect { some(4).flat_map(divide(2).optional) { |v| divide(2).optional.(v) } }.to raise_error(RuntimeError)
+    expect { some(1).get_or_else(returns(2)) { |value| 3 } }.to raise_error(RuntimeError)
   end
 
 end

data/spec/sequence_spec.rb

@@ -1,6 +1,7 @@
 require_relative 'spec_helper'
 
 describe 'Sequence' do
+
   it 'should create empty sequence when iterable is nil' do
     expect(sequence(nil)).to eq(empty)
   end
@@ -78,7 +79,7 @@ describe 'Sequence' do
   end
 
   it 'should support composite predicates' do
-    expect(sequence(1, 2, 3, 4).filter(Predicates::not(even))).to eq(sequence(1, 3))
+    expect(sequence(1, 2, 3, 4).filter(_not(even))).to eq(sequence(1, 3))
   end
 
   it 'should support reject' do
@@ -187,8 +188,8 @@ describe 'Sequence' do
   end
 
   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))
+    expect(repeat(10).take(5)).to eq(sequence(10, 10, 10, 10, 10))
+    expect(repeat_fn(returns(20)).take(5)).to eq(sequence(20, 20, 20, 20, 20))
   end
 
   it 'should support is_empty?' do

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rspec'
-require 'totally_lazy'
+require_relative '../lib/totally_lazy'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.1.22
+  version: 0.1.23
 platform: ruby
 authors:
 - Raymond Barlow
@@ -154,17 +154,17 @@ files:
 - Rakefile
 - VERSION
 - contributors.txt
-- lib/comparators.rb
-- lib/enumerators.rb
-- lib/functions.rb
-- lib/lambda_block.rb
-- lib/numbers.rb
-- lib/option.rb
-- lib/pair.rb
-- lib/predicates.rb
-- lib/sequence.rb
-- lib/strings.rb
 - lib/totally_lazy.rb
+- lib/totally_lazy/comparators.rb
+- lib/totally_lazy/enumerators.rb
+- lib/totally_lazy/functions.rb
+- lib/totally_lazy/lambda_block.rb
+- lib/totally_lazy/numbers.rb
+- lib/totally_lazy/option.rb
+- lib/totally_lazy/pair.rb
+- lib/totally_lazy/predicates.rb
+- lib/totally_lazy/sequence.rb
+- lib/totally_lazy/strings.rb
 - readme.md
 - spec/option_spec.rb
 - spec/sequence_spec.rb
@@ -180,7 +180,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement

data/lib/option.rb

@@ -1,156 +0,0 @@
-require_relative 'lambda_block'
-
-module Option
-  include LambdaBlock
-
-  def option(value)
-    value.nil? ? none : some(value)
-  end
-
-  def some(value)
-    Some.new(value)
-  end
-
-  def none
-    NONE
-  end
-
-  class Option
-    def is_defined?
-      !is_empty?
-    end
-  end
-
-  def is?(fn_pred=nil, &block_pred)
-    assert_funcs(fn_pred, block_given?)
-    exists?(block_given? ? ->(value) { block_pred.call(value) } : fn_pred)
-  end
-
-  def flatten
-    flat_map(identity)
-  end
-
-  class Some < Option
-    include Comparable
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def contains?(value)
-      @value == value
-    end
-
-    def exists?(fn_pred=nil, &block_pred)
-      assert_funcs(fn_pred, block_given?)
-      block_given? ? block_pred.call(@value) : fn_pred.(@value)
-    end
-
-    def map(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      option(block_given? ? block.call(@value) : fn.(@value))
-    end
-
-    def flat_map(fn=nil, &block) # function should return an option
-      assert_funcs(fn, block_given?)
-      block_given? ? block.call(@value) : fn.(@value)
-    end
-
-    def fold(seed, fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      block_given? ? block.call(seed, @value) : fn.(seed, @value)
-    end
-
-    alias fold_left fold
-
-    def is_empty?
-      false
-    end
-
-    def size
-      1
-    end
-
-    def get
-      @value
-    end
-
-    def get_or_else(value)
-      get
-    end
-
-    def enumerator
-      Enumerator.new { |y|
-        y << @value
-        raise StopIteration.new
-      }
-    end
-
-    def <=>(other)
-      @value <=> other.value
-    end
-
-    def to_s
-      "Some(#{value})"
-    end
-  end
-
-  class None < Option
-    def is_empty?
-      true
-    end
-
-    def contains?(value)
-      false
-    end
-
-    def exists?(fn_pred=nil, &block_pred)
-      assert_funcs(fn_pred, block_given?)
-      false
-    end
-
-    def map(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      none
-    end
-
-    def flat_map(fn=nil, &block) # function should return an option
-      assert_funcs(fn, block_given?)
-      none
-    end
-
-    def fold(seed, fn=nil &block)
-      assert_funcs(fn, block_given?)
-      seed
-    end
-
-    alias fold_left fold
-
-    def size
-      0
-    end
-
-    def get
-      raise NoSuchElementException.new
-    end
-
-    def get_or_else(value)
-      value
-    end
-
-    alias or_else get_or_else
-
-    def enumerator
-      Enumerator.new { |y|
-        raise StopIteration.new
-      }
-    end
-
-    def to_s
-      'None'
-    end
-  end
-
-  NONE=None.new
-end

data/lib/pair.rb

@@ -1,40 +0,0 @@
-module Pair
-
-  def pair(first, second)
-    Pair.new(first, second)
-  end
-
-  class Pair
-    include Comparable
-
-    def initialize(first, second)
-      @first = -> { first }
-      @second = -> { second }
-    end
-
-    def first
-      @first.()
-    end
-
-    def second
-      @second.()
-    end
-
-    def enumerator
-      Enumerator.new { |y|
-        y << first
-        y << second
-        raise StopIteration.new
-      }
-    end
-
-    def <=>(other)
-      (first <=> other.first) <=> (second <=> other.second)
-    end
-
-    def to_s
-      "(#{first}, #{second})"
-    end
-  end
-
-end

data/lib/sequence.rb

@@ -1,298 +0,0 @@
-require_relative 'lambda_block'
-
-class NoSuchElementException < RuntimeError
-end
-
-module Sequences
-  def empty
-    EMPTY
-  end
-
-  def sequence(*items)
-    if items.first.nil?
-      empty
-    else
-      Sequence.new(items.lazy)
-    end
-  end
-
-  def zip(left, right)
-    left.zip(right)
-  end
-
-  def take(sequence, count)
-    Sequence.new(sequence.enumerator.take(count))
-  end
-
-  def drop(sequence, count)
-    Sequence.new(sequence.enumerator.drop(count))
-  end
-
-  def repeat(item)
-    Sequence.new(repeat_enumerator(item))
-  end
-
-  def repeat_fn(item)
-    Sequence.new(repeat_fn_enumerator(item))
-  end
-
-  def sort(sequence, comparator=ascending)
-    Sequence.new(sequence.enumerator.sort { |a, b| comparator.(a, b) }.lazy)
-  end
-
-  def map_concurrently(sequence, fn=nil, &block)
-    call_concurrently(sequence.map(defer_return(block_given? ? ->(value) { block.call(value) } : fn)))
-  end
-
-  # noinspection RubyTooManyMethodsInspection
-  class Sequence
-    include Comparable
-    include LambdaBlock
-    attr_reader :enumerator
-
-    def initialize(enumerator)
-      raise "Sequence only accepts Enumerator::Lazy, not #{enumerator.class}" unless (enumerator.class == Enumerator::Lazy)
-      @enumerator = enumerator
-    end
-
-    def is_empty?
-      @enumerator.rewind
-      begin
-        @enumerator.peek
-        false
-      rescue
-        true
-      end
-    end
-
-    def size
-      @enumerator.count
-    end
-
-    def head
-      @enumerator.first
-    end
-
-    alias first head
-
-    def second
-      tail.head
-    end
-
-    def head_option
-      option(head)
-    end
-
-    def last
-      reverse.head
-    end
-
-    def last_option
-      reverse.head_option
-    end
-
-    def reverse
-      Sequence.new(Enumerators::reverse(@enumerator))
-    end
-
-    def tail
-      unless has_next(@enumerator)
-        raise NoSuchElementException.new
-      end
-      Sequence.new(@enumerator.drop(1))
-    end
-
-    def init
-      reverse.tail.reverse
-    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 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
-
-    alias fold_left fold
-
-    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 reduce(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      _fn = block_given? ? ->(a, b) { block.call(a, b) } : fn
-      accumulator = seed(@enumerator, fn)
-      while has_next(@enumerator)
-        accumulator = _fn.(accumulator, @enumerator.next)
-      end
-      accumulator
-    end
-
-    alias reduce_left reduce
-
-    def reduce_right(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      _fn = block_given? ? ->(a, b) { block.call(a, b) } : fn
-      reversed = Enumerators::reverse(@enumerator)
-      accumulator = seed(reversed, fn)
-      while has_next(reversed)
-        accumulator = _fn.(reversed.next, accumulator)
-      end
-      accumulator
-    end
-
-    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 zip(other)
-      Sequence.new(pair_enumerator(@enumerator, other.enumerator))
-    end
-
-    def zip_with_index
-      Sequences.zip(range_from(0), self)
-    end
-
-    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 take(count)
-      Sequences::take(self, count)
-    end
-
-    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 drop(count)
-      Sequences::drop(self, count)
-    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 flat_map(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      map(block_given? ? ->(value) { block.call(value) } : fn).flatten
-    end
-
-    def flatten
-      Sequence.new(flatten_enumerator(enumerator))
-    end
-
-    def sort_by(comparator)
-      Sequences::sort(self, comparator)
-    end
-
-    def contains?(value)
-      @enumerator.member?(value)
-    end
-
-    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 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 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 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 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 each(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      @enumerator.each { |value| block_given? ? block.call(value) : fn.(value) }
-    end
-
-    def map_concurrently(fn=nil, &block)
-      assert_funcs(fn, block_given?)
-      Sequences::map_concurrently(self, block_given? ? ->(value) { block.call(value) } : fn)
-    end
-
-    def realise
-      Sequence.new(@enumerator.to_a.lazy)
-    end
-
-    def <=>(other)
-      @enumerator.entries <=> other.enumerator.entries
-    end
-
-    private
-    def seed(enumerator, fn)
-      enumerator.rewind
-      !fn.nil? && fn.respond_to?(:identity) ? fn.identity : enumerator.next
-    end
-  end
-
-  def group(key, enumerator)
-    Group.new(key, enumerator)
-  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