FuncType - v1.8.0
    Preparing search index...

    Interface ExitType<E, A>

    Exit represents the outcome of running an IO effect.

    • Success: The effect completed successfully with a value
    • Failure: The effect failed with a typed error — a value from the declared E channel
    • Die: The effect produced a defect — a value that is not an E
    • Interrupted: The effect was cancelled/interrupted

    Die exists so the error channel stops lying. IO.sync and IO.die declare E = never, so nothing they put in the error channel can be an E: a throwing IO.sync thunk, a throwing map/flatMap/mapError callback, and IO.die all produce values the declared type says cannot exist. Before Die these collapsed into Failure, so a consumer that pattern-matched on error._tag got undefined with no runtime signal that anything was wrong.

    Defects remain recoverable — recover / recoverWith / fold / mapError treat Die exactly as they treat Failure. That is deliberate, and it is where functype parts company with ZIO: promoting defects to uncatchable would silently change what every existing .recover() catches. Die is an observability fix, not a control-flow one — it records what the outcome really was when nothing recovered it.

    Note the sync interpreter cannot distinguish the two. runSync returns Either<E, A>, which has no third branch to put a defect in, and the sync interpreter signals failure by throwing the raw value — so Fail and Die arrive identically. Die is observable through the async terminals (runExit) and through the Exit handed to a bracketExit release.

    interface ExitType<E extends Type, A extends Type> {
        _tag: ExitTag;
        "[toStringTag]": string;
        flatMap<B extends unknown>(f: (a: A) => ExitType<E, B>): ExitType<E, B>;
        fold<T>(
            onFailure: (e: E) => T,
            onSuccess: (a: A) => T,
            onInterrupted?: (fiberId: string) => T,
            onDie?: (defect: unknown) => T,
        ): T;
        isDie(): this is ExitType<E, A> & { _tag: "Die"; defect: unknown };
        isFailure(): this is ExitType<E, A> & { _tag: "Failure"; error: E };
        isInterrupted(): this is ExitType<E, A> & {
            _tag: "Interrupted";
            fiberId: string;
        };
        isSuccess(): this is ExitType<E, A> & { _tag: "Success"; value: A };
        map<B extends unknown>(f: (a: A) => B): ExitType<E, B>;
        mapBoth<E2 extends unknown, B extends unknown>(
            onError: (e: E) => E2,
            onSuccess: (a: A) => B,
        ): ExitType<E2, B>;
        mapError<E2 extends unknown>(f: (e: E) => E2): ExitType<E2, A>;
        match<T>(
            patterns: {
                Die?: (defect: unknown) => T;
                Failure: (error: E) => T;
                Interrupted: (fiberId: string) => T;
                Success: (value: A) => T;
            },
        ): T;
        orElse(defaultValue: A): A;
        orThrow(): A;
        toEither(): Either<E, A>;
        toJSON(): {
            _tag: ExitTag;
            defect?: unknown;
            error?: E;
            fiberId?: string;
            value?: A;
        };
        toOption(): Option<A>;
        toString(): string;
        toValue(): {
            _tag: ExitTag;
            defect?: unknown;
            error?: E;
            fiberId?: string;
            value?: A;
        };
    }

    Type Parameters

    Index
    _tag [toStringTag]
    flatMap fold isDie isFailure isInterrupted isSuccess map mapBoth mapError match orElse orThrow toEither toJSON toOption toString toValue

    Readonly_tag

    _tag: ExitTag
    "[toStringTag]": string

    • Pattern matches over the Exit.

      onDie is optional and appended rather than inserted so existing three-argument calls keep compiling. Omitting it routes a defect to onFailure — the pre-Die behaviour, where defects were indistinguishable from typed failures. Supply it when the distinction matters; note the value it receives is unknown, not E.

      Type Parameters

      • T

      Parameters

      • onFailure: (e: E) => T
      • onSuccess: (a: A) => T
      • OptionalonInterrupted: (fiberId: string) => T
      • OptionalonDie: (defect: unknown) => T

      Returns T

    • Type guard to check if this is a Die (a defect — the carried value is not an E)

      Returns this is ExitType<E, A> & { _tag: "Die"; defect: unknown }

    • Type guard to check if this is a Failure

      Returns this is ExitType<E, A> & { _tag: "Failure"; error: E }

    • Type guard to check if this is Interrupted

      Returns this is ExitType<E, A> & { _tag: "Interrupted"; fiberId: string }

    • Type guard to check if this is a Success

      Returns this is ExitType<E, A> & { _tag: "Success"; value: A }

    • Maps the success value

      Type Parameters

      • B extends unknown

      Parameters

      • f: (a: A) => B

      Returns ExitType<E, B>

    • Maps both error and success values

      Type Parameters

      • E2 extends unknown
      • B extends unknown

      Parameters

      • onError: (e: E) => E2
      • onSuccess: (a: A) => B

      Returns ExitType<E2, B>

    • Maps the error value

      Type Parameters

      • E2 extends unknown

      Parameters

      • f: (e: E) => E2

      Returns ExitType<E2, A>

    • Pattern matches over the Exit with object patterns.

      Die is optional for the same back-compat reason as fold's onDie, and falls back to Failure when absent.

      Type Parameters

      • T

      Parameters

      • patterns: {
            Die?: (defect: unknown) => T;
            Failure: (error: E) => T;
            Interrupted: (fiberId: string) => T;
            Success: (value: A) => T;
        }

      Returns T

    • Returns the success value or a default

      Parameters

      • defaultValue: A

      Returns A

    • Returns the success value or throws

      Returns A

    • Converts to Either (Right for Success, Left for Failure) Throws if Interrupted

      A Die becomes Left(defect), which widens the Left beyond E — the same lossiness IO.run() already has. Use isDie first if the distinction matters.

      Returns Either<E, A>

    • JSON serialization

      Returns { _tag: ExitTag; defect?: unknown; error?: E; fiberId?: string; value?: A }

    • Converts to Option (Some for Success, None otherwise)

      Returns Option<A>

    • String representation

      Returns string

    • Returns the raw value for inspection

      Returns { _tag: ExitTag; defect?: unknown; error?: E; fiberId?: string; value?: A }

    Settings
    Member Visibility

    On This Page
    Properties
    Methods