effect 3.0.8 → 3.1.1

package/dist/dts/Effect.d.ts

@@ -2123,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.
@@ -2145,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.
@@ -3240,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.
  *
@@ -3801,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.
@@ -3818,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.
@@ -3837,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.
@@ -3852,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.
@@ -3876,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.