Convert to go2go type parameters

example_test.go example_test.go2

···
 	"fmt"
 	"sort"
 
-	"github.com/jwkohnen/lrmap"
+	"github.com/jwkohnen/lrmap2"
 )
 
 func ExampleReadHandler_Iterate() {
-	m := lrmap.New()
+	m := lrmap2.New[int, int]()
 
 	for i := 0; i < 10; i++ {
-		k, v := lrmap.Key(i), lrmap.Value(i)
 		m.Set(k, v)
 	}
 
···
 
 	var values []int
 
-	rh.Iterate(func(_ lrmap.Key, v lrmap.Value) bool {
-		values = append(values, int(v))
+	rh.Iterate(func(_ int, v int) bool {
+		values = append(values, v)
 
 		return true
 	})

go.mod

···
-module github.com/jwkohnen/lrmap
+module github.com/jwkohnen/lrmap2
 
 go 1.16

lrmap.go lrmap.go2

···
 )
 
 type (
-	LRMap struct {
+	LRMap[K comparable, V any] struct {
 		mu              sync.Mutex
-		left            arena
-		right           arena
+		left            arena[K, V]
+		right           arena[K, V]
 		readMap         unsafe.Pointer
-		writeMap        *arena
-		redoLog         []operation
-		readHandlers    map[*readHandlerInner]struct{}
+		writeMap        *arena[K, V]
+		redoLog         []operation[K, V]
+		readHandlers    map[*readHandlerInner[K, V]]struct{}
 		readHandlerPool sync.Pool
 	}
 
-	Key   int
-	Value int
-
-	arena map[Key]Value
+	arena[K comparable, V any] map[K]V
 )
 
-func New() *LRMap {
+func New[K comparable, V any]() *LRMap[K, V] {
 	// nolint:exhaustivestruct
-	m := &LRMap{
-		left:         make(arena),
-		right:        make(arena),
-		readHandlers: make(map[*readHandlerInner]struct{}),
+	m := &LRMap[K, V]{
+		left:         make(arena[K, V]),
+		right:        make(arena[K, V]),
+		readHandlers: make(map[*readHandlerInner[K, V]]struct{}),
 	}
 
 	m.readHandlerPool.New = func() interface{} { return m.newReadHandler() }
···
 	return m
 }
 
-func (m *LRMap) Set(k Key, v Value) {
+func (m *LRMap[K, V]) Set(k K, v V) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	(*(m.writeMap))[k] = v
 
-	m.redoLog = append(m.redoLog, operation{typ: opSet, key: k, value: &v})
+	m.redoLog = append(m.redoLog, operation[K, V]{typ: opSet, key: k, value: &v})
 }
 
-func (m *LRMap) Delete(k Key) {
+func (m *LRMap[K, V]) Delete(k K) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	delete(*(m.writeMap), k)
 
 	// nolint:exhaustivestruct
-	m.redoLog = append(m.redoLog, operation{typ: opDelete, key: k})
+	m.redoLog = append(m.redoLog, operation[K, V]{typ: opDelete, key: k})
 }
 
-func (m *LRMap) Get(k Key) Value {
+func (m *LRMap[K, V]) Get(k K) V {
 	v, _ := m.GetOK(k)
 
 	return v
 }
 
-func (m *LRMap) GetOK(k Key) (Value, bool) {
+func (m *LRMap[K, V]) GetOK(k K) (V, bool) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
···
 	return v, ok
 }
 
-func (m *LRMap) Flush() {
+func (m *LRMap[K, V]) Flush() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
···
 	m.redoLog = nil
 }
 
-func (m *LRMap) NewReadHandler() *ReadHandler {
-	rh := m.readHandlerPool.Get().(*ReadHandler)
+func (m *LRMap[K, V]) NewReadHandler() *ReadHandler[K, V] {
+	rh := m.readHandlerPool.Get().(*ReadHandler[K, V])
 	rh.ready = true
 
 	return rh
 }
 
-func (m *LRMap) newReadHandler() *ReadHandler {
+func (m *LRMap[K, V]) newReadHandler() *ReadHandler[K, V] {
 	// Wrap the actual (inner) readHandler in an outer shim and return that shim to the
 	// user and only keep a "weak reference" to the inner readHandler, but not the shim.
 	// If the user drops any references to the outer shim, (eventually) the runtime runs
···
 	// thus leaking resources through the readHandlers list.
 
 	// nolint:exhaustivestruct
-	inner := &readHandlerInner{lrm: m}
+	inner := &readHandlerInner[K, V]{lrm: m}
 
 	m.mu.Lock()
 	m.readHandlers[inner] = struct{}{}
 	m.mu.Unlock()
 
-	outer := &ReadHandler{inner: inner}
-	runtime.SetFinalizer(outer, func(rh *ReadHandler) {
+	outer := &ReadHandler[K, V]{inner: inner}
+	runtime.SetFinalizer(outer, func(rh *ReadHandler[K, V]) {
 		rh.ready = false
 		rh.inner.close()
 	})
···
 	return outer
 }
 
-func (m *LRMap) swap() {
+func (m *LRMap[K, V]) swap() {
 	var (
-		read  = (*arena)(m.readMap)
-		write *arena
+		read  = (*arena[K, V])(m.readMap)
+		write *arena[K, V]
 	)
 
 	switch read {
···
 	m.writeMap = write
 }
 
-func (m *LRMap) waitForReaders() {
-	readers := make(map[*readHandlerInner]uint64)
+func (m *LRMap[K, V]) waitForReaders() {
+	readers := make(map[*readHandlerInner[K, V]]uint64)
 
 	for rh := range m.readHandlers {
 		if epoch := atomic.LoadUint64(&(rh.epoch)); epoch%2 == 1 {
···
 	}
 }
 
-func (m *LRMap) getArenaAtomic() arena {
-	return *(*arena)(atomic.LoadPointer(&(m.readMap)))
+func (m *LRMap[K, V]) getArenaAtomic() arena[K, V] {
+	return *(*arena[K, V])(atomic.LoadPointer(&(m.readMap)))
 }
 
 type opType int8
···
 	opDelete
 )
 
-type operation struct {
+type operation[K comparable, V any] struct {
 	typ   opType
-	key   Key
-	value *Value
+	key   K
+	value *V
 }
 
-type ReadHandler struct {
-	inner *readHandlerInner
+type ReadHandler[K comparable, V any] struct {
+	inner *readHandlerInner[K, V]
 	ready bool
 }
 
-func (rh *ReadHandler) Enter()                    { rh.assertReady(); rh.inner.enter() }
-func (rh *ReadHandler) Leave()                    { rh.assertReady(); rh.inner.leave() }
-func (rh *ReadHandler) Get(k Key) Value           { rh.assertReady(); return rh.inner.get(k) }
-func (rh *ReadHandler) GetOK(k Key) (Value, bool) { rh.assertReady(); return rh.inner.getOK(k) }
-func (rh *ReadHandler) Len() int                  { rh.assertReady(); return rh.inner.len() }
+func (rh *ReadHandler[K, V]) Enter()                    { rh.assertReady(); rh.inner.enter() }
+func (rh *ReadHandler[K, V]) Leave()                    { rh.assertReady(); rh.inner.leave() }
+func (rh *ReadHandler[K, V]) Get(k K) V                 { rh.assertReady(); return rh.inner.get(k) }
+func (rh *ReadHandler[K, V]) GetOK(k K) (V, bool)       { rh.assertReady(); return rh.inner.getOK(k) }
+func (rh *ReadHandler[K, V]) Len() int                  { rh.assertReady(); return rh.inner.len() }
 
-func (rh *ReadHandler) Iterate(fn func(k Key, v Value) bool) {
+func (rh *ReadHandler[K, V]) Iterate(fn func(k K, v V) bool) {
 	rh.assertReady()
 
 	if !rh.inner.entered() {
···
 	}
 }
 
-func (rh *ReadHandler) Close() {
+func (rh *ReadHandler[K, V]) Close() {
 	rh.assertReady()
 
 	runtime.SetFinalizer(rh, nil)
···
 	rh.inner.close()
 }
 
-func (rh *ReadHandler) Recycle() {
+func (rh *ReadHandler[K, V]) Recycle() {
 	if !rh.ready {
 		panic("illegal reader state: must not recycle twice")
 	}
···
 	rh.inner.lrm.readHandlerPool.Put(rh)
 }
 
-func (rh *ReadHandler) assertReady() {
+func (rh *ReadHandler[K, V]) assertReady() {
 	if rh.inner == nil {
 		panic("reader illegal state: must create with NewReadHandler()") // TODO
 	}
···
 	}
 }
 
-type readHandlerInner struct {
-	lrm   *LRMap
-	live  arena
+type readHandlerInner[K comparable, V any] struct {
+	lrm   *LRMap[K, V]
+	live  arena[K, V]
 	epoch uint64
 }
 
-func (r *readHandlerInner) enter() {
+func (r *readHandlerInner[K, V]) enter() {
 	if r.entered() {
 		panic("reader illegal state: must not Enter() twice")
 	}
···
 	r.live = r.lrm.getArenaAtomic()
 }
 
-func (r *readHandlerInner) leave() {
+func (r *readHandlerInner[K, V]) leave() {
 	if !r.entered() {
 		panic("reader illegal state: must not Leave() twice")
 	}
···
 	atomic.AddUint64(&r.epoch, 1)
 }
 
-func (r *readHandlerInner) get(k Key) Value {
+func (r *readHandlerInner[K, V]) get(k K) V {
 	v, _ := r.getOK(k)
 
 	return v
 }
 
-func (r *readHandlerInner) getOK(k Key) (Value, bool) {
+func (r *readHandlerInner[K, V]) getOK(k K) (V, bool) {
 	if !r.entered() {
 		panic("reader illegal state: must Enter() before operating on data")
 	}
···
 	return v, ok
 }
 
-func (r *readHandlerInner) len() int {
+func (r *readHandlerInner[K, V]) len() int {
 	if !r.entered() {
 		panic("reader illegal state: must Enter() before operation on data")
 	}
···
 	return len(r.live)
 }
 
-func (r *readHandlerInner) close() {
+func (r *readHandlerInner[K, V]) close() {
 	r.lrm.mu.Lock()
 	defer r.lrm.mu.Unlock()
 
 	delete(r.lrm.readHandlers, r)
 }
 
-func (r *readHandlerInner) entered() bool {
+func (r *readHandlerInner[K, V]) entered() bool {
 	return r.epoch%2 == 1
 }

lrmap_test.go lrmap_test.go2

···
 )
 
 func TestHundred(t *testing.T) {
-	lrm := New()
+	lrm := New[int, int]()
 
 	rh := lrm.NewReadHandler()
 	defer rh.Close()
 
 	for i := 1; i < 100; i += 2 {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		lrm.Set(k, v)
 	}
···
 	lrm.Flush()
 
 	for i := 1; i < 100; i += 2 {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		rh.Enter()
 		if _v := rh.Get(k); _v != v {
···
 	}
 
 	for i := 0; i < 100; i += 2 {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 		lrm.Set(k, v)
 	}
 
···
 
 	for i := 0; i < 100; i++ {
 		rh.Enter()
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		if _v := rh.Get(k); _v != v {
 			t.Errorf("Get(%d) want %d, got %d", k, v, _v)
···
 
 	rh.Enter()
 	for i := 0; i < 100; i++ {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		if _v := rh.Get(k); _v != v {
 			t.Errorf("Get(%d) want %d, got %d", k, v, _v)
···
 	rh.Leave()
 
 	for i := 0; i < 100; i += 2 {
-		k := Key(i)
+		k := i
 		lrm.Delete(k)
 	}
 
···
 
 	rh.Enter()
 	for i := 0; i < 100; i++ {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		_v, ok := rh.GetOK(k)
 		if i%2 == 0 {
···
 
 	rh.Enter()
 	for i := 0; i < 100; i++ {
-		k, v := Key(i), Value(i)
+		k, v := i, i
 
 		_v, ok := rh.GetOK(k)
 		if i%2 == 0 {