I am intrigued by the idea that the Scala compiler can detect type mismatches in code and insert implicit type conversions.
I was able to get a simple conversion working that converts java.lang.String to a "StringAspect" (a simple wrapper class) so I can see the utility of this feature and I am thinking I could take this pretty far in order to simplify code structures.
But ... how far can I expect to take this?
For example, would it be reasonable to convert a java.lang.String containing XML text to a DOM? If I did, what if the conversion throws an exception because the XML text was not properly formed?
My personal take on implicit conversions is that they should only be used when the conversion is guaranteed to succeed.
I wouldn't rely on an implicit conversion from a String to an XML DOM object unless the String was a constant/literal that I controlled; adding a point of failure that doesn't even have a visible representation in the code is just asking for trouble.
My rule of thumb is to use them when they make the code clearer not just to make the code shorter. This restricts their use to occasions where you are dealing with objects that reside at the boundaries of two type hierarchies.
Previous Topic
