Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace IO

Index

Variables

bracket

bracket: <Resource, EOpen, EClose>(open: IO<Resource, EOpen>, close: (r: Resource) => IO<unknown, EClose>) => <A, EUse>(use: (r: Resource) => IO<A, EUse>) => IO<A, EOpen | EClose | EUse>

Type declaration

    • <Resource, EOpen, EClose>(open: IO<Resource, EOpen>, close: (r: Resource) => IO<unknown, EClose>): <A, EUse>(use: (r: Resource) => IO<A, EUse>) => IO<A, EOpen | EClose | EUse>
    • Creates a wrapper function which will use an open action to acquire a resource and close action to release it. If the open action succeeds, then the close function is guaranteed to be called. This can be used where you might use a try... finally block in imperative code, when a clean up action must always be taken.

      Type parameters

      • Resource

      • EOpen

      • EClose

      Parameters

      • open: IO<Resource, EOpen>
      • close: (r: Resource) => IO<unknown, EClose>
          • (r: Resource): IO<unknown, EClose>
          • Parameters

            • r: Resource

            Returns IO<unknown, EClose>

      Returns <A, EUse>(use: (r: Resource) => IO<A, EUse>) => IO<A, EOpen | EClose | EUse>

        • <A, EUse>(use: (r: Resource) => IO<A, EUse>): IO<A, EOpen | EClose | EUse>
        • Type parameters

          • A

          • EUse

          Parameters

          • use: (r: Resource) => IO<A, EUse>
              • (r: Resource): IO<A, EUse>
              • Parameters

                • r: Resource

                Returns IO<A, EUse>

          Returns IO<A, EOpen | EClose | EUse>

cancel

cancel: () => IO<never, never>

Type declaration

    • (): IO<never, never>
    • Cancels the execution of the current fiber.

      Returns IO<never, never>

cancelable

cancelable: <A>(cancelableEffect: () => { promise: Promise<A>; cancel: any }) => IO<A, unknown>

Type declaration

    • <A>(cancelableEffect: () => { promise: Promise<A>; cancel: any }): IO<A, unknown>
    • Type parameters

      • A

      Parameters

      • cancelableEffect: () => { promise: Promise<A>; cancel: any }
          • (): { promise: Promise<A>; cancel: any }
          • Returns { promise: Promise<A>; cancel: any }

            • promise: Promise<A>
            • cancel:function
              • cancel(): void

      Returns IO<A, unknown>

lift

lift: <Args, Return>(func: (...args: Args) => Return | Promise<Return>) => (...args: Args) => IO<Return>

Type declaration

    • <Args, Return>(func: (...args: Args) => Return | Promise<Return>): (...args: Args) => IO<Return>
    • Type parameters

      • Args: unknown[]

      • Return

      Parameters

      • func: (...args: Args) => Return | Promise<Return>
          • (...args: Args): Return | Promise<Return>
          • Parameters

            • Rest ...args: Args

            Returns Return | Promise<Return>

      Returns (...args: Args) => IO<Return>

        • (...args: Args): IO<Return>
        • Parameters

          • Rest ...args: Args

          Returns IO<Return>

parallel

parallel: <Actions>(actions: Actions) => IO<ValuesArray<Actions>, UnionOfErrors<Actions>>

Type declaration

    • <Actions>(actions: Actions): IO<ValuesArray<Actions>, UnionOfErrors<Actions>>
    • Creates a single from an array of actions, which will perform the actions concurrently, returning an array of the results. If any of the actions cancel or raise an error, all other actions are immediately canceled.

      Type parameters

      • Actions: readonly IO<unknown, unknown>[]

      Parameters

      • actions: Actions

      Returns IO<ValuesArray<Actions>, UnionOfErrors<Actions>>

race

race: <Actions>(actions: Actions) => IO<UnionOfValues<Actions>, UnionOfErrors<Actions> | (Actions extends { 0: unknown } ? never : TypeError)>

Type declaration

    • <Actions>(actions: Actions): IO<UnionOfValues<Actions>, UnionOfErrors<Actions> | (Actions extends { 0: unknown } ? never : TypeError)>
    • Creates an IO from an array of IOs, which will perform the actions concurrently, returning the earliest successful result or stopping when the first error occurs.

      Type parameters

      • Actions: readonly IO<unknown, unknown>[]

      Parameters

      • actions: Actions

      Returns IO<UnionOfValues<Actions>, UnionOfErrors<Actions> | (Actions extends { 0: unknown } ? never : TypeError)>

raise

raise: <E>(error: E) => IO<never, E>

Type declaration

    • <E>(error: E): IO<never, E>
    • Type parameters

      • E

      Parameters

      • error: E

      Returns IO<never, E>

sequence

sequence: <Actions>(actions: Actions) => IO<ValuesArray<Actions>, UnionOfErrors<Actions>>

Type declaration

    • <Actions>(actions: Actions): IO<ValuesArray<Actions>, UnionOfErrors<Actions>>
    • Creates a single action from an array of actions, which will perform the actions sequentially, returning an array of the results, or stopping on the first error encountered.

      Type parameters

      • Actions: readonly IO<unknown, unknown>[]

      Parameters

      • actions: Actions

      Returns IO<ValuesArray<Actions>, UnionOfErrors<Actions>>

uncancelable

uncancelable: <A, E>(action: IO<A, E>) => IO<A, E>

Type declaration

    • <A, E>(action: IO<A, E>): IO<A, E>
    • Type parameters

      • A

      • E

      Parameters

      • action: IO<A, E>

      Returns IO<A, E>

void

void: IO<void, never>

wait

wait: (time: number, units: "millisecond" | "milliseconds" | "seconds" | "second" | "minute" | "minutes" | "hour" | "hours") => IO<void, never>

Type declaration

    • (time: number, units: "millisecond" | "milliseconds" | "seconds" | "second" | "minute" | "minutes" | "hour" | "hours"): IO<void, never>
    • Parameters

      • time: number
      • units: "millisecond" | "milliseconds" | "seconds" | "second" | "minute" | "minutes" | "hour" | "hours"

      Returns IO<void, never>

wrap

wrap: <A>(value: A) => IO<A, never>

Type declaration

    • <A>(value: A): IO<A, never>
    • Type parameters

      • A

      Parameters

      • value: A

      Returns IO<A, never>

Generated using TypeDoc