effect 3.11.1 → 3.11.3

package/dist/esm/Micro.js

@@ -95,7 +95,7 @@ class MicroCauseImpl extends globalThis.Error {
     return this.stack;
   }
 }
-class FailImpl extends MicroCauseImpl {
+class Fail extends MicroCauseImpl {
   error;
   constructor(error, traces = []) {
     super("Fail", error, traces);
@@ -107,8 +107,8 @@ class FailImpl extends MicroCauseImpl {
  * @experimental
  * @category MicroCause
  */
-export const causeFail = (error, traces = []) => new FailImpl(error, traces);
-class DieImpl extends MicroCauseImpl {
+export const causeFail = (error, traces = []) => new Fail(error, traces);
+class Die extends MicroCauseImpl {
   defect;
   constructor(defect, traces = []) {
     super("Die", defect, traces);
@@ -120,8 +120,8 @@ class DieImpl extends MicroCauseImpl {
  * @experimental
  * @category MicroCause
  */
-export const causeDie = (defect, traces = []) => new DieImpl(defect, traces);
-class InterruptImpl extends MicroCauseImpl {
+export const causeDie = (defect, traces = []) => new Die(defect, traces);
+class Interrupt extends MicroCauseImpl {
   constructor(traces = []) {
     super("Interrupt", "interrupted", traces);
   }
@@ -131,7 +131,7 @@ class InterruptImpl extends MicroCauseImpl {
  * @experimental
  * @category MicroCause
  */
-export const causeInterrupt = (traces = []) => new InterruptImpl(traces);
+export const causeInterrupt = (traces = []) => new Interrupt(traces);
 /**
  * @since 3.4.6
  * @experimental
@@ -173,22 +173,22 @@ export const causeWithTrace = /*#__PURE__*/dual(2, (self, trace) => {
   }
 });
 // ----------------------------------------------------------------------------
-// Fiber
+// MicroFiber
 // ----------------------------------------------------------------------------
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export const FiberTypeId = /*#__PURE__*/Symbol.for("effect/Micro/Fiber");
+export const MicroFiberTypeId = /*#__PURE__*/Symbol.for("effect/Micro/MicroFiber");
 const fiberVariance = {
   _A: identity,
   _E: identity
 };
-class FiberImpl {
+class MicroFiberImpl {
   context;
   interruptible;
-  [FiberTypeId];
+  [MicroFiberTypeId];
   _stack = [];
   _observers = [];
   _exit;
@@ -197,7 +197,7 @@ class FiberImpl {
   constructor(context, interruptible = true) {
     this.context = context;
     this.interruptible = interruptible;
-    this[FiberTypeId] = fiberVariance;
+    this[MicroFiberTypeId] = fiberVariance;
   }
   getRef(ref) {
     return InternalContext.unsafeGetReference(this.context, ref);
@@ -276,7 +276,7 @@ class FiberImpl {
       }
     } catch (error) {
       if (!hasProperty(current, evaluate)) {
-        return exitDie(`Micro/Fiber.runLoop: Not a valid effect: ${String(current)}`);
+        return exitDie(`MicroFiber.runLoop: Not a valid effect: ${String(current)}`);
       }
       return exitDie(error);
     }
@@ -314,13 +314,19 @@ const fiberInterruptChildren = fiber => {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
 export const fiberAwait = self => async(resume => sync(self.addObserver(exit => resume(succeed(exit)))));
+/**
+ * @since 3.11.2
+ * @experimental
+ * @category MicroFiber
+ */
+export const fiberJoin = self => flatten(fiberAwait(self));
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
 export const fiberInterrupt = self => suspend(() => {
   self.unsafeInterrupt();
@@ -329,7 +335,7 @@ export const fiberInterrupt = self => suspend(() => {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
 export const fiberInterruptAll = fibers => suspend(() => {
   for (const fiber of fibers) fiber.unsafeInterrupt();
@@ -376,7 +382,7 @@ const MicroProto = {
   },
   toJSON() {
     return {
-      _id: "effect/Micro",
+      _id: "Micro",
       op: this[identifier],
       ...(args in this ? {
         args: this[args]
@@ -419,7 +425,7 @@ const makeExit = options => {
     },
     toJSON() {
       return {
-        _id: "effect/Micro/Exit",
+        _id: "MicroExit",
         _tag: options.op,
         [options.prop]: this[args]
       };
@@ -474,10 +480,10 @@ export const failCause = /*#__PURE__*/makeExit({
   }
 });
 /**
- * Creates a `Micro` effect that will fail with the specified error.
+ * Creates a `Micro` effect that fails with the given error.
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * This results in a `Fail` variant of the `MicroCause` type, where the error is
+ * tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -485,10 +491,10 @@ export const failCause = /*#__PURE__*/makeExit({
  */
 export const fail = error => failCause(causeFail(error));
 /**
- * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ * Creates a `Micro` effect that succeeds with a lazily evaluated value.
  *
- * If the evaluation of the value throws an error, the effect will fail with
- * `CauseDie`.
+ * If the evaluation of the value throws an error, the effect will fail with a
+ * `Die` variant of the `MicroCause` type.
  *
  * @since 3.4.0
  * @experimental
@@ -546,7 +552,7 @@ export const yieldNowWith = /*#__PURE__*/makePrimitive({
  */
 export const yieldNow = /*#__PURE__*/yieldNowWith(0);
 /**
- * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ * Creates a `Micro` effect that will succeed with the value wrapped in `Some`.
  *
  * @since 3.4.0
  * @experimental
@@ -554,7 +560,7 @@ export const yieldNow = /*#__PURE__*/yieldNowWith(0);
  */
 export const succeedSome = a => succeed(Option.some(a));
 /**
- * Creates a `Micro` effect that will succeed with `Option.None`.
+ * Creates a `Micro` effect that succeeds with `None`.
  *
  * @since 3.4.0
  * @experimental
@@ -572,8 +578,8 @@ export const failCauseSync = evaluate => suspend(() => failCause(evaluate()));
 /**
  * Creates a `Micro` effect that will die with the specified error.
  *
- * This will result in a `CauseDie`, where the error is not tracked at
- * the type level.
+ * This results in a `Die` variant of the `MicroCause` type, where the error is
+ * not tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -583,8 +589,8 @@ export const die = defect => exitDie(defect);
 /**
  * Creates a `Micro` effect that will fail with the lazily evaluated error.
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * This results in a `Fail` variant of the `MicroCause` type, where the error is
+ * tracked at the type level.
  *
  * @since 3.4.6
  * @experimental
@@ -633,9 +639,6 @@ export {
  * The `Micro` equivalent of a try / catch block, which allows you to map
  * thrown errors to a specific error type.
  *
- * @since 3.4.0
- * @experimental
- * @category constructors
  * @example
  * ```ts
  * import { Micro } from "effect"
@@ -645,11 +648,17 @@ export {
  *   catch: (cause) => new Error("caught", { cause })
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
  */
 try_ as try };
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
- * `CauseDie`.
+ * Wrap a `Promise` into a `Micro` effect.
+ *
+ * Any errors will result in a `Die` variant of the `MicroCause` type, where the
+ * error is not tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -662,9 +671,6 @@ export const promise = evaluate => asyncOptions(function (resume, signal) {
  * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
  * converted into a specific error type.
  *
- * @since 3.4.0
- * @experimental
- * @category constructors
  * @example
  * ```ts
  * import { Micro } from "effect"
@@ -674,6 +680,10 @@ export const promise = evaluate => asyncOptions(function (resume, signal) {
  *   catch: (cause) => new Error("caught", { cause })
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
  */
 export const tryPromise = options => asyncOptions(function (resume, signal) {
   try {
@@ -683,14 +693,14 @@ export const tryPromise = options => asyncOptions(function (resume, signal) {
   }
 }, options.try.length !== 0);
 /**
- * Create a `Micro` effect using the current `Fiber`.
+ * Create a `Micro` effect using the current `MicroFiber`.
  *
  * @since 3.4.0
  * @experimental
  * @category constructors
  */
-export const withFiber = /*#__PURE__*/makePrimitive({
-  op: "WithFiber",
+export const withMicroFiber = /*#__PURE__*/makePrimitive({
+  op: "WithMicroFiber",
   eval(fiber) {
     return this[args](fiber);
   }
@@ -702,7 +712,7 @@ export const withFiber = /*#__PURE__*/makePrimitive({
  * @experimental
  * @category constructors
  */
-export const yieldFlush = /*#__PURE__*/withFiber(fiber => {
+export const yieldFlush = /*#__PURE__*/withMicroFiber(fiber => {
   fiber.getRef(CurrentScheduler).flush();
   return exitVoid;
 });
@@ -806,7 +816,7 @@ const fromIterator = /*#__PURE__*/makePrimitive({
  */
 export const as = /*#__PURE__*/dual(2, (self, value) => map(self, _ => value));
 /**
- * Wrap the success value of this `Micro` effect in an `Option.Some`.
+ * Wrap the success value of this `Micro` effect in a `Some`.
  *
  * @since 3.4.0
  * @experimental
@@ -825,11 +835,11 @@ export const flip = self => matchEffect(self, {
   onSuccess: fail
 });
 /**
- * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
- * a single api.
+ * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+ * single API.
  *
- * It also allows you to pass in a `Micro` effect directly, which will be
- * executed after the current effect.
+ * It also lets you directly pass a `Micro` effect, which will be executed after
+ * the current effect.
  *
  * @since 3.4.0
  * @experimental
@@ -888,7 +898,7 @@ export const sandbox = self => catchAllCause(self, fail);
  * @experimental
  * @category sequencing
  */
-export const raceAll = all => withFiber(parent => async(resume => {
+export const raceAll = all => withMicroFiber(parent => async(resume => {
   const effects = Arr.fromIterable(all);
   const len = effects.length;
   let doneCount = 0;
@@ -921,13 +931,13 @@ export const raceAll = all => withFiber(parent => async(resume => {
 /**
  * Returns an effect that races all the specified effects,
  * yielding the value of the first effect to succeed or fail. Losers of
- * the race will be interrupted immediately
+ * the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
  * @category sequencing
  */
-export const raceAllFirst = all => withFiber(parent => async(resume => {
+export const raceAllFirst = all => withMicroFiber(parent => async(resume => {
   let done = false;
   const fibers = new Set();
   const onExit = exit => {
@@ -947,7 +957,7 @@ export const raceAllFirst = all => withFiber(parent => async(resume => {
 }));
 /**
  * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed. Losers of the race will be interrupted immediately
+ * effect to succeed. Losers of the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
@@ -956,7 +966,7 @@ export const raceAllFirst = all => withFiber(parent => async(resume => {
 export const race = /*#__PURE__*/dual(2, (self, that) => raceAll([self, that]));
 /**
  * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+ * effect to succeed *or* fail. Losers of the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
@@ -1147,7 +1157,7 @@ export class MicroSchedulerDefault {
  * @experimental
  * @category environment
  */
-export const service = tag => withFiber(fiber => succeed(Context.unsafeGet(fiber.context, tag)));
+export const service = tag => withMicroFiber(fiber => succeed(Context.unsafeGet(fiber.context, tag)));
 /**
  * Access the given `Context.Tag` from the environment, without tracking the
  * dependency at the type level.
@@ -1159,7 +1169,7 @@ export const service = tag => withFiber(fiber => succeed(Context.unsafeGet(fiber
  * @experimental
  * @category environment
  */
-export const serviceOption = tag => withFiber(fiber => succeed(Context.getOption(fiber.context, tag)));
+export const serviceOption = tag => withMicroFiber(fiber => succeed(Context.getOption(fiber.context, tag)));
 /**
  * Update the Context with the given mapping function.
  *
@@ -1167,7 +1177,7 @@ export const serviceOption = tag => withFiber(fiber => succeed(Context.getOption
  * @experimental
  * @category environment
  */
-export const updateContext = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber => {
+export const updateContext = /*#__PURE__*/dual(2, (self, f) => withMicroFiber(fiber => {
   const prev = fiber.context;
   fiber.context = f(prev);
   return onExit(self, () => {
@@ -1182,7 +1192,7 @@ export const updateContext = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber =
  * @experimental
  * @category environment
  */
-export const updateService = /*#__PURE__*/dual(3, (self, tag, f) => withFiber(fiber => {
+export const updateService = /*#__PURE__*/dual(3, (self, tag, f) => withMicroFiber(fiber => {
   const prev = Context.unsafeGet(fiber.context, tag);
   fiber.context = Context.add(fiber.context, tag, f(prev));
   return onExit(self, () => {
@@ -1198,7 +1208,7 @@ export const updateService = /*#__PURE__*/dual(3, (self, tag, f) => withFiber(fi
  * @category environment
  */
 export const context = () => getContext;
-const getContext = /*#__PURE__*/withFiber(fiber => succeed(fiber.context));
+const getContext = /*#__PURE__*/withMicroFiber(fiber => succeed(fiber.context));
 /**
  * Merge the given `Context` with the current context.
  *
@@ -1255,10 +1265,8 @@ export class CurrentScheduler extends /*#__PURE__*/Context.Reference()("effect/M
  * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
  * api to control the concurrency of that `Micro` when it is run.
  *
- * @since 3.4.0
- * @experimental
- * @category environment refs
  * @example
+ * ```ts
  * import * as Micro from "effect/Micro"
  *
  * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
@@ -1266,6 +1274,11 @@ export class CurrentScheduler extends /*#__PURE__*/Context.Reference()("effect/M
  * }).pipe(
  *   Micro.withConcurrency(2) // use a concurrency of 2
  * )
+ * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
  */
 export const withConcurrency = /*#__PURE__*/dual(2, (self, concurrency) => provideService(self, CurrentConcurrency, concurrency));
 // ----------------------------------------------------------------------------
@@ -1509,7 +1522,7 @@ export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchAl
 /**
  * Catch the error of the given `Micro` effect, allowing you to recover from it.
  *
- * It only catches expected (`MicroCause.Fail`) errors.
+ * It only catches expected errors.
  *
  * @since 3.4.6
  * @experimental
@@ -2014,7 +2027,7 @@ export const interrupt = /*#__PURE__*/failCause( /*#__PURE__*/causeInterrupt());
  * @experimental
  * @category flags
  */
-export const uninterruptible = self => withFiber(fiber => {
+export const uninterruptible = self => withMicroFiber(fiber => {
   if (!fiber.interruptible) return self;
   fiber.interruptible = false;
   fiber._stack.push(setInterruptible(true));
@@ -2037,7 +2050,7 @@ const setInterruptible = /*#__PURE__*/makePrimitive({
  * @experimental
  * @category flags
  */
-export const interruptible = self => withFiber(fiber => {
+export const interruptible = self => withMicroFiber(fiber => {
   if (fiber.interruptible) return self;
   fiber.interruptible = true;
   fiber._stack.push(setInterruptible(false));
@@ -2051,9 +2064,6 @@ export const interruptible = self => withFiber(fiber => {
  * You can use the `restore` function to restore a `Micro` effect to the
  * interruptibility state before the `uninterruptibleMask` was applied.
  *
- * @since 3.4.0
- * @experimental
- * @category interruption
  * @example
  * ```ts
  * import * as Micro from "effect/Micro"
@@ -2064,8 +2074,12 @@ export const interruptible = self => withFiber(fiber => {
  *   )
  * )
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
  */
-export const uninterruptibleMask = f => withFiber(fiber => {
+export const uninterruptibleMask = f => withMicroFiber(fiber => {
   if (!fiber.interruptible) return f(identity);
   fiber.interruptible = false;
   fiber._stack.push(setInterruptible(true));
@@ -2120,19 +2134,20 @@ export const whileLoop = /*#__PURE__*/makePrimitive({
   }
 });
 /**
- * For each element of the provided iterable, run the effect and collect the results.
+ * For each element of the provided iterable, run the effect and collect the
+ * results.
  *
  * If the `discard` option is set to `true`, the results will be discarded and
  * the effect will return `void`.
  *
- * The `concurrency` option can be set to control how many effects are run in
- * parallel. By default, the effects are run sequentially.
+ * The `concurrency` option can be set to control how many effects are run
+ * concurrently. By default, the effects are run sequentially.
  *
  * @since 3.4.0
  * @experimental
  * @category collecting & elements
  */
-export const forEach = (iterable, f, options) => withFiber(parent => {
+export const forEach = (iterable, f, options) => withMicroFiber(parent => {
   const concurrencyOption = options?.concurrency === "inherit" ? parent.getRef(CurrentConcurrency) : options?.concurrency ?? 1;
   const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
   const items = Arr.fromIterable(iterable);
@@ -2206,7 +2221,8 @@ export const forEach = (iterable, f, options) => withFiber(parent => {
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental
@@ -2219,7 +2235,8 @@ export const filter = (iterable, f, options) => filterMap(iterable, a => map(f(a
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental
@@ -2277,21 +2294,21 @@ let_ as let };
 // fibers & forking
 // ----------------------------------------------------------------------------
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * When the parent `Micro` finishes, this `Micro` will be aborted.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
-export const fork = self => withFiber(fiber => {
+export const fork = self => withMicroFiber(fiber => {
   fiberMiddleware.interruptChildren ??= fiberInterruptChildren;
   return succeed(unsafeFork(fiber, self));
 });
 const unsafeFork = (parent, effect, immediate = false, daemon = false) => {
-  const child = new FiberImpl(parent.context, parent.interruptible);
+  const child = new MicroFiberImpl(parent.context, parent.interruptible);
   if (!daemon) {
     parent.children().add(child);
     child.addObserver(() => parent.children().delete(child));
@@ -2304,51 +2321,48 @@ const unsafeFork = (parent, effect, immediate = false, daemon = false) => {
   return child;
 };
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * It will not be aborted when the parent `Micro` finishes.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
-export const forkDaemon = self => withFiber(fiber => succeed(unsafeFork(fiber, self, false, true)));
+export const forkDaemon = self => withMicroFiber(fiber => succeed(unsafeFork(fiber, self, false, true)));
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * The lifetime of the handle will be attached to the provided `MicroScope`.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
 export const forkIn = /*#__PURE__*/dual(2, (self, scope) => uninterruptibleMask(restore => flatMap(scope.fork, scope => tap(restore(forkDaemon(onExit(self, exit => scope.close(exit)))), fiber => scope.addFinalizer(_ => fiberInterrupt(fiber))))));
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * The lifetime of the handle will be attached to the current `MicroScope`.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
 export const forkScoped = self => flatMap(scope, scope => forkIn(self, scope));
 // ----------------------------------------------------------------------------
 // execution
 // ----------------------------------------------------------------------------
 /**
- * Execute the `Micro` effect and return a `Handle` that can be awaited, joined,
+ * Execute the `Micro` effect and return a `MicroFiber` that can be awaited, joined,
  * or aborted.
  *
  * You can listen for the result by adding an observer using the handle's
  * `addObserver` method.
  *
- * @since 3.4.0
- * @experimental
- * @category execution
  * @example
  * ```ts
  * import * as Micro from "effect/Micro"
@@ -2362,9 +2376,13 @@ export const forkScoped = self => flatMap(scope, scope => forkIn(self, scope));
  *   console.log(exit)
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
  */
 export const runFork = (effect, options) => {
-  const fiber = new FiberImpl(CurrentScheduler.context(options?.scheduler ?? new MicroSchedulerDefault()));
+  const fiber = new MicroFiberImpl(CurrentScheduler.context(options?.scheduler ?? new MicroSchedulerDefault()));
   fiber.evaluate(effect);
   if (options?.signal) {
     if (options.signal.aborted) {
@@ -2409,7 +2427,7 @@ export const runPromise = (effect, options) => runPromiseExit(effect, options).t
  * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`.
  *
  * If any asynchronous effects are encountered, the function will return a
- * `CauseDie` containing the `Handle`.
+ * `CauseDie` containing the `MicroFiber`.
  *
  * @since 3.4.6
  * @experimental