feat: add Join and AsType standard library shortcuts

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

Author: tonistiigi

astype.go

@@ -0,0 +1,10 @@
+//go:build !go1.26
+
+package errors
+
+// AsType finds the first error in err's chain that matches type E,
+// and if so, returns that error value and true.
+func AsType[E error](err error) (E, bool) {
+	var target E
+	return target, As(err, &target)
+}

astype_go126.go

@@ -0,0 +1,13 @@
+//go:build go1.26
+
+package errors
+
+import (
+	stderrors "errors"
+)
+
+// AsType finds the first error in err's chain that matches type E,
+// and if so, returns that error value and true.
+func AsType[E error](err error) (E, bool) {
+	return stderrors.AsType[E](err)
+}

unwrap.go

@@ -34,3 +34,11 @@ func As(err error, target interface{}) bool { return stderrors.As(err, target) }
 func Unwrap(err error) error {
 	return stderrors.Unwrap(err)
 }
+
+// Join returns an error that wraps the given errors.
+// Any nil error values are discarded.
+// Join returns nil if every value in errs is nil.
+// The error formats each wrapped error, separated by newlines.
+func Join(errs ...error) error {
+	return stderrors.Join(errs...)
+}

unwrap_test.go

@@ -3,6 +3,7 @@ package errors
 import (
 	stderrors "errors"
 	"fmt"
+	"io"
 	"reflect"
 	"testing"
 )
@@ -174,3 +175,66 @@ func TestUnwrap(t *testing.T) {
 		})
 	}
 }
+
+func TestJoin(t *testing.T) {
+	err1 := New("err1")
+	err2 := New("err2")
+
+	tests := []struct {
+		name string
+		errs []error
+		want string
+	}{
+		{
+			name: "two errors",
+			errs: []error{err1, err2},
+			want: "err1\nerr2",
+		},
+		{
+			name: "nil filtered",
+			errs: []error{err1, nil, err2},
+			want: "err1\nerr2",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := Join(tt.errs...)
+			if err == nil {
+				t.Fatal("Join() = nil, want non-nil")
+			}
+			if got := err.Error(); got != tt.want {
+				t.Errorf("Join().Error() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestJoinNil(t *testing.T) {
+	if err := Join(); err != nil {
+		t.Errorf("Join() = %v, want nil", err)
+	}
+	if err := Join(nil, nil); err != nil {
+		t.Errorf("Join(nil, nil) = %v, want nil", err)
+	}
+}
+
+func TestAsType(t *testing.T) {
+	err := customErr{msg: "test"}
+	wrapped := Wrap(err, "wrapped")
+
+	got, ok := AsType[customErr](wrapped)
+	if !ok {
+		t.Fatal("AsType[customErr]() = false, want true")
+	}
+	if got != err {
+		t.Errorf("AsType[customErr]() = %v, want %v", got, err)
+	}
+}
+
+func TestAsTypeNotFound(t *testing.T) {
+	err := io.EOF
+	_, ok := AsType[customErr](err)
+	if ok {
+		t.Error("AsType[customErr](io.EOF) = true, want false")
+	}
+}