Don't Forget About Infinite Enumerators

2016.05.11 @ 02:05 PM UTC

When was the last time you created an Enumerator? We use enumerables all over the place but it’s rare to see Enumerator.new. If I’m being honest, sometimes I forget it’s an option. I’m guessing you might as well.

Enumerators don’t have to be infinite but I find that’s where the power lies. With finite enumerations your immediately limiting where they can be used. They come with an extra expectation that must be addressed. Are there enough elements for me? When they’re infinite you can just go crazy.

An Example

I’ve created a List class with a print method.

class List
  def initialize(items)
    @items = items
  end

  def print
    @items.each { |item| puts "* #{item}" }
  end
end

It takes an array of items and prints them as a list.

> List.new(['eggs', 'milk', 'bread']).print
* eggs
* milk
* bread

It’s nothing too fancy but it works. The thing is, people want different kinds of markers. Some like the asterisk, some want dashes, others reach for a bullet. Forcing everyone to use the same marker might offend some aesthetics. It’ll also pose a problem if order is important.

I could add an argument to set the marker.

def print(marker)
  @items.each { |item| puts "#{marker} #{item}" }
end

Now people can use “-“ or “•” but I didn’t solve the issue of ordered lists. To indicate order I’ll need to support an incrementing marker.

I could accept a symbol indicating the kind of marker. That’ll limit the set of available markers. It also means print might become more marker selection code than printing code. Sounds like a mess in the making.

As a Rubyist, I’ll fix this with a block.

First a Block

My new block argument means the caller can dictate the marker. I’ll provide the block with the current index allowing for incrementing markers. People using static markers (e.g. asterisks) can ignore the index.

def print
  @items.each_with_index do |item, i|
    puts "#{yield(i)} #{item}"
  end
end

Using an incrementing numeric marker:

> list.print { |i| "#{i + 1}." }
eggs
milk
bread

Using a static marker:

> list.print { '*' }
* eggs
* milk
* bread

Great! What if the caller wants letter instead of numbers? I wonder how that works out. I could add the current index to the ASCII value of "A".

> list.print { |i| "#{(65 + i).chr}." }
A. eggs
B. milk
C. bread

At a glance, it looks good but I don’t like it.

Most people don’t spend their nights memorizing the ASCII table. That 65 falls into the “magic number” category of bad code. I could fix it by setting it to a well named variable or adding a comment. There is another, bigger problem. What does it do after the 26th item?

...
Y. eggs
Z. milk
[. bread

That’s not great. I’ll have to add logic to handle proper post-alphabet incrementing. Usually, that means moving from “Z” to “AA”, “AB”, “AC”, and so on. If I rework this to use next Ruby will do it for me. That approach doesn’t really work with the block as I have it.

Then an Infinite Sequence

As I look at it, this block seems to be doing the job of an enumerator. Instead of using a block, I’ll expect to be given an enumerator.

def print(markers)
  @items.zip(markers) do |item, marker|
    puts "#{marker} #{item}"
  end
end

Each item will be joined with a marker generated by the enumerator and then iterated on. Now I can create an infinitely long incrementing alphabetic marker:

def incrementor
  Enumerator.new do |yielder|
    letter = 'A'

    loop do
      yielder << "#{letter}."
      letter = letter.next
    end
  end
end

Passing the alphabetic incrementor looks good at first.

> list.print(incrementor)
A. eggs
B. milk
C. bread

What about that 27th item on the list?

...
Y. 25
Z. 26
AA. 27

There we are! With a minor tweak, I can make this work for numerals. See, integers also have next. I’ll add an argument that works for anything responding to next.

def incrementor(incrementable)
  Enumerator.new do |yielder|
    loop do
      yielder << "#{incrementable}."
      incrementable = incrementable.next
    end
  end
end

For the alphabetic version pass in "A".

> list.print(incrementor('A'))
A. eggs
B. milk
C. bread

For the numeric version pass in 1.

> list.print(incrementor(1))
eggs
milk
bread

What about non-incrementing markers? With cycle we can get an infinite list of the same character.

> list.print(['*'].cycle)
* eggs
* milk
* bread

All of this works but it feels a bit heavy.

I can make it easier to use a static marker. If the marker passed doesn’t respond to each then I’ll wrap it with cycle.

def print(markers)
  if !markers.respond_to?(:each)
    markers = [markers].cycle
  end

  @items.zip(markers) do |item, marker|
    puts "#{marker} #{item}"
  end
end

Numeric and alphabetical incrementing are common so I’ll provide pre-built markers.

def self.incrementor(incrementable)
  Enumerator.new do |yielder|
    loop do
      yielder << "#{incrementable}."
      incrementable = incrementable.next
    end
  end
end
private_class_method :incrementor

NUMERIC = incrementor(1)
ALPHA_UPPER = incrementor('A')
ALPHA_LOWER = incrementor('a')

Put everything together and here’s the final product.

class List
  def self.incrementor(incrementable)
    Enumerator.new do |yielder|
      loop do
        yielder << "#{incrementable}."
        incrementable = incrementable.next
      end
    end
  end
  private_class_method :incrementor

  NUMERIC = incrementor(1)
  ALPHA_UPPER = incrementor('A')
  ALPHA_LOWER = incrementor('a')

  def initialize(items)
    @items = items
  end

  def print(markers)
    if !markers.respond_to?(:each)
      markers = [markers].cycle
    end

    @items.zip(markers) do |item, marker|
      puts "#{marker} #{item}"
    end
  end
end

By leveraging enumerators I was able to keep print flexible. Want to use Roman numerals? Go for it. No pull request or monkey patching required.

In a way, it’s unfortunate that Ruby chose the name Enumerator. It implies a sequential nature that conceals the truth. These are generators capable of spitting out an infinite number of… whatever. Want a bunch of fake names?

> fnames = Enumerator.new do |y|
*   loop { y << ['Aaron', 'Bob', 'Claire'].sample }
* end
> lnames = Enumerator.new { |y|
*   loop { y << ['Smith', 'Jones', 'Jackson'].sample }
* end
> fnames.take(5).zip(lnames) { |names| puts names.join(' ') }
Claire Jones
Bob Jones
Claire Jackson
Aaron Jones
Bob Smith

If you haven’t created an enumerator before I hope you’re curious. If you have I hope you don’t forget they’re there. I’m doing my best to remember.

Aaron
Lasseigne