Add labeled and sentinel errors (#9)

Author: vearutop

error.go

@@ -226,3 +226,69 @@ func (se structuredError) MarshalText() ([]byte, error) {
 func (se structuredError) MarshalJSON() ([]byte, error) {
 	return json.Marshal(se.err.Error())
 }
+
+// SentinelError is a constant error.
+type SentinelError string
+
+// Error returns error message.
+func (e SentinelError) Error() string {
+	return string(e)
+}
+
+// LabeledError adds indicative errors to an error wrap.
+//
+// Labels could be checked with errors.Is, errors.As.
+// Error message remains the same with original error.
+func LabeledError(err error, labels ...error) error {
+	return labeledError{
+		err:    err,
+		labels: labels,
+	}
+}
+
+type labeledError struct {
+	err    error
+	labels []error
+}
+
+// Error returns message.
+func (le labeledError) Error() string {
+	return le.err.Error()
+}
+
+// Is returns true if err matches original error or any of labels.
+func (le labeledError) Is(err error) bool {
+	if errors.Is(le.err, err) {
+		return true
+	}
+
+	for _, l := range le.labels {
+		if errors.Is(err, l) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// As returns true if original error or any of labels can be assigned to v.
+//
+// If multiple assignations are possible, only first one is performed.
+func (le labeledError) As(v interface{}) bool {
+	if errors.As(le.err, v) {
+		return true
+	}
+
+	for _, l := range le.labels {
+		if errors.As(l, v) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Unwrap returns original error.
+func (le labeledError) Unwrap() error {
+	return le.err
+}

error_test.go

@@ -222,3 +222,28 @@ func BenchmarkWrapError(b *testing.B) {
 	}
 	ctxd.LogError(ctx, err, logFunc)
 }
+
+func TestSentinelError_Error(t *testing.T) {
+	assert.EqualError(t, ctxd.SentinelError("failed"), "failed")
+}
+
+func TestLabeledError(t *testing.T) {
+	err1 := errors.New("failed")
+	label1 := ctxd.SentinelError("miserably")
+	label2 := ctxd.SentinelError("hopelessly")
+
+	err := ctxd.LabeledError(fmt.Errorf("oops: %w", err1), label1, label2)
+
+	assert.True(t, errors.Is(err, err1))
+	assert.True(t, errors.Is(err, label1))
+	assert.True(t, errors.Is(err, label2))
+
+	// Labels do not implicitly contribute to error message.
+	assert.Equal(t, "oops: failed", err.Error())
+
+	// If there are two matches, only first is returned.
+	var se ctxd.SentinelError
+
+	assert.True(t, errors.As(err, &se))
+	assert.Equal(t, "miserably", string(se))
+}

example_test.go

@@ -92,3 +92,32 @@ func ExampleWrapError() {
 	// error: something failed {"field1":1,"field2":"abc","field3":3}
 	// warn: wrapped: something failed {"field1":1,"field2":"abc","field3":3,"field4":true,"field5":"V"}
 }
+
+func ExampleLabeledError() {
+	err1 := errors.New("failed")
+	label1 := ctxd.SentinelError("miserably")
+	label2 := ctxd.SentinelError("hopelessly")
+
+	err := ctxd.LabeledError(fmt.Errorf("oops: %w", err1), label1, label2)
+
+	fmt.Println("err is err1:", errors.Is(err, err1))
+	fmt.Println("err is label1:", errors.Is(err, label1))
+	fmt.Println("err is label2:", errors.Is(err, label2))
+
+	// Labels do not implicitly contribute to error message.
+	fmt.Println("error message:", err.Error())
+
+	// If there are two matches, only first is returned.
+	var se ctxd.SentinelError
+
+	fmt.Println("err as &se:", errors.As(err, &se))
+	fmt.Println("err as value:", string(se))
+
+	// Output:
+	// err is err1: true
+	// err is label1: true
+	// err is label2: true
+	// error message: oops: failed
+	// err as &se: true
+	// err as value: miserably
+}