Any updates regarding the if-hell of error handling?

They spent months consolidating feedback and made two proposals. The community didn't want change. Now they are no longer working on it and are focusing on getting generics out.

I would guess they start looking into it again after the generics transition is done. But I think it is a good practice not to force things but let certain ideas rest, if no agreement can be reached. Probably the best solution hasn't been found yet :)

"Try another language instead" is always a valid option.

There isn't anything wrong with a language just not jiving with your sensibilities.

Problem is, perfect language with perfect libraries and perfect tools doesn't exist.

Somewhere in the middle of Go, Julia and Rust is the programming language I'd really like to use.

I'd throw in Swift into the mix

I just took another fresh look at it and on the surface the syntax looks really attractive.

No, it's not. It's just being dismissive because your wants are being met by the current state.

(Not attacking you) Do you write a substantial amount of Go very frequently?

I have never used golang but from my reading of the type parameters proposal, it also includes an approximation of "Sum types".

You can define an interface with a closed set of types

type Number interface { float64, int64, ... }

Now, the value will be boxed, so you will not have no-allocation sum types but you can approximate boxed sum types with this I think.

Approximating closed sum types is easy already, by creating an interface with a stub private method and implementing it for all variants. Then it's not possible to implement it using a type outside of that package.

The main thing that's lacking is compile time checks whether variant matching is exhaustive.

THIS ! and "pattern-matching" :)

So, in the end all of languages move closer to StandardML :D Like even python has sum-types and pattern matching now!

Lol I know I know... but it is so useful :)

That would be awesome!

And exceptions :)

Please, just not exceptions.

Too late, Go already has exceptions since 1.0.

Indeeed,

    func ThrowIfError(err error) {
        if err != nil {
            panic(err)
        }
    }
    // ....
    name, err := FuncWithError()
    ThrowIfError(err)

Panic and recover already exist, which are semantically exceptions.

Were there discussions? What is the general impression, is there hope?