Reduce the public interface of cache

Author: emad-elsaid

cache/with_fallback.go

@@ -1,16 +1,23 @@
 package cache
 
 // WithFallback On read it will return the first available value in the
-// cachers then write to all the caches missing the value in the way. On write
-// it will write to all caches.
-type WithFallback[K, V any] struct {
+// cachers then write to all the caches missing the value in the way.
+//
+// On store it will store to all caches.
+func WithFallback[K, V any](c ...Cacher[K, V]) Cacher[K, V] {
+	return &withFallback[K, V]{
+		Caches: c,
+	}
+}
+
+type withFallback[K, V any] struct {
 	Caches []Cacher[K, V]
 }
 
 // Load will ask every cacher for the key in order. keep track of all caches missing the key.
 // When the key is found it writes the value to all the caches that was asked for the key and didn't have it
 // effectively bringing the key to cachers at the top of the list.
-func (c *WithFallback[K, V]) Load(key K) (value V, ok bool) {
+func (c *withFallback[K, V]) Load(key K) (value V, ok bool) {
 	for i := range c.Caches {
 		if value, ok = c.Caches[i].Load(key); ok {
 			// From the previous cache backward until we hit the head of the slice
@@ -27,7 +34,7 @@ func (c *WithFallback[K, V]) Load(key K) (value V, ok bool) {
 }
 
 // Store will store the key, value pair in all the cachers in order
-func (c *WithFallback[K, V]) Store(key K, value V) {
+func (c *withFallback[K, V]) Store(key K, value V) {
 	for i := range c.Caches {
 		c.Caches[i].Store(key, value)
 	}

cache/with_fallback_test.go

@@ -5,9 +5,7 @@ import "testing"
 func TestWithFallback(t *testing.T) {
 	t.Run("Load", func(t *testing.T) {
 		var c1, c2 Cache[string, int]
-		c := WithFallback[string, int]{
-			Caches: []Cacher[string, int]{&c1, &c2},
-		}
+		c := WithFallback(&c1, &c2)
 
 		// Looking up non-existent
 		v, ok := c.Load("non-existent")
@@ -33,9 +31,7 @@ func TestWithFallback(t *testing.T) {
 
 	t.Run("Store", func(t *testing.T) {
 		var c1, c2 Cache[string, int]
-		c := WithFallback[string, int]{
-			Caches: []Cacher[string, int]{&c1, &c2},
-		}
+		c := WithFallback(&c1, &c2)
 
 		c.Store("k1", 1)
 

cache/with_read_only.go

@@ -3,13 +3,17 @@ package cache
 // WithReadOnly wraps another cacher making it's Store method Noop. useful with
 // combination of CacheWithFallback. you can supress writes to some levels of
 // the caches for example a list of [memory, redis, database] will store values
-// in all of them on write, wrapping `database` in WithReadOnly will stop it
+// in all of them on write, wrapping `database` in withReadOnly will stop it
 // from being modified. So the CacheWithFallback will bring up the values from
 // the database to faster cachers without modifying it. Also useful if your
 // database is readonly.
-type WithReadOnly[K, V any] struct {
+func WithReadOnly[K, V any](c Loader[K, V]) Cacher[K, V] {
+	return &withReadOnly[K, V]{c}
+}
+
+type withReadOnly[K, V any] struct {
 	Loader[K, V]
 }
 
 // Store method in this case is a Noop
-func (r *WithReadOnly[K, V]) Store(key K, value V) {}
+func (r *withReadOnly[K, V]) Store(key K, value V) {}

cache/with_read_only_test.go

@@ -4,7 +4,7 @@ import "testing"
 
 func TestWithReadOnly(t *testing.T) {
 	var c1 Cache[string, int]
-	ro := WithReadOnly[string, int]{&c1}
+	ro := WithReadOnly(&c1)
 
 	c1.Store("k1", 1)
 	v, ok := ro.Load("k1")

cache/with_write_only.go

@@ -1,12 +1,16 @@
 package cache
 
-// WithWriteOnly wraps another cacher making it's Load method Noop. useful for
+// withWriteOnly wraps another cacher making it's Load method Noop. useful for
 // systems that you would like to write to without reading from. For example you
 // can have the last cache of your system write to Kafka. But doesn't attempt to
 // read from it.
-type WithWriteOnly[K, V any] struct {
+func WithWriteOnly[K, V any](c Storer[K, V]) Cacher[K, V] {
+	return &withWriteOnly[K, V]{c}
+}
+
+type withWriteOnly[K, V any] struct {
 	Storer[K, V]
 }
 
 // Load always respond with false
-func (w *WithWriteOnly[K, V]) Load(key K) (value V, ok bool) { return value, false }
+func (w *withWriteOnly[K, V]) Load(key K) (value V, ok bool) { return value, false }

cache/with_write_only_test.go

@@ -4,7 +4,7 @@ import "testing"
 
 func TestWithWriteOnly(t *testing.T) {
 	var c1 Cache[string, int]
-	wo := WithWriteOnly[string, int]{&c1}
+	wo := WithWriteOnly(&c1)
 
 	c1.Store("k1", 1)
 	v, ok := wo.Load("k1")