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 any) 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"
 	"testing"
 )
 
@@ -173,3 +174,93 @@ 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 TestWrapAsType(t *testing.T) {
+	err := customErr{msg: "test"}
+	wrapped := Wrap(err, "wrapped")
+
+	tests := []struct {
+		name string
+		fn   func(error) (customErr, bool)
+	}{
+		{name: "AsType", fn: AsType[customErr]},
+		{name: "stderrors.AsType", fn: stderrors.AsType[customErr]},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := tt.fn(wrapped)
+			if !ok {
+				t.Fatalf("%s[customErr]() = false, want true", tt.name)
+			}
+			if got != err {
+				t.Errorf("%s[customErr]() = %v, want %v", tt.name, got, err)
+			}
+		})
+	}
+}
+
+func TestAsTypeNotFound(t *testing.T) {
+	err := io.EOF
+	assertNotFound := func(name string, ok bool) {
+		t.Helper()
+		if ok {
+			t.Errorf("%s[customErr](io.EOF) = true, want false", name)
+		}
+	}
+
+	tests := []struct {
+		name string
+		fn   func(error) (customErr, bool)
+	}{
+		{name: "AsType", fn: AsType[customErr]},
+		{name: "stderrors.AsType", fn: stderrors.AsType[customErr]},
+	}
+
+	for _, tt := range tests {
+		_, ok := tt.fn(err)
+		assertNotFound(tt.name, ok)
+	}
+}