Implement ordered persistent array maps

Preserve array-map insertion order, use the Clojure eight-entry
promotion threshold, and optimize persistent and transient operations.
Add coverage for ordering, duplicate keys, metadata, allocation
behavior, Atom references, typed arrays, native slice reduction, and
decimal printing.

Author: ingydotnet

Makefile

@@ -78,7 +78,7 @@ TEST-SUITE-BRANCH := glojure
 TEST-SUITE-DIR := test/clojure-test-suite
 TEST-SUITE-FILE := test-glojure.glj
 TEST-SUITE-EXPECT-FAILURES ?= 0
-TEST-SUITE-EXPECT-ERRORS ?= 1
+TEST-SUITE-EXPECT-ERRORS ?= 0
 TEST-SUITE-EXPECT-LOAD-ERRORS ?= 7
 
 MAKES-CLEAN := \

pkg/lang/atom.go

@@ -204,8 +204,11 @@ func (a *Atom) Meta() IPersistentMap {
 }
 
 func (a *Atom) AlterMeta(f IFn, args ISeq) IPersistentMap {
-	meta := ApplySeq(f, NewCons(a.Meta(), args)).(IPersistentMap)
-	return a.ResetMeta(meta)
+	meta := ApplySeq(f, NewCons(a.Meta(), args))
+	if meta == nil {
+		return a.ResetMeta(nil)
+	}
+	return a.ResetMeta(meta.(IPersistentMap))
 }
 
 func (a *Atom) ResetMeta(meta IPersistentMap) IPersistentMap {

pkg/lang/atom_test.go

@@ -105,13 +105,27 @@ func TestAtomValidator(t *testing.T) {
 		t.Fatalf("validated Reset returned %v", got)
 	}
 
+	assertPanics(t, func() {
+		atom.Reset(int64(3))
+	})
+	if got := atom.Deref(); got != int64(4) {
+		t.Fatalf("rejected reset changed state to %v", got)
+	}
+
+	assertPanics(t, func() {
+		atom.SetValidator(FnFunc1(func(any) any { return false }))
+	})
+	if got := Apply1(atom.Validator(), int64(4)); got != true {
+		t.Fatal("rejected validator replaced the current validator")
+	}
+}
+
+func assertPanics(t *testing.T, fn func()) {
+	t.Helper()
 	defer func() {
 		if recover() == nil {
-			t.Fatal("validator accepted invalid state")
-		}
-		if got := atom.Deref(); got != int64(4) {
-			t.Fatalf("failed validation changed atom to %v", got)
+			t.Fatal("expected panic")
 		}
 	}()
-	atom.Reset(int64(3))
+	fn()
 }

pkg/lang/persistentarraymap.go

@@ -192,13 +192,18 @@ func (s *KeywordMapShape) indexOf(key Keyword) int {
 }
 
 func newArrayMap(keyVals []any) *Map {
-	if len(keyVals) <= arrayMapInlineSize {
+	m := newArrayMapWithSize(len(keyVals))
+	copy(m.keyVals, keyVals)
+	return m
+}
+
+func newArrayMapWithSize(size int) *Map {
+	if size <= arrayMapInlineSize {
 		storage := &inlineMapStorage{}
-		copy(storage.keyVals[:], keyVals)
-		storage.Map.keyVals = storage.keyVals[:len(keyVals)]
+		storage.Map.keyVals = storage.keyVals[:size]
 		return &storage.Map
 	}
-	return &Map{keyVals: append([]any(nil), keyVals...)}
+	return &Map{keyVals: make([]any, size)}
 }
 
 // canBePersistentArrayMap mirrors Clojure's PersistentArrayMap thresholds.
@@ -221,7 +226,8 @@ func canBePersistentArrayMap(keyVals []any) bool {
 }
 
 func NewPersistentArrayMapAsIfByAssoc(init []any) IPersistentMap {
-	complexPath := (len(init) & 1) == 1
+	hasTrailing := (len(init) & 1) == 1
+	complexPath := hasTrailing
 	for i := 0; i < len(init) && !complexPath; i += 2 {
 		for j := 0; j < i; j += 2 {
 			if equalKey(init[i], init[j]) {
@@ -232,13 +238,28 @@ func NewPersistentArrayMapAsIfByAssoc(init []any) IPersistentMap {
 	}
 
 	if complexPath {
-		return newPersistentArrayMapAsIfByAssocComplexPath(init)
+		return newPersistentArrayMapAsIfByAssocComplexPath(init, hasTrailing)
 	}
 
-	return NewMap(init...)
+	return newArrayMap(init)
 }
 
-func newPersistentArrayMapAsIfByAssocComplexPath(init []any) IPersistentMap {
+func newPersistentArrayMapAsIfByAssocComplexPath(init []any, hasTrailing bool) IPersistentMap {
+	if hasTrailing {
+		trailing := emptyMap.Cons(init[len(init)-1]).(IPersistentMap)
+		seedCount := len(init) - 1
+		grown := make([]any, seedCount+trailing.Count()*2)
+		copy(grown, init[:seedCount])
+		i := seedCount
+		for seq := trailing.Seq(); seq != nil; seq = seq.Next() {
+			entry := seq.First().(IMapEntry)
+			grown[i] = entry.Key()
+			grown[i+1] = entry.Val()
+			i += 2
+		}
+		init = grown
+	}
+
 	n := 0
 	for i := 0; i < len(init); i += 2 {
 		duplicateKey := false
@@ -283,7 +304,7 @@ func newPersistentArrayMapAsIfByAssocComplexPath(init []any) IPersistentMap {
 		}
 		init = nodups
 	}
-	return NewMap(init...)
+	return newArrayMap(init)
 }
 
 func (m *Map) ValAt(key any) any {
@@ -479,13 +500,25 @@ func (m *Map) Without(k any) IPersistentMap {
 		}
 		return NewMapUniqueKeys(keyVals...).(IObj).WithMeta(m.meta).(IPersistentMap)
 	}
-	newKeyVals := make([]any, 0, len(m.keyVals))
+	remove := -1
 	for i := 0; i < len(m.keyVals); i += 2 {
-		if !Equiv(m.keyVals[i], k) {
-			newKeyVals = append(newKeyVals, m.keyVals[i], m.keyVals[i+1])
+		if Equiv(m.keyVals[i], k) {
+			remove = i
+			break
 		}
 	}
-	return NewMap(newKeyVals...).(IObj).WithMeta(m.meta).(IPersistentMap)
+	if remove < 0 {
+		return m
+	}
+	if len(m.keyVals) == 2 {
+		return emptyMap.WithMeta(m.meta).(IPersistentMap)
+	}
+
+	result := newArrayMapWithSize(len(m.keyVals) - 2)
+	result.meta = m.meta
+	copy(result.keyVals, m.keyVals[:remove])
+	copy(result.keyVals[remove:], m.keyVals[remove+2:])
+	return result
 }
 
 func (m *Map) Count() int {
@@ -596,8 +629,7 @@ func (m *Map) ReduceInit(f IFn, init any) any {
 }
 
 func (m *Map) AsTransient() ITransientCollection {
-	// TODO: implement transients
-	return &TransientMap{IPersistentMap: m}
+	return &TransientMap{IPersistentMap: m.clone()}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -650,12 +682,49 @@ func (m *TransientMap) Conj(v any) Conjer {
 
 func (m *TransientMap) Assoc(k, v any) Associative {
 	m.ensureEditable()
+	if arrayMap, ok := m.IPersistentMap.(*Map); ok && arrayMap.keywordShape == nil {
+		for i := 0; i < len(arrayMap.keyVals); i += 2 {
+			if Equiv(arrayMap.keyVals[i], k) {
+				arrayMap.keyVals[i+1] = v
+				arrayMap.hash = 0
+				arrayMap.hasheq = 0
+				return m
+			}
+		}
+
+		threshold := arrayMapHashThreshold
+		if _, ok := k.(Keyword); ok {
+			threshold = arrayMapKeywordThreshold
+		}
+		if len(arrayMap.keyVals) < threshold {
+			arrayMap.keyVals = append(arrayMap.keyVals, k, v)
+			arrayMap.hash = 0
+			arrayMap.hasheq = 0
+			return m
+		}
+	}
 	m.IPersistentMap = m.IPersistentMap.Assoc(k, v).(IPersistentMap)
 	return m
 }
 
 func (m *TransientMap) Without(key any) IPersistentMap {
 	m.ensureEditable()
+	if arrayMap, ok := m.IPersistentMap.(*Map); ok && arrayMap.keywordShape == nil {
+		for i := 0; i < len(arrayMap.keyVals); i += 2 {
+			if !Equiv(arrayMap.keyVals[i], key) {
+				continue
+			}
+			newLen := len(arrayMap.keyVals) - 2
+			copy(arrayMap.keyVals[i:], arrayMap.keyVals[i+2:])
+			arrayMap.keyVals[newLen] = nil
+			arrayMap.keyVals[newLen+1] = nil
+			arrayMap.keyVals = arrayMap.keyVals[:newLen]
+			arrayMap.hash = 0
+			arrayMap.hasheq = 0
+			break
+		}
+		return m
+	}
 	m.IPersistentMap = m.IPersistentMap.Without(key).(IPersistentMap)
 	return m
 }

pkg/lang/persistentarraymap_test.go

@@ -1,11 +1,149 @@
 package lang
 
 import (
+	"reflect"
 	"runtime"
 	"strconv"
 	"testing"
 )
 
+func mapKeys(m IPersistentMap) []any {
+	keys := make([]any, 0, m.Count())
+	for seq := m.Seq(); seq != nil; seq = seq.Next() {
+		keys = append(keys, seq.First().(IMapEntry).Key())
+	}
+	return keys
+}
+
+func TestPersistentArrayMapConstructionPreservesOrder(t *testing.T) {
+	init := []any{
+		"a", 1,
+		"b", 2,
+		"c", 3,
+		"d", 4,
+		"e", 5,
+		"f", 6,
+		"g", 7,
+		"h", 8,
+		"i", 9,
+	}
+	m, ok := NewPersistentArrayMapAsIfByAssoc(init).(*Map)
+	if !ok {
+		t.Fatalf("array-map constructor returned %T, want *Map", m)
+	}
+	if got, want := mapKeys(m), []any{"a", "b", "c", "d", "e", "f", "g", "h", "i"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("keys = %v, want %v", got, want)
+	}
+
+	updated := m.Assoc("a", 10)
+	if _, ok := updated.(*Map); !ok {
+		t.Fatalf("existing-key assoc returned %T, want *Map", updated)
+	}
+	grown := m.Assoc("j", 10)
+	if _, ok := grown.(*PersistentHashMap); !ok {
+		t.Fatalf("new-key assoc returned %T, want *PersistentHashMap", grown)
+	}
+
+	init[0] = "changed"
+	if !m.ContainsKey("a") || m.ContainsKey("changed") {
+		t.Fatal("array-map retained mutable constructor storage")
+	}
+}
+
+func TestPersistentArrayMapConstructionHandlesTrailingMapEntry(t *testing.T) {
+	m := NewPersistentArrayMapAsIfByAssoc([]any{
+		"a", 1,
+		NewVector("b", 2),
+	}).(*Map)
+
+	if got, want := mapKeys(m), []any{"a", "b"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("keys = %v, want %v", got, want)
+	}
+	if got := m.ValAt("b"); got != 2 {
+		t.Fatalf("value at b = %v, want 2", got)
+	}
+}
+
+func TestPersistentArrayMapConstructionHandlesDuplicateKeys(t *testing.T) {
+	m := NewPersistentArrayMapAsIfByAssoc([]any{
+		"a", 1,
+		"b", 2,
+		"a", 3,
+	}).(*Map)
+
+	if got := m.Count(); got != 2 {
+		t.Fatalf("count = %d, want 2", got)
+	}
+	if got := m.ValAt("a"); got != 3 {
+		t.Fatalf("value at a = %v, want 3", got)
+	}
+	if got, want := mapKeys(m), []any{"a", "b"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("keys = %v, want %v", got, want)
+	}
+}
+
+func TestPersistentArrayMapWithoutPreservesTypeOrderAndMeta(t *testing.T) {
+	init := []any{
+		"a", 1,
+		"b", 2,
+		"c", 3,
+		"d", 4,
+		"e", 5,
+		"f", 6,
+		"g", 7,
+		"h", 8,
+		"i", 9,
+	}
+	meta := NewMap(NewKeyword("source"), "test")
+	m := NewPersistentArrayMapAsIfByAssoc(init).(*Map).WithMeta(meta).(*Map)
+
+	without := m.Without("e")
+	got, ok := without.(*Map)
+	if !ok {
+		t.Fatalf("without returned %T, want *Map", without)
+	}
+	if got.Meta() != meta {
+		t.Fatal("without discarded metadata")
+	}
+	wantKeys := []any{"a", "b", "c", "d", "f", "g", "h", "i"}
+	if keys := mapKeys(got); !reflect.DeepEqual(keys, wantKeys) {
+		t.Fatalf("keys = %v, want %v", keys, wantKeys)
+	}
+	if same := m.Without("missing"); same != m {
+		t.Fatal("removing a missing key did not return the original map")
+	}
+}
+
+func TestTransientArrayMapMutatesPrivateStorage(t *testing.T) {
+	original := NewMap("a", 1, "b", 2).(*Map)
+	transient := original.AsTransient().(*TransientMap)
+
+	key := any("a")
+	value := any(10)
+	if got := testing.AllocsPerRun(1_000, func() {
+		transient.Assoc(key, value)
+	}); got != 0 {
+		t.Fatalf("transient existing-key assoc allocated %v objects, want 0", got)
+	}
+	transient.Assoc("c", 3)
+	transient.Without("b")
+
+	if got, want := mapKeys(original), []any{"a", "b"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("original keys = %v, want %v", got, want)
+	}
+	if got := original.ValAt("a"); got != 1 {
+		t.Fatalf("original value at a = %v, want 1", got)
+	}
+
+	persistent := transient.Persistent().(*Map)
+	if got, want := mapKeys(persistent), []any{"a", "c"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("persistent keys = %v, want %v", got, want)
+	}
+	if got := persistent.ValAt("a"); got != 10 {
+		t.Fatalf("persistent value at a = %v, want 10", got)
+	}
+}
+
 type testStaticKeywordMapStorage struct {
 	Map
 	values [9]any