Built-in helper for "Must" pattern in Go

Is there a more built-in wrapper to make a function that returns (X, error) successfully execute or abort, like regexp.MustCompile?

I'm talking about something like this, but more "built-in".

Since Go 1.18 we can define typed Must instead of interface{}:

func Must[T any](obj T, err error) T {
	if err != nil {
		panic(err)
	}
	return obj
}

How to use: https://go.dev/play/p/ajQAjfro0HG

func success() (int, error) {
	return 0, nil
}

func fail() (int, error) {
	return -1, fmt.Errorf("Failed")
}

func main() {
	n1 := Must(success())
	fmt.Println(n1)
	var n2 int = Must(fail())
	fmt.Println(n2)
}

Must fails inside main, when fail() returns non-nil error

You can even define Mustn for more than 1 return parameter, e.g.

func Must2[T1 any, T2 any](obj1 T1, obj2 T2, err error) (T1, T2) {
	if err != nil {
		panic(err)
	}
	return obj1, obj2
}

There is not. The best you'll get is something like this:

func Must(fn func() (interface{}, error)) interface{} {
    v, err := fn()
    if err != nil {
        log.Fatalln(err)
    }
    return v
}

Then to use it:

Must(func() (interface{}, error) {
    return template.ParseGlob(pattern)
}).(*template.Template)

Assuming that template.ParseGlob(pattern) is the call you wanted to wrap.

Go does not have parametric polymorphism, so this kind of code will end up requiring type assertions to restore the original type and so (in my opinion) is more effort than it's worth. The tidiest, idiomatic error handling you'll get for long chains of potential failure is simply to check for an error, and return it. Defer your cleanup handlers:

func MyFunc() (err error) {
    a, err := blah1()
    if err != nil {
        return
    }
    defer a.Close()
    b, err := blah2(a)
    if err != nil {
        return
    }
    defer b.Close()
    // ad nauseam
}

Long and tedious, but at least it's explicit and easy to follow. Here are two modules I wrote that are crying out for parametric polymorphism that might give you some ideas for dealing without it:

• bitbucket.org/anacrolix/dms/futures
• bitbucket.org/anacrolix/dms/cache

I don't think a built-in mechanism would make sense since you could very well handle a non-nil error in various ways, as does the examples in the template package itself: see "text/template/examplefiles_test.go", illustrating 2 different usage of 'err':

// Here starts the example proper.
	// T0.tmpl is the first name matched, so it becomes the starting template,
	// the value returned by ParseGlob.
	tmpl := template.Must(template.ParseGlob(pattern))

	err := tmpl.Execute(os.Stdout, nil)
	if err != nil {
		log.Fatalf("template execution: %s", err)
	}
	// Output:
	// T0 invokes T1: (T1 invokes T2: (This is T2))

In the particular case of the helper function (*Template) Must(), transforming an error into an exception (panic) isn't always the right course for all go programs (as debated in this thread), and to cover all the possible way to handle an error would mean to create a lot of "built-in" mechanisms.

I have encountered the same problem myself and decided to develop the following solution: https://github.com/boramalper/must

Example:

database := must.MV(sql.Open("sqlite3", "...")).(*sql.DB)
defer must.M(database.Close())

must.M(database.Ping())

// Use MustValVoid (or MVV shortly) if you don't care about
// the return value.
must.MVV(database.Exec(`
    PRAGMA foreign_key_check;
    ...
`))

I am not sure why all the answers here are using the log package, when the
source itself uses panic:

func MustCompile(str string) *Regexp {
   regexp, err := Compile(str)
   if err != nil {
      panic(`regexp: Compile(` + quote(str) + `): ` + err.Error())
   }
   return regexp
}

My recommendation would be instead of a generic Must wrapper, just implement
Must variants as needed in your code.

1. https://github.com/golang/go/blob/go1.16.5/src/regexp/regexp.go#L305-L314