Move "underlying errors" into property.

benchmark                         old ns/op     new ns/op     delta
BenchmarkAllocProperty/props0     83.0          67.7          -18.43%
BenchmarkAllocProperty/props1     172           148           -13.95%
BenchmarkAllocProperty/props2     292           262           -10.27%
BenchmarkAllocProperty/props3     443           375           -15.35%
BenchmarkAllocProperty/props4     624           530           -15.06%
BenchmarkAllocProperty/props5     828           713           -13.89%
BenchmarkAllocProperty/props6     1062          969           -8.76%
BenchmarkAllocProperty/props7     1375          1099          -20.07%
BenchmarkAllocProperty/props8     1591          1297          -18.48%

benchmark                         old allocs     new allocs     delta
BenchmarkAllocProperty/props0     1              1              +0.00%
BenchmarkAllocProperty/props1     3              3              +0.00%
BenchmarkAllocProperty/props2     6              6              +0.00%
BenchmarkAllocProperty/props3     10             9              -10.00%
BenchmarkAllocProperty/props4     14             13             -7.14%
BenchmarkAllocProperty/props5     19             18             -5.26%
BenchmarkAllocProperty/props6     25             24             -4.00%
BenchmarkAllocProperty/props7     32             28             -12.50%
BenchmarkAllocProperty/props8     37             33             -10.81%

benchmark                         old bytes     new bytes     delta
BenchmarkAllocProperty/props0     96            64            -33.33%
BenchmarkAllocProperty/props1     240           176           -26.67%
BenchmarkAllocProperty/props2     432           336           -22.22%
BenchmarkAllocProperty/props3     672           496           -26.19%
BenchmarkAllocProperty/props4     912           704           -22.81%
BenchmarkAllocProperty/props5     1200          960           -20.00%
BenchmarkAllocProperty/props6     1536          1264          -17.71%
BenchmarkAllocProperty/props7     1920          1472          -23.33%
BenchmarkAllocProperty/props8     2208          1728          -21.74%

Author: funny-falcon

builder.go

@@ -12,7 +12,6 @@ type ErrorBuilder struct {
 	errorType     *Type
 	message       string
 	cause         error
-	underlying    []error
 	mode          callStackBuildMode
 	isTransparent bool
 }
@@ -93,14 +92,14 @@ func (eb ErrorBuilder) WithConditionallyFormattedMessage(message string, args ..
 
 // Create returns an error with specified params.
 func (eb ErrorBuilder) Create() *Error {
-	return &Error{
+	err := &Error{
 		errorType:   eb.errorType,
 		message:     eb.message,
 		cause:       eb.cause,
-		underlying:  eb.underlying,
 		transparent: eb.isTransparent,
 		stackTrace:  eb.assembleStackTrace(),
 	}
+	return err
 }
 
 type callStackBuildMode int

error.go

@@ -10,13 +10,15 @@ import (
 // At the moment of creation, Error collects information based on context, creation modifiers and type it belongs to.
 // Error is mostly immutable, and distinct errors composition is achieved through wrap.
 type Error struct {
-	message     string
-	errorType   *Type
-	cause       error
-	underlying  []error
-	stackTrace  *stackTrace
-	transparent bool
-	properties  *propertyMap
+	message    string
+	errorType  *Type
+	cause      error
+	stackTrace *stackTrace
+	// properties are used both for public properties inherited through "transparent" wrapping
+	// and for some optional per-instance information like "underlying errors"
+	properties    *propertyMap
+	transparent   bool
+	hasUnderlying bool
 }
 
 var _ fmt.Formatter = (*Error)(nil)
@@ -35,21 +37,25 @@ func (e *Error) WithProperty(key Property, value interface{}) *Error {
 // Note that these errors make no other effect whatsoever: their traits, types, properties etc. are lost on the observer.
 // Consider using errorx.DecorateMany instead.
 func (e *Error) WithUnderlyingErrors(errs ...error) *Error {
-	errorCopy := *e
-
-	newUnderying := make([]error, 0, len(e.underlying)+len(errs))
-	newUnderying = append(newUnderying, e.underlying...)
+	underlying := e.underlying()
+	newUnderlying := underlying
 
 	for _, err := range errs {
 		if err == nil {
 			continue
 		}
 
-		newUnderying = append(newUnderying, err)
+		newUnderlying = append(newUnderlying, err)
 	}
 
-	errorCopy.underlying = newUnderying
-	return &errorCopy
+	if len(newUnderlying) == len(underlying) {
+		return e
+	}
+
+	l := len(newUnderlying) // note: l > 0, because non-increased 0 length is handled above
+	errorCopy := e.WithProperty(propertyUnderlying, newUnderlying[:l:l])
+	errorCopy.hasUnderlying = true
+	return errorCopy
 }
 
 // Property extracts a dynamic property value from an error.
@@ -185,18 +191,29 @@ func (e *Error) messageWithUnderlyingInfo() string {
 }
 
 func (e *Error) underlyingInfo() string {
-	if len(e.underlying) == 0 {
+	if !e.hasUnderlying {
 		return ""
 	}
 
-	infos := make([]string, 0, len(e.underlying))
-	for _, err := range e.underlying {
+	underlying := e.underlying()
+	infos := make([]string, 0, len(underlying))
+	for _, err := range underlying {
 		infos = append(infos, err.Error())
 	}
 
 	return fmt.Sprintf("(hidden: %s)", joinStringsIfNonEmpty(", ", infos...))
 }
 
+func (e *Error) underlying() []error {
+	if !e.hasUnderlying {
+		return nil
+	}
+	// Note: properties are used as storage for optional "underlying errors".
+	// Chain of cause should not be traversed here.
+	u, _ := e.properties.get(propertyUnderlying)
+	return u.([]error)
+}
+
 func (e *Error) messageText() string {
 	if e.Cause() == nil {
 		return e.message

error_test.go

@@ -101,9 +101,9 @@ func TestImmutableError(t *testing.T) {
 		require.True(t, err.errorType.IsOfType(err2.errorType))
 		require.Equal(t, err.message, err2.message)
 
-		require.Len(t, err.underlying, 0)
-		require.Len(t, err1.underlying, 1)
-		require.Len(t, err2.underlying, 2)
+		require.Len(t, err.underlying(), 0)
+		require.Len(t, err1.underlying(), 1)
+		require.Len(t, err2.underlying(), 2)
 	})
 }
 

property.go

@@ -69,8 +69,9 @@ func ExtractProperty(err error, key Property) (interface{}, bool) {
 }
 
 var (
-	propertyContext = RegisterProperty("ctx")
-	propertyPayload = RegisterProperty("payload")
+	propertyContext    = RegisterProperty("ctx")
+	propertyPayload    = RegisterProperty("payload")
+	propertyUnderlying = RegisterProperty("underlying")
 )
 
 func newProperty(label string) Property {