Generics are wrapping up, and I’ve just implemented built-in types at last, so I’m starting to think ahead to next tasks. One of them is exception handling, and I have an idea that combines throwables and standard return types in a way that should settle the “checked vs unchecked” exceptions battle for good. Take that, Java!
Checked exceptions in Java are useful for defining edge cases at API boundaries. For instance, all sorts of things can go wrong in a SQL query, and it makes sense for the entry point to the SQL API to declare, “hey, this method can throw a
SqlException, and you should know that.”
But sometimes the best you can do with that exception is to propagate it. This results in a whole bunch of methods declaring
throws SqlException (or
throws IOException, or, if the programmer is a bit lazy, the infamous
throws Exception). Eventually you get to a method like
Runnable::run that can’t throw any checked exceptions, so you just handle the exception generically, probably by wrapping it in a
RuntimeException and throwing that. Yo dawg, I heard you like exceptions.
So, the problem is that one piece of code wants to treat
SqlException as a checked exception, while another wants to treat it as an unchecked exception. Java doesn’t let you do that.
In Effes, there’ll be two ways to handle an exception: by throwing it, or by returning it. This is where the dynamic nature of disjunctive types comes into play.
All exceptions will be unchecked in Effes, meaning that you can throw them willy-nilly:
executeQuery (query: String) -> QueryResult: throw SqlException("dummy SQL engine") -- unchecked
But a method can also include an exception as one of its return type disjunctions:
runQuery (query: String) -> QueryResult | SqlException: return SqlException("dummy SQL engine") -- "checked"
The latter method essentially turns the exception into a checked exception, because the resulting variable is a disjunction that has to be picked apart with a case statement:
query = runQuery "SELECT * FROM bobby_tables" summary = case query of: SqlException(msg): throw query SqlResults: summarize query
Note that in this snippet, we converted
SqlException from a “checked” exception (in that it was a disjunction in the result type) to unchecked, just by throwing it.
Moreover, if a method declares an exception as part of its return type, then it’ll never throw it. Trying to throw it from the method directly results in a compile-time exception, and if it’s thrown from down the stack, it’ll be returned immediately. It’s essentially shorthand for:
runQuery (query: String) -> QueryResult | SqlException: try: <whatever> catch (SqlException e) return e
This lets us easily convert unchecked
SqlExceptions thrown from
<whatever> to the equivalent checked exceptions — thus providing that API border we wanted.