t-tasks 1.2.1 → 2.1.0

package/dist/maybe.d.ts

@@ -1,595 +0,0 @@
-/**
- * Just a value
- *
- * Maybe data type specialization representing an existing value
- *
- * @template R underlying value
- */
-export interface Just<R> {
-    readonly just: R;
-    /**
-     * Maybe peeker function
-     *
-     * Applied to 'just value' returns self invoking op(value) in process
-     * Applied to 'nothing' returns self without invoking callback
-     *
-     * @param op function to be invoked with underlying value
-     * @returns self
-     */
-    tap(op: (value: R) => void): this;
-    /**
-     * Maybe fallback peeker function
-     *
-     * Applied to 'just value' returns self without invoking callback
-     * Applied to 'nothing' returns self invoking op() in process
-     *
-     * @param op function to be invoked
-     * @returns self
-     */
-    orTap(op: () => void): this;
-    /**
-     * Maybe patter matching peeker function
-     *
-     * Applied to 'just value' returns self invoking op.just(value) in process
-     * Applied to 'nothing' returns self invoking op.nothing() in process
-     *
-     * @param op.just function to be invoked with underlying value in case of just
-     * @param op.nothing function to be invoked in case of nothing
-     * @returns self
-     */
-    matchTap(op: {
-        just: (value: R) => void;
-        nothing: () => void;
-    }): this;
-    /**
-     * Maybe transformer function
-     *
-     * Applied to 'just value' returns 'just op(value)'
-     * Applied to 'nothing' returns self without invoking transformer
-     *
-     * @template R2 transformer function's return type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'just op(value)' or 'nothing'
-     */
-    map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;
-    map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;
-    /**
-     * Maybe fallback transformer function
-     *
-     * Applied to 'just value' returns self without invoking transformer
-     * Applied to 'nothing' returns 'just op()'
-     *
-     * @param op function to be invoked
-     * @returns 'just value' or 'just op()'
-     */
-    orMap<R2>(this: Just<R>, op: () => R2): Just<R>;
-    orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
-    /**
-     * Maybe patter matching transformer function
-     *
-     * Applied to 'just value' returns 'just op.just(value)'
-     * Applied to 'nothing' returns 'just op.nothing()'
-     *
-     * @template R2 just transformer function's return type
-     * @template R3 nothing transformer function's return type
-     * @param op.just transformer to be invoked with underlying value in case of just
-     * @param op.nothing transformer to be invoked in case of nothing
-     * @returns 'just op.just(value)' or 'just op.nothing()'
-     */
-    matchMap<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => R2;
-        nothing: () => R3;
-    }): Just<R2>;
-    matchMap<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => R2;
-        nothing: () => R3;
-    }): Just<R2 | R3>;
-    /**
-     * Maybe composition function
-     *
-     * Applied to 'just value' returns 'op(value)'
-     * Applied to 'nothing' returns self without invoking composition function
-     *
-     * @template R2 transformer function result's underlying type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'op(value)' or 'nothing'
-     */
-    chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;
-    chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
-    chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
-    /**
-     * Maybe fallback composition function
-     *
-     * Applied to 'just value' returns self witjout invoking composition function
-     * Applied to 'nothing' returns op()
-     *
-     * @template R2 transformer function result's underlying type
-     * @param op transformer to be invoked
-     * @returns 'just value' or 'op()'
-     */
-    orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;
-    orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;
-    orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;
-    orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;
-    orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;
-    orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
-    /**
-     * Maybe patter matching composition function
-     *
-     * Applied to 'just value' returns 'op.just(value)'
-     * Applied to 'nothing' returns op.nothing()
-     *
-     * @template R2 just transformer function result's underlying type
-     * @template R3 nothing transformer function result's underlying type
-     * @param op.just transformer to be invoked with underlying value in case of just
-     * @param op.nothing transformer to be invoked in case of nothing
-     * @returns 'op.just(value)' or 'op.nothing()'
-     */
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R2>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Nothing<R3>;
-    }): Just<R2>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Just<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Maybe<R3>;
-    }): Just<R2>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Maybe<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Just<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Nothing<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Just<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Nothing<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Just<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Just<R3>;
-    }): Maybe<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Nothing<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R2 | R3>;
-    /**
-     * Maybe type guard for 'just'
-     *
-     * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')
-     *
-     * @example
-     * ```typescript
-     * if (maybe.isJust()) {
-     *   console.log(maybe.just);
-     * }
-     * ```
-     */
-    isJust(): this is Just<R>;
-    /**
-     * Maybe type guard for 'nothing'
-     *
-     * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')
-     *
-     * @example
-     * ```typescript
-     * if (maybe.isNohing()) {
-     *   console.log('nothing');
-     * }
-     * ```
-     */
-    isNothing(): this is Nothing<R>;
-    /**
-     * Wrap Maybe to singleton generator
-     *
-     * Userful in order to avoid ambiguous yied types
-     *
-     * @returns generator of Maybe wrapping this
-     */
-    generator: MaybeGeneratorFunction<[], R, Just<R>, R>;
-}
-/**
- * Absolutely Nothing
- *
- * Maybe data type specialiation representing an absence of any value
- */
-export interface Nothing<R> {
-    /**
-     * Maybe peeker function
-     *
-     * Applied to 'just value' returns self invoking op(value) in process
-     * Applied to 'nothing' returns self without invoking callback
-     *
-     * @param op function to be invoked with underlying value
-     * @returns self
-     */
-    tap(op: (value: R) => void): this;
-    /**
-     * Maybe fallback peeker function
-     *
-     * Applied to 'just value' returns self without invoking callback
-     * Applied to 'nothing' returns self invoking op() in process
-     *
-     * @param op function to be invoked
-     * @returns self
-     */
-    orTap(op: () => void): this;
-    /**
-     * Maybe patter matching peeker function
-     *
-     * Applied to 'just value' returns self invoking op.just(value) in process
-     * Applied to 'nothing' returns self invoking op.nothing() in process
-     *
-     * @param op.just function to be invoked with underlying value in case of just
-     * @param op.nothing function to be invoked in case of nothing
-     * @returns self
-     */
-    matchTap(op: {
-        just: (value: R) => void;
-        nothing: () => void;
-    }): this;
-    /**
-     * Maybe transformer function
-     *
-     * Applied to 'just value' returns 'just op(value)'
-     * Applied to 'nothing' returns self without invoking transformer
-     *
-     * @template R2 transformer function's return type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'just op(value)' or 'nothing'
-     */
-    map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;
-    map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;
-    /**
-     * Maybe fallback transformer function
-     *
-     * Applied to 'just value' returns self without invoking transformer
-     * Applied to 'nothing' returns 'just op()'
-     *
-     * @param op function to be invoked
-     * @returns 'just value' or 'just op()'
-     */
-    orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;
-    orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
-    /**
-     * Maybe patter matching transformer function
-     *
-     * Applied to 'just value' returns 'just op.just(value)'
-     * Applied to 'nothing' returns 'just op.nothing()'
-     *
-     * @template R2 just transformer function's return type
-     * @template R3 nothing transformer function's return type
-     * @param op.just transformer to be invoked with underlying value in case of just
-     * @param op.nothing transformer to be invoked in case of nothing
-     * @returns 'just op.just(value)' or 'just op.nothing()'
-     */
-    matchMap<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => R2;
-        nothing: () => R3;
-    }): Just<R3>;
-    matchMap<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => R2;
-        nothing: () => R3;
-    }): Just<R2 | R3>;
-    /**
-     * Maybe composition function
-     *
-     * Applied to 'just value' returns 'op(value)'
-     * Applied to 'nothing' returns self without invoking composition function
-     *
-     * @template R2 transformer function result's underlying type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'op(value)' or 'nothing'
-     */
-    chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;
-    chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
-    chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
-    chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
-    /**
-     * Maybe fallback composition function
-     *
-     * Applied to 'just value' returns self witjout invoking composition function
-     * Applied to 'nothing' returns op()
-     *
-     * @template R2 transformer function result's underlying type
-     * @param op transformer to be invoked
-     * @returns 'just value' or 'op()'
-     */
-    orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;
-    orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;
-    orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;
-    orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;
-    orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;
-    orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
-    /**
-     * Maybe patter matching composition function
-     *
-     * Applied to 'just value' returns 'op.just(value)'
-     * Applied to 'nothing' returns op.nothing()
-     *
-     * @template R2 just transformer function result's underlying type
-     * @template R3 nothing transformer function result's underlying type
-     * @param op.just transformer to be invoked with underlying value in case of just
-     * @param op.nothing transformer to be invoked in case of nothing
-     * @returns 'op.just(value)' or 'op.nothing()'
-     */
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R3>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R3>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R3>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Just<R3>;
-    }): Just<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Nothing<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Just<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Nothing<R3>;
-    }): Nothing<never>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Just<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Nothing<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Just<R3>;
-    }): Maybe<R2 | R3>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Nothing<R3>;
-    }): Maybe<R2>;
-    matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
-        just: (value: R) => Maybe<R2>;
-        nothing: () => Maybe<R3>;
-    }): Maybe<R2 | R3>;
-    /**
-     * Maybe type guard for 'just'
-     *
-     * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')
-     *
-     * @example
-     * ```typescript
-     * if (maybe.isJust()) {
-     *   console.log(maybe.just);
-     * }
-     * ```
-     */
-    isJust(): this is Just<R>;
-    /**
-     * Maybe type guard for 'nothing'
-     *
-     * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')
-     *
-     * @example
-     * ```typescript
-     * if (maybe.isNohing()) {
-     *   console.log('nothing');
-     * }
-     * ```
-     */
-    isNothing(): this is Nothing<R>;
-    /**
-     * Wrap Maybe to singleton generator
-     *
-     * Userful in order to avoid ambiguous yied types
-     *
-     * @returns generator of Maybe wrapping this
-     */
-    generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>;
-}
-/**
- * Genric Maybe monad interface
- *
- * As per classic Maybe monad implementation can eithr contain just a value or contain nothing
- * Used throughout the library to represent optional return type, specifically return type of cancelled tasks
- *
- * @template R underlying value
- */
-export type Maybe<R> = Just<R> | Nothing<R>;
-export declare namespace Just {
-    /**
-     * Standalone Just value extractor
-     *
-     * Userful for passing as a function to collection transformers
-     *
-     * @template R underlying value type
-     * @param just Just instance
-     * @returns underlying value
-     */
-    function just<R>(just: Just<R>): R;
-}
-export declare namespace Nothing { }
-export type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;
-export type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;
-export declare namespace Maybe {
-    /**
-     * Non-empty monad constructor
-     *
-     * @template R underlying type
-     * @param value underlying value
-     * @returns 'just value'
-     */
-    function just<R>(value: R): Just<R>;
-    /**
-     * Empty monad constructor
-     *
-     * @returns 'nothing'
-     */
-    function nothing(): Nothing<never>;
-    /**
-     * Maybe constructor from optional value
-     *
-     * Resolves to 'nothing' in case of undefined value and 'just value' otherwise
-     *
-     * @param value possibly undefined value
-     * @returns either 'just value' or 'nothing'
-     */
-    function fromOptional(value: undefined): Nothing<never>;
-    function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;
-    function fromOptional<R>(value: R | undefined): Maybe<R>;
-    /**
-     * Maybe constructor from optional or nullable value
-     *
-     * Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise
-     *
-     * @param value possibly undefined value
-     * @returns either 'just value' or 'nothing'
-     */
-    function fromNullable(value: undefined): Nothing<never>;
-    function fromNullable(value: null): Nothing<never>;
-    function fromNullable<R>(value: Exclude<R, null | undefined>): Just<R>;
-    function fromNullable<R>(value: R | null | undefined): Maybe<R>;
-    /**
-     * Standalone type guard for 'just'
-     *
-     * Userful for passing as a predicate to collection transformers
-     *
-     * @template R underlying value type
-     * @param maybe Maybe instance
-     * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')
-     */
-    function isJust<R>(maybe: Maybe<R>): maybe is Just<R>;
-    /**
-     * Standalone type guard for 'nothing'
-     *
-     * Userful for passing as a predicate to collection transformers
-     *
-     * @template R underlying value type
-     * @param maybe Maybe instance
-     * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')
-     */
-    function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<never>;
-    /**
-     * Standalone list predicate
-     *
-     * @param maybes a list of Maybe
-     * @returns true in case every list element is Just
-     */
-    function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[];
-    /**
-     * Standalone list predicate
-     *
-     * @param maybes a list of Maybe
-     * @returns true in case al east one list element is Just
-     */
-    function someJust<R>(maybes: Maybe<R>[]): boolean;
-    /**
-     * Standalone list predicate
-     *
-     * @param maybes a list of Maybe
-     * @returns true in case every list element is Nothing
-     */
-    function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[];
-    /**
-     * Standalone list predicate
-     *
-     * @param maybes a list of Maybe
-     * @returns true in case at least one list element is Nothing
-     */
-    function someNothing<R>(maybes: Maybe<R>[]): boolean;
-    /**
-     * Create compound Maybe from generator function
-     *
-     * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success
-     * However the convinient option for typescript is to use ```yield* maybe.generator()``` as othervise one may have to deal with union types
-     *
-     * @template TT yielded Maybe type
-     * @template R returned underlying type
-     * @param maybeGeneratorFunction Maybe generator function
-     * @returns Just wrapping the result of generator function or Nothing
-     * ```
-     */
-    function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R>;
-}

package/dist/t-tasks.modern.mjs

@@ -1,2 +0,0 @@
-let t,e,r;var n;(t||(t={})).just=function(t){return t.just},(n=r||(r={})).just=function(t){return new i(t)},n.nothing=function(){return u},n.fromOptional=function(t){return void 0!==t?r.just(t):r.nothing()},n.fromNullable=function(t){return r.fromOptional(t).chain(t=>null!==t?r.just(t):r.nothing())},n.isJust=function(t){return t.isJust()},n.isNothing=function(t){return t.isNothing()},n.everyJust=function(t){return t.every(r.isJust)},n.someJust=function(t){return t.some(r.isJust)},n.everyNothing=function(t){return t.every(r.isNothing)},n.someNothing=function(t){return t.some(r.isNothing)},n.generate=function(t){const e=t(),n=t=>t.done?r.just(t.value):t.value.matchChain({just:t=>n(e.next(t)),nothing:r.nothing});return r.just(void 0).chain(()=>n(e.next()))};class i{constructor(t){this.just=t}tap(t){return t(this.just),this}orTap(){return this}map(t){return r.just(t(this.just))}orMap(){return this}chain(t){return t(this.just)}orChain(){return this}isJust(){return!0}isNothing(){return!1}matchTap(t){return this.tap(t.just)}matchMap(t){return this.map(t.just)}matchChain(t){return this.chain(t.just)}generator(){return function*(t){return yield t}(this)}}const u=new class{tap(){return this}orTap(t){return t(),this}map(){return this}orMap(t){return r.just(t())}chain(){return this}orChain(t){return t()}isJust(){return!1}isNothing(){return!0}matchTap(t){return this.orTap(t.nothing)}matchMap(t){return this.orMap(t.nothing)}matchChain(t){return this.orChain(t.nothing)}generator(){return function*(t){return yield t}(this)}};let o,c,a;var s;(o||(o={})).right=function(t){return t.right},(c||(c={})).left=function(t){return t.left},(s=a||(a={})).right=function(t){return new h(t)},s.left=function(t){return new l(t)},s.fromOptional=function(t,e){return void 0!==t?a.right(t):a.left(e)},s.fromNullable=function(t,e){return a.fromOptional(t,e).chain(r=>null!==r?a.right(t):a.left(e))},s.isRight=function(t){return t.isRight()},s.isLeft=function(t){return t.isLeft()},s.everyRight=function(t){return t.every(a.isRight)},s.someRight=function(t){return t.some(a.isRight)},s.everyLeft=function(t){return t.every(a.isLeft)},s.someLeft=function(t){return t.some(a.isLeft)},s.generate=function(t){const e=t(),r=t=>t.done?a.right(t.value):t.value.matchChain({right:t=>r(e.next(t)),left:a.left});return a.right(void 0).chain(()=>r(e.next()))};class h{constructor(t){this.right=t}tap(t){return t(this.right),this}orTap(){return this}map(t){return a.right(t(this.right))}orMap(){return this}chain(t){return t(this.right)}orChain(){return this}isRight(){return!0}isLeft(){return!1}matchTap(t){return this.tap(t.right)}matchMap(t){return this.map(t.right)}matchChain(t){return this.chain(t.right)}generator(){return function*(t){return yield t}(this)}}class l{constructor(t){this.left=t}tap(){return this}orTap(t){return t(this.left),this}map(){return this}orMap(t){return a.right(t(this.left))}chain(){return this}orChain(t){return t(this.left)}isRight(){return!1}isLeft(){return!0}matchTap(t){return this.orTap(t.left)}matchMap(t){return this.orMap(t.left)}matchChain(t){return this.orChain(t.left)}generator(){return function*(t){return yield t}(this)}}let f;!function(e){function n(t){const e=t(),r=t=>t.done?f.resolved(t.value):t.value.matchChain({resolved:t=>r(e.next(t)),rejected:t=>r(e.throw(t)),canceled:f.canceled});return f.resolved(void 0).chain(()=>r(e.next()))}function i(t,e){let n;const[i,u]=m();return f.create(new Promise(e=>{u(e),n=t(t=>i(r.just(a.right(t))),t=>i(r.just(a.left(t))),()=>i(r.nothing()))}),t=>{i(t.map(a.left)),e(n)})}e.create=function(t,e){return new M(t,e)},e.resolved=function(t){return f.create(Promise.resolve(r.just(a.right(t))),()=>{})},e.rejected=function(t){return f.create(Promise.resolve(r.just(a.left(t))),()=>{})},e.canceled=function(){return f.create(Promise.resolve(r.nothing()),()=>{})},e.fromPromise=function(t){const[e,n]=m();return f.create(new Promise(i=>{n(i),t.then(a.right,a.left).then(r.just).then(e)}),t=>e(t.map(a.left)))},e.fromFunction=function(t,e){const[n,i]=m(),u=t=>n(t.map(a.left));return e.cancel=u,f.create(new Promise(e=>{i(e);try{n(r.just(a.right(t())))}catch(t){n(r.just(a.left(t)))}}),u)},e.promiseGenerator=function(t){return f.fromPromise(t).generator()},e.timeoutGenerator=function(t){return f.timeout(t).generator()},e.lift=function(t){return(...e)=>f.fromPromise(t(...e))},e.generate=n,e.generateFunction=function(t){return(...e)=>n(function*(){return yield*t(...e)})},e.timeout=function(t){return i(e=>setTimeout(()=>e(),t),clearTimeout)},e.fromCallback=i,e.sequence=function(t){return Array.from(t).reduce((t,e)=>t.chain(t=>e().map(e=>t.concat(e))),f.resolved([]))},e.all=function(e){const[n,i]=m(),u=Array.from(e),o=t=>u.forEach(e=>e._cancel(t)),c=u.map(r.nothing),s=t=>{n(t.map(a.left)),o(t)};return f.create(new Promise(e=>{if(i(e),u.length<1)return n(r.just(a.right([])));u.map((e,i)=>e.matchTap({resolved:e=>((e,i)=>{c[i]=r.just(e),r.everyJust(c)&&n(r.just(a.right(c.map(t.just))))})(e,i),rejected:t=>s(r.just(t)),canceled:()=>s(r.nothing())}))}),o)},e.any=function(e){const[n,i]=m(),u=Array.from(e),o=t=>u.forEach(e=>e._cancel(t)),c=u.map(r.nothing),s=t=>{n(t.map(a.right)),o(r.nothing())};return f.create(new Promise(e=>{if(i(e),u.length<1)return n(r.nothing());u.map((e,i)=>e.matchTap({resolved:t=>s(r.just(t)),rejected:e=>((e,i)=>{c[i]=r.just(e),r.everyJust(c)&&n(r.just(a.left(c.map(t.just))))})(e,i),canceled:()=>s(r.nothing())}))}),o)},e.limit=function(t,e){return f.any([t,e.chain(f.canceled)]).chainRejected(t=>f.rejected(t[0]))},e.repeat=function(t){const e=()=>t().chainRejected(e);return e()}}(f||(f={}));const m=()=>{const t=()=>{};let e=t;return[r=>{const n=e;e=t,n(r)},t=>{e=t}]};function g(t,e){const n={cancel:t._cancel};return f.create(t._invoke.then(async t=>{try{const{_invoke:i,_cancel:u}=f.fromFunction(()=>e(t),n);n.cancel=u;const o=await i;if(o.isNothing())return r.nothing();if(o.just.isLeft())return r.just(a.left(o.just.left));const{_invoke:c,_cancel:s}=o.just.right;return n.cancel=s,c}catch(t){return r.just(a.left(t))}}),t=>n.cancel(t))}function p(t,e){return g(t,t=>t.map(e).orMap(f.canceled).just)}function j(t,e){return g(t,t=>e(t).matchMap({just:t=>t.matchMap({right:f.resolved,left:f.rejected}).right,nothing:f.canceled}).just)}function d(t,e){return j(t,t=>t.map(e))}function v(t,e){return j(t,t=>(e(t),t))}function y(t,e){return v(t,t=>t.tap(e))}class M{constructor(t,e){this._invoke=t,this._cancel=e}tapCanceled(t){return v(this,e=>e.orTap(t))}tapRejected(t){return y(this,e=>e.orTap(t))}tap(t){return y(this,e=>e.tap(t))}mapCanceled(t){return j(this,e=>e.orMap(()=>a.right(t())))}mapRejected(t){return d(this,e=>e.orMap(t))}map(t){return d(this,e=>e.map(t))}chainCanceled(t){const e=t=>t.map(f.resolved).orMap(f.rejected).right;return g(this,r=>r.map(e).orMap(t).just)}chainRejected(t){return p(this,e=>e.map(f.resolved).orMap(t).right)}chain(t){return p(this,e=>e.map(t).orMap(f.rejected).right)}resolve(){return this._invoke}cancel(){return this._cancel(r.nothing())}reject(t){return this._cancel(r.just(t))}generator(){return function*(t){return yield t}(this)}matchTap(t){return v(this,e=>e.matchTap({just:e=>e.matchTap({right:t.resolved,left:t.rejected}),nothing:t.canceled}))}matchMap(t){return j(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}),nothing:()=>a.right(t.canceled())}))}matchChain(t){return g(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}).right,nothing:t.canceled}).just)}}export{a as Either,t as Just,c as Left,r as Maybe,e as Nothing,o as Right,f as Task};
-//# sourceMappingURL=t-tasks.modern.mjs.map