@mikuroxina/mini-fn
    Preparing search index...

    Type Alias CatFailT<M, CTX>

    A combinator which contains a ctx and can be transformed it into another one by its methods.

    type CatFailT<M, CTX> = {
        addM: <const K extends PropertyKey, A>(
            key: K,
            value: Get1<M, A>,
        ) => CatFailT<M, Record<K, A> & CTX>;
        addMWith: <const K extends PropertyKey, A>(
            key: K,
            fn: (ctx: CTX) => Get1<M, A>,
        ) => CatFailT<M, Record<K, A> & CTX>;
        addWith: <const K extends PropertyKey, A>(
            key: K,
            fn: (ctx: CTX) => A,
        ) => CatFailT<M, Record<K, A> & CTX>;
        assert: (cond: (ctx: CTX) => boolean, message: string) => CatFailT<M, CTX>;
        ctx: Get1<M, CTX>;
        fail: (message: string) => CatFailT<M, CTX>;
        finish: <R>(fn: (ctx: CTX) => R) => Get1<M, R>;
        finishM: <R>(fn: (ctx: CTX) => Get1<M, R>) => Get1<M, R>;
        loop: <S>(
            initState: S,
            body: (state: S, ctx: CTX) => Get1<M, ControlFlow.ControlFlow<never[], S>>,
        ) => CatFailT<M, CTX>;
        monadFail: TypeClass.MonadFail.MonadFail<M>;
        run: (computation: Get1<M, never[]>) => CatFailT<M, CTX>;
        runWith: (computation: (ctx: CTX) => Get1<M, never[]>) => CatFailT<M, CTX>;
        when: (
            cond: (ctx: CTX) => boolean,
            computation: (ctx: CTX) => Get1<M, never[]>,
        ) => CatFailT<M, CTX>;
        while: (
            cond: (ctx: CTX) => Get1<M, boolean>,
            body: (ctx: CTX) => Get1<M, never[]>,
        ) => CatFailT<M, CTX>;
    }

    Type Parameters

    • M

      HKT key applied to MonadFail.

    • CTX

      Passing context type.

    Index

    Properties

    addM addMWith addWith assert ctx fail finish finishM loop monadFail run runWith when while

    Properties

    addM: <const K extends PropertyKey, A>(
        key: K,
        value: Get1<M, A>,
    ) => CatFailT<M, Record<K, A> & CTX>

    Binds a new value wrapped by the monad.

    Type Declaration

      • <const K extends PropertyKey, A>(
            key: K,
            value: Get1<M, A>,
        ): CatFailT<M, Record<K, A> & CTX>

      • Type Parameters

        • const K extends PropertyKey
        • A

        Parameters

        • key: K

          The new property key for context

        • value: Get1<M, A>

          The wrapped value to bind.

        Returns CatFailT<M, Record<K, A> & CTX>

        A new CatT containing the value at the key.

    addMWith: <const K extends PropertyKey, A>(
        key: K,
        fn: (ctx: CTX) => Get1<M, A>,
    ) => CatFailT<M, Record<K, A> & CTX>

    Binds a new value wrapped by the monad, calculated from ctx by fn.

    Type Declaration

      • <const K extends PropertyKey, A>(
            key: K,
            fn: (ctx: CTX) => Get1<M, A>,
        ): CatFailT<M, Record<K, A> & CTX>

      • Type Parameters

        • const K extends PropertyKey
        • A

        Parameters

        • key: K

          The new property key for context

        • fn: (ctx: CTX) => Get1<M, A>

          The calculation which returns the wrapped value.

        Returns CatFailT<M, Record<K, A> & CTX>

        A new CatT containing the value at the key.

    addWith: <const K extends PropertyKey, A>(
        key: K,
        fn: (ctx: CTX) => A,
    ) => CatFailT<M, Record<K, A> & CTX>

    Appends a new value calculated from ctx by fn.

    Type Declaration

      • <const K extends PropertyKey, A>(
            key: K,
            fn: (ctx: CTX) => A,
        ): CatFailT<M, Record<K, A> & CTX>

      • Type Parameters

        • const K extends PropertyKey
        • A

        Parameters

        • key: K

          The new property key for context

        • fn: (ctx: CTX) => A

          The calculation.

        Returns CatFailT<M, Record<K, A> & CTX>

        A new CatT containing the value at the key.

    assert: (cond: (ctx: CTX) => boolean, message: string) => CatFailT<M, CTX>

    Asserts the predicate or return early with the error message.

    Type Declaration

      • (cond: (ctx: CTX) => boolean, message: string): CatFailT<M, CTX>

      • Parameters

        • cond: (ctx: CTX) => boolean
        • message: string

        Returns CatFailT<M, CTX>

        The exiting computation.

    ctx: Get1<M, CTX>

    Contained context. Altering an interior value must be abstained, or may occurs unsound behaviors.

    fail: (message: string) => CatFailT<M, CTX>

    Aborts the execution and return early with the error message.

    Type Declaration

    finish: <R>(fn: (ctx: CTX) => R) => Get1<M, R>

    Reduces the context into a value by fn.

    Type Declaration

      • <R>(fn: (ctx: CTX) => R): Get1<M, R>

      • Type Parameters

        • R

        Parameters

        • fn: (ctx: CTX) => R

          The finishing computation.

        Returns Get1<M, R>

        A reduced value.

    finishM: <R>(fn: (ctx: CTX) => Get1<M, R>) => Get1<M, R>

    Reduces the context into a value on M by fn.

    Type Declaration

      • <R>(fn: (ctx: CTX) => Get1<M, R>): Get1<M, R>

      • Type Parameters

        • R

        Parameters

        • fn: (ctx: CTX) => Get1<M, R>

          The finishing computation.

        Returns Get1<M, R>

        A reduced value on M.

    loop: <S>(
        initState: S,
        body: (state: S, ctx: CTX) => Get1<M, ControlFlow.ControlFlow<never[], S>>,
    ) => CatFailT<M, CTX>

    Runs a looping computation while it returns Continue<S>.

    Type Declaration

    monadFail: TypeClass.MonadFail.MonadFail<M>

    The MonadFail instance for M.

    run: (computation: Get1<M, never[]>) => CatFailT<M, CTX>

    Runs the computation.

    Type Declaration

      • (computation: Get1<M, never[]>): CatFailT<M, CTX>

      • Parameters

        • computation: Get1<M, never[]>

          The computation to run.

        Returns CatFailT<M, CTX>

        A new CatT with modified environment.

    runWith: (computation: (ctx: CTX) => Get1<M, never[]>) => CatFailT<M, CTX>

    Runs the computation with the context.

    Type Declaration

      • (computation: (ctx: CTX) => Get1<M, never[]>): CatFailT<M, CTX>

      • Parameters

        • computation: (ctx: CTX) => Get1<M, never[]>

          The computation to run.

        Returns CatFailT<M, CTX>

        A new CatT with modified environment.

    when: (
        cond: (ctx: CTX) => boolean,
        computation: (ctx: CTX) => Get1<M, never[]>,
    ) => CatFailT<M, CTX>

    Runs a computation if only cond is satisfied.

    Type Declaration

      • (
            cond: (ctx: CTX) => boolean,
            computation: (ctx: CTX) => Get1<M, never[]>,
        ): CatFailT<M, CTX>

      • Parameters

        • cond: (ctx: CTX) => boolean

          A condition function.

        • computation: (ctx: CTX) => Get1<M, never[]>

          A monadic operation used only if cond returns true.

        Returns CatFailT<M, CTX>

        A new CatT with modified environment.

    while: (
        cond: (ctx: CTX) => Get1<M, boolean>,
        body: (ctx: CTX) => Get1<M, never[]>,
    ) => CatFailT<M, CTX>

    Runs a looping computation while cond returns true.

    Type Declaration

      • (
            cond: (ctx: CTX) => Get1<M, boolean>,
            body: (ctx: CTX) => Get1<M, never[]>,
        ): CatFailT<M, CTX>

      • Parameters

        • cond: (ctx: CTX) => Get1<M, boolean>

          A function to decide to continue the loop.

        • body: (ctx: CTX) => Get1<M, never[]>

          A computation to run.

        Returns CatFailT<M, CTX>

        A new CatT with modified environment.

    Settings

    Member Visibility

    On This Page

    Properties