Java also has chained exceptions, done manually

[Andrei Alexandrescu]

On 9/7/18 7:15 PM, Tobias Mueller wrote:
> On Thursday, 6 September 2018 at 14:39:12 UTC, Andrei Alexandrescu wrote:
>> Second, it does pay to keep abreast other languages. I had no idea 
>> (and am quite ashamed of it) that Java also has chained exceptions:
>>
>> https://www.geeksforgeeks.org/chained-exceptions-java/
> 
> Now I'm surprised... is there a language (except C++) that supports 
> exceptions that does _not_ have it?
> Java: getCause()
> C#: InnerException
> PHP: getPrevious()
> ...

David Nadlinger wrote that Python also has them.

> I think chained exception in D is semantically very different from other 
> languages like Java.
> 
> In languages like Java or C# the exception chain has nothing to do with 
> saving exceptions that are thrown in finally blocks.
> Instead the chain is used for a layer model. The "outer" exception is 
> the higher level exception and the "inner" exception is the lower level 
> cause of the higher level exception.
> 
> Often a low level exception is quite meaningless when thrown over 
> multiple levels in the call stack.
> For example, imagine a program that uses a configuration file. While 
> parsing the configuration, a misformatted number is encountered.
> If the NumberFormatException is propagated to the top level, it is 
> basically useless for programmatic error handling.
> This is much better:
> ConfigurationException -> JsonParsingException -> NumberFormatException
> 
> The higher level exceptions are therefore directly caused by the lower 
> level exception and always thrown _directly_ in the catch block where 
> the lower level exception is catched and readily available. Not in a 
> finally block and not indirectly in a function called from the catch block.
> Manually passing the inner exception to the constructor of the outer 
> exception is trivial and IMO the right thing, because it's probably not 
> always wanted.
> 
> Now in D, chained exceptions work differently.
> The first exception that is thrown is deemed the "important" exception 
> and later exceptions are simply chained to it. A direct semantic 
> connection between the exceptions is not possible at all, since the 
> later exception has no knowledge about the first exception at all.
> It also means that the order of the exceptions is reversed. The first 
> exception is the "outer" exception which is the exact opposite of how it 
> is meant in Java.
> 
> When handling an exception, it's not clear at all what those additional 
> exceptions mean and how they should be handled.
> 
> Personally I find the Java/C# model much more useful.

Well indeed the upper you are on the stack, the more likely you are in a 
high-level function. It's a good heuristic. Sadly we cannot change 
chaining semantics now, but it does stand to reason to print the last 
exception in a chain, instead of the head, as the most relevant cause. 
Guess we'd do good to have such functionality in the stdlib.


Andrei