effect 3.13.1 → 3.13.3

package/src/Either.ts

@@ -828,10 +828,7 @@ export const filterOrLeft: {
    * @since 2.0.0
    * @category filtering & conditionals
    */
-  <R, L2>(
-    predicate: Predicate<NoInfer<R>>,
-    orLeftWith: (right: NoInfer<R>) => L2
-  ): <L>(self: Either<R, L>) => Either<R, L2 | L>
+  <R, L2>(predicate: Predicate<NoInfer<R>>, orLeftWith: (right: NoInfer<R>) => L2): <L>(self: Either<R, L>) => Either<R, L2 | L>
   /**
    * Filter the right value with the provided function.
    * If the predicate fails, set the left value with the result of the provided function.
@@ -1445,10 +1442,7 @@ export const bind: {
    * @category do notation
    * @since 2.0.0
    */
-  <N extends string, A extends object, B, L2>(
-    name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Either<B, L2>
-  ): <L1>(self: Either<A, L1>) => Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
+  <N extends string, A extends object, B, L2>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Either<B, L2>): <L1>(self: Either<A, L1>) => Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
   /**
    * 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/ExecutionStrategy.ts

@@ -114,11 +114,11 @@ export const match: {
    * @category folding
    */
   <A>(
-    options: {
-      readonly onSequential: LazyArg<A>
-      readonly onParallel: LazyArg<A>
-      readonly onParallelN: (n: number) => A
-    }
+   options: {
+     readonly onSequential: LazyArg<A>
+     readonly onParallel: LazyArg<A>
+     readonly onParallelN: (n: number) => A
+   }
   ): (self: ExecutionStrategy) => A
   /**
    * Folds over the specified `ExecutionStrategy` using the provided case
@@ -128,11 +128,11 @@ export const match: {
    * @category folding
    */
   <A>(
-    self: ExecutionStrategy,
-    options: {
-      readonly onSequential: LazyArg<A>
-      readonly onParallel: LazyArg<A>
-      readonly onParallelN: (n: number) => A
-    }
+   self: ExecutionStrategy,
+   options: {
+     readonly onSequential: LazyArg<A>
+     readonly onParallel: LazyArg<A>
+     readonly onParallelN: (n: number) => A
+   }
   ): A
 } = internal.match

package/src/Exit.ts

@@ -258,9 +258,7 @@ export const flatMapEffect: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, E, A2, E2, R>(
-    f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>
-  ): (self: Exit<A, E>) => Effect.Effect<Exit<A2, E>, E2, R>
+  <A, E, A2, E2, R>(f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>): (self: Exit<A, E>) => Effect.Effect<Exit<A2, E>, E2, R>
   /**
    * @since 2.0.0
    * @category sequencing
@@ -387,7 +385,7 @@ export const mapBoth: {
    * @category mapping
    */
   <E, A, E2, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+   options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
   ): (self: Exit<A, E>) => Exit<A2, E2>
   /**
    * Maps over the `Success` and `Failure` cases of the specified exit using the
@@ -397,8 +395,8 @@ export const mapBoth: {
    * @category mapping
    */
   <A, E, E2, A2>(
-    self: Exit<A, E>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+   self: Exit<A, E>,
+   options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
   ): Exit<A2, E2>
 } = core.exitMapBoth
 
@@ -464,15 +462,15 @@ export const match: {
    * @category folding
    */
   <E, A, Z1, Z2>(
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+   options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
   ): (self: Exit<A, E>) => Z1 | Z2
   /**
    * @since 2.0.0
    * @category folding
    */
   <A, E, Z1, Z2>(
-    self: Exit<A, E>,
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+   self: Exit<A, E>,
+   options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
   ): Z1 | Z2
 } = core.exitMatch
 
@@ -486,21 +484,21 @@ export const matchEffect: {
    * @category folding
    */
   <E, A2, E2, R, A, A3, E3, R2>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
-      readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
-    }
+   options: {
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
+     readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
+   }
   ): (self: Exit<A, E>) => Effect.Effect<A2 | A3, E2 | E3, R | R2>
   /**
    * @since 2.0.0
    * @category folding
    */
   <A, E, A2, E2, R, A3, E3, R2>(
-    self: Exit<A, E>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
-      readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
-    }
+   self: Exit<A, E>,
+   options: {
+     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
+     readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
+   }
   ): Effect.Effect<A2 | A3, E2 | E3, R | R2>
 } = core.exitMatchEffect
 
@@ -695,11 +693,11 @@ export const zipWith: {
    * @category zipping
    */
   <B, E2, A, C, E>(
-    that: Exit<B, E2>,
-    options: {
-      readonly onSuccess: (a: A, b: B) => C
-      readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<any>
-    }
+   that: Exit<B, E2>,
+   options: {
+     readonly onSuccess: (a: A, b: B) => C
+     readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<any>
+   }
   ): (self: Exit<A, E>) => Exit<C, any>
   /**
    * Zips this exit together with that exit using the specified combination
@@ -709,11 +707,11 @@ export const zipWith: {
    * @category zipping
    */
   <A, E, B, E2, C>(
-    self: Exit<A, E>,
-    that: Exit<B, E2>,
-    options: {
-      readonly onSuccess: (a: A, b: B) => C
-      readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<E | E2>
-    }
+   self: Exit<A, E>,
+   that: Exit<B, E2>,
+   options: {
+     readonly onSuccess: (a: A, b: B) => C
+     readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<E | E2>
+   }
   ): Exit<C, E | E2>
 } = core.exitZipWith

package/src/Fiber.ts

@@ -668,10 +668,10 @@ export const match: {
    * @category folding
    */
   <A, E, Z>(
-    options: {
-      readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
-    }
+   options: {
+     readonly onFiber: (fiber: Fiber<A, E>) => Z
+     readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
+   }
   ): (self: Fiber<A, E>) => Z
   /**
    * Folds over the `Fiber` or `RuntimeFiber`.
@@ -680,11 +680,11 @@ export const match: {
    * @category folding
    */
   <A, E, Z>(
-    self: Fiber<A, E>,
-    options: {
-      readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
-    }
+   self: Fiber<A, E>,
+   options: {
+     readonly onFiber: (fiber: Fiber<A, E>) => Z
+     readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
+   }
   ): Z
 } = internal.match
 

package/src/FiberHandle.ts

@@ -111,13 +111,17 @@ export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberHandle<A, E
   Effect.acquireRelease(
     Effect.map(Deferred.make<void, E>(), (deferred) => unsafeMake<A, E>(deferred)),
     (handle) =>
-      Effect.zipRight(
-        clear(handle),
-        Effect.suspend(() => {
-          handle.state = { _tag: "Closed" }
-          return Deferred.done(handle.deferred, Exit.void)
-        })
-      )
+      Effect.withFiberRuntime((parent) => {
+        const state = handle.state
+        if (state._tag === "Closed") return Effect.void
+        handle.state = { _tag: "Closed" }
+        return state.fiber ?
+          Effect.intoDeferred(
+            Effect.asVoid(Fiber.interruptAs(state.fiber, FiberId.combine(parent.id(), internalFiberId))),
+            handle.deferred
+          ) :
+          Deferred.done(handle.deferred, Exit.void)
+      })
   )
 
 /**

package/src/FiberMap.ts

@@ -125,13 +125,17 @@ export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A
         deferred
       )),
     (map) =>
-      Effect.zipRight(
-        clear(map),
-        Effect.suspend(() => {
-          map.state = { _tag: "Closed" }
-          return Deferred.done(map.deferred, Exit.void)
-        })
-      )
+      Effect.withFiberRuntime((parent) => {
+        const state = map.state
+        if (state._tag === "Closed") return Effect.void
+        map.state = { _tag: "Closed" }
+        return Fiber.interruptAllAs(
+          Iterable.map(state.backing, ([, fiber]) => fiber),
+          FiberId.combine(parent.id(), internalFiberId)
+        ).pipe(
+          Effect.intoDeferred(map.deferred)
+        )
+      })
   )
 
 /**

package/src/FiberRefsPatch.ts

@@ -132,8 +132,8 @@ export const patch: {
    * @category destructors
    */
   (
-    self: FiberRefsPatch,
-    fiberId: FiberId.Runtime,
-    oldValue: FiberRefs.FiberRefs
+   self: FiberRefsPatch,
+   fiberId: FiberId.Runtime,
+   oldValue: FiberRefs.FiberRefs
   ): FiberRefs.FiberRefs
 } = internal.patch

package/src/FiberSet.ts

@@ -118,13 +118,15 @@ export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>,
   Effect.acquireRelease(
     Effect.map(Deferred.make<void, unknown>(), (deferred) => unsafeMake(new Set(), deferred)),
     (set) =>
-      Effect.zipRight(
-        clear(set),
-        Effect.suspend(() => {
-          set.state = { _tag: "Closed" }
-          return Deferred.done(set.deferred, Exit.void)
-        })
-      )
+      Effect.withFiberRuntime((parent) => {
+        const state = set.state
+        if (state._tag === "Closed") return Effect.void
+        set.state = { _tag: "Closed" }
+        const fibers = state.backing
+        return Fiber.interruptAllAs(fibers, FiberId.combine(parent.id(), internalFiberId)).pipe(
+          Effect.intoDeferred(set.deferred)
+        )
+      })
   )
 
 /**

package/src/Function.ts

@@ -116,10 +116,7 @@ export const dual: {
    *
    * @since 2.0.0
    */
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
-    arity: Parameters<DataFirst>["length"],
-    body: DataFirst
-  ): DataLast & DataFirst
+  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(arity: Parameters<DataFirst>["length"], body: DataFirst): DataLast & DataFirst
   /**
    * Creates a function that can be used in a data-last (aka `pipe`able) or
    * data-first style.
@@ -163,10 +160,7 @@ export const dual: {
    *
    * @since 2.0.0
    */
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
-    isDataFirst: (args: IArguments) => boolean,
-    body: DataFirst
-  ): DataLast & DataFirst
+  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(isDataFirst: (args: IArguments) => boolean, body: DataFirst): DataLast & DataFirst
 } = function(arity, body) {
   if (typeof arity === "function") {
     return function() {

package/src/GroupBy.ts

@@ -67,8 +67,8 @@ export const evaluate: {
    * @category destructors
    */
   <K, V, E, A, E2, R2>(
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
+   f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+   options?: { readonly bufferSize?: number | undefined } | undefined
   ): <R>(self: GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>
   /**
    * Run the function across all groups, collecting the results in an
@@ -78,9 +78,9 @@ export const evaluate: {
    * @category destructors
    */
   <K, V, E, R, A, E2, R2>(
-    self: GroupBy<K, V, E, R>,
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
+   self: GroupBy<K, V, E, R>,
+   f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+   options?: { readonly bufferSize?: number | undefined } | undefined
   ): Stream.Stream<A, E | E2, R | R2>
 } = internal.evaluate
 

package/src/HashSet.ts

@@ -551,9 +551,7 @@ export const partition: {
    * @since 2.0.0
    * @category partitioning
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>
-  ): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
   /**
    * Partition the values of a `HashSet` using the specified predicate.
    *
@@ -575,10 +573,7 @@ export const partition: {
    * @since 2.0.0
    * @category partitioning
    */
-  <A, B extends A>(
-    self: HashSet<A>,
-    refinement: Refinement<A, B>
-  ): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
   /**
    * Partition the values of a `HashSet` using the specified predicate.
    *

package/src/Iterable.ts

@@ -977,9 +977,7 @@ export const groupBy: {
    * @category grouping
    * @since 2.0.0
    */
-  <A, K extends string | symbol>(
-    f: (a: A) => K
-  ): (self: Iterable<A>) => Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  <A, K extends string | symbol>(f: (a: A) => K): (self: Iterable<A>) => Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
   /**
    * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
    * function on each element, and grouping the results according to values returned
@@ -987,10 +985,7 @@ export const groupBy: {
    * @category grouping
    * @since 2.0.0
    */
-  <A, K extends string | symbol>(
-    self: Iterable<A>,
-    f: (a: A) => K
-  ): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  <A, K extends string | symbol>(self: Iterable<A>, f: (a: A) => K): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
 } = dual(2, <A, K extends string | symbol>(
   self: Iterable<A>,
   f: (a: A) => K

package/src/JSONSchema.ts

@@ -635,13 +635,19 @@ const go = (
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
         return { ...constEmpty, ...getJsonSchemaAnnotations(ast) }
       }
+      const output: JsonSchema7Object = {
+        type: "object",
+        required: [],
+        properties: {},
+        additionalProperties: false
+      }
       let patternProperties: JsonSchema7 | undefined = undefined
       let propertyNames: JsonSchema7 | undefined = undefined
       for (const is of ast.indexSignatures) {
         const parameter = is.parameter
         switch (parameter._tag) {
           case "StringKeyword": {
-            patternProperties = go(is.type, $defs, true, path, options)
+            output.additionalProperties = go(is.type, $defs, true, path, options)
             break
           }
           case "TemplateLiteral": {
@@ -661,12 +667,6 @@ const go = (
             throw new Error(errors_.getJSONSchemaUnsupportedParameterErrorMessage(path, parameter))
         }
       }
-      const output: JsonSchema7Object = {
-        type: "object",
-        required: [],
-        properties: {},
-        additionalProperties: false
-      }
       // ---------------------------------------------
       // handle property signatures
       // ---------------------------------------------