Remainder in pattern matching

[Dan Heidinga]

The rules regarding NPE, ICCE and MatchException look reasonable to me.


> As a separate but not-separate exception problem, we have to deal with at least two additional sources of exceptions:
>
>  - A dtor / record acessor may throw an arbitrary exception in the course of evaluating whether a case matches.
>
>  - User code in the switch may throw an arbitrary exception.
>
> For the latter, this has always been handled by having the switch terminate abruptly with the same exception, and we should continue to do this.
>
> For the former, we surely do not want to swallow this exception (such an exception indicates a bug).  The choices here are to treat this the same way we do with user code, throwing it out of the switch, or to wrap with MatchException.
>
> I prefer the latter -- wrapping with MatchException -- because the exception is thrown from synthetic code between the user code and the ultimate thrower, which means the pattern matching feature is mediating access to the thrower.  I think we should handle this as "if a pattern invoked from pattern matching completes abruptly by throwing X, pattern matching completes abruptly with MatchException", because the specific X is not a detail we want the user to bind to.  (We don't want them to bind to anything, but if they do, we want them to bind to the logical action, not the implementation details.)

My intuition (and maybe I have the wrong mental model?) is that the
pattern matching calling a user written dtor / record accessor is akin
to calling a method.  We don't wrap the exceptions thrown by methods
apart from some very narrow cases (ie: reflection), and I thought part
of reflection's behaviour was related to needing to ensure exceptions
(particularly checked ones) were converted to something explicitly
handled by the caller.

If the dtor / record accessor can declare they throw checked
exceptions, then I can kind of see the rationale for wrapping them.
Otherwise, it seems clearer to me to let them be thrown without
wrapping.

I don't think we expect users to explicitly handle MatchException when
using pattern matching so what does wrapping gain us here?

--Dan