News for hackers. Stuff that matters.
Re:The Next Step for Generics by lenish on Tuesday June 16, 2020 @06:37PM (#23545156)

    func foo() (*SomeType, error) {
        ...
        return someErr
    }

    ...
    result, err := foo()
    if err != nil {
        // handle err
    }
    // handle result
vs

    type Result struct {
        Err error
        Data SomeType
    }

    func (r *Result) HasError() bool {
        return r.Err != nil
    }

    func bar() *Result {
        ...
        return &Result { ... }
    }

    ...
    result := bar()
    if result.HasError() {
       // handle result.Err
    }
    // handle result

I'm not really sure I see the benefit to the latter. In a language with special operators and built-in types it may be easier (e.g. foo()?.bar()?.commit()), but without these language features I don't see how the Result<T> approach is better.
Re:The Next Step for Generics by et1337 on Tuesday June 16, 2020 @06:56PM (#23545342)
Go can't really express the Result<T> approach. In Go, it's up to you to remember to check result.HasError(), just like it's up to you to check if err != nil. If you forget that check, you'll try to access the Data and get a nil pointer exception.

The Result<T> approach prevents you from accessing Data if you haven't handled the error, and it does so with a compile-time error.

Even with Go's draconian unused variable rules, I and my colleagues have been burned more than once by forgotten error checks.

Re:The Next Step for Generics by jatone on Tuesday June 16, 2020 @08:49PM (#23546338)
there are linters that will help you with that.

https://github.com/kisielk/errcheck

https://golangci-lint.run/usage/linters/ has a solid set of options.

Re:The Next Step for Generics by nimish on Wednesday June 17, 2020 @12:47AM (#23547906)
I just wish the linter was integrated into the compiler. And that code that didn't check would simply not compile
Re:The Next Step for Generics by mrkeen on Wednesday June 17, 2020 @11:55AM (#23552873)
> without these language features I don't see how the Result<T> approach is better.

That's the point! I want language features!

I don't want to wait 6 years for the designers to bake some new operator into the language. I want rich enough expression so that if '?.' is missing I just throw it in as a one-liner.

Generics is one such source of richness.

Re:The Next Step for Generics by whateveracct on Wednesday June 17, 2020 @03:47AM (#23548901)
A language with sun types will express Result as Success XOR Failure. And then to access the Success, the compiler will force you to go through a switch statement that handles each case.
Re:The Next Step for Generics by apta on Tuesday June 16, 2020 @11:55PM (#23547586)
The alternative is not the Result type you defined, but something along the lines of what languages like Rust or Haskell define: https://doc.rust-lang.org/std/result/