property tree instead of builtin map

benchmark                         old ns/op     new ns/op     delta
BenchmarkAllocProperty/props0     83.4          83.0          -0.48%
BenchmarkAllocProperty/props1     254           172           -32.28%
BenchmarkAllocProperty/props2     492           292           -40.65%
BenchmarkAllocProperty/props3     804           443           -44.90%
BenchmarkAllocProperty/props4     1112          624           -43.88%
BenchmarkAllocProperty/props5     1503          828           -44.91%
BenchmarkAllocProperty/props6     1866          1062          -43.09%
BenchmarkAllocProperty/props7     2322          1375          -40.78%
BenchmarkAllocProperty/props8     2733          1591          -41.79%

benchmark                         old allocs     new allocs     delta
BenchmarkAllocProperty/props0     1              1              +0.00%
BenchmarkAllocProperty/props1     4              3              -25.00%
BenchmarkAllocProperty/props2     7              6              -14.29%
BenchmarkAllocProperty/props3     10             10             +0.00%
BenchmarkAllocProperty/props4     13             14             +7.69%
BenchmarkAllocProperty/props5     16             19             +18.75%
BenchmarkAllocProperty/props6     19             25             +31.58%
BenchmarkAllocProperty/props7     22             32             +45.45%
BenchmarkAllocProperty/props8     25             37             +48.00%

benchmark                         old bytes     new bytes     delta
BenchmarkAllocProperty/props0     96            96            +0.00%
BenchmarkAllocProperty/props1     448           240           -46.43%
BenchmarkAllocProperty/props2     800           432           -46.00%
BenchmarkAllocProperty/props3     1152          672           -41.67%
BenchmarkAllocProperty/props4     1504          912           -39.36%
BenchmarkAllocProperty/props5     1856          1200          -35.34%
BenchmarkAllocProperty/props6     2208          1536          -30.43%
BenchmarkAllocProperty/props7     2560          1920          -25.00%
BenchmarkAllocProperty/props8     2912          2208          -24.18%

Author: funny-falcon

error.go

@@ -16,7 +16,7 @@ type Error struct {
 	underlying  []error
 	stackTrace  *stackTrace
 	transparent bool
-	properties  map[int64]interface{}
+	properties  *propertyMap
 }
 
 var _ fmt.Formatter = (*Error)(nil)
@@ -27,17 +27,7 @@ var _ fmt.Formatter = (*Error)(nil)
 // Dynamic properties is a brittle mechanism and should therefore be used with care and in a simple and robust manner.
 func (e *Error) WithProperty(key Property, value interface{}) *Error {
 	errorCopy := *e
-
-	if errorCopy.properties == nil {
-		errorCopy.properties = make(map[int64]interface{}, 1)
-	} else {
-		errorCopy.properties = make(map[int64]interface{}, len(e.properties)+1)
-		for k, v := range e.properties {
-			errorCopy.properties[k] = v
-		}
-	}
-
-	errorCopy.properties[key.id] = value
+	errorCopy.properties = errorCopy.properties.with(key, value)
 	return &errorCopy
 }
 
@@ -69,7 +59,7 @@ func (e *Error) WithUnderlyingErrors(errs ...error) *Error {
 func (e *Error) Property(key Property) (interface{}, bool) {
 	cause := e
 	for cause != nil {
-		value, ok := cause.properties[key.id]
+		value, ok := cause.properties.get(key)
 		if ok {
 			return value, true
 		}

id.go

@@ -1,11 +1,23 @@
 package errorx
 
-import "sync/atomic"
+import (
+	"sync"
+)
 
-var internalID int64
+var internalID uint64 = 0x123456789abcdef0
+var idMtx sync.Mutex
 
 // 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() int64 {
-	return atomic.AddInt64(&internalID, 1)
+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
 }

namespace.go

@@ -11,16 +11,15 @@ import "fmt"
 //
 type Namespace struct {
 	parent    *Namespace
-	id        int64
+	id        uint64
 	name      string
 	traits    []Trait
 	modifiers modifiers
 }
 
 // NamespaceKey is a comparable descriptor of a Namespace.
 type NamespaceKey struct {
-	id   int64
-	name string
+	id uint64
 }
 
 // NewNamespace defines a namespace with a name and, optionally, a number of inheritable traits.
@@ -51,8 +50,7 @@ func (n Namespace) NewType(typeName string, traits ...Trait) *Type {
 // Key returns a comparison key for namespace.
 func (n Namespace) Key() NamespaceKey {
 	return NamespaceKey{
-		id:   n.id,
-		name: n.name,
+		id: n.id,
 	}
 }
 

property.go

@@ -8,7 +8,11 @@ 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 {
-	id    int64
+	*property
+}
+
+type property struct {
+	id    uint64
 	label string
 }
 
@@ -70,8 +74,56 @@ var (
 )
 
 func newProperty(label string) Property {
-	return Property{
-		id:    nextInternalID(),
-		label: label,
+	p := Property{
+		&property{
+			id:    nextInternalID(),
+			label: label,
+		},
+	}
+	return p
+}
+
+// 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.
+type propertyMap struct {
+	p     Property
+	value interface{}
+	left  *propertyMap
+	right *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
+	}
+}
+
+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)
 	}
 }

trait.go

@@ -4,7 +4,7 @@ package errorx
 // All errors of a specific type possess exactly the same traits.
 // Traits are both defined along with an error and inherited from a supertype and a namespace.
 type Trait struct {
-	id    int64
+	id    uint64
 	label string
 }
 

type.go

@@ -11,7 +11,7 @@ import (
 type Type struct {
 	namespace Namespace
 	parent    *Type
-	id        int64
+	id        uint64
 	fullName  string
 	traits    map[Trait]bool
 	modifiers modifiers