Interface ExitType<E, A>

Readonly_tag

flatMap

• flatMap<B extends unknown>(f: (a: A) => ExitType<E, B>): ExitType<E, B>

  Flat maps the success value

  Type Parameters

  • B extends unknown

  Parameters

  • f: (a: A) => ExitType<E, B>

  Returns ExitType<E, B>

fold

• fold<T>(
      onFailure: (e: E) => T,
      onSuccess: (a: A) => T,
      onInterrupted?: (fiberId: string) => T,
  ): T

  Pattern matches over the Exit

  Type Parameters

  • T

  Parameters

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

  Returns T

isFailure

• isFailure(): this is ExitType<E, A> & { _tag: "Failure"; error: E }

  Type guard to check if this is a Failure

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

isInterrupted

• isInterrupted(): this is ExitType<E, A> & {
      _tag: "Interrupted";
      fiberId: string;
  }

  Type guard to check if this is Interrupted

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

isSuccess

• isSuccess(): this is ExitType<E, A> & { _tag: "Success"; value: A }

  Type guard to check if this is a Success

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

map

• map<B extends unknown>(f: (a: A) => B): ExitType<E, B>

  Maps the success value

  Type Parameters

  • B extends unknown

  Parameters

  • f: (a: A) => B

  Returns ExitType<E, B>

mapBoth

• mapBoth<E2 extends unknown, B extends unknown>(
      onError: (e: E) => E2,
      onSuccess: (a: A) => B,
  ): ExitType<E2, 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>

mapError

• mapError<E2 extends unknown>(f: (e: E) => E2): ExitType<E2, A>

  Maps the error value

  Type Parameters

  • E2 extends unknown

  Parameters

  • f: (e: E) => E2

  Returns ExitType<E2, A>

match

• match<T>(
      patterns: {
          Failure: (error: E) => T;
          Interrupted: (fiberId: string) => T;
          Success: (value: A) => T;
      },
  ): T

  Pattern matches over the Exit with object patterns

  Type Parameters

  • T

  Parameters

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

  Returns T

orElse

• orElse(defaultValue: A): A

  Returns the success value or a default

  Parameters

  • defaultValue: A

  Returns A

orThrow

• orThrow(): A

  Returns the success value or throws

  Returns A

toEither

• toEither(): Either<E, A>

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

  Returns Either<E, A>

toJSON

• toJSON(): { _tag: ExitTag; error?: E; fiberId?: string; value?: A }

  JSON serialization

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

toOption

• toOption(): Option<A>

  Converts to Option (Some for Success, None otherwise)

  Returns Option<A>

toString

• toString(): string

  String representation

  Returns string

toValue

• toValue(): { _tag: ExitTag; error?: E; fiberId?: string; value?: A }

  Returns the raw value for inspection

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