Golang returning nil does not return nil

Question

I created a custom error type to wrap errors around for easier debugging in Golang. It works when there are errors to print, but now it is causing a panic.

Demo

type Error struct {
    ErrString string
}

func (e *Error) Error() string {
    return e.ErrString
}

func Wrap(err error, str string) *Error {
    if err == nil {
        return nil
    }
    e := &Error{
        ErrString: str + err.Error(),
    }
    return e
}

When I call a function an it doesn't return an error, I should still be able to wrap the error.

The expected behavior is that if the error is nil, it should simply ignore it, unfortunately it does the opposite.

func foo() error {
    err := bar()
    return Wrap(err, "bar called")
}

func bar() error {
    return nil
}

func main() {
    err := foo()
    if err != nil {
        fmt.Printf("Found error %v\n",err)
        return
    }
    fmt.Println("No Errors")
}

I expect it to print No errors. Instead it prints Found error <nil> even though the error is nil.

See duplicate: Hiding nil values, understanding why golang fails here — icza
– icza, Commented Dec 22, 2018 at 16:51

pigeonhands · Accepted Answer · 2018-12-22 02:26:45Z

7

if err != nil

Is comparing a the err variable to a nil error , but its actually a nil *Error

Changing the code to

err:=foo()
var  nilerror *Error = nil
if err != nilerror {
    fmt.Printf("Found error %v\n",err)
    return
}
fmt.Println("No Errors")

Yields the predicted result.

answered Dec 22, 2018 at 2:26

pigeonhands

3,47420 silver badges30 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Ibu Over a year ago

Now it makes sense. my Wrap function was returning a *Error nil, not an error nil.

mehlichmeyer Over a year ago

is it possible to change the custom error so that it will work with (if err != nil), instead of having to check against a declared nil pointer?

peterSO · Accepted Answer · 2018-12-22 02:45:34Z

2

type error

The error built-in interface type is the conventional interface for representing an error condition, with the nil value representing no error.
type error interface {
    Error() string 
}

The value of err of interface type error is not nil. It is the value nil of type *main.Error. In fact, err != nil && err.(*Error) == nil is true

For example,

package main

import (
    "fmt"
)

func error1() {
    err := foo()
    fmt.Printf("%T %v %v %v\n", err, err, err == nil, err.(*Error) == nil)
    if err != nil {
        fmt.Printf("Found error %v\n", err)
        return
    }
    fmt.Println("No Errors")
}

func error2() {
    err := foo()
    fmt.Printf("%T %v %v %v\n", err, err, err == nil, err.(*Error) == nil)
    if err != nil && err.(*Error) != nil {
        fmt.Printf("Found error %v\n", err)
        return
    }
    fmt.Println("No Errors")
}

type Error struct {
    ErrString string
}

func (e *Error) Error() string {
    return e.ErrString
}

func Wrap(err error, str string) *Error {
    if err == nil {
        return nil
    }
    e := &Error{
        ErrString: str + err.Error(),
    }
    return e
}

func foo() error {
    err := bar()
    return Wrap(err, "bar called")
}

func bar() error {
    return nil
}

func main() {
    error1()
    fmt.Println()
    error2()
}

Playground: https://play.golang.org/p/nwNRa2sNwj0

Output:

*main.Error <nil> false true
Found error <nil>

*main.Error <nil> false true
No Errors

edited Dec 22, 2018 at 2:45

answered Dec 22, 2018 at 2:26

peterSO

168k32 gold badges303 silver badges293 bronze badges

3 Comments

Ibu Over a year ago

Then how could I rewrite the Wrap function to take the type into consideration?

Ibu Over a year ago

It took a while but now I understand. Basically for my case, Wrap will return error not my custom Error.

peterSO Over a year ago

@Ibu: No. foo, not Wrap, will return type error, not your custom type *Error. error is an interface type.

Joris · Accepted Answer · 2018-12-22 11:19:05Z

2

Since your Error type implements the error interface, the easiest solution, is to return an error in Wrap():

func Wrap(err error, str string) error {
    if err == nil {
        return nil
    }
    e := &Error{
        ErrString: str + err.Error(),
    }
    return e
}

answered Dec 22, 2018 at 11:19

Joris

8811 gold badge8 silver badges17 bronze badges

Comments

xblymmx · Accepted Answer · 2022-02-17 08:30:07Z

0

Change foo() return value to *Error

func foo() error {
    err := bar()
    return Wrap(err, "bar called")
}

Or:

func Wrap(err error, str string) error{
    if err == nil {
        return nil
    }
    e := &Error{
        ErrString: str + err.Error(),
    }
    return e
}

answered Feb 17, 2022 at 8:30

xblymmx

593 silver badges3 bronze badges

Collectives™ on Stack Overflow

Golang returning nil does not return nil

4 Answers 4

2 Comments

3 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related