linked list properties

benchmark                         old ns/op     new ns/op     delta
BenchmarkAllocProperty/props0     67.8          68.2          +0.59%
BenchmarkAllocProperty/props1     149           135           -9.40%
BenchmarkAllocProperty/props2     262           202           -22.90%
BenchmarkAllocProperty/props3     375           275           -26.67%
BenchmarkAllocProperty/props4     522           341           -34.67%
BenchmarkAllocProperty/props5     712           408           -42.70%
BenchmarkAllocProperty/props6     970           474           -51.13%
BenchmarkAllocProperty/props7     1100          540           -50.91%
BenchmarkAllocProperty/props8     1296          607           -53.16%

benchmark                         old allocs     new allocs     delta
BenchmarkAllocProperty/props0     1              1              +0.00%
BenchmarkAllocProperty/props1     3              3              +0.00%
BenchmarkAllocProperty/props2     6              5              -16.67%
BenchmarkAllocProperty/props3     9              7              -22.22%
BenchmarkAllocProperty/props4     13             9              -30.77%
BenchmarkAllocProperty/props5     18             11             -38.89%
BenchmarkAllocProperty/props6     24             13             -45.83%
BenchmarkAllocProperty/props7     28             15             -46.43%
BenchmarkAllocProperty/props8     33             17             -48.48%

benchmark                         old bytes     new bytes     delta
BenchmarkAllocProperty/props0     64            64            +0.00%
BenchmarkAllocProperty/props1     176           160           -9.09%
BenchmarkAllocProperty/props2     336           256           -23.81%
BenchmarkAllocProperty/props3     496           352           -29.03%
BenchmarkAllocProperty/props4     704           448           -36.36%
BenchmarkAllocProperty/props5     960           544           -43.33%
BenchmarkAllocProperty/props6     1264          640           -49.37%
BenchmarkAllocProperty/props7     1472          736           -50.00%
BenchmarkAllocProperty/props8     1728          832           -51.85%

benchmark                       old ns/op     new ns/op     delta
BenchmarkGetProperty/props0     14.4          15.0          +4.17%
BenchmarkGetProperty/props1     22.1          15.9          -28.05%
BenchmarkGetProperty/props2     20.4          17.7          -13.24%
BenchmarkGetProperty/props3     26.2          20.2          -22.90%
BenchmarkGetProperty/props4     29.3          21.9          -25.26%
BenchmarkGetProperty/props5     32.7          22.3          -31.80%
BenchmarkGetProperty/props6     26.2          23.5          -10.31%
BenchmarkGetProperty/props7     29.3          24.0          -18.09%
BenchmarkGetProperty/props8     26.2          25.9          -1.15%

Author: funny-falcon

error.go

@@ -27,6 +27,7 @@ var _ fmt.Formatter = (*Error)(nil)
 // If an error already contained another value for the same property, it is overwritten.
 // It is a caller's responsibility to accumulate and update a property, if needed.
 // Dynamic properties is a brittle mechanism and should therefore be used with care and in a simple and robust manner.
+// Currently, properties are implemented as a linked list, therefore it is not safe to have many dozens of them. But couple of dozen is just ok.
 func (e *Error) WithProperty(key Property, value interface{}) *Error {
 	errorCopy := *e
 	errorCopy.properties = errorCopy.properties.with(key, value)

id.go

@@ -1,23 +1,13 @@
 package errorx
 
 import (
-	"sync"
+	"sync/atomic"
 )
 
-var internalID uint64 = 0x123456789abcdef0
-var idMtx sync.Mutex
+var internalID uint64
 
 // nextInternalID creates next unique id for errorx entities.
 // All equality comparison should take id into account, lest there be some false positive matches.
 func nextInternalID() uint64 {
-	idMtx.Lock()
-	// xorshift
-	x := internalID
-	x ^= x << 13
-	x ^= x >> 7
-	x ^= x << 17
-	id := x + internalID
-	internalID = x
-	idMtx.Unlock()
-	return id
+	return atomic.AddUint64(&internalID, 1)
 }

property.go

@@ -8,11 +8,10 @@ import (
 // Property value belongs to an error instance only, never inherited from a type.
 // Property visibility is hindered by Wrap, preserved by Decorate.
 type Property struct {
-	*property
+	*property // Property is compared by this pointer.
 }
 
 type property struct {
-	id    uint64
 	label string
 }
 
@@ -77,7 +76,6 @@ var (
 func newProperty(label string) Property {
 	p := Property{
 		&property{
-			id:    nextInternalID(),
 			label: label,
 		},
 	}
@@ -86,45 +84,23 @@ func newProperty(label string) Property {
 
 // propertyMap represents map of properties.
 // Compared to builtin type, it uses less allocations and reallocations on copy.
-// It is simple binary search tree that relies on property id randomness for balancing.
+// It is implemented as a simple linked list.
 type propertyMap struct {
 	p     Property
 	value interface{}
-	left  *propertyMap
-	right *propertyMap
+	next  *propertyMap
 }
 
-// withProperty creates new map with property added or overwritten
 func (pm *propertyMap) with(p Property, value interface{}) *propertyMap {
-	if pm == nil {
-		return &propertyMap{p: p, value: value}
-	} else if pm.p == p {
-		return &propertyMap{
-			p:     p,
-			value: value,
-			left:  pm.left,
-			right: pm.right,
-		}
-	} else {
-		copy := *pm
-		if copy.p.id < p.id {
-			copy.right = copy.right.with(p, value)
-		} else {
-			copy.left = copy.left.with(p, value)
-		}
-		return &copy
-	}
+	return &propertyMap{p: p, value: value, next: pm}
 }
 
 func (pm *propertyMap) get(p Property) (value interface{}, ok bool) {
-	switch {
-	case pm == nil:
-		return nil, false
-	case pm.p == p:
-		return pm.value, true
-	case pm.p.id < p.id:
-		return pm.right.get(p)
-	default:
-		return pm.left.get(p)
+	for pm != nil {
+		if pm.p == p {
+			return pm.value, true
+		}
+		pm = pm.next
 	}
+	return nil, false
 }