Hacker News Reader

Comment by vips7L | Hacker News Reader

The modern language landscape has not backed away from checked errors. Rust is praised for its checked errors, countless posts on this forum praise Result<T> in multiple languages. Swift has checked errors and Kotlin is implementing them via union types in the near future.

Checked errors, via results or exceptions have never been the problem. It has always been Java the language that hasn't provided the syntax sugar for handling checked errors effectively.

There is no difference between:

    A doIt() throws B
    fun doIt(): Result<A, B>

It all comes down to what the language lets you do once you encounter that error.

View on HN

There is a huge difference: the first is an _exception_, which:

- Unwinds the stack to a try/catch or exception handler, making exceptions practically difficult to deal with in concurrent programming.

- If unchecked, can be ignored, silently propagating during stack unwinding.

- If checked, infects the call stack with 'throws' annotations.

The second is a normal return value, with no try/catch needed, handling the error case is mandatory in order to handle the success case, and there is not a separate execution regime occurring whenever an error case is encountered.

I genuinely disagree. There is no difference between a checked exception and a Result.

- In concurrent programming uncaught exceptions won’t leave the future. Both values are available to you just like Results. I also don’t think arguments for concurrent programming are valid though. 99% of all code is single threaded.

- It is checked.

- Result infects the call stack as well.

- handling the error case with a checked exception is also mandatory with handling the success case. There is no separate “execution regime”. What is the difference here:

    val a = try {
        a();
    } catch (b) {
        onB();
    }
    
    val a = match (a()) {
        Success(a) => a
        Failure(b) => onB()
    }

The difference is you can just call

    val a = a();

And start the stack unwinding. The `try/catch` is not mandatory to call a().

You definitely just don't know how checked exceptions work. This is not true at all. The compiler will not let you call a(); without handling the exception or checking it up the stack. The same way results work.

Is Rust praised for its checked errors? I've personally found it extremely verbose since there essentially is no possibility for unchecked errors.

Also, external crates like "anyhow" are required if you don't want to account for literally every single possible error case. Really seems like a pedantic's dream but a burden to everyone else.

Effective Java recommends checked exceptions only in the case where the caller may recover, but in practice you're usually just propagating the error to the caller in some form, so almost everything just becomes unchecked runtime exceptions.

I'm only saying what I've seen here. I typically see praise for Rust's checked errors. Especially since they provide ? to panic and uncheck them. Personally I disagree with Bloch, if you are the thrower you can't possibly know if the caller can or cannot recover from your error so in my opinion its best to check it. If you are not the thrower and you can't recover from it I prefer to uncheck them, because if I can't recover my caller most likely can't either.

The issue really just arises with Java not giving you the capability to uncheck that error easily if you can't recover from it. For example, you need a ton of lines to uncheck:

    A doIt() throws B {
       throw new B();
    }

    void usingIt() {
       A a;
       try {
           a = doIt();
       } catch (B b) {
           throw new RuntimeException(b);
       }
       
       a.woohoo();
    }

My ideal situation would be for some sort of throws unchecked operator (or whatever syntax we want to bikeshed over) that turns them into unchecked exceptions.

    void usingIt() throws unchecked B {
        var a = doIt();
        a.woohoo();
    }

Have you heard of the language elm? The language elm is so safe that it is literally impossible to crash the program short of a memory error.

That's essentially the direction of modern programming languages. It's part of that feeling you get when programming haskell. Once you get it running, it just works. It's very different from the old paradigm where once you get it working, it can crash and you have to debug and do more to get it working better.

Looks like a huge difference to me. The first function throws an error. The second function may not even return an error.

The first function may not return an error either.

Reply on news.ycombinator.com