typed_cache 0.2.0 → 0.3.0

data/lib/typed_cache/namespace.rb

@@ -20,16 +20,17 @@ module TypedCache
       # Returns a new Namespace instance rooted at the given namespace string.
       #
       # @param namespace [String] the root namespace
+      # @param namespaces [Array<String>] additional namespaces to join
       # @return [Namespace] a new Namespace instance at the given root
       #
       # Example:
-      #   TypedCache::Namespace.at("users") # => #<TypedCache::Namespace namespace=users>
+      #   TypedCache::Namespace.at("users", "sessions") # => #<TypedCache::Namespace namespace=users:sessions>
       #
       # The returned Namespace can be further nested or used to generate cache keys.
       #
-      # @rbs (String) -> Namespace
-      def at(namespace)
-        root.nested(namespace)
+      # @rbs (String, *String) -> Namespace
+      def at(namespace, *namespaces)
+        root.join(namespace, *namespaces)
       end
 
       # Returns the root Namespace instance (with an empty namespace).
@@ -79,7 +80,26 @@ module TypedCache
     def nested(namespace, &key_factory)
       key_factory ||= @key_factory
 
-      self.class.new("#{@namespace}:#{namespace}", &key_factory)
+      self.class.new([@namespace, namespace].join(delimiter), &key_factory)
+    end
+
+    # Creates a new namespace by joining the current namespace with the given namespaces.
+    #
+    # @param namespaces [Array<String>] the namespaces to join
+    # @param key_factory [Proc, nil] optional custom key factory for the joined namespace
+    # @return [Namespace] a new Namespace instance with the combined namespace
+    #
+    # Example:
+    #   ns = Namespace.at("users")
+    #   ns.join("sessions", "admin") # => #<TypedCache::Namespace namespace=users:sessions:admin>
+    #
+    # If no key_factory is provided, the parent's key factory is inherited.
+    #
+    # @rbs (*String) ?{ (Namespace, String) -> CacheKey } -> Namespace
+    def join(*namespaces, &key_factory)
+      key_factory ||= @key_factory
+
+      self.class.new([@namespace, *namespaces].join(delimiter), &key_factory)
     end
 
     # Returns the parent namespace by removing the last namespace segment.
@@ -96,7 +116,7 @@ module TypedCache
     def parent_namespace
       return self if @namespace.empty?
 
-      case pathsep_idx = @namespace.rindex(':')
+      case pathsep_idx = @namespace.rindex(delimiter)
       when nil
         self.class.root
       else
@@ -158,5 +178,12 @@ module TypedCache
     end
 
     alias eql? ==
+
+    private
+
+    # @rbs (String) -> String
+    def delimiter
+      TypedCache.config.cache_delimiter
+    end
   end
 end

data/lib/typed_cache/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TypedCache
+  class Railtie < ::Rails::Railtie
+    config.to_prepare do
+      # Set the default instrumenter to Rails
+      ::TypedCache.configure do |config|
+        config.instrumentation.instrumenter = :rails
+      end
+
+      # Register the ActiveSupport backend
+      ::TypedCache.backends.register(:active_support, ::TypedCache::Instrumenters::ActiveSupport)
+    end
+  end
+end

data/lib/typed_cache/snapshot.rb

@@ -4,12 +4,14 @@ module TypedCache
   # Immutable snapshot of a cached value with metadata about its source and age
   # @rbs generic V
   class Snapshot
+    attr_reader :key #: CacheKey
     attr_reader :value #: V
     attr_reader :retrieved_at #: Time
     attr_reader :source #: Symbol
 
-    #: (V, source: Symbol, retrieved_at: Time) -> void
-    def initialize(value, source:, retrieved_at: Time.now)
+    #: (CacheKey, V, source: Symbol, retrieved_at: Time) -> void
+    def initialize(key, value, source:, retrieved_at: Time.now)
+      @key = key
       @value = value
       @retrieved_at = retrieved_at
       @source = source
@@ -43,29 +45,35 @@ module TypedCache
     #: [R] () { (V) -> R } -> Snapshot[R]
     def map(&block)
       new_value = yield(value)
-      Snapshot.new(new_value, source: source, retrieved_at: retrieved_at)
+      Snapshot.new(key, new_value, source: source, retrieved_at: retrieved_at)
     end
 
     # Bind over the value with Either error handling
     #: [R] () { (V) -> either[Error, R] } -> either[Error, Snapshot[R]]
     def bind(&block)
       result = yield(value)
-      result.map { |new_value| Snapshot.new(new_value, source: source, retrieved_at: retrieved_at) }
+      result.map { |new_value| Snapshot.new(key, new_value, source: source, retrieved_at: retrieved_at) }
     end
 
     alias flat_map bind
 
     class << self
+      # Creates a snapshot for a cached value
+      #: [V] (CacheKey, V) -> Snapshot[V]
+      def cached(key, value)
+        new(key, value, source: :cache)
+      end
+
       # Creates a snapshot for a computed value
-      #: [V] (V) -> Snapshot[V]
-      def computed(value)
-        new(value, source: :computed)
+      #: [V] (CacheKey, V) -> Snapshot[V]
+      def computed(key, value)
+        new(key, value, source: :computed)
       end
 
       # Creates a snapshot for an updated value
-      #: [V] (V) -> Snapshot[V]
-      def updated(value)
-        new(value, source: :updated)
+      #: [V] (CacheKey, V) -> Snapshot[V]
+      def updated(key, value)
+        new(key, value, source: :updated)
       end
     end
   end

data/lib/typed_cache/store.rb

@@ -17,13 +17,16 @@ module TypedCache
 
     # @rbs!
     #   interface _Store[V]
-    #     def get: (cache_key) -> either[Error, Snapshot[V]]
+    #     def read: (cache_key) -> either[Error, Snapshot[V]]
+    #     def read_all: (Array[cache_key]) -> either[Error, Array[Snapshot[V]]]
     #     def ref: (cache_key) -> CacheRef[V]
-    #     def set: (cache_key, V) -> either[Error, Snapshot[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 key?: (cache_key) -> bool
     #     def clear: () -> maybe[Error]
-    #     def fetch: (cache_key) { () -> V } -> either[Error, Snapshot[V]]
+    #     def fetch: (cache_key) { () -> V? } -> either[Error, Snapshot[maybe[V]]]
+    #     def fetch_all: (Array[cache_key]) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
     #     def namespace: () -> Namespace
     #     def with_namespace: (Namespace) -> Store[V]
     #     def store_type: () -> String
@@ -43,8 +46,17 @@ module TypedCache
 
     # Retrieves a value from the cache
     # @rbs (cache_key) -> either[Error, Snapshot[V]]
-    def get(key)
-      Either.left(NotImplementedError.new("#{self.class} must implement #get"))
+    def read(key)
+      Either.left(NotImplementedError.new("#{self.class} must implement #read"))
+    end
+
+    # @rbs (Array[cache_key]) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    def read_all(keys)
+      keys.map { |key| read(key) }.reduce(Either.right({})) do |acc, result|
+        acc.bind do |values|
+          result.map { |value| values.merge(value.key => value) }
+        end
+      end
     end
 
     # Retrieves a cache reference for a key
@@ -55,8 +67,17 @@ module TypedCache
 
     # Stores a value in the cache
     # @rbs (cache_key, V) -> either[Error, Snapshot[V]]
-    def set(key, value)
-      Either.left(NotImplementedError.new("#{self.class} must implement #set"))
+    def write(key, value)
+      Either.left(NotImplementedError.new("#{self.class} must implement #write"))
+    end
+
+    # @rbs (Hash[cache_key, V]) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    def write_all(values)
+      values.map { |key, value| write(key, value) }.reduce(Either.right({})) do |acc, result|
+        acc.bind do |values|
+          result.map { |value| values.merge(value.key => value) }
+        end
+      end
     end
 
     # Removes a value from the cache, returning the removed value
@@ -78,26 +99,36 @@ module TypedCache
     end
 
     # Fetches a value from cache, computing and storing it if not found
-    # This is an atomic operation that combines get and set
+    # This is an atomic operation that combines read and write
     # @rbs (cache_key) { () -> V } -> either[Error, Snapshot[V]]
     def fetch(key, &block)
-      # Default implementation using get/set pattern
-      get_result = get(key)
-      return get_result if get_result.right?
+      # 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 get_result unless get_result.error.is_a?(CacheMissError)
+      return read_result unless read_result.error.is_a?(CacheMissError)
 
       # Compute and store new value
       begin
         computed_value = yield
-        set(key, computed_value)
-        Either.right(Snapshot.computed(computed_value))
+        write(key, computed_value)
+        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))
       end
     end
 
+    # @rbs (Array[cache_key]) { (CacheKey) -> V } -> either[Error, Array[Snapshot[V]]]
+    def fetch_all(keys, &block)
+      keys = keys.map { |key| namespaced_key(key) }
+      keys.reduce(Either.right([])) do |acc, key|
+        acc.bind do |values|
+          fetch(key) { yield(key) }.map { |value| values + [value] }
+        end
+      end
+    end
+
     # @rbs () -> Instrumenter
     def instrumenter = Instrumenters::Null.instance
 
@@ -109,11 +140,12 @@ module TypedCache
 
     # Accepts a String segment or a fully-formed Namespace and returns a cloned
     # store scoped to that namespace.
-    # @rbs (Namespace | String) -> Store[V]
+    #: (Namespace | String | Array[String]) -> Store[V]
     def with_namespace(ns)
       new_namespace =
         case ns
         when Namespace then ns
+        when Array then namespace.join(*ns)
         else
           # treat as nested segment under the current namespace
           namespace.nested(ns.to_s)

data/lib/typed_cache/version.rb

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

data/lib/typed_cache.rb

@@ -39,6 +39,7 @@ module TypedCache
   # @rbs!
   #   interface _TypedCacheConfig
   #     def default_namespace: -> String
+  #     def cache_delimiter: -> String
   #     def instrumentation: -> _TypedCacheInstrumentationConfig
   #   end
 
@@ -46,6 +47,7 @@ module TypedCache
 
   # Configuration
   setting :default_namespace, default: 'typed_cache'
+  setting :cache_delimiter, default: ':'
 
   setting :instrumentation do
     setting :enabled, default: false
@@ -72,3 +74,5 @@ module TypedCache
     def instrumenters = Instrumenters
   end
 end
+
+require 'typed_cache/railtie' if defined?(Rails::Railtie)

data/rbi/typed_cache/backend.rbi

@@ -0,0 +1,9 @@
+# typed: strict
+
+module TypedCache
+  module Backend
+    extend T::Generic
+    include ::TypedCache::Store
+    CachedType = type_member
+  end
+end

data/rbi/typed_cache/backends/active_support.rbi

@@ -0,0 +1,13 @@
+# typed: strict
+
+module TypedCache
+  module Backends
+    module ActiveSupport
+      extend T::Generic
+
+      include ::TypedCache::Backend
+
+      CachedType = type_member
+    end
+  end
+end

data/rbi/typed_cache/backends/memory.rbi

@@ -0,0 +1,13 @@
+# typed: strict
+
+module TypedCache
+  module Backends
+    module Memory
+      extend T::Generic
+
+      include ::TypedCache::Backend
+
+      CachedType = type_member
+    end
+  end
+end

data/rbi/typed_cache/backends.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+
+module TypedCache
+  module Backends
+    class << self
+      sig { params(name: Symbol, klass: T::Class[::TypedCache::Backend[T.anything]]).returns(T.self_type) }
+      def register(name, klass); end
+
+      sig { params(name: Symbol, args: T::Array[T.anything], options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+      def resolve(name, *args, **options); end
+
+      sig { returns(T::Array[T::Class[::TypedCache::Backend[T.anything]]]) }
+      def available; end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def registered?(name); end
+    end
+  end
+end

data/rbi/typed_cache/cache_builder.rbi

@@ -0,0 +1,23 @@
+# 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) }
+
+    private_constant :Config, :Error, :InstrumenterSource
+
+    sig { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Either[Error, ::TypedCache::Store[T.anything]]) }
+    def build(namespace = T.unsafe(nil)); end
+
+    sig { params(name: Symbol, args: T.untyped, options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+    def with_backend(name, *args, **options); end
+
+    sig { 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) }
+    def with_instrumentation(source = T.unsafe(nil)); end
+  end
+end

data/rbi/typed_cache/cache_key.rbi

@@ -0,0 +1,16 @@
+# typed: strict
+
+module TypedCache
+  class CacheKey
+    sealed!
+
+    sig { returns(::TypedCache::Namespace) }
+    attr_reader :namespace
+
+    sig { returns(String) }
+    attr_reader :key
+
+    sig { returns(String) }
+    def to_s; end
+  end
+end

data/rbi/typed_cache/cache_ref.rbi

@@ -0,0 +1,56 @@
+# typed: strict
+
+module TypedCache
+  class CacheRef
+    extend T::Generic
+
+    sealed!
+
+    RefType = type_member
+
+    sig { returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def read; end
+
+    sig { params(value: RefType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def write(value); end
+
+    sig { returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def delete; end
+
+    sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def fetch(&block); end
+
+    sig { returns(T::Boolean) }
+    def present?; end
+
+    sig { returns(T::Boolean) }
+    def empty?; end
+
+    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
+  end
+end

data/rbi/typed_cache/decorator.rbi

@@ -0,0 +1,67 @@
+# typed: strict
+
+module TypedCache
+  module Decorator
+    extend T::Generic
+
+    include ::TypedCache::Store
+
+    abstract!
+
+    CachedType = type_member
+
+    sig { params(store: ::TypedCache::Store[CachedType]).void }
+    def initialize(store); end
+
+    sig { overridable.returns(::TypedCache::Store[CachedType]) }
+    def store; end
+
+    sig(:final) { params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::CacheRef[CachedType]) }
+    def ref(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def read(key); 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]]) }
+    def delete(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).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 { 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 { 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 { 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 { overridable.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) }
+    def instrumenter; end
+  end
+end

data/rbi/typed_cache/decorators/instrumented.rbi

@@ -0,0 +1,13 @@
+# typed: strict
+
+module TypedCache
+  module Decorators
+    module Instrumented
+      extend T::Generic
+
+      include ::TypedCache::Decorator
+
+      CachedType = type_member
+    end
+  end
+end

data/rbi/typed_cache/decorators.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+
+module TypedCache
+  module Decorators
+    class << self
+      sig { params(name: Symbol, klass: T::Class[::TypedCache::Decorator[T.anything]]).returns(T.self_type) }
+      def register(name, klass); end
+
+      sig { params(name: Symbol, args: T::Array[T.anything], options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+      def resolve(name, *args, **options); end
+
+      sig { returns(T::Array[T::Class[::TypedCache::Decorator[T.anything]]]) }
+      def available; end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def registered?(name); end
+    end
+  end
+end

data/rbi/typed_cache/either.rbi

@@ -0,0 +1,122 @@
+# typed: strict
+
+module TypedCache
+  module Either
+    extend T::Generic
+    include Kernel
+
+    mixes_in_class_methods(T::Generic)
+
+    sealed!
+    interface!
+
+    L = type_member(:out)
+    R = type_member(:out)
+
+    interface!
+
+    sig { abstract.returns(T::Boolean) }
+    def left?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def right?; end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(::TypedCache::Either[L, T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(::TypedCache::Either[T.type_parameter(:T), R]) }
+    def map_left(&block); end
+
+    sig { abstract.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)]) }
+    def bind(&block); end
+
+    sig { abstract.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { abstract.params(block: T.proc.params(value: L).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { abstract.returns(R) }
+    def right_or_raise!; end
+  end
+
+  class Left
+    sealed!
+
+    include ::TypedCache::Either
+    extend T::Generic
+
+    L = type_member(:out)
+    R = type_member(:out) { { fixed: T.noreturn } }
+
+    sig { override.returns(TrueClass) }
+    def left?; end
+
+    sig { override.returns(FalseClass) }
+    def right?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(Left[T.type_parameter(:T)]) }
+    def map_left(&block); end
+
+    sig { override.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(T.self_type) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { returns(L) }
+    def value; end
+
+    sig { returns(L) }
+    def error; end
+
+    sig { params(block: T.proc.params(value: L).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { returns(T.noreturn) }
+    def right_or_raise!; end
+  end
+
+  class Right
+    sealed!
+
+    include ::TypedCache::Either
+    extend T::Generic
+
+    L = type_member(:out) { { fixed: T.noreturn } }
+    R = type_member(:out)
+
+    sig { override.returns(FalseClass) }
+    def left?; end
+
+    sig { override.returns(TrueClass) }
+    def right?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(Right[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map_left(&block); end
+
+    sig { override.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)]) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { returns(R) }
+    def value; end
+
+    sig { returns(R) }
+    def result; end
+
+    sig { params(block: T.proc.params(value: T.anything).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { returns(R) }
+    def right_or_raise!; end
+  end
+end