cache

c := memcache.New(memcache.WithMaxEntries(100_000))
defer c.Close()

// Bytes in, bytes out. Get returns (nil, cache.ErrNotFound) on miss — never (nil, nil).
_ = c.Set(ctx, "k", []byte("v"), time.Minute)
b, err := c.Get(ctx, "k")

// Typed load-through with stampede protection and the differentiator options:
u, err := cache.Remember(ctx, c, "user:42", 5*time.Minute,
    func(ctx context.Context) (User, error) { return db.LoadUser(ctx, 42) },
    cache.WithJitter(0.1),                 // spread expiry across a batch of keys
    cache.WithStaleIfError(time.Minute),   // serve last-good if the loader fails
    cache.WithRefreshAhead(0.8),           // refresh hot keys before they expire
)

// Multi-tenant isolation:
tenant := cache.Namespaced(c, "tenant:42")

// Portable distributed lock (works on any backend):
l := cache.NewLock(c, "cron:nightly", 30*time.Second)
if err := l.Acquire(ctx); err == nil {
    defer l.Release(ctx)
    // ... only one holder runs this ...
}

c := cache.NewAuditLog(
        cache.NewBulkhead(
            cache.NewRetry(
                cache.NewCircuitBreaker(rediscache.New(rdb)),
            ), 256),
        auditSink)

type Cache interface {
    Get(ctx, key) ([]byte, error)
    GetMulti(ctx, keys) (map[string][]byte, error)
    Has(ctx, key) (bool, error)
    TTL(ctx, key) (time.Duration, error)
    Set(ctx, key, val, ttl) error
    SetMulti(ctx, items map[string]Item) error
    SetNX(ctx, key, val, ttl) (bool, error)
    Expire(ctx, key, ttl) error
    Touch(ctx, key) error
    Incr(ctx, key, delta) (int64, error)
    Decr(ctx, key, delta) (int64, error)
    Del(ctx, keys ...string) error
    DeleteByPrefix(ctx, prefix) error
    Flush(ctx) error
    Iterate(ctx, IterateOpts) Iterator
    Ping(ctx) error
    Close() error
    Stats() Stats
}

v, err := c.Get(ctx, "user:42")
if errors.Is(err, cache.ErrNotFound) {
    // cache miss — load it
}