Functional languages like Clojure have sequences. Sequences are pretty amazing: they let us treat algorithms as data structures. We can call functions on the data as it is produced, allowing us to interact with the results like a collection even when the sequence is infinite.

The Ruby standard library doesn’t have an official sequence class or module, but we can get pretty far with the Enumerable module. Rubyists are typically introduced to Enumerable through methods on Array, like #map and #select. Arrays like [1,2,3,4] may be thought of as finite, eagerly loaded sequences; they already contains all the members we want to enumerate with methods. We can also extend this API to sequences like “give me multiples of 5” in Ruby.

Enumerable Fibonacci

Consider an infinite sequence like fibonacci. We could create a method that generates the first n fibonacci members given n as a paramter. This implementation could look like this:

def eager_fibonacci(n)
  a = b = 1
  result = []

  loop do
    break if result.size >= n

    result << a
    a, b = b, a + b
  end

  result
end

This works, but we can go one step further. Instead of returning an eagerly-loaded array, we can return an Enumerator. We'll yield each member to the Enumerator as it is generated.

def fibonacci
  Enumerator.new do |y|
    a = b = 1

    loop do
      y << a
      a, b = b, a + b
    end
  end
end

What the heck is an Enumerator? It’s an enumerable object that can be used for either internal or external enumeration of a collection - for more details, check out my previous post. The Enumerator initialize method take a block that acts like a template for an enumerable algorithm. The block takes a parameter, y, which is an instance of an Enumerator::Yielder, which let's us yield each member of the Enumerator to blocks passed to Enumerable method calls. In short, this means we can treat an Enumerator like an Array, though we can also do so much more.

To retrieve the first ten members of our enumerable fibonacci method, we’d instead do something like:

fibonacci.take(10)

We can still enumerate over the fibonacci sequence as before:

fibonacci.take(10).each { |i| puts i }

Using the Enumerator#lazy method, we can avoid eager enumeration and run queries or calculations as each member is generated. This opens the door to some interesting use cases, like the following:

fibonacci.lazy.select(&:even?).first(10)
#=> [2, 8, 34, 144, 610, 2584, 10946, 46368, 196418, 832040]

fibonacci.lazy.select(&:odd?).first(10)
#=> [1, 1, 3, 5, 13, 21, 55, 89, 233, 377]

We can filter for the first 10 even or odd numbers generated by fibonacci. Inserting the with_index enumerator method, we can see how many items we need to enumerate to get either the first 10 even or odd numbers:

fibonacci.lazy.with_index.select { |n, i| n.odd? }.first(10)
#=> [[1, 0], [1, 1], [3, 3], [5, 4], [13, 6], [21, 7], [55, 9], [89, 10], [233, 12], [377, 13]]

fibonacci.lazy.with_index.select { |n, i| n.even? }.first(10)
#=> [[2, 2], [8, 5], [34, 8], [144, 11], [610, 14], [2584, 17], [10946, 20], [46368, 23], [196418, 26], [832040, 29]]

Notice we only need to enumerate 13 items to retrieve 10 odd numbers from fibonacci, while 29 are needed to retrieve the first 10 evens. These results wouldn’t be easily achieved with our previous fibonacci implementation in which the number of desired members must be known ahead of time.

Try creating other numerical sequences with enumerators on your own, like multiples of n, factorials for the first n integers or enumerating sums of squares. Also be sure to check out Pat Shaughnessy's great primer on lazy enumerators.

Sequence Functions

Clojure also has a number of useful functions that allow us to generate sequences from other functions. Let’s look at repeatedly which simply calls the given function over and over, emitting the results as a sequence. To get a sequence of five random numbers between 0 - 100:

(take 5 (repeatedly #(rand-int 100)))

For those new to Clojure, the syntax may look odd, but this expression "takes the first 5 results of repeatedly asking for a random integer of 0 to 100" and returns a sequence.

We can use Ruby enumerators to do something similar in Ruby. Let’s create our own version of repeatedly, which takes a will call a given block over and over again. Let's start with a naive implementation which use a loop:

def repeatedly_foo(&block)
 loop do
    block.call
  end
end

This method is not useful because the function will never return; it's an infinite loop! You’ll have to issue a kill signal to stop the execution (Ctrl-C!). We could give repeatedly_foo a limit n and break out of the loop with a counter.

def repeatedly_foo(n, &block)
  result = []

  loop do
    break if result.size >= n

    result << block.call
  end

  result
end

This is an improvement, but like our fibonacci example earlier, it means we need to load the desired number eagerly in the result array and have less control over the results.

Again, we'll wrap the loop in an Enumerator so we can treat the result as a sequence. We’ll “yield” the result of calling the block to the Enumerator::Yielder object (the y << block.call) expression in our loop:

def repeatedly(&block)
  Enumerator.new do |y|
    loop do
      y << block.call # "yield" the result to the Enumerator::Yielder
    end
  end
end

We now have an abstraction that can be chained to other enumerator methods. It also has a similar terse feel to the Clojure inspiration we saw earlier.

repeatedly { rand(100) }.take(5)
#=> [48, 48, 72, 41, 70] # your results will vary... they're random!

To Infinity and Beyond

Of course, sequences of numbers aren't the only concept that can be modeled this way in Ruby. Any collection of unknown size, for example, results from a search query, paginated resources from an API client library, data from a web crawl, etc., are also great use cases for exposure as enumerables. Consider wrapping your generated collections in an Enumerator to provide callers with flexible, composable results.