npm - t-tasks - Versions diffs - 2.0.0 → 2.1.0 - Mend

t-tasks 2.0.0 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/t-tasks.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"t-tasks.js","names":[],"sources":["../src/maybe.ts","../src/either.ts","../src/task.ts"],"sourcesContent":["/*\n Just a value\n \n Maybe data type specialization representing an existing value\n \n @template R underlying value\n /\nexport interface Just<R> {\n readonly just: R;\n\n /\n Maybe peeker function\n \n Applied to 'just value' returns self invoking op(value) in process\n * Applied to 'nothing' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Maybe fallback peeker function\n \n Applied to 'just value' returns self without invoking callback\n * Applied to 'nothing' returns self invoking op() in process\n \n @param op function to be invoked\n * @returns self\n /\n orTap(op: () => void): this;\n\n /\n Maybe pattern matching peeker function\n \n Applied to 'just value' returns self invoking op.just(value) in process\n * Applied to 'nothing' returns self invoking op.nothing() in process\n \n @param op.just function to be invoked with underlying value in case of just\n * @param op.nothing function to be invoked in case of nothing\n * @returns self\n /\n matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n /\n Maybe transformer function\n \n Applied to 'just value' returns 'just op(value)'\n * Applied to 'nothing' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'just op(value)' or 'nothing'\n /\n // Just case\n map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;\n // Generic case\n map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n /\n Maybe fallback transformer function\n \n Applied to 'just value' returns self without invoking transformer\n * Applied to 'nothing' returns 'just op()'\n \n @param op function to be invoked\n * @returns 'just value' or 'just op()'\n /\n // Just case\n orMap<R2>(this: Just<R>, op: () => R2): Just<R>;\n // Generic case\n orMap<R2>(this: Maybe<R>, op: () => R2): Just<R \| R2>;\n\n /\n Maybe pattern matching extractor function\n \n Applied to 'just value' returns op.just(value)\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just extractor function's return type\n * @template R3 nothing extractor function's return type\n * @param op.just extractor to be invoked with underlying value in case of just\n * @param op.nothing extractor to be invoked in case of nothing\n * @returns op.just(value) or op.nothing()\n /\n // Just cases\n match<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2;\n // General case\n match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 \| R3;\n\n // Nothing cases\n matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;\n // General case\n matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 \| R3>;\n\n\n /\n Maybe composition function\n \n Applied to 'just value' returns 'op(value)'\n * Applied to 'nothing' returns self without invoking composition function\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'nothing'\n /\n // Just cases\n chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;\n chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n // General cases\n chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n /\n Maybe fallback composition function\n \n Applied to 'just value' returns self without invoking composition function\n * Applied to 'nothing' returns op()\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked\n * @returns 'just value' or 'op()'\n /\n // Just cases\n orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;\n orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;\n orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;\n // General case\n orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R \| R2>;\n orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R \| R2>;\n\n /\n Maybe pattern matching composition function\n \n Applied to 'just value' returns 'op.just(value)'\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just transformer function result's underlying type\n * @template R3 nothing transformer function result's underlying type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'op.just(value)' or 'op.nothing()'\n /\n // Just cases\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2>;\n // General cases\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n\n /\n Maybe type guard for 'just'\n \n @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n \n @example\n * ```typescript\n * if (maybe.isJust()) {\n * console.log(maybe.just);\n * }\n * ```\n /\n isJust(): this is Just<R>;\n\n /\n Maybe type guard for 'nothing'\n \n @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n \n @example\n * ```typescript\n * if (maybe.isNothing()) {\n * console.log('nothing');\n * }\n * ```\n /\n isNothing(): this is Nothing<R>;\n\n /\n Wrap Maybe to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Maybe wrapping this\n /\n generator: MaybeGeneratorFunction<[], R, Just<R>, R>\n}\n\n/\n Absolutely Nothing\n \n Maybe data type specialization representing an absence of any value\n /\nexport interface Nothing<R> {\n /\n Maybe peeker function\n \n Applied to 'just value' returns self invoking op(value) in process\n * Applied to 'nothing' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Maybe fallback peeker function\n \n Applied to 'just value' returns self without invoking callback\n * Applied to 'nothing' returns self invoking op() in process\n \n @param op function to be invoked\n * @returns self\n /\n orTap(op: () => void): this;\n\n /\n Maybe pattern matching peeker function\n \n Applied to 'just value' returns self invoking op.just(value) in process\n * Applied to 'nothing' returns self invoking op.nothing() in process\n \n @param op.just function to be invoked with underlying value in case of just\n * @param op.nothing function to be invoked in case of nothing\n * @returns self\n /\n matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n /\n Maybe transformer function\n \n Applied to 'just value' returns 'just op(value)'\n * Applied to 'nothing' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'just op(value)' or 'nothing'\n /\n // Nothing case\n map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;\n // Generic case\n map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n /\n Maybe fallback transformer function\n \n Applied to 'just value' returns self without invoking transformer\n * Applied to 'nothing' returns 'just op()'\n \n @param op function to be invoked\n * @returns 'just value' or 'just op()'\n /\n // Nothing case\n orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;\n // Generic case\n orMap<R2>(this: Maybe<R>, op: () => R2): Just<R \| R2>;\n\n /\n Maybe pattern matching extractor function\n \n Applied to 'just value' returns op.just(value)\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just extractor function's return type\n * @template R3 nothing extractor function's return type\n * @param op.just extractor to be invoked with underlying value in case of just\n * @param op.nothing extractor to be invoked in case of nothing\n * @returns op.just(value) or op.nothing()\n /\n // Nothing cases\n match<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R3;\n // General case\n match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 \| R3;\n\n // Just cases\n matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;\n // General case\n matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 \| R3>;\n\n /\n Maybe composition function\n \n Applied to 'just value' returns 'op(value)'\n * Applied to 'nothing' returns self without invoking composition function\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'nothing'\n /\n // Nothing cases\n chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;\n chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;\n // General cases\n chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n /\n Maybe fallback composition function\n \n Applied to 'just value' returns self without invoking composition function\n * Applied to 'nothing' returns op()\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked\n * @returns 'just value' or 'op()'\n /\n // Nothing cases\n orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;\n orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;\n orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;\n // General cases\n orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R \| R2>;\n orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R \| R2>;\n\n /\n Maybe pattern matching composition function\n \n Applied to 'just value' returns 'op.just(value)'\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just transformer function result's underlying type\n * @template R3 nothing transformer function result's underlying type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'op.just(value)' or 'op.nothing()'\n /\n // Nothing cases\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n // General cases\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n\n /\n Maybe type guard for 'just'\n \n @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n \n @example\n * ```typescript\n * if (maybe.isJust()) {\n * console.log(maybe.just);\n * }\n * ```\n /\n isJust(): this is Just<R>;\n\n /\n Maybe type guard for 'nothing'\n \n @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n \n @example\n * ```typescript\n * if (maybe.isNothing()) {\n * console.log('nothing');\n * }\n * ```\n /\n isNothing(): this is Nothing<R>;\n\n /\n Wrap Maybe to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Maybe wrapping this\n /\n generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>\n}\n\n/\n Generic Maybe monad interface\n \n As per classic Maybe monad implementation can either contain just a value or contain nothing\n * Used throughout the library to represent optional return type, specifically return type of cancelled tasks\n \n @template R underlying value\n /\nexport type Maybe<R> = Just<R> \| Nothing<R>;\n\nexport namespace Just {\n /\n Standalone Just value extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @param just Just instance\n * @returns underlying value\n /\n export function just<R>(just: Just<R>) {\n return just.just;\n }\n}\n\nexport namespace Nothing {}\n\nexport type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;\nexport type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;\n\nexport namespace Maybe {\n /\n Non-empty monad constructor\n \n @template R underlying type\n * @param value underlying value\n * @returns 'just value'\n /\n export function just<R>(value: R): Just<R> {\n return new JustClass<R>(value);\n }\n\n /\n Empty monad constructor\n \n @returns 'nothing'\n /\n export function nothing<R = never>(): Nothing<R> {\n return staticNothing as Nothing<R>;\n }\n\n /\n Maybe constructor from optional value\n \n Resolves to 'nothing' in case of undefined value and 'just value' otherwise\n \n @param value possibly undefined value\n * @returns either 'just value' or 'nothing'\n /\n export function fromOptional(value: undefined): Nothing<never>;\n export function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;\n export function fromOptional<R>(value: R \| undefined): Maybe<R>;\n export function fromOptional<R>(value: R \| undefined) {\n return typeof value !== 'undefined' ? Maybe.just(value) : Maybe.nothing();\n }\n\n /\n Maybe constructor from optional or nullable value\n \n Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise\n \n @param value possibly undefined value\n * @returns either 'just value' or 'nothing'\n /\n export function fromNullable(value: undefined): Nothing<never>;\n export function fromNullable(value: null): Nothing<never>;\n export function fromNullable<R>(value: Exclude<R, null \| undefined>): Just<R>;\n export function fromNullable<R>(value: R \| null \| undefined): Maybe<R>;\n export function fromNullable<R>(value: R \| null \| undefined) {\n return Maybe.fromOptional(value).chain((v) => (v !== null ? Maybe.just(v) : Maybe.nothing()));\n }\n\n /\n Standalone Maybe value extractor\n \n Applied to 'just value' returns underlying value without using fallback\n * Applied to 'nothing' returns fallback\n \n @template R underlying value type\n * @template R2 fallback value type\n * @param maybe Maybe instance\n * @param fallback value to be returned in case of 'nothing'\n * @returns underlying value or fallback\n /\n export function fromMaybe<R>(maybe: Just<R>, fallback: unknown): R;\n export function fromMaybe<R, R2>(maybe: Nothing<R>, fallback: R2): R2;\n export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2): R \| R2;\n export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2) {\n return maybe.match({ just: (value) => value, nothing: () => fallback });\n }\n\n /\n Standalone type guard for 'just'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param maybe Maybe instance\n * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')\n /\n export function isJust<R>(maybe: Maybe<R>): maybe is Just<R> {\n return maybe.isJust();\n }\n\n /\n Standalone type guard for 'nothing'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param maybe Maybe instance\n * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')\n /\n export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<R> {\n return maybe.isNothing();\n }\n\n /\n Standalone list predicate\n \n @param maybes a list of Maybe\n * @returns true in case every list element is Just\n /\n export function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {\n return maybes.every(Maybe.isJust);\n }\n\n /\n Standalone list predicate\n \n @param maybes a list of Maybe\n * @returns true in case at least one list element is Just\n /\n export function someJust<R>(maybes: Maybe<R>[]): boolean {\n return maybes.some(Maybe.isJust);\n }\n\n /\n Standalone list predicate\n \n @param maybes a list of Maybe\n * @returns true in case every list element is Nothing\n /\n export function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {\n return maybes.every(Maybe.isNothing);\n }\n\n /\n Standalone list predicate\n \n @param maybes a list of Maybe\n * @returns true in case at least one list element is Nothing\n /\n export function someNothing<R>(maybes: Maybe<R>[]): boolean {\n return maybes.some(Maybe.isNothing);\n }\n\n /\n Create compound Maybe from generator function\n \n Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success\n * However the convenient option for typescript is to use ```yield* maybe.generator()``` as otherwise one may have to deal with union types\n \n @template TT yielded Maybe type\n * @template R returned underlying type\n * @param maybeGeneratorFunction Maybe generator function\n * @returns Just wrapping the result of generator function or Nothing\n /\n export function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R> {\n const generator = maybeGeneratorFunction();\n let next = generator.next();\n\n while (!next.done) {\n if (next.value.isNothing()) {\n return Maybe.nothing();\n }\n\n next = generator.next(next.value.just);\n }\n\n return Maybe.just(next.value);\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass JustClass<R> implements Just<R> {\n constructor(readonly just: R) {}\n\n tap(op: (value: R) => void) {\n op(this.just);\n\n return this;\n }\n orTap() {\n return this;\n }\n map<R2>(op: (value: R) => R2) {\n return Maybe.just(op(this.just));\n }\n orMap() {\n return this;\n }\n chain<RR extends Maybe<unknown>>(op: (value: R) => RR) {\n return op(this.just);\n }\n orChain() {\n return this;\n }\n isJust(): this is Just<R> {\n return true;\n }\n isNothing(): this is Nothing<R> {\n return false;\n }\n match<R2>(op: { just: (value: R) => R2 }) {\n return op.just(this.just);\n }\n matchTap(op: { just: (value: R) => void }) {\n return this.tap(op.just);\n }\n matchMap<R2>(op: { just: (value: R) => R2 }) {\n return this.map(op.just);\n }\n matchChain<RR extends Maybe<unknown>>(op: { just: (value: R) => RR }) {\n return this.chain(op.just);\n }\n generator() {\n return (function(value) {\n return (yield value) as R;\n })(this);\n }\n}\n\nclass NothingClass implements Nothing<never> {\n tap() {\n return this;\n }\n orTap(op: () => void) {\n op();\n\n return this;\n }\n map() {\n return this;\n }\n orMap<R2>(op: () => R2) {\n return Maybe.just(op());\n }\n chain() {\n return this;\n }\n orChain<RR extends Maybe<unknown>>(op: () => RR) {\n return op();\n }\n isJust(): this is Just<never> {\n return false;\n }\n isNothing(): this is Nothing<never> {\n return true;\n }\n match<R2>(op: { nothing: () => R2 }) {\n return op.nothing();\n }\n matchTap(op: { nothing: () => void }) {\n return this.orTap(op.nothing);\n }\n matchMap<R2>(op: { nothing: () => R2 }) {\n return this.orMap(op.nothing);\n }\n matchChain<RR extends Maybe<unknown>>(op: { nothing: () => RR }) {\n return this.orChain(op.nothing);\n }\n generator() {\n return (function(value) {\n return (yield value) as never;\n })(this);\n }\n}\n\nconst staticNothing = new NothingClass();\n","/\n Right (correct) value of type R\n \n Either data type specialization representing a correct value\n \n @template R underlying value type\n * @template L underlying error type (needed for type merging, in fact always considered to be never)\n /\nexport interface Right<R, L> {\n readonly right: R;\n\n /\n Either peeker function\n \n Applied to 'right value' returns self invoking op(value) in process\n * Applied to 'left error' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Either fallback peeker function\n \n Applied to 'right value' returns self without invoking callback\n * Applied to 'left error' returns self invoking op(error) in process\n \n @param op function to be invoked with underlying error\n * @returns self\n /\n orTap(op: (error: L) => void): this;\n\n /\n Either pattern matching peeker function\n \n Applied to 'right value' returns self invoking op.right(value) in process\n * Applied to 'left error' returns self invoking op.left(error) in process\n \n @param op.right function to be invoked with underlying value in case of 'right'\n * @param op.left function to be invoked with underlying error in case of 'left'\n * @returns self\n /\n matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n /\n Either transformer function\n \n Applied to 'right value' returns 'right op(value)'\n * Applied to 'left error' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'right op(value)' or 'left error'\n /\n // Right case\n map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;\n // General case\n map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n /\n Either fallback transformer function\n \n Applied to 'right value' returns self without invoking transformer\n * Applied to 'left error' returns 'right op(error)'\n \n @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'right op(error)'\n /\n // Right case\n orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;\n // General case\n orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R \| R2, never>;\n\n /\n Either pattern matching extractor function\n \n Applied to 'right value' returns op.right(value)\n * Applied to 'left error' returns op.left(error)\n \n @template R2 right extractor function's return type\n * @template R3 left extractor function's return type\n * @param op.right extractor to be invoked with underlying value in case of 'right'\n * @param op.left extractor to be invoked with underlying error in case of 'left'\n * @returns op.right(value) or op.left(error)\n /\n // Right case\n match<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2;\n // General case\n match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 \| R3;\n\n // Right case\n matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;\n // General case\n matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 \| R3, never>;\n\n /\n Either composition function\n \n Applied to 'right value' returns 'op(value)'\n * Applied to 'left error' returns self without invoking composition function\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'left error'\n /\n // Right cases\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;\n // General cases\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L \| L2>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L \| L2>;\n\n /\n Either composition function\n \n Applied to 'right value' returns self without invoking composition function\n * Applied to 'left error' returns 'op(error)'\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'op(error)'\n /\n // Right cases\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;\n // General cases\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R \| R2, never>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R \| R2, L2>;\n\n /\n Either pattern matching composition function\n \n Applied to 'right value' returns 'op.right(value)'\n * Applied to 'left error' returns 'op.left(error)'\n \n @template R2 right transformer function result's underlying value type\n * @template L2 right transformer function result's underlying error type\n * @template R3 left transformer function result's underlying value type\n * @template L3 left transformer function result's underlying error type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'op(value)' or 'op(error)'\n /\n // Right cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2, L2>;\n // General cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 \| R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 \| R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L2 \| L3>;\n\n /\n Either type guard for 'right'\n \n @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n \n @example\n * ```typescript\n * if (either.isRight()) {\n * console.log(either.right)\n * }\n * ```\n /\n isRight(): this is Right<R, L>;\n\n /\n Either type guard for 'left'\n \n @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n \n @example\n * ```typescript\n * if (either.isLeft()) {\n * console.error(either.left)\n * }\n * ```\n /\n isLeft(): this is Left<R, L>;\n\n /\n Wrap Either to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Either wrapping this\n /\n generator: EitherGeneratorFunction<[], R, Right<R, L>, R>\n}\n\n/\n Left (erroneous) value of type L\n \n Either data type specialization representing an erroneous value\n \n @template R underlying value type (needed for type merging, in fact always considered to be never)\n * @template L underlying error type\n /\nexport interface Left<R, L> {\n readonly left: L;\n\n /\n Either peeker function\n \n Applied to 'right value' returns self invoking op(value) in process\n * Applied to 'left error' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Either fallback peeker function\n \n Applied to 'right value' returns self without invoking callback\n * Applied to 'left error' returns self invoking op(error) in process\n \n @param op function to be invoked with underlying error\n * @returns self\n /\n orTap(op: (error: L) => void): this;\n\n /\n Either pattern matching peeker function\n \n Applied to 'right value' returns self invoking op.right(value) in process\n * Applied to 'left error' returns self invoking op.left(error) in process\n \n @param op.right function to be invoked with underlying value in case of 'right'\n * @param op.left function to be invoked with underlying error in case of 'left'\n * @returns self\n /\n matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n /\n Either transformer function\n \n Applied to 'right value' returns 'right op(value)'\n * Applied to 'left error' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'right op(value)' or 'left error'\n /\n // Left case\n map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;\n // General case\n map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n /\n Either fallback transformer function\n \n Applied to 'right value' returns self without invoking transformer\n * Applied to 'left error' returns 'right op(error)'\n \n @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'right op(error)'\n /\n // Left case\n orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;\n // General case\n orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R \| R2, never>;\n\n /\n Either pattern matching extractor function\n \n Applied to 'right value' returns op.right(value)\n * Applied to 'left error' returns op.left(error)\n \n @template R2 right extractor function's return type\n * @template R3 left extractor function's return type\n * @param op.right extractor to be invoked with underlying value in case of 'right'\n * @param op.left extractor to be invoked with underlying error in case of 'left'\n * @returns op.right(value) or op.left(error)\n /\n // Left case\n match<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R3;\n // General case\n match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 \| R3;\n\n // Left case\n matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;\n // General case\n matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 \| R3, never>;\n\n /\n Either composition function\n \n Applied to 'right value' returns 'op(value)'\n * Applied to 'left error' returns self without invoking composition function\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'left error'\n /\n // Left cases\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;\n // General cases\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L \| L2>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L \| L2>;\n\n /\n Either fallback composition function\n \n Applied to 'right value' returns self without invoking composition function\n * Applied to 'left error' returns 'op(error)'\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'op(error)'\n /\n // Left cases\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;\n // General cases\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R \| R2, never>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R \| R2, L2>;\n\n /\n Either pattern matching composition function\n \n Applied to 'right value' returns 'op.right(value)'\n * Applied to 'left error' returns 'op.left(error)'\n \n @template R2 right transformer function result's underlying value type\n * @template L2 right transformer function result's underlying error type\n * @template R3 left transformer function result's underlying value type\n * @template L3 left transformer function result's underlying error type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'op(value)' or 'op(error)'\n /\n // Left cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n // General cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 \| R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 \| R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L2 \| L3>;\n\n /\n Either type guard for 'right'\n \n @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n \n @example\n * ```typescript\n * if (either.isRight()) {\n * console.log(either.right)\n * }\n * ```\n /\n isRight(): this is Right<R, L>;\n\n /\n Either type guard for 'left'\n \n @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n \n @example\n * ```typescript\n * if (either.isLeft()) {\n * console.error(either.left)\n * }\n * ```\n /\n isLeft(): this is Left<R, L>;\n\n /\n Wrap Either to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Either wrapping this\n /\n generator: EitherGeneratorFunction<[], R, Left<R, L>, R>\n}\n\n/\n Either data type: either Right value of type R or Left value of type L\n \n As per classic Either monad implementation can either contain a right (correct) value or a left (erroneous) value\n * Used throughout the library to represent the result of failable operations, namely failed tasks\n \n @template R underlying value type\n * @template L underlying error type\n /\nexport type Either<R, L> = Right<R, L> \| Left<R, L>;\n\nexport namespace Right {\n /\n Standalone Right value extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param right Right instance\n * @returns underlying value\n /\n export function right<R, L>(right: Right<R, L>) {\n return right.right;\n }\n}\n\nexport namespace Left {\n /\n Standalone Left error extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param left Left instance\n * @returns underlying error\n /\n export function left<R, L>(left: Left<R, L>) {\n return left.left;\n }\n}\n\nexport type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;\nexport type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;\n\nexport namespace Either {\n /\n Right monad constructor\n \n @template R underlying value type\n * @param value underlying value\n * @returns 'right value'\n /\n export function right<R>(value: R): Right<R, never> {\n return new RightClass<R>(value);\n }\n\n /\n Left monad constructor\n \n @template L underlying error type\n * @param error underlying error\n * @returns 'left error'\n /\n export function left<L>(error: L): Left<never, L> {\n return new LeftClass<L>(error);\n }\n\n /\n Either constructor from optional value\n \n Resolves to 'left error' in case of undefined value and 'right value' otherwise\n \n @param value possibly undefined value\n * @param error error to use in case of undefined value\n * @returns either 'right value' or 'left error'\n /\n export function fromOptional<L>(value: undefined, error: L): Left<never, L>;\n export function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;\n export function fromOptional<R, L>(value: R \| undefined, error: L): Either<R, L>;\n export function fromOptional<R, L>(value: R \| undefined, error: L) {\n return typeof value !== 'undefined' ? Either.right(value) : Either.left(error);\n }\n\n /\n Either constructor from optional or nullable value\n \n Resolves to 'left error' in case of undefined or null value and 'right value' otherwise\n \n @param value possibly undefined or nullable value\n * @param error error to use in case of undefined or nullable value\n * @returns either 'right value' or 'left error'\n /\n export function fromNullable<L>(value: undefined, error: L): Left<never, L>;\n export function fromNullable<L>(value: null, error: L): Left<never, L>;\n export function fromNullable<R>(value: Exclude<R, null \| undefined>, error: unknown): Right<R, never>;\n export function fromNullable<R, L>(value: R \| null \| undefined, error: L): Either<R, L>;\n export function fromNullable<R, L>(value: R \| null \| undefined, error: L) {\n return Either.fromOptional(value, error).chain((v) => (v !== null ? Either.right(value) : Either.left(error)));\n }\n\n /\n Standalone Either value extractor\n \n Applied to 'right value' returns underlying value without using fallback\n * Applied to 'left error' returns fallback\n \n @template R underlying value type\n * @template L underlying error type\n * @template R2 fallback value type\n * @param either Either instance\n * @param fallback value to be returned in case of 'left error'\n * @returns underlying value or fallback\n /\n export function fromEither<R, L>(either: Right<R, L>, fallback: unknown): R;\n export function fromEither<R, L, R2>(either: Left<R, L>, fallback: R2): R2;\n export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2): R \| R2;\n export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2) {\n return either.match({ right: (value) => value, left: () => fallback });\n }\n\n /\n Standalone type guard for 'right'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param either Either instance\n * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')\n /\n export function isRight<R, L>(either: Either<R, L>): either is Right<R, never> {\n return either.isRight();\n }\n\n /\n Standalone type guard for 'left'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param either Either instance\n * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')\n /\n export function isLeft<R, L>(either: Either<R, L>): either is Left<never, L> {\n return either.isLeft();\n }\n\n /\n Standalone list predicate\n \n @param eithers a list of Either\n * @returns true in case every list element is Right\n /\n export function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {\n return eithers.every(Either.isRight);\n }\n\n /\n Standalone list predicate\n \n @param eithers a list of Either\n * @returns true in case at least one list element is Right\n /\n export function someRight<R, L>(eithers: Either<R, L>[]): boolean {\n return eithers.some(Either.isRight);\n }\n\n /\n Standalone list predicate\n \n @param eithers a list of Either\n * @returns true in case every list element is Left\n /\n export function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {\n return eithers.every(Either.isLeft);\n }\n\n /\n Standalone list predicate\n \n @param eithers a list of Either\n * @returns true in case at least one list element is Left\n /\n export function someLeft<R, L>(eithers: Either<R, L>[]): boolean {\n return eithers.some(Either.isLeft);\n }\n\n /\n Create compound Either from generator function\n \n Applying yield to an Either within the generator function unwraps the Either and returns underlying value in case of success\n * However the convenient option for typescript is to use ```yield* either.generator()``` as otherwise one may have to deal with union types\n \n @template TT yielded Either type\n * @template R returned underlying type\n * @param eitherGeneratorFunction Either generator function\n * @returns Right wrapping the result of generator function or Left\n /\n export function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any> {\n const generator = eitherGeneratorFunction();\n let next = generator.next();\n\n while (!next.done) {\n if (next.value.isLeft()) {\n return Either.left(next.value.left);\n }\n\n next = generator.next(next.value.right);\n }\n\n return Either.right(next.value);\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass RightClass<R> implements Right<R, never> {\n constructor(readonly right: R) {}\n\n tap(op: (value: R) => void) {\n op(this.right);\n\n return this;\n }\n orTap() {\n return this;\n }\n map<R2>(op: (value: R) => R2) {\n return Either.right(op(this.right));\n }\n orMap() {\n return this;\n }\n chain<RR extends Either<unknown, unknown>>(op: (value: R) => RR) {\n return op(this.right);\n }\n orChain() {\n return this;\n }\n isRight(): this is Right<R, never> {\n return true;\n }\n isLeft(): this is Left<R, never> {\n return false;\n }\n match<R2>(op: { right: (value: R) => R2 }) {\n return op.right(this.right);\n }\n matchTap(op: { right: (value: R) => void }) {\n return this.tap(op.right);\n }\n matchMap<R2>(op: { right: (value: R) => R2 }) {\n return this.map(op.right);\n }\n matchChain<RR extends Either<unknown, unknown>>(op: { right: (value: R) => RR }) {\n return this.chain(op.right);\n }\n generator() {\n return (function(value) {\n return (yield value) as R;\n })(this);\n }\n}\n\nclass LeftClass<L> implements Left<never, L> {\n constructor(readonly left: L) {}\n\n tap() {\n return this;\n }\n orTap(op: (error: L) => void) {\n op(this.left);\n\n return this;\n }\n map() {\n return this;\n }\n orMap<R2>(op: (error: L) => R2) {\n return Either.right(op(this.left));\n }\n chain() {\n return this;\n }\n orChain<RR extends Either<unknown, unknown>>(op: (error: L) => RR) {\n return op(this.left);\n }\n isRight(): this is Right<never, L> {\n return false;\n }\n isLeft(): this is Left<never, L> {\n return true;\n }\n match<R2>(op: { left: (error: L) => R2 }) {\n return op.left(this.left);\n }\n matchTap(op: { left: (error: L) => void }) {\n return this.orTap(op.left);\n }\n matchMap<R2>(op: { left: (error: L) => R2 }) {\n return this.orMap(op.left);\n }\n matchChain<RR extends Either<unknown, unknown>>(op: { left: (error: L) => RR }) {\n return this.orChain(op.left);\n }\n generator() {\n return (function(value) {\n return (yield value) as never;\n })(this);\n }\n}\n","import { Maybe, Just } from './maybe';\nimport { Either, Right } from './either';\n\n/\n Shortcut for monadic Either type, where erroneous value is of type any\n \n @template R underlying type\n /\nexport type Rejectable<R> = Either<R, any>;\n\n/\n Shortcut for underlying task result type\n \n @template R underlying type\n /\nexport type Cancelable<R> = Maybe<Rejectable<R>>;\n\n/\n Function returning Task\n \n @template A argument types\n * @template R returned task resolve type\n /\nexport type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;\n\n/\n Task generator\n \n @template TT yielded task type\n * @template R returned task resolve type\n \n @example\n * ```typescript\n * const generatorFunction = function(): TaskGenerator<unknown, Task<string>, number> {\n const v = yield* someTaskFunction().generator();\n \n return v.length;\n * };\n * ```\n /\nexport type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;\n\n/\n Function returning task generator (generator function)\n \n @template A argument types\n * @template TT yielded task type\n * @template R returned task resolve type\n \n @example\n * ```typescript\n * const generatorFunction: TaskGeneratorFunction<[], unknown, Task<string>, number> = function() {\n const v = yield* someTaskFunction().generator();\n \n return v.length;\n * };\n * ```\n /\nexport type TaskGeneratorFunction<A extends unknown[], T, TT extends Task<T>, R> = (...args: A) => TaskGenerator<T, TT, R>;\n\n/\n Task monad interface\n \n @template R task resolve type\n /\nexport interface Task<R> extends TaskBase<R> {\n /\n Invoke callback when task is resolved (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tap(op: (value: R) => void): Task<R>;\n\n /\n Invoke callback when task is rejected (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tapRejected(op: (error: any) => void): Task<R>;\n\n /\n Invoke callback when task is canceled (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tapCanceled(op: () => void): Task<R>;\n\n /\n Invoke a dedicated callback according to task resolution\n \n @param op.resolved callback to invoke on success\n * @param op.rejected callback to invoke on failure\n * @param op.canceled callback to invoke on cancelation\n * @returns self\n /\n matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R>;\n\n /\n Invoke transformer when task is resolved (and only then) and return it's result instead\n \n @template R2 transformer return type\n * @param op transformer to invoke\n * @returns task returning transformer result\n /\n map<R2>(op: (value: R) => R2): Task<R2>;\n\n /\n Invoke transformer when task is rejected (and only then) and return it's result instead\n \n @template R2 fallback return type\n * @param op transformer to invoke\n * @returns task returning fallback result in case of failure\n /\n mapRejected<R2>(op: (error: any) => R2): Task<R \| R2>;\n\n /\n Invoke transformer when task is canceled (and only then) and return it's result instead\n \n @template R2 fallback return type\n * @param op transformer to invoke\n * @returns task returning fallback result in case of cancelation\n /\n mapCanceled<R2>(op: () => R2): Task<R \| R2>;\n\n /\n Invoke a dedicated transformer according to task resolution\n \n @template R2 success transformer return type\n * @template R3 failure transformer return type\n * @template R4 cancelation transformer return type\n * @param op.resolved transformer to invoke on success\n * @param op.rejected transformer to invoke on failure\n * @param op.canceled transformer to invoke on cancelation\n * @returns task resolving to a corresponding transformer result\n /\n matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 \| R3 \| R4>;\n\n /\n Invoke transformer when task is resolved (and only then) and continue execution with it's result\n \n @template R2 transformer task resolve type\n * @param op transformer to invoke\n * @returns task chaining to transformer result task\n /\n chain<R2>(op: (value: R) => Task<R2>): Task<R2>;\n\n /\n Invoke transformer when task is rejected (and only then) and continue execution with it's result\n \n @template R2 fallback task resolve type\n * @param op transformer to invoke\n * @returns task chaining to fallback task in case of failure\n /\n chainRejected<R2>(op: (error: any) => Task<R2>): Task<R \| R2>;\n\n /\n Invoke transformer when task is canceled (and only then) and continue execution with it's result\n \n @template R2 fallback task resolve type\n * @param op transformer to invoke\n * @returns task chaining to fallback task in case of cancelation\n /\n chainCanceled<R2>(op: () => Task<R2>): Task<R \| R2>;\n\n /\n Invoke a dedicated transformer according to task resolution and continue execution with it's result\n \n @template R2 success transformer resolve type\n * @template R3 failure transformer resolve type\n * @template R4 cancelation transformer resolve type\n * @param op.resolved transformer to invoke on success\n * @param op.rejected transformer to invoke on failure\n * @param op.canceled transformer to invoke on cancelation\n * @returns task chaining to a corresponding transformer result\n /\n matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 \| R3 \| R4>;\n\n resolved: () => Cancelable<R> \| null;\n\n /\n Return underlying promise in order to await result\n \n @returns underlying promise\n /\n resolve: () => TaskInvoke<R>;\n\n /\n Invoke underlying canel method without error\n /\n cancel: () => boolean;\n\n /\n Invoke underlying canel method with error\n \n @param error error value to be injected from outside\n /\n reject: (error: any) => boolean;\n\n /\n Wrap task to singleton generator\n \n Userful in order to avoid ambiguous yied types\n \n @returns generator of task wrapping the task\n * @example\n * ```typescript\n * const getString = () => Task.resolved('hello');\n * const getLength = (data: string) => Task.resolved(data.length);\n \n // ..... //\n \n Task.generate(function* () {\n * const data = yield getString(); // data: string \| number\n * const length = yield getLength(data); // length: string \| number\n \n return length;\n * });\n \n // ..... //\n \n Task.generate(function* () {\n * const data = yield* getString().generator(); // data: string\n * const length = yield* getLength(data).generator(); // length: number\n \n return length;\n * });\n * ```\n /\n generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;\n}\n\nexport namespace Task {\n /\n Custom task monad constructor\n \n @template R returned task's resolve type\n * @param invoke promise defining task execution\n * @param cancel cancelation function\n * @returns task resolving to resolve value of invoke\n \n @note low-level primitive for creating custom tasks, not intended for general use\n /\n export function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R> {\n return new TaskClass<R>({ resolved: false, invoke, cancel });\n }\n\n /\n Invariant task constructor creating resolved task from plain value\n \n @template R returned task's resolve type\n * @param value value to be returned upon awaiting\n * @returns task resolving to specified value\n /\n export function resolved<R>(value: R): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.right(value)) });\n }\n\n /\n Invariant task constructor creating rejected task from error value\n \n @template R returned task's resolve type\n * @param error error to be returned upon awaiting\n * @returns task resolving to specified value\n /\n export function rejected<R>(error: any): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.left(error)) });\n }\n\n /\n Invariant task constructor creating canceled task\n \n @template R returned task's resolve type\n * @returns task resolving to specified value\n /\n export function canceled<R>(): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.nothing() });\n }\n\n /\n Lift from promise to task resolving to that promise result\n \n Userfull for converting promises to tasks\n * If converted task is canceled or failed externally return value will be ignored without side-effects\n * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n \n @template R returned task resolve type\n * @param promise promise to be resolved\n * @returns task resolving to specified promise value\n \n @example\n * ```typescript\n * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);\n * ```\n /\n export function fromPromise<R>(promise: PromiseLike<R>): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));\n \n promise\n .then(Either.right, Either.left)\n .then(Maybe.just)\n .then(cell.resolve);\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Lift from sync function to task resolving to said function result\n \n Generally, functions are not considered tasks as they cannot be interrupted in any way\n * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from\n * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain\n * This function is mostly used internally and is not expected to be widely used except of some edge scenarios\n \n If converted task is canceled or failed externally return value will be ignored without side-effects\n * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n \n @template R returned task resolve type\n * @param producer function to be wrapped to a task\n * @param cancelRef reference object allowing to set cancelation function prior to invoking function\n * @returns task resolving to the specified function's result\n \n @example\n * ```typescript\n * const cancelRef = { cancel: () => {} };\n \n const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);\n * ```\n /\n export function fromFunction<R>(producer: () => R, cancelRef: { cancel: TaskCancel }): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));\n\n cancelRef.cancel = cancel;\n\n try {\n cell.resolve(Maybe.just(Either.right(producer())));\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Generic callback task\n \n Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction\n \n @param create task body with success and error callbacks\n * @param cancel cancelation function intended for stopping task execution\n * @returns task resolving to success value\n \n @example\n * ```typescript\n * export function timeout(delay: number) {\n * return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n * }\n * ```\n /\n export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void, cancel: () => void) => H, onCancel: (handler: H) => void): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n let handler: { value: H } \| null = null;\n\n const cancel: TaskCancel = (error: Maybe<any>) => {\n const wasPending = cell.resolve(error.map(Either.left));\n if (wasPending && handler) {\n onCancel(handler.value);\n }\n return wasPending;\n }\n\n try {\n const value = create(\n (r) => cell.resolve(Maybe.just(Either.right(r))),\n (e) => cell.resolve(Maybe.just(Either.left(e))),\n () => cancel(Maybe.nothing()),\n );\n\n handler = { value };\n\n const result = cell.settled();\n if (result && !result.value.match({ just: (v) => v.isRight(), nothing: () => false })) {\n onCancel(value);\n }\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Lift an async operation that accepts an AbortSignal into a Task.\n \n Creates an internal AbortController and passes its signal to `producer`.\n * If the resulting task is canceled or rejected externally, `controller.abort()`\n * is called automatically.\n \n @template R returned task resolve type\n * @param producer factory function receiving an AbortSignal\n * @returns task wrapping the operation\n \n @example\n * ```typescript\n * const fetchUser = (id: string) =>\n * Task.fromAbortSignal((signal) =>\n * fetch(`/api/users/${id}`, { signal }).then((res) => res.json())\n * );\n * ```\n /\n export function fromAbortSignal<R>(\n producer: (signal: AbortSignal) => PromiseLike<R>\n ): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n const controller = new AbortController();\n\n const cancel: TaskCancel = (error: Maybe<any>) => {\n const wasPending = cell.resolve(error.map(Either.left));\n if (wasPending) {\n controller.abort(error.match({ just: (err) => err, nothing: () => undefined }));\n }\n return wasPending;\n };\n\n try {\n producer(controller.signal).then((value) => {\n cell.resolve(Maybe.just(Either.right(value)));\n }, (error) => {\n if (controller.signal.aborted && (error?.name === 'AbortError' \|\| (typeof DOMException !== 'undefined' && error instanceof DOMException && error.name === 'AbortError'))) {\n cell.resolve(Maybe.nothing());\n } else {\n cell.resolve(Maybe.just(Either.left(error)));\n }\n });\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Convinience shortcut for yielding async functions as tasks\n \n @template R returned generator resolve type\n * @param promise promise to be resolved\n * @returns generator to be be used with yield\n /\n export function promiseGenerator<R>(promise: PromiseLike<R>) {\n return Task.fromPromise(promise).generator();\n }\n\n /*\n Convinience shortcut for yielding timers\n \n @template R returned generator resolve type\n * @param promise promise to be resolved\n * @returns generator to be be used with yield\n /\n export function timeoutGenerator(delay: number) {\n return Task.timeout(delay).generator();\n }\n\n /*\n Lift from function returning value/promise to function returning task resolving to that value\n \n Userfull for converting exising async functions to task functions for further use\n \n @template A returned function's argument types\n * @template R returned function's result task's resolve type\n * @param promiseFunction function returning promise or plain value to be resolved\n * @returns task function wrapping specified promise function\n * @see Task.fromPromise\n \n @example\n * ```typescript\n * const taskFunction = liftPromiseFunction(someAsyncOperation);\n \n const task = taskFunction('someData').map((result) => result.length);\n * ```\n /\n export function lift<A extends unknown[], R>(promiseFunction: (...args: A) => PromiseLike<R>): TaskFunction<A, R> {\n return (...args: A) => Task.fromPromise(promiseFunction(...args));\n }\n\n /\n Create compound task from generator function\n \n Applying yield to task within the generator function awaits the task and returns underlying value in case of success\n * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types\n \n In case of failure an error is thrown and may be caught by try-catch\n \n If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately\n \n @template TT yielded task type\n * @template R returned task resolve type\n * @param taskGeneratorFunction task generator function\n * @returns task resolving to generator's return type\n \n @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield\n * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly\n \n @example\n * ```typescript\n * const task = Task.generate(function() {\n try {\n * const value1 = yield* delayedValueTask('data', 400).generator();\n \n const value2 = yield* delayedValueTask(value1.length, 300).generator();\n \n return value2;\n * } catch (e) {\n * return -1;\n * }\n * });\n * ```\n /\n export function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R> {\n const generator: TaskGenerator<T, TT, R> = taskGeneratorFunction();\n const cell = settleCell<Cancelable<R>>();\n\n let current: { task: Task<T>; error: Maybe<any> \| null } \| null = null;\n\n const sequentor = (invoke: () => IteratorResult<TT, R>, override?: Cancelable<R>) => {\n try {\n const next = invoke();\n\n if (next.done) {\n cell.resolve(override ?? current?.error?.map(Either.left) ?? Maybe.just(Either.right(next.value)));\n current = null;\n return;\n }\n\n current = {\n task: next.value,\n error: null,\n };\n\n next.value._invoke((maybe) => maybe.matchTap({\n just: (either) => either.matchTap({\n right: (value) => sequentor(() => generator.next(value), override),\n left: (error) => sequentor(() => generator.throw(error), override),\n }),\n nothing: () => sequentor(() => generator.return(undefined as R), Maybe.nothing()),\n }))\n } catch (error) {\n cell.resolve(override ?? Maybe.just(Either.left(error)));\n current = null;\n }\n };\n\n sequentor(() => generator.next());\n\n return Task.create(cell.promise, (error) => {\n if (cell.settled() \|\| !current) {\n return false;\n }\n\n current.error = error;\n\n return current.task._cancel(error);\n });\n }\n\n /\n Task function generator\n * \n * Simplifies wrighting functions returning generated tasks\n * \n * @template Args generator arguments\n * @template TT yielded task type\n * @template R returned task resolve type\n * @param taskGeneratorFunction function* (...args) task generator function\n * @returns task resolving to generator's return type\n /\n export function generateFunction<A extends any[], T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<A, T, TT, R>): TaskFunction<A, R> {\n return (...args: A) => generate(() => taskGeneratorFunction(...args));\n }\n\n /\n Generic timeout task\n \n Usefull for creating delays in task chains or implementing limiting tasks\n \n @param delay duration in ms after that the task resolves to void\n * @returns task resolving to void (undefined) after specified delay\n \n @example\n * ```typescript\n * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);\n * // ... //\n * const value = yield* delayedValueTask(42, 1000).generator();\n \n console.log(\"It's past 1 second and here's a value:\", value)\n * ```\n /\n export function timeout(delay: number) {\n return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(resolve, delay), clearTimeout);\n }\n\n /\n Start multiple tasks one after another\n \n @param taskFunctions list of task functions (without arguments)\n * @returns composite task invoring every task in order and resolving to the list of results\n /\n export function sequence<T>(taskFunctions: Iterable<TaskFunction<[], T>>): Task<T[]> {\n return Array.from(taskFunctions).reduce((prev, taskFunction) => {\n return prev.chain((list) => {\n return taskFunction().map((value) => list.concat(value));\n });\n }, Task.resolved<T[]>([]));\n }\n\n /\n Execute all tasks in parallel and return list of results\n \n Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order\n * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled\n * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n \n @note direct equivalent of Promise.all\n \n @template T underlying task type\n * @param tasks iterable of tasks to execute\n * @retuirns task resolving to the list of results\n /\n export function all<T>(tasks: Iterable<Task<T>>) {\n const taskArray = Array.from(tasks);\n if (taskArray.length === 0) {\n return Task.resolved([]);\n }\n\n return Task.fromCallback<Task<T>[], T[]>((resolve, reject, cancel) => {\n const results: T[] = new Array(taskArray.length);\n let remaining = taskArray.length;\n\n taskArray.forEach((task, i) => {\n task.matchTap({\n resolved: (value) => {\n results[i] = value;\n remaining--;\n if (remaining === 0) resolve(results);\n },\n rejected: (error) => {\n reject(error);\n taskArray.forEach((t) => t.cancel());\n },\n canceled: () => {\n cancel();\n taskArray.forEach((t) => t.cancel());\n },\n });\n });\n\n return taskArray;\n }, (subtasks) => subtasks.forEach((t) => t.cancel()));\n }\n\n /\n Execute all tasks in parallel and return the result of the first successful one\n \n Resulting task resolves when the first tasks is successfuly resolved, returning it's result\n * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors\n * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors\n * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n \n @note direct equivalent of Promise.any\n \n @template T underlying task type\n * @param tasks iterable of tasks to execute\n * @retuirns task resolving to the result of first successfull task\n /\n export function any<T>(tasks: Iterable<Task<T>>) {\n const cell = settleCell<Cancelable<T>>();\n\n const taskArray = Array.from(tasks);\n\n if (taskArray.length < 1) {\n return Task.canceled();\n }\n\n const cancel = (error: Maybe<any>) => taskArray.map((task) => task._cancel(error)).every((r) => r);\n\n const list = taskArray.map<Maybe<any>>(() => Maybe.nothing());\n\n const resolved = (value: Maybe<T>) => {\n cell.resolve(value.map(Either.right));\n cancel(Maybe.nothing());\n };\n\n const rejected = (error: any, i: number) => {\n list[i] = Maybe.just(error);\n\n if (Maybe.everyJust(list)) {\n cell.resolve(Maybe.just(Either.left(list.map((v) => Just.just(v)))));\n }\n };\n\n taskArray.map((task, i) => {\n return task.matchTap({\n resolved: (value) => resolved(Maybe.just(value)),\n rejected: (error) => rejected(error, i),\n canceled: () => resolved(Maybe.nothing()),\n });\n });\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Limit task execution based on another task\n \n If the second task resolves sooner than the first, resulting task is canceled\n * Otherwise the resulting task resolves together with the first one\n \n @param task task to limit\n * @param limitTask limiting task\n * @returns task limites according to limitTask\n /\n export function limit<T>(task: Task<T>, limitTask: Task<void>) {\n return Task.any<T>([task, limitTask.chain<T>(Task.canceled)]).chainRejected((errors) => Task.rejected<T>(errors[0]));\n }\n\n /\n Repeat task untill successful\n \n Given task is re-generated in case of failure (both external and internal)\n * Resulting task is still cancelable by standard means\n \n @param taskFunction task preoducing function\n /\n export function repeat<T>(taskFunction: TaskFunction<[], T>) {\n const sequentor = (): Task<T> => taskFunction().chainRejected(sequentor);\n\n return sequentor();\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\ntype TaskInvoke<R> = Promise<Cancelable<R>>;\ntype TaskCancel = (error: Maybe<any>) => boolean;\n\n/\n @hidden\n /\ninterface TaskBase<R> {\n _invoke(op: (result: Cancelable<R>) => void): void;\n _cancel(error: Maybe<any>): boolean;\n}\n\n/\n One-shot settlement cell.\n \n The Promise is created internally, so there is no unarmed window: `resolve`\n * before or after construction always owns the result (first writer wins).\n * Later `resolve` calls are ignored. Reentrant `resolve` from the sink is ignored.\n \n `settled` is for skipping continuations; it does not cancel children by itself.\n * After creating a child, if `settled` is already true, cancel that child with\n * the stored value. Bind `_cancel` to the child only after that check.\n /\ntype SettleCell<T> = {\n readonly promise: Promise<T>;\n readonly resolve: (value: T) => boolean;\n readonly settled: () => { value: T } \| null;\n};\n\nconst stub = () => void undefined;\n\nconst settleCell = <T>(): SettleCell<T> => {\n let sink: (value: T) => void = stub;\n let settled: { value: T } \| null = null;\n\n const promise = new Promise<T>((resolve) => {\n sink = resolve;\n });\n\n const resolve = (next: T) => {\n if (settled) {\n return false;\n }\n\n settled = { value: next };\n\n sink(next);\n\n return true;\n };\n\n return {\n promise,\n resolve,\n settled: () => settled,\n };\n};\n\nfunction chainTaskMaybe<R, R2>(parent: TaskBase<R>, op: (value: Cancelable<R>) => Task<R2>) {\n const cell = settleCell<Cancelable<R2>>();\n\n let state:\n \| { phase: 'parent' }\n \| { phase: 'transform', error: Maybe<any> \| null }\n \| { phase: 'child', cancel: TaskCancel }\n \| { phase: 'closed' } = { phase: 'parent' };\n\n parent._invoke((result) => {\n state = { phase: 'transform', error: null }\n\n let child: Task<R2> \| null = null;\n try {\n child = op(result);\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n state = { phase: 'closed' };\n return;\n }\n\n const transformError = state.phase === 'transform' ? state.error : null;\n\n state = { phase: 'child', cancel: (error) => child._cancel(error) };\n\n if (transformError) {\n cell.resolve(transformError.map(Either.left));\n state = { phase: 'closed' };\n child._cancel(transformError);\n return;\n }\n\n return child._invoke((value) => {\n cell.resolve(value);\n state = { phase: 'closed' };\n });\n });\n\n return Task.create(cell.promise, (error) => {\n if (cell.settled()) {\n return false;\n }\n\n if (state.phase === 'parent') {\n return parent._cancel(error);\n } else if (state.phase === 'transform') {\n state.error = error;\n return true;\n } else if (state.phase === 'child') {\n return state.cancel(error);\n } else {\n return false;\n }\n });\n}\n\nfunction chainTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Task<R2>) {\n return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);\n}\n\nfunction mapTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Cancelable<R2>) {\n return chainTaskMaybe<R, R2>(_task, (maybe) => {\n return op(maybe).match<Task<R2>>({\n just: (either) =>\n either.match<Task<R2>>({\n right: Task.resolved,\n left: Task.rejected,\n }),\n nothing: Task.canceled,\n });\n });\n}\n\nfunction mapTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Rejectable<R2>) {\n return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));\n}\n\nfunction tapTaskMaybe<R>(_task: TaskBase<R>, op: (value: Cancelable<R>) => void) {\n return mapTaskMaybe<R, R>(_task, (value) => {\n op(value);\n\n return value;\n });\n}\n\nfunction tapTaskEither<R>(_task: TaskBase<R>, op: (value: Rejectable<R>) => void) {\n return tapTaskMaybe<R>(_task, (maybe) => maybe.tap(op));\n}\n\ntype SyncState<R> =\n \| { resolved: false; invoke: TaskInvoke<R>; cancel: TaskCancel }\n \| { resolved: true; result: Cancelable<R> }\n\nclass TaskClass<R> implements Task<R> {\n constructor(private _state: SyncState<R>) {\n if (!this._state.resolved) {\n this._state.invoke = this._state.invoke.then((result) => {\n if (!this._state.resolved) {\n this._state = { resolved: true, result }\n }\n return result;\n });\n }\n }\n\n _invoke(op: (result: Cancelable<R>) => void) {\n if (this._state.resolved) {\n return op(this._state.result);\n } else {\n return this._state.invoke.then(op);\n }\n }\n\n _cancel(error: Maybe<any>) {\n if (this._state.resolved) {\n return false\n } else {\n return this._state.cancel(error);\n }\n }\n\n tapCanceled(op: () => void) {\n return tapTaskMaybe<R>(this, (maybe) => maybe.orTap(op));\n }\n tapRejected(op: (error: any) => void) {\n return tapTaskEither<R>(this, (either) => either.orTap(op));\n }\n tap(op: (value: R) => void) {\n return tapTaskEither<R>(this, (either) => either.tap(op));\n }\n\n mapCanceled<R2>(op: () => R2) {\n return mapTaskMaybe<R, R \| R2>(this, (maybe) => maybe.orMap(() => Either.right(op())));\n }\n mapRejected<R2>(op: (error: any) => R2) {\n return mapTaskEither<R, R \| R2>(this, (either) => either.orMap(op));\n }\n map<R2>(op: (value: R) => R2) {\n return mapTaskEither<R, R2>(this, (either) => either.map(op));\n }\n\n chainCanceled<R2>(op: () => Task<R2>) {\n const mapEither = (either: Rejectable<R>) => either.map(Task.resolved).orMap<Task<R>>(Task.rejected).right;\n\n return chainTaskMaybe<R, R \| R2>(this, (maybe) => maybe.map(mapEither).orMap(op).just);\n }\n chainRejected<R2>(op: (error: any) => Task<R2>) {\n return chainTaskEither<R, R \| R2>(this, (either) => either.map(Task.resolved).orMap(op).right);\n }\n chain<R2>(op: (value: R) => Task<R2>) {\n return chainTaskEither<R, R2>(this, (either) => either.map(op).orMap<Task<R2>>(Task.rejected).right);\n }\n\n resolved() {\n if (this._state.resolved) {\n return this._state.result;\n } else {\n return null;\n }\n }\n\n resolve() {\n if (this._state.resolved) {\n return Promise.resolve(this._state.result);\n } else {\n return this._state.invoke;\n }\n }\n cancel() {\n if (this._state.resolved) {\n return false;\n } else {\n return this._state.cancel(Maybe.nothing());\n }\n }\n reject(error: any) {\n if (this._state.resolved) {\n return false;\n } else {\n return this._state.cancel(Maybe.just(error));\n }\n }\n\n generator() {\n return (function(task) {\n return (yield task) as R;\n })(this);\n }\n\n matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }) {\n return tapTaskMaybe(this, (maybe) => {\n return maybe.matchTap({\n just: (either) => {\n return either.matchTap({\n right: op.resolved,\n left: op.rejected,\n });\n },\n nothing: op.canceled,\n });\n });\n }\n\n matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }) {\n return mapTaskMaybe(this, (maybe) => {\n return Maybe.just(maybe.match<Right<R2 \| R3 \| R4, any>>({\n just: (either) => {\n return Either.right(either.match({\n right: op.resolved,\n left: op.rejected,\n }));\n },\n nothing: () => Either.right(op.canceled()),\n }));\n });\n }\n\n matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }) {\n return chainTaskMaybe(this, (maybe) => {\n return maybe.match<Task<R2 \| R3 \| R4>>({\n just: (either) => {\n return either.match<Task<R2 \| R3>>({\n right: op.resolved,\n left: op.rejected,\n });\n },\n nothing: op.canceled,\n });\n });\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"t-tasks.js","names":[],"sources":["../src/maybe.ts","../src/either.ts","../src/task.ts"],"sourcesContent":["/*\n Just a value\n \n Maybe data type specialization representing an existing value\n \n @template R underlying value\n /\nexport interface Just<R> {\n readonly just: R;\n\n /\n Maybe peeker function\n \n Applied to 'just value' returns self invoking op(value) in process\n * Applied to 'nothing' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Maybe fallback peeker function\n \n Applied to 'just value' returns self without invoking callback\n * Applied to 'nothing' returns self invoking op() in process\n \n @param op function to be invoked\n * @returns self\n /\n orTap(op: () => void): this;\n\n /\n Maybe pattern matching peeker function\n \n Applied to 'just value' returns self invoking op.just(value) in process\n * Applied to 'nothing' returns self invoking op.nothing() in process\n \n @param op.just function to be invoked with underlying value in case of just\n * @param op.nothing function to be invoked in case of nothing\n * @returns self\n /\n matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n /\n Maybe transformer function\n \n Applied to 'just value' returns 'just op(value)'\n * Applied to 'nothing' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'just op(value)' or 'nothing'\n /\n // Just case\n map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;\n // Generic case\n map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n /\n Maybe fallback transformer function\n \n Applied to 'just value' returns self without invoking transformer\n * Applied to 'nothing' returns 'just op()'\n \n @template R2 transformer function's return type\n * @param op function to be invoked\n * @returns 'just value' or 'just op()'\n /\n // Just case\n orMap<R2>(this: Just<R>, op: () => R2): Just<R>;\n // Generic case\n orMap<R2>(this: Maybe<R>, op: () => R2): Just<R \| R2>;\n\n /\n Maybe pattern matching extractor function\n \n Applied to 'just value' returns op.just(value)\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just extractor function's return type\n * @template R3 nothing extractor function's return type\n * @param op.just extractor to be invoked with underlying value in case of just\n * @param op.nothing extractor to be invoked in case of nothing\n * @returns op.just(value) or op.nothing()\n /\n // Just cases\n match<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2;\n // General case\n match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 \| R3;\n\n /\n Maybe pattern matching transformer function\n \n Applied to 'just value' returns 'just op.just(value)'\n * Applied to 'nothing' returns 'just op.nothing()'\n \n @template R2 just transformer function's return type\n * @template R3 nothing transformer function's return type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'just op.just(value)' or 'just op.nothing()'\n /\n // Just cases\n matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;\n // General case\n matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 \| R3>;\n\n\n /\n Maybe composition function\n \n Applied to 'just value' returns 'op(value)'\n * Applied to 'nothing' returns self without invoking composition function\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'nothing'\n /\n // Just cases\n chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;\n chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n // General cases\n chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n /\n Maybe fallback composition function\n \n Applied to 'just value' returns self without invoking composition function\n * Applied to 'nothing' returns op()\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked\n * @returns 'just value' or 'op()'\n /\n // Just cases\n orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;\n orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;\n orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;\n // General case\n orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R \| R2>;\n orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R \| R2>;\n\n /\n Maybe pattern matching composition function\n \n Applied to 'just value' returns 'op.just(value)'\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just transformer function result's underlying type\n * @template R3 nothing transformer function result's underlying type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'op.just(value)' or 'op.nothing()'\n /\n // Just cases\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Just<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2>;\n // General cases\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n\n /\n Maybe type guard for 'just'\n \n @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n \n @example\n * ```typescript\n * if (maybe.isJust()) {\n * console.log(maybe.just);\n * }\n * ```\n /\n isJust(): this is Just<R>;\n\n /\n Maybe type guard for 'nothing'\n \n @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n \n @example\n * ```typescript\n * if (maybe.isNothing()) {\n * console.log('nothing');\n * }\n * ```\n /\n isNothing(): this is Nothing<R>;\n\n /\n Wrap Maybe to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Maybe wrapping this\n /\n generator: MaybeGeneratorFunction<[], R, Just<R>, R>\n}\n\n/\n Absolutely Nothing\n \n Maybe data type specialization representing an absence of any value\n \n @template R underlying value\n /\nexport interface Nothing<R> {\n /\n Maybe peeker function\n \n Applied to 'just value' returns self invoking op(value) in process\n * Applied to 'nothing' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Maybe fallback peeker function\n \n Applied to 'just value' returns self without invoking callback\n * Applied to 'nothing' returns self invoking op() in process\n \n @param op function to be invoked\n * @returns self\n /\n orTap(op: () => void): this;\n\n /\n Maybe pattern matching peeker function\n \n Applied to 'just value' returns self invoking op.just(value) in process\n * Applied to 'nothing' returns self invoking op.nothing() in process\n \n @param op.just function to be invoked with underlying value in case of just\n * @param op.nothing function to be invoked in case of nothing\n * @returns self\n /\n matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n /\n Maybe transformer function\n \n Applied to 'just value' returns 'just op(value)'\n * Applied to 'nothing' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'just op(value)' or 'nothing'\n /\n // Nothing case\n map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;\n // Generic case\n map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n /\n Maybe fallback transformer function\n \n Applied to 'just value' returns self without invoking transformer\n * Applied to 'nothing' returns 'just op()'\n \n @template R2 transformer function's return type\n * @param op function to be invoked\n * @returns 'just value' or 'just op()'\n /\n // Nothing case\n orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;\n // Generic case\n orMap<R2>(this: Maybe<R>, op: () => R2): Just<R \| R2>;\n\n /\n Maybe pattern matching extractor function\n \n Applied to 'just value' returns op.just(value)\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just extractor function's return type\n * @template R3 nothing extractor function's return type\n * @param op.just extractor to be invoked with underlying value in case of just\n * @param op.nothing extractor to be invoked in case of nothing\n * @returns op.just(value) or op.nothing()\n /\n // Nothing cases\n match<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R3;\n // General case\n match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 \| R3;\n\n /\n Maybe pattern matching transformer function\n \n Applied to 'just value' returns 'just op.just(value)'\n * Applied to 'nothing' returns 'just op.nothing()'\n \n @template R2 just transformer function's return type\n * @template R3 nothing transformer function's return type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'just op.just(value)' or 'just op.nothing()'\n /\n // Nothing cases\n matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;\n // General case\n matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 \| R3>;\n\n /\n Maybe composition function\n \n Applied to 'just value' returns 'op(value)'\n * Applied to 'nothing' returns self without invoking composition function\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'nothing'\n /\n // Nothing cases\n chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;\n chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;\n // General cases\n chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n /\n Maybe fallback composition function\n \n Applied to 'just value' returns self without invoking composition function\n * Applied to 'nothing' returns op()\n \n @template R2 transformer function result's underlying type\n * @param op transformer to be invoked\n * @returns 'just value' or 'op()'\n /\n // Nothing cases\n orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;\n orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;\n orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;\n // General cases\n orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R \| R2>;\n orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R \| R2>;\n\n /\n Maybe pattern matching composition function\n \n Applied to 'just value' returns 'op.just(value)'\n * Applied to 'nothing' returns op.nothing()\n \n @template R2 just transformer function result's underlying type\n * @template R3 nothing transformer function result's underlying type\n * @param op.just transformer to be invoked with underlying value in case of just\n * @param op.nothing transformer to be invoked in case of nothing\n * @returns 'op.just(value)' or 'op.nothing()'\n /\n // Nothing cases\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Just<R3>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n // General cases\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 \| R3>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 \| R3>;\n\n /\n Maybe type guard for 'just'\n \n @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n \n @example\n * ```typescript\n * if (maybe.isJust()) {\n * console.log(maybe.just);\n * }\n * ```\n /\n isJust(): this is Just<R>;\n\n /\n Maybe type guard for 'nothing'\n \n @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n \n @example\n * ```typescript\n * if (maybe.isNothing()) {\n * console.log('nothing');\n * }\n * ```\n /\n isNothing(): this is Nothing<R>;\n\n /\n Wrap Maybe to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Maybe wrapping this\n /\n generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>\n}\n\n/\n Generic Maybe monad interface\n \n As per classic Maybe monad implementation can either contain just a value or contain nothing\n * Used throughout the library to represent optional return type, specifically return type of cancelled tasks\n \n @template R underlying value\n /\nexport type Maybe<R> = Just<R> \| Nothing<R>;\n\nexport namespace Just {\n /\n Standalone Just value extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @param just Just instance\n * @returns underlying value\n /\n export function just<R>(just: Just<R>) {\n return just.just;\n }\n}\n\nexport namespace Nothing {}\n\n/\n Maybe generator\n \n @template T yielded underlying type\n * @template TT yielded Maybe type\n * @template R returned underlying type\n /\nexport type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;\n\n/\n Function returning Maybe generator (generator function)\n \n @template A argument types\n * @template T yielded underlying type\n * @template TT yielded Maybe type\n * @template R returned underlying type\n /\nexport type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;\n\nexport namespace Maybe {\n /\n Non-empty monad constructor\n \n @template R underlying type\n * @param value underlying value\n * @returns 'just value'\n /\n export function just<R>(value: R): Just<R> {\n return new JustClass<R>(value);\n }\n\n /\n Empty monad constructor\n \n @returns 'nothing'\n /\n export function nothing<R = never>(): Nothing<R> {\n return staticNothing as Nothing<R>;\n }\n\n /\n Maybe constructor from optional value\n \n Resolves to 'nothing' in case of undefined value and 'just value' otherwise\n \n @template R underlying type\n * @param value possibly undefined value\n * @returns either 'just value' or 'nothing'\n /\n export function fromOptional(value: undefined): Nothing<never>;\n export function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;\n export function fromOptional<R>(value: R \| undefined): Maybe<R>;\n export function fromOptional<R>(value: R \| undefined) {\n return typeof value !== 'undefined' ? Maybe.just(value) : Maybe.nothing();\n }\n\n /\n Maybe constructor from optional or nullable value\n \n Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise\n \n @template R underlying type\n * @param value possibly undefined or null value\n * @returns either 'just value' or 'nothing'\n /\n export function fromNullable(value: undefined): Nothing<never>;\n export function fromNullable(value: null): Nothing<never>;\n export function fromNullable<R>(value: Exclude<R, null \| undefined>): Just<R>;\n export function fromNullable<R>(value: R \| null \| undefined): Maybe<R>;\n export function fromNullable<R>(value: R \| null \| undefined) {\n return Maybe.fromOptional(value).chain((v) => (v !== null ? Maybe.just(v) : Maybe.nothing()));\n }\n\n /\n Standalone Maybe value extractor\n \n Applied to 'just value' returns underlying value without using fallback\n * Applied to 'nothing' returns fallback\n \n @template R underlying value type\n * @template R2 fallback value type\n * @param maybe Maybe instance\n * @param fallback value to be returned in case of 'nothing'\n * @returns underlying value or fallback\n /\n export function fromMaybe<R>(maybe: Just<R>, fallback: unknown): R;\n export function fromMaybe<R, R2>(maybe: Nothing<R>, fallback: R2): R2;\n export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2): R \| R2;\n export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2) {\n return maybe.match({ just: (value) => value, nothing: () => fallback });\n }\n\n /\n Standalone type guard for 'just'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param maybe Maybe instance\n * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')\n /\n export function isJust<R>(maybe: Maybe<R>): maybe is Just<R> {\n return maybe.isJust();\n }\n\n /\n Standalone type guard for 'nothing'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @param maybe Maybe instance\n * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')\n /\n export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<R> {\n return maybe.isNothing();\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @param maybes a list of Maybe\n * @returns true in case every list element is Just\n /\n export function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {\n return maybes.every(Maybe.isJust);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @param maybes a list of Maybe\n * @returns true in case at least one list element is Just\n /\n export function someJust<R>(maybes: Maybe<R>[]): boolean {\n return maybes.some(Maybe.isJust);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @param maybes a list of Maybe\n * @returns true in case every list element is Nothing\n /\n export function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {\n return maybes.every(Maybe.isNothing);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @param maybes a list of Maybe\n * @returns true in case at least one list element is Nothing\n /\n export function someNothing<R>(maybes: Maybe<R>[]): boolean {\n return maybes.some(Maybe.isNothing);\n }\n\n /\n Create compound Maybe from generator function\n \n Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success\n * However the convenient option for typescript is to use ```yield* maybe.generator()``` as otherwise one may have to deal with union types\n \n @template T yielded underlying type\n * @template TT yielded Maybe type\n * @template R returned underlying type\n * @param maybeGeneratorFunction Maybe generator function\n * @returns Just wrapping the result of generator function or Nothing\n /\n export function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R> {\n const generator = maybeGeneratorFunction();\n let next = generator.next();\n\n while (!next.done) {\n if (next.value.isNothing()) {\n return Maybe.nothing();\n }\n\n next = generator.next(next.value.just);\n }\n\n return Maybe.just(next.value);\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass JustClass<R> implements Just<R> {\n constructor(readonly just: R) {}\n\n tap(op: (value: R) => void) {\n op(this.just);\n\n return this;\n }\n orTap() {\n return this;\n }\n map<R2>(op: (value: R) => R2) {\n return Maybe.just(op(this.just));\n }\n orMap() {\n return this;\n }\n chain<RR extends Maybe<unknown>>(op: (value: R) => RR) {\n return op(this.just);\n }\n orChain() {\n return this;\n }\n isJust(): this is Just<R> {\n return true;\n }\n isNothing(): this is Nothing<R> {\n return false;\n }\n match<R2>(op: { just: (value: R) => R2 }) {\n return op.just(this.just);\n }\n matchTap(op: { just: (value: R) => void }) {\n return this.tap(op.just);\n }\n matchMap<R2>(op: { just: (value: R) => R2 }) {\n return this.map(op.just);\n }\n matchChain<RR extends Maybe<unknown>>(op: { just: (value: R) => RR }) {\n return this.chain(op.just);\n }\n generator() {\n return (function(value) {\n return (yield value) as R;\n })(this);\n }\n}\n\nclass NothingClass implements Nothing<never> {\n tap() {\n return this;\n }\n orTap(op: () => void) {\n op();\n\n return this;\n }\n map() {\n return this;\n }\n orMap<R2>(op: () => R2) {\n return Maybe.just(op());\n }\n chain() {\n return this;\n }\n orChain<RR extends Maybe<unknown>>(op: () => RR) {\n return op();\n }\n isJust(): this is Just<never> {\n return false;\n }\n isNothing(): this is Nothing<never> {\n return true;\n }\n match<R2>(op: { nothing: () => R2 }) {\n return op.nothing();\n }\n matchTap(op: { nothing: () => void }) {\n return this.orTap(op.nothing);\n }\n matchMap<R2>(op: { nothing: () => R2 }) {\n return this.orMap(op.nothing);\n }\n matchChain<RR extends Maybe<unknown>>(op: { nothing: () => RR }) {\n return this.orChain(op.nothing);\n }\n generator() {\n return (function(value) {\n return (yield value) as never;\n })(this);\n }\n}\n\nconst staticNothing = new NothingClass();\n","/\n Right (correct) value of type R\n \n Either data type specialization representing a correct value\n \n @template R underlying value type\n * @template L underlying error type (needed for type merging, in fact always considered to be never)\n /\nexport interface Right<R, L> {\n readonly right: R;\n\n /\n Either peeker function\n \n Applied to 'right value' returns self invoking op(value) in process\n * Applied to 'left error' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Either fallback peeker function\n \n Applied to 'right value' returns self without invoking callback\n * Applied to 'left error' returns self invoking op(error) in process\n \n @param op function to be invoked with underlying error\n * @returns self\n /\n orTap(op: (error: L) => void): this;\n\n /\n Either pattern matching peeker function\n \n Applied to 'right value' returns self invoking op.right(value) in process\n * Applied to 'left error' returns self invoking op.left(error) in process\n \n @param op.right function to be invoked with underlying value in case of 'right'\n * @param op.left function to be invoked with underlying error in case of 'left'\n * @returns self\n /\n matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n /\n Either transformer function\n \n Applied to 'right value' returns 'right op(value)'\n * Applied to 'left error' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'right op(value)' or 'left error'\n /\n // Right case\n map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;\n // General case\n map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n /\n Either fallback transformer function\n \n Applied to 'right value' returns self without invoking transformer\n * Applied to 'left error' returns 'right op(error)'\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'right op(error)'\n /\n // Right case\n orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;\n // General case\n orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R \| R2, never>;\n\n /\n Either pattern matching extractor function\n \n Applied to 'right value' returns op.right(value)\n * Applied to 'left error' returns op.left(error)\n \n @template R2 right extractor function's return type\n * @template R3 left extractor function's return type\n * @param op.right extractor to be invoked with underlying value in case of 'right'\n * @param op.left extractor to be invoked with underlying error in case of 'left'\n * @returns op.right(value) or op.left(error)\n /\n // Right case\n match<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2;\n // General case\n match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 \| R3;\n\n /\n Either pattern matching transformer function\n \n Applied to 'right value' returns 'right op.right(value)'\n * Applied to 'left error' returns 'right op.left(error)'\n \n @template R2 right transformer function's return type\n * @template R3 left transformer function's return type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'right op.right(value)' or 'right op.left(error)'\n /\n // Right case\n matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;\n // General case\n matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 \| R3, never>;\n\n /\n Either composition function\n \n Applied to 'right value' returns 'op(value)'\n * Applied to 'left error' returns self without invoking composition function\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'left error'\n /\n // Right cases\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;\n chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;\n // General cases\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L \| L2>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L \| L2>;\n\n /\n Either fallback composition function\n \n Applied to 'right value' returns self without invoking composition function\n * Applied to 'left error' returns 'op(error)'\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'op(error)'\n /\n // Right cases\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;\n orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;\n // General cases\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R \| R2, never>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R \| R2, L2>;\n\n /\n Either pattern matching composition function\n \n Applied to 'right value' returns 'op.right(value)'\n * Applied to 'left error' returns 'op.left(error)'\n \n @template R2 right transformer function result's underlying value type\n * @template L2 right transformer function result's underlying error type\n * @template R3 left transformer function result's underlying value type\n * @template L3 left transformer function result's underlying error type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'op.right(value)' or 'op.left(error)'\n /\n // Right cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Right<R2, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Left<never, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2, L2>;\n // General cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 \| R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 \| R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L2 \| L3>;\n\n /\n Either type guard for 'right'\n \n @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n \n @example\n * ```typescript\n * if (either.isRight()) {\n * console.log(either.right)\n * }\n * ```\n /\n isRight(): this is Right<R, L>;\n\n /\n Either type guard for 'left'\n \n @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n \n @example\n * ```typescript\n * if (either.isLeft()) {\n * console.error(either.left)\n * }\n * ```\n /\n isLeft(): this is Left<R, L>;\n\n /\n Wrap Either to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Either wrapping this\n /\n generator: EitherGeneratorFunction<[], R, Right<R, L>, R>\n}\n\n/\n Left (erroneous) value of type L\n \n Either data type specialization representing an erroneous value\n \n @template R underlying value type (needed for type merging, in fact always considered to be never)\n * @template L underlying error type\n /\nexport interface Left<R, L> {\n readonly left: L;\n\n /\n Either peeker function\n \n Applied to 'right value' returns self invoking op(value) in process\n * Applied to 'left error' returns self without invoking callback\n \n @param op function to be invoked with underlying value\n * @returns self\n /\n tap(op: (value: R) => void): this;\n\n /\n Either fallback peeker function\n \n Applied to 'right value' returns self without invoking callback\n * Applied to 'left error' returns self invoking op(error) in process\n \n @param op function to be invoked with underlying error\n * @returns self\n /\n orTap(op: (error: L) => void): this;\n\n /\n Either pattern matching peeker function\n \n Applied to 'right value' returns self invoking op.right(value) in process\n * Applied to 'left error' returns self invoking op.left(error) in process\n \n @param op.right function to be invoked with underlying value in case of 'right'\n * @param op.left function to be invoked with underlying error in case of 'left'\n * @returns self\n /\n matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n /\n Either transformer function\n \n Applied to 'right value' returns 'right op(value)'\n * Applied to 'left error' returns self without invoking transformer\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying value\n * @returns 'right op(value)' or 'left error'\n /\n // Left case\n map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;\n // General case\n map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n /\n Either fallback transformer function\n \n Applied to 'right value' returns self without invoking transformer\n * Applied to 'left error' returns 'right op(error)'\n \n @template R2 transformer function's return type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'right op(error)'\n /\n // Left case\n orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;\n // General case\n orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R \| R2, never>;\n\n /\n Either pattern matching extractor function\n \n Applied to 'right value' returns op.right(value)\n * Applied to 'left error' returns op.left(error)\n \n @template R2 right extractor function's return type\n * @template R3 left extractor function's return type\n * @param op.right extractor to be invoked with underlying value in case of 'right'\n * @param op.left extractor to be invoked with underlying error in case of 'left'\n * @returns op.right(value) or op.left(error)\n /\n // Left case\n match<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R3;\n // General case\n match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 \| R3;\n\n /\n Either pattern matching transformer function\n \n Applied to 'right value' returns 'right op.right(value)'\n * Applied to 'left error' returns 'right op.left(error)'\n \n @template R2 right transformer function's return type\n * @template R3 left transformer function's return type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'right op.right(value)' or 'right op.left(error)'\n /\n // Left case\n matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;\n // General case\n matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 \| R3, never>;\n\n /\n Either composition function\n \n Applied to 'right value' returns 'op(value)'\n * Applied to 'left error' returns self without invoking composition function\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying value\n * @returns 'op(value)' or 'left error'\n /\n // Left cases\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;\n chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;\n // General cases\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L \| L2>;\n chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L \| L2>;\n\n /\n Either fallback composition function\n \n Applied to 'right value' returns self without invoking composition function\n * Applied to 'left error' returns 'op(error)'\n \n @template R2 transformer function result's underlying value type\n * @template L2 transformer function result's underlying error type\n * @param op transformer to be invoked with underlying error\n * @returns 'right value' or 'op(error)'\n /\n // Left cases\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;\n orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;\n // General cases\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R \| R2, never>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R \| R2, L2>;\n\n /\n Either pattern matching composition function\n \n Applied to 'right value' returns 'op.right(value)'\n * Applied to 'left error' returns 'op.left(error)'\n \n @template R2 right transformer function result's underlying value type\n * @template L2 right transformer function result's underlying error type\n * @template R3 left transformer function result's underlying value type\n * @template L3 left transformer function result's underlying error type\n * @param op.right transformer to be invoked with underlying value in case of 'right'\n * @param op.left transformer to be invoked with underlying error in case of 'left'\n * @returns 'op.right(value)' or 'op.left(error)'\n /\n // Left cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n // General cases\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 \| R3, never>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 \| R3, L2>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 \| L3>;\n matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 \| R3, L2 \| L3>;\n\n /\n Either type guard for 'right'\n \n @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n \n @example\n * ```typescript\n * if (either.isRight()) {\n * console.log(either.right)\n * }\n * ```\n /\n isRight(): this is Right<R, L>;\n\n /\n Either type guard for 'left'\n \n @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n \n @example\n * ```typescript\n * if (either.isLeft()) {\n * console.error(either.left)\n * }\n * ```\n /\n isLeft(): this is Left<R, L>;\n\n /\n Wrap Either to singleton generator\n \n Useful in order to avoid ambiguous yield types\n \n @returns generator of Either wrapping this\n /\n generator: EitherGeneratorFunction<[], R, Left<R, L>, R>\n}\n\n/\n Either data type: either Right value of type R or Left value of type L\n \n As per classic Either monad implementation can either contain a right (correct) value or a left (erroneous) value\n * Used throughout the library to represent the result of failable operations, namely failed tasks\n \n @template R underlying value type\n * @template L underlying error type\n /\nexport type Either<R, L> = Right<R, L> \| Left<R, L>;\n\nexport namespace Right {\n /\n Standalone Right value extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param right Right instance\n * @returns underlying value\n /\n export function right<R, L>(right: Right<R, L>) {\n return right.right;\n }\n}\n\nexport namespace Left {\n /\n Standalone Left error extractor\n \n Useful for passing as a function to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param left Left instance\n * @returns underlying error\n /\n export function left<R, L>(left: Left<R, L>) {\n return left.left;\n }\n}\n\n/\n Either generator\n \n @template T yielded underlying type\n * @template TT yielded Either type\n * @template R returned underlying type\n /\nexport type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;\n\n/\n Function returning Either generator (generator function)\n \n @template A argument types\n * @template T yielded underlying type\n * @template TT yielded Either type\n * @template R returned underlying type\n /\nexport type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;\n\nexport namespace Either {\n /\n Right monad constructor\n \n @template R underlying value type\n * @param value underlying value\n * @returns 'right value'\n /\n export function right<R>(value: R): Right<R, never> {\n return new RightClass<R>(value);\n }\n\n /\n Left monad constructor\n \n @template L underlying error type\n * @param error underlying error\n * @returns 'left error'\n /\n export function left<L>(error: L): Left<never, L> {\n return new LeftClass<L>(error);\n }\n\n /\n Either constructor from optional value\n \n Resolves to 'left error' in case of undefined value and 'right value' otherwise\n \n @template R underlying value type\n * @template L underlying error type\n * @param value possibly undefined value\n * @param error error to use in case of undefined value\n * @returns either 'right value' or 'left error'\n /\n export function fromOptional<L>(value: undefined, error: L): Left<never, L>;\n export function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;\n export function fromOptional<R, L>(value: R \| undefined, error: L): Either<R, L>;\n export function fromOptional<R, L>(value: R \| undefined, error: L) {\n return typeof value !== 'undefined' ? Either.right(value) : Either.left(error);\n }\n\n /\n Either constructor from optional or nullable value\n \n Resolves to 'left error' in case of undefined or null value and 'right value' otherwise\n \n @template R underlying value type\n * @template L underlying error type\n * @param value possibly undefined or null value\n * @param error error to use in case of undefined or null value\n * @returns either 'right value' or 'left error'\n /\n export function fromNullable<L>(value: undefined, error: L): Left<never, L>;\n export function fromNullable<L>(value: null, error: L): Left<never, L>;\n export function fromNullable<R>(value: Exclude<R, null \| undefined>, error: unknown): Right<R, never>;\n export function fromNullable<R, L>(value: R \| null \| undefined, error: L): Either<R, L>;\n export function fromNullable<R, L>(value: R \| null \| undefined, error: L) {\n return Either.fromOptional(value, error).chain((v) => (v !== null ? Either.right(value) : Either.left(error)));\n }\n\n /\n Standalone Either value extractor\n \n Applied to 'right value' returns underlying value without using fallback\n * Applied to 'left error' returns fallback\n \n @template R underlying value type\n * @template L underlying error type\n * @template R2 fallback value type\n * @param either Either instance\n * @param fallback value to be returned in case of 'left error'\n * @returns underlying value or fallback\n /\n export function fromEither<R, L>(either: Right<R, L>, fallback: unknown): R;\n export function fromEither<R, L, R2>(either: Left<R, L>, fallback: R2): R2;\n export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2): R \| R2;\n export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2) {\n return either.match({ right: (value) => value, left: () => fallback });\n }\n\n /\n Standalone type guard for 'right'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param either Either instance\n * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')\n /\n export function isRight<R, L>(either: Either<R, L>): either is Right<R, never> {\n return either.isRight();\n }\n\n /\n Standalone type guard for 'left'\n \n Useful for passing as a predicate to collection transformers\n \n @template R underlying value type\n * @template L underlying error type\n * @param either Either instance\n * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')\n /\n export function isLeft<R, L>(either: Either<R, L>): either is Left<never, L> {\n return either.isLeft();\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @template L underlying error type\n * @param eithers a list of Either\n * @returns true in case every list element is Right\n /\n export function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {\n return eithers.every(Either.isRight);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @template L underlying error type\n * @param eithers a list of Either\n * @returns true in case at least one list element is Right\n /\n export function someRight<R, L>(eithers: Either<R, L>[]): boolean {\n return eithers.some(Either.isRight);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @template L underlying error type\n * @param eithers a list of Either\n * @returns true in case every list element is Left\n /\n export function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {\n return eithers.every(Either.isLeft);\n }\n\n /\n Standalone list predicate\n \n @template R underlying value type\n * @template L underlying error type\n * @param eithers a list of Either\n * @returns true in case at least one list element is Left\n /\n export function someLeft<R, L>(eithers: Either<R, L>[]): boolean {\n return eithers.some(Either.isLeft);\n }\n\n /\n Create compound Either from generator function\n \n Applying yield to an Either within the generator function unwraps the Either and returns underlying value in case of success\n * However the convenient option for typescript is to use ```yield* either.generator()``` as otherwise one may have to deal with union types\n \n @template T yielded underlying type\n * @template TT yielded Either type\n * @template R returned underlying type\n * @param eitherGeneratorFunction Either generator function\n * @returns Right wrapping the result of generator function or Left\n /\n export function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any> {\n const generator = eitherGeneratorFunction();\n let next = generator.next();\n\n while (!next.done) {\n if (next.value.isLeft()) {\n return Either.left(next.value.left);\n }\n\n next = generator.next(next.value.right);\n }\n\n return Either.right(next.value);\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass RightClass<R> implements Right<R, never> {\n constructor(readonly right: R) {}\n\n tap(op: (value: R) => void) {\n op(this.right);\n\n return this;\n }\n orTap() {\n return this;\n }\n map<R2>(op: (value: R) => R2) {\n return Either.right(op(this.right));\n }\n orMap() {\n return this;\n }\n chain<RR extends Either<unknown, unknown>>(op: (value: R) => RR) {\n return op(this.right);\n }\n orChain() {\n return this;\n }\n isRight(): this is Right<R, never> {\n return true;\n }\n isLeft(): this is Left<R, never> {\n return false;\n }\n match<R2>(op: { right: (value: R) => R2 }) {\n return op.right(this.right);\n }\n matchTap(op: { right: (value: R) => void }) {\n return this.tap(op.right);\n }\n matchMap<R2>(op: { right: (value: R) => R2 }) {\n return this.map(op.right);\n }\n matchChain<RR extends Either<unknown, unknown>>(op: { right: (value: R) => RR }) {\n return this.chain(op.right);\n }\n generator() {\n return (function(value) {\n return (yield value) as R;\n })(this);\n }\n}\n\nclass LeftClass<L> implements Left<never, L> {\n constructor(readonly left: L) {}\n\n tap() {\n return this;\n }\n orTap(op: (error: L) => void) {\n op(this.left);\n\n return this;\n }\n map() {\n return this;\n }\n orMap<R2>(op: (error: L) => R2) {\n return Either.right(op(this.left));\n }\n chain() {\n return this;\n }\n orChain<RR extends Either<unknown, unknown>>(op: (error: L) => RR) {\n return op(this.left);\n }\n isRight(): this is Right<never, L> {\n return false;\n }\n isLeft(): this is Left<never, L> {\n return true;\n }\n match<R2>(op: { left: (error: L) => R2 }) {\n return op.left(this.left);\n }\n matchTap(op: { left: (error: L) => void }) {\n return this.orTap(op.left);\n }\n matchMap<R2>(op: { left: (error: L) => R2 }) {\n return this.orMap(op.left);\n }\n matchChain<RR extends Either<unknown, unknown>>(op: { left: (error: L) => RR }) {\n return this.orChain(op.left);\n }\n generator() {\n return (function(value) {\n return (yield value) as never;\n })(this);\n }\n}\n","import { Maybe, Just } from './maybe';\nimport { Either, Right } from './either';\n\n/\n Shortcut for monadic Either type, where erroneous value is of type any\n \n @template R underlying type\n /\nexport type Rejectable<R> = Either<R, any>;\n\n/\n Shortcut for underlying task result type\n \n @template R underlying type\n /\nexport type Cancelable<R> = Maybe<Rejectable<R>>;\n\n/\n Function returning Task\n \n @template A argument types\n * @template R returned task resolve type\n /\nexport type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;\n\n/\n Task generator\n \n @template T yielded underlying type\n * @template TT yielded task type\n * @template R returned task resolve type\n \n @example\n * ```typescript\n * const generatorFunction = function(): TaskGenerator<unknown, Task<string>, number> {\n const v = yield* someTaskFunction().generator();\n \n return v.length;\n * };\n * ```\n /\nexport type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;\n\n/\n Function returning task generator (generator function)\n \n @template A argument types\n * @template T yielded underlying type\n * @template TT yielded task type\n * @template R returned task resolve type\n \n @example\n * ```typescript\n * const generatorFunction: TaskGeneratorFunction<[], unknown, Task<string>, number> = function() {\n const v = yield* someTaskFunction().generator();\n \n return v.length;\n * };\n * ```\n /\nexport type TaskGeneratorFunction<A extends unknown[], T, TT extends Task<T>, R> = (...args: A) => TaskGenerator<T, TT, R>;\n\n/\n Task monad interface\n \n @template R task resolve type\n /\nexport interface Task<R> extends TaskBase<R> {\n /\n Invoke callback when task is resolved (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tap(op: (value: R) => void): Task<R>;\n\n /\n Invoke callback when task is rejected (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tapRejected(op: (error: any) => void): Task<R>;\n\n /\n Invoke callback when task is canceled (and only then)\n \n @param op callback to invoke\n * @returns self\n /\n tapCanceled(op: () => void): Task<R>;\n\n /\n Invoke a dedicated callback according to task resolution\n \n @param op.resolved callback to invoke on success\n * @param op.rejected callback to invoke on failure\n * @param op.canceled callback to invoke on cancelation\n * @returns self\n /\n matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R>;\n\n /\n Invoke transformer when task is resolved (and only then) and return it's result instead\n \n @template R2 transformer return type\n * @param op transformer to invoke\n * @returns task returning transformer result\n /\n map<R2>(op: (value: R) => R2): Task<R2>;\n\n /\n Invoke transformer when task is rejected (and only then) and return it's result instead\n \n @template R2 fallback return type\n * @param op transformer to invoke\n * @returns task returning fallback result in case of failure\n /\n mapRejected<R2>(op: (error: any) => R2): Task<R \| R2>;\n\n /\n Invoke transformer when task is canceled (and only then) and return it's result instead\n \n @template R2 fallback return type\n * @param op transformer to invoke\n * @returns task returning fallback result in case of cancelation\n /\n mapCanceled<R2>(op: () => R2): Task<R \| R2>;\n\n /\n Invoke a dedicated transformer according to task resolution\n \n @template R2 success transformer return type\n * @template R3 failure transformer return type\n * @template R4 cancelation transformer return type\n * @param op.resolved transformer to invoke on success\n * @param op.rejected transformer to invoke on failure\n * @param op.canceled transformer to invoke on cancelation\n * @returns task resolving to a corresponding transformer result\n /\n matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 \| R3 \| R4>;\n\n /\n Invoke transformer when task is resolved (and only then) and continue execution with it's result\n \n @template R2 transformer task resolve type\n * @param op transformer to invoke\n * @returns task chaining to transformer result task\n /\n chain<R2>(op: (value: R) => Task<R2>): Task<R2>;\n\n /\n Invoke transformer when task is rejected (and only then) and continue execution with it's result\n \n @template R2 fallback task resolve type\n * @param op transformer to invoke\n * @returns task chaining to fallback task in case of failure\n /\n chainRejected<R2>(op: (error: any) => Task<R2>): Task<R \| R2>;\n\n /\n Invoke transformer when task is canceled (and only then) and continue execution with it's result\n \n @template R2 fallback task resolve type\n * @param op transformer to invoke\n * @returns task chaining to fallback task in case of cancelation\n /\n chainCanceled<R2>(op: () => Task<R2>): Task<R \| R2>;\n\n /\n Invoke a dedicated transformer according to task resolution and continue execution with it's result\n \n @template R2 success transformer resolve type\n * @template R3 failure transformer resolve type\n * @template R4 cancelation transformer resolve type\n * @param op.resolved transformer to invoke on success\n * @param op.rejected transformer to invoke on failure\n * @param op.canceled transformer to invoke on cancelation\n * @returns task chaining to a corresponding transformer result\n /\n matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 \| R3 \| R4>;\n\n /\n Read the settled result when the task has already finished\n \n @returns settled result, or null when the task is still pending\n /\n resolved: () => Cancelable<R> \| null;\n\n /\n Return underlying promise in order to await result\n \n @returns underlying promise\n /\n resolve: () => TaskInvoke<R>;\n\n /\n Invoke underlying cancel method without error\n \n @returns 'true' when the task was still pending and cancelation was applied\n /\n cancel: () => boolean;\n\n /\n Invoke underlying cancel method with error\n \n @param error error value to be injected from outside\n * @returns 'true' when the task was still pending and the error was applied\n /\n reject: (error: any) => boolean;\n\n /\n Wrap task to singleton generator\n \n Userful in order to avoid ambiguous yied types\n \n @returns generator of task wrapping the task\n * @example\n * ```typescript\n * const getString = () => Task.resolved('hello');\n * const getLength = (data: string) => Task.resolved(data.length);\n \n // ..... //\n \n Task.generate(function* () {\n * const data = yield getString(); // data: string \| number\n * const length = yield getLength(data); // length: string \| number\n \n return length;\n * });\n \n // ..... //\n \n Task.generate(function* () {\n * const data = yield* getString().generator(); // data: string\n * const length = yield* getLength(data).generator(); // length: number\n \n return length;\n * });\n * ```\n /\n generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;\n}\n\nexport namespace Task {\n /\n Custom task monad constructor\n \n @template R returned task's resolve type\n * @param invoke promise defining task execution\n * @param cancel cancelation function\n * @returns task resolving to resolve value of invoke\n \n @note low-level primitive for creating custom tasks, not intended for general use\n /\n export function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R> {\n return new TaskClass<R>({ resolved: false, invoke, cancel });\n }\n\n /\n Invariant task constructor creating resolved task from plain value\n \n @template R returned task's resolve type\n * @param value value to be returned upon awaiting\n * @returns task resolving to specified value\n /\n export function resolved<R>(value: R): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.right(value)) });\n }\n\n /\n Invariant task constructor creating rejected task from error value\n \n @template R returned task's resolve type\n * @param error error to be returned upon awaiting\n * @returns task rejected with the specified error\n /\n export function rejected<R>(error: any): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.just(Either.left(error)) });\n }\n\n /\n Invariant task constructor creating canceled task\n \n @template R returned task's resolve type\n * @returns canceled task\n /\n export function canceled<R>(): Task<R> {\n return new TaskClass<R>({ resolved: true, result: Maybe.nothing() });\n }\n\n /\n Lift from promise to task resolving to that promise result\n \n Userfull for converting promises to tasks\n * If converted task is canceled or failed externally return value will be ignored without side-effects\n * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n \n @template R returned task resolve type\n * @param promise promise to be resolved\n * @returns task resolving to specified promise value\n \n @example\n * ```typescript\n * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);\n * ```\n /\n export function fromPromise<R>(promise: PromiseLike<R>): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));\n \n promise\n .then(Either.right, Either.left)\n .then(Maybe.just)\n .then(cell.resolve);\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Lift from sync function to task resolving to said function result\n \n Generally, functions are not considered tasks as they cannot be interrupted in any way\n * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from\n * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain\n * This function is mostly used internally and is not expected to be widely used except of some edge scenarios\n \n If converted task is canceled or failed externally return value will be ignored without side-effects\n * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n \n @template R returned task resolve type\n * @param producer function to be wrapped to a task\n * @param cancelRef reference object allowing to set cancelation function prior to invoking function\n * @returns task resolving to the specified function's result\n \n @example\n * ```typescript\n * const cancelRef = { cancel: () => {} };\n \n const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);\n * ```\n /\n export function fromFunction<R>(producer: () => R, cancelRef: { cancel: TaskCancel }): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n const cancel: TaskCancel = (error: Maybe<any>) => cell.resolve(error.map(Either.left));\n\n cancelRef.cancel = cancel;\n\n try {\n cell.resolve(Maybe.just(Either.right(producer())));\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Generic callback task\n \n Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFunction\n \n @template H cancelation handler type\n * @template R returned task resolve type\n * @param create task body with success and error callbacks\n * @param onCancel cancelation function intended for stopping task execution\n * @returns task resolving to success value\n \n @example\n * ```typescript\n * export function timeout(delay: number) {\n * return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n * }\n * ```\n /\n export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void, cancel: () => void) => H, onCancel: (handler: H) => void): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n\n let handler: { value: H } \| null = null;\n\n const cancel: TaskCancel = (error: Maybe<any>) => {\n const wasPending = cell.resolve(error.map(Either.left));\n if (wasPending && handler) {\n onCancel(handler.value);\n }\n return wasPending;\n }\n\n try {\n const value = create(\n (r) => cell.resolve(Maybe.just(Either.right(r))),\n (e) => cell.resolve(Maybe.just(Either.left(e))),\n () => cancel(Maybe.nothing()),\n );\n\n handler = { value };\n\n const result = cell.settled();\n if (result && !result.value.match({ just: (v) => v.isRight(), nothing: () => false })) {\n onCancel(value);\n }\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Lift an async operation that accepts an AbortSignal into a Task.\n \n Creates an internal AbortController and passes its signal to `producer`.\n * If the resulting task is canceled or rejected externally, `controller.abort()`\n * is called automatically.\n \n @template R returned task resolve type\n * @param producer factory function receiving an AbortSignal\n * @returns task wrapping the operation\n \n @example\n * ```typescript\n * const fetchUser = (id: string) =>\n * Task.fromAbortSignal((signal) =>\n * fetch(`/api/users/${id}`, { signal }).then((res) => res.json())\n * );\n * ```\n /\n export function fromAbortSignal<R>(\n producer: (signal: AbortSignal) => PromiseLike<R>\n ): Task<R> {\n const cell = settleCell<Cancelable<R>>();\n const controller = new AbortController();\n\n const cancel: TaskCancel = (error: Maybe<any>) => {\n const wasPending = cell.resolve(error.map(Either.left));\n if (wasPending) {\n controller.abort(error.match({ just: (err) => err, nothing: () => undefined }));\n }\n return wasPending;\n };\n\n try {\n producer(controller.signal).then((value) => {\n cell.resolve(Maybe.just(Either.right(value)));\n }, (error) => {\n if (controller.signal.aborted && (error?.name === 'AbortError' \|\| (typeof DOMException !== 'undefined' && error instanceof DOMException && error.name === 'AbortError'))) {\n cell.resolve(Maybe.nothing());\n } else {\n cell.resolve(Maybe.just(Either.left(error)));\n }\n });\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n }\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Convinience shortcut for yielding async functions as tasks\n \n @template R returned generator resolve type\n * @param promise promise to be resolved\n * @returns generator to be be used with yield\n /\n export function promiseGenerator<R>(promise: PromiseLike<R>) {\n return Task.fromPromise(promise).generator();\n }\n\n /*\n Convinience shortcut for yielding timers\n \n @param delay duration in ms after that the generator resolves\n * @returns generator to be used with yield\n /\n export function timeoutGenerator(delay: number) {\n return Task.timeout(delay).generator();\n }\n\n /*\n Lift from function returning value/promise to function returning task resolving to that value\n \n Userfull for converting exising async functions to task functions for further use\n \n @template A returned function's argument types\n * @template R returned function's result task's resolve type\n * @param promiseFunction function returning promise or plain value to be resolved\n * @returns task function wrapping specified promise function\n * @see Task.fromPromise\n \n @example\n * ```typescript\n * const taskFunction = liftPromiseFunction(someAsyncOperation);\n \n const task = taskFunction('someData').map((result) => result.length);\n * ```\n /\n export function lift<A extends unknown[], R>(promiseFunction: (...args: A) => PromiseLike<R>): TaskFunction<A, R> {\n return (...args: A) => Task.fromPromise(promiseFunction(...args));\n }\n\n /\n Create compound task from generator function\n \n Applying yield to task within the generator function awaits the task and returns underlying value in case of success\n * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types\n \n In case of failure an error is thrown and may be caught by try-catch\n \n If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately\n \n @template T yielded underlying type\n * @template TT yielded task type\n * @template R returned task resolve type\n * @param taskGeneratorFunction task generator function\n * @returns task resolving to generator's return type\n \n @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield\n * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly\n \n @example\n * ```typescript\n * const task = Task.generate(function() {\n try {\n * const value1 = yield* delayedValueTask('data', 400).generator();\n \n const value2 = yield* delayedValueTask(value1.length, 300).generator();\n \n return value2;\n * } catch (e) {\n * return -1;\n * }\n * });\n * ```\n /\n export function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R> {\n const generator: TaskGenerator<T, TT, R> = taskGeneratorFunction();\n const cell = settleCell<Cancelable<R>>();\n\n let current: { task: Task<T>; error: Maybe<any> \| null } \| null = null;\n\n const sequentor = (invoke: () => IteratorResult<TT, R>, override?: Cancelable<R>) => {\n try {\n const next = invoke();\n\n if (next.done) {\n cell.resolve(override ?? current?.error?.map(Either.left) ?? Maybe.just(Either.right(next.value)));\n current = null;\n return;\n }\n\n current = {\n task: next.value,\n error: null,\n };\n\n next.value._invoke((maybe) => maybe.matchTap({\n just: (either) => either.matchTap({\n right: (value) => sequentor(() => generator.next(value), override),\n left: (error) => sequentor(() => generator.throw(error), override),\n }),\n nothing: () => sequentor(() => generator.return(undefined as R), Maybe.nothing()),\n }))\n } catch (error) {\n cell.resolve(override ?? Maybe.just(Either.left(error)));\n current = null;\n }\n };\n\n sequentor(() => generator.next());\n\n return Task.create(cell.promise, (error) => {\n if (cell.settled() \|\| !current) {\n return false;\n }\n\n current.error = error;\n\n return current.task._cancel(error);\n });\n }\n\n /\n Task function generator\n * \n * Simplifies wrighting functions returning generated tasks\n * \n * @template A generator arguments\n * @template T yielded underlying type\n * @template TT yielded task type\n * @template R returned task resolve type\n * @param taskGeneratorFunction function* (...args) task generator function\n * @returns task function resolving to generator's return type\n /\n export function generateFunction<A extends any[], T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<A, T, TT, R>): TaskFunction<A, R> {\n return (...args: A) => generate(() => taskGeneratorFunction(...args));\n }\n\n /\n Generic timeout task\n \n Usefull for creating delays in task chains or implementing limiting tasks\n \n @param delay duration in ms after that the task resolves to void\n * @returns task resolving to void (undefined) after specified delay\n \n @example\n * ```typescript\n * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);\n * // ... //\n * const value = yield* delayedValueTask(42, 1000).generator();\n \n console.log(\"It's past 1 second and here's a value:\", value)\n * ```\n /\n export function timeout(delay: number) {\n return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(resolve, delay), clearTimeout);\n }\n\n /\n Start multiple tasks one after another\n \n @template T underlying task type\n * @param taskFunctions list of task functions (without arguments)\n * @returns composite task invoring every task in order and resolving to the list of results\n /\n export function sequence<T>(taskFunctions: Iterable<TaskFunction<[], T>>): Task<T[]> {\n return Array.from(taskFunctions).reduce((prev, taskFunction) => {\n return prev.chain((list) => {\n return taskFunction().map((value) => list.concat(value));\n });\n }, Task.resolved<T[]>([]));\n }\n\n /\n Execute all tasks in parallel and return list of results\n \n Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order\n * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled\n * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n \n @note direct equivalent of Promise.all\n \n @template T underlying task type\n * @param tasks iterable of tasks to execute\n * @returns task resolving to the list of results\n /\n export function all<T>(tasks: Iterable<Task<T>>) {\n const taskArray = Array.from(tasks);\n if (taskArray.length === 0) {\n return Task.resolved([]);\n }\n\n return Task.fromCallback<Task<T>[], T[]>((resolve, reject, cancel) => {\n const results: T[] = new Array(taskArray.length);\n let remaining = taskArray.length;\n\n taskArray.forEach((task, i) => {\n task.matchTap({\n resolved: (value) => {\n results[i] = value;\n remaining--;\n if (remaining === 0) resolve(results);\n },\n rejected: (error) => {\n reject(error);\n taskArray.forEach((t) => t.cancel());\n },\n canceled: () => {\n cancel();\n taskArray.forEach((t) => t.cancel());\n },\n });\n });\n\n return taskArray;\n }, (subtasks) => subtasks.forEach((t) => t.cancel()));\n }\n\n /\n Execute all tasks in parallel and return the result of the first successful one\n \n Resulting task resolves when the first tasks is successfuly resolved, returning it's result\n * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors\n * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors\n * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n \n @note direct equivalent of Promise.any\n \n @template T underlying task type\n * @param tasks iterable of tasks to execute\n * @returns task resolving to the result of first successfull task\n /\n export function any<T>(tasks: Iterable<Task<T>>) {\n const cell = settleCell<Cancelable<T>>();\n\n const taskArray = Array.from(tasks);\n\n if (taskArray.length < 1) {\n return Task.canceled();\n }\n\n const cancel = (error: Maybe<any>) => taskArray.map((task) => task._cancel(error)).every((r) => r);\n\n const list = taskArray.map<Maybe<any>>(() => Maybe.nothing());\n\n const resolved = (value: Maybe<T>) => {\n cell.resolve(value.map(Either.right));\n cancel(Maybe.nothing());\n };\n\n const rejected = (error: any, i: number) => {\n list[i] = Maybe.just(error);\n\n if (Maybe.everyJust(list)) {\n cell.resolve(Maybe.just(Either.left(list.map((v) => Just.just(v)))));\n }\n };\n\n taskArray.map((task, i) => {\n return task.matchTap({\n resolved: (value) => resolved(Maybe.just(value)),\n rejected: (error) => rejected(error, i),\n canceled: () => resolved(Maybe.nothing()),\n });\n });\n\n return Task.create(cell.promise, cancel);\n }\n\n /\n Limit task execution based on another task\n \n If the second task resolves sooner than the first, resulting task is canceled\n * Otherwise the resulting task resolves together with the first one\n \n @template T underlying task type\n * @param task task to limit\n * @param limitTask limiting task\n * @returns task limites according to limitTask\n /\n export function limit<T>(task: Task<T>, limitTask: Task<void>) {\n return Task.any<T>([task, limitTask.chain<T>(Task.canceled)]).chainRejected((errors) => Task.rejected<T>(errors[0]));\n }\n\n /\n Repeat task untill successful\n \n Given task is re-generated in case of failure (both external and internal)\n * Resulting task is still cancelable by standard means\n \n @template T underlying task type\n * @param taskFunction task preoducing function\n * @returns task that retries until the produced task resolves\n /\n export function repeat<T>(taskFunction: TaskFunction<[], T>) {\n const sequentor = (): Task<T> => taskFunction().chainRejected(sequentor);\n\n return sequentor();\n }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\ntype TaskInvoke<R> = Promise<Cancelable<R>>;\ntype TaskCancel = (error: Maybe<any>) => boolean;\n\n/\n @hidden\n /\ninterface TaskBase<R> {\n _invoke(op: (result: Cancelable<R>) => void): void;\n _cancel(error: Maybe<any>): boolean;\n}\n\n/\n One-shot settlement cell.\n \n The Promise is created internally, so there is no unarmed window: `resolve`\n * before or after construction always owns the result (first writer wins).\n * Later `resolve` calls are ignored. Reentrant `resolve` from the sink is ignored.\n \n `settled` is for skipping continuations; it does not cancel children by itself.\n * After creating a child, if `settled` is already true, cancel that child with\n * the stored value. Bind `_cancel` to the child only after that check.\n /\ntype SettleCell<T> = {\n readonly promise: Promise<T>;\n readonly resolve: (value: T) => boolean;\n readonly settled: () => { value: T } \| null;\n};\n\nconst stub = () => void undefined;\n\nconst settleCell = <T>(): SettleCell<T> => {\n let sink: (value: T) => void = stub;\n let settled: { value: T } \| null = null;\n\n const promise = new Promise<T>((resolve) => {\n sink = resolve;\n });\n\n const resolve = (next: T) => {\n if (settled) {\n return false;\n }\n\n settled = { value: next };\n\n sink(next);\n\n return true;\n };\n\n return {\n promise,\n resolve,\n settled: () => settled,\n };\n};\n\nfunction chainTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Task<R2>): Task<R2> {\n const cell = settleCell<Cancelable<R2>>();\n\n let state:\n \| { phase: 'parent' }\n \| { phase: 'transform', error: Maybe<any> \| null }\n \| { phase: 'child', cancel: TaskCancel }\n \| { phase: 'closed' } = { phase: 'parent' };\n\n parent._invoke((result) => {\n state = { phase: 'transform', error: null }\n\n let child: Task<R2> \| null = null;\n try {\n child = op(result);\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n state = { phase: 'closed' };\n return;\n }\n\n const transformError = state.phase === 'transform' ? state.error : null;\n\n state = { phase: 'child', cancel: (error) => child._cancel(error) };\n\n if (transformError) {\n cell.resolve(transformError.map(Either.left));\n state = { phase: 'closed' };\n child._cancel(transformError);\n return;\n }\n\n return child._invoke((value) => {\n cell.resolve(value);\n state = { phase: 'closed' };\n });\n });\n\n return Task.create(cell.promise, (error) => {\n if (cell.settled()) {\n return false;\n }\n\n if (state.phase === 'parent') {\n return parent._cancel(error);\n } else if (state.phase === 'transform') {\n state.error = error;\n return true;\n } else if (state.phase === 'child') {\n return state.cancel(error);\n } else {\n return false;\n }\n });\n}\n\nfunction mapTaskMaybe<R, R2>(parent: Task<R>, op: (value: Cancelable<R>) => Cancelable<R2>): Task<R2> {\n const cell = settleCell<Cancelable<R2>>();\n\n let state:\n \| { phase: 'parent' }\n \| { phase: 'transform', error: Maybe<any> \| null }\n \| { phase: 'closed' } = { phase: 'parent' };\n\n parent._invoke((result) => {\n state = { phase: 'transform', error: null }\n\n let value: Cancelable<R2> \| null = null;\n try {\n value = op(result);\n } catch (e) {\n cell.resolve(Maybe.just(Either.left(e)));\n state = { phase: 'closed' };\n return;\n }\n\n const transformError = state.phase === 'transform' ? state.error : null;\n\n if (transformError) {\n cell.resolve(transformError.map(Either.left));\n } else {\n cell.resolve(value);\n }\n \n state = { phase: 'closed' };\n });\n\n return Task.create(cell.promise, (error) => {\n if (cell.settled()) {\n return false;\n }\n\n if (state.phase === 'parent') {\n return parent._cancel(error);\n } else if (state.phase === 'transform') {\n state.error = error;\n return true;\n } else {\n return false;\n }\n });\n}\n\nfunction tapTaskMaybe<R>(parent: Task<R>, op: (value: Cancelable<R>) => void): Task<R> {\n parent._invoke((result) => {\n try {\n op(result);\n } catch (e) {\n reportError(e);\n }\n });\n\n return parent;\n}\n\nfunction chainTaskEither<R, R2>(_task: Task<R>, op: (value: Rejectable<R>) => Task<R2>): Task<R2> {\n return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);\n}\n\nfunction mapTaskEither<R, R2>(_task: Task<R>, op: (value: Rejectable<R>) => Rejectable<R2>): Task<R2> {\n return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));\n}\n\nfunction tapTaskEither<R>(_task: Task<R>, op: (value: Rejectable<R>) => void): Task<R> {\n return tapTaskMaybe<R>(_task, (maybe) => maybe.tap(op));\n}\n\ntype SyncState<R> =\n \| { resolved: false; invoke: TaskInvoke<R>; cancel: TaskCancel }\n \| { resolved: true; result: Cancelable<R> }\n\nclass TaskClass<R> implements Task<R> {\n constructor(private _state: SyncState<R>) {\n if (!this._state.resolved) {\n this._state.invoke = this._state.invoke.then((result) => {\n if (!this._state.resolved) {\n this._state = { resolved: true, result }\n }\n return result;\n });\n }\n }\n\n _invoke(op: (result: Cancelable<R>) => void) {\n if (this._state.resolved) {\n return op(this._state.result);\n } else {\n return this._state.invoke.then(op);\n }\n }\n\n _cancel(error: Maybe<any>) {\n if (this._state.resolved) {\n return false\n } else {\n return this._state.cancel(error);\n }\n }\n\n tapCanceled(op: () => void): Task<R> {\n return tapTaskMaybe<R>(this, (maybe) => maybe.orTap(op));\n }\n tapRejected(op: (error: any) => void): Task<R> {\n return tapTaskEither<R>(this, (either) => either.orTap(op));\n }\n tap(op: (value: R) => void): Task<R> {\n return tapTaskEither<R>(this, (either) => either.tap(op));\n }\n\n mapCanceled<R2>(op: () => R2): Task<R \| R2> {\n return mapTaskMaybe<R, R \| R2>(this, (maybe) => maybe.orMap(() => Either.right(op())));\n }\n mapRejected<R2>(op: (error: any) => R2): Task<R \| R2> {\n return mapTaskEither<R, R \| R2>(this, (either) => either.orMap(op));\n }\n map<R2>(op: (value: R) => R2): Task<R2> {\n return mapTaskEither<R, R2>(this, (either) => either.map(op));\n }\n\n chainCanceled<R2>(op: () => Task<R2>): Task<R \| R2> {\n const mapEither = (either: Rejectable<R>) => either.map(Task.resolved).orMap<Task<R>>(Task.rejected).right;\n\n return chainTaskMaybe<R, R \| R2>(this, (maybe) => maybe.map(mapEither).orMap(op).just);\n }\n chainRejected<R2>(op: (error: any) => Task<R2>): Task<R \| R2> {\n return chainTaskEither<R, R \| R2>(this, (either) => either.map(Task.resolved).orMap(op).right);\n }\n chain<R2>(op: (value: R) => Task<R2>): Task<R2> {\n return chainTaskEither<R, R2>(this, (either) => either.map(op).orMap<Task<R2>>(Task.rejected).right);\n }\n\n resolved() {\n if (this._state.resolved) {\n return this._state.result;\n } else {\n return null;\n }\n }\n\n resolve() {\n if (this._state.resolved) {\n return Promise.resolve(this._state.result);\n } else {\n return this._state.invoke;\n }\n }\n cancel() {\n if (this._state.resolved) {\n return false;\n } else {\n return this._state.cancel(Maybe.nothing());\n }\n }\n reject(error: any) {\n if (this._state.resolved) {\n return false;\n } else {\n return this._state.cancel(Maybe.just(error));\n }\n }\n\n generator() {\n return (function(task) {\n return (yield task) as R;\n })(this);\n }\n\n matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R> {\n return tapTaskMaybe(this, (maybe) => {\n return maybe.matchTap({\n just: (either) => {\n return either.matchTap({\n right: op.resolved,\n left: op.rejected,\n });\n },\n nothing: op.canceled,\n });\n });\n }\n\n matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 \| R3 \| R4> {\n return mapTaskMaybe(this, (maybe) => {\n return Maybe.just(maybe.match<Right<R2 \| R3 \| R4, any>>({\n just: (either) => {\n return Either.right(either.match({\n right: op.resolved,\n left: op.rejected,\n }));\n },\n nothing: () => Either.right(op.canceled()),\n }));\n });\n }\n\n matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 \| R3 \| R4> {\n return chainTaskMaybe(this, (maybe) => {\n return maybe.match<Task<R2 \| R3 \| R4>>({\n just: (either) => {\n return either.match<Task<R2 \| R3>>({\n right: op.resolved,\n left: op.rejected,\n });\n },\n nothing: op.canceled,\n });\n });\n }\n}\n\nfunction reportError(error: unknown): void {\n if (typeof globalThis.reportError === 'function') {\n globalThis.reportError(error);\n }\n}\n"],"mappings":"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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "t-tasks",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "main": "dist/t-tasks.js",
   "module": "dist/t-tasks.esm.js",