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!=