News for hackers. Stuff that matters.
Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @03:31PM (#38234212)
Because handling errors is important for complex programs. Whether errors-as-values or exceptions or aborts are the best option, being able to write a program that handles errors well makes it that much more robust. Don't want some weird behavior happening when the program should've noticed an error and dealt with it somehow.
Re:Fourteen Years of Go by randomdata on Saturday November 11, 2023 @05:02PM (#38235014)
Handing values is important for all programs. You don't want some weird behaviour happening in any case. If you are writing a system that turns on a heater when the temperature falls below freezing, you're going to have a really bad time if you forget to handle the temperature.

So, yes, it makes sense to have constructs that can help with that problem, but it would be weird to have such constructs only for what a human considers an error condition. You would want that for every case that needs to be handled.

Otherwise you have to resort to testing, and if you accept that testing is good enough to ensure that you don't forget to check the temperature, then it also good enough to ensure that you have checked an error. There is nothing special about the error case. It's just another state like any other.

Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @05:16PM (#38235135)
Well, I think that's why a lot of people are disappointed that Go doesn't quite have sum types, because sum types do increase expressivity around values in general. That they improve error handling is just one application.
Re:Fourteen Years of Go by randomdata on Saturday November 11, 2023 @05:40PM (#38235320)
There seems to be no consensus as to what sum types actually means, but the most popular definition I find in my travels is: Tagged unions.

While Go might benefit from tagged unions, I'm not sure they actually help in any way with errors. There is no other type at play, so there is nothing to union with. Maybe if you have different kinds of errors you might union different error types, but even just one type of error state is prone to the forgetting to handle it problem.

But perhaps you are of another sum type school? Perhaps one of the other sum type definitions are useful here?

Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @05:43PM (#38235343)
Tagged union is a good definition. I was thinking of Rust's Result type, which has Ok(some value) and Err(some value) variants.
Re:Fourteen Years of Go by randomdata on Saturday November 11, 2023 @05:58PM (#38235453)
Right. See that doesn't help, at least not in the context of Go without any other modifications. Logically, you can reduce that Result state to a simple boolean (Ok = true, Err = false). But the bool type in Go is prone to the very same problem.

It doesn't matter how many type layers you add. The problem is that there is nothing in the language that enforces handling of values, no matter what type that value might be.

Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @06:23PM (#38235626)
Yes, manual tagging doesn't provide type safety. That's why I said some people are disappointed that Go doesn't have sum types. There isn't even a convoluted workaround either, at least not a full one.
Re:Fourteen Years of Go by randomdata on Saturday November 11, 2023 @07:09PM (#38235893)
It is not so much a matter of lack of type safety, it is forgetting to implement an application requirement.

Even an advanced type system capable of formal proofs isn't going to help you if you've forgotten the requirement when defining the types. And if you are using a language with a lesser type system (Go, Rust, any language you are likely to use in the real word), and haven't forgotten the requirement, then you would have encoded that knowledge in tests instead, making the forgetfulness in implementation ultimately immaterial. After all, there is no practical difference between learning that you forgot to implement logic by the compiler telling you or the test suite telling you.

So, we can infer that the OP is talking about where one straight up forgot about the requirement from start to finish. I'm skeptical that there is any technical solution to that problem, but sum types most certainly isn't it.

Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @07:27PM (#38236006)
There is a point at which even dependent typing won't save you, but sum types are a useful tool to reduce negligence. Don't let perfect be the enemy of good.
Re:Fourteen Years of Go by randomdata on Saturday November 11, 2023 @07:45PM (#38236126)
Sum types are useful tool, but they are not helpful in this particular case. There is nothing about sum types that would help avoid this problem in the slightest. Perfect need not be the enemy of good, but good is not equivalent to not even trying.

This is not a general "wouldn't it be nice of Go had..." thread. We are talking about a specific problem.

Re:Fourteen Years of Go by vacuity on Saturday November 11, 2023 @08:04PM (#38236239)
I'm not really sure what your point is then. We should have comprehensive tests and therefore error checking isn't special compared to other programming mistakes? I think we should both have tests (don't skimp on them if given time, of course) and use tools like sum types to write more robust programs from the get-go. Errors can even be treated like other values using sum types; that raises the bar universally instead of just improving error checking.
Re:Fourteen Years of Go by randomdata on Sunday November 12, 2023 @12:43PM (#38242374)
The point is to stay on topic. In what way do you believe sum types solve the problem being discussed?
Re:Fourteen Years of Go by vacuity on Sunday November 12, 2023 @01:12PM (#38242629)
If you're going to invoke some abstract "the programmer doesn't know what they're doing" situation, I'm not sure how to continue this discussion. Even testing may not help in that case. Things are going to slip through the cracks. Having features like sum types is a way to generally reduce the likelihood of such semantic errors.

Besides, the original topic was that Go doesn't make its error handling very foolproof. Sum types help with that and don't make error handling special, so I really don't see your point. Why not write everything in Brainfuck then? Everything is uniform and simple. Well, it's simple to the point that it's way too easy to make mistakes.

Re:Fourteen Years of Go by randomdata on Sunday November 12, 2023 @03:51PM (#38243970)
The original topic was, stated quite explicitly, that it is easy to forget to handle errors in Go. There is nothing about sum types, as defined, that addresses that concern.

Like we established in my very first comment, well before you even showed up, the handling forgetfulness problem exists for all types. That would include a hypothetical (tagged) union type. I did question if you were using some other definition of sum types, as there isn't a great consensus on what sum types actually mean, but you did confirm you were thinking of tagged unions...

But it must be that you didn't actually mean tagged unions. What is the definition of sum types that you are using here that would help with the stated problem?

Re:Fourteen Years of Go by vacuity on Sunday November 12, 2023 @05:21PM (#38244704)
There may be a misunderstanding. I say "sum type" to mean something along the lines of Rust's enum: a value stores both a tag and its data, and pattern matching distinguishes the variants (like a switch statement). It's a tagged union where the interpretation of the tag is managed by the compiler. The underlying value can't be used without extracting the variant with pattern matching. Even if the success and failure variants both contain an integer, you can't add an integer with this value.
Re:Fourteen Years of Go by randomdata on Monday November 13, 2023 @10:25AM (#38251241)
And how do you think that solves the problem? Consider:

   func foo() error
With the programmer forgetting to handle the error:

   foo()
Now imagine that Go received some kind of hypothetical Result type that matches what you describe. The foo function is updated to use it.

   func foo() Result[error]
But the problem remains... The compiler still isn't going to tell you that you forgot to handle the error.
Re:Fourteen Years of Go by vacuity on Monday November 13, 2023 @05:13PM (#38256095)
So you're saying the programmer forgets to use the return value at all. There are linters, documentation, and basic common sense. This is not at all a relevant issue, or else there are serious issues with the programs you see. Why are you discussing whether Go's error handling needs improvement if your imagined programmer can't even program? Well, I've spent enough time on this thread.
Re:Fourteen Years of Go by randomdata on Monday November 13, 2023 @07:26PM (#38257240)
> So you're saying the programmer forgets to use the return value at all.

That's what the original commenter said. Logically, how else could you forget to handle the error? The compiler will bitch and moan if you do capture the result and then don't do anything with it. You did take the time to read the thread before replying, yes?

> This is not at all a relevant issue

It must be, else how do you explain the many comments you wrote trying to explain how sum types solves the problem? Even while I continually told you they don't.

> Why are you discussing whether Go's error handling needs improvement if your imagined programmer can't even program?

I said that it doesn't need improvement because in practice your tests will catch the problem immediately anyway. I even said that it is probably fundamentally impossible for there to be technical solution to the problem.

And the rest of the time was telling you that sum types cannot solve the problem, despite your constant urging. I am still not clear how you think sum types solve the problem.

> Well, I've spent enough time on this thread.

Are you sure you spent any time on this thread?

Re:Fourteen Years of Go by erik_seaberg on Saturday November 11, 2023 @11:14PM (#38237235)
An error signals that a non-error value you were relying on will not be available. Control flow should nearly always change in response to that, often drastically. That’s why a language should provide a caller-controlled non-local exit from a futile chain of calls. Many languages only do that for errors, and it’s not a major limitation when users can define errors.
Re:Fourteen Years of Go by randomdata on Monday November 13, 2023 @10:14AM (#38251091)
> An error signals that a non-error value you were relying on will not be available.

Except the non-error value should always be available, even if that means relying on the zero value. Zero values should be useful. An error state is an independent state. It should also be useful without any other values.

While the caller may choose to use the error state to make decisions about other state, it is faulty API design to force that upon the caller.

Re:Fourteen Years of Go by erik_seaberg on Tuesday November 14, 2023 @12:50PM (#38266788)
Many domains have no meaningful zero value. If “getUserByID” returns a fake user, anything you do with him will be incorrect, if you don’t panic and die (as zeroes of builtin types often do).
Re:Fourteen Years of Go by randomdata on Friday November 17, 2023 @08:43AM (#38303415)
> If “getUserByID” returns a fake user

Logically, getUserByID returns nil when there is no user, not a fake user. The caller can then check for its nil-ness without needing to consider the error value. nil is a useful value. For better or worse, nil is how Go convention represents the absence of a value. In fact, convention sees error also rely on nil to be useful in the very same way.

It's funny how people completely forget how to write software as soon as they see the word error. Why is that?