DDevelopment & Design

Use asInstanceOf[T] carefully!

BackgroundScala has nice static type checking engine but from time to time there are situations when we must downcast some general object. If this casting is not possible we expect that virtual machine will throw ClassCastExeption as fast as possible. …

Background

Scala has nice static type checking engine but from time to time there are situations when we must downcast some general object. If this casting is not possible we expect that virtual machine will throw ClassCastExeption as fast as possible. Although it is not always true. Consider code below.

Suprisingly when we run this test we will see:

Solution

Why this happens? Because type T is erasured during compile. The problem is that compiler doesn’t warn about it. Method asInstanceOf[T] is treated as any other regular generic method. If we want to be noticed about type erasure we should use pattern matching:

And then during compilation we will see:

But how to fix this? We can provide implicit evidence parameter:

But we will still have no error if we cast value to generic type e.g.:

With help comes shapeless with Type safe cast. Using this approach casting will be available in compile time only when exists evidence how it is possible.

Summary

Summarizing:
* Use pattern matching instead of asInstanceOf[T]
* If you are using asInstanceOf[T] make sure that target type is not erasured
* Use ClassTag implicit evidence parameter if you are casting only to not generic types
* Use shapeless Typeable in all other situations

# CodeCode with tests is available on

[GitHub][2]

— Previous article

Warsjawa – hold your own workshop

Next article —

TouK on Warsjawa 2014

You May Also Like
DDevelopment & Design

Grails render as JSON catch

One of a reasons your controller doesn't render a proper response in JSON format might be wrong package name that you use. It is easy to overlook. Import are on top of a file, you look at your code and everything seems to be fine. Except response is still not in JSON format.

Consider this simple controller:

class RestJsonCatchController {
def grailsJson() {
render([first: 'foo', second: 5] as grails.converters.JSON)
    }

def netSfJson() {
render([first: 'foo', second: 5] as net.sf.json.JSON)
    }
}

And now, with finger crossed... We have a winner!

$ curl localhost:8080/example/restJsonCatch/grailsJson
{"first":"foo","second":5}
$ curl localhost:8080/example/restJsonCatch/netSfJson
{first=foo, second=5}

As you can see only grails.converters.JSON converts your response to JSON format. There is no such converter for net.sf.json.JSON, so Grails has no converter to apply and it renders Map normally.

Conclusion: always carefully look at your imports if you're working with JSON in Grails!

Edit: Burt suggested that this is a bug. I've submitted JIRA issue here: GRAILS-9622 render as class that is not a codec should throw exception