effect 2.4.19 → 3.0.0

package/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>

package/src/SortedSet.ts

@@ -14,7 +14,7 @@ import { pipeArguments } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
-import type { Invariant, NoInfer } from "./Types.js"
+import type { Invariant } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
 

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -3707,7 +3707,7 @@ export const throttleEffect: {
 } = internal.throttleEffect
 
 /**
- * A stream that emits Unit values spaced by the specified duration.
+ * A stream that emits void values spaced by the specified duration.
  *
  * @since 2.0.0
  * @category constructors
@@ -3915,13 +3915,16 @@ export const unfoldEffect: <S, A, E, R>(
   f: (s: S) => Effect.Effect<Option.Option<readonly [A, S]>, E, R>
 ) => Stream<A, E, R> = internal.unfoldEffect
 
-/**
- * A stream that contains a single `Unit` value.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Stream<void> = internal.unit
+const void_: Stream<void> = internal.void
+export {
+  /**
+   * A stream that contains a single `void` value.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Creates a stream produced from an `Effect`.
@@ -4025,7 +4028,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined
@@ -4036,7 +4039,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined

package/src/StreamHaltStrategy.ts

@@ -102,10 +102,22 @@ export const isBoth: (self: HaltStrategy) => self is Both = internal.isBoth
 export const isEither: (self: HaltStrategy) => self is Either = internal.isEither
 
 /**
+ * Folds over the specified `HaltStrategy` using the provided case functions.
+ *
  * @since 2.0.0
  * @category folding
  */
 export const match: {
-  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): (self: HaltStrategy) => Z
-  <Z>(self: HaltStrategy, onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): Z
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): (self: HaltStrategy) => Z
+  <Z>(self: HaltStrategy, options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): Z
 } = internal.match

package/src/String.ts

@@ -6,16 +6,16 @@
  * @since 2.0.0
  */
 
+import type { NonEmptyArray } from "./Array.js"
 import * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
-import * as readonlyArray from "./internal/readonlyArray.js"
+import * as readonlyArray from "./internal/array.js"
 import * as number from "./Number.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type * as Ordering from "./Ordering.js"
 import type { Refinement } from "./Predicate.js"
 import * as predicate from "./Predicate.js"
-import type { NonEmptyArray } from "./ReadonlyArray.js"
 
 /**
  * Tests if a value is a `string`.
@@ -624,6 +624,49 @@ export const stripMarginWith: {
  */
 export const stripMargin = (self: string): string => stripMarginWith(self, "|")
 
+/**
+ * @since 2.0.0
+ */
+export const snakeToCamel = (self: string): string => {
+  let str = self[0]
+  for (let i = 1; i < self.length; i++) {
+    str += self[i] === "_" ? self[++i].toUpperCase() : self[i]
+  }
+  return str
+}
+
+/**
+ * @since 2.0.0
+ */
+export const snakeToPascal = (self: string): string => {
+  let str = self[0].toUpperCase()
+  for (let i = 1; i < self.length; i++) {
+    str += self[i] === "_" ? self[++i].toUpperCase() : self[i]
+  }
+  return str
+}
+
+/**
+ * @since 2.0.0
+ */
+export const snakeToKebab = (self: string): string => self.replace(/_/g, "-")
+
+/**
+ * @since 2.0.0
+ */
+export const camelToSnake = (self: string): string => self.replace(/([A-Z])/g, "_$1").toLowerCase()
+
+/**
+ * @since 2.0.0
+ */
+export const pascalToSnake = (self: string): string =>
+  (self.slice(0, 1) + self.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase()
+
+/**
+ * @since 2.0.0
+ */
+export const kebabToSnake = (self: string): string => self.replace(/-/g, "_")
+
 class LinesIterator implements IterableIterator<string> {
   private index: number
   private readonly length: number

package/src/TestAnnotations.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import * as RA from "./Array.js"
 import * as Context from "./Context.js"
 import type * as Effect from "./Effect.js"
 import * as Equal from "./Equal.js"
@@ -11,7 +12,6 @@ import * as core from "./internal/core.js"
 import * as fiber from "./internal/fiber.js"
 import * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
-import * as RA from "./ReadonlyArray.js"
 import * as Ref from "./Ref.js"
 import * as SortedSet from "./SortedSet.js"
 import * as TestAnnotation from "./TestAnnotation.js"

package/src/TestClock.ts

@@ -209,7 +209,7 @@ export class TestClockImpl implements TestClock {
         core.flatMap((shouldAwait) =>
           shouldAwait ?
             pipe(this.warningStart(), core.zipRight(core.deferredAwait(deferred))) :
-            pipe(core.deferredSucceed(deferred, void 0), core.asUnit)
+            pipe(core.deferredSucceed(deferred, void 0), core.asVoid)
         )
       ))
   }
@@ -250,7 +250,7 @@ export class TestClockImpl implements TestClock {
   }
   /**
    * Captures a "snapshot" of the identifier and status of all fibers in this
-   * test other than the current fiber. Fails with the `Unit` value if any of
+   * test other than the current fiber. Fails with the `void` value if any of
    * these fibers are not done or suspended. Note that because we cannot
    * synchronize on the status of multiple fibers at the same time this
    * snapshot may not be fully consistent.
@@ -409,7 +409,7 @@ export class TestClockImpl implements TestClock {
         core.flatMap((option) => {
           switch (option._tag) {
             case "None": {
-              return core.unit
+              return core.void
             }
             case "Some": {
               const [end, deferred] = option.value

package/src/Tracer.ts

@@ -26,7 +26,7 @@ export interface Tracer {
   readonly [TracerTypeId]: TracerTypeId
   span(
     name: string,
-    parent: Option.Option<ParentSpan>,
+    parent: Option.Option<AnySpan>,
     context: Context.Context<never>,
     links: ReadonlyArray<SpanLink>,
     startTime: bigint
@@ -52,13 +52,21 @@ export type SpanStatus = {
  * @since 2.0.0
  * @category models
  */
-export type ParentSpan = Span | ExternalSpan
+export type AnySpan = Span | ExternalSpan
 
 /**
  * @since 2.0.0
  * @category tags
  */
-export const ParentSpan: Context.Tag<ParentSpan, ParentSpan> = internal.spanTag
+export interface ParentSpan {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export const ParentSpan: Context.Tag<ParentSpan, AnySpan> = internal.spanTag
 
 /**
  * @since 2.0.0
@@ -81,7 +89,7 @@ export interface Span {
   readonly name: string
   readonly spanId: string
   readonly traceId: string
-  readonly parent: Option.Option<ParentSpan>
+  readonly parent: Option.Option<AnySpan>
   readonly context: Context.Context<never>
   readonly status: SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
@@ -98,7 +106,7 @@ export interface Span {
  */
 export interface SpanLink {
   readonly _tag: "SpanLink"
-  readonly span: ParentSpan
+  readonly span: AnySpan
   readonly attributes: Readonly<Record<string, unknown>>
 }
 

package/src/Trie.ts

@@ -20,7 +20,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as TR from "./internal/trie.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant } from "./Types.js"
 
 const TypeId: unique symbol = TR.TrieTypeId as TypeId
 

package/src/Types.ts

@@ -170,14 +170,6 @@ export type Mutable<T> = {
   -readonly [P in keyof T]: T[P]
 }
 
-/**
- * Avoid inference on a specific parameter
- *
- * @since 2.0.0
- * @category models
- */
-export type NoInfer<A> = [A][A extends any ? 0 : never]
-
 /**
  * Invariant helper.
  *

package/src/index.ts

@@ -29,6 +29,13 @@ export {
   unsafeCoerce
 } from "./Function.js"
 
+/**
+ * This module provides utility functions for working with arrays in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as Array from "./Array.js"
+
 /**
  * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
@@ -255,6 +262,11 @@ export * as Exit from "./Exit.js"
  */
 export * as Fiber from "./Fiber.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as FiberHandle from "./FiberHandle.js"
+
 /**
  * @since 2.0.0
  */
@@ -575,19 +587,12 @@ export * as RateLimiter from "./RateLimiter.js"
  */
 export * as Readable from "./Readable.js"
 
-/**
- * This module provides utility functions for working with arrays in TypeScript.
- *
- * @since 2.0.0
- */
-export * as ReadonlyArray from "./ReadonlyArray.js"
-
 /**
  * This module provides utility functions for working with records in TypeScript.
  *
  * @since 2.0.0
  */
-export * as ReadonlyRecord from "./ReadonlyRecord.js"
+export * as Record from "./Record.js"
 
 /**
  * @since 2.0.0

package/src/internal/{readonlyArray.ts → array.ts}

@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 
-import type { NonEmptyArray } from "../ReadonlyArray.js"
+import type { NonEmptyArray } from "../Array.js"
 
 /** @internal */
 export const isNonEmptyArray = <A>(self: ReadonlyArray<A>): self is NonEmptyArray<A> => self.length > 0

package/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()
@@ -443,7 +443,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
           }
         }
         if (value === undefined) {
-          return core.asUnit(this.lookupValueOf(key, deferred))
+          return core.asVoid(this.lookupValueOf(key, deferred))
         } else {
           switch (value._tag) {
             case "Complete": {
@@ -452,7 +452,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 if (Equal.equals(found, value)) {
                   MutableHashMap.remove(this.cacheState.map, k)
                 }
-                return core.asUnit(this.get(key))
+                return core.asVoid(this.get(key))
               }
               // Only trigger the lookup if we're still the current value, `completedResult`
               return pipe(
@@ -460,13 +460,13 @@ 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
                   }
                   return false
                 }),
-                core.asUnit
+                core.asVoid
               )
             }
             case "Pending": {
@@ -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,