基于泛型实现异常捕获工具类

package catch

func Try[T any](e func() (T, error)) Catch[T] {
    v, err := e()
    return Catch[T]{err: err, result: v}
}

type Catch[T any] struct {
    err    error
    result T
}

func (c Catch[T]) Catch(handler func(T, error) T) Catch[T] {
    if c.err != nil {
        c.result = handler(c.result, c.err)
    }
    c.err = nil
    return c
}

func (c Catch[T]) Final(handler func(T)) {
    handler(c.result)
}

单测

package catch

import "testing"

type e struct{}

func (a e) Error() string { return "error" }

func TestTryCatch(t *testing.T) {
    Try(func() (int, error) {
        return 0, nil
    }).Catch(func(_ int, err error) int {
        t.Fatalf("catch error: %v", err)
        return 0
    }).Final(func(result int) {
        t.Log("errors: everything is good")
    })

    Try(func() (int, error) {
        return 1, e{}
    }).Catch(func(result int, err error) int {
        t.Logf("captured result: %v", result)
        t.Logf("captured error: %v", err)
        return 1
    }).Final(func(result int) {
        if result != 1 {
            t.Fatalf("cannot capture error")
        }
    })

    Try(func() (int, error) {
        return 1, nil
    }).Final(func(r int) {
        if r != 1 {
            t.Fatalf("result from try block is not as expected")
        }
    })
}