add support for generics

Author: mycrEEpy

README.md

@@ -5,7 +5,7 @@
 [![Go Build & Test](https://github.com/mycrEEpy/mempot/actions/workflows/build.yml/badge.svg)](https://github.com/mycrEEpy/mempot/actions/workflows/build.yml)
 [![Go Coverage](https://github.com/mycreepy/mempot/wiki/coverage.svg)](https://raw.githack.com/wiki/mycreepy/mempot/coverage.html)
 
-`mempot` is a small and easy memory cache for Go.
+`mempot` is a small and easy generic memory cache for Go.
 
 ## Usage
 
@@ -19,20 +19,15 @@ import (
 )
 
 func main() {
-	cache := mempot.New()
+	cache := mempot.NewCache[string, string](mempot.Config{})
 
 	cache.Set("foo", "bar")
 
 	item, ok := cache.Get("foo")
 	if !ok {
 		panic("item not found or expired")
 	}
-
-	data, ok := item.Data.(string)
-	if !ok {
-		panic("item data is not a string")
-	}
 
-	fmt.Println(data)
+	fmt.Println(item.Data)
 }
 ```

mempot.go

@@ -7,10 +7,21 @@ import (
 	"time"
 )
 
+// Config allows to alter the configuration of a Cache.
+//
+// Context is by default an empty background context.
+// DefaultTTL is by default 15 minutes.
+// CleanupInterval is by default 5 minutes.
+type Config struct {
+	Context         context.Context
+	DefaultTTL      time.Duration
+	CleanupInterval time.Duration
+}
+
 // Cache holds the data you want to cache in memory.
-type Cache struct {
+type Cache[K comparable, T any] struct {
 	mut  sync.RWMutex
-	data map[string]Item
+	data map[K]Item[T]
 
 	defaultTTL      time.Duration
 	cleanupInterval time.Duration
@@ -19,137 +30,118 @@ type Cache struct {
 	cancel context.CancelFunc
 }
 
-// Item is a unit of data which can be cached and has an expiration as Unix epoch.
-type Item struct {
-	Data any
+// Item is a unit of typed data which can be cached and has an expiration as Unix epoch.
+type Item[T any] struct {
+	Data T
 	TTL  int64
 }
 
 // Expired returns true if the data of the Item has expired.
-func (i *Item) Expired() bool {
+func (i *Item[T]) Expired() bool {
 	return time.Now().Unix() > i.TTL
 }
 
-// Option can alter the behavior of a Cache.
-type Option func(*Cache)
-
-// New create a new Cache instance.
-func New(opts ...Option) *Cache {
-	c := &Cache{
-		data:            make(map[string]Item),
+// NewCache create a new Cache instance with K as key and T as data.
+func NewCache[K comparable, T any](cfg Config) *Cache[K, T] {
+	c := &Cache[K, T]{
+		data:            make(map[K]Item[T]),
 		defaultTTL:      time.Minute * 15,
 		cleanupInterval: time.Minute * 5,
 	}
 
 	c.ctx, c.cancel = context.WithCancel(context.Background())
 
-	for _, opt := range opts {
-		opt(c)
+	if cfg.Context != nil {
+		c.ctx = cfg.Context
 	}
 
-	go c.cleanup()
-
-	return c
-}
-
-// WithDefaultTTL changes the default time-to-live for an Item in the Cache.
-// Default is 15m.
-func WithDefaultTTL(ttl time.Duration) Option {
-	return func(c *Cache) {
-		c.defaultTTL = ttl
+	if cfg.DefaultTTL > 0 {
+		c.defaultTTL = cfg.DefaultTTL
 	}
-}
 
-// WithCleanupInterval changes the default interval at which expired Items are removed from the Cache.
-// Default is 5m.
-func WithCleanupInterval(interval time.Duration) Option {
-	return func(c *Cache) {
-		c.cleanupInterval = interval
+	if cfg.CleanupInterval > 0 {
+		c.cleanupInterval = cfg.CleanupInterval
 	}
-}
 
-// WithContext adds a custom context for the Cache.
-// If the context is canceled, the cleanup ticker will stop.
-func WithContext(ctx context.Context) Option {
-	return func(c *Cache) {
-		c.ctx = ctx
-	}
+	go c.cleanup()
+
+	return c
 }
 
 // Set will add an Item to the Cache with the default time-to-live.
-func (c *Cache) Set(key string, value any) {
+func (c *Cache[K, T]) Set(key K, value T) {
 	c.SetWithTTL(key, value, c.defaultTTL)
 }
 
 // SetWithTTL will add an Item to the Cache with the given time-to-live.
-func (c *Cache) SetWithTTL(key string, data any, ttl time.Duration) {
+func (c *Cache[K, T]) SetWithTTL(key K, data T, ttl time.Duration) {
 	c.mut.Lock()
-	c.data[key] = Item{Data: data, TTL: time.Now().Add(ttl).Unix()}
+	c.data[key] = Item[T]{Data: data, TTL: time.Now().Add(ttl).Unix()}
 	c.mut.Unlock()
 }
 
 // Get returns an Item and true if the Item was found in the Cache and has not been expired.
 // An empty Item and false is returned when the Item was not found or has been expired.
-func (c *Cache) Get(key string) (Item, bool) {
+func (c *Cache[K, T]) Get(key K) (Item[T], bool) {
 	c.mut.RLock()
 	item, ok := c.data[key]
 	c.mut.RUnlock()
 
 	if item.Expired() {
-		return Item{}, false
+		return Item[T]{}, false
 	}
 
 	return item, ok
 }
 
 // QueryFunc is a function to retrieve data which will be put into the Cache.
-type QueryFunc func(key string) (any, error)
+type QueryFunc[K comparable, T any] func(key K) (T, error)
 
 // Remember tries to get the Item from the Cache, if the Item is not found or expired QueryFunc is called
 // to retrieve the data from source and put it into the Cache.
-func (c *Cache) Remember(key string, query QueryFunc) (Item, error) {
+func (c *Cache[K, T]) Remember(key K, query QueryFunc[K, T]) (Item[T], error) {
 	return c.RememberWithTTL(key, query, c.defaultTTL)
 }
 
 // RememberWithTTL tries to get the Item from the Cache, if the Item is not found or expired QueryFunc is called
 // to retrieve the data from source and put it into the Cache with the given time-to-live.
-func (c *Cache) RememberWithTTL(key string, query QueryFunc, ttl time.Duration) (Item, error) {
+func (c *Cache[K, T]) RememberWithTTL(key K, query QueryFunc[K, T], ttl time.Duration) (Item[T], error) {
 	item, ok := c.Get(key)
 	if ok {
 		return item, nil
 	}
 
 	data, err := query(key)
 	if err != nil {
-		return Item{}, fmt.Errorf("failed to query data: %w", err)
+		return Item[T]{}, fmt.Errorf("failed to query data: %w", err)
 	}
 
 	c.SetWithTTL(key, data, ttl)
 
-	return Item{Data: data, TTL: time.Now().Add(c.defaultTTL).Unix()}, nil
+	return Item[T]{Data: data, TTL: time.Now().Add(c.defaultTTL).Unix()}, nil
 }
 
 // Delete removes an Item from the Cache.
-func (c *Cache) Delete(key string) {
+func (c *Cache[K, T]) Delete(key K) {
 	c.mut.Lock()
 	delete(c.data, key)
 	c.mut.Unlock()
 }
 
 // Reset removes all Items from the Cache.
-func (c *Cache) Reset() {
+func (c *Cache[K, T]) Reset() {
 	c.mut.Lock()
-	c.data = make(map[string]Item)
+	c.data = make(map[K]Item[T])
 	c.mut.Unlock()
 }
 
 // Cancel will cancel the default Context of the Cache which stops the cleanup ticker.
 // This only has an effect when the Cache has not been created with a custom context.
-func (c *Cache) Cancel() {
+func (c *Cache[K, T]) Cancel() {
 	c.cancel()
 }
 
-func (c *Cache) cleanup() {
+func (c *Cache[K, T]) cleanup() {
 	ticker := time.NewTicker(c.cleanupInterval)
 
 	for {
@@ -158,7 +150,7 @@ func (c *Cache) cleanup() {
 			ticker.Stop()
 			return
 		case <-ticker.C:
-			toBeDeleted := make([]string, 0)
+			toBeDeleted := make([]K, 0)
 
 			c.mut.RLock()
 			for key, item := range c.data {

mempot_test.go

@@ -13,7 +13,11 @@ const data = "bar"
 func TestCache(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 
-	cache := New(WithDefaultTTL(30*time.Second), WithCleanupInterval(4*time.Second), WithContext(ctx))
+	cache := NewCache[string, string](Config{
+		Context:         ctx,
+		DefaultTTL:      30 * time.Second,
+		CleanupInterval: 4 * time.Second,
+	})
 
 	cache.SetWithTTL(key, "bar", 2*time.Second)
 
@@ -22,13 +26,8 @@ func TestCache(t *testing.T) {
 		t.Error("item not found")
 	}
 
-	got, ok := item.Data.(string)
-	if !ok {
-		t.Error("item data is not a string")
-	}
-
-	if got != data {
-		t.Errorf("got %s, want %s", got, data)
+	if item.Data != data {
+		t.Errorf("got %s, want %s", item.Data, data)
 	}
 
 	// wait for cleanup
@@ -55,14 +54,14 @@ func TestCache(t *testing.T) {
 		t.Error("item still exists after delete all")
 	}
 
-	_, err := cache.Remember(key, func(key string) (any, error) {
-		return nil, errors.New("data not available")
+	_, err := cache.Remember(key, func(key string) (string, error) {
+		return "", errors.New("data not available")
 	})
 	if err == nil {
 		t.Error("QueryFunc failed but Remember did not return an error")
 	}
 
-	_, err = cache.Remember(key, func(key string) (any, error) {
+	_, err = cache.Remember(key, func(key string) (string, error) {
 		return data, nil
 	})
 	if err != nil {