snax

10 Comments

1. Klondike
   Posted August 20, 2007 at 8:29 PM | Permalink

   What…is going on here.

   irb(main):032:0> desire
   => :desire
   irb(main):033:0> for desire in heaven do end
   => :each
   irb(main):034:0> desire
   => nil
   

2. evan
   Posted August 20, 2007 at 8:30 PM | Permalink

   The descent of the muse, probably?

3. Nick Sieger
   Posted August 20, 2007 at 8:31 PM | Permalink

   That sure is slick. I love how :each comes tumbling out of the for/in syntax.

   Seems like we need a new word to describe sentences that parse as valid Ruby with this trick.

   >> send money or love?
   => :money
   

   Guess that answers the question.

4. Chris
   Posted August 20, 2007 at 8:32 PM | Permalink

   Klondike: http://errtheblog.com/post/31

5. evan
   Posted August 20, 2007 at 8:33 PM | Permalink

   Chris, Klondike: actually, it turns out that the for/in block parameter doesn’t get its own lexical scope at all:

   >> [defined?(q), defined?(r)]
   => [nil, nil]
   >> for q in [] do r=3 end
   => []
   >> [defined?(q), defined?(r)]
   => ["local-variable", "local-variable"]
   

   This is the opposite of obj.each {|| } behavior, even though each is still called. Word on the street is that it’s a special case in MRI.

6. Nick Sieger
   Posted August 20, 2007 at 8:34 PM | Permalink

   Wow, I love your auto-reformat-comments plugin. Can I get some?

7. Chronic
   Posted August 20, 2007 at 8:35 PM | Permalink

   The way I understood it, we’ve got this basic structure:

   for {foo} in {bar} do
     {block}
   end or {baz}

   To run that code, the Ruby interpreter is going to call the each method on {bar} and pass it the block.

   In the case above, {bar} is the word heaven. The interpreter is going to try and call a method named heaven on Kernel (or Object? I forget) and not find one, invoking our new method_missing, which will return the symbol :heaven.

   It then tries to call each on the symbol :heaven. Since the Symbol class does not define an each method, method_missing is again invoked, returning the symbol :each.

   The block is effectively ignored—our method_missing does not care about it—and you get :each. Because we have a true value, the conditional is short-circuited, and we receive the symbol as our final result.

   Does that sound about right?

8. evan
   Posted August 20, 2007 at 8:36 PM | Permalink

   Chronic: right. The missing methods are sent to the irb context (main), but our handler gets defined on Object because of the way irb works (this way Symbol gets it too). And regular Enumerable#each returns self, but our method_missing(:each) returns the first param.

   Nick: it’s not auto. Just keeping the discourse level high. :)

9. Chronic
   Posted August 20, 2007 at 8:37 PM | Permalink

   Right, cool.

   So I guess this is the answer to your first question…

   >> class Symbol
   >>   def inspect
   >>     'some lovers remain unhappy even in paradise'
   >>   end
   >> end                                                                                                                         

10. evan
    Posted August 20, 2007 at 8:38 PM | Permalink

    Note that Rubinius supports all this literature already:

    sirb(eval):003> for desires in heaven do not always
    end or fade
    => some lovers remain unhappy even in paradise