I: Exclamation marks in method names

-----Messaggio originale-----
Da: Sylvester Keil [mailto:[e-mail]]=20
Inviato: luned=EC 14 novembre 2011 13:08
A: ruby-talk ML
Oggetto: Exclamation marks in method names

Dear all,

in a number of projects now, I've been (ab)using the convention of using
exclamation marks at the end of method names somewhat and was therefore
wondering about the current consensus in the community regarding the use =
of
exclamation marks.

As outlined in the Matz/Flanagan book (also in Pickaxe and, I believe, I
read about it the Best Practices book, too), the prevailing convention =
is to
use exclamation marks for methods that should 'be used with caution'; =
common
examples include mutators (when there is also a nonmutating variant), or
methods that raise errors (when there are variants that fail 'silently' =
by
returning a known good value or a default value). I have used =
exclamation
marks in both these contexts, however, I've also come up with a =
different
idiom recently, mainly in combination with predicates.

As we know, predicates (or predicate-like state) can often be accessed =
using
methods ending with a question mark like #empty?, #nil? etc. Now, in =
cases
where the predicate's state is determined solely by an attribute, I =
started
using methods with exclamation marks to set the value. For example, =
consider
a Date class that is supposed to handle uncertain dates:

d =3D Date.new
d.uncertain? #-> false
d.uncertain! #-> make date uncertain (instead of d.uncertain =3D true)
d.uncertain? #-> true d.certain! #-> make date certain again

These methods are mutators, but they are not really dangerous (and there =
are
no non mutating variants), so this usage is in violation with the naming
convention. Nevertheless, I've grown quite fond of the symmetry (using =
both
? and ! for predicates), going so far as adding separate accessor =
generators
(think attar_predicate). To make matters worse, I broke another =
convention:
in Ruby, the exclamation mark mutators usually return self only if a
mutation actually took place (nil otherwise), for example:

'U'.upcase! #-> nil

and are therefore not chainable. Because I wanted the predicate-setters =
to
be chainable, I made them return self always. For instance, I had a Name
class that printed names according to different formatting rules and I
wanted to write things like:

name.sort_order!.to_s #-> set name to sort order formatting and convert =
to
string

What do you think? Is it a terrible idea to break conventions like that =
and
would you discourage or condone such usage? Also, I'd be curious to know =
if
there were any other common conventions regarding the use of exclamation
(and question) marks in method names?

Thanks!

 
 
 --
 Caselle da 1GB, trasmetti allegati fino a 3GB e in piu' IMAP, POP3 e SMTP autenticato? GRATIS solo con Email.it http://www.email.it/f
 
 Sponsor:
 Riccione Hotel 3 stelle in centro: Pacchetto Capodanno mezza pensione, animazione bimbi, zona relax, parcheggio. Scopri l'offerta solo per oggi...
 Clicca qui: http://adv.email.it/cgi-bin/foclick.cgi?mid=11982&d=29-12