effect 2.2.5 → 2.3.0

package/src/RateLimiter.ts

@@ -0,0 +1,37 @@
+/**
+ * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
+ *
+ * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
+ *
+ * Calls are queued up in an unbounded queue until capacity becomes available.
+ *
+ * @since 2.0.0
+ */
+import type { DurationInput } from "./Duration.js"
+import type { Effect } from "./Effect.js"
+import * as internal from "./internal/rateLimiter.js"
+import type { Scope } from "./Scope.js"
+
+/**
+ * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
+ *
+ * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
+ *
+ * Calls are queued up in an unbounded queue until capacity becomes available.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface RateLimiter {
+  <A, E, R>(task: Effect<A, E, R>): Effect<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (limit: number, window: DurationInput) => Effect<
+  RateLimiter,
+  never,
+  Scope
+> = internal.make

package/src/ReadonlyRecord.ts

@@ -275,6 +275,47 @@ export const get: {
   <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A> => has(self, key) ? Option.some(self[key]) : Option.none()
 )
 
+/**
+ * Apply a function to the element at the specified key, creating a new record.
+ * If the key does not exist, the record is returned unchanged.
+ *
+ * @param self - The record to be updated.
+ * @param key - The key of the element to modify.
+ * @param f - The function to apply to the element.
+ *
+ * @example
+ * import { modify } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * const f = (x: number) => x * 2
+ *
+ * assert.deepStrictEqual(
+ *  modify({ a: 3 }, 'a', f),
+ *  { a: 6 }
+ * )
+ * assert.deepStrictEqual(
+ *  modify({ a: 3 }, 'b', f),
+ *  { a: 3 }
+ * )
+ *
+ * @since 2.0.0
+ */
+export const modify: {
+  <A, B>(
+    key: string,
+    f: (a: A) => B
+  ): (self: ReadonlyRecord<A>) => Record<string, A | B>
+  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B>
+} = dual(
+  3,
+  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B> => {
+    if (!has(self, key)) {
+      return { ...self }
+    }
+    return { ...self, [key]: f(self[key]) }
+  }
+)
+
 /**
  * Apply a function to the element at the specified key, creating a new record,
  * or return `None` if the key doesn't exist.
@@ -771,14 +812,14 @@ export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_
  * @param values - The value you want to associate with the key.
  *
  * @example
- * import { upsert } from "effect/ReadonlyRecord"
+ * import { set } from "effect/ReadonlyRecord"
  *
- * assert.deepStrictEqual(upsert("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
- * assert.deepStrictEqual(upsert("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
+ * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
+ * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
  *
  * @since 2.0.0
  */
-export const upsert: {
+export const set: {
   <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
   <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
 } = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {
@@ -795,15 +836,15 @@ export const upsert: {
  * @param value - The new value to associate with the key.
  *
  * @example
- * import { update } from "effect/ReadonlyRecord"
+ * import { replace } from "effect/ReadonlyRecord"
  * import { some, none } from "effect/Option"
  *
- * assert.deepStrictEqual(update("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
- * assert.deepStrictEqual(update("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
+ * assert.deepStrictEqual(replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
+ * assert.deepStrictEqual(replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
  *
  * @since 2.0.0
  */
-export const update: {
+export const replace: {
   <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
   <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
 } = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {

package/src/Ref.ts

@@ -24,7 +24,7 @@ export type RefTypeId = typeof RefTypeId
  * @category models
  */
 export interface Ref<in out A> extends Ref.Variance<A>, Pipeable {
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
 }
 
 /**
@@ -46,21 +46,21 @@ export declare namespace Ref {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <A>(value: A) => Effect.Effect<never, never, Ref<A>> = internal.make
+export const make: <A>(value: A) => Effect.Effect<Ref<A>> = internal.make
 
 /**
  * @since 2.0.0
  * @category getters
  */
-export const get: <A>(self: Ref<A>) => Effect.Effect<never, never, A> = internal.get
+export const get: <A>(self: Ref<A>) => Effect.Effect<A> = internal.get
 
 /**
  * @since 2.0.0
  * @category utils
  */
 export const getAndSet: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, A>
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<A>
 } = internal.getAndSet
 
 /**
@@ -68,8 +68,8 @@ export const getAndSet: {
  * @category utils
  */
 export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
 } = internal.getAndUpdate
 
 /**
@@ -77,8 +77,8 @@ export const getAndUpdate: {
  * @category utils
  */
 export const getAndUpdateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = internal.getAndUpdateSome
 
 /**
@@ -86,8 +86,8 @@ export const getAndUpdateSome: {
  * @category utils
  */
 export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<never, never, B>
-  <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<B>
+  <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
 } = internal.modify
 
 /**
@@ -95,8 +95,8 @@ export const modify: {
  * @category utils
  */
 export const modifySome: {
-  <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<never, never, B>
-  <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<never, never, B>
+  <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<B>
+  <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B>
 } = internal.modifySome
 
 /**
@@ -104,8 +104,8 @@ export const modifySome: {
  * @category utils
  */
 export const set: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, void>
-  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, void>
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, value: A): Effect.Effect<void>
 } = internal.set
 
 /**
@@ -113,8 +113,8 @@ export const set: {
  * @category utils
  */
 export const setAndGet: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, A>
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<A>
 } = internal.setAndGet
 
 /**
@@ -122,8 +122,8 @@ export const setAndGet: {
  * @category utils
  */
 export const update: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, void>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, void>
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<void>
 } = internal.update
 
 /**
@@ -131,8 +131,8 @@ export const update: {
  * @category utils
  */
 export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
 } = internal.updateAndGet
 
 /**
@@ -140,8 +140,8 @@ export const updateAndGet: {
  * @category utils
  */
 export const updateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, void>
-  <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<never, never, void>
+  <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
 } = internal.updateSome
 
 /**
@@ -149,8 +149,8 @@ export const updateSome: {
  * @category utils
  */
 export const updateSomeAndGet: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, A>
-  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = internal.updateSomeAndGet
 
 /**

package/src/Reloadable.ts

@@ -36,7 +36,7 @@ export interface Reloadable<in out A> extends Reloadable.Variance<A> {
   /**
    * @internal
    */
-  readonly reload: Effect.Effect<never, unknown, void>
+  readonly reload: Effect.Effect<void, unknown>
 }
 
 /**
@@ -65,10 +65,10 @@ export declare namespace Reloadable {
 export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
   tag: Out,
   options: {
-    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
     readonly schedule: Schedule.Schedule<R, unknown, unknown>
   }
-) => Layer.Layer<In | R, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.auto
+) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.auto
 
 /**
  * Makes a new reloadable service from a layer that describes the construction
@@ -81,10 +81,10 @@ export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
 export const autoFromConfig: <Out extends Context.Tag<any, any>, In, E, R>(
   tag: Out,
   options: {
-    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
     readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
   }
-) => Layer.Layer<In | R, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.autoFromConfig
+) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.autoFromConfig
 
 /**
  * Retrieves the current version of the reloadable service.
@@ -94,7 +94,7 @@ export const autoFromConfig: <Out extends Context.Tag<any, any>, In, E, R>(
  */
 export const get: <T extends Context.Tag<any, any>>(
   tag: T
-) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, never, Context.Tag.Service<T>> = internal.get
+) => Effect.Effect<Context.Tag.Service<T>, never, Reloadable<Context.Tag.Identifier<T>>> = internal.get
 
 /**
  * Makes a new reloadable service from a layer that describes the construction
@@ -105,8 +105,8 @@ export const get: <T extends Context.Tag<any, any>>(
  */
 export const manual: <Out extends Context.Tag<any, any>, In, E>(
   tag: Out,
-  options: { readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>> }
-) => Layer.Layer<In, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.manual
+  options: { readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In> }
+) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In> = internal.manual
 
 /**
  * Reloads the specified service.
@@ -116,7 +116,7 @@ export const manual: <Out extends Context.Tag<any, any>, In, E>(
  */
 export const reload: <T extends Context.Tag<any, any>>(
   tag: T
-) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, unknown, void> = internal.reload
+) => Effect.Effect<void, unknown, Reloadable<Context.Tag.Identifier<T>>> = internal.reload
 
 /**
  * @since 2.0.0
@@ -134,4 +134,4 @@ export const tag: <T extends Context.Tag<any, any>>(
  */
 export const reloadFork: <T extends Context.Tag<any, any>>(
   tag: T
-) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, unknown, void> = internal.reloadFork
+) => Effect.Effect<void, unknown, Reloadable<Context.Tag.Identifier<T>>> = internal.reloadFork

package/src/Request.ts

@@ -3,7 +3,6 @@
  */
 import type * as _Cache from "./Cache.js"
 import type { Cause } from "./Cause.js"
-import type * as Data from "./Data.js"
 import type { Deferred } from "./Deferred.js"
 import type { DurationInput } from "./Duration.js"
 import type * as Effect from "./Effect.js"
@@ -30,13 +29,13 @@ export const RequestTypeId: unique symbol = internal.RequestTypeId
 export type RequestTypeId = typeof RequestTypeId
 
 /**
- * A `Request<E, A>` is a request from a data source for a value of type `A`
+ * A `Request<A, E>` is a request from a data source for a value of type `A`
  * that may fail with an `E`.
  *
  * @since 2.0.0
  * @category models
  */
-export interface Request<out E, out A> extends Request.Variance<E, A>, Data.Case {}
+export interface Request<out A, out E = never> extends Request.Variance<A, E> {}
 
 /**
  * @since 2.0.0
@@ -46,10 +45,10 @@ export declare namespace Request {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out E, out A> {
+  export interface Variance<out A, out E> {
     readonly [RequestTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 
@@ -58,7 +57,7 @@ export declare namespace Request {
    * @category models
    */
   export interface Constructor<R extends Request<any, any>, T extends keyof R = never> {
-    (args: Omit<R, T | keyof (Data.Case & Request.Variance<Request.Error<R>, Request.Success<R>>)>): R
+    (args: Omit<R, T | keyof (Request.Variance<Request.Error<R>, Request.Success<R>>)>): R
   }
 
   /**
@@ -67,7 +66,7 @@ export declare namespace Request {
    * @since 2.0.0
    * @category type-level
    */
-  export type Error<T extends Request<any, any>> = [T] extends [Request<infer _E, infer _A>] ? _E : never
+  export type Error<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _E : never
 
   /**
    * A utility type to extract the value type from a `Request`.
@@ -75,7 +74,7 @@ export declare namespace Request {
    * @since 2.0.0
    * @category type-level
    */
-  export type Success<T extends Request<any, any>> = [T] extends [Request<infer _E, infer _A>] ? _A : never
+  export type Success<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _A : never
 
   /**
    * A utility type to extract the result type from a `Request`.
@@ -83,7 +82,7 @@ export declare namespace Request {
    * @since 2.0.0
    * @category type-level
    */
-  export type Result<T extends Request<any, any>> = T extends Request<infer E, infer A> ? Exit.Exit<E, A> : never
+  export type Result<T extends Request<any, any>> = T extends Request<infer A, infer E> ? Exit.Exit<A, E> : never
 
   /**
    * A utility type to extract the optional result type from a `Request`.
@@ -91,8 +90,8 @@ export declare namespace Request {
    * @since 2.0.0
    * @category type-level
    */
-  export type OptionalResult<T extends Request<any, any>> = T extends Request<infer E, infer A>
-    ? Exit.Exit<E, Option.Option<A>>
+  export type OptionalResult<T extends Request<any, any>> = T extends Request<infer A, infer E>
+    ? Exit.Exit<Option.Option<A>, E>
     : never
 }
 
@@ -141,7 +140,7 @@ export const tagged: <R extends Request<any, any> & { _tag: string }>(
 export const Class: new<Error, Success, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
-) => Request<Error, Success> & Readonly<A> = internal.Class as any
+) => Request<Success, Error> & Readonly<A> = internal.Class as any
 
 /**
  * Provides a Tagged constructor for a Request Class.
@@ -164,7 +163,7 @@ export const TaggedClass: <Tag extends string>(
 ) => new<Error, Success, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
-) => Request<Error, Success> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any
+) => Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any
 
 /**
  * Complete a `Request` with the specified result.
@@ -173,8 +172,8 @@ export const TaggedClass: <Tag extends string>(
  * @category request completion
  */
 export const complete: {
-  <A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<never, never, void>
-  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<void>
 } = internal.complete
 
 /**
@@ -184,8 +183,8 @@ export const complete: {
  * @category request completion
  */
 export const interruptWhenPossible: {
-  (all: Iterable<Request<any, any>>): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, void>
-  <R, E, A>(self: Effect.Effect<R, E, A>, all: Iterable<Request<any, any>>): Effect.Effect<R, E, void>
+  (all: Iterable<Request<any, any>>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, all: Iterable<Request<any, any>>): Effect.Effect<void, E, R>
 } = fiberRuntime.interruptWhenPossible
 
 /**
@@ -198,12 +197,12 @@ export const interruptWhenPossible: {
  */
 export const completeEffect: {
   <A extends Request<any, any>, R>(
-    effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
-  ): (self: A) => Effect.Effect<R, never, void>
+    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
+  ): (self: A) => Effect.Effect<void, never, R>
   <A extends Request<any, any>, R>(
     self: A,
-    effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
-  ): Effect.Effect<R, never, void>
+    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
+  ): Effect.Effect<void, never, R>
 } = internal.completeEffect
 
 /**
@@ -213,8 +212,8 @@ export const completeEffect: {
  * @category request completion
  */
 export const fail: {
-  <A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<never, never, void>
-  <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<void>
 } = internal.fail
 
 /**
@@ -224,8 +223,8 @@ export const fail: {
  * @category request completion
  */
 export const failCause: {
-  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<never, never, void>
-  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<void>
 } = internal.failCause
 
 /**
@@ -235,8 +234,8 @@ export const failCause: {
  * @category request completion
  */
 export const succeed: {
-  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<never, never, void>
-  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<void>
 } = internal.succeed
 
 /**
@@ -272,10 +271,11 @@ export const makeCache = (
     readonly capacity: number
     readonly timeToLive: DurationInput
   }
-): Effect.Effect<never, never, Cache> =>
+): Effect.Effect<Cache> =>
   cache.make({
     ...options,
-    lookup: () => core.map(core.deferredMake(), (handle) => ({ listeners: new internal.Listeners(), handle }))
+    lookup: () =>
+      core.map(core.deferredMake<unknown, unknown>(), (handle) => ({ listeners: new internal.Listeners(), handle }))
   })
 
 /**
@@ -303,8 +303,8 @@ export type EntryTypeId = typeof EntryTypeId
 export interface Entry<out R> extends Entry.Variance<R> {
   readonly request: R
   readonly result: Deferred<
-    [R] extends [Request<infer _E, infer _A>] ? _E : never,
-    [R] extends [Request<infer _E, infer _A>] ? _A : never
+    [R] extends [Request<infer _A, infer _E>] ? _A : never,
+    [R] extends [Request<infer _A, infer _E>] ? _E : never
   >
   readonly listeners: Listeners
   readonly ownerId: FiberId

package/src/RequestBlock.ts

@@ -30,7 +30,7 @@ export declare namespace RequestBlock {
     emptyCase(): Z
     parCase(left: Z, right: Z): Z
     singleCase(
-      dataSource: RequestResolver.RequestResolver<unknown, never>,
+      dataSource: RequestResolver.RequestResolver<unknown>,
       blockedRequest: Request.Entry<unknown>
     ): Z
     seqCase(left: Z, right: Z): Z
@@ -71,7 +71,7 @@ export interface Seq {
  */
 export interface Single {
   readonly _tag: "Single"
-  readonly dataSource: RequestResolver.RequestResolver<unknown, never>
+  readonly dataSource: RequestResolver.RequestResolver<unknown>
   readonly blockedRequest: Request.Entry<unknown>
 }
 
@@ -80,7 +80,7 @@ export interface Single {
  * @category constructors
  */
 export const single: <A>(
-  dataSource: RequestResolver.RequestResolver<A, never>,
+  dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
 ) => RequestBlock = _RequestBlock.single