typed_cache 0.3.1 → 0.4.0.pre.1

data/lib/typed_cache/store.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module TypedCache
-  # @rbs!
-  #
-
   # Generic interface for type-safe cache storage implementations
   # All stores are assumed to handle namespacing internally
   #
@@ -12,31 +9,38 @@ module TypedCache
   # - Queries (get, key?, fetch) ask questions without side effects
   #
   # @rbs generic V
-  module Store
+  class Store
     # @rbs! type cache_key = String | CacheKey
 
     # @rbs!
     #   interface _Store[V]
-    #     def read: (cache_key) -> either[Error, Snapshot[V]]
-    #     def read_all: (Array[cache_key]) -> either[Error, Array[Snapshot[V]]]
+    #     def read: (cache_key) -> either[Error, Snapshot[maybe[V]]]
+    #     def read_all: (Array[cache_key]) -> either[Error, Hash[CacheKey, Snapshot[V]]]
     #     def ref: (cache_key) -> CacheRef[V]
     #     def write: (cache_key, V) -> either[Error, Snapshot[V]]
-    #     def write_all: (Hash[cache_key, V]) -> either[Error, Array[Snapshot[V]]]
-    #     def delete: (cache_key) -> either[Error, Snapshot[V]]
+    #     def write_all: (Hash[cache_key, V]) -> either[Error, Hash[CacheKey, Snapshot[V]]]
+    #     def delete: (cache_key) -> either[Error, maybe[V]]
     #     def key?: (cache_key) -> bool
-    #     def clear: () -> maybe[Error]
-    #     def fetch: (cache_key) { () -> V? } -> either[Error, Snapshot[maybe[V]]]
+    #     def clear: () -> void
+    #     def fetch: (cache_key) { (CacheKey) -> V? } -> either[Error, Snapshot[maybe[V]]]
     #     def fetch_all: (Array[cache_key]) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
+    #     def fetch_or_compute_all: (Array[cache_key]) { (Array[CacheKey]) -> Hash[CacheKey, V] } -> either[Error, Hash[CacheKey, Snapshot[V]]]
     #     def namespace: () -> Namespace
     #     def with_namespace: (Namespace) -> Store[V]
-    #     def store_type: () -> String
+    #     def at_namespace: (Namespace) -> Store[V]
+    #     def cache_for: [T] (Class[T], at: (Namespace | String | Array[String])) -> Store[T]
+    #     def backend: () -> Backend[V]
     #   end
     #   include _Store[V]
 
-    # @rbs!
-    #   interface _Decorator[V]
-    #     def initialize: (Store[V]) -> void
-    #   end
+    attr_reader :namespace #: Namespace
+    attr_reader :backend #: Backend[V]
+
+    # @rbs (Namespace, Backend[V]) -> void
+    def initialize(namespace, backend)
+      @namespace = namespace
+      @backend = backend
+    end
 
     # @rbs (Store[V]) -> void
     def initialize_copy(other)
@@ -45,18 +49,33 @@ module TypedCache
     end
 
     # Retrieves a value from the cache
-    # @rbs (cache_key, **top) -> either[Error, Snapshot[V]]
+    # @rbs (cache_key, **top) -> either[Error, Snapshot[maybe[V]]]
     def read(key, **kwargs)
-      Either.left(NotImplementedError.new("#{self.class} must implement #read"))
+      key = namespaced_key(key)
+
+      value = backend.read(key, **kwargs)
+
+      Either.right(
+        if value.nil?
+          Snapshot.cached(key, Maybe.none)
+        else
+          Snapshot.cached(key, Maybe.some(value))
+        end,
+      )
+    rescue => e
+      Either.left(StoreError.new(:read, key, "Failed to read from cache: #{e.message}", e))
     end
 
-    # @rbs (Array[cache_key], **top) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    # @rbs (Array[cache_key], **top) -> either[Error, Hash[CacheKey, Snapshot[V]]]
     def read_all(keys, **kwargs)
-      keys.map { |key| read(key, **kwargs) }.reduce(Either.right({})) do |acc, result|
-        acc.bind do |values|
-          result.map { |value| values.merge(value.key => value) }
-        end
-      end
+      keys = keys.map { |key| namespaced_key(key) }
+      cached_values = backend.read_multi(keys, **kwargs)
+
+      keys.filter_map do |key|
+        next unless cached_values.key?(key.to_s)
+
+        [key, Snapshot.cached(key, cached_values[key.to_s])]
+      end.to_h
     end
 
     # Retrieves a cache reference for a key
@@ -68,76 +87,105 @@ module TypedCache
     # Stores a value in the cache
     # @rbs (cache_key, V, **top) -> either[Error, Snapshot[V]]
     def write(key, value, **kwargs)
-      Either.left(NotImplementedError.new("#{self.class} must implement #write"))
+      key = namespaced_key(key)
+      backend.write(key, value, **kwargs)
+
+      Either.right(Snapshot.cached(key, value))
+    rescue => e
+      Either.left(StoreError.new(:write, key, "Failed to write to cache: #{e.message}", e))
     end
 
-    # @rbs (Hash[cache_key, V], **top) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    # @rbs (Hash[cache_key, V], **top) -> either[Error, Hash[CacheKey, Snapshot[V]]]
+
     def write_all(values, **kwargs)
-      values.map { |key, value| write(key, value, **kwargs) }.reduce(Either.right({})) do |acc, result|
-        acc.bind do |values|
-          result.map { |value| values.merge(value.key => value) }
-        end
-      end
+      values.transform_keys! { |key| namespaced_key(key) }
+
+      written_values = backend.write_multi(values, **kwargs)
+      written_values.transform_values { |value| Snapshot.cached(key, value) }
     end
 
     # Removes a value from the cache, returning the removed value
-    # @rbs (cache_key) -> either[Error, Snapshot[V]]
+    # @rbs (cache_key) -> either[Error, maybe[V]]
     def delete(key)
-      Either.left(NotImplementedError.new("#{self.class} must implement #delete"))
+      key = namespaced_key(key)
+      deleted_value = backend.delete(key)
+
+      Either.right(Maybe.wrap(deleted_value))
+    rescue => e
+      Either.left(StoreError.new(:delete, key, "Failed to delete from cache: #{e.message}", e))
     end
 
     # Checks if a key exists in the cache (query operation)
     # @rbs (cache_key) -> bool
     def key?(key)
-      false # Safe default - assume key doesn't exist
+      key = namespaced_key(key)
+      backend.key?(key)
     end
 
     # Clears all values from the cache namespace (command operation)
-    # @rbs () -> maybe[Error]
+    # @rbs () -> void
     def clear
-      Maybe.some(NotImplementedError.new("#{self.class} does not implement #clear"))
+      backend.clear
     end
 
     # Fetches a value from cache, computing and storing it if not found
     # This is an atomic operation that combines read and write
-    # @rbs (cache_key, **top) { () -> V } -> either[Error, Snapshot[V]]
+    # @rbs (cache_key, **top) { (CacheKey) -> V? } -> either[Error, Snapshot[maybe[V]]]
     def fetch(key, **kwargs, &block)
-      # Default implementation using read/write pattern
-      read_result = read(key)
-      return read_result if read_result.right?
-
-      # Only proceed if it's a cache miss
-      return read_result unless read_result.error.is_a?(CacheMissError)
-
-      # Compute and store new value
-      begin
-        computed_value = yield
-        write(key, computed_value, **kwargs)
-        Either.right(Snapshot.computed(key, computed_value))
-      rescue => e
-        Either.left(StoreError.new(:fetch, key, "Failed to compute value for key '#{key}': #{e.message}", e))
+      key = namespaced_key(key)
+      computed = false
+      result = backend.fetch(key, **kwargs) do
+        computed = true
+        yield(key)
+      end
+
+      if result.nil?
+        Either.right(Snapshot.cached(key, Maybe.none))
+      else
+        snapshot = computed ? Snapshot.computed(key, result) : Snapshot.cached(key, result)
+        Either.right(snapshot.map { Maybe.wrap(_1) })
       end
+    rescue => e
+      Either.left(StoreError.new(:fetch, key, "Failed to fetch from cache: #{e.message}", e))
     end
 
-    # @rbs (Array[cache_key], **top) { (CacheKey) -> V } -> either[Error, Array[Snapshot[V]]]
+    # @rbs (Array[cache_key], **top) { (CacheKey) -> V? } -> either[Error, Hash[CacheKey, Snapshot[V]]]
     def fetch_all(keys, **kwargs, &block)
       keys = keys.map { |key| namespaced_key(key) }
-      keys.reduce(Either.right([])) do |acc, key|
-        acc.bind do |values|
-          fetch(key. **kwargs) { yield(key) }.map { |value| values + [value] }
-        end
+      computed_keys = Set.new
+      fetched_values = backend.fetch_multi(keys, **kwargs) do |key|
+        computed_keys << key
+        yield(key)
       end
+
+      Either.right(keys.to_h do |key|
+        snapshot = computed_keys.include?(key) ? Snapshot.computed(key, fetched_values[key]) : Snapshot.cached(key, fetched_values[key])
+        [key, snapshot]
+      end)
+    rescue => e
+      Either.left(StoreError.new(:fetch_all, keys, "Failed to fetch from cache: #{e.message}", e))
     end
 
-    # @rbs () -> Instrumenter
-    def instrumenter = Instrumenters::Null.instance
+    # @rbs (Array[cache_key], **top) { (Array[CacheKey]) -> Hash[CacheKey, V] } -> either[Error, Hash[CacheKey, Snapshot[V]]]
+    def fetch_or_compute_all(keys, **kwargs, &block)
+      keys = keys.map { |key| namespaced_key(key) }
+      cached_values = backend.read_multi(keys, **kwargs)
+      missing_keys = keys - cached_values.keys
+
+      if missing_keys.any?
+        computed_values = yield(missing_keys)
+        backend.write_multi(computed_values, **kwargs)
+      end
 
-    # Returns the namespace for this store (for instrumentation/debugging)
-    # @rbs () -> Namespace
-    def namespace
-      raise NotImplementedError, "#{self.class} must implement #namespace"
+      cached_values.transform_values! { |value| Snapshot.cached(key, value) }
+      computed_values.transform_values! { |value| Snapshot.computed(key, value) }
+
+      cached_values.merge(computed_values)
     end
 
+    # @rbs () -> Instrumenter
+    def instrumenter = @instrumenter ||= Instrumenters::Null.new(namespace:)
+
     # Accepts a String segment or a fully-formed Namespace and returns a cloned
     # store scoped to that namespace.
     #: (Namespace | String | Array[String]) -> Store[V]
@@ -154,34 +202,38 @@ module TypedCache
       clone.tap { |store| store.namespace = new_namespace }
     end
 
-    # Returns the store type identifier for instrumentation/debugging
-    # @rbs () -> String
-    def store_type
-      snake_case(self.class.name.split('::').last)
+    # @rbs [T] (Class[T], at: (Namespace | String | Array[String])) -> Store[T]
+    def cache_for(klass, at: nil)
+      new_namespace =
+        case at
+        when Namespace then at
+        when Array then namespace.join(*at)
+        else
+          namespace.nested(at.to_s)
+        end
+
+      clone.tap { |store| store.namespace = new_namespace }
     end
 
+    alias at_namespace with_namespace
+
+    # @rbs () -> String
+    def to_s = "Store(#{namespace})"
+
+    # @rbs () -> String
+    def inspect = "Store(#{namespace}, #{backend.inspect})"
+
     protected
 
-    attr_writer :namespace #: Namespace
+    attr_writer :namespace
 
     private
 
-    #: (String) -> String
-    def snake_case(string)
-      string
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .tr('-', '_')
-        .downcase
-    end
-
     #: (cache_key) -> CacheKey
     def namespaced_key(key)
       key.is_a?(CacheKey) ? key : CacheKey.new(namespace, key)
     end
   end
 
-  # @rbs! type backend[V] = Store::_Store[V]
-  # @rbs! type decorator[V] = backend[V] & Store::_Decorator[V]
-  # @rbs! type store[V] = backend[V] | decorator[V]
+  # @rbs! type store[V] = Store::_Store[V]
 end

data/lib/typed_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypedCache
-  VERSION = '0.3.1'
+  VERSION = '0.4.0-1'
 end

data/lib/typed_cache.rb

@@ -34,6 +34,7 @@ module TypedCache
   #   interface _TypedCacheInstrumentationConfig
   #     def enabled: -> bool
   #     def namespace: -> String
+  #     def instrumenter: -> Symbol
   #   end
 
   # @rbs!
@@ -56,10 +57,12 @@ module TypedCache
   end
 
   class << self
+    # @rbs! type cache_definition = TypedCache::_CacheDefinition
+
     # Returns a CacheBuilder with the fluent interface
-    # @rbs [V] () -> CacheBuilder[V]
+    # @rbs () -> cache_definition
     def builder
-      CacheBuilder.new(config, Backends, Decorators)
+      CacheBuilder.new(CacheDefinition.new, Backends, Decorators)
     end
 
     # @rbs! def config: -> _TypedCacheConfig

data/rbi/typed_cache/backend.rbi

@@ -3,7 +3,49 @@
 module TypedCache
   module Backend
     extend T::Generic
-    include ::TypedCache::Store
-    CachedType = type_member
+
+    interface!
+
+    BackendType = type_member
+
+    KeyValue = T.type_alias { T.any(CacheKey, String) }
+
+    sig { abstract.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, Snapshot[Maybe[BackendType]]]) }
+    def read(key, **opts); end
+
+    sig { abstract.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, Snapshot[BackendType]]) }
+    def write(key, value, **opts); end
+
+    sig { abstract.params(key: KeyValue).returns(Either[Error, Snapshot[Maybe[BackendType]]]) }
+    def delete(key); end
+
+    sig { abstract.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    def read_multi(keys, **opts); end
+
+    sig { abstract.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    def write_multi(values, **opts); end
+
+    sig { abstract.void }
+    def clear; end
+
+    sig { abstract.params(key: KeyValue).returns(T::Boolean) }
+    def key?(key); end
+
+    sig { abstract.returns(T.nilable(Instrumenter)) }
+    def instrumenter; end
+
+    sig do
+      abstract
+        .type_parameters(:K)
+        .params(key: T.all(KeyValue, T.type_parameter(:K)), block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(Either[Error, Snapshot[Maybe[BackendType]]])
+    end
+    def fetch(key, &block); end
+
+    sig do
+      abstract
+        .type_parameters(:K)
+        .params(keys: T::Array[T.all(KeyValue, T.type_parameter(:K))], block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]])
+    end
+    def fetch_multi(keys, &block); end
   end
 end

data/rbi/typed_cache/backends/active_support.rbi

@@ -7,7 +7,7 @@ module TypedCache
 
       include ::TypedCache::Backend
 
-      CachedType = type_member
+      BackendType = type_member
     end
   end
 end

data/rbi/typed_cache/backends/memory.rbi

@@ -7,7 +7,7 @@ module TypedCache
 
       include ::TypedCache::Backend
 
-      CachedType = type_member
+      BackendType = type_member
     end
   end
 end

data/rbi/typed_cache/cache_builder.rbi

@@ -1,23 +1,42 @@
 # typed: strict
 
 module TypedCache
-  class CacheBuilder
-    Error = T.type_alias { TypedCache::Error }
-    Config = T.type_alias { ::TypedCache::Private::Configuration }
-    InstrumenterSource = T.type_alias { T.any(Symbol, ::TypedCache::Instrumenter) }
+  module CacheDefinition
+    extend T::Sig
+    extend T::Helpers
 
-    private_constant :Config, :Error, :InstrumenterSource
+    InstrumenterSource = T.type_alias { T.any(Symbol, ::TypedCache::Instrumenter) }
 
-    sig { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Either[Error, ::TypedCache::Store[T.anything]]) }
-    def build(namespace = T.unsafe(nil)); end
+    interface!
+    sealed!
 
-    sig { params(name: Symbol, args: T.untyped, options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+    sig { abstract.params(name: Symbol, args: T.untyped, options: T::Hash[Symbol, T.anything]).returns(T.all(CacheDefinition, CacheBuilder)) }
     def with_backend(name, *args, **options); end
 
-    sig { params(name: Symbol, options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+    sig { abstract.params(name: Symbol, options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
     def with_decorator(name, **options); end
 
-    sig { params(source: InstrumenterSource).returns(T.self_type) }
+    sig { abstract.params(source: InstrumenterSource).returns(T.self_type) }
     def with_instrumentation(source = T.unsafe(nil)); end
   end
+
+  module CacheBuilder
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+    sealed!
+
+    sig { abstract.params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Either[::TypedCache::Error, ::TypedCache::Store[T.untyped]]) }
+    def build(namespace = T.unsafe(nil)); end
+
+    sig { abstract.params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Store[T.untyped]) }
+    def build!(namespace = T.unsafe(nil)); end
+
+    sig { abstract.returns(::TypedCache::Either[::TypedCache::Error, ::TypedCache::Backend[T.untyped]]) }
+    def build_backend; end
+
+    sig { abstract.returns(::TypedCache::Backend[T.untyped]) }
+    def build_backend!; end
+  end
 end

data/rbi/typed_cache/cache_key.rbi

@@ -12,5 +12,19 @@ module TypedCache
 
     sig { returns(String) }
     def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { returns(Integer) }
+    def hash; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    private
+
+    sig { returns(String) }
+    def delimiter; end
   end
 end

data/rbi/typed_cache/cache_ref.rbi

@@ -29,28 +29,19 @@ module TypedCache
     sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
     def update(&block); end
 
-    sig { params(default: RefType).returns(RefType) }
-    def value_or(default); end
-
-    sig { returns(::TypedCache::Maybe[RefType]) }
-    def value_maybe; end
-
     sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
     def compute_if_absent(&block); end
 
-    sig { params(new_key: String).returns(::TypedCache::CacheRef[RefType]) }
-    def with_key(new_key); end
-
-    sig { params(scope_key: String).returns(::TypedCache::CacheRef[RefType]) }
-    def scope(scope_key); end
-
-    sig { type_parameters(:T).params(left_fn: T.proc.params(value: Error).returns(T.type_parameter(:T)), right_fn: T.proc.params(value: ::TypedCache::Snapshot[RefType]).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
-    def fold(left_fn, right_fn); end
-
     sig { type_parameters(:T).params(block: T.proc.params(value: ::TypedCache::Snapshot[RefType]).returns(T.type_parameter(:T))).returns(::TypedCache::Either[Error, T.type_parameter(:T)]) }
     def with_snapshot(&block); end
 
     sig { type_parameters(:T).params(block: T.proc.params(value: RefType).returns(T.type_parameter(:T))).returns(::TypedCache::Either[Error, T.type_parameter(:T)]) }
     def with(&block); end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
   end
 end

data/rbi/typed_cache/decorator.rbi

@@ -4,64 +4,50 @@ module TypedCache
   module Decorator
     extend T::Generic
 
-    include ::TypedCache::Store
+    include ::TypedCache::Backend
 
     abstract!
 
-    CachedType = type_member
+    BackendType = type_member
+    KeyValue = T.type_alias { TypedCache::Backend::KeyValue }
 
-    sig { params(store: ::TypedCache::Store[CachedType]).void }
-    def initialize(store); end
+    sig { params(backend: ::TypedCache::Backend[BackendType]).void }
+    def initialize(backend); end
 
-    sig { overridable.returns(::TypedCache::Store[CachedType]) }
-    def store; end
+    sig { abstract.returns(::TypedCache::Backend[BackendType]) }
+    def backend; end
 
-    sig(:final) { params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::CacheRef[CachedType]) }
-    def ref(key); end
+    sig { override.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
+    def read(key, **opts); end
 
-    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
-    def read(key); end
+    sig { override.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[BackendType]]) }
+    def write(key, value, **opts); end
 
-    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey), value: CachedType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
-    def write(key, value); end
-
-    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    sig { override.params(key: KeyValue).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
     def delete(key); end
 
-    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(T::Boolean) }
+    sig { override.params(key: KeyValue).returns(T::Boolean) }
     def key?(key); end
 
-    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey), block: T.proc.params(value: CachedType).returns(CachedType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
-    def fetch(key, &block); end
+    sig { override.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped], block: T.proc.returns(T.nilable(BackendType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
+    def fetch(key, **opts, &block); end
 
-    sig { overridable.params(keys: T::Array[T.any(String, ::TypedCache::CacheKey)]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
-    def read_all(keys); end
+    sig { override.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    def read_multi(keys, **opts); end
 
-    sig { overridable.params(keys: T::Array[T.any(String, ::TypedCache::CacheKey)], block: T.proc.params(key: T.any(String, ::TypedCache::CacheKey)).returns(CachedType)).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
-    def fetch_all(keys, &block); end
+    sig { override.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped], block: T.proc.params(key: KeyValue).returns(T.nilable(BackendType))).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    def fetch_multi(keys, **opts, &block); end
 
-    sig { overridable.params(values: T::Hash[T.any(String, ::TypedCache::CacheKey), CachedType]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
-    def write_all(values); end
+    sig { override.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    def write_multi(values, **opts); end
 
-    sig { overridable.void }
+    sig { override.void }
     def clear; end
 
-    sig(:final) { returns(::TypedCache::Namespace) }
-    def namespace; end
-
-    sig(:final) { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Store[CachedType]) }
-    def with_namespace(namespace); end
-
-    sig { abstract.returns(String) }
-    def store_type; end
-
     sig { overridable.params(other: T.self_type).void }
     def initialize_copy(other); end
 
-    sig(:final) { params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::CacheKey) }
-    def namespaced_key(key); end
-
-    sig { overridable.returns(::TypedCache::Instrumenter) }
+    sig { override.returns(T.nilable(::TypedCache::Instrumenter)) }
     def instrumenter; end
   end
 end

data/rbi/typed_cache/decorators/instrumented.rbi

@@ -7,7 +7,7 @@ module TypedCache
 
       include ::TypedCache::Decorator
 
-      CachedType = type_member
+      BackendType = type_member
     end
   end
 end

data/rbi/typed_cache/either.rbi

@@ -78,6 +78,18 @@ module TypedCache
 
     sig { returns(T.noreturn) }
     def right_or_raise!; end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { returns(Integer) }
+    def hash; end
   end
 
   class Right
@@ -118,5 +130,17 @@ module TypedCache
 
     sig { returns(R) }
     def right_or_raise!; end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { returns(Integer) }
+    def hash; end
   end
 end