Hi,

I think things should stay the way they are, here is
why.

Things are a little complex about truthness/falseness.
One has to distinguish the "value" of an object from
its "truthness".

Only nil and false are "false" from a "truthness"
perspective. All other objects are "true".

For true? and false? to be somehow usefull, I first felt
that they should relate to the "truthness" of the
object, not its "value". That is very different from
nil? (it checks the value of the object, only The nil
object is nil?).

This leads to:
class Object
  def true?  ; true      ; end
  def false? ; not true? ; end
end
class NilClass
  def true?  ; false     ; end
end
class FalseClass
  def true?  ; false     ; end
end
Usage: 1 - Checking truthness
  if some_thing.true? then
    xxx
  end
Usage: 2 - Checking value
  if some_thing == true then
    xxx
  end

On the other hand, one may consider that
checking the value is what matters most,
versus checking the truthness.

This leads to:
class Object
  def true?  ; false ; end
  def false? ; false ; end
end
class TrueClass
  def true?  ; true  ; end
end
class FalseClass
  def false? ; true  ; end
end
Usage: 1 - Checking the truthness
  if some_thing then
    xxx
  end
Usage: 2 - Checking the value
  if some_thing.true? then
    xxx
  end

Solution 2 (checking values) leads to
code that is slightly smaller (less characters).
Which is probably a good thing by itself.
However, I think that it is fairly unreadable.

As a conclusion, I think that the status quo
is the best solution. Instead of a hard to
understand true?/false?, let's keep an explicit
xxx == true when value matters instead of
truthness.

My 0.2 Euros.

Yours,

    JeanHuguesRobert
-------------------------------------------------------------------------
Web:  http://hdl.handle.net/1030.37/1.1
Phone: +33 (0) 4 92 27 74 17