modern-ts 0.8.0

package/dist/types/Maybe/consumers-async.d.ts

@@ -0,0 +1,58 @@
+import { AnyMaybe, Maybe } from './types';
+import { MaybePromise } from '../Utils/type-tool';
+/**
+ * Asynchronously pattern matches on a Maybe value, executing the appropriate callback
+ * @param val - The Maybe value or Promise of Maybe to match on
+ * @param onSome - Callback executed when value is Some
+ * @param onNone - Callback executed when value is None
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns Promise resolving to the result of the executed callback
+ */
+export declare function matchAsync<T, R>(val: AnyMaybe<T>, onSome: (value: T, signal?: AbortSignal) => MaybePromise<R>, onNone: (signal?: AbortSignal) => MaybePromise<R>, signal?: AbortSignal): Promise<R>;
+/**
+ * Executes callback only if Maybe value is Some (single callback version)
+ * @returns Promise resolving to callback result or undefined
+ */
+export declare function ifSomeAsync<T, R1>(val: AnyMaybe<T>, onSome: (value: T) => MaybePromise<R1>): Promise<R1 | void>;
+/**
+ * Executes appropriate callback based on Maybe value (two callback version)
+ * @returns Promise resolving to result of either callback
+ */
+export declare function ifSomeAsync<T, R1, R2>(val: AnyMaybe<T>, onSome: (value: T) => MaybePromise<R1>, onElse: () => MaybePromise<R2>): Promise<R1 | R2>;
+/**
+ * Executes callback only if Maybe value is None (single callback version)
+ * @returns Promise resolving to callback result or undefined
+ */
+export declare function ifNoneAsync<T, R1>(val: AnyMaybe<T>, onNone: () => MaybePromise<R1>): Promise<R1 | void>;
+/**
+ * Executes appropriate callback based on Maybe value (two callback version)
+ * @returns Promise resolving to result of either callback
+ */
+export declare function ifNoneAsync<T, R1, R2>(val: AnyMaybe<T>, onNone: () => MaybePromise<R1>, onElse: (value: T) => MaybePromise<R2>): Promise<R1 | R2>;
+/**
+ * Executes a side effect for Some values without modifying the Maybe
+ * @param val - The Maybe value or Promise of Maybe to inspect
+ * @param fn - Side effect function for Some values
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns Promise resolving to the original Maybe value
+ */
+export declare function peekAsync<T>(val: AnyMaybe<T>, fn: (v: T, signal?: AbortSignal) => MaybePromise<void>, signal?: AbortSignal): Promise<Maybe<T>>;
+/**
+ * Executes a side effect for None values without modifying the Maybe
+ * @param val - The Maybe value or Promise of Maybe to inspect
+ * @param fn - Side effect function for None values
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns Promise resolving to the original Maybe value
+ */
+export declare function peekNoneAsync<T>(val: AnyMaybe<T>, fn: (signal?: AbortSignal) => MaybePromise<void>, signal?: AbortSignal): Promise<Maybe<T>>;
+/**
+ * Executes side effects for both Some and None cases without modifying the Maybe
+ * @param val - The Maybe value or Promise of Maybe to inspect
+ * @param handlers - Object containing optional Some and None handlers
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns Promise resolving to the original Maybe value
+ */
+export declare function peekBothAsync<T>(val: AnyMaybe<T>, { fnSome, fnNone, }: {
+    fnSome?: (v: T, signal?: AbortSignal) => MaybePromise<void>;
+    fnNone?: (signal?: AbortSignal) => MaybePromise<void>;
+}, signal?: AbortSignal): Promise<Maybe<T>>;

package/dist/types/Maybe/consumers.d.ts

@@ -0,0 +1,63 @@
+import { Maybe } from './types';
+/**
+ * Pattern matching for Maybe type
+ * @param val - Maybe value to match
+ * @param onSome - Callback for Some case
+ * @param onNone - Callback for None case
+ * @returns Result of the matched case
+ */
+export declare const match: <T, R>(val: Maybe<T>, onSome: (value: T) => R, onNone: () => R) => R;
+/**
+ * Execute callback only if Maybe is Some
+ * @param val - Maybe value to check
+ * @param onSome - Callback for Some case
+ * @returns Callback result or undefined
+ */
+export declare function ifSome<T, R1>(val: Maybe<T>, onSome: (value: T) => R1): R1 | void;
+/**
+ * Execute callback for Some, fallback for None
+ * @param val - Maybe value to check
+ * @param onSome - Callback for Some case
+ * @param onElse - Fallback callback
+ * @returns Result of either callback
+ */
+export declare function ifSome<T, R1, R2>(val: Maybe<T>, onSome: (value: T) => R1, onElse: () => R2): R1 | R2;
+/**
+ * Execute callback only if Maybe is None
+ * @param val - Maybe value to check
+ * @param onNone - Callback for None case
+ * @returns Callback result or undefined
+ */
+export declare function ifNone<T, R1>(val: Maybe<T>, onNone: () => R1): R1 | void;
+/**
+ * Execute callback for None, fallback for Some
+ * @param val - Maybe value to check
+ * @param onNone - Callback for None case
+ * @param onElse - Fallback callback
+ * @returns Result of either callback
+ */
+export declare function ifNone<T, R1, R2>(val: Maybe<T>, onNone: () => R1, onElse: (value: T) => R2): R1 | R2;
+/**
+ * Peek at Some value without consuming
+ * @param val - Maybe value to inspect
+ * @param fn - Side effect callback
+ * @returns Original Maybe value
+ */
+export declare const peek: <T>(val: Maybe<T>, fn: (v: T) => void) => Maybe<T>;
+/**
+ * Peek at None case without consuming
+ * @param val - Maybe value to inspect
+ * @param fn - Side effect callback
+ * @returns Original Maybe value
+ */
+export declare const peekNone: <T>(val: Maybe<T>, fn: () => void) => Maybe<T>;
+/**
+ * Peek at both cases with separate callbacks
+ * @param val - Maybe value to inspect
+ * @param callbacks - Object with Some and None handlers
+ * @returns Original Maybe value
+ */
+export declare function peekBoth<T>(val: Maybe<T>, { fnSome, fnNone, }: {
+    fnSome?: (v: T) => void;
+    fnNone?: () => void;
+}): Maybe<T>;

package/dist/types/Maybe/operators-async.d.ts

@@ -0,0 +1,145 @@
+import { AnyMaybe, AsyncMaybe } from './types';
+/**
+ * Applies async function from Maybe to async value.
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param fn_val - Maybe function
+ * @param val - Maybe value
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R>
+ */
+export declare const apAsync: <T, R>(fn_val: AnyMaybe<(v: T) => R | Promise<R>>, val: AnyMaybe<T>, signal?: AbortSignal) => AsyncMaybe<R>;
+/**
+ * Transforms async Maybe value with async function.
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param fn - Async transformation function
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R>
+ */
+export declare const mapAsync: <T, R>(val: AnyMaybe<T>, fn: (v: T) => R | Promise<R>, signal?: AbortSignal) => AsyncMaybe<R>;
+/**
+ * Maps value only if predicate passes (async).
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param predicate - Async condition check
+ * @param fn - Async transformation function
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R>
+ */
+export declare const mapIfAsync: <T, R>(val: AnyMaybe<T>, predicate: (v: T) => boolean | Promise<boolean>, fn: (v: T) => R | Promise<R>, signal?: AbortSignal) => AsyncMaybe<R>;
+/**
+ * Chains async computations that may fail.
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param fn - Async function returning Maybe
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R>
+ */
+export declare const andThenAsync: <T, R>(val: AnyMaybe<T>, fn: (v: T) => AnyMaybe<R>, signal?: AbortSignal) => AsyncMaybe<R>;
+/**
+ * Filters async Maybe value with async predicate.
+ * @typeparam T - Value type
+ * @param val - Maybe value
+ * @param predicate - Async filter condition
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<T>
+ */
+export declare const filterAsync: <T>(val: AnyMaybe<T>, predicate: (v: T) => boolean | Promise<boolean>, signal?: AbortSignal) => AsyncMaybe<T>;
+/**
+ * Zips two async Maybes into tuple if both are Some.
+ * @typeparam T - First type
+ * @typeparam U - Second type
+ * @param a - First Maybe
+ * @param b - Second Maybe
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<[T, U]>
+ */
+export declare const zipAsync: <T, U>(a: AnyMaybe<T>, b: AnyMaybe<U>, signal?: AbortSignal) => AsyncMaybe<[T, U]>;
+/**
+ * Extracts value from async Maybe or returns default.
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param initial - Default value or Promise
+ * @param onSome - Async handler for Some case
+ * @param signal - Optional AbortSignal
+ * @returns Promise<R>
+ */
+export declare const foldAsync: <T, R>(val: AnyMaybe<T>, initial: R | Promise<R>, onSome: (v: T) => R | Promise<R>, signal?: AbortSignal) => Promise<R>;
+/**
+ * Returns value if Some, otherwise async fallback.
+ * @typeparam T - Value type
+ * @param val - Maybe value
+ * @param fn - Async fallback supplier
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<T>
+ */
+export declare const orElseAsync: <T>(val: AnyMaybe<T>, fn: () => AnyMaybe<T>, signal?: AbortSignal) => AsyncMaybe<T>;
+/**
+ * Maps array with async function, fails if any returns None.
+ * @typeparam T - Input type
+ * @typeparam R - Output type
+ * @param items - Input array
+ * @param fn - Async mapping function
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R[]>
+ */
+export declare const mapAllAsync: <T, R>(items: readonly T[], fn: (it: T, i: number) => AnyMaybe<R>, signal?: AbortSignal) => AsyncMaybe<R[]>;
+/**
+ * Returns all async values if all are Some, None otherwise.
+ * @typeparam T - Element type
+ * @param vals - Array of async Maybes
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<T[]>
+ */
+export declare const allAsync: <T>(vals: readonly AnyMaybe<T>[], signal?: AbortSignal) => AsyncMaybe<T[]>;
+/**
+ * Returns first Some value from async array, None if none found.
+ * @typeparam T - Element type
+ * @param vals - Array of async Maybes
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<T>
+ */
+export declare const firstSomeAsync: <T>(vals: readonly AnyMaybe<T>[], signal?: AbortSignal) => AsyncMaybe<T>;
+/**
+ * Reduces array of async Maybes with async reducer.
+ * @typeparam T - Element type
+ * @typeparam R - Result type
+ * @param vals - Array of async Maybes
+ * @param initial - Initial value
+ * @param reducer - Async reduction function
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R>
+ */
+export declare function reduceAsync<T, R>(vals: readonly AnyMaybe<T>[], initial: R, reducer: (acc: R, v: T) => R | Promise<R>, signal?: AbortSignal): AsyncMaybe<R>;
+/**
+ * Performs async scan reduction on array of async Maybes.
+ * @typeparam T - Element type
+ * @typeparam R - Result type
+ * @param vals - Array of async Maybes
+ * @param initial - Initial value
+ * @param scanner - Async scanning function
+ * @param signal - Optional AbortSignal
+ * @returns AsyncMaybe<R[]>
+ */
+export declare function scanAsync<T, R>(vals: readonly AnyMaybe<T>[], initial: R, scanner: (acc: R, v: T) => R | Promise<R>, signal?: AbortSignal): AsyncMaybe<R[]>;
+/**
+ * Collects all Some values from async array.
+ * @typeparam T - Element type
+ * @param vals - Array of async Maybes
+ * @param signal - Optional AbortSignal
+ * @returns Promise<T[]> - Only Some values
+ */
+export declare const collectSomesAsync: <T>(vals: readonly AnyMaybe<T>[], signal?: AbortSignal) => Promise<T[]>;
+/**
+ * Partitions async array into Some values and None count.
+ * @typeparam T - Element type
+ * @param vals - Array of async Maybes
+ * @param signal - Optional AbortSignal
+ * @returns Promise<[T[], number]> - [Some values, None count]
+ */
+export declare const partitionAsync: <T>(vals: readonly AnyMaybe<T>[], signal?: AbortSignal) => Promise<[T[], number]>;

package/dist/types/Maybe/operators.d.ts

@@ -0,0 +1,177 @@
+import { Maybe } from './types';
+/**
+ * Transforms the contained value if Some, returns None otherwise.
+ * @typeparam T - Original value type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param fn - Transformation function
+ * @returns Maybe<R>
+ */
+export declare const map: <T, R>(val: Maybe<T>, fn: (value: T) => R) => Maybe<R>;
+/**
+ * Chains computations that may fail. If Some, applies fn, otherwise returns None.
+ * @typeparam T - Original value type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param fn - Function returning Maybe<R>
+ * @returns Maybe<R>
+ */
+export declare const andThen: <T, R>(val: Maybe<T>, fn: (value: T) => Maybe<R>) => Maybe<R>;
+/**
+ * Applies a Maybe-wrapped function to a Maybe value.
+ * @typeparam T - Input type
+ * @typeparam R - Result type
+ * @param fn_val - Maybe<(v: T) => R>
+ * @param val - Maybe<T>
+ * @returns Maybe<R>
+ */
+export declare const ap: <T, R>(fn_val: Maybe<(v: T) => R>, val: Maybe<T>) => Maybe<R>;
+/**
+ * Returns Some if value satisfies predicate, None otherwise.
+ * @typeparam T - Value type
+ * @param val - Maybe value
+ * @param predicate - Filter condition
+ * @returns Maybe<T>
+ */
+export declare const filter: <T>(val: Maybe<T>, predicate: (v: T) => boolean) => Maybe<T>;
+/**
+ * Maps value if predicate passes, returns None otherwise.
+ * @typeparam T - Original type
+ * @typeparam R - Result type
+ * @param val - Maybe value
+ * @param predicate - Condition to check
+ * @param fn - Transformation function
+ * @returns Maybe<R>
+ */
+export declare const mapIf: <T, R>(val: Maybe<T>, predicate: (v: T) => boolean, fn: (v: T) => R) => Maybe<R>;
+/**
+ * Returns other if val is Some, None otherwise.
+ * @typeparam T - First type
+ * @typeparam U - Second type
+ * @param val - Maybe<T>
+ * @param other - Maybe<U>
+ * @returns Maybe<U>
+ */
+export declare const and: <T, U>(val: Maybe<T>, other: Maybe<U>) => Maybe<U>;
+/**
+ * Returns first Some value, otherwise other.
+ * @typeparam T - Value type
+ * @param val - First Maybe
+ * @param other - Fallback Maybe
+ * @returns Maybe<T>
+ */
+export declare const or: <T>(val: Maybe<T>, other: Maybe<T>) => Maybe<T>;
+/**
+ * Returns val if Some, otherwise calls fn for fallback.
+ * @typeparam T - Value type
+ * @param val - Maybe value
+ * @param fn - Fallback supplier
+ * @returns Maybe<T>
+ */
+export declare const orElse: <T>(val: Maybe<T>, fn: () => Maybe<T>) => Maybe<T>;
+/**
+ * Extracts value or returns default.
+ * @typeparam T - Input type
+ * @typeparam R - Output type
+ * @param val - Maybe value
+ * @param initial - Default value
+ * @param onSome - Handler for Some case
+ * @returns R
+ */
+export declare const fold: <T, R>(val: Maybe<T>, initial: R, onSome: (v: T) => R) => R;
+/**
+ * Checks if Maybe contains specific value.
+ * @typeparam T - Value type
+ * @param val - Maybe value
+ * @param x - Value to compare
+ * @returns boolean
+ */
+export declare const contains: <T>(val: Maybe<T>, x: T) => boolean;
+/**
+ * Combines two Maybes into tuple if both are Some.
+ * @typeparam T - First type
+ * @typeparam U - Second type
+ * @param a - Maybe<T>
+ * @param b - Maybe<U>
+ * @returns Maybe<[T, U]>
+ */
+export declare const zip: <T, U>(a: Maybe<T>, b: Maybe<U>) => Maybe<[T, U]>;
+/**
+ * Applies function to two Maybes if both are Some.
+ * @typeparam T - First type
+ * @typeparam U - Second type
+ * @typeparam R - Result type
+ * @param ma - Maybe<T>
+ * @param mb - Maybe<U>
+ * @param fn - Combining function
+ * @returns Maybe<R>
+ */
+export declare const zipWith: <T, U, R>(ma: Maybe<T>, mb: Maybe<U>, fn: (a: T, b: U) => R) => Maybe<R>;
+/**
+ * Returns array of all values if all are Some, None otherwise.
+ * @typeparam T - Element type
+ * @param vals - Array of Maybes
+ * @returns Maybe<T[]>
+ */
+export declare const all: <T>(vals: readonly Maybe<T>[]) => Maybe<T[]>;
+/**
+ * Maps array to Maybes, returns Some of results if all succeed.
+ * @typeparam T - Input type
+ * @typeparam U - Output type
+ * @param items - Input array
+ * @param fn - Mapping function
+ * @returns Maybe<U[]>
+ */
+export declare const mapAll: <T, U>(items: readonly T[], fn: (it: T, i: number) => Maybe<U>) => Maybe<U[]>;
+/**
+ * Partitions array into Some values and None count.
+ * @typeparam T - Element type
+ * @param vals - Array of Maybes
+ * @returns [T[], number] - [Some values, None count]
+ */
+export declare const partition: <T>(vals: readonly Maybe<T>[]) => [T[], number];
+/**
+ * Collects all Some values from array.
+ * @typeparam T - Element type
+ * @param vals - Array of Maybes
+ * @returns T[] - Only Some values
+ */
+export declare const collectSomes: <T>(vals: readonly Maybe<T>[]) => T[];
+/**
+ * Returns first Some value in array, None if none found.
+ * @typeparam T - Element type
+ * @param vals - Array of Maybes
+ * @returns Maybe<T>
+ */
+export declare const firstSome: <T>(vals: readonly Maybe<T>[]) => Maybe<T>;
+/**
+ * Reduces array of Maybes. Returns None if any is None.
+ * @typeparam T - Element type
+ * @typeparam R - Result type
+ * @param vals - Array of Maybes
+ * @param initial - Initial value
+ * @param reducer - Reduction function
+ * @returns Maybe<R>
+ */
+export declare function reduce<T, R>(vals: readonly Maybe<T>[], initial: R, reducer: (acc: R, v: T) => R): Maybe<R>;
+/**
+ * Performs scan reduction. Returns None if any is None.
+ * @typeparam T - Element type
+ * @typeparam R - Result type
+ * @param vals - Array of Maybes
+ * @param initial - Initial value
+ * @param scanner - Scanning function
+ * @returns Maybe<R[]>
+ */
+export declare function scan<T, R>(vals: readonly Maybe<T>[], initial: R, scanner: (acc: R, v: T) => R): Maybe<R[]>;
+/**
+ * Folds with separate handlers for Some/None.
+ * @typeparam T - Element type
+ * @typeparam R - Result type
+ * @param vals - Array of Maybes
+ * @param initial - Initial value
+ * @param onSome - Handler for Some values
+ * @param onNone - Handler for None values
+ * @returns R
+ */
+export declare const folds: <T, R>(vals: readonly Maybe<T>[], initial: R, onSome: (acc: R, v: T) => R, onNone: (acc: R) => R) => R;

package/dist/types/Maybe/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A nullable type that can be `T`, `null`, or `undefined`.
+ */
+export type Maybe<T> = T | null | undefined;
+/**
+ * A Promise that resolves to a {@link Maybe} value.
+ */
+export type AsyncMaybe<T> = Promise<Maybe<T>>;
+/**
+ * A union of all possible maybe-like types - synchronous, asynchronous, or Promise-like.
+ */
+export type AnyMaybe<T> = Maybe<T> | AsyncMaybe<T> | PromiseLike<Maybe<T>>;

package/dist/types/Maybe.d.ts

@@ -0,0 +1,2 @@
+export * from './Maybe/__export__'
+export {}