Rename struct LazyCache => Cache

Author: bep

README.md

@@ -5,14 +5,14 @@
 
 **Note:** This is still a work in progress and the API will most likely change.
 
-**Lazycache** is a simple thread safe in-memory LRU cache. Under the hood it leverages the great [simpleru package in golang-lru](https://github.com/hashicorp/golang-lru), with its exellent performance. One big difference between `golang-lru` and this library is the [GetOrCreate](https://pkg.go.dev/github.com/bep/lazycache#LazyCache.GetOrCreate) method, which provides: 
+**Lazycache** is a simple thread safe in-memory LRU cache. Under the hood it leverages the great [simpleru package in golang-lru](https://github.com/hashicorp/golang-lru), with its exellent performance. One big difference between `golang-lru` and this library is the [GetOrCreate](https://pkg.go.dev/github.com/bep/lazycache#Cache.GetOrCreate) method, which provides: 
 
 * Non-blocking cache priming on cache misses. 
 * A guarantee that the prime function is only called once for a given key.
 * The cache's [RWMutex](https://pkg.go.dev/sync#RWMutex) is not locked during the execution of the prime function, which should make it easier to reason about potential deadlocks.
 
 Other notable features:
 
-* The cache can be [resized](https://pkg.go.dev/github.com/bep/lazycache#LazyCache.Resize) while running.
+* The cache can be [resized](https://pkg.go.dev/github.com/bep/lazycache#Cache.Resize) while running.
 * When the number of entries overflows the defined cache size, the least recently used item gets discarded (LRU).
 

lazycache.go

@@ -8,13 +8,13 @@ import (
 
 var _ = Entry(&delayedEntry{})
 
-// New creates a new LazyCache.
-func New(options CacheOptions) *LazyCache {
+// New creates a new Cache.
+func New(options CacheOptions) *Cache {
 	lru, err := simplelru.NewLRU(int(options.MaxEntries), nil)
 	if err != nil {
 		panic(err)
 	}
-	c := &LazyCache{
+	c := &Cache{
 		lru: lru,
 	}
 	return c
@@ -33,13 +33,13 @@ type Entry interface {
 	Err() error
 }
 
-type LazyCache struct {
+type Cache struct {
 	lru *simplelru.LRU
 	mu  sync.RWMutex
 }
 
 // Contains returns true if the given key is in the cache.
-func (c *LazyCache) Contains(key any) bool {
+func (c *Cache) Contains(key any) bool {
 	c.mu.RLock()
 	b := c.lru.Contains(key)
 	c.mu.RUnlock()
@@ -48,14 +48,14 @@ func (c *LazyCache) Contains(key any) bool {
 
 // Delete deletes the item with given key from the cache, returning if the
 // key was contained.
-func (c *LazyCache) Delete(key any) bool {
+func (c *Cache) Delete(key any) bool {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	return c.lru.Remove(key)
 }
 
 // DeleteFunc deletes all entries for which the given function returns true.
-func (c *LazyCache) DeleteFunc(matches func(key any, item Entry) bool) int {
+func (c *Cache) DeleteFunc(matches func(key any, item Entry) bool) int {
 	c.mu.RLock()
 	keys := c.lru.Keys()
 
@@ -81,21 +81,21 @@ func (c *LazyCache) DeleteFunc(matches func(key any, item Entry) bool) int {
 }
 
 // Keys returns a slice of the keys in the cache, oldest first.
-func (c *LazyCache) Keys() []any {
+func (c *Cache) Keys() []any {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return c.lru.Keys()
 }
 
 // Len returns the number of items in the cache.
-func (c *LazyCache) Len() int {
+func (c *Cache) Len() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return c.lru.Len()
 }
 
 // Get returns the value associated with key.
-func (c *LazyCache) Get(key any) Entry {
+func (c *Cache) Get(key any) Entry {
 	c.mu.Lock()
 	v, ok := c.lru.Get(key)
 	c.mu.Unlock()
@@ -109,7 +109,7 @@ func (c *LazyCache) Get(key any) Entry {
 // Note that create, the cache prime function, is called once and then not called again for a given key
 // unless the cache entry is evicted; it does not block other goroutines from calling GetOrCreate,
 // it is not called with the cache lock held.
-func (c *LazyCache) GetOrCreate(key any, create func(key any) (any, error)) Entry {
+func (c *Cache) GetOrCreate(key any, create func(key any) (any, error)) Entry {
 	c.mu.Lock()
 	v, ok := c.lru.Get(key)
 	if ok {
@@ -138,15 +138,15 @@ func (c *LazyCache) GetOrCreate(key any, create func(key any) (any, error)) Entr
 }
 
 // Resize changes the cache size and returns the number of entries evicted.
-func (c *LazyCache) Resize(size int) (evicted int) {
+func (c *Cache) Resize(size int) (evicted int) {
 	c.mu.Lock()
 	evicted = c.lru.Resize(size)
 	c.mu.Unlock()
 	return evicted
 }
 
 // Set associates value with key.
-func (c *LazyCache) Set(key, value any) {
+func (c *Cache) Set(key, value any) {
 	c.mu.Lock()
 	if _, ok := value.(Entry); !ok {
 		value = entry{

lazycache_test.go

@@ -120,7 +120,7 @@ func TestGetOrCreateConcurrent(t *testing.T) {
 func BenchmarkGetOrCreate(b *testing.B) {
 	const maxSize = 1000
 
-	runBenchmark := func(b *testing.B, cache *LazyCache, getOrCreate func(key any, create func(key any) (any, error)) Entry) {
+	runBenchmark := func(b *testing.B, cache *Cache, getOrCreate func(key any, create func(key any) (any, error)) Entry) {
 		r := rand.New(rand.NewSource(99))
 		var mu sync.Mutex
 
@@ -241,7 +241,7 @@ func BenchmarkCacheParallel(b *testing.B) {
 
 // These are only used in benchmarks.
 // This should be functionally equivalent to GetOrCreate.
-func (c *LazyCache) getOrCreateBaselineLock(key any, create func(key any) (any, error)) Entry {
+func (c *Cache) getOrCreateBaselineLock(key any, create func(key any) (any, error)) Entry {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	v, ok := c.lru.Get(key)
@@ -263,7 +263,7 @@ func (c *LazyCache) getOrCreateBaselineLock(key any, create func(key any) (any,
 }
 
 // This variant does not hold any lock while calling create, which means it may be called multiple times for the same key.
-func (c *LazyCache) getOrCreateBaselDoubleCheckedLock(key any, create func(key any) (any, error)) Entry {
+func (c *Cache) getOrCreateBaselDoubleCheckedLock(key any, create func(key any) (any, error)) Entry {
 	c.mu.Lock()
 	v, ok := c.lru.Get(key)
 	if ok {