initial commit

cache/cache.go

@@ -0,0 +1,238 @@
+package cache
+
+import (
+	"context"
+	"sync"
+)
+
+const (
+	// DefaultEvictedBufferSize defines the default buffer size to store evicted key/val
+	DefaultEvictedBufferSize = 16
+)
+
+// Cache is a thread-safe fixed size LRU cache.
+type Cache[K comparable, V any] struct {
+	lru         *LRU[K, V]
+	evictedKeys []K
+	evictedVals []V
+	onEvictedCB func(ctx context.Context, k K, v V)
+	lock        sync.RWMutex
+}
+
+// New creates an LRU of the given size.
+func NewCache[K comparable, V any](size int) (*Cache[K, V], error) {
+	return NewWithEvict[K, V](size, nil)
+}
+
+// NewWithEvict constructs a fixed size cache with the given eviction
+// callback.
+func NewWithEvict[K comparable, V any](size int, onEvicted func(context.Context, K, V)) (c *Cache[K, V], err error) {
+	// create a cache with default settings
+	c = &Cache[K, V]{
+		onEvictedCB: onEvicted,
+	}
+	if onEvicted != nil {
+		c.initEvictBuffers()
+		onEvicted = c.onEvicted
+	}
+	c.lru, err = NewLRU(size, onEvicted)
+	return
+}
+
+func (c *Cache[K, V]) initEvictBuffers() {
+	c.evictedKeys = make([]K, 0, DefaultEvictedBufferSize)
+	c.evictedVals = make([]V, 0, DefaultEvictedBufferSize)
+}
+
+// onEvicted save evicted key/val and sent in externally registered callback
+// outside of critical section
+func (c *Cache[K, V]) onEvicted(ctx context.Context, k K, v V) {
+	c.evictedKeys = append(c.evictedKeys, k)
+	c.evictedVals = append(c.evictedVals, v)
+}
+
+// Purge is used to completely clear the cache.
+func (c *Cache[K, V]) Purge(ctx context.Context) {
+	var ks []K
+	var vs []V
+	c.lock.Lock()
+	c.lru.Purge(ctx)
+	if c.onEvictedCB != nil && len(c.evictedKeys) > 0 {
+		ks, vs = c.evictedKeys, c.evictedVals
+		c.initEvictBuffers()
+	}
+	c.lock.Unlock()
+	// invoke callback outside of critical section
+	if c.onEvictedCB != nil {
+		for i := 0; i < len(ks); i++ {
+			c.onEvictedCB(ctx, ks[i], vs[i])
+		}
+	}
+}
+
+// Add adds a value to the cache. Returns true if an eviction occurred.
+func (c *Cache[K, V]) Add(ctx context.Context, key K, value V) (evicted bool) {
+	var k K
+	var v V
+	c.lock.Lock()
+	evicted = c.lru.Add(ctx, key, value)
+	if c.onEvictedCB != nil && evicted {
+		k, v = c.evictedKeys[0], c.evictedVals[0]
+		c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0]
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && evicted {
+		c.onEvictedCB(ctx, k, v)
+	}
+	return
+}
+
+// Get looks up a key's value from the cache.
+func (c *Cache[K, V]) Get(key K) (value *V, ok bool) {
+	c.lock.Lock()
+	value, ok = c.lru.Get(key)
+	c.lock.Unlock()
+	return value, ok
+}
+
+// Contains checks if a key is in the cache, without updating the
+// recent-ness or deleting it for being stale.
+func (c *Cache[K, V]) Contains(key K) bool {
+	c.lock.RLock()
+	containKey := c.lru.Contains(key)
+	c.lock.RUnlock()
+	return containKey
+}
+
+// Peek returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *Cache[K, V]) Peek(key K) (value *V, ok bool) {
+	c.lock.RLock()
+	value, ok = c.lru.Peek(key)
+	c.lock.RUnlock()
+	return value, ok
+}
+
+// ContainsOrAdd checks if a key is in the cache without updating the
+// recent-ness or deleting it for being stale, and if not, adds the value.
+// Returns whether found and whether an eviction occurred.
+func (c *Cache[K, V]) ContainsOrAdd(ctx context.Context, key K, value V) (ok, evicted bool) {
+	var k K
+	var v V
+	c.lock.Lock()
+	if c.lru.Contains(key) {
+		c.lock.Unlock()
+		return true, false
+	}
+	evicted = c.lru.Add(ctx, key, value)
+	if c.onEvictedCB != nil && evicted {
+		k, v = c.evictedKeys[0], c.evictedVals[0]
+		c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0]
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && evicted {
+		c.onEvictedCB(ctx, k, v)
+	}
+	return false, evicted
+}
+
+// PeekOrAdd checks if a key is in the cache without updating the
+// recent-ness or deleting it for being stale, and if not, adds the value.
+// Returns whether found and whether an eviction occurred.
+func (c *Cache[K, V]) PeekOrAdd(ctx context.Context, key K, value V) (previous *V, ok, evicted bool) {
+	var k K
+	var v V
+	c.lock.Lock()
+	previous, ok = c.lru.Peek(key)
+	if ok {
+		c.lock.Unlock()
+		return previous, true, false
+	}
+	evicted = c.lru.Add(ctx, key, value)
+	if c.onEvictedCB != nil && evicted {
+		k, v = c.evictedKeys[0], c.evictedVals[0]
+		c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0]
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && evicted {
+		c.onEvictedCB(ctx, k, v)
+	}
+	return nil, false, evicted
+}
+
+// Remove removes the provided key from the cache.
+func (c *Cache[K, V]) Remove(ctx context.Context, key K) (present bool) {
+	var k K
+	var v V
+	c.lock.Lock()
+	present = c.lru.Remove(ctx, key)
+	if c.onEvictedCB != nil && present {
+		k, v = c.evictedKeys[0], c.evictedVals[0]
+		c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0]
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && present {
+		c.onEvicted(ctx, k, v)
+	}
+	return
+}
+
+// Resize changes the cache size.
+func (c *Cache[K, V]) Resize(ctx context.Context, size int) (evicted int) {
+	var ks []K
+	var vs []V
+	c.lock.Lock()
+	evicted = c.lru.Resize(ctx, size)
+	if c.onEvictedCB != nil && evicted > 0 {
+		ks, vs = c.evictedKeys, c.evictedVals
+		c.initEvictBuffers()
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && evicted > 0 {
+		for i := 0; i < len(ks); i++ {
+			c.onEvictedCB(ctx, ks[i], vs[i])
+		}
+	}
+	return evicted
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *Cache[K, V]) RemoveOldest(ctx context.Context) (key *K, value *V, ok bool) {
+	var k K
+	var v V
+	c.lock.Lock()
+	key, value, ok = c.lru.RemoveOldest(ctx)
+	if c.onEvictedCB != nil && ok {
+		k, v = c.evictedKeys[0], c.evictedVals[0]
+		c.evictedKeys, c.evictedVals = c.evictedKeys[:0], c.evictedVals[:0]
+	}
+	c.lock.Unlock()
+	if c.onEvictedCB != nil && ok {
+		c.onEvictedCB(ctx, k, v)
+	}
+	return
+}
+
+// GetOldest returns the oldest entry
+func (c *Cache[K, V]) GetOldest() (key *K, value *V, ok bool) {
+	c.lock.RLock()
+	key, value, ok = c.lru.GetOldest()
+	c.lock.RUnlock()
+	return
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *Cache[K, V]) Keys() []K {
+	c.lock.RLock()
+	keys := c.lru.Keys()
+	c.lock.RUnlock()
+	return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *Cache[K, V]) Len() int {
+	c.lock.RLock()
+	length := c.lru.Len()
+	c.lock.RUnlock()
+	return length
+}

cache/cache_test.go

@@ -0,0 +1,131 @@
+package cache_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/matryer/is"
+	"go.sour.is/pkg/cache"
+)
+
+func TestCache(t *testing.T) {
+	is := is.New(t)
+	ctx := context.Background()
+
+	c, err := cache.NewCache[string, int](1)
+	is.NoErr(err)
+
+	evicted := c.Add(ctx, "one", 1)
+	is.True(!evicted)
+
+	is.True(c.Contains("one"))
+	_, ok := c.Peek("one")
+	is.True(ok)
+
+	ok, evicted = c.ContainsOrAdd(ctx, "two", 2)
+	is.True(!ok)
+	is.True(evicted)
+
+	is.True(!c.Contains("one"))
+	is.True(c.Contains("two"))
+
+	is.Equal(c.Len(), 1)
+	is.Equal(c.Keys(), []string{"two"})
+
+	v, ok := c.Get("two")
+	is.True(ok)
+	is.Equal(*v, 2)
+
+	evictCount := c.Resize(ctx, 100)
+	is.True(evictCount == 0)
+
+	c.Add(ctx, "one", 1)
+
+	prev, ok, evicted := c.PeekOrAdd(ctx, "three", 3)
+	is.True(!ok)
+	is.True(!evicted)
+	is.Equal(prev, nil)
+
+	key, value, ok := c.GetOldest()
+	is.True(ok)
+	is.Equal(*key, "two")
+	is.Equal(*value, 2)
+
+	key, value, ok = c.RemoveOldest(ctx)
+	is.True(ok)
+	is.Equal(*key, "two")
+	is.Equal(*value, 2)
+
+	c.Remove(ctx, "one")
+
+	c.Purge(ctx)
+	is.True(!c.Contains("three"))
+}
+
+func TestCacheWithEvict(t *testing.T) {
+	is := is.New(t)
+	ctx := context.Background()
+
+	evictions := 0
+
+	c, err := cache.NewWithEvict(1, func(ctx context.Context, s string, i int) { evictions++ })
+	is.NoErr(err)
+
+	key, value, ok := c.GetOldest()
+	is.True(!ok)
+	is.Equal(key, nil)
+	is.Equal(value, nil)
+
+	key, value, ok = c.RemoveOldest(ctx)
+	is.True(!ok)
+	is.Equal(key, nil)
+	is.Equal(value, nil)
+
+	evicted := c.Add(ctx, "one", 1)
+	is.True(!evicted)
+
+	is.True(c.Contains("one"))
+	_, ok = c.Peek("one")
+	is.True(ok)
+
+	ok, evicted = c.ContainsOrAdd(ctx, "two", 2)
+	is.True(!ok)
+	is.True(evicted)
+
+	is.True(!c.Contains("one"))
+	is.True(c.Contains("two"))
+
+	is.Equal(c.Len(), 1)
+	is.Equal(c.Keys(), []string{"two"})
+
+	v, ok := c.Get("two")
+	is.True(ok)
+	is.Equal(*v, 2)
+
+	evictCount := c.Resize(ctx, 100)
+	is.True(evictCount == 0)
+
+	c.Add(ctx, "one", 1)
+
+	prev, ok, evicted := c.PeekOrAdd(ctx, "three", 3)
+	is.True(!ok)
+	is.True(!evicted)
+	is.Equal(prev, nil)
+
+	key, value, ok = c.GetOldest()
+	is.True(ok)
+	is.Equal(*key, "two")
+	is.Equal(*value, 2)
+
+	key, value, ok = c.RemoveOldest(ctx)
+	is.True(ok)
+	is.Equal(*key, "two")
+	is.Equal(*value, 2)
+
+	c.Resize(ctx, 1)
+
+	c.Purge(ctx)
+	is.True(!c.Contains("three"))
+
+	is.Equal(evictions, 4)
+}

cache/list.go

@@ -0,0 +1,235 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package list implements a doubly linked list.
+//
+// To iterate over a list (where l is a *List):
+//
+//	for e := l.Front(); e != nil; e = e.Next() {
+//		// do something with e.Value
+//	}
+package cache
+
+// Element is an element of a linked list.
+type Element[V any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *Element[V]
+
+	// The list to which this element belongs.
+	list *List[V]
+
+	// The value stored with this element.
+	Value V
+}
+
+// Next returns the next list element or nil.
+func (e *Element[V]) Next() *Element[V] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *Element[V]) Prev() *Element[V] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// List represents a doubly linked list.
+// The zero value for List is an empty list ready to use.
+type List[V any] struct {
+	root Element[V] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int        // current list length excluding (this) sentinel element
+}
+
+// Init initializes or clears list l.
+func (l *List[V]) Init() *List[V] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// NewList returns an initialized list.
+func NewList[V any]() *List[V] { return new(List[V]).Init() }
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *List[V]) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *List[V]) Front() *Element[V] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *List[V]) Back() *Element[V] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *List[V]) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *List[V]) insert(e, at *Element[V]) *Element[V] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *List[V]) insertValue(v V, at *Element[V]) *Element[V] {
+	return l.insert(&Element[V]{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len
+func (l *List[V]) remove(e *Element[V]) {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+}
+
+// move moves e to next to at.
+func (l *List[V]) move(e, at *Element[V]) {
+	if e == at {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *List[V]) Remove(e *Element[V]) any {
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero Element) and l.remove will crash
+		l.remove(e)
+	}
+	return e.Value
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *List[V]) PushFront(v V) *Element[V] {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *List[V]) PushBack(v V) *Element[V] {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[V]) InsertBefore(v V, mark *Element[V]) *Element[V] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[V]) InsertAfter(v V, mark *Element[V]) *Element[V] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[V]) MoveToFront(e *Element[V]) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[V]) MoveToBack(e *Element[V]) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[V]) MoveBefore(e, mark *Element[V]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[V]) MoveAfter(e, mark *Element[V]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark)
+}
+
+// PushBackList inserts a copy of another list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[V]) PushBackList(other *List[V]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of another list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[V]) PushFrontList(other *List[V]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}

cache/lru.go

@@ -0,0 +1,175 @@
+package cache
+
+import (
+	"context"
+	"errors"
+)
+
+// EvictCallback is used to get a callback when a cache entry is evicted
+type EvictCallback[K comparable, V any] func(context.Context, K, V)
+
+// LRU implements a non-thread safe fixed size LRU cache
+type LRU[K comparable, V any] struct {
+	size      int
+	evictList *List[entry[K, V]]
+	items     map[K]*Element[entry[K, V]]
+	onEvict   EvictCallback[K, V]
+}
+
+// entry is used to hold a value in the evictList
+type entry[K comparable, V any] struct {
+	key   K
+	value V
+}
+
+// NewLRU constructs an LRU of the given size
+func NewLRU[K comparable, V any](size int, onEvict EvictCallback[K, V]) (*LRU[K, V], error) {
+	if size <= 0 {
+		return nil, errors.New("must provide a positive size")
+	}
+	c := &LRU[K, V]{
+		size:      size,
+		evictList: NewList[entry[K, V]](),
+		items:     make(map[K]*Element[entry[K, V]]),
+		onEvict:   onEvict,
+	}
+	return c, nil
+}
+
+// Purge is used to completely clear the cache.
+func (c *LRU[K, V]) Purge(ctx context.Context) {
+	for k, v := range c.items {
+		if c.onEvict != nil {
+			c.onEvict(ctx, k, v.Value.value)
+		}
+		delete(c.items, k)
+	}
+	c.evictList.Init()
+}
+
+// Add adds a value to the cache.  Returns true if an eviction occurred.
+func (c *LRU[K, V]) Add(ctx context.Context, key K, value V) (evicted bool) {
+	// Check for existing item
+	if ent, ok := c.items[key]; ok {
+		c.evictList.MoveToFront(ent)
+		ent.Value.value = value
+		return false
+	}
+
+	// Add new item
+	entry := c.evictList.PushFront(entry[K, V]{key, value})
+	c.items[key] = entry
+
+	evict := c.evictList.Len() > c.size
+	// Verify size not exceeded
+	if evict {
+		c.removeOldest(ctx)
+	}
+	return evict
+}
+
+// Get looks up a key's value from the cache.
+func (c *LRU[K, V]) Get(key K) (value *V, ok bool) {
+	if ent, ok := c.items[key]; ok {
+		c.evictList.MoveToFront(ent)
+		if ent == nil {
+			return nil, false
+		}
+		return &ent.Value.value, true
+	}
+	return
+}
+
+// Contains checks if a key is in the cache, without updating the recent-ness
+// or deleting it for being stale.
+func (c *LRU[K, V]) Contains(key K) (ok bool) {
+	_, ok = c.items[key]
+	return ok
+}
+
+// Peek returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *LRU[K, V]) Peek(key K) (value *V, ok bool) {
+	if ent, ok := c.items[key]; ok {
+		return &ent.Value.value, true
+	}
+	return nil, false
+}
+
+// Remove removes the provided key from the cache, returning if the
+// key was contained.
+func (c *LRU[K, V]) Remove(ctx context.Context, key K) (present bool) {
+	if ent, ok := c.items[key]; ok {
+		c.removeElement(ctx, ent)
+		return true
+	}
+	return false
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *LRU[K, V]) RemoveOldest(ctx context.Context) (key *K, value *V, ok bool) {
+	ent := c.evictList.Back()
+	if ent != nil {
+		c.removeElement(ctx, ent)
+		kv := ent.Value
+		return &kv.key, &kv.value, true
+	}
+	return nil, nil, false
+}
+
+// GetOldest returns the oldest entry
+func (c *LRU[K, V]) GetOldest() (key *K, value *V, ok bool) {
+	ent := c.evictList.Back()
+	if ent != nil {
+		kv := ent.Value
+		return &kv.key, &kv.value, true
+	}
+	return nil, nil, false
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *LRU[K, V]) Keys() []K {
+	keys := make([]K, len(c.items))
+	i := 0
+	for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() {
+		keys[i] = ent.Value.key
+		i++
+	}
+	return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *LRU[K, V]) Len() int {
+	return c.evictList.Len()
+}
+
+// Resize changes the cache size.
+func (c *LRU[K, V]) Resize(ctx context.Context, size int) (evicted int) {
+	diff := c.Len() - size
+	if diff < 0 {
+		diff = 0
+	}
+	for i := 0; i < diff; i++ {
+		c.removeOldest(ctx)
+	}
+	c.size = size
+	return diff
+}
+
+// removeOldest removes the oldest item from the cache.
+func (c *LRU[K, V]) removeOldest(ctx context.Context) {
+	ent := c.evictList.Back()
+	if ent != nil {
+		c.removeElement(ctx, ent)
+	}
+}
+
+// removeElement is used to remove a given list element from the cache
+func (c *LRU[K, V]) removeElement(ctx context.Context, e *Element[entry[K, V]]) {
+	c.evictList.Remove(e)
+	kv := e.Value
+	delete(c.items, kv.key)
+	if c.onEvict != nil {
+		c.onEvict(ctx, kv.key, kv.value)
+	}
+}