effect 3.10.19 → 3.11.0

package/dist/dts/Effect.d.ts

@@ -47,7 +47,7 @@ import type * as Supervisor from "./Supervisor.js";
 import type * as Tracer from "./Tracer.js";
 import type { Concurrency, Contravariant, Covariant, NoExcessProperties, NoInfer, NotFunction } from "./Types.js";
 import type * as Unify from "./Unify.js";
-import type { YieldWrap } from "./Utils.js";
+import { type YieldWrap } from "./Utils.js";
 /**
  * @since 2.0.0
  * @category Symbols
@@ -130,6 +130,9 @@ declare module "./Context.js" {
     interface Tag<Id, Value> extends Effect<Value, never, Id> {
         [Symbol.iterator](): EffectGenerator<Tag<Id, Value>>;
     }
+    interface Reference<Id, Value> extends Effect<Value> {
+        [Symbol.iterator](): EffectGenerator<Reference<Id, Value>>;
+    }
     interface TagUnifyIgnore {
         Effect?: true;
         Either?: true;
@@ -6901,6 +6904,15 @@ export declare const scope: Effect<Scope.Scope, never, Scope.Scope>;
  * @category scoping, resources & finalization
  */
 export declare const scopeWith: <A, E, R>(f: (scope: Scope.Scope) => Effect<A, E, R>) => Effect<A, E, R | Scope.Scope>;
+/**
+ * Creates a `Scope`, passes it to the specified effectful function, and then
+ * closes the scope as soon as the effect is complete (whether through success,
+ * failure, or interruption).
+ *
+ * @since 3.11.0
+ * @category scoping, resources & finalization
+ */
+export declare const scopedWith: <A, E, R>(f: (scope: Scope.Scope) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Scopes all resources used in this workflow to the lifetime of the workflow,
  * ensuring that their finalizers are run as soon as this workflow completes
@@ -17233,4 +17245,79 @@ export declare namespace Service {
         readonly accessors: true;
     } ? true : false;
 }
+/**
+ * @since 3.11.0
+ * @category models
+ */
+export declare namespace fn {
+    /**
+     * @since 3.11.0
+     * @category models
+     */
+    type FnEffect<AEff, Eff extends YieldWrap<Effect<any, any, any>>> = Effect<AEff, [
+        Eff
+    ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer E, infer _R>>] ? E : never, [
+        Eff
+    ] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never>;
+    /**
+     * @since 3.11.0
+     * @category models
+     */
+    type Gen = {
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>>(body: (...args: Args) => Generator<Eff, AEff, never>): (...args: Args) => fn.FnEffect<AEff, Eff>;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A): (...args: Args) => A;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B): (...args: Args) => B;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C): (...args: Args) => C;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D): (...args: Args) => D;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E): (...args: Args) => E;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F): (...args: Args) => F;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G): (...args: Args) => G;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G, H extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G, h: (_: G) => H): (...args: Args) => H;
+        <Eff extends YieldWrap<Effect<any, any, any>>, AEff, Args extends Array<any>, A, B, C, D, E, F, G, H, I extends Effect<any, any, any>>(body: (...args: Args) => Generator<Eff, AEff, never>, a: (_: fn.FnEffect<AEff, Eff>) => A, b: (_: A) => B, c: (_: B) => C, d: (_: C) => D, e: (_: D) => E, f: (_: E) => F, g: (_: F) => G, h: (_: G) => H, i: (_: H) => I): (...args: Args) => I;
+    };
+    /**
+     * @since 3.11.0
+     * @category models
+     */
+    type NonGen = {
+        <Eff extends Effect<any, any, any>, Args extends Array<any>>(body: (...args: Args) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => H, h: (_: H) => Eff): (...args: Args) => Eff;
+        <Eff extends Effect<any, any, any>, A, B, C, D, E, F, G, H, I, Args extends Array<any>>(body: (...args: Args) => A, a: (_: A) => B, b: (_: B) => C, c: (_: C) => D, d: (_: D) => E, e: (_: E) => F, f: (_: E) => G, g: (_: G) => H, h: (_: H) => I, i: (_: H) => Eff): (...args: Args) => Eff;
+    };
+}
+/**
+ * Creates a function that returns an Effect which is automatically traced with a span pointing to the call site.
+ *
+ * The function can be created both using a generator function that can yield effects or using a normal function.
+ *
+ * @since 3.11.0
+ * @category function
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * const logExample = Effect.fn("logExample")(
+ *   function*<N extends number>(n: N) {
+ *     yield* Effect.annotateCurrentSpan("n", n)
+ *     yield* Effect.logInfo(`got: ${n}`)
+ *     yield* Effect.fail(new Error())
+ *   },
+ *   Effect.delay("1 second")
+ * )
+ *
+ * Effect.runFork(
+ *   // this location is printed on the stack trace of the following `Effect.logError`
+ *   logExample(100).pipe(
+ *     Effect.catchAllCause(Effect.logError)
+ *   )
+ * )
+ */
+export declare const fn: (name: string, options?: Tracer.SpanOptions) => fn.Gen & fn.NonGen;
 //# sourceMappingURL=Effect.d.ts.map