Here is some thoughts ~

[yeqown]

for now, all cache implement CacheInterface, but some cache is using CacheInterface:
could I understand this as the Decorator pattern ?

// LoadableCache represents a cache that uses a function to load data
type LoadableCache struct {
	loadFunc   loadFunction
	cache      CacheInterface
	setChannel chan *loadableKeyValue
}

// Marshaler is the struct that marshal and unmarshal cache values
type Marshaler struct {
	cache cache.CacheInterface
}

AND StoreInterface is same to CacheInterface,

// CacheInterface represents the interface for all caches (aggregates, metric, memory, redis, ...)
type CacheInterface interface {
	Get(key interface{}) (interface{}, error)
	Set(key, object interface{}, options *store.Options) error
	Delete(key interface{}) error
	Invalidate(options store.InvalidateOptions) error
	Clear() error
	GetType() string
}

// StoreInterface is the interface for all available stores
type StoreInterface interface {
	Get(key interface{}) (interface{}, error)
	Set(key interface{}, value interface{}, options *Options) error
	Delete(key interface{}) error
	Invalidate(options InvalidateOptions) error
	Clear() error
	GetType() string
}

according to the above case, there is my thoughts:

1. all cache implement CacheInterface, all store implement StoreInterface, this is good, but the two interface should be different (CacheInterface is an wrapper of StoreInterface, but provide extern functions like: "metrics, loadable, chain and others"), I would change CacheInterface as:

// CacheInterface represents the interface for all caches (aggregates, metric, memory, redis, ...)
type CacheInterface interface {
	Get(key interface{}) (interface{}, error)
	Set(key, object interface{}, options *store.Options) error
	Delete(key interface{}) error
	Invalidate(options store.InvalidateOptions) error
	Clear() error

        GetType() string                                     // return cache type
        GetCodec()  codec.CodecInterface{}  // get codec instance
        GetStore() store.StoreInterface{}        // get current store instance
}

2. all cache constructor should return CacheInterface to limit usage.

3. I also think about extern functions, Could we coding them as WithLoadFunc() WithMetrics() WithChain()

type Option struct {
    marshal mashaler.MarshalerInterface
    // ...  other fields
}

func WithMarshal(params ...string) *Option {
  // do something
}

func NewCache(store store.StoreInterface, opts ...*Options) CacheInterface {
      // to construct a Cache
}

I hope this image can help to understand me ~~~