From 22a171566400560a0c2fdddbe3b1c3f698e3d53a Mon Sep 17 00:00:00 2001
From: Khraks Mamtsov <khraks.mamtsov@gmail.com>
Date: Sat, 2 Mar 2024 17:44:07 +0100
Subject: [PATCH] `Cache`, `ScopedCache` swap type parameters [another try]
 (#2239)

Co-authored-by: maksim.khramtsov <maksim.khramtsov@btsdigital.kz>
---
 .changeset/tough-jeans-allow.md               |  7 ++
 packages/effect/src/Cache.ts                  | 22 +++--
 packages/effect/src/Request.ts                |  2 +-
 packages/effect/src/ScopedCache.ts            | 20 ++--
 packages/effect/src/internal/cache.ts         | 74 +++++++--------
 packages/effect/src/internal/query.ts         |  4 +-
 packages/effect/src/internal/scopedCache.ts   | 92 +++++++++----------
 packages/effect/test/Cache.test.ts            |  2 +-
 packages/effect/test/ScopedCache.test.ts      |  4 +-
 .../test/utils/cache/WatchableLookup.ts       | 36 ++++----
 10 files changed, 137 insertions(+), 126 deletions(-)
 create mode 100644 .changeset/tough-jeans-allow.md

diff --git a/.changeset/tough-jeans-allow.md b/.changeset/tough-jeans-allow.md
new file mode 100644
index 0000000000..e047ac747f
--- /dev/null
+++ b/.changeset/tough-jeans-allow.md
@@ -0,0 +1,7 @@
+---
+"effect": minor
+---
+
+`Cache<Key, Error, Value>` has been changed to `Cache<Key, Value, Error = never>`.
+`ScopedCache<Key, Error, Value>` has been changed to `ScopedCache<Key, Value, Error = never>`.
+`Lookup<Key, Environment, Error, Value>` has been changed to `Lookup<Key, Value, Error = never, Environment = never>`
diff --git a/packages/effect/src/Cache.ts b/packages/effect/src/Cache.ts
index ff716b0594..6e267ea3e4 100644
--- a/packages/effect/src/Cache.ts
+++ b/packages/effect/src/Cache.ts
@@ -43,7 +43,7 @@ export type CacheTypeId = typeof CacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Cache<in out Key, out Error, out Value> extends ConsumerCache<Key, Error, Value> {
+export interface Cache<in out Key, out Value, out Error = never> extends ConsumerCache<Key, Value, Error> {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise computes the value with the lookup function, puts it in the
@@ -83,7 +83,7 @@ export interface Cache<in out Key, out Error, out Value> extends ConsumerCache<K
  * @since 2.0.0
  * @category models
  */
-export interface ConsumerCache<in out Key, out Error, out Value> extends Cache.Variance<Key, Error, Value> {
+export interface ConsumerCache<in out Key, out Value, out Error = never> extends Cache.Variance<Key, Value, Error> {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
@@ -156,7 +156,7 @@ export declare namespace Cache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in out Key, out Error, out Value> {
+  export interface Variance<in out Key, out Value, out Error> {
     readonly [CacheTypeId]: {
       readonly _Key: Types.Invariant<Key>
       readonly _Error: Types.Covariant<Error>
@@ -172,13 +172,13 @@ export declare namespace Cache {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <Key, Environment, Error, Value>(
+export const make: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
   }
-) => Effect.Effect<Cache<Key, Error, Value>, never, Environment> = internal.make
+) => Effect.Effect<Cache<Key, Value, Error>, never, Environment> = internal.make
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -188,13 +188,13 @@ export const make: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <Key, Environment, Error, Value>(
+export const makeWith: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-) => Effect.Effect<Cache<Key, Error, Value>, never, Environment> = internal.makeWith
+) => Effect.Effect<Cache<Key, Value, Error>, never, Environment> = internal.makeWith
 
 /**
  * `CacheStats` represents a snapshot of statistics for the cache as of a
@@ -249,4 +249,6 @@ export const makeEntryStats: (loadedMillis: number) => EntryStats = internal.mak
  * @since 2.0.0
  * @category models
  */
-export type Lookup<Key, Environment, Error, Value> = (key: Key) => Effect.Effect<Value, Error, Environment>
+export type Lookup<Key, Value, Error = never, Environment = never> = (
+  key: Key
+) => Effect.Effect<Value, Error, Environment>
diff --git a/packages/effect/src/Request.ts b/packages/effect/src/Request.ts
index 29cf74bf73..ce219bbfb2 100644
--- a/packages/effect/src/Request.ts
+++ b/packages/effect/src/Request.ts
@@ -257,7 +257,7 @@ export interface Listeners {
  * @since 2.0.0
  */
 export interface Cache extends
-  _Cache.ConsumerCache<Request<any, any>, never, {
+  _Cache.ConsumerCache<Request<any, any>, {
     listeners: Listeners
     handle: Deferred<unknown, unknown>
   }>
diff --git a/packages/effect/src/ScopedCache.ts b/packages/effect/src/ScopedCache.ts
index e0b65efb18..19cf996b20 100644
--- a/packages/effect/src/ScopedCache.ts
+++ b/packages/effect/src/ScopedCache.ts
@@ -27,7 +27,9 @@ export type ScopedCacheTypeId = typeof ScopedCacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
+export interface ScopedCache<in Key, out Value, out Error = never>
+  extends ScopedCache.Variance<Key, Value, Error>, Pipeable
+{
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
@@ -98,7 +100,7 @@ export declare namespace ScopedCache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in Key, out Error, out Value> {
+  export interface Variance<in Key, out Value, out Error> {
     readonly [ScopedCacheTypeId]: {
       _Key: Types.Contravariant<Key>
       _Error: Types.Covariant<Error>
@@ -114,13 +116,13 @@ export declare namespace ScopedCache {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <Key, Environment, Error, Value>(
+export const make: <Key, Value, Error = never, Environment = never>(
   options: {
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.make
+) => Effect.Effect<ScopedCache<Key, Value, Error>, never, Scope.Scope | Environment> = internal.make
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -130,13 +132,13 @@ export const make: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <Key, Environment, Error, Value>(
+export const makeWith: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.makeWith
+) => Effect.Effect<ScopedCache<Key, Value, Error>, never, Scope.Scope | Environment> = internal.makeWith
 
 /**
  * Similar to `Cache.Lookup`, but executes the lookup function within a `Scope`.
@@ -144,6 +146,6 @@ export const makeWith: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category models
  */
-export type Lookup<Key, Environment, Error, Value> = (
+export type Lookup<Key, Value, Error = never, Environment = never> = (
   key: Key
 ) => Effect.Effect<Value, Error, Environment | Scope.Scope>
diff --git a/packages/effect/src/internal/cache.ts b/packages/effect/src/internal/cache.ts
index a19fee4dc1..a54c7feabf 100644
--- a/packages/effect/src/internal/cache.ts
+++ b/packages/effect/src/internal/cache.ts
@@ -29,13 +29,13 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export type MapValue<Key, Error, Value> =
-  | Complete<Key, Error, Value>
-  | Pending<Key, Error, Value>
-  | Refreshing<Key, Error, Value>
+export type MapValue<Key, Value, Error> =
+  | Complete<Key, Value, Error>
+  | Pending<Key, Value, Error>
+  | Refreshing<Key, Value, Error>
 
 /** @internal */
-export interface Complete<out Key, out Error, out Value> {
+export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
   readonly key: MapKey<Key>
   readonly exit: Exit.Exit<Value, Error>
@@ -44,26 +44,26 @@ export interface Complete<out Key, out Error, out Value> {
 }
 
 /** @internal */
-export interface Pending<out Key, in out Error, in out Value> {
+export interface Pending<out Key, in out Value, in out Error> {
   readonly _tag: "Pending"
   readonly key: MapKey<Key>
   readonly deferred: Deferred.Deferred<Value, Error>
 }
 
 /** @internal */
-export interface Refreshing<out Key, in out Error, in out Value> {
+export interface Refreshing<out Key, in out Value, in out Error> {
   readonly _tag: "Refreshing"
   readonly deferred: Deferred.Deferred<Value, Error>
-  readonly complete: Complete<Key, Error, Value>
+  readonly complete: Complete<Key, Value, Error>
 }
 
 /** @internal */
-export const complete = <Key, Error, Value>(
+export const complete = <Key, Value, Error>(
   key: MapKey<Key>,
   exit: Exit.Exit<Value, Error>,
   entryStats: Cache.EntryStats,
   timeToLiveMillis: number
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Complete" as const,
     key,
@@ -73,10 +73,10 @@ export const complete = <Key, Error, Value>(
   })
 
 /** @internal */
-export const pending = <Key, Error, Value>(
+export const pending = <Key, Value, Error>(
   key: MapKey<Key>,
   deferred: Deferred.Deferred<Value, Error>
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Pending" as const,
     key,
@@ -84,10 +84,10 @@ export const pending = <Key, Error, Value>(
   })
 
 /** @internal */
-export const refreshing = <Key, Error, Value>(
+export const refreshing = <Key, Value, Error>(
   deferred: Deferred.Deferred<Value, Error>,
-  complete: Complete<Key, Error, Value>
-): MapValue<Key, Error, Value> =>
+  complete: Complete<Key, Value, Error>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Refreshing" as const,
     deferred,
@@ -216,8 +216,8 @@ export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>()
  *
  * @internal
  */
-export interface CacheState<in out Key, in out Error, in out Value> {
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
+export interface CacheState<in out Key, in out Value, in out Error> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
   keys: KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
@@ -230,14 +230,14 @@ export interface CacheState<in out Key, in out Error, in out Value> {
  *
  * @internal
  */
-export const makeCacheState = <Key, Error, Value>(
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>>,
+export const makeCacheState = <Key, Value, Error>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
   keys: KeySet<Key>,
   accesses: MutableQueue.MutableQueue<MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
-): CacheState<Key, Error, Value> => ({
+): CacheState<Key, Value, Error> => ({
   map,
   keys,
   accesses,
@@ -251,7 +251,7 @@ export const makeCacheState = <Key, Error, Value>(
  *
  * @internal
  */
-export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, Value> =>
+export const initialCacheState = <Key, Value, Error>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
     makeKeySet(),
@@ -292,14 +292,14 @@ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
   loadedMillis
 })
 
-class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<Key, Error, Value> {
+class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
   readonly [CacheTypeId] = cacheVariance
-  readonly cacheState: CacheState<Key, Error, Value>
+  readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,
     readonly context: Context.Context<any>,
     readonly fiberId: FiberId.FiberId,
-    readonly lookup: Cache.Lookup<Key, any, Error, Value>,
+    readonly lookup: Cache.Lookup<Key, Value, Error, any>,
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   ) {
     this.cacheState = initialCacheState()
@@ -460,7 +460,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 effect.when(() => {
                   const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                   if (Equal.equals(current, value)) {
-                    const mapValue = refreshing(deferred, value as Complete<Key, Error, Value>)
+                    const mapValue = refreshing(deferred, value as Complete<Key, Value, Error>)
                     MutableHashMap.set(this.cacheState.map, k, mapValue)
                     return true
                   }
@@ -496,7 +496,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
         MutableHashMap.set(
           this.cacheState.map,
           k,
-          mapValue as Complete<Key, Error, Value>
+          mapValue as Complete<Key, Value, Error>
         )
       })
     )
@@ -545,7 +545,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
   }
 
   resolveMapValue(
-    value: MapValue<Key, Error, Value>,
+    value: MapValue<Key, Value, Error>,
     ignorePending = false
   ): Effect.Effect<Option.Option<Value>, Error> {
     return effect.clockWith((clock) => {
@@ -665,13 +665,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
 }
 
 /** @internal */
-export const make = <Key, Environment, Error, Value>(
+export const make = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> => {
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -681,13 +681,13 @@ export const make = <Key, Environment, Error, Value>(
 }
 
 /** @internal */
-export const makeWith = <Key, Environment, Error, Value>(
+export const makeWith = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> =>
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> =>
   core.map(
     fiberRuntime.all([core.context<Environment>(), core.fiberId]),
     ([context, fiberId]) =>
@@ -701,12 +701,12 @@ export const makeWith = <Key, Environment, Error, Value>(
   )
 
 /** @internal */
-export const unsafeMakeWith = <Key, Error, Value>(
+export const unsafeMakeWith = <Key, Value, Error = never>(
   capacity: number,
-  lookup: Cache.Lookup<Key, never, Error, Value>,
+  lookup: Cache.Lookup<Key, Value, Error>,
   timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
-): Cache.Cache<Key, Error, Value> =>
-  new CacheImpl<Key, Error, Value>(
+): Cache.Cache<Key, Value, Error> =>
+  new CacheImpl<Key, Value, Error>(
     capacity,
     Context.empty() as Context.Context<any>,
     none,
diff --git a/packages/effect/src/internal/query.ts b/packages/effect/src/internal/query.ts
index 71fcbe8ad2..72506e8015 100644
--- a/packages/effect/src/internal/query.ts
+++ b/packages/effect/src/internal/query.ts
@@ -12,7 +12,7 @@ import * as core from "./core.js"
 import { ensuring } from "./fiberRuntime.js"
 import { Listeners } from "./request.js"
 
-type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
+type RequestCache = Cache.Cache<Request.Request<any, any>, {
   listeners: Request.Listeners
   handle: Deferred<any, any>
 }>
@@ -21,7 +21,7 @@ type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
 export const currentCache = globalValue(
   Symbol.for("effect/FiberRef/currentCache"),
   () =>
-    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, never, {
+    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, {
       listeners: Request.Listeners
       handle: Deferred<any, any>
     }>(
diff --git a/packages/effect/src/internal/scopedCache.ts b/packages/effect/src/internal/scopedCache.ts
index f09ba80c5e..5b2fde02c0 100644
--- a/packages/effect/src/internal/scopedCache.ts
+++ b/packages/effect/src/internal/scopedCache.ts
@@ -25,8 +25,8 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export interface CacheState<in out Key, out Error, out Value> {
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
+export interface CacheState<in out Key, out Value, out Error = never> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
   keys: _cache.KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
@@ -35,14 +35,14 @@ export interface CacheState<in out Key, out Error, out Value> {
 }
 
 /** @internal */
-export const makeCacheState = <Key, Error, Value>(
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>>,
+export const makeCacheState = <Key, Value, Error = never>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
   keys: _cache.KeySet<Key>,
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
-): CacheState<Key, Error, Value> => ({
+): CacheState<Key, Value, Error> => ({
   map,
   keys,
   accesses,
@@ -56,7 +56,7 @@ export const makeCacheState = <Key, Error, Value>(
  *
  * @internal
  */
-export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, Value> =>
+export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
     _cache.makeKeySet(),
@@ -74,13 +74,13 @@ export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, V
  *
  * @internal
  */
-export type MapValue<Key, Error, Value> =
-  | Complete<Key, Error, Value>
-  | Pending<Key, Error, Value>
-  | Refreshing<Key, Error, Value>
+export type MapValue<Key, Value, Error> =
+  | Complete<Key, Value, Error>
+  | Pending<Key, Value, Error>
+  | Refreshing<Key, Value, Error>
 
 /** @internal */
-export interface Complete<out Key, out Error, out Value> {
+export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
   readonly key: _cache.MapKey<Key>
   readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
@@ -90,27 +90,27 @@ export interface Complete<out Key, out Error, out Value> {
 }
 
 /** @internal */
-export interface Pending<out Key, out Error, out Value> {
+export interface Pending<out Key, out Value, out Error> {
   readonly _tag: "Pending"
   readonly key: _cache.MapKey<Key>
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 }
 
 /** @internal */
-export interface Refreshing<out Key, out Error, out Value> {
+export interface Refreshing<out Key, out Value, out Error> {
   readonly _tag: "Refreshing"
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
-  readonly complete: Complete<Key, Error, Value>
+  readonly complete: Complete<Key, Value, Error>
 }
 
 /** @internal */
-export const complete = <Key, Error, Value>(
+export const complete = <Key, Value, Error = never>(
   key: _cache.MapKey<Key>,
   exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
   ownerCount: MutableRef.MutableRef<number>,
   entryStats: Cache.EntryStats,
   timeToLive: number
-): Complete<Key, Error, Value> =>
+): Complete<Key, Value, Error> =>
   Data.struct({
     _tag: "Complete",
     key,
@@ -121,10 +121,10 @@ export const complete = <Key, Error, Value>(
   })
 
 /** @internal */
-export const pending = <Key, Error, Value>(
+export const pending = <Key, Value, Error = never>(
   key: _cache.MapKey<Key>,
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
-): Pending<Key, Error, Value> =>
+): Pending<Key, Value, Error> =>
   Data.struct({
     _tag: "Pending",
     key,
@@ -132,10 +132,10 @@ export const pending = <Key, Error, Value>(
   })
 
 /** @internal */
-export const refreshing = <Key, Error, Value>(
+export const refreshing = <Key, Value, Error = never>(
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>,
-  complete: Complete<Key, Error, Value>
-): Refreshing<Key, Error, Value> =>
+  complete: Complete<Key, Value, Error>
+): Refreshing<Key, Value, Error> =>
   Data.struct({
     _tag: "Refreshing",
     scoped,
@@ -143,8 +143,8 @@ export const refreshing = <Key, Error, Value>(
   })
 
 /** @internal */
-export const toScoped = <Key, Error, Value>(
-  self: Complete<Key, Error, Value>
+export const toScoped = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
 ): Effect.Effect<Value, Error, Scope.Scope> =>
   Exit.matchEffect(self.exit, {
     onFailure: (cause) => core.failCause(cause),
@@ -156,8 +156,8 @@ export const toScoped = <Key, Error, Value>(
   })
 
 /** @internal */
-export const releaseOwner = <Key, Error, Value>(
-  self: Complete<Key, Error, Value>
+export const releaseOwner = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
 ): Effect.Effect<void> =>
   Exit.matchEffect(self.exit, {
     onFailure: () => core.unit,
@@ -186,13 +186,13 @@ const scopedCacheVariance = {
 }
 
 class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
-  implements ScopedCache.ScopedCache<Key, Error, Value>
+  implements ScopedCache.ScopedCache<Key, Value, Error>
 {
   readonly [ScopedCacheTypeId] = scopedCacheVariance
-  readonly cacheState: CacheState<Key, Error, Value>
+  readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,
-    readonly scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
+    readonly scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
     readonly clock: Clock.Clock,
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration,
     readonly context: Context.Context<Environment>
@@ -285,7 +285,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             this.resolveMapValue(value),
             core.flatMap(Option.match({
               onNone: () => {
-                const val = value as Complete<Key, Error, Value>
+                const val = value as Complete<Key, Value, Error>
                 const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
                 if (Equal.equals(current, value)) {
                   MutableHashMap.remove(this.cacheState.map, key)
@@ -393,7 +393,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
   }
 
   resolveMapValue(
-    value: MapValue<Key, Error, Value>,
+    value: MapValue<Key, Value, Error>,
     ignorePending = false
   ): Effect.Effect<Effect.Effect<Option.Option<Value>, Error, Scope.Scope>> {
     switch (value._tag) {
@@ -459,14 +459,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
               exit.value,
               release
             ])
-            const completedResult = complete<Key, Error, Value>(
+            const completedResult = complete<Key, Value, Error>(
               _cache.makeMapKey(key),
               exitWithFinalizer,
               MutableRef.make(1),
               _cache.makeEntryStats(now),
               expiredAt
             )
-            let previousValue: MapValue<Key, Error, Value> | undefined = undefined
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
             if (MutableHashMap.has(this.cacheState.map, key)) {
               previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             }
@@ -481,14 +481,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             )
           }
           case "Failure": {
-            const completedResult = complete<Key, Error, Value>(
+            const completedResult = complete<Key, Value, Error>(
               _cache.makeMapKey(key),
               exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
               MutableRef.make(0),
               _cache.makeEntryStats(now),
               expiredAt
             )
-            let previousValue: MapValue<Key, Error, Value> | undefined = undefined
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
             if (MutableHashMap.has(this.cacheState.map, key)) {
               previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             }
@@ -524,8 +524,8 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     this.cacheState.misses = this.cacheState.misses + 1
   }
 
-  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Error, Value>> {
-    const cleanedKeys: Array<MapValue<Key, Error, Value>> = []
+  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
+    const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
     MutableQueue.offer(this.cacheState.accesses, key)
     if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
       let loop = true
@@ -558,7 +558,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     return cleanedKeys
   }
 
-  cleanMapValue(mapValue: MapValue<Key, Error, Value> | undefined): Effect.Effect<void> {
+  cleanMapValue(mapValue: MapValue<Key, Value, Error> | undefined): Effect.Effect<void> {
     if (mapValue === undefined) {
       return core.unit
     }
@@ -586,13 +586,13 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
 }
 
 /** @internal */
-export const make = <Key, Environment, Error, Value>(
+export const make = <Key, Value, Error = never, Environment = never>(
   options: {
-    readonly lookup: ScopedCache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> => {
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -602,13 +602,13 @@ export const make = <Key, Environment, Error, Value>(
 }
 
 /** @internal */
-export const makeWith = <Key, Environment, Error, Value>(
+export const makeWith = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: ScopedCache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
   core.flatMap(
     effect.clock,
     (clock) =>
@@ -620,12 +620,12 @@ export const makeWith = <Key, Environment, Error, Value>(
       )
   )
 
-const buildWith = <Key, Environment, Error, Value>(
+const buildWith = <Key, Value, Error = never, Environment = never>(
   capacity: number,
-  scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
+  scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
   clock: Clock.Clock,
   timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
   fiberRuntime.acquireRelease(
     core.flatMap(
       core.context<Environment>(),
diff --git a/packages/effect/test/Cache.test.ts b/packages/effect/test/Cache.test.ts
index 96b65171b1..cfb73aa929 100644
--- a/packages/effect/test/Cache.test.ts
+++ b/packages/effect/test/Cache.test.ts
@@ -10,7 +10,7 @@ describe("Cache", () => {
       const cache = yield* _(Cache.make({
         capacity: 100,
         timeToLive: "1 seconds",
-        lookup: (n: number) => Effect.succeed(n)
+        lookup: (n: number): Effect.Effect<number, 2> => Effect.succeed(n)
       }))
       yield* _(cache.get(42))
       yield* _(TestClock.adjust("2 seconds"))
diff --git a/packages/effect/test/ScopedCache.test.ts b/packages/effect/test/ScopedCache.test.ts
index 8926214d83..f4b1740a28 100644
--- a/packages/effect/test/ScopedCache.test.ts
+++ b/packages/effect/test/ScopedCache.test.ts
@@ -302,7 +302,7 @@ describe("ScopedCache", () => {
   it.effect("get - sequential use of a failing scoped effect should cache the error and immediately call the resource finalizer", () =>
     Effect.gen(function*($) {
       const watchableLookup = yield* $(
-        WatchableLookup.makeEffect<void, Cause.RuntimeException, never>(() =>
+        WatchableLookup.makeEffect<void, never, Cause.RuntimeException>(() =>
           Effect.fail(new Cause.RuntimeException("fail"))
         )
       )
@@ -355,7 +355,7 @@ describe("ScopedCache", () => {
   it.effect("get - concurrent use on a failing scoped effect should cache the error and immediately call the resource finalizer", () =>
     Effect.gen(function*($) {
       const watchableLookup = yield* $(
-        WatchableLookup.makeEffect<void, Cause.RuntimeException, never>(() =>
+        WatchableLookup.makeEffect<void, never, Cause.RuntimeException>(() =>
           Effect.fail(new Cause.RuntimeException("fail"))
         )
       )
diff --git a/packages/effect/test/utils/cache/WatchableLookup.ts b/packages/effect/test/utils/cache/WatchableLookup.ts
index 763ae487e6..94569724e6 100644
--- a/packages/effect/test/utils/cache/WatchableLookup.ts
+++ b/packages/effect/test/utils/cache/WatchableLookup.ts
@@ -11,40 +11,40 @@ import type * as Scope from "effect/Scope"
 import * as TestServices from "effect/TestServices"
 import { expect } from "vitest"
 
-export interface WatchableLookup<Key, Error, Value> {
+export interface WatchableLookup<Key, Value, Error = never> {
   (key: Key): Effect.Effect<Value, Error, Scope.Scope>
-  lock(): Effect.Effect<void>
-  unlock(): Effect.Effect<void>
-  createdResources(): Effect.Effect<
+  lock: () => Effect.Effect<void>
+  unlock: () => Effect.Effect<void>
+  createdResources: () => Effect.Effect<
     HashMap.HashMap<Key, Chunk.Chunk<ObservableResource.ObservableResource<Error, Value>>>
   >
-  firstCreatedResource(key: Key): Effect.Effect<ObservableResource.ObservableResource<Error, Value>>
-  getCalledTimes(key: Key): Effect.Effect<number>
-  resourcesCleaned(
+  firstCreatedResource: (key: Key) => Effect.Effect<ObservableResource.ObservableResource<Error, Value>>
+  getCalledTimes: (key: Key) => Effect.Effect<number>
+  resourcesCleaned: (
     resources: Iterable<ObservableResource.ObservableResource<Error, Value>>
-  ): Effect.Effect<void>
-  assertCalledTimes(key: Key, sizeAssertion: (value: number) => void): Effect.Effect<void>
-  assertFirstNCreatedResourcesCleaned(key: Key, n: number): Effect.Effect<void>
-  assertAllCleaned(): Effect.Effect<void>
-  assertAllCleanedForKey(key: Key): Effect.Effect<void>
-  assertAtLeastOneResourceNotCleanedForKey(key: Key): Effect.Effect<void>
+  ) => Effect.Effect<void>
+  assertCalledTimes: (key: Key, sizeAssertion: (value: number) => void) => Effect.Effect<void>
+  assertFirstNCreatedResourcesCleaned: (key: Key, n: number) => Effect.Effect<void>
+  assertAllCleaned: () => Effect.Effect<void>
+  assertAllCleanedForKey: (key: Key) => Effect.Effect<void>
+  assertAtLeastOneResourceNotCleanedForKey: (key: Key) => Effect.Effect<void>
 }
 
 export const make = <Key, Value>(
   concreteLookup: (key: Key) => Value
-): Effect.Effect<WatchableLookup<Key, never, Value>> => makeEffect((key) => Effect.succeed(concreteLookup(key)))
+): Effect.Effect<WatchableLookup<Key, Value>> => makeEffect((key) => Effect.succeed(concreteLookup(key)))
 
-export const makeUnit = (): Effect.Effect<WatchableLookup<void, never, void>> => make((_: void) => void 0)
+export const makeUnit = (): Effect.Effect<WatchableLookup<void, void>> => make<void, void>((_: void) => void 0)
 
-export const makeEffect = <Key, Error, Value>(
+export const makeEffect = <Key, Value, Error = never>(
   concreteLookup: (key: Key) => Effect.Effect<Value, Error>
-): Effect.Effect<WatchableLookup<Key, Error, Value>> =>
+): Effect.Effect<WatchableLookup<Key, Value, Error>> =>
   Effect.map(
     Effect.zip(
       Ref.make(false),
       Ref.make(HashMap.empty<Key, Chunk.Chunk<ObservableResource.ObservableResource<Error, Value>>>())
     ),
-    ([blocked, resources]): WatchableLookup<Key, Error, Value> => {
+    ([blocked, resources]): WatchableLookup<Key, Value, Error> => {
       function lookup(key: Key): Effect.Effect<Value, Error, Scope.Scope> {
         return Effect.flatten(Effect.gen(function*($) {
           const observableResource = yield* $(ObservableResource.makeEffect(concreteLookup(key)))