totally_lazy 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eaad07a76c011ba5573c34c69bf011a0a6c83dcf
-  data.tar.gz: 0d6623c562462a5e936b60bcee8d43ea919fa4bf
+  metadata.gz: 01903b7c27ad47c879061f9c243f2d9584f677b4
+  data.tar.gz: aedadff3f94da81d7360577b81a038bc2e59406e
 SHA512:
-  metadata.gz: 9000dde503c5754b186847d11e300de5cc53ea8c48f5a0806ecd3847b3f565870cce50e3f7a330df184a0e2af4fd534bc06dfce1abbcfc5d38571128b87e122d
-  data.tar.gz: 8dc151abd744dbb82190bc7774d431f868cabd9b856a62e275475601e7416cefe053f9e4fb71e50c4f7f6a87c32587a5091481632d244a038b63da84cfea97a4
+  metadata.gz: 3cf69966f72d69ec77ad6fde9de8829b83e5fcd40a73c1daf055e4aff7721db506b6cfb85b966eed8eff1b4b04bce55686ea8f2d30c0989a16671c27567ad045
+  data.tar.gz: e36f76e5bc0999828dd11b5dd622c4af0ce1e04c071df9b9e31eeadac35ccf3231cc298829532b2e82a05508b903cccdc424aa290ccb6f440141bfa1c971ad71

data/README.md

@@ -73,8 +73,87 @@ Iter.range(1,4) # example with Iter: lazily returns 1,2,3,4 with a regular ruby
 Naturally you can combine these operations together:
 
 ```ruby
-option(1).join(sequence(2,3,4)).join(sequence(5,6)).filter(odd).take(2) 
-# lazily returns 1,3
+option(1).join(sequence(2,3,4)).join(sequence(5,6)).filter(odd).take(2) # lazily returns 1,3
 
 Seq.iterate(:+, 1).filter(even).take(2).reduce(:+) # returns 6
-```
+```
+
+### Predicates
+
+You can supply basic predicates as follows:
+
+##### numbers
+
+    sequence(1,2,3).filter(even) # returns 2
+
+##### conversions
+
+    sequence(1,2,3).map(as_string) # returns ["1","2","3"]
+
+##### comparisons
+
+    sequence(1,2,3).filter(equals(2) # return 2
+
+##### where - for self or objects
+
+**using self**
+
+When the predicate applies to an item in the sequence you use the **is** keyword with *where* to indicate the operation is on *self*
+
+    sequence(1,2,3).filter(where is greater_than 2)
+
+**using objects**
+
+When the predicate applies to a method on an object in the sequence then you supply hashmap of method_name:predicate (without using *is*)
+
+    sequence(pair(1,2),pair(3,4)).filter(where key:greater_than(3))
+
+(pair has methods key and value)
+
+##### Regex
+
+You can use a regex predicate
+
+   sequence("apple","pear").filter(matches(/app/))
+   sequence(pair("apple",1),pair("pear",2)).filter(where(key:matches(/app/)))
+
+#### Custom Predicates
+
+Writing a custom predicate is very easy and there are 3 built in helpers:
+
+* simple_predicate
+* value predicate
+* self predicate
+
+##### simple_predicate
+
+For example:
+
+    def as_uppercase
+      simple_predicate(:as_uppercase, -> (v) { v.upcase })
+    end
+
+    sequence("apple","pear").map(as_uppercase) # returns ["APPLE","PEAR"]
+
+##### value_predicate
+
+For example:
+
+    def greater_than_or_equal_to(value)
+      value_predicate(:greater_than_or_equal_to,:>=,value)
+    end
+
+    sequence(1,2,3).filter(greater_than_or_equal_to 2)
+    sequence(1,2,3).filter(where is greater_than_or_equal_to 2)
+
+##### self_predicate
+
+For example:
+
+    def is_valid
+      self_predicate(:is_valid, :is_valid)
+    end
+
+    sequence(OpenStruct.new(is_valid:true,name:'apple'),OpenStruct.new(is_valid:false,name:'pear')).filter(is_valid).to_a
+    => [#<OpenStruct is_valid=true, name="apple">]
+

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/option.rb

@@ -23,7 +23,6 @@ module Option
     end
 
 
-
     def <=>(object)
       self.state <=> object.state
     end
@@ -81,46 +80,46 @@ module Option
     end
 
     def map(predicate=nil, &block)
-      sequence(@content).map(predicate, &block).head_option
+      as_option(sequence(@content).map(predicate, &block))
     end
 
     alias collect map
 
     def select(predicate=nil, &block)
-      sequence(@content).select(predicate, &block).head_option
+      as_option(sequence(@content).select(predicate, &block))
     end
 
     alias find_all select
     alias filter select
 
     def reject(predicate=nil, &block)
-      sequence(@content).reject(predicate, &block).head_option
+      as_option(sequence(@content).reject(predicate, &block))
     end
 
     alias unfilter reject
 
     def grep(pattern)
-      sequence(@content).grep(pattern).head_option
+      as_option(sequence(@content).grep(pattern))
     end
 
     def drop(n)
-      sequence(@content).drop(n).head_option
+      as_option(sequence(@content).drop(n))
     end
 
     def drop_while(&block)
-      sequence(@content).drop_while(&block).head_option
+      as_option(sequence(@content).drop_while(&block))
     end
 
     def take(n)
-      sequence(@content).take(n).head_option
+      as_option(sequence(@content).take(n))
     end
 
     def take_while(&block)
-      sequence(@content).take_while(&block).head_option
+      as_option(sequence(@content).take_while(&block))
     end
 
     def flat_map(&block)
-      sequence(@content).flat_map(&block).head_option
+      as_option(sequence(@content).flat_map(&block))
     end
 
     alias collect_concat flat_map
@@ -144,6 +143,10 @@ module Option
       @content.respond_to?(:empty?) ? @content.empty? : !@content
     end
 
+    def as_option(seq)
+      seq.count == 1 ? seq.head_option : option(seq.entries)
+    end
+
   end
 
   class None
@@ -214,49 +217,49 @@ module Option
     alias << join
 
     def map(predicate=nil, &block)
-          sequence(@content).map(predicate, &block).head_option
-        end
+      none
+    end
 
-        alias collect map
+    alias collect map
 
-        def select(predicate=nil, &block)
-         none
-        end
+    def select(predicate=nil, &block)
+      none
+    end
 
-        alias find_all select
-        alias filter select
+    alias find_all select
+    alias filter select
 
-        def reject(predicate=nil, &block)
-          none
-        end
+    def reject(predicate=nil, &block)
+      none
+    end
 
-        alias unfilter reject
+    alias unfilter reject
 
-        def grep(pattern)
-          none
-        end
+    def grep(pattern)
+      none
+    end
 
-        def drop(n)
-          none
-        end
+    def drop(n)
+      none
+    end
 
-        def drop_while(&block)
-          none
-        end
+    def drop_while(&block)
+      none
+    end
 
-        def take(n)
-          none
-        end
+    def take(n)
+      none
+    end
 
-        def take_while(&block)
-          none
-        end
+    def take_while(&block)
+      none
+    end
 
-        def flat_map(&block)
-          none
-        end
+    def flat_map(&block)
+      none
+    end
 
-        alias collect_concat flat_map
+    alias collect_concat flat_map
 
     protected
 
@@ -267,4 +270,4 @@ module Option
   end
 
 
-end
+end

data/lib/sequence.rb

@@ -44,6 +44,7 @@ module Sequences
     end
   end
 
+
   # Creates an empty sequence
   #
   # == Returns:
@@ -165,14 +166,13 @@ module Sequences
     end
 
     def drop(n)
-      dropped = 0
-      Sequence.new(self) { |yielder, val|
-        if dropped < n
-          dropped += 1
-        else
-          yielder << val
-        end
-      }
+      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)
@@ -191,14 +191,14 @@ module Sequences
 
     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)
+                     self.each_with_index do |v, i|
+                       if i < n
+                         g.yield v
+                       else
+                         raise StopIteration
+                       end
+                     end
+                   end)
     end
 
     def take_while(&block)
@@ -249,7 +249,7 @@ module Sequences
     end
 
     def head
-      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.first
+      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.entries.first
     end
 
     def head_option
@@ -270,83 +270,83 @@ module Sequences
 
     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)
+                     self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.drop(1).each { |i| g.yield i }
+                   end)
     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)
+                     size = self.count
+                     self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.first(size-1).each { |i| g.yield i }
+                   end)
     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)
+                     self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.entries.shuffle.each { |i| g.yield i }
+                   end)
     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)
+                     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)
+                     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)
+                     (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)
+                     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)
+                     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)
+                     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)
@@ -355,26 +355,26 @@ module Sequences
 
     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)
+                     self.entries.map { |e| Type.check(e, Pair::Pair); [e.key, e.value] }.flatten.each { |i| g.yield i }
+                   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)
+                     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)
+                     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)
+                     self.each_slice(2) { |k, v| g.yield pair(k, v) }
+                   end)
     end
 
     def to_a
@@ -393,21 +393,21 @@ module Sequences
 
     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)
+                     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)
     end
 
     def marshal_dump
@@ -437,19 +437,19 @@ module Sequences
     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)
+                       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)
+                       self.sort_by { |e| attr.map { |v| e.send(v) } }.each { |i| g.yield i }
+                     end)
       end
     end
 
     def sorting
       Sequence.new(Sequence::Generator.new do |g|
-        self.sort.each { |i| g.yield i }
-      end)
+                     self.sort.each { |i| g.yield i }
+                   end)
     end
 
     def get_or_else(index, or_else)
@@ -466,32 +466,32 @@ module Sequences
 
 
     def get_by(pair_key)
-      item = self.filter{|e| e.first == pair_key}.head_option
+      item = self.filter { |e| e.first == pair_key }.head_option
       item.is_some? ? item.get.value : none
     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}})
+      Maps.merge(self.map { |p| {p.key => p.value} })
     end
 
     def drop_nil
       Sequence.new(Sequence::Generator.new do |g|
-        self.reject { |e| e.nil? }.each { |i| g.yield i }
-      end)
+                     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.exec.call(val)
-          }.each { |i| g.yield i unless i.nil? }
-        end)
+                       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)
+                       Parallel.map(self.entries, options) { |val| block.call(val) }.each { |i| g.yield i }
+                     end)
       end
     end
 
@@ -501,8 +501,8 @@ module Sequences
 
     def cycle
       Sequence.new(Sequence::Generator.new do |g|
-        self.entries.cycle.each { |i| g.yield i }
-      end)
+                     self.entries.cycle.each { |i| g.yield i }
+                   end)
     end
 
     protected

data/spec/option_spec.rb

@@ -125,6 +125,8 @@ describe 'Option' do
   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]))
@@ -167,4 +169,4 @@ describe 'Option' do
     expect(option(nil).flat_map{|v| v.first}).to eq(none)
   end
 
-end
+end

data/totally_lazy.gemspec

@@ -6,7 +6,7 @@
 
 Gem::Specification.new do |s|
   s.name = "totally_lazy"
-  s.version = "0.0.8"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Kingsley Hendrickse