Can someone help me understand when and why to use Enumerators and Enumerable?

It is heavy. As you said, it's all about each and yield. I'm going to try and summarize what you said below.

When do you need to include Enumerable in your class Foo? When you are treating Foo objects as collections. Collections (or lists of things) can be arrays, hashes, file names, etc., that you iterate over. When it's a class object, ie. an instance of your class, you include Enumerable to get those methods. If your array is just an array, it already includes Enumerable.

I'd like to clarify the difference between the Enumerator class and enumeration in general.

Why use enumerators? Enumerators allow you to store data, defer enumeration, can be chained together and more.

Many classes have Enumerable methods. The Enumerator class inherits from the Enumerable module.

p Array.ancestors # [Array, Enumerable, Object, Kernel, BasicObject] 
p Hash.ancestors # [Hash, Enumerable, Object, Kernel, BasicObject]
p Enumerator.ancestors # [Enumerator, Enumerable, Object, Kernel, BasicObject]

Enumerators generate data; Enumerable methods consume it.

1. Generate the data and store it, deferring enumeration
2. Consume the data by yielding it to a block

p enum = (1..10).each # #<Enumerator: 1..10:each>
p enum.inject { |sum, n| sum + n } # => 55
p enum.select { |x| x.even? } # => [2, 4, 6, 8, 10]
p enum.select { |x| x.even? }.inject(:+) # => 30

The enumerable method calls each to request data; later the enumerator object provides the data by yielding it to a block.

p enum = ["cat", "bat", "rat"].map # #<Enumerator: ["cat", "bat", "rat"]:map>
p enum.with_index { |word, index| "#{index}: #{word}" } # ["0: cat", "1: bat", "2: rat"]

# Same as:
p ["cat", "bat", "rat"].map.with_index { |word, index| "#{index}: #{word}" }
# ["0: cat", "1: bat", "2: rat"]

For more on Enumerator (and Collections) see my link to RubyMonk (above) and http://patshaughnessy.net/2013/4/3/ruby-2-0-works-hard-so-you-can-be-lazy http://blog.carbonfive.com/2012/10/02/enumerator-rubys-versatile-iterator/

I don't know anything about ruby. But examining your code they are different completely.

First code you are actually making an array called 'friends'. Then you are calling your class and creating a new one each time, Friends.new()

friends = [Friends.new("Chandler", 24), Friends.new("Monica", 22), Friends.new("Joey", 23), Friends.new("Phoebe", 26)]

You actually created an array with 4 Friends class members. Since friends is an ruby array then friends.sort works, because friends is an array, Friends (with a capital F) is your class.

The second code implements Enumerable in the class Friends

friends = Friends.new

This actually assigns Friends class to friends instead of making friends an array directly

friends.members = ["Chandler", "Joey", "Monica", "Phoebe"]

Is assigning that array(["Chandler", "Joey", "Monica", "Phoebe"]) to the array INSIDE Friends class, so friends.members is an array.

def each &block
    @members.each &block

this is telling enumerable what an element is or each means. So it just grabs the enumerable in friends array called member.each and gives it to friends.each so now when you do enumerable commands you can do them directly to friends. When an enumerable sort or select it goes through EACH item inside it, so .each just references what each is, in your second example friends.each is each on of your strings in members array. Your first example since friends is an array then friends.each would reference each one of your Friends class in the array.

friends.sort, if you didn't you have to allow access to members and write friends.members.sort, or friends.members.select instead of friends.method.

So basically you made friends an array the first time and filled the array with 4 objects of class Friends, and the second time you made friends an class Friends with a array inside it, then you extended enumerable in friends to access the enumerables directly from Friends instead of Friends.members.

Does this make sense?

Yes, you're completely right, I should have written this:

class Friends
  attr_accessor :members
  def initialize
    @members = []
  end
  def <=> (friend)
    members <=> friend.members
  end
  def each &block
    @members.each &block
  end
end
friends = Friends.new
friends = ["Monica", "Chandler", "Joey", "Phoebe"]

I wanted to demonstrate (from our class BankAccount example) that you could define your own sort using def (insert spaceship operator here*), each and to_s without include Enumerable. [Note to readers: include and extend are different things in Ruby.] *The combined comparison/spaceship operator does not display in Markdown.

I appreciate the clarification on my Classes and Arrays. Now that the code is almost the same, I can clearly see that adding friends.members = ["Monica... is the Voodoo bit which makes it need Enumerable. Thanks, I didn't catch that. However, the Enumerable bit is still Voodoo - other than populating the array, what's going on?

In the context of Array - we already have the same methods and we can re-define those methods. Why and when do you use Enumerable/Enumerator, since both programs provide identical output?

Cause friends is still an array. Since in Ruby you don't have to declare a type first you can easily change it by mistake.

friends = Friends.new

friends.class 
#Will tell you what class it is hint: class Friends

friends = ["Monica", "Chandler", "Joey", "Phoebe"]
friends.class
# will tell you what class it is hint: array

The voodoo your doing is the same, you are just creating an array of strings.

Do this here: You'll get an error about sort

class Friends
  attr_accessor :members
  def initialize
    @members = []
  end
  def <=> (friend)
    members <=> friend.members
  end
  def each &block
    @members.each &block
  end
end

friends = Friends.new
friends.class
friends.members = ["Monica", "Chandler", "Joey", "Phoebe"]

friends.members

friends.sort

Now add include Enumerable after class Friends and that same code I posted works.

Man I haven't even learn ruby, throwing stuff at me I have to learn on the fly how dare you! :)

In all seriousness once you get a grasp on programming concepts it'll get a lot easier. Keep asking and ill do my best!

We're about to be in vehement agreement here :) - you get a NoMethodError (as per preamble). I did a lot of p foo.class and missed that it wasn't an array the second time. The thing is, my alternate code works. Technically, I don't need to make it p friends.class # => Friends Excellent instruction, I might add. I never thought of Duck Typing as having gotchas. OK, so the take away is that you need to include Enumerable if your array is really an instance of a class that contains an array:

# First time
p friends.inspect # => "[\"Monica\", \"Chandler\", \"Joey\", \"Phoebe\"]"
# Second time
p friends.inspect # => "#<Friends:0x000000027ccf48 @members=[\"Chandler\", \"Joey\", \"Monica\", \"Phoebe\"]>"

But:

p Friends.ancestors # [Friends, Enumerable, Object, Kernel, BasicObject]
p Array.ancestors # [Array, Enumerable, Object, Kernel, BasicObject]
p Enumerable.instance_methods - Array.instance_methods # => []

(Going back to my preamble...) Great - since I have Array, why do I need Enumerable in general?