Cool.  Enumerators are objects.  Any method that returns an enumerator can then be treated as an enumerator object.  So if you need to do some more sophisticated enumeration, you can simply call .each or some other method that returns an enumerator and then manipulate that object.  cat.eatch_char.each_with_index {|thing| action}
more practice with enumerators.  pass in a parameter to the enum_for(:each_char) for example on strings.
enumerators can be used to generate infinite sequences, but actually more importantly, they can be used to generate sequences of arbitrary length that conform to some sort of conditional pattern.  This is awesome, because in a program you may want to generate a new state, a different random number, etc. and the number of times you want to do this is based on some other state that is undefined.  This way your enumerator can generate a value in an infinite do loop (or whatever) but then on each execution of the loop it will return a value and wait to see if your program needs another, and if it doesn't then it will exit.
mind blown.  so this concept of enumerators being able to return an arbitrary length sequence is really cool.  also the types of blocks they are able to execute, the level of control on the filtering, is very interesting.  this should be remembered as an interesting concept i have yet to explore fully.  seems like it would be useful for interesting programs.
blocks are also good for controlling access (transactional control) in that you can create a block that will close out some code after the block is done being used.  This is how the File.open method is used if passed in with a block - should look at this... ok, i see it now.  will know to look again in future.  just pass in a block ho
two methods turn a block into an object, Proc.new and lambda, both take a block as an object.  cool way to add a sythetic method to an object, not sure how this works with mixins, but just cool in general, the block gets added to the .call method of the object.
closure is when variables in the surrounding scope that are referenced in a block remain accessible for teh life of that block and life of any Proc object created fromt that block.
passing more than one Proc object to a method.
while loop that can cut out on each go around b/c it is a block and gets re-evaluated to see if it should exit each time.
blocks have all the same abilities as methods now in Ruby 1.9.  Which is awesome.  they can take an arguement, an arguement list - something*, and a block, &someblock like so - procedure = -> parameter, parameterlist*, &someblock

it gets called like this

procedure.call('first_parameter', 'rest', 'of', 'parameters') { puts 'the blcok }
containers, blocks, and iterators are core concepts in ruby.  i will get use to them.