totally_lazy 0.0.20 → 0.1.0

data/lib/strings.rb

@@ -0,0 +1,13 @@
+module Strings
+  def join(separator='')
+    ->(a, b) { "#{a}#{separator}#{b}" }
+  end
+
+  def to_characters
+    ->(string) { Sequence.new(character_enumerator(string)) }
+  end
+
+  def to_string
+    ->(value) { value.to_s }
+  end
+end

data/lib/totally_lazy.rb

@@ -1,170 +1,19 @@
-require_relative 'type_check'
-require 'set'
-require 'prime'
-require_relative 'sequence'
-require_relative 'pair'
+require_relative 'comparators'
+require_relative 'enumerators'
+require_relative 'functions'
+require_relative 'numbers'
 require_relative 'option'
-require_relative 'functor'
-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'
-require_relative 'utils'
+require_relative 'pair'
+require_relative 'predicates'
+require_relative 'sequence'
+require_relative 'strings'
 
-include Sequences
+include Comparators
+include Enumerators
+include Functions
+include Numbers
 include Option
 include Pair
 include Predicates
-include Predicates::Numbers
-include Predicates::Conversions
-include Predicates::Compare
-include Predicates::Where
-include Generators
-include Any
-include Maps
-
-
-# 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
-
-
-# p Seq.range(1,20).filter(odd).update(10).to_a
-
-# require 'ostruct'
-# #
-# #
-# # p Seq.repeat(->{OpenStruct.new(name:Any.string(5),age:Any.int(2))}).take(100000).update(age:11,name:'woops').take(1000).head
-# #
-# # p sequence({apple:1,pear:2}).each_slice(2).map{|s| [s[0],s[1]]}.to_a
-#
-# a = Seq.range(1,10).map{|n| OpenStruct.new(name:Any.string(5),age:Any.int(2)) }.to_a
-#
-# orig = sequence(a)
-#
-# updates = orig.filter(where(age:greater_than(70))).update(age:2)
-#
-# p orig.count
-# p updates.count
-
-# p where(id:equals(1)).as_map.entries
-
-#
-
-# p sequence(1,2,3,4).filter(where(is equal_to(2))).entries
-
-# p where(is equal_to 2).predicates.head.value
-
-
-# p sequence(1,2,3,4,5,6).map(as_string).to_a
-
-
-
-
-
-
-
-
-
-
-
+include Sequences
+include Strings

data/readme.md

@@ -0,0 +1,2 @@
+totally_lazy [![Build Status](https://travis-ci.org/raymanoz/totally_lazy.svg?branch=master)](https://travis-ci.org/raymanoz/totally_lazy)
+============

data/spec/option_spec.rb

@@ -1,186 +1,10 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require_relative 'spec_helper'
 
 describe 'Option' do
-
-  it 'should support contains' do
-    expect(option(1).contains(1)).to eq(true)
-  end
-
-  it 'should support is alias' do
-    pending('support is alias')
-    pass
-  end
-
-  it 'should support exists' do
-    pending('exists')
-    pass
-  end
-
-  it 'should support join' do
-    expect(option(1).join(sequence(2, 3))).to eq(sequence(1, 2, 3))
-  end
-
-  it 'should get value of some' do
-    expect(option(1).get).to eq(1)
-  end
-
-  it 'should not get value of none' do
-    pending('not get none')
-    pass
-  end
-
-  it 'should support each' do
-    result = 0
-    option(1).each{|i| result=i+1}
-    expect(result).to eq(2)
-    result=0
-    none.each{|i| result=100}
-    expect(result).to eq(0)
-  end
-
-  it 'should get or else' do
-    expect(option(1).get_or_else(2)).to eq(1)
-    expect(option(empty).get_or_else(2)).to eq(2)
-  end
-
-  it 'should get or nil' do
-    expect(option(1).get_or_nil).to eq(1)
-    expect(option(empty).get_or_nil).to eq(nil)
-  end
-
-  it 'should get or raise exception' do
-    expect(option(1).get_or_throw(Exception)).to eq(1)
-    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(1))
-    expect(none.to_seq).to eq(empty)
-  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 a head option' do
-    expect(option({:name => 'apples'}).head_option).to eq(some({:name => 'apples'}))
-    expect(option(empty).head_option).to eq(none)
-  end
-
-  it 'should return false for defined on none' do
-    expect(option(empty).defined?).to eq(false)
+  it 'should support is_empty? & is_defined?' do
+    expect(some(1).is_empty?).to eq(false)
+    expect(some(1).is_defined?).to eq(true)
+    expect(none.is_empty?).to eq(true)
+    expect(none.is_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 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
-
-  it 'should support select' do
-    expect(option(2).filter(even)).to eq(some(2))
-    expect(option(2).find_all(even)).to eq(some(2))
-    expect(option(2).select(even)).to eq(some(2))
-    expect(option(2).filter(&:even?)).to eq(some(2))
-    expect(option(2).filter{|v| v == 2}).to eq(some(2))
-    expect(option(nil).filter(even)).to eq(none)
-  end
-
-  it 'should support map' do
-    expect(option([{apple:1,pear:2},{melon:3}]).map{|h| h}).to eq(some([{apple:1,pear:2},{melon:3}]))
-    expect(option({apple:1,pear:2})).to eq(some({apple:1,pear:2}))
-    expect(option(1).map(as_string)).to eq(some('1'))
-    expect(option(1).collect(as_string)).to eq(some('1'))
-    expect(option(sequence(1, 2, 3)).map { |s| s.entries }).to eq(some([1, 2, 3]))
-    expect(option(nil).map(as_string)).to eq(none)
-  end
-
-  it 'should support reject' do
-    expect(option(2).reject(odd)).to eq(some(2))
-    expect(option(2).unfilter(odd)).to eq(some(2))
-    expect(option(2).reject(&:odd?)).to eq(some(2))
-    expect(option(2).reject{|v| v == 1}).to eq(some(2))
-    expect(option(nil).reject(odd)).to eq(none)
-  end
-
-  it 'should support grep' do
-    expect(option('apple').grep(/p/)).to eq(some('apple'))
-    expect(option(nil).grep(/p/)).to eq(none)
-  end
-
-  it 'should support drop' do
-    expect(option(1).drop(1)).to eq(none)
-    expect(option(nil).drop(1)).to eq(none)
-  end
-
-  it 'should support drop_while' do
-    expect(option(sequence(1,7)).drop_while { |n| n < 5 }).to eq(some(1))
-    expect(option(nil).drop_while { |n| n < 5 }).to eq(none)
-  end
-
-  it 'should support take' do
-    expect(option(1).take(2)).to eq(some(1))
-    expect(option(nil).take(2)).to eq(none)
-  end
-
-  it 'should support take_while' do
-    expect(option(sequence(1,7)).take_while { |n| n < 5 }).to eq(some(1))
-    expect(option(nil).take_while { |n| n < 5 }).to eq(none)
-  end
-
-  it 'should support flat_map' do
-    expect(option(nil).flat_map{|v| v.first}).to eq(none)
-    expect(option(1).flat_map{|v| some(2)}).to eq(some(2))
-    expect(option(1).flat_map{|v| none}).to eq(none)
-  end
-
 end