@duplojs/utils 1.0.5 → 1.0.7

package/dist/array/group.cjs

@@ -19,7 +19,7 @@ function group(...args) {
         return (array) => group(array, theFunction);
     }
     const [array, theFunction] = args;
-    return reduce.reduce(array, ({ from }) => from({}), ({ index, element, lastValue, nextWithObject }) => {
+    return reduce.reduce(array, reduce.reduceFrom({}), ({ index, element, lastValue, nextWithObject }) => {
         const { group, value } = theFunction(element, {
             index,
             output: groupOutput,

package/dist/array/group.mjs

@@ -1,4 +1,4 @@
-import { reduce } from './reduce.mjs';
+import { reduce, reduceFrom } from './reduce.mjs';
 
 function groupOutput(...args) {
     if (args.length === 1) {
@@ -17,7 +17,7 @@ function group(...args) {
         return (array) => group(array, theFunction);
     }
     const [array, theFunction] = args;
-    return reduce(array, ({ from }) => from({}), ({ index, element, lastValue, nextWithObject }) => {
+    return reduce(array, reduceFrom({}), ({ index, element, lastValue, nextWithObject }) => {
         const { group, value } = theFunction(element, {
             index,
             output: groupOutput,

package/dist/array/index.cjs

@@ -48,6 +48,7 @@ var _delete$1 = require('./findAndSplice/delete.cjs');
 var insert$1 = require('./findAndSplice/insert.cjs');
 var replace$1 = require('./findAndSplice/replace.cjs');
 var sum = require('./sum.cjs');
+var length = require('./length.cjs');
 
 
 
@@ -64,6 +65,7 @@ exports.minElements = minElements.minElements;
 exports.minOf = minOf.minOf;
 exports.push = push.push;
 exports.reduce = reduce.reduce;
+exports.reduceFrom = reduce.reduceFrom;
 exports.some = some.some;
 exports.sort = _default.sort;
 exports.sortNumber = number.sortNumber;
@@ -100,3 +102,4 @@ exports.findAndSpliceDelete = _delete$1.findAndSpliceDelete;
 exports.findAndSpliceInsert = insert$1.findAndSpliceInsert;
 exports.findAndSpliceReplace = replace$1.findAndSpliceReplace;
 exports.sum = sum.sum;
+exports.length = length.length;

package/dist/array/index.d.ts

@@ -38,3 +38,4 @@ export * from "./copyWithin";
 export * from "./findAndReplace";
 export * from "./findAndSplice";
 export * from "./sum";
+export * from "./length";

package/dist/array/index.mjs

@@ -9,7 +9,7 @@ export { maxOf } from './maxOf.mjs';
 export { minElements } from './minElements.mjs';
 export { minOf } from './minOf.mjs';
 export { push } from './push.mjs';
-export { reduce } from './reduce.mjs';
+export { reduce, reduceFrom } from './reduce.mjs';
 export { some } from './some.mjs';
 export { sort } from './sort/default.mjs';
 export { sortNumber } from './sort/number.mjs';
@@ -46,3 +46,4 @@ export { findAndSpliceDelete } from './findAndSplice/delete.mjs';
 export { findAndSpliceInsert } from './findAndSplice/insert.mjs';
 export { findAndSpliceReplace } from './findAndSplice/replace.mjs';
 export { sum } from './sum.mjs';
+export { length } from './length.mjs';

package/dist/array/length.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function length(input) {
+    return input.length;
+}
+
+exports.length = length;

package/dist/array/length.d.ts

@@ -0,0 +1 @@
+export declare function length<GenericInput extends readonly unknown[]>(input: GenericInput): GenericInput["length"];

package/dist/array/length.mjs

@@ -0,0 +1,5 @@
+function length(input) {
+    return input.length;
+}
+
+export { length };

package/dist/array/reduce.cjs

@@ -6,18 +6,16 @@ var unwrap = require('../common/unwrap.cjs');
 var override = require('../object/override.cjs');
 
 const arrayReduceFromKind = kind.createKind("array-reduce-from");
-const getStartValueParams = {
-    from: (value) => arrayReduceFromKind.addTo(wrapValue.wrapValue(value), null),
-};
+function reduceFrom(value) {
+    return arrayReduceFromKind.addTo(wrapValue.wrapValue(value));
+}
 function reduce(...args) {
     if (args.length === 2) {
-        const [getStartValue, theFunction] = args;
-        return (array) => reduce(array, getStartValue, theFunction);
+        const [fromValue, theFunction] = args;
+        return (array) => reduce(array, fromValue, theFunction);
     }
-    const [array, getStartValue, theFunction] = args;
-    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
-        ? getStartValue(getStartValueParams)
-        : getStartValue);
+    const [array, fromValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(fromValue);
     for (let index = 0; index < array.length; index++) {
         const element = array[index];
         const result = theFunction({
@@ -39,3 +37,4 @@ function reduce(...args) {
 }
 
 exports.reduce = reduce;
+exports.reduceFrom = reduceFrom;

package/dist/array/reduce.d.ts

@@ -8,7 +8,7 @@ interface ArrayReduceNext<GenericOutput extends unknown> {
 interface ArrayReduceExit<GenericOutput extends unknown> {
     "-exit": GenericOutput;
 }
-type ExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | ArrayReduceNext<GenericOutput>;
+export type ArrayReduceExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | ArrayReduceNext<GenericOutput>;
 export interface ArrayReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
     element: GenericElement;
     index: number;
@@ -20,11 +20,9 @@ export interface ArrayReduceFunctionParams<GenericElement extends unknown = unkn
 declare const arrayReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-from", unknown>>;
 export interface ArrayReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceFromKind.definition>, WrappedValue<GenericValue> {
 }
-interface GetStartValueParams {
-    from<GenericValue extends unknown>(value: GenericValue): ArrayReduceFromResult<GenericValue>;
-}
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): (array: readonly GenericElement[]) => ToLargeEnsemble<GenericReduceFrom>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): (array: readonly GenericElement[]) => Unwrap<GenericReduceFrom>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): ToLargeEnsemble<GenericReduceFrom>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceFromResult>(array: readonly GenericElement[], getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): Unwrap<GenericReduceFrom>;
+export declare function reduceFrom<GenericValue extends unknown>(value: GenericValue): ArrayReduceFromResult<GenericValue>;
+export type ArrayEligibleReduceFromValue = number | string | bigint | boolean | ArrayReduceFromResult;
+export type ArrayReduceFromValue<GenericValue extends ArrayEligibleReduceFromValue> = GenericValue extends ArrayReduceFromResult ? Unwrap<GenericValue> : ToLargeEnsemble<GenericValue>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayEligibleReduceFromValue>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): ArrayReduceFromValue<GenericReduceFrom>;
 export {};

package/dist/array/reduce.mjs

@@ -4,18 +4,16 @@ import { unwrap } from '../common/unwrap.mjs';
 import { override } from '../object/override.mjs';
 
 const arrayReduceFromKind = createKind("array-reduce-from");
-const getStartValueParams = {
-    from: (value) => arrayReduceFromKind.addTo(wrapValue(value), null),
-};
+function reduceFrom(value) {
+    return arrayReduceFromKind.addTo(wrapValue(value));
+}
 function reduce(...args) {
     if (args.length === 2) {
-        const [getStartValue, theFunction] = args;
-        return (array) => reduce(array, getStartValue, theFunction);
+        const [fromValue, theFunction] = args;
+        return (array) => reduce(array, fromValue, theFunction);
     }
-    const [array, getStartValue, theFunction] = args;
-    let lastValue = unwrap(typeof getStartValue === "function"
-        ? getStartValue(getStartValueParams)
-        : getStartValue);
+    const [array, fromValue, theFunction] = args;
+    let lastValue = unwrap(fromValue);
     for (let index = 0; index < array.length; index++) {
         const element = array[index];
         const result = theFunction({
@@ -36,4 +34,4 @@ function reduce(...args) {
     return lastValue;
 }
 
-export { reduce };
+export { reduce, reduceFrom };

package/dist/array/reduceRight.cjs

@@ -1,23 +1,15 @@
 'use strict';
 
-var kind = require('../common/kind.cjs');
-var wrapValue = require('../common/wrapValue.cjs');
 var unwrap = require('../common/unwrap.cjs');
 var override = require('../object/override.cjs');
 
-const arrayReduceRightFromKind = kind.createKind("array-reduce-right-from");
-const getStartValueParams = {
-    from: (value) => arrayReduceRightFromKind.addTo(wrapValue.wrapValue(value), null),
-};
 function reduceRight(...args) {
     if (args.length === 2) {
-        const [getStartValue, theFunction] = args;
-        return (array) => reduceRight(array, getStartValue, theFunction);
+        const [fromValue, theFunction] = args;
+        return (array) => reduceRight(array, fromValue, theFunction);
     }
-    const [array, getStartValue, theFunction] = args;
-    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
-        ? getStartValue(getStartValueParams)
-        : getStartValue);
+    const [array, fromValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(fromValue);
     for (let index = array.length - 1; index >= 0; index--) {
         const element = array[index];
         const result = theFunction({

package/dist/array/reduceRight.d.ts

@@ -1,30 +1,3 @@
-import { type Kind } from "../common/kind";
-import { type WrappedValue } from "../common/wrapValue";
-import { type Unwrap } from "../common/unwrap";
-import { type ToLargeEnsemble } from "../common";
-interface ArrayReduceRightNext<GenericOutput extends unknown> {
-    "-next": GenericOutput;
-}
-interface ArrayReduceRightExit<GenericOutput extends unknown> {
-    "-exit": GenericOutput;
-}
-type ExitOrNextRight<GenericOutput extends unknown = unknown> = ArrayReduceRightExit<GenericOutput> | ArrayReduceRightNext<GenericOutput>;
-export interface ArrayReduceRightFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
-    element: GenericElement;
-    index: number;
-    lastValue: GenericOutput;
-    nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => ArrayReduceRightNext<GenericOutput> : undefined;
-    next(output: GenericOutput): ArrayReduceRightNext<GenericOutput>;
-    exit(output: GenericOutput): ArrayReduceRightExit<GenericOutput>;
-}
-declare const arrayReduceRightFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-right-from", unknown>>;
-export interface ArrayReduceRightFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceRightFromKind.definition>, WrappedValue<GenericValue> {
-}
-interface GetStartValueParams {
-    from<GenericValue extends unknown>(value: GenericValue): ArrayReduceRightFromResult<GenericValue>;
-}
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNextRight<ToLargeEnsemble<GenericReduceFrom>>): (array: readonly GenericElement[]) => ToLargeEnsemble<GenericReduceFrom>;
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceRightFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNextRight<Unwrap<GenericReduceFrom>>): (array: readonly GenericElement[]) => Unwrap<GenericReduceFrom>;
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNextRight<ToLargeEnsemble<GenericReduceFrom>>): ToLargeEnsemble<GenericReduceFrom>;
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceRightFromResult>(array: readonly GenericElement[], getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNextRight<Unwrap<GenericReduceFrom>>): Unwrap<GenericReduceFrom>;
-export {};
+import { type ArrayReduceFunctionParams, type ArrayReduceFromResult, type ArrayReduceExitOrNext, type ArrayReduceFromValue } from "./reduce";
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom>;
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): ArrayReduceFromValue<GenericReduceFrom>;

package/dist/array/reduceRight.mjs

@@ -1,21 +1,13 @@
-import { createKind } from '../common/kind.mjs';
-import { wrapValue } from '../common/wrapValue.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 import { override } from '../object/override.mjs';
 
-const arrayReduceRightFromKind = createKind("array-reduce-right-from");
-const getStartValueParams = {
-    from: (value) => arrayReduceRightFromKind.addTo(wrapValue(value), null),
-};
 function reduceRight(...args) {
     if (args.length === 2) {
-        const [getStartValue, theFunction] = args;
-        return (array) => reduceRight(array, getStartValue, theFunction);
+        const [fromValue, theFunction] = args;
+        return (array) => reduceRight(array, fromValue, theFunction);
     }
-    const [array, getStartValue, theFunction] = args;
-    let lastValue = unwrap(typeof getStartValue === "function"
-        ? getStartValue(getStartValueParams)
-        : getStartValue);
+    const [array, fromValue, theFunction] = args;
+    let lastValue = unwrap(fromValue);
     for (let index = array.length - 1; index >= 0; index--) {
         const element = array[index];
         const result = theFunction({

package/dist/array/types/index.d.ts

@@ -6,3 +6,4 @@ export * from "./tupleHasSpread";
 export * from "./mergeUnionTuple";
 export * from "./extractTuple";
 export * from "./excludeTuple";
+export * from "./createTuple";

package/dist/common/and.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function and(...args) {
+    if (args.length === 1) {
+        const [predicatedList] = args;
+        return (input) => and(input, predicatedList);
+    }
+    const [input, predicatedList] = args;
+    for (const predicate of predicatedList) {
+        if (!predicate(input)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.and = and;

package/dist/common/and.mjs

@@ -0,0 +1,15 @@
+function and(...args) {
+    if (args.length === 1) {
+        const [predicatedList] = args;
+        return (input) => and(input, predicatedList);
+    }
+    const [input, predicatedList] = args;
+    for (const predicate of predicatedList) {
+        if (!predicate(input)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { and };

package/dist/common/index.d.ts

@@ -30,3 +30,7 @@ export * from "./whenNot";
 export * from "./equal";
 export * from "./not";
 export * from "./isType";
+export * from "./and";
+export * from "./or";
+export * from "./whenElse";
+export * from "./justReturn";

package/dist/common/justReturn.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+exports.justReturn = justReturn;

package/dist/common/justReturn.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "./types";
+export declare function justReturn<GenericValue extends AnyValue>(value: GenericValue): (input: unknown) => GenericValue;
+export declare function justReturn<GenericValue extends AnyValue>(input: unknown, value: GenericValue): GenericValue;

package/dist/common/justReturn.mjs

@@ -0,0 +1,10 @@
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+export { justReturn };

package/dist/common/kind.d.ts

@@ -1,4 +1,4 @@
-import { type Or, type IsEqual } from "./types";
+import { type Or, type IsEqual, type BreakGenericLink } from "./types";
 export interface KindHandler<GenericKindDefinition extends KindDefinition> {
     definition: GenericKindDefinition;
     runTimeKey: string;
@@ -7,7 +7,7 @@ export interface KindHandler<GenericKindDefinition extends KindDefinition> {
         IsEqual<GenericValue, never>,
         IsEqual<GenericValue, unknown>,
         IsEqual<GenericValue, any>
-    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & GenericInput;
+    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
     getValue<GenericKind extends Kind<GenericKindDefinition, GenericKindDefinition["value"]>>(input: GenericKind): GenericKind[SymbolKind][GenericKindDefinition["name"]];
 }
 export interface KindDefinition<GenericName extends string = string, GenericValue extends unknown = unknown> {

package/dist/common/or.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function or(...args) {
+    if (args.length === 1) {
+        const [predicatedList] = args;
+        return (input) => or(input, predicatedList);
+    }
+    const [input, predicatedList] = args;
+    for (const predicate of predicatedList) {
+        if (predicate(input)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+exports.or = or;

package/dist/common/or.mjs

@@ -0,0 +1,15 @@
+function or(...args) {
+    if (args.length === 1) {
+        const [predicatedList] = args;
+        return (input) => or(input, predicatedList);
+    }
+    const [input, predicatedList] = args;
+    for (const predicate of predicatedList) {
+        if (predicate(input)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { or };

package/dist/common/when.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/common/whenElse.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+exports.whenElse = whenElse;

package/dist/common/whenElse.d.ts

@@ -0,0 +1,5 @@
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): (input: GenericInput) => BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): (input: GenericInput) => GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;

package/dist/common/whenElse.mjs

@@ -0,0 +1,15 @@
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+export { whenElse };

package/dist/common/whenNot.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | GenericPredicatedInput;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | BreakGenericLink<GenericPredicatedInput>;
 export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): GenericOutput | GenericPredicatedInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/either/bool/create.d.ts

@@ -2,3 +2,4 @@ import { type IsEqual } from "../../common";
 import { type BoolFalsyValue, type EitherBoolFalsy } from "./falsy";
 import { type EitherBoolTruthy } from "./truthy";
 export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends BoolFalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;
+export type Bool<GenericValue extends unknown> = EitherBoolTruthy<GenericValue> | EitherBoolFalsy;

package/dist/either/bool/falsy.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { bool } from "./create";
@@ -13,6 +13,6 @@ export declare function boolFalsy<const GenericValue extends BoolFalsyValue = un
 type Either = EitherRight | EitherLeft;
 export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
 export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
 export {};

package/dist/either/bool/truthy.d.ts

@@ -2,7 +2,7 @@ import { type EitherRight } from "../right";
 import { bool } from "./create";
 import { type EitherLeft } from "../left";
 import { type Kind } from "../../common/kind";
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { eitherBoolKind } from "./base";
 export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-truthy", unknown>>;
 type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
@@ -12,6 +12,6 @@ export declare function boolTruthy<const GenericValue extends unknown>(value: Ge
 type Either = EitherRight | EitherLeft;
 export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
 export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
 export {};

package/dist/either/future/create.d.ts

@@ -21,5 +21,5 @@ export declare class Future<const GenericValue extends unknown = unknown> extend
     static instanceof<GenericValue extends unknown>(value: GenericValue): value is Extract<GenericValue, Future<any>>;
     static all<const GenericValue extends unknown, GenericArray extends readonly GenericValue[] | []>(values: GenericArray): FutureEitherAllResult<GenericArray>;
 }
-export declare function future<const GenericEither extends unknown>(value: GenericEither): Future<GenericEither>;
+export declare function future<GenericEither extends AnyValue>(value: GenericEither): Future<GenericEither>;
 export {};

package/dist/either/left/when.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "./create";
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherLeft> | GenericOutput;
 export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;

package/dist/either/nullable/create.d.ts

@@ -1,3 +1,4 @@
 import { type EitherNullableEmpty } from "./empty";
 import { type EitherNullableFilled } from "./filled";
 export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? EitherNullableEmpty : EitherNullableFilled<GenericValue>;
+export type Nullable<GenericValue extends unknown> = EitherNullableFilled<GenericValue> | EitherNullableEmpty;

package/dist/either/nullable/empty.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
@@ -13,5 +13,5 @@ export declare function nullableEmpty(): EitherNullableEmpty;
 export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
 export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
-export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
 export {};

package/dist/either/nullable/filled.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullableFilled<GenericValue>;
 export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>;
 export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
 export {};

package/dist/either/nullish/create.d.ts

@@ -1,3 +1,4 @@
 import { type EitherNullishEmpty, type NullishValue } from "./empty";
 import { type EitherNullishFilled } from "./filled";
 export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? EitherNullishEmpty<GenericValue> : EitherNullishFilled<GenericValue>;
+export type Nullish<GenericValue extends unknown> = EitherNullishFilled<GenericValue> | EitherNullishEmpty;

package/dist/either/nullish/empty.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullish } from "./create";
@@ -13,6 +13,6 @@ export declare function nullishEmpty<const GenericValue extends NullishValue = u
 type Either = EitherRight | EitherLeft;
 export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>;
 export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
 export {};