effect 3.13.0 → 3.13.2

package/src/Logger.ts

@@ -140,17 +140,12 @@ export const mapInput: {
    * @since 2.0.0
    * @category mapping
    */
-  <Message, Message2>(
-    f: (message: Message2) => Message
-  ): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
+  <Message, Message2>(f: (message: Message2) => Message): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
   /**
    * @since 2.0.0
    * @category mapping
    */
-  <Output, Message, Message2>(
-    self: Logger<Message, Output>,
-    f: (message: Message2) => Message
-  ): Logger<Message2, Output>
+  <Output, Message, Message2>(self: Logger<Message, Output>, f: (message: Message2) => Message): Logger<Message2, Output>
 } = internal.mapInput
 
 /**
@@ -162,16 +157,14 @@ export const mapInputOptions: {
    * @since 2.0.0
    * @category mapping
    */
-  <Message, Message2>(
-    f: (options: Logger.Options<Message2>) => Logger.Options<Message>
-  ): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
+  <Message, Message2>(f: (options: Logger.Options<Message2>) => Logger.Options<Message>): <Output>(self: Logger<Message, Output>) => Logger<Message2, Output>
   /**
    * @since 2.0.0
    * @category mapping
    */
   <Output, Message, Message2>(
-    self: Logger<Message, Output>,
-    f: (options: Logger.Options<Message2>) => Logger.Options<Message>
+   self: Logger<Message, Output>,
+   f: (options: Logger.Options<Message2>) => Logger.Options<Message>
   ): Logger<Message2, Output>
 } = internal.mapInputOptions
 
@@ -190,9 +183,7 @@ export const filterLogLevel: {
    * @since 2.0.0
    * @category filtering
    */
-  (
-    f: (logLevel: LogLevel.LogLevel) => boolean
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Option.Option<Output>>
+  (f: (logLevel: LogLevel.LogLevel) => boolean): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Option.Option<Output>>
   /**
    * Returns a version of this logger that only logs messages when the log level
    * satisfies the specified predicate.
@@ -200,10 +191,7 @@ export const filterLogLevel: {
    * @since 2.0.0
    * @category filtering
    */
-  <Message, Output>(
-    self: Logger<Message, Output>,
-    f: (logLevel: LogLevel.LogLevel) => boolean
-  ): Logger<Message, Option.Option<Output>>
+  <Message, Output>(self: Logger<Message, Output>, f: (logLevel: LogLevel.LogLevel) => boolean): Logger<Message, Option.Option<Output>>
 } = internal.filterLogLevel
 
 /**
@@ -215,9 +203,7 @@ export const map: {
    * @since 2.0.0
    * @category mapping
    */
-  <Output, Output2>(
-    f: (output: Output) => Output2
-  ): <Message>(self: Logger<Message, Output>) => Logger<Message, Output2>
+  <Output, Output2>(f: (output: Output) => Output2): <Message>(self: Logger<Message, Output>) => Logger<Message, Output2>
   /**
    * @since 2.0.0
    * @category mapping
@@ -295,8 +281,8 @@ export const batched: {
    * @category mapping
    */
   <Output, R>(
-    window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+   window: DurationInput,
+   f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
   ): <Message>(self: Logger<Message, Output>) => Effect<Logger<Message, void>, never, R | Scope>
   /**
    * Creates a batched logger that groups log messages together and processes them
@@ -333,9 +319,9 @@ export const batched: {
    * @category mapping
    */
   <Message, Output, R>(
-    self: Logger<Message, Output>,
-    window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+   self: Logger<Message, Output>,
+   window: DurationInput,
+   f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
   ): Effect<Logger<Message, void>, never, Scope | R>
 } = fiberRuntime.batchedLogger
 
@@ -432,17 +418,12 @@ export const replaceScoped: {
    * @since 2.0.0
    * @category context
    */
-  <B, E, R>(
-    that: Effect<Logger<unknown, B>, E, R>
-  ): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
+  <B, E, R>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
   /**
    * @since 2.0.0
    * @category context
    */
-  <A, B, E, R>(
-    self: Logger<unknown, A>,
-    that: Effect<Logger<unknown, B>, E, R>
-  ): Layer.Layer<never, E, Exclude<R, Scope>>
+  <A, B, E, R>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>
 } = circular.replaceLoggerScoped
 
 /**
@@ -558,9 +539,7 @@ export const zip: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, [Output, Output2]>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, [Output, Output2]>
   /**
    * Combines this logger with the specified logger to produce a new logger that
    * logs to both this logger and that logger.
@@ -568,10 +547,7 @@ export const zip: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, [Output, Output2]>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, [Output, Output2]>
 } = internal.zip
 
 /**
@@ -583,17 +559,12 @@ export const zipLeft: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output>
   /**
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, Output>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output>
 } = internal.zipLeft
 
 /**
@@ -605,17 +576,12 @@ export const zipRight: {
    * @since 2.0.0
    * @category zipping
    */
-  <Message2, Output2>(
-    that: Logger<Message2, Output2>
-  ): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output2>
+  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message & Message2, Output2>
   /**
    * @since 2.0.0
    * @category zipping
    */
-  <Message, Output, Message2, Output2>(
-    self: Logger<Message, Output>,
-    that: Logger<Message2, Output2>
-  ): Logger<Message & Message2, Output2>
+  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<Message & Message2, Output2>
 } = internal.zipRight
 
 /**

package/src/Mailbox.ts

@@ -275,10 +275,10 @@ export const fromStream: {
    * @category conversions
    */
   (
-    options?: {
-      readonly capacity?: number | undefined
-      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-    }
+   options?: {
+     readonly capacity?: number | undefined
+     readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+   }
   ): <A, E, R>(self: Stream<A, E, R>) => Effect<ReadonlyMailbox<A, E>, never, R | Scope>
   /**
    * Create a `ReadonlyMailbox` from a `Stream`.
@@ -288,10 +288,10 @@ export const fromStream: {
    * @category conversions
    */
   <A, E, R>(
-    self: Stream<A, E, R>,
-    options?: {
-      readonly capacity?: number | undefined
-      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
-    }
+   self: Stream<A, E, R>,
+   options?: {
+     readonly capacity?: number | undefined
+     readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+   }
   ): Effect<ReadonlyMailbox<A, E>, never, R | Scope>
 } = internal.fromStream

package/src/MergeDecision.ts

@@ -84,20 +84,20 @@ export const match: {
    * @category folding
    */
   <R, E0, Z0, E, Z, Z2>(
-    options: {
-      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
-    }
+   options: {
+     readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+     readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
+   }
   ): (self: MergeDecision<R, E0, Z0, E, Z>) => Z2
   /**
    * @since 2.0.0
    * @category folding
    */
   <R, E0, Z0, E, Z, Z2>(
-    self: MergeDecision<R, E0, Z0, E, Z>,
-    options: {
-      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
-    }
+   self: MergeDecision<R, E0, Z0, E, Z>,
+   options: {
+     readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+     readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
+   }
   ): Z2
 } = internal.match

package/src/MergeStrategy.ts

@@ -103,10 +103,10 @@ export const match: {
    * @category folding
    */
   <A>(
-    options: {
-      readonly onBackPressure: () => A
-      readonly onBufferSliding: () => A
-    }
+   options: {
+     readonly onBackPressure: () => A
+     readonly onBufferSliding: () => A
+   }
   ): (self: MergeStrategy) => A
   /**
    * Folds an `MergeStrategy` into a value of type `A`.
@@ -115,10 +115,10 @@ export const match: {
    * @category folding
    */
   <A>(
-    self: MergeStrategy,
-    options: {
-      readonly onBackPressure: () => A
-      readonly onBufferSliding: () => A
-    }
+   self: MergeStrategy,
+   options: {
+     readonly onBackPressure: () => A
+     readonly onBufferSliding: () => A
+   }
   ): A
 } = internal.match

package/src/Metric.ts

@@ -720,9 +720,7 @@ export const taggedWithLabelsInput: {
    * @since 2.0.0
    * @category utils
    */
-  <In>(
-    f: (input: In) => Iterable<MetricLabel.MetricLabel>
-  ): <Type, Out>(self: Metric<Type, In, Out>) => Metric<Type, In, void>
+  <In>(f: (input: In) => Iterable<MetricLabel.MetricLabel>): <Type, Out>(self: Metric<Type, In, Out>) => Metric<Type, In, void>
   /**
    * Returns a new metric, which is identical in every way to this one, except
    * dynamic tags are added based on the update values. Note that the metric
@@ -811,9 +809,7 @@ export const trackAll: {
    * @since 2.0.0
    * @category aspects
    */
-  <In>(
-    input: In
-  ): <Type, Out>(self: Metric<Type, In, Out>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <In>(input: In): <Type, Out>(self: Metric<Type, In, Out>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the specified constant
    * value every time the aspect is applied to an effect, regardless of whether
@@ -822,10 +818,7 @@ export const trackAll: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    self: Metric<Type, In, Out>,
-    input: In
-  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(self: Metric<Type, In, Out>, input: In): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 } = internal.trackAll
 
 /**
@@ -871,10 +864,7 @@ export const trackDefectWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>,
-    f: (defect: unknown) => In
-  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>, f: (defect: unknown) => In): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the defect throwables of the effects that the
@@ -907,9 +897,7 @@ export const trackDuration: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, Out>(
-    metric: Metric<Type, Duration.Duration, Out>
-  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, Out>(metric: Metric<Type, Duration.Duration, Out>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the duration that the
    * effect takes to execute. To call this method, the input type of the metric
@@ -918,10 +906,7 @@ export const trackDuration: {
    * @since 2.0.0
    * @category aspects
    */
-  <A, E, R, Type, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, Duration.Duration, Out>
-  ): Effect.Effect<A, E, R>
+  <A, E, R, Type, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, Duration.Duration, Out>): Effect.Effect<A, E, R>
 } = internal.trackDuration
 
 /**
@@ -941,10 +926,7 @@ export const trackDurationWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>,
-    f: (duration: Duration.Duration) => In
-  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>, f: (duration: Duration.Duration) => In): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the duration that the
    * effect takes to execute. To call this method, you must supply a function
@@ -975,9 +957,7 @@ export const trackError: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>
-  ): <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>): <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the failure value of
    * the effects that it is applied to.
@@ -985,10 +965,7 @@ export const trackError: {
    * @since 2.0.0
    * @category aspects
    */
-  <A, E extends In, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, In, Out>
-  ): Effect.Effect<A, E, R>
+  <A, E extends In, R, Type, In, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, In, Out>): Effect.Effect<A, E, R>
 } = internal.trackError
 
 /**
@@ -1008,10 +985,7 @@ export const trackErrorWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out, In2>(
-    metric: Metric<Type, In, Out>,
-    f: (error: In2) => In
-  ): <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out, In2>(metric: Metric<Type, In, Out>, f: (error: In2) => In): <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the error value of the effects that the aspect is
@@ -1042,9 +1016,7 @@ export const trackSuccess: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out>(
-    metric: Metric<Type, In, Out>
-  ): <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out>(metric: Metric<Type, In, Out>): <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the success value of
    * the effects that it is applied to.
@@ -1052,10 +1024,7 @@ export const trackSuccess: {
    * @since 2.0.0
    * @category aspects
    */
-  <A extends In, E, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric<Type, In, Out>
-  ): Effect.Effect<A, E, R>
+  <A extends In, E, R, Type, In, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, In, Out>): Effect.Effect<A, E, R>
 } = internal.trackSuccess
 
 /**
@@ -1075,10 +1044,7 @@ export const trackSuccessWith: {
    * @since 2.0.0
    * @category aspects
    */
-  <Type, In, Out, In2>(
-    metric: Metric<Type, In, Out>,
-    f: (value: In2) => In
-  ): <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <Type, In, Out, In2>(metric: Metric<Type, In, Out>, f: (value: In2) => In): <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * Returns an aspect that will update this metric with the result of applying
    * the specified function to the success value of the effects that the aspect is

package/src/MetricKey.ts

@@ -232,21 +232,14 @@ export const tagged: {
    * @since 2.0.0
    * @category constructors
    */
-  (
-    key: string,
-    value: string
-  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
+  (key: string, value: string): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
   /**
    * Returns a new `MetricKey` with the specified tag appended.
    *
    * @since 2.0.0
    * @category constructors
    */
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey<Type>,
-    key: string,
-    value: string
-  ): MetricKey<Type>
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>, key: string, value: string): MetricKey<Type>
 } = internal.tagged
 
 /**
@@ -262,17 +255,12 @@ export const taggedWithLabels: {
    * @since 2.0.0
    * @category constructors
    */
-  (
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
+  (extraTags: ReadonlyArray<MetricLabel.MetricLabel>): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
   /**
    * Returns a new `MetricKey` with the specified tags appended.
    *
    * @since 2.0.0
    * @category constructors
    */
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey<Type>,
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ): MetricKey<Type>
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): MetricKey<Type>
 } = internal.taggedWithLabels

package/src/MetricPolling.ts

@@ -127,9 +127,7 @@ export const retry: {
    * @since 2.0.0
    * @category constructors
    */
-  <X, E, R2>(
-    policy: Schedule.Schedule<X, NoInfer<E>, R2>
-  ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
+  <X, E, R2>(policy: Schedule.Schedule<X, NoInfer<E>, R2>): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
   /**
    * Returns a new polling metric whose poll function will be retried with the
    * specified retry policy.