effect 3.6.8 → 3.7.1

package/dist/dts/Effect.d.ts

@@ -427,6 +427,7 @@ export declare const all: <const Arg extends Iterable<Effect<any, any, any>> | R
     readonly batching?: boolean | "inherit" | undefined;
     readonly discard?: boolean | undefined;
     readonly mode?: "default" | "validate" | "either" | undefined;
+    readonly concurrentFinalizers?: boolean | undefined;
 }>(arg: Arg, options?: O) => All.Return<Arg, O>;
 /**
  * Data-last variant of `Effect.all`.
@@ -443,6 +444,7 @@ export declare const allWith: <O extends {
     readonly batching?: boolean | "inherit" | undefined;
     readonly discard?: boolean | undefined;
     readonly mode?: "default" | "validate" | "either" | undefined;
+    readonly concurrentFinalizers?: boolean | undefined;
 }>(options?: O) => <const Arg extends Iterable<Effect<any, any, any>> | Record<string, Effect<any, any, any>>>(arg: Arg) => All.Return<Arg, O>;
 /**
  * @since 2.0.0
@@ -516,6 +518,7 @@ export declare namespace All {
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: boolean | undefined;
         readonly mode?: "default" | "validate" | "either" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }> = [Arg] extends [ReadonlyArray<EffectAny>] ? ReturnTuple<Arg, IsDiscard<O>, ExtractMode<O>> : [Arg] extends [Iterable<EffectAny>] ? ReturnIterable<Arg, IsDiscard<O>, ExtractMode<O>> : [Arg] extends [Record<string, EffectAny>] ? ReturnObject<Arg, IsDiscard<O>, ExtractMode<O>> : never;
 }
 /**
@@ -528,6 +531,7 @@ export declare namespace All {
 export declare const allSuccesses: <X extends Effect<any, any, any>>(elements: Iterable<X>, options?: {
     readonly concurrency?: Concurrency | undefined;
     readonly batching?: boolean | "inherit" | undefined;
+    readonly concurrentFinalizers?: boolean | undefined;
 } | undefined) => Effect<Array<Effect.Success<X>>, never, Effect.Context<X>>;
 /**
  * Drops all elements until the effectful predicate returns true.
@@ -571,10 +575,12 @@ export declare const exists: {
     <A, E, R>(f: (a: A, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<A>) => Effect<boolean, E, R>;
     <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<boolean, E, R>;
 };
 /**
@@ -588,11 +594,13 @@ export declare const filter: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly negate?: boolean | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
     <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly negate?: boolean | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<Array<A>, E, R>;
 };
 /**
@@ -644,21 +652,25 @@ export declare const forEach: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (self: S) => Effect<RA.ReadonlyArray.With<S, B>, E, R>;
     <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): (self: Iterable<A>) => Effect<void, E, R>;
     <B, E, R, S extends Iterable<any>>(self: S, f: (a: RA.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<RA.ReadonlyArray.With<S, B>, E, R>;
     <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<void, E, R>;
 };
 /**
@@ -680,10 +692,12 @@ export declare const mergeAll: {
     <Z, Eff extends Effect<any, any, any>>(zero: Z, f: (z: Z, a: Effect.Success<Eff>, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<Eff>) => Effect<Z, Effect.Error<Eff>, Effect.Context<Eff>>;
     <Eff extends Effect<any, any, any>, Z>(elements: Iterable<Eff>, zero: Z, f: (z: Z, a: Effect.Success<Eff>, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<Z, Effect.Error<Eff>, Effect.Context<Eff>>;
 };
 /**
@@ -697,10 +711,12 @@ export declare const partition: {
     <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>;
     <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>;
 };
 /**
@@ -724,10 +740,12 @@ export declare const reduceEffect: {
     <Z, E, R, Eff extends Effect<any, any, any>>(zero: Effect<Z, E, R>, f: (acc: NoInfer<Z>, a: Effect.Success<Eff>, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<Eff>) => Effect<Z, E | Effect.Error<Eff>, R | Effect.Context<Eff>>;
     <Eff extends Effect<any, any, any>, Z, E, R>(elements: Iterable<Eff>, zero: Effect<Z, E, R>, f: (acc: NoInfer<Z>, a: Effect.Success<Eff>, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<Z, E | Effect.Error<Eff>, R | Effect.Context<Eff>>;
 };
 /**
@@ -779,21 +797,25 @@ export declare const replicateEffect: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<Array<A>, E, R>;
     (n: number, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R>;
     <A, E, R>(self: Effect<A, E, R>, n: number, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<Array<A>, E, R>;
     <A, E, R>(self: Effect<A, E, R>, n: number, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<void, E, R>;
 };
 /**
@@ -831,21 +853,25 @@ export declare const validateAll: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<A>) => Effect<Array<B>, Array<E>, R>;
     <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): (elements: Iterable<A>) => Effect<void, Array<E>, R>;
     <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<Array<B>, Array<E>, R>;
     <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<void, Array<E>, R>;
 };
 /**
@@ -872,10 +898,12 @@ export declare const validateFirst: {
     <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): (elements: Iterable<A>) => Effect<B, Array<E>, R>;
     <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<B, Array<E>, R>;
 };
 /**
@@ -1217,9 +1245,9 @@ export declare const catchSomeDefect: {
 export declare const catchTag: {
     <K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: NoInfer<Extract<E, {
         _tag: K;
-    }>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, {
+    }>>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, {
         _tag: K;
     }>, R1 | R>;
     <A, E, R, K extends E extends {
@@ -2592,6 +2620,50 @@ export declare const bind: {
         [K in N | keyof A]: K extends keyof A ? A[K] : B;
     }, E1 | E2, R1 | R2>;
 };
+/**
+ * `bindAll` combines `Effect.all` with `Effect.bind`. It is useful
+ * when you want to concurrently run multiple effects and then combine their
+ * results in a Do notation pipeline.
+ *
+ * @example
+ * import { Effect, Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ *   Effect.Do,
+ *   Effect.bind("x", () => Effect.succeed(2)),
+ *   Effect.bindAll(({ x }) => ({
+ *     a: Effect.succeed(x),
+ *     b: Effect.fail("oops"),
+ *   }), { concurrency: 2, mode: "either" })
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") })
+ *
+ * @category do notation
+ * @since 3.7.0
+ */
+export declare const bindAll: {
+    <A extends object, X extends Record<string, Effect<any, any, any>>, O extends {
+        readonly concurrency?: Concurrency | undefined;
+        readonly batching?: boolean | "inherit" | undefined;
+        readonly mode?: "default" | "validate" | "either" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
+    }>(f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`, options?: undefined | O): <E1, R1>(self: Effect<A, E1, R1>) => [All.ReturnObject<X, false, All.ExtractMode<O>>] extends [Effect<infer Success, infer Error, infer Context>] ? Effect<{
+        [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never;
+    }, E1 | Error, R1 | Context> : never;
+    <A extends object, X extends Record<string, Effect<any, any, any>>, O extends {
+        readonly concurrency?: Concurrency | undefined;
+        readonly batching?: boolean | "inherit" | undefined;
+        readonly mode?: "default" | "validate" | "either" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
+    }, E1, R1>(self: Effect<A, E1, R1>, f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`, options?: undefined | {
+        readonly concurrency?: Concurrency | undefined;
+        readonly batching?: boolean | "inherit" | undefined;
+        readonly mode?: "default" | "validate" | "either" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
+    }): [All.ReturnObject<X, false, All.ExtractMode<O>>] extends [Effect<infer Success, infer Error, infer Context>] ? Effect<{
+        [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never;
+    }, E1 | Error, R1 | Context> : never;
+};
 /**
  * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
  *
@@ -3148,9 +3220,9 @@ export declare const tapError: {
 export declare const tapErrorTag: {
     <K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: NoInfer<Extract<E, {
         _tag: K;
-    }>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E1, R1 | R>;
+    }>>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E1, R1 | R>;
     <A, E, R, K extends E extends {
         _tag: string;
     } ? E["_tag"] : never, A1, E1, R1>(self: Effect<A, E, R>, k: K, f: (e: Extract<E, {
@@ -4065,16 +4137,14 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  */
 export declare const validate: {
     <B, E1, R1>(that: Effect<B, E1, R1>, options?: {
-        /**
-         * @since 2.0.0
-         * @category supervision & fibers
-         */
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, B], E1 | E, R1 | R>;
     <A, E, R, B, E1, R1>(self: Effect<A, E, R>, that: Effect<B, E1, R1>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<[A, B], E | E1, R | R1>;
 };
 /**
@@ -4088,10 +4158,12 @@ export declare const validateWith: {
     <B, E1, R1, A, C>(that: Effect<B, E1, R1>, f: (a: A, b: B) => C, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): <E, R>(self: Effect<A, E, R>) => Effect<C, E1 | E, R1 | R>;
     <A, E, R, B, E1, R1, C>(self: Effect<A, E, R>, that: Effect<B, E1, R1>, f: (a: A, b: B) => C, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<C, E | E1, R | R1>;
 };
 /**
@@ -4151,10 +4223,12 @@ export declare const zip: {
     <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, A2], E2 | E, R2 | R>;
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<[A, A2], E | E2, R | R2>;
 };
 /**
@@ -4181,10 +4255,12 @@ export declare const zipLeft: {
     <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R2 | R>;
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     } | undefined): Effect<A, E | E2, R | R2>;
 };
 /**
@@ -4211,10 +4287,12 @@ export declare const zipRight: {
     <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<A2, E2 | E, R2 | R>;
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<A2, E2 | E, R2 | R>;
 };
 /**
@@ -4254,10 +4332,12 @@ export declare const zipWith: {
     <A2, E2, R2, A, B>(that: Effect<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R2 | R>;
     <A, E, R, A2, E2, R2, B>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
+        readonly concurrentFinalizers?: boolean | undefined;
     }): Effect<B, E2 | E, R2 | R>;
 };
 /**