Does using curly braces go against the "Ruby way"?

Question

I've been using Ruby for about two weeks, and I've not been programming for too terribly long, but I'm coming at the language from a C-style background (C++, C#, etc). Anyway - a good friend and mentor of mine was looking at some Ruby that I'd written the other day, and he told me that he'd smack me if he caught me using curly braces in Ruby again.

Well, I just found out about Builder yesterday, via this About.com article, and the example that they have posted uses curly braces. Is there a different way to do this, or do you have to use curly braces with Builder?

This may seem like a minor point, but I'm new to Ruby, and I don't want to let myself develop any bad habits. What do you guys think?

Answer 1

While some people go with "braces for one-liners, do-end for multi-liners", I personally find the following rule the most logical:

• use do-end when your block has side-effects (typically, with each and related methods) and
• use braces when your block is without side-effects (map, inject and alike)

This logic goes well with method chaining issue that Matt wrote about.

One benefit of this approach is that it is going to make you think about side-effects every time you write a block, and they are very important, although sometimes overlooked by coders with no functional programming background.

Another way to put it, without involving side-effects terminology would be:

• use do-end for blocks that perform
• use { and } for blocks that return

Here are couple of articles with more info:

http://onestepback.org/index.cgi/Tech/Ruby/BraceVsDoEnd.rdoc

http://talklikeaduck.denhaven2.com/2007/10/02/ruby-blocks-do-or-brace

Answer 2

Idiomatic ruby is

method_name {|param| param.do_something} # squigglies for one liners

# do/end for multi-line
method_name do |param|
  param.do_something
end

One reason for this is for chaining, foo.map {|f| f.num}.reduce(0) {|memo, i| memo + i} looks nicer then hanging a method call off of an end like

foo.map do |f| 
  f.num
end.reduce(0) do |memo, i| 
  memo + i
end

There is just something strange about calling a method off of end, even though syntactically the two are equivalent.

Answer 3

"The Ruby way" doesn't advocate any specific style. If they didn't want you to have the option to use curly braces, it wouldn't be in the language. That said, conform to your team's coding style (if you're working with a team).

Most Ruby code I've seen uses end in place of curly braces, but I don't use Ruby so I can't say for sure that this is the preferred style. Ruby has more than one way of doing things -- you can use whichever way pleases you (within reason).

Answer 4

The usual convention is { ... } blocks for one-liners and do ... end for multi-liners. I generally follow this convention but should I ever be king I think I would use do .. end more often.

An occasional issue with {} is that {} binds more tightly than do end so the only way to write a poetry-mode block for a method that also has parameters is to use do end, otherwise the block will be part of the parameter and will not be not passed directly to the method.

def f x
  yield x
end

f 123 do |n| p n end  # works
f 123  { |n| p n }    # does not work
f(123) { |n| p n }    # works, of course

Of course, if you wanted to attach a block to a parameter in poetry mode, then you win with {} followed by do end.

def g  ; p ['g', yield] end
def f x; p ['f', yield] end

f g { 2 } do 3 end
["g", 2]
["f", 3]

Finally, and contrary to some of the advice you have received here, a ; is not needed before end.