effect 3.13.1 → 3.13.2

package/src/StreamHaltStrategy.ts

@@ -115,12 +115,12 @@ export const match: {
    * @category folding
    */
   <Z>(
-    options: {
-      readonly onLeft: () => Z
-      readonly onRight: () => Z
-      readonly onBoth: () => Z
-      readonly onEither: () => Z
-    }
+   options: {
+     readonly onLeft: () => Z
+     readonly onRight: () => Z
+     readonly onBoth: () => Z
+     readonly onEither: () => Z
+   }
   ): (self: HaltStrategy) => Z
   /**
    * Folds over the specified `HaltStrategy` using the provided case functions.
@@ -129,12 +129,12 @@ export const match: {
    * @category folding
    */
   <Z>(
-    self: HaltStrategy,
-    options: {
-      readonly onLeft: () => Z
-      readonly onRight: () => Z
-      readonly onBoth: () => Z
-      readonly onEither: () => Z
-    }
+   self: HaltStrategy,
+   options: {
+     readonly onLeft: () => Z
+     readonly onRight: () => Z
+     readonly onBoth: () => Z
+     readonly onEither: () => Z
+   }
   ): Z
 } = internal.match

package/src/Struct.ts

@@ -53,10 +53,7 @@ export const pick: {
    *
    * @since 2.0.0
    */
-  <S extends object, Keys extends Array<keyof S>>(
-    s: S,
-    ...keys: Keys
-  ): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
+  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
 } = dual(
   (args) => Predicate.isObject(args[0]),
   <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
@@ -97,9 +94,7 @@ export const omit: {
    *
    * @since 2.0.0
    */
-  <Keys extends Array<PropertyKey>>(
-    ...keys: Keys
-  ): <S extends { [K in Keys[number]]?: any }>(s: S) => Simplify<Omit<S, Keys[number]>>
+  <Keys extends Array<PropertyKey>>(...keys: Keys): <S extends { [K in Keys[number]]?: any }>(s: S) => Simplify<Omit<S, Keys[number]>>
   /**
    * Create a new object by omitting properties of an existing object.
    *

package/src/Subscribable.ts

@@ -83,9 +83,7 @@ export const mapEffect: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, B, E2, R2>(
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
-  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  <A, B, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
   /**
    * @since 2.0.0
    * @category combinators

package/src/SubscriptionRef.ts

@@ -395,9 +395,7 @@ export const updateSomeEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
+  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
   /**
    * @since 2.0.0
    * @category utils

package/src/SynchronizedRef.ts

@@ -159,8 +159,8 @@ export const getAndUpdateSomeEffect: {
    * @category utils
    */
   <A, R, E>(
-    self: SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+   self: SynchronizedRef<A>,
+   pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
   ): Effect.Effect<A, E, R>
 } = internal.getAndUpdateSomeEffect
 
@@ -196,8 +196,8 @@ export const modifyEffect: {
    * @category utils
    */
   <A, B, E, R>(
-    self: SynchronizedRef<A>,
-    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+   self: SynchronizedRef<A>,
+   f: (a: A) => Effect.Effect<readonly [B, A], E, R>
   ): Effect.Effect<B, E, R>
 } = internal.modifyEffect
 
@@ -216,9 +216,9 @@ export const modifySome: {
    * @category utils
    */
   <A, B>(
-    self: Ref.Ref<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
+   self: Ref.Ref<A>,
+   fallback: B,
+   pf: (a: A) => Option.Option<readonly [B, A]>
   ): Effect.Effect<B>
 } = ref.modifySome
 
@@ -232,17 +232,17 @@ export const modifySomeEffect: {
    * @category utils
    */
   <A, B, R, E>(
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+   fallback: B,
+   pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
   ): (self: SynchronizedRef<A>) => Effect.Effect<B, E, R>
   /**
    * @since 2.0.0
    * @category utils
    */
   <A, B, R, E>(
-    self: SynchronizedRef<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+   self: SynchronizedRef<A>,
+   fallback: B,
+   pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
   ): Effect.Effect<B, E, R>
 } = internal.modifySomeEffect
 
@@ -374,16 +374,14 @@ export const updateSomeEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: SynchronizedRef<A>) => Effect.Effect<void, E, R>
+  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: SynchronizedRef<A>) => Effect.Effect<void, E, R>
   /**
    * @since 2.0.0
    * @category utils
    */
   <A, R, E>(
-    self: SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+   self: SynchronizedRef<A>,
+   pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
   ): Effect.Effect<void, E, R>
 } = internal.updateSomeEffect
 
@@ -419,8 +417,8 @@ export const updateSomeAndGetEffect: {
    * @category utils
    */
   <A, R, E>(
-    self: SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+   self: SynchronizedRef<A>,
+   pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
   ): Effect.Effect<A, E, R>
 } = circular.updateSomeAndGetEffectSynchronized
 

package/src/TArray.ts

@@ -399,10 +399,7 @@ export const findFirstIndexWhereFromSTM: {
    * @since 2.0.0
    * @category elements
    */
-  <A, R, E>(
-    predicate: (value: A) => STM.STM<boolean, E, R>,
-    from: number
-  ): (self: TArray<A>) => STM.STM<Option.Option<number>, E, R>
+  <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>, from: number): (self: TArray<A>) => STM.STM<Option.Option<number>, E, R>
   /**
    * Starting at specified index, get the index of the next entry that matches a
    * transactional predicate.
@@ -411,9 +408,9 @@ export const findFirstIndexWhereFromSTM: {
    * @category elements
    */
   <A, R, E>(
-    self: TArray<A>,
-    predicate: (value: A) => STM.STM<boolean, E, R>,
-    from: number
+   self: TArray<A>,
+   predicate: (value: A) => STM.STM<boolean, E, R>,
+   from: number
   ): STM.STM<Option.Option<number>, E, R>
 } = internal.findFirstIndexWhereFromSTM
 
@@ -760,9 +757,9 @@ export const reduceSTM: {
    * @category folding
    */
   <Z, A, R, E>(
-    self: TArray<A>,
-    zero: Z,
-    f: (accumulator: Z, current: A) => STM.STM<Z, E, R>
+   self: TArray<A>,
+   zero: Z,
+   f: (accumulator: Z, current: A) => STM.STM<Z, E, R>
   ): STM.STM<Z, E, R>
 } = internal.reduceSTM
 

package/src/TMap.ts

@@ -107,9 +107,7 @@ export const findSTM: {
    * @since 2.0.0
    * @category elements
    */
-  <K, V, A, E, R>(
-    f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ): (self: TMap<K, V>) => STM.STM<Option.Option<A>, E, R>
+  <K, V, A, E, R>(f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<Option.Option<A>, E, R>
   /**
    * Finds the key/value pair matching the specified predicate, and uses the
    * provided effectful function to extract a value out of it.
@@ -117,10 +115,7 @@ export const findSTM: {
    * @since 2.0.0
    * @category elements
    */
-  <K, V, A, E, R>(
-    self: TMap<K, V>,
-    f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ): STM.STM<Option.Option<A>, E, R>
+  <K, V, A, E, R>(self: TMap<K, V>, f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<Option.Option<A>, E, R>
 } = internal.findSTM
 
 /**
@@ -164,9 +159,7 @@ export const findAllSTM: {
    * @since 2.0.0
    * @category elements
    */
-  <K, V, A, E, R>(
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ): (self: TMap<K, V>) => STM.STM<Array<A>, E, R>
+  <K, V, A, E, R>(pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<Array<A>, E, R>
   /**
    * Finds all the key/value pairs matching the specified predicate, and uses
    * the provided effectful function to extract values out of them..
@@ -701,9 +694,7 @@ export const takeSomeSTM: {
    * @since 2.0.0
    * @category mutations
    */
-  <K, V, A, E, R>(
-    pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
-  ): (self: TMap<K, V>) => STM.STM<[A, ...Array<A>], E, R>
+  <K, V, A, E, R>(pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<[A, ...Array<A>], E, R>
   /**
    * Takes all matching values, or retries until there is at least one.
    *

package/src/TSubscriptionRef.ts

@@ -156,9 +156,9 @@ export const modifySome: {
    * @category mutations
    */
   <A, B>(
-    self: TSubscriptionRef<A>,
-    fallback: B,
-    f: (a: A) => Option.Option<readonly [B, A]>
+   self: TSubscriptionRef<A>,
+   fallback: B,
+   f: (a: A) => Option.Option<readonly [B, A]>
   ): STM.STM<B>
 } = internal.modifySome
 

package/src/Take.ts

@@ -209,11 +209,11 @@ export const match: {
    * @category destructors
    */
   <Z, E, Z2, A, Z3>(
-    options: {
-      readonly onEnd: () => Z
-      readonly onFailure: (cause: Cause.Cause<E>) => Z2
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
-    }
+   options: {
+     readonly onEnd: () => Z
+     readonly onFailure: (cause: Cause.Cause<E>) => Z2
+     readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+   }
   ): (self: Take<A, E>) => Z | Z2 | Z3
   /**
    * Folds over the failure cause, success value and end-of-stream marker to
@@ -223,12 +223,12 @@ export const match: {
    * @category destructors
    */
   <A, E, Z, Z2, Z3>(
-    self: Take<A, E>,
-    options: {
-      readonly onEnd: () => Z
-      readonly onFailure: (cause: Cause.Cause<E>) => Z2
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
-    }
+   self: Take<A, E>,
+   options: {
+     readonly onEnd: () => Z
+     readonly onFailure: (cause: Cause.Cause<E>) => Z2
+     readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+   }
   ): Z | Z2 | Z3
 } = internal.match
 
@@ -252,11 +252,11 @@ export const matchEffect: {
    * @category destructors
    */
   <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
-    options: {
-      readonly onEnd: Effect.Effect<Z, E2, R>
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
-    }
+   options: {
+     readonly onEnd: Effect.Effect<Z, E2, R>
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
+     readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
+   }
   ): (self: Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
   /**
    * Effectful version of `Take.fold`.
@@ -268,12 +268,12 @@ export const matchEffect: {
    * @category destructors
    */
   <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
-    self: Take<A, E>,
-    options: {
-      readonly onEnd: Effect.Effect<Z, E2, R>
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
-    }
+   self: Take<A, E>,
+   options: {
+     readonly onEnd: Effect.Effect<Z, E2, R>
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
+     readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
+   }
   ): Effect.Effect<Z | Z2 | Z3, E | E2 | E3, R | R2 | R3>
 } = internal.matchEffect
 
@@ -298,17 +298,12 @@ export const tap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, X, E2, R>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
-  ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
+  <A, X, E2, R>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
   /**
    * Returns an effect that effectfully "peeks" at the success of this take.
    *
    * @since 2.0.0
    * @category sequencing
    */
-  <A, E, X, E2, R>(
-    self: Take<A, E>,
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
-  ): Effect.Effect<void, E | E2, R>
+  <A, E, X, E2, R>(self: Take<A, E>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>): Effect.Effect<void, E | E2, R>
 } = internal.tap

package/src/TestServices.ts

@@ -242,9 +242,7 @@ export const provideWithLive = dual<
    *
    * @since 2.0.0
    */
-  <A, E, R, A2, E2, R2>(
-    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A2, E2, R2>
-  ) => (self: Effect.Effect<A, E, R>) => Effect.Effect<A2, E | E2, R | R2>,
+  <A, E, R, A2, E2, R2>(f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A2, E2, R2>) => (self: Effect.Effect<A, E, R>) => Effect.Effect<A2, E | E2, R | R2>,
   /**
    * Runs a transformation function with the live default Effect services while
    * ensuring that the workflow itself is run with the test services.

package/src/Unify.ts

@@ -104,9 +104,7 @@ export const unify: {
     Args2 extends Array<any>,
     Args3 extends Array<any>,
     T
-  >(
-    x: (...args: Args) => (...args: Args2) => (...args: Args3) => T
-  ): (...args: Args) => (...args: Args2) => (...args: Args3) => Unify<T>
+  >(x: (...args: Args) => (...args: Args2) => (...args: Args3) => T): (...args: Args) => (...args: Args2) => (...args: Args3) => Unify<T>
   /**
    * @since 2.0.0
    */

package/src/UpstreamPullRequest.ts

@@ -108,10 +108,10 @@ export const match: {
    * @category folding
    */
   <A, Z>(
-    options: {
-      readonly onPulled: (value: A) => Z
-      readonly onNoUpstream: (activeDownstreamCount: number) => Z
-    }
+   options: {
+     readonly onPulled: (value: A) => Z
+     readonly onNoUpstream: (activeDownstreamCount: number) => Z
+   }
   ): (self: UpstreamPullRequest<A>) => Z
   /**
    * Folds an `UpstreamPullRequest<A>` into a value of type `Z`.
@@ -120,10 +120,10 @@ export const match: {
    * @category folding
    */
   <A, Z>(
-    self: UpstreamPullRequest<A>,
-    options: {
-      readonly onPulled: (value: A) => Z
-      readonly onNoUpstream: (activeDownstreamCount: number) => Z
-    }
+   self: UpstreamPullRequest<A>,
+   options: {
+     readonly onPulled: (value: A) => Z
+     readonly onNoUpstream: (activeDownstreamCount: number) => Z
+   }
   ): Z
 } = internal.match

package/src/UpstreamPullStrategy.ts

@@ -112,10 +112,10 @@ export const match: {
    * @category folding
    */
   <A, Z>(
-    options: {
-      readonly onNext: (emitSeparator: Option.Option<A>) => Z
-      readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
-    }
+   options: {
+     readonly onNext: (emitSeparator: Option.Option<A>) => Z
+     readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
+   }
   ): (self: UpstreamPullStrategy<A>) => Z
   /**
    * Folds an `UpstreamPullStrategy<A>` into a value of type `Z`.
@@ -124,10 +124,10 @@ export const match: {
    * @category folding
    */
   <A, Z>(
-    self: UpstreamPullStrategy<A>,
-    options: {
-      readonly onNext: (emitSeparator: Option.Option<A>) => Z
-      readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
-    }
+   self: UpstreamPullStrategy<A>,
+   options: {
+     readonly onNext: (emitSeparator: Option.Option<A>) => Z
+     readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
+   }
   ): Z
 } = internal.match

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.13.1"
+let moduleVersion = "3.13.2"
 
 export const getCurrentVersion = () => moduleVersion