effect 3.0.7 → 3.1.0

package/dist/dts/Effect.d.ts

@@ -527,16 +527,11 @@ export declare const forEach: {
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
     }): (self: Iterable<A>) => Effect<void, E, R>;
-    <A, B, E, R>(self: RA.NonEmptyReadonlyArray<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
+    <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;
-    } | undefined): Effect<RA.NonEmptyArray<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?: false | undefined;
-    } | undefined): Effect<Array<B>, E, R>;
+    } | 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;
@@ -909,7 +904,7 @@ export interface Adapter {
     <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _A, _E, _R>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => Effect<_A, _E, _R>): Effect<_A, _E, _R>;
 }
 /**
- * Returns a effect that will never produce anything. The moral equivalent of
+ * Returns an effect that will never produce anything. The moral equivalent of
  * `while(true) {}`, only without the wasted CPU cycles.
  *
  * @since 2.0.0
@@ -2128,9 +2123,8 @@ export declare const timedWith: {
     <A, E, R, E1, R1>(self: Effect<A, E, R>, nanoseconds: Effect<bigint, E1, R1>): Effect<[Duration.Duration, A], E | E1, R | R1>;
 };
 /**
- * Returns an effect that will timeout this effect, returning `None` if the
- * timeout elapses before the effect has produced a value; and returning
- * `Some` of the produced value otherwise.
+ * Returns an effect that will timeout this effect, failing with a `Cause.TimeoutException`
+ * if the timeout elapses before the effect has produced a value.
  *
  * If the timeout elapses without producing a value, the running effect will
  * be safely interrupted.
@@ -2150,6 +2144,29 @@ export declare const timeout: {
     (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutException, R>;
     <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, Cause.TimeoutException | E, R>;
 };
+/**
+ * Returns an effect that will timeout this effect, returning `None` if the
+ * timeout elapses before the effect has produced a value; and returning
+ * `Some` of the produced value otherwise.
+ *
+ * If the timeout elapses without producing a value, the running effect will
+ * be safely interrupted.
+ *
+ * WARNING: The effect returned by this method will not itself return until
+ * the underlying effect is actually interrupted. This leads to more
+ * predictable resource utilization. If early return is desired, then instead
+ * of using `effect.timeout(d)`, use `effect.disconnect.timeout(d)`, which
+ * first disconnects the effect's interruption signal before performing the
+ * timeout, resulting in earliest possible return, before an underlying effect
+ * has been successfully interrupted.
+ *
+ * @since 3.1.0
+ * @category delays & timeouts
+ */
+export declare const timeoutOption: {
+    (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<Option.Option<A>, E, R>;
+};
 /**
  * The same as `timeout`, but instead of producing a `None` in the event of
  * timeout, it will produce the specified error.
@@ -3245,6 +3262,27 @@ export declare const annotateLogs: {
     <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
     <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
 };
+/**
+ * Annotates each log with the specified log annotation(s), until the Scope is closed.
+ *
+ * @since 3.1.0
+ * @category logging
+ * @example
+ * import { Effect } from "effect"
+ *
+ * Effect.gen(function*() {
+ *   yield* Effect.log("no annotations")
+ *   yield* Effect.annotateLogsScoped({ foo: "bar" })
+ *   yield* Effect.log("annotated with foo=bar")
+ * }).pipe(
+ *   Effect.scoped,
+ *   Effect.andThen(Effect.log("no annotations again"))
+ * )
+ */
+export declare const annotateLogsScoped: {
+    (key: string, value: unknown): Effect<void, never, Scope.Scope>;
+    (values: Record<string, unknown>): Effect<void, never, Scope.Scope>;
+};
 /**
  * Retrieves the log annotations associated with the current scope.
  *
@@ -3806,13 +3844,7 @@ export declare const linkSpans: {
  * @since 2.0.0
  * @category tracing
  */
-export declare const makeSpan: (name: string, options?: {
-    readonly attributes?: Record<string, unknown> | undefined;
-    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-    readonly parent?: Tracer.AnySpan | undefined;
-    readonly root?: boolean | undefined;
-    readonly context?: Context.Context<never> | undefined;
-}) => Effect<Tracer.Span>;
+export declare const makeSpan: (name: string, options?: Tracer.SpanOptions) => Effect<Tracer.Span>;
 /**
  * Create a new span for tracing, and automatically close it when the Scope
  * finalizes.
@@ -3823,13 +3855,7 @@ export declare const makeSpan: (name: string, options?: {
  * @since 2.0.0
  * @category tracing
  */
-export declare const makeSpanScoped: (name: string, options?: {
-    readonly attributes?: Record<string, unknown> | undefined;
-    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-    readonly parent?: Tracer.AnySpan | undefined;
-    readonly root?: boolean | undefined;
-    readonly context?: Context.Context<never> | undefined;
-} | undefined) => Effect<Tracer.Span, never, Scope.Scope>;
+export declare const makeSpanScoped: (name: string, options?: Tracer.SpanOptions | undefined) => Effect<Tracer.Span, never, Scope.Scope>;
 /**
  * Create a new span for tracing, and automatically close it when the effect
  * completes.
@@ -3842,13 +3868,7 @@ export declare const makeSpanScoped: (name: string, options?: {
  */
 export declare const useSpan: {
     <A, E, R>(name: string, evaluate: (span: Tracer.Span) => Effect<A, E, R>): Effect<A, E, R>;
-    <A, E, R>(name: string, options: {
-        readonly attributes?: Record<string, unknown> | undefined;
-        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-        readonly parent?: Tracer.AnySpan | undefined;
-        readonly root?: boolean | undefined;
-        readonly context?: Context.Context<never> | undefined;
-    }, evaluate: (span: Tracer.Span) => Effect<A, E, R>): Effect<A, E, R>;
+    <A, E, R>(name: string, options: Tracer.SpanOptions, evaluate: (span: Tracer.Span) => Effect<A, E, R>): Effect<A, E, R>;
 };
 /**
  * Wraps the effect with a new span for tracing.
@@ -3857,20 +3877,8 @@ export declare const useSpan: {
  * @category tracing
  */
 export declare const withSpan: {
-    (name: string, options?: {
-        readonly attributes?: Record<string, unknown> | undefined;
-        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-        readonly parent?: Tracer.AnySpan | undefined;
-        readonly root?: boolean | undefined;
-        readonly context?: Context.Context<never> | undefined;
-    } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
-    <A, E, R>(self: Effect<A, E, R>, name: string, options?: {
-        readonly attributes?: Record<string, unknown> | undefined;
-        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-        readonly parent?: Tracer.AnySpan | undefined;
-        readonly root?: boolean | undefined;
-        readonly context?: Context.Context<never> | undefined;
-    } | undefined): Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+    (name: string, options?: Tracer.SpanOptions | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Effect<A, E, R>, name: string, options?: Tracer.SpanOptions | undefined): Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * Wraps the effect with a new span for tracing.
@@ -3881,20 +3889,8 @@ export declare const withSpan: {
  * @category tracing
  */
 export declare const withSpanScoped: {
-    (name: string, options?: {
-        readonly attributes?: Record<string, unknown> | undefined;
-        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-        readonly parent?: Tracer.AnySpan | undefined;
-        readonly root?: boolean | undefined;
-        readonly context?: Context.Context<never> | undefined;
-    }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
-    <A, E, R>(self: Effect<A, E, R>, name: string, options?: {
-        readonly attributes?: Record<string, unknown> | undefined;
-        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
-        readonly parent?: Tracer.AnySpan | undefined;
-        readonly root?: boolean | undefined;
-        readonly context?: Context.Context<never> | undefined;
-    }): Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
+    (name: string, options?: Tracer.SpanOptions): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
+    <A, E, R>(self: Effect<A, E, R>, name: string, options?: Tracer.SpanOptions): Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
 };
 /**
  * Adds the provided span to the current span stack.