[ruby-core:24005] Object#to: Possible Refinements on the .try_convert Methods for Type Coercion

Musing on type conversion, I hit on the idea of an Object#to method
which took a String, Symbol, or class name and tried to coerce the receiver
into that type, returning nil on error. I initially wrote the
following:

 class Object
    COERCABLE = {String   => 's',    Float    => 'f',   Integer    => 'i',
                 Complex  => 'c',    Rational => 'r',   Array      => 'a',
                 Proc     => 'proc', Symbol   => 'sym', Enumerator => 'enum'}

    def to(arg)
      name = arg.is_a?(Class) ? COERCABLE[arg] : arg.to_s.sub(/^to_/,'')
      method = ('to_' + name.to_s).to_sym
      return unless respond_to? method
      coerced = send method
      return unless coerced.is_a?(COERCABLE.invert[name] || Object)
      coerced
    end
  end

  20.to(Complex)      #=> (20+0i)
  20.to(:c)                #=> (20+0i)
  20.to(Enumerable) #=> nil

Having done this, I discovered the .try_convert methods that some core
classes had (the name implied to me that they were for character-set
conversion, so I'd never looked at them). I'm posting anyway because
this approach may offer some advantages.

(I used the "explicit conversion" form of the #to_* methods, e.g.
#to_s rather than #to_str, because if somebody calls #to(String),
that's as explicit a conversion you can get. .try_convert mainly uses
the implicit form, but an `ack` of `1.9 source shows inconsistencies).

It's an instance method, because it feels more natural to me to say
obj.to(Foo) than Foo.try_convert(obj). It also means that it's subject
to inheritance, so objects that want to redefine the semantics of
their type conversion can override #to.

It puts the _object_ at the heart of the operation; not the target of
the conversion. Philosophical arguments aside, this would also allow
you to specify multiple conversion targets in a single #to_call, and
have them tried in order of preference.

It's also closer to the #to_* idiom we're already used to. Indeed,
with a symbol argument #to(:a) is only two characters longer than
#to_a, yet performs type-checking and avoids NoMethodErrors.

It doesn't raise exceptions, so it can be chained safely. .try_convert
can raise a TypeError. It doesn't matter to me whether a coercion
failed because the object didn't implement the right method, or said
method returned the wrong thing. .try_convert forces you to care,
which seems self defeating because it's principle advantage was
avoiding NoMethodErrors, thus rescue clauses, but by raising
TypeErrors, rescue must come to your rescue once again.

The flexibility of accepting a symbol name argument allows you to
specify that you want to use, say, #to_ary rather than #to_a to
perform the conversion. It also makes the process extensible for more
types.

It's more supportive of #to_* methods that don't imply a resultant
type. For example. #to_path returns a String, but you wouldn't use
String.try_convert(path). IO.try_convert(path) could try #to_path
after #to_io, but that's a kludge because now you have to think in
terms of IO objects, and rely on a side effect, just to get your
conversion.

.try_convert requires each "target" class to implement a .try_convert
method, which seems most ungainly. My approach of using a constant is
perhaps worse, of course, but it still seems preferable because the
constant could simply be used to short-circuit common cases, letting
us use introspection to dispatch .try_convert/#to calls to unknown
classes. Again, this is only possible because the source of the
conversion is to the receiver. (A possible extension of this approach
is to also allow classes to define a .from method, that would accept
an object to coerce from as an argument, and raise a TypeError if it
can't. IOW, an alternative constructor that could be called by #to,
giving classes more control over how foreign objects were coerced).

Anyway, just an idea. :-)

--
Run Paint Run Run