How to Implement Generic Error Handling in Go Without Generics?

Implementing Generic Error Handling in Go

Go's absence of generic capabilities poses challenges when attempting to generalize functionalities. A common scenario is the need for a generic error handling function applicable to any function returning a value and an error.

The provided example demonstrates an attempt to create such a function using an empty interface:

<code class="go">func P(any interface{}, err error) (interface{}) {
    if err != nil {
        panic("error: "+ err.Error())
    }
    return any
}</code>

While this approach works for error handling, it loses type information, leaving the resulting interface empty.

Generating Type-Specific Error Handling Functions

To avoid the issue of lost type information, consider using code generation to create specialized implementations of the error handling function for different types. This can be achieved using tools like "go generate", "gengen", "genny", or "gen".

For example, using "gen", you can define a template:

<code class="text">// template.go

package main

import "fmt"

func P[T any](v T, err error) (T) {
    if err != nil {
        panic(fmt.Sprintf("error: %v", err))
    }
    return v
}</code>

This template can be used to generate type-specific implementations of P():

<code class="sh">gen generate</code>

This will create implementations such as:

<code class="go">// p_int.go

package main

func PInt(v int, err error) (int) {
    if err != nil {
        panic(fmt.Sprintf("error: %v", err))
    }
    return v
}</code>

By using these generated functions, type information is preserved and the error handling can be applied to specific types seamlessly.

The above is the detailed content of How to Implement Generic Error Handling in Go Without Generics?. For more information, please follow other related articles on the PHP Chinese website!