Totally Lazy for Ruby

This is a port of the java functional library Totally Lazy to the ruby language.

Status

Summary

• Tries to be as lazy as possible
• Supports method chaining
• Is primarily based on ruby Enumerators
• For function, can use blocks or lambdas (some places require lambdas, eg. when 2 functions need to be passed in)

Install

This gem requires ruby >= 2.0.0

In your bundler Gemfile

gem totally_lazy, '~>0.1.54' # (or latest) 

Or with rubygems

gem install totally_lazy

Examples

require 'totally_lazy'

sequence(1, 2, 3, 4).filter(even)           # lazily returns 2,4
sequence(1, 3, 5).find(even)                # eagerly returns none()
sequence(1, 2, 3).contains?(2)              # eagerly returns true
sequence(1, 2, 3).exists?(even)             # eagerly return true
sequence(1, 2).map(to_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).reduce(sum)               # eagerly return 6
sequence(1, 2, 3).for_all(odd)              # eagerly returns false;
sequence(1, 2, 3).fold_left(0, add)         # eagerly returns 6
some(sequence(1, 2, 3)).get_or_else(empty)  # eagerly returns value or else empty sequence
sequence(1, 2, 3, 4, 5).filter(greater_than(2).and(odd))
                                            # lazily returns 3,5
sequence(pair(1, 2), pair(3, 4)).filter(where(first, equal_to?(3))) 
                                            # lazily returns pair(3,4)
sequence(1, 2, 3).to_s                      # eagerly returns "[1,2,3]"

Generators

range(1, 4)             # lazily returns 1,2,3,4
repeat('car')           # lazily returns an infinite sequence of 'car's
enumerate(increment, 1) # lazily returns 1,2,3 ... to infinity
range(1, 4).cycle()     # lazily returns 1,2,3,4,1,2,3,4,1,2,3,4 infinitely 
powers_of(3)            # lazily returns the powers of 3 (i.e 1,3,9,27 ...)

Naturally you can combine these operations together ...

enumerate(increment, 1).filter(even).take(10).reduce(sum) # returns 110

And because all the operations except reduce are lazy the sequence of numbers is only processed once.

License

Apache 2