Many errors in go are simply: var ErrFoo = errors.New("error doing Foo") Sometimes if you want an error to have a specific type, but have a custom error m

Many errors in go are simply: var ErrFoo = errors.New("error doing Foo") Sometimes if you want an error to have a specific type, but have a custom error message with context in it (like the name of the file that was missing, for ErrFileNotFound) you can do something like this: type ErrBar struct { error } Then you can return errors of that type thusly: func Do(s string) error { // ... return ErrBar{ fmt.Errorf("failed to use %q", s) } } Finally, a lot of the time you just want to give the caller some information about an error you received from a function you called, so you just wrap it thusly: func DoIt() error { // ... if err := parseConfig(); err != nil { return fmt.Errorf("can't parse foo config: %s", err) } } That'll give you an error with a useful message (adding context to the error from getConfig), but with an anonymous type. And since errors are just regular values, you can check for them in all the same ways you would for any other value (== for errors that are static values, type assertions to check for the type, etc). It's not super different from Rust's errors, except that with embedding and the implicit interfaces, you don't have to explicitly tell the compiler quite so much to make your error a valid error. Rust's main difference is the ability to define some automatic conversions and the try! macro that will do an automatic return if the call fails... which are definitely cool.