@jsoldi/hkt/dist/classes/monadPlus.d.ts

Higher kinded types for typescript and a few utility monads.

import { $, $K1 } from "../core/hkt.js";
import { IMonad, IMonadBase } from "./monad.js";
import { IMonoid, IMonoidBase } from "./monoid.js";
import { TypeClassArg } from "./utilities.js";
import { ISemiring } from "./semiring.js";
/** The monad plus interface. */
export interface IMonadPlus<F> extends IMonad<F>, IMonoid<F> {
    /** Guards a value based on a boolean condition. */
    guard(b: unknown): $<F, null>;
    /** Creates a semiring from a monoid where addition is this monadPlus and multiplication is the given monoid. */
    semiring<M>(mult: IMonoid<M>): ISemiring<F, M>;
    /** Creates a monad from an array of values. */
    from<A>(as: A[]): $<F, A>;
    /** Filters values in a monadPlus based on a predicate. */
    filter<A, B extends A>(f: (a: A) => a is B): (fa: $<F, A>) => $<F, B>;
    filter<A>(f: (a: A) => unknown): (fa: $<F, A>) => $<F, A>;
    /** Applies a monadic action zero or more times. */
    some<A>(fa: $<F, A>): $<F, A[]>;
    /** Applies a monadic action one or more times. */
    many<A>(fa: $<F, A>): $<F, A[]>;
}
declare const is_monadPlus: unique symbol;
export type MonadPlusArg<F> = TypeClassArg<IMonadBase<F> & IMonoidBase<F>, IMonadPlus<F>, typeof is_monadPlus>;
/** Creates a `IMonadPlus` from an instance of `IMonadBase` and `IMonoidBase`. */
export declare function _monadPlus<F>(base: MonadPlusArg<F>): IMonadPlus<F>;
export declare namespace _monadPlus {
    var _a: <T>(t: T) => IMonadPlus<$K1<T>>;
    var _b: IMonadPlus<$K1<void>>;
    var _c: IMonadPlus<$K1<null>>;
    export { _a as const, _b as void, _c as null };
}
/** The monad plus factory. */
export interface IMonadPlusFactory {
    /** Creates a monad plus from a monad and a monoid. */
    <F>(base: MonadPlusArg<F>): IMonadPlus<F>;
    /** Creates a constant monadPlus. Type T **must** have a single instance such as `null`. */
    const<const T>(t: T): IMonad<$K1<T>>;
    /** The void constant. */
    readonly void: IMonad<$K1<void>>;
    /** Creates a monad plus with a null type. */
    readonly null: IMonad<$K1<null>>;
}
/** The monad plus factory. */
export declare const monadPlus: IMonadPlusFactory;
export {};
//# sourceMappingURL=monadPlus.d.ts.map