# Totally Lazy for Ruby This is a port of the java functional library [Totally Lazy](https://code.google.com/p/totallylazy/) to the ruby language. ### Status [![Build Status](https://travis-ci.org/raymanoz/totally_lazy.svg?branch=master)](https://travis-ci.org/raymanoz/totally_lazy) [![Gem Version](https://badge.fury.io/rb/totally_lazy.svg)](https://badge.fury.io/rb/totally_lazy) ### 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 ```ruby gem totally_lazy, '~>0.1.54' # (or latest) ``` Or with rubygems ``` gem install totally_lazy ``` ### Examples ```ruby 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 ```ruby 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 ... ```ruby 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](http://www.apache.org/licenses/LICENSE-2.0)