effect 3.13.1 → 3.13.3

package/src/SchemaAST.ts

@@ -1075,7 +1075,7 @@ export class Enums implements Annotated {
   toString() {
     return Option.getOrElse(
       getExpected(this),
-      () => `<enum ${this.enums.length} value(s): ${this.enums.map((_, value) => JSON.stringify(value)).join(" | ")}>`
+      () => `<enum ${this.enums.length} value(s): ${this.enums.map(([_, value]) => JSON.stringify(value)).join(" | ")}>`
     )
   }
   /**

package/src/Sink.ts

@@ -336,19 +336,14 @@ export const mapInputEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In, E2, R2>(
-    f: (input: In0) => Effect.Effect<In, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
+  <In0, In, E2, R2>(f: (input: In0) => Effect.Effect<In, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's input elements.
    *
    * @since 2.0.0
    * @category mapping
    */
-  <A, In, L, E, R, In0, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (input: In0) => Effect.Effect<In, E2, R2>
-  ): Sink<A, In0, L, E | E2, R | R2>
+  <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In0) => Effect.Effect<In, E2, R2>): Sink<A, In0, L, E | E2, R | R2>
 } = internal.mapInputEffect
 
 /**
@@ -364,9 +359,7 @@ export const mapInputChunks: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In>(
-    f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>
+  <In0, In>(f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>
   /**
    * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
    *
@@ -394,9 +387,7 @@ export const mapInputChunksEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <In0, In, E2, R2>(
-    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
+  <In0, In, E2, R2>(f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's input chunks. `f` must preserve
    * chunking-invariance.
@@ -648,9 +639,7 @@ export const ensuring: {
    * @since 2.0.0
    * @category finalization
    */
-  <X, R2>(
-    finalizer: Effect.Effect<X, never, R2>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
+  <X, R2>(finalizer: Effect.Effect<X, never, R2>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
   /**
    * Returns a new sink with an attached finalizer. The finalizer is guaranteed
    * to be executed so long as the sink begins execution (and regardless of
@@ -679,9 +668,7 @@ export const ensuringWith: {
    * @since 2.0.0
    * @category finalization
    */
-  <A, E, X, R2>(
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
-  ): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
+  <A, E, X, R2>(finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
   /**
    * Returns a new sink with an attached finalizer. The finalizer is guaranteed
    * to be executed so long as the sink begins execution (and regardless of
@@ -787,9 +774,7 @@ export const filterInput: {
    * @since 2.0.0
    * @category filtering
    */
-  <In, In1 extends In, In2 extends In1>(
-    f: Refinement<In1, In2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>
+  <In, In1 extends In, In2 extends In1>(f: Refinement<In1, In2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>
   /**
    * Filters the sink's input with the given predicate.
    *
@@ -812,9 +797,7 @@ export const filterInputEffect: {
    * @since 2.0.0
    * @category filtering
    */
-  <In, In1 extends In, E2, R2>(
-    f: (input: In1) => Effect.Effect<boolean, E2, R2>
-  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>
+  <In, In1 extends In, E2, R2>(f: (input: In1) => Effect.Effect<boolean, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>
   /**
    * Effectfully filter the input of this sink using the specified predicate.
    *
@@ -840,19 +823,14 @@ export const findEffect: {
    * @since 2.0.0
    * @category elements
    */
-  <A, E2, R2>(
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option.Option<A>, In, L, E2 | E, R2 | R>
+  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option.Option<A>, In, L, E2 | E, R2 | R>
   /**
    * Creates a sink that produces values until one verifies the predicate `f`.
    *
    * @since 2.0.0
    * @category elements
    */
-  <A, In, L extends In, E, R, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Sink<Option.Option<A>, In, L, E | E2, R | R2>
+  <A, In, L extends In, E, R, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Sink<Option.Option<A>, In, L, E | E2, R | R2>
 } = internal.findEffect as any
 
 /**
@@ -1190,9 +1168,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A1, In, In1 extends In, L1, E1, R1>(
-    f: (a: A) => Sink<A1, In1, L1, E1, R1>
-  ): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>
+  <A, A1, In, In1 extends In, L1, E1, R1>(f: (a: A) => Sink<A1, In1, L1, E1, R1>): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>
   /**
    * Runs this sink until it yields a result, then uses that result to create
    * another sink from the provided function which will continue to run until it
@@ -1203,10 +1179,7 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Sink<A1, In1, L1, E1, R1>
-  ): Sink<A1, In & In1, L | L1, E | E1, R | R1>
+  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(self: Sink<A, In, L, E, R>, f: (a: A) => Sink<A1, In1, L1, E1, R1>): Sink<A1, In & In1, L | L1, E | E1, R | R1>
 } = internal.flatMap
 
 /**
@@ -1350,19 +1323,14 @@ export const mapEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, A2, E2, R2>(
-    f: (a: A) => Effect.Effect<A2, E2, R2>
-  ): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (a: A) => Effect.Effect<A2, E2, R2>): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>
   /**
    * Effectfully transforms this sink's result.
    *
    * @since 2.0.0
    * @category mapping
    */
-  <A, In, L, E, R, A2, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    f: (a: A) => Effect.Effect<A2, E2, R2>
-  ): Sink<A2, In, L, E | E2, R | R2>
+  <A, In, L, E, R, A2, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>): Sink<A2, In, L, E | E2, R | R2>
 } = internal.mapEffect
 
 /**
@@ -1440,19 +1408,14 @@ export const orElse: {
    * @since 2.0.0
    * @category error handling
    */
-  <A2, In2, L2, E2, R2>(
-    that: LazyArg<Sink<A2, In2, L2, E2, R2>>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>
+  <A2, In2, L2, E2, R2>(that: LazyArg<Sink<A2, In2, L2, E2, R2>>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>
   /**
    * Switch to another sink in case of failure
    *
    * @since 2.0.0
    * @category error handling
    */
-  <A, In, L, E, R, A2, In2, L2, E2, R2>(
-    self: Sink<A, In, L, E, R>,
-    that: LazyArg<Sink<A2, In2, L2, E2, R2>>
-  ): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>
+  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: LazyArg<Sink<A2, In2, L2, E2, R2>>): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>
 } = internal.orElse
 
 /**
@@ -1496,9 +1459,7 @@ export const race: {
    * @since 2.0.0
    * @category utils
    */
-  <R1, E1, In1, L1, A1>(
-    that: Sink<A1, In1, L1, E1, R1>
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
+  <R1, E1, In1, L1, A1>(that: Sink<A1, In1, L1, E1, R1>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
   /**
    * Runs both sinks in parallel on the input, , returning the result or the
    * error from the one that finishes first.
@@ -1506,10 +1467,7 @@ export const race: {
    * @since 2.0.0
    * @category utils
    */
-  <A, In, L, E, R, A1, In1, L1, E1, R1>(
-    self: Sink<A, In, L, E, R>,
-    that: Sink<A1, In1, L1, E1, R1>
-  ): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>
+  <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>
 } = internal.race
 
 /**
@@ -1612,10 +1570,7 @@ export const refineOrDieWith: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, E2>(
-    pf: (error: E) => Option.Option<E2>,
-    f: (error: E) => unknown
-  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>
+  <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>
   /**
    * @since 2.0.0
    * @category error handling
@@ -1695,10 +1650,7 @@ export const summarized: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, E2, R2, A3>(
-    summary: Effect.Effect<A2, E2, R2>,
-    f: (start: A2, end: A2) => A3
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>
+  <A2, E2, R2, A3>(summary: Effect.Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>
   /**
    * Summarize a sink by running an effect when the sink starts and again when
    * it completes.

package/src/SortedMap.ts

@@ -334,9 +334,7 @@ export const partition: {
    * @since 3.1.0
    * @category filtering
    */
-  <K, V>(
-    predicate: (a: Types.NoInfer<K>) => boolean
-  ): (self: SortedMap<K, V>) => [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
+  <K, V>(predicate: (a: Types.NoInfer<K>) => boolean): (self: SortedMap<K, V>) => [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
   /**
    * @since 3.1.0
    * @category filtering