effect 3.11.1 → 3.11.2

package/src/Micro.ts

@@ -169,7 +169,15 @@ export const MicroCauseTypeId = Symbol.for("effect/Micro/MicroCause")
 export type MicroCauseTypeId = typeof MicroCauseTypeId
 
 /**
- * A Micro Cause is a data type that represents the different ways a Micro can fail.
+ * A `MicroCause` is a data type that represents the different ways a `Micro` can fail.
+ *
+ * **Details**
+ *
+ * `MicroCause` comes in three forms:
+ *
+ * - `Die`: Indicates an unforeseen defect that wasn't planned for in the system's logic.
+ * - `Fail`: Covers anticipated errors that are recognized and typically handled within the application.
+ * - `Interrupt`: Signifies an operation that has been purposefully stopped.
  *
  * @since 3.4.6
  * @experimental
@@ -290,7 +298,7 @@ abstract class MicroCauseImpl<Tag extends string, E> extends globalThis.Error im
   }
 }
 
-class FailImpl<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E> {
+class Fail<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E> {
   constructor(
     readonly error: E,
     traces: ReadonlyArray<string> = []
@@ -307,9 +315,9 @@ class FailImpl<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E
 export const causeFail = <E>(
   error: E,
   traces: ReadonlyArray<string> = []
-): MicroCause<E> => new FailImpl(error, traces)
+): MicroCause<E> => new Fail(error, traces)
 
-class DieImpl extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
+class Die extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
   constructor(
     readonly defect: unknown,
     traces: ReadonlyArray<string> = []
@@ -326,9 +334,9 @@ class DieImpl extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
 export const causeDie = (
   defect: unknown,
   traces: ReadonlyArray<string> = []
-): MicroCause<never> => new DieImpl(defect, traces)
+): MicroCause<never> => new Die(defect, traces)
 
-class InterruptImpl extends MicroCauseImpl<"Interrupt", never> implements MicroCause.Interrupt {
+class Interrupt extends MicroCauseImpl<"Interrupt", never> implements MicroCause.Interrupt {
   constructor(traces: ReadonlyArray<string> = []) {
     super("Interrupt", "interrupted", traces)
   }
@@ -341,7 +349,7 @@ class InterruptImpl extends MicroCauseImpl<"Interrupt", never> implements MicroC
  */
 export const causeInterrupt = (
   traces: ReadonlyArray<string> = []
-): MicroCause<never> => new InterruptImpl(traces)
+): MicroCause<never> => new Interrupt(traces)
 
 /**
  * @since 3.4.6
@@ -407,30 +415,30 @@ export const causeWithTrace: {
 })
 
 // ----------------------------------------------------------------------------
-// Fiber
+// MicroFiber
 // ----------------------------------------------------------------------------
 
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export const FiberTypeId = Symbol.for("effect/Micro/Fiber")
+export const MicroFiberTypeId = Symbol.for("effect/Micro/MicroFiber")
 
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export type FiberTypeId = typeof FiberTypeId
+export type MicroFiberTypeId = typeof MicroFiberTypeId
 
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export interface Fiber<out A, out E = never> {
-  readonly [FiberTypeId]: Fiber.Variance<A, E>
+export interface MicroFiber<out A, out E = never> {
+  readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>
 
   readonly currentOpCount: number
   readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A
@@ -443,13 +451,13 @@ export interface Fiber<out A, out E = never> {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export declare namespace Fiber {
+export declare namespace MicroFiber {
   /**
    * @since 3.11.0
    * @experimental
-   * @category Fiber
+   * @category MicroFiber
    */
   export interface Variance<out A, out E = never> {
     readonly _A: Covariant<A>
@@ -462,13 +470,13 @@ const fiberVariance = {
   _E: identity
 }
 
-class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
-  readonly [FiberTypeId]: Fiber.Variance<A, E>
+class MicroFiberImpl<in out A = any, in out E = any> implements MicroFiber<A, E> {
+  readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>
 
   readonly _stack: Array<Primitive> = []
   readonly _observers: Array<(exit: MicroExit<A, E>) => void> = []
   _exit: MicroExit<A, E> | undefined
-  public _children: Set<FiberImpl<any, any>> | undefined
+  public _children: Set<MicroFiberImpl<any, any>> | undefined
 
   public currentOpCount = 0
 
@@ -476,7 +484,7 @@ class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
     public context: Context.Context<never>,
     public interruptible = true
   ) {
-    this[FiberTypeId] = fiberVariance
+    this[MicroFiberTypeId] = fiberVariance
   }
 
   getRef<I, A>(ref: Context.Reference<I, A>): A {
@@ -563,7 +571,7 @@ class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
       }
     } 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)
     }
@@ -571,7 +579,7 @@ class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
 
   getCont<S extends successCont | failureCont>(
     symbol: S
-  ): Primitive & Record<S, (value: any, fiber: FiberImpl) => Primitive> | undefined {
+  ): Primitive & Record<S, (value: any, fiber: MicroFiberImpl) => Primitive> | undefined {
     while (true) {
       const op = this._stack.pop()
       if (!op) return undefined
@@ -588,16 +596,16 @@ class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
     return Yield
   }
 
-  children(): Set<Fiber<any, any>> {
+  children(): Set<MicroFiber<any, any>> {
     return this._children ??= new Set()
   }
 }
 
 const fiberMiddleware = globalValue("effect/Micro/fiberMiddleware", () => ({
-  interruptChildren: undefined as ((fiber: FiberImpl) => Micro<void> | undefined) | undefined
+  interruptChildren: undefined as ((fiber: MicroFiberImpl) => Micro<void> | undefined) | undefined
 }))
 
-const fiberInterruptChildren = (fiber: FiberImpl) => {
+const fiberInterruptChildren = (fiber: MicroFiberImpl) => {
   if (fiber._children === undefined || fiber._children.size === 0) {
     return undefined
   }
@@ -607,17 +615,24 @@ const fiberInterruptChildren = (fiber: FiberImpl) => {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export const fiberAwait = <A, E>(self: Fiber<A, E>): Micro<MicroExit<A, E>> =>
+export const fiberAwait = <A, E>(self: MicroFiber<A, E>): Micro<MicroExit<A, E>> =>
   async((resume) => sync(self.addObserver((exit) => resume(succeed(exit)))))
 
+/**
+ * @since 3.11.2
+ * @experimental
+ * @category MicroFiber
+ */
+export const fiberJoin = <A, E>(self: MicroFiber<A, E>): Micro<A, E> => flatten(fiberAwait(self))
+
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export const fiberInterrupt = <A, E>(self: Fiber<A, E>): Micro<void> =>
+export const fiberInterrupt = <A, E>(self: MicroFiber<A, E>): Micro<void> =>
   suspend(() => {
     self.unsafeInterrupt()
     return asVoid(fiberAwait(self))
@@ -626,9 +641,9 @@ export const fiberInterrupt = <A, E>(self: Fiber<A, E>): Micro<void> =>
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export const fiberInterruptAll = <A extends Iterable<Fiber<any, any>>>(fibers: A): Micro<void> =>
+export const fiberInterruptAll = <A extends Iterable<MicroFiber<any, any>>>(fibers: A): Micro<void> =>
   suspend(() => {
     for (const fiber of fibers) fiber.unsafeInterrupt()
     const iter = fibers[Symbol.iterator]()
@@ -674,16 +689,16 @@ type Yield = typeof Yield
 
 interface Primitive {
   readonly [identifier]: string
-  readonly [successCont]: ((value: unknown, fiber: FiberImpl) => Primitive | Yield) | undefined
+  readonly [successCont]: ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield) | undefined
   readonly [failureCont]:
-    | ((cause: MicroCause<unknown>, fiber: FiberImpl) => Primitive | Yield)
+    | ((cause: MicroCause<unknown>, fiber: MicroFiberImpl) => Primitive | Yield)
     | undefined
   readonly [ensureCont]:
-    | ((fiber: FiberImpl) =>
-      | ((value: unknown, fiber: FiberImpl) => Primitive | Yield)
+    | ((fiber: MicroFiberImpl) =>
+      | ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield)
       | undefined)
     | undefined
-  [evaluate](fiber: FiberImpl): Primitive | Yield
+  [evaluate](fiber: MicroFiberImpl): Primitive | Yield
 }
 
 const microVariance = {
@@ -704,7 +719,7 @@ const MicroProto = {
   },
   toJSON(this: Primitive) {
     return {
-      _id: "effect/Micro",
+      _id: "Micro",
       op: this[identifier],
       ...(args in this ? { args: this[args] } : undefined)
     }
@@ -717,20 +732,20 @@ const MicroProto = {
   }
 }
 
-function defaultEvaluate(_fiber: FiberImpl): Primitive | Yield {
+function defaultEvaluate(_fiber: MicroFiberImpl): Primitive | Yield {
   return exitDie(`Micro.evaluate: Not implemented`) as any
 }
 
 const makePrimitiveProto = <Op extends string>(options: {
   readonly op: Op
-  readonly eval?: (fiber: FiberImpl) => Primitive | Micro<any, any, any> | Yield
-  readonly contA?: (this: Primitive, value: any, fiber: FiberImpl) => Primitive | Micro<any, any, any> | Yield
+  readonly eval?: (fiber: MicroFiberImpl) => Primitive | Micro<any, any, any> | Yield
+  readonly contA?: (this: Primitive, value: any, fiber: MicroFiberImpl) => Primitive | Micro<any, any, any> | Yield
   readonly contE?: (
     this: Primitive,
     cause: MicroCause<any>,
-    fiber: FiberImpl
+    fiber: MicroFiberImpl
   ) => Primitive | Micro<any, any, any> | Yield
-  readonly ensure?: (this: Primitive, fiber: FiberImpl) => void | ((value: any, fiber: FiberImpl) => void)
+  readonly ensure?: (this: Primitive, fiber: MicroFiberImpl) => void | ((value: any, fiber: MicroFiberImpl) => void)
 }): Primitive => ({
   ...MicroProto,
   [identifier]: options.op,
@@ -745,22 +760,22 @@ const makePrimitive = <Fn extends (...args: Array<any>) => any, Single extends b
   readonly single?: Single
   readonly eval?: (
     this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
-    fiber: FiberImpl
+    fiber: MicroFiberImpl
   ) => Primitive | Micro<any, any, any> | Yield
   readonly contA?: (
     this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
     value: any,
-    fiber: FiberImpl
+    fiber: MicroFiberImpl
   ) => Primitive | Micro<any, any, any> | Yield
   readonly contE?: (
     this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
     cause: MicroCause<any>,
-    fiber: FiberImpl
+    fiber: MicroFiberImpl
   ) => Primitive | Micro<any, any, any> | Yield
   readonly ensure?: (
     this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
-    fiber: FiberImpl
-  ) => void | ((value: any, fiber: FiberImpl) => void)
+    fiber: MicroFiberImpl
+  ) => void | ((value: any, fiber: MicroFiberImpl) => void)
 }): Fn => {
   const Proto = makePrimitiveProto(options as any)
   return function() {
@@ -777,7 +792,7 @@ const makeExit = <Fn extends (...args: Array<any>) => any, Prop extends string>(
     this:
       & MicroExit<unknown, unknown>
       & { [args]: Parameters<Fn>[0] },
-    fiber: FiberImpl<unknown, unknown>
+    fiber: MicroFiberImpl<unknown, unknown>
   ) => Primitive | Yield
 }): Fn => {
   const Proto = {
@@ -789,7 +804,7 @@ const makeExit = <Fn extends (...args: Array<any>) => any, Prop extends string>(
     },
     toJSON(this: any) {
       return {
-        _id: "effect/Micro/Exit",
+        _id: "MicroExit",
         _tag: options.op,
         [options.prop]: this[args]
       }
@@ -848,10 +863,10 @@ export const failCause: <E>(cause: MicroCause<E>) => Micro<never, E> = 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
@@ -860,10 +875,10 @@ export const failCause: <E>(cause: MicroCause<E>) => Micro<never, E> = makeExit(
 export const fail = <E>(error: E): Micro<never, E> => 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
@@ -925,7 +940,7 @@ export const yieldNowWith: (priority?: number) => Micro<void> = makePrimitive({
 export const yieldNow: Micro<void> = 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
@@ -934,7 +949,7 @@ export const yieldNow: Micro<void> = yieldNowWith(0)
 export const succeedSome = <A>(a: A): Micro<Option.Option<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
@@ -955,8 +970,8 @@ export const failCauseSync = <E>(evaluate: LazyArg<MicroCause<E>>): Micro<never,
 /**
  * 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
@@ -967,8 +982,8 @@ export const die = (defect: unknown): Micro<never> => 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
@@ -1028,9 +1043,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"
@@ -1040,13 +1052,19 @@ 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
@@ -1064,9 +1082,6 @@ export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): M
  * 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"
@@ -1076,6 +1091,10 @@ export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): M
  *   catch: (cause) => new Error("caught", { cause })
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
  */
 export const tryPromise = <A, E>(options: {
   readonly try: (signal: AbortSignal) => PromiseLike<A>
@@ -1093,16 +1112,16 @@ export const tryPromise = <A, E>(options: {
   }, 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: <A, E = never, R = never>(
-  evaluate: (fiber: FiberImpl<A, E>) => Micro<A, E, R>
+export const withMicroFiber: <A, E = never, R = never>(
+  evaluate: (fiber: MicroFiberImpl<A, E>) => Micro<A, E, R>
 ) => Micro<A, E, R> = makePrimitive({
-  op: "WithFiber",
+  op: "WithMicroFiber",
   eval(fiber) {
     return this[args](fiber)
   }
@@ -1115,7 +1134,7 @@ export const withFiber: <A, E = never, R = never>(
  * @experimental
  * @category constructors
  */
-export const yieldFlush: Micro<void> = withFiber((fiber) => {
+export const yieldFlush: Micro<void> = withMicroFiber((fiber) => {
   fiber.getRef(CurrentScheduler).flush()
   return exitVoid
 })
@@ -1230,7 +1249,7 @@ const fromIterator: (
     fiber._stack.push(this)
     return yieldWrapGet(state.value)
   },
-  eval(this: any, fiber: FiberImpl) {
+  eval(this: any, fiber: MicroFiberImpl) {
     return this[successCont](undefined, fiber)
   }
 })
@@ -1277,7 +1296,7 @@ export const as: {
 } = dual(2, <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R> => 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
@@ -1299,11 +1318,11 @@ export const flip = <A, E, R>(self: Micro<A, E, R>): Micro<E, A, R> =>
   })
 
 /**
- * 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
@@ -1311,11 +1330,11 @@ export const flip = <A, E, R>(self: Micro<A, E, R>): Micro<E, A, R> =>
  */
 export const andThen: {
   /**
-   * 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
@@ -1326,11 +1345,11 @@ export const andThen: {
   ) => [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 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
@@ -1341,11 +1360,11 @@ export const andThen: {
   ) => [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 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
@@ -1357,11 +1376,11 @@ export const andThen: {
   ): [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 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
@@ -1497,13 +1516,13 @@ export const sandbox = <A, E, R>(self: Micro<A, E, R>): Micro<A, MicroCause<E>,
 export const raceAll = <Eff extends Micro<any, any, any>>(
   all: Iterable<Eff>
 ): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  withFiber((parent) =>
+  withMicroFiber((parent) =>
     async((resume) => {
       const effects = Arr.fromIterable(all)
       const len = effects.length
       let doneCount = 0
       let done = false
-      const fibers = new Set<Fiber<any, any>>()
+      const fibers = new Set<MicroFiber<any, any>>()
       const causes: Array<MicroCause<any>> = []
       const onExit = (exit: MicroExit<any, any>) => {
         doneCount++
@@ -1535,7 +1554,7 @@ export const raceAll = <Eff extends Micro<any, any, any>>(
 /**
  * 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
@@ -1544,10 +1563,10 @@ export const raceAll = <Eff extends Micro<any, any, any>>(
 export const raceAllFirst = <Eff extends Micro<any, any, any>>(
   all: Iterable<Eff>
 ): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  withFiber((parent) =>
+  withMicroFiber((parent) =>
     async((resume) => {
       let done = false
-      const fibers = new Set<Fiber<any, any>>()
+      const fibers = new Set<MicroFiber<any, any>>()
       const onExit = (exit: MicroExit<any, any>) => {
         done = true
         resume(fibers.size === 0 ? exit : flatMap(fiberInterruptAll(fibers), () => exit))
@@ -1569,7 +1588,7 @@ export const raceAllFirst = <Eff extends Micro<any, any, any>>(
 
 /**
  * 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
@@ -1578,7 +1597,7 @@ export const raceAllFirst = <Eff extends Micro<any, any, any>>(
 export const race: {
   /**
    * 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
@@ -1587,7 +1606,7 @@ export const race: {
   <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
   /**
    * 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
@@ -1602,7 +1621,7 @@ export const race: {
 
 /**
  * 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
@@ -1611,7 +1630,7 @@ export const race: {
 export const raceFirst: {
   /**
    * 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
@@ -1620,7 +1639,7 @@ export const raceFirst: {
   <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
   /**
    * 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
@@ -1674,7 +1693,7 @@ export const flatMap: {
 )
 const OnSuccessProto = makePrimitiveProto({
   op: "OnSuccess",
-  eval(this: any, fiber: FiberImpl): Primitive {
+  eval(this: any, fiber: MicroFiberImpl): Primitive {
     fiber._stack.push(this)
     return this[args]
   }
@@ -1732,10 +1751,9 @@ export const map: {
 // ----------------------------------------------------------------------------
 
 /**
- * The MicroExit type is a data type that represents the result of a Micro
- * computation.
- *
- * It uses the `Either` data type to represent the success and failure cases.
+ * The `MicroExit` type is used to represent the result of a `Micro` computation. It
+ * can either be successful, containing a value of type `A`, or it can fail,
+ * containing an error of type `E` wrapped in a `MicroCause`.
  *
  * @since 3.4.6
  * @experimental
@@ -1908,7 +1926,7 @@ export const exitVoidAll = <I extends Iterable<MicroExit<any, any>>>(
  */
 export interface MicroScheduler {
   readonly scheduleTask: (task: () => void, priority: number) => void
-  readonly shouldYield: (fiber: Fiber<unknown, unknown>) => boolean
+  readonly shouldYield: (fiber: MicroFiber<unknown, unknown>) => boolean
   readonly flush: () => void
 }
 
@@ -1958,7 +1976,7 @@ export class MicroSchedulerDefault implements MicroScheduler {
   /**
    * @since 3.5.9
    */
-  shouldYield(fiber: Fiber<unknown, unknown>) {
+  shouldYield(fiber: MicroFiber<unknown, unknown>) {
     return fiber.currentOpCount >= fiber.getRef(MaxOpsBeforeYield)
   }
 
@@ -1998,7 +2016,7 @@ export const service: {
   <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I>
 } =
   (<I, S>(tag: Context.Tag<I, S>): Micro<S, never, I> =>
-    withFiber((fiber) => succeed(Context.unsafeGet(fiber.context, tag)))) as any
+    withMicroFiber((fiber) => succeed(Context.unsafeGet(fiber.context, tag)))) as any
 
 /**
  * Access the given `Context.Tag` from the environment, without tracking the
@@ -2013,7 +2031,7 @@ export const service: {
  */
 export const serviceOption = <I, S>(
   tag: Context.Tag<I, S>
-): Micro<Option.Option<S>> => withFiber((fiber) => succeed(Context.getOption(fiber.context, tag)))
+): Micro<Option.Option<S>> => withMicroFiber((fiber) => succeed(Context.getOption(fiber.context, tag)))
 
 /**
  * Update the Context with the given mapping function.
@@ -2050,7 +2068,7 @@ export const updateContext: {
     self: Micro<A, E, R>,
     f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Micro<A, E, R2> =>
-    withFiber<
+    withMicroFiber<
       /**
        * Update the Context with the given mapping function.
        *
@@ -2133,7 +2151,7 @@ export const updateService: {
     tag: Context.Reference<I, A>,
     f: (value: A) => A
   ): Micro<XA, E, R> =>
-    withFiber((fiber) => {
+    withMicroFiber((fiber) => {
       const prev = Context.unsafeGet(fiber.context, tag)
       fiber.context = Context.add(fiber.context, tag, f(prev))
       return onExit(
@@ -2154,7 +2172,7 @@ export const updateService: {
  * @category environment
  */
 export const context = <R>(): Micro<Context.Context<R>> => getContext as any
-const getContext = withFiber((fiber) => succeed(fiber.context))
+const getContext = withMicroFiber((fiber) => succeed(fiber.context))
 
 /**
  * Merge the given `Context` with the current context.
@@ -2311,10 +2329,8 @@ export class CurrentScheduler extends Context.Reference<CurrentScheduler>()<
  * 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), {
@@ -2322,16 +2338,19 @@ export class CurrentScheduler extends Context.Reference<CurrentScheduler>()<
  * }).pipe(
  *   Micro.withConcurrency(2) // use a concurrency of 2
  * )
+ * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
  */
 export const withConcurrency: {
   /**
    * 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), {
@@ -2339,16 +2358,19 @@ export const withConcurrency: {
    * }).pipe(
    *   Micro.withConcurrency(2) // use a concurrency of 2
    * )
+   * ```
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category environment refs
    */
   (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
   /**
    * 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), {
@@ -2356,6 +2378,11 @@ export const withConcurrency: {
    * }).pipe(
    *   Micro.withConcurrency(2) // use a concurrency of 2
    * )
+   * ```
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category environment refs
    */
   <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>
 } = dual(
@@ -3212,7 +3239,7 @@ export const catchAllCause: {
 )
 const OnFailureProto = makePrimitiveProto({
   op: "OnFailure",
-  eval(this: any, fiber: FiberImpl): Primitive {
+  eval(this: any, fiber: MicroFiberImpl): Primitive {
     fiber._stack.push(this as any)
     return this[args]
   }
@@ -3292,7 +3319,7 @@ export const catchCauseIf: {
 /**
  * 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
@@ -3302,7 +3329,7 @@ export const catchAll: {
   /**
    * 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
@@ -3312,7 +3339,7 @@ export const catchAll: {
   /**
    * 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
@@ -3936,7 +3963,7 @@ export const matchCauseEffect: {
 )
 const OnSuccessAndFailureProto = makePrimitiveProto({
   op: "OnSuccessAndFailure",
-  eval(this: any, fiber: FiberImpl): Primitive {
+  eval(this: any, fiber: MicroFiberImpl): Primitive {
     fiber._stack.push(this)
     return this[args]
   }
@@ -4738,7 +4765,7 @@ export const interrupt: Micro<never> = failCause(causeInterrupt())
 export const uninterruptible = <A, E, R>(
   self: Micro<A, E, R>
 ): Micro<A, E, R> =>
-  withFiber((fiber) => {
+  withMicroFiber((fiber) => {
     if (!fiber.interruptible) return self
     fiber.interruptible = false
     fiber._stack.push(setInterruptible(true))
@@ -4766,7 +4793,7 @@ const setInterruptible: (interruptible: boolean) => Primitive = makePrimitive({
 export const interruptible = <A, E, R>(
   self: Micro<A, E, R>
 ): Micro<A, E, R> =>
-  withFiber((fiber) => {
+  withMicroFiber((fiber) => {
     if (fiber.interruptible) return self
     fiber.interruptible = true
     fiber._stack.push(setInterruptible(false))
@@ -4781,9 +4808,6 @@ export const interruptible = <A, E, R>(
  * 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"
@@ -4794,13 +4818,17 @@ export const interruptible = <A, E, R>(
  *   )
  * )
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
  */
 export const uninterruptibleMask = <A, E, R>(
   f: (
     restore: <A, E, R>(effect: Micro<A, E, R>) => Micro<A, E, R>
   ) => Micro<A, E, R>
 ): Micro<A, E, R> =>
-  withFiber((fiber) => {
+  withMicroFiber((fiber) => {
     if (!fiber.interruptible) return f(identity)
     fiber.interruptible = false
     fiber._stack.push(setInterruptible(true))
@@ -5017,7 +5045,7 @@ export const forEach: {
   readonly concurrency?: Concurrency | undefined
   readonly discard?: boolean | undefined
 }): Micro<any, E, R> =>
-  withFiber((parent) => {
+  withMicroFiber((parent) => {
     const concurrencyOption = options?.concurrency === "inherit"
       ? parent.getRef(CurrentConcurrency)
       : options?.concurrency ?? 1
@@ -5047,7 +5075,7 @@ export const forEach: {
       )
     }
     return async((resume) => {
-      const fibers = new Set<Fiber<unknown, unknown>>()
+      const fibers = new Set<MicroFiber<unknown, unknown>>()
       let result: MicroExit<any, any> | undefined = undefined
       let inProgress = 0
       let doneCount = 0
@@ -5253,30 +5281,30 @@ export {
 // ----------------------------------------------------------------------------
 
 /**
- * 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 = <A, E, R>(
   self: Micro<A, E, R>
-): Micro<Fiber<A, E>, never, R> =>
-  withFiber((fiber) => {
+): Micro<MicroFiber<A, E>, never, R> =>
+  withMicroFiber((fiber) => {
     fiberMiddleware.interruptChildren ??= fiberInterruptChildren
     return succeed(unsafeFork(fiber, self))
   })
 
 const unsafeFork = <FA, FE, A, E, R>(
-  parent: FiberImpl<FA, FE>,
+  parent: MicroFiberImpl<FA, FE>,
   effect: Micro<A, E, R>,
   immediate = false,
   daemon = false
-): Fiber<A, E> => {
-  const child = new FiberImpl<A, E>(parent.context, parent.interruptible)
+): MicroFiber<A, E> => {
+  const child = new MicroFiberImpl<A, E>(parent.context, parent.interruptible)
   if (!daemon) {
     parent.children().add(child)
     child.addObserver(() => parent.children().delete(child))
@@ -5290,55 +5318,55 @@ const unsafeFork = <FA, FE, A, E, R>(
 }
 
 /**
- * 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 = <A, E, R>(
   self: Micro<A, E, R>
-): Micro<Fiber<A, E>, never, R> => withFiber((fiber) => succeed(unsafeFork(fiber, self, false, true)))
+): Micro<MicroFiber<A, E>, never, R> => 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: {
   /**
-   * 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
    */
-  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>
+  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>
   /**
-   * 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
    */
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R>
+  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R>
 } = dual(
   2,
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R> =>
+  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R> =>
     uninterruptibleMask((restore) =>
       flatMap(scope.fork, (scope) =>
         tap(
@@ -5349,16 +5377,16 @@ export const forkIn: {
 )
 
 /**
- * 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 = <A, E, R>(self: Micro<A, E, R>): Micro<Fiber<A, E>, never, R | MicroScope> =>
+export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<MicroFiber<A, E>, never, R | MicroScope> =>
   flatMap(scope, (scope) => forkIn(self, scope))
 
 // ----------------------------------------------------------------------------
@@ -5366,15 +5394,12 @@ export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<Fiber<A, E>, ne
 // ----------------------------------------------------------------------------
 
 /**
- * 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"
@@ -5388,6 +5413,10 @@ export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<Fiber<A, E>, ne
  *   console.log(exit)
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
  */
 export const runFork = <A, E>(
   effect: Micro<A, E>,
@@ -5395,8 +5424,8 @@ export const runFork = <A, E>(
     readonly signal?: AbortSignal | undefined
     readonly scheduler?: MicroScheduler | undefined
   } | undefined
-): FiberImpl<A, E> => {
-  const fiber = new FiberImpl<A, E>(CurrentScheduler.context(
+): MicroFiberImpl<A, E> => {
+  const fiber = new MicroFiberImpl<A, E>(CurrentScheduler.context(
     options?.scheduler ?? new MicroSchedulerDefault()
   ))
   fiber.evaluate(effect as any)
@@ -5458,7 +5487,7 @@ export const runPromise = <A, E>(
  * 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