Cannot use other type except "any" when using Marshaler

[rajatbhatnagar94]

Steps for Reproduction

Changing the generic type of the cache from any to any other type doesn't work. The code fails to compile as Marshaler doesn't implement the specific generic type. For example, in your test cases for marshal, if I change the generic type while initializing cache to string instead of any I see an error while initializing the marshal object.

Sample Code:

func TestNew(t *testing.T) {
	// Given
	ctrl := gomock.NewController(t)

	cache := cache.NewMockCacheInterface[string](ctrl) // changed the type from `any` to `string`
	// When
	marshaler := New(cache) // (errors out here)

	// Then
	assert.IsType(t, new(Marshaler), marshaler)
	assert.Equal(t, cache, marshaler.cache)
}

Let me know if I'm using it incorrectly, but according to the Readme with the Book example, it should be correct.
Here's another example

package main

import (
	"fmt"

	redis "github.com/go-redis/redis/v8"
	cache "github.com/eko/gocache/lib/v4/cache"
	metrics "github.com/eko/gocache/lib/v4/metrics"
	marshaler "github.com/eko/gocache/lib/v4/marshaler"
	redis_store "github.com/eko/gocache/store/redis/v4"
)
type Book struct{}
func main() {

	// Initialize Redis client and store
		redisClient := redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
		redisStore := redis_store.NewRedis(redisClient)

		promMetrics := metrics.NewPrometheus("my-test-app")
		// Initialize chained cache
		cacheManager := cache.NewMetric[*Book](
			promMetrics,
			cache.New[*Book](redisStore),
		)

		// Initializes marshaler
		marshal := marshaler.New(cacheManager) // throws an error here
		fmt.Println(marshal)
}

Expected behavior:
It should be able to initialize the object properly.

Actual behavior:

./marshaler_test.go:26:19: cannot use cache (variable of type *cache.MockCacheInterface[string]) as cache.CacheInterface[any] value in argument to New: *cache.MockCacheInterface[string] does not implement cache.CacheInterface[any] (wrong type for method Get)
                have Get(context.Context, any) (string, error)
                want Get(context.Context, any) (any, error)
FAIL    github.com/eko/gocache/lib/v4/marshaler [build failed]

Second error:

cannot use cacheManager (variable of type *cache.MetricCache[*Book]) as cache.CacheInterface[any] value in argument to marshaler.New: *cache.MetricCache[*Book] does not implement cache.CacheInterface[any] (wrong type for method Get)
		have Get(context.Context, any) (*Book, error)
		want Get(context.Context, any) (any, error)compiler[InvalidIfaceAssign](https://pkg.go.dev/golang.org/x/tools/internal/typesinternal#InvalidIfaceAssign)

Platforms:

Include browser, operating system and respective versions: Linux

Versions:

Which versions are you running? v4.1.2

[hoshsadiq]

Got test same issue here:

package main_test

import (
	"context"
	"github.com/eko/gocache/lib/v4/cache"
	"github.com/eko/gocache/lib/v4/marshaler"
	redis_store "github.com/eko/gocache/store/redis/v4"
	"github.com/redis/go-redis/v9"
	"testing"
)

func TestInvalidTypes(t *testing.T) {
	// Client stores the client to the underlying cache service
	var client *redis.Client

	// cache stores the cache interface
	var cStore *cache.Cache[string]

	client = redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
	cacheStore := redis_store.NewRedis(client, nil)
	cStore = cache.New[string](cacheStore)

	m := marshaler.New(cStore)
	m.Set(context.Background(), "somekey", "somevalue")
}

$ go test .
# github.com/hoshsadiq/playground/main_test [github.com/hoshsadiq/playground/main.test]
./cache_test.go:23:21: cannot use cStore (variable of type *cache.Cache[string]) as cache.CacheInterface[any] value in argument to marshaler.New: *cache.Cache[string] does not implement cache.CacheInterface[any] (wrong type for method Get)
                have Get(context.Context, any) (string, error)
                want Get(context.Context, any) (any, error)
FAIL    github.com/hoshsadiq/playground/main [build failed]
FAIL

[bohdand-weka]

I think marshaler concept is wrong.

Better to use marshaler over store, but it requires to patch marshaler by ourself.

The target usage in my case would be like this:

        client = redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
	cacheStore := redis_store.NewRedis(client, nil)
	cStore = cache.New[string](marshaler.New[string](cacheStore))

	m.Set(context.Background(), "somekey", "somevalue")