
Ruby’s Most Underused Keyword - sant0sk1
http://www.rubyrailways.com/rubys-most-underused-keyword/
======
old-gregg
My personal up until recently underused keyword was (surprise!) "rescue".

I'm not sure how this has been escaping me since 07, but I had no idea you can
apply it at the end of an expression, i.e. when you're facing nasty functions
that insist on trhowing exceptions, instead of

begin

    
    
      value = function_that_throws
    

rescue

    
    
      value = "default"
    

end

you can just write:

value = function_that_throws rescue "default"

~~~
iamwil
that's along the lines of using or for nil returns.

value = function_that_nils || "default"

I've found it makes code more succinct.

~~~
old-gregg
Careful here: I've seen plenty of "Rubiomatic" bugs that look like this:

value = function_that_nils or "default"

... which results in nil assignment to value. Accidental confusion between ||
and 'or' is very common in Ruby world IMO, almost like famous == vs = in C.

~~~
iamwil
Agreed. I think one is for statements (or) and the other one is for
expressions (||), so they have different operational precedence, even though
you could use them interchangeably, as long as you knew what got executed
first.

------
petercooper
redo, in the Fibonacci example, is still iterative - it's presented as a third
way, when it's just a cruftier way of being iterative. If you remove the cruft
of the lambda and the redo, you end up with:

    
    
      def fib(i)
        n, result = 1, 0
        while i != -1
          i, n, result = i - 1, n + result, n
        end
        result
      end
    

Cleaner, faster (by 10% on Ruby 1.8) and shorter, but certainly iterative.

(Separate to this, the fib routines shown produce incorrect results - my
example above maintains this, just for comparison with the original code.
fib(10) is 55 not 89 - it's one off in its input.)

~~~
judofyr
You are absolutely right... if you're an interpreter...

From a user's point of view, the redo says "run this block again"; and since
the block == the method it's just another way to run acc(). Of course, it's
still _faking_ , but I've never claimed anything else :-)

~~~
petercooper
Since we're having the discussion in two places, I'll be quicker here.. ;-)

"run this block again" signifies "loop" to me and "loop" signifies
"iteration." If I see a block of code being looped, I don't think (as a coder,
not as an interpreter) that it's recursive. Perhaps others would, though. If
we got in a time machine back to the 80s, I kinda feel that "redo" would turn
into "goto".. :)

(Hey, we should be doing this on RubyFlow as well - you could be earning some
serious karma :))

------
jimbokun
Using redo for tail recursion in Ruby is an interesting idea, similar to
Clojure's recur keyword.

~~~
sunkencity
but ruby doesn't support tail recursion effectively? or is this something new
in 1.9. Stack level is not deep enough in 1.8 :P

~~~
judofyr
1.9 supports it, together with some other optimizations, but everything is
turned off in 1.9.1. 1.9.2 will be sweet :-)

