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

pkg/lang/atom.go

@@ -1,14 +1,19 @@
 package lang
 
-import "sync/atomic"
+import (
+	"sync"
+	"sync/atomic"
+)
 
 type (
 	Atom struct {
 		state   atomic.Pointer[Box]
 		initial Box
 		watches IPersistentMap
 
-		meta IPersistentMap
+		referenceMu sync.RWMutex
+		meta        IPersistentMap
+		validator   IFn
 	}
 )
 
@@ -36,8 +41,34 @@ func (a *Atom) Deref() interface{} {
 	return a.state.Load().val
 }
 
-func (a *Atom) SetValidator(vf IFn) { panic("not implemented") }
-func (a *Atom) Validator() IFn      { panic("not implemented") }
+func (a *Atom) SetValidator(vf IFn) {
+	if vf != nil && !IsTruthy(Apply1(vf, a.Deref())) {
+		panic(NewIllegalStateError("Invalid reference state"))
+	}
+	a.referenceMu.Lock()
+	a.validator = vf
+	a.referenceMu.Unlock()
+}
+
+func (a *Atom) Validator() IFn {
+	a.referenceMu.RLock()
+	defer a.referenceMu.RUnlock()
+	return a.validator
+}
+
+func (a *Atom) GetValidator() IFn {
+	return a.Validator()
+}
+
+func (a *Atom) validate(newVal any) {
+	a.referenceMu.RLock()
+	validator := a.validator
+	a.referenceMu.RUnlock()
+	if validator != nil && !IsTruthy(Apply1(validator, newVal)) {
+		panic(NewIllegalStateError("Invalid reference state"))
+	}
+}
+
 func (a *Atom) Watches() IPersistentMap {
 	return a.watches
 }
@@ -118,7 +149,7 @@ func (a *Atom) CompareAndSet(oldv, newv interface{}) bool {
 }
 
 func (a *Atom) compareAndSetBox(old *Box, newv interface{}) bool {
-	// TODO: validate
+	a.validate(newv)
 	if Identical(old.val, newv) &&
 		(a.watches == nil || a.watches.Count() == 0) {
 		return a.state.CompareAndSwap(old, old)
@@ -131,7 +162,7 @@ func (a *Atom) compareAndSetBox(old *Box, newv interface{}) bool {
 }
 
 func (a *Atom) Reset(newVal interface{}) interface{} {
-	// TODO: validate
+	a.validate(newVal)
 	for {
 		old := a.state.Load()
 		if Identical(old.val, newVal) &&
@@ -148,8 +179,22 @@ func (a *Atom) Reset(newVal interface{}) interface{} {
 }
 
 func (a *Atom) Meta() IPersistentMap {
-	if a.meta == nil {
-		return nil
-	}
+	a.referenceMu.RLock()
+	defer a.referenceMu.RUnlock()
 	return a.meta
 }
+
+func (a *Atom) AlterMeta(f IFn, args ISeq) IPersistentMap {
+	meta := f.ApplyTo(NewCons(a.Meta(), args))
+	if meta == nil {
+		return a.ResetMeta(nil)
+	}
+	return a.ResetMeta(meta.(IPersistentMap))
+}
+
+func (a *Atom) ResetMeta(meta IPersistentMap) IPersistentMap {
+	a.referenceMu.Lock()
+	a.meta = meta
+	a.referenceMu.Unlock()
+	return meta
+}

pkg/lang/atom_test.go

@@ -68,3 +68,64 @@ func TestAtomIdenticalUpdatesStillNotifyWatches(t *testing.T) {
 		t.Fatalf("watch called %d times, want 2", calls)
 	}
 }
+
+func TestAtomMetadata(t *testing.T) {
+	atom := NewAtom(nil)
+	meta := NewMap(NewKeyword("source"), "test")
+
+	if got := atom.ResetMeta(meta); got != meta {
+		t.Fatalf("ResetMeta returned %v, want %v", got, meta)
+	}
+	if got := atom.Meta(); got != meta {
+		t.Fatalf("Meta returned %v, want %v", got, meta)
+	}
+
+	updated := atom.AlterMeta(
+		FnFunc2(func(current, value any) any {
+			return current.(IPersistentMap).Assoc(NewKeyword("updated"), value)
+		}),
+		NewList(true),
+	)
+	if got := updated.ValAt(NewKeyword("updated")); got != true {
+		t.Fatalf("altered metadata value = %v, want true", got)
+	}
+}
+
+func TestAtomValidator(t *testing.T) {
+	atom := NewAtom(int64(2))
+	even := FnFunc1(func(value any) any {
+		return value.(int64)%2 == 0
+	})
+	atom.SetValidator(even)
+
+	if got := Apply1(atom.Validator(), int64(2)); got != true {
+		t.Fatalf("validator returned %v for 2, want true", got)
+	}
+	if got := atom.Reset(int64(4)); got != int64(4) {
+		t.Fatalf("Reset returned %v, want 4", 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("expected panic")
+		}
+	}()
+	fn()
+}