effect 3.13.0 → 3.13.2

package/src/Micro.ts

@@ -1370,10 +1370,7 @@ export const andThen: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: A) => X
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: (a: A) => X): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
     : Micro<X, E, R>
   /**
    * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
@@ -1386,10 +1383,7 @@ export const andThen: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
     : Micro<X, E, R>
 } = dual(
   2,
@@ -1445,10 +1439,7 @@ export const tap: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: NoInfer<A>) => X
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
     : Micro<A, E, R>
   /**
    * Execute a side effect from the success value of the `Micro` effect.
@@ -1459,10 +1450,7 @@ export const tap: {
    * @experimental
    * @category mapping & sequencing
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+  <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
     : Micro<A, E, R>
 } = dual(
   2,
@@ -2048,9 +2036,7 @@ export const updateContext: {
    * @experimental
    * @category environment
    */
-  <R2, R>(
-    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
-  ): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
+  <R2, R>(f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
   /**
    * Update the Context with the given mapping function.
    *
@@ -2068,30 +2054,28 @@ export const updateContext: {
     self: Micro<A, E, R>,
     f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Micro<A, E, R2> =>
-    withMicroFiber<
-      /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      A, /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      E, /**
-       * Update the Context with the given mapping function.
-       *
-       * @since 3.11.0
-       * @experimental
-       * @category environment
-       */
-      R2
-    >((fiber) => {
+    withMicroFiber</**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    A, /**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    E, /**
+     * Update the Context with the given mapping function.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category environment
+     */
+    R2>((fiber) => {
       const prev = fiber.context as Context.Context<R2>
       fiber.context = f(prev)
       return onExit(
@@ -2256,10 +2240,7 @@ export const provideServiceEffect: {
    * @experimental
    * @category environment
    */
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
+  <I, S, E2, R2>(tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
   /**
    * Create a service using the provided `Micro` effect, and add it to the
    * current context.
@@ -2268,11 +2249,7 @@ export const provideServiceEffect: {
    * @experimental
    * @category environment
    */
-  <A, E, R, I, S, E2, R2>(
-    self: Micro<A, E, R>,
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): Micro<A, E | E2, Exclude<R, I> | R2>
+  <A, E, R, I, S, E2, R2>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): Micro<A, E | E2, Exclude<R, I> | R2>
 } = dual(
   3,
   <A, E, R, I, S, E2, R2>(
@@ -2620,10 +2597,7 @@ export const filterOrFail: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, B extends A, E2>(
-    refinement: Refinement<A, B>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
+  <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
   /**
    * Filter the specified effect with the provided function, failing with specified
    * error if the predicate fails.
@@ -2635,10 +2609,7 @@ export const filterOrFail: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, E2>(
-    predicate: Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
+  <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
   /**
    * Filter the specified effect with the provided function, failing with specified
    * error if the predicate fails.
@@ -2688,9 +2659,7 @@ export const when: {
    * @experimental
    * @category filtering & conditionals
    */
-  <E2 = never, R2 = never>(
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>
+  <E2 = never, R2 = never>(condition: LazyArg<boolean> | Micro<boolean, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>
   /**
    * The moral equivalent of `if (p) exp`.
    *
@@ -2698,10 +2667,7 @@ export const when: {
    * @experimental
    * @category filtering & conditionals
    */
-  <A, E, R, E2 = never, R2 = never>(
-    self: Micro<A, E, R>,
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): Micro<Option.Option<A>, E | E2, R | R2>
+  <A, E, R, E2 = never, R2 = never>(self: Micro<A, E, R>, condition: LazyArg<boolean> | Micro<boolean, E2, R2>): Micro<Option.Option<A>, E | E2, R | R2>
 } = dual(
   2,
   <A, E, R, E2 = never, R2 = never>(
@@ -3206,9 +3172,7 @@ export const catchAllCause: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
+  <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
   // ----------------------------------------------------------------------------
   // error handling
   // ----------------------------------------------------------------------------
@@ -3399,9 +3363,7 @@ export const tapErrorCause: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
+  <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
   /**
    * Perform a side effect using the full `MicroCause` object of the given `Micro`.
    *
@@ -3438,10 +3400,7 @@ export const tapErrorCauseIf: {
    * @experimental
    * @category error handling
    */
-  <E, B, E2, R2, EB extends MicroCause<E>>(
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (a: EB) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
+  <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
   /**
    * Perform a side effect using if a `MicroCause` object matches the specified
    * predicate.
@@ -3564,10 +3523,7 @@ export const catchIf: {
    * @experimental
    * @category error handling
    */
-  <E, EB extends E, A2, E2, R2>(
-    refinement: Refinement<NoInfer<E>, EB>,
-    f: (e: EB) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
+  <E, EB extends E, A2, E2, R2>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
   /**
    * Catch any expected errors that match the specified predicate.
    *
@@ -3575,10 +3531,7 @@ export const catchIf: {
    * @experimental
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    predicate: Predicate<NoInfer<E>>,
-    f: (e: NoInfer<E>) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
+  <E, A2, E2, R2>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
   /**
    * Catch any expected errors that match the specified predicate.
    *
@@ -3632,10 +3585,7 @@ export const catchTag: {
    * @experimental
    * @category error handling
    */
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   /**
    * Recovers from the specified tagged error.
    *
@@ -4521,9 +4471,7 @@ export const onExit: {
    * @experimental
    * @category resources & finalization
    */
-  <A, E, XE, XR>(
-    f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
+  <A, E, XE, XR>(f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
   /**
    * When the `Micro` effect is completed, run the given finalizer effect with the
    * `MicroExit` of the executed effect.
@@ -4664,9 +4612,7 @@ export const onError: {
    * @experimental
    * @category resources & finalization
    */
-  <A, E, XE, XR>(
-    f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
+  <A, E, XE, XR>(f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
   /**
    * When the `Micro` effect fails, run the given finalizer effect with the
    * `MicroCause` of the executed effect.
@@ -5240,10 +5186,7 @@ export const bind: {
    * @experimental
    * @category do notation
    */
-  <N extends string, A extends Record<string, any>, B, E2, R2>(
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
+  <N extends string, A extends Record<string, any>, B, E2, R2>(name: N, f: (a: NoInfer<A>) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
   /**
    * Bind the success value of this `Micro` effect to the provided name.
    *
@@ -5251,11 +5194,7 @@ export const bind: {
    * @experimental
    * @category do notation
    */
-  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(
-    self: Micro<A, E, R>,
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
+  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(self: Micro<A, E, R>, name: N, f: (a: NoInfer<A>) => Micro<B, E2, R2>): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
 } = doNotation.bind<MicroTypeLambda>(map, flatMap)
 
 const let_: {

package/src/MutableHashMap.ts

@@ -376,10 +376,7 @@ export const modifyAt: {
    *
    * @since 2.0.0
    */
-  <K, V>(
-    key: K,
-    f: (value: Option.Option<V>) => Option.Option<V>
-  ) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
   /**
    * Set or remove the specified key in the `MutableHashMap` using the specified
    * update function.

package/src/Option.ts

@@ -2889,7 +2889,7 @@ export const partitionMap: {
  *
  * // Transform and filter numbers
  * const transformEven = (n: Option.Option<number>): Option.Option<string> =>
- *   Option.flatMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
+ *   Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
  *
  * console.log(transformEven(Option.none()))
  * // Output: { _id: 'Option', _tag: 'None' }
@@ -2927,7 +2927,7 @@ export const filterMap: {
    *
    * // Transform and filter numbers
    * const transformEven = (n: Option.Option<number>): Option.Option<string> =>
-   *   Option.flatMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
+   *   Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
    *
    * console.log(transformEven(Option.none()))
    * // Output: { _id: 'Option', _tag: 'None' }
@@ -2965,7 +2965,7 @@ export const filterMap: {
    *
    * // Transform and filter numbers
    * const transformEven = (n: Option.Option<number>): Option.Option<string> =>
-   *   Option.flatMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
+   *   Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none()))
    *
    * console.log(transformEven(Option.none()))
    * // Output: { _id: 'Option', _tag: 'None' }
@@ -3919,10 +3919,7 @@ export const bind: {
    * @category Do notation
    * @since 2.0.0
    */
-  <N extends string, A extends object, B>(
-    name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Option<B>
-  ): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+  <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Option<B>): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   /**
    * 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`.
    *

package/src/ParseResult.ts

@@ -318,17 +318,12 @@ export const flatMap: {
    * @category optimisation
    * @since 3.10.0
    */
-  <A, B, E1, R1>(
-    f: (a: A) => Effect.Effect<B, E1, R1>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E1 | E, R1 | R>
+  <A, B, E1, R1>(f: (a: A) => Effect.Effect<B, E1, R1>): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E1 | E, R1 | R>
   /**
    * @category optimisation
    * @since 3.10.0
    */
-  <A, E, R, B, E1, R1>(
-    self: Effect.Effect<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E1, R1>
-  ): Effect.Effect<B, E | E1, R | R1>
+  <A, E, R, B, E1, R1>(self: Effect.Effect<A, E, R>, f: (a: A) => Effect.Effect<B, E1, R1>): Effect.Effect<B, E | E1, R | R1>
 } = dual(2, <A, E, R, B, E1, R1>(
   self: Effect.Effect<A, E, R>,
   f: (a: A) => Effect.Effect<B, E1, R1>
@@ -431,17 +426,12 @@ export const orElse: {
    * @category optimisation
    * @since 3.10.0
    */
-  <E, A2, E2, R2>(
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E2, R2 | R>
+  <E, A2, E2, R2>(f: (e: E) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E2, R2 | R>
   /**
    * @category optimisation
    * @since 3.10.0
    */
-  <A, E, R, A2, E2, R2>(
-    self: Effect.Effect<A, E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Effect.Effect<A2 | A, E2, R2 | R>
+  <A, E, R, A2, E2, R2>(self: Effect.Effect<A, E, R>, f: (e: E) => Effect.Effect<A2, E2, R2>): Effect.Effect<A2 | A, E2, R2 | R>
 } = dual(2, <A, E, R, A2, E2, R2>(
   self: Effect.Effect<A, E, R>,
   f: (e: E) => Effect.Effect<A2, E2, R2>

package/src/Predicate.ts

@@ -1040,9 +1040,7 @@ export const tuple: {
    *
    * @since 2.0.0
    */
-  <T extends ReadonlyArray<Predicate.Any>>(
-    ...elements: T
-  ): [Extract<T[number], Refinement.Any>] extends [never] ? Predicate<{ readonly [I in keyof T]: Predicate.In<T[I]> }>
+  <T extends ReadonlyArray<Predicate.Any>>(...elements: T): [Extract<T[number], Refinement.Any>] extends [never] ? Predicate<{ readonly [I in keyof T]: Predicate.In<T[I]> }>
     : Refinement<
       { readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.In<T[I]> : Predicate.In<T[I]> },
       { readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.Out<T[I]> : Predicate.In<T[I]> }
@@ -1068,9 +1066,7 @@ export const struct: {
    *
    * @since 2.0.0
    */
-  <R extends Record<string, Predicate.Any>>(
-    fields: R
-  ): [Extract<R[keyof R], Refinement.Any>] extends [never] ?
+  <R extends Record<string, Predicate.Any>>(fields: R): [Extract<R[keyof R], Refinement.Any>] extends [never] ?
     Predicate<{ readonly [K in keyof R]: Predicate.In<R[K]> }> :
     Refinement<
       { readonly [K in keyof R]: R[K] extends Refinement.Any ? Refinement.In<R[K]> : Predicate.In<R[K]> },

package/src/RcMap.ts

@@ -113,11 +113,11 @@ export const make: {
    * ```
    */
   <K, A, E, R>(
-    options: {
-      readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
-      readonly capacity?: undefined
-    }
+   options: {
+     readonly lookup: (key: K) => Effect.Effect<A, E, R>
+     readonly idleTimeToLive?: Duration.DurationInput | undefined
+     readonly capacity?: undefined
+   }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
   /**
    * An `RcMap` can contain multiple reference counted resources that can be indexed
@@ -153,11 +153,11 @@ export const make: {
    * ```
    */
   <K, A, E, R>(
-    options: {
-      readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
-      readonly capacity: number
-    }
+   options: {
+     readonly lookup: (key: K) => Effect.Effect<A, E, R>
+     readonly idleTimeToLive?: Duration.DurationInput | undefined
+     readonly capacity: number
+   }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>
 } = internal.make