fnts 1.0.2 → 1.3.0

package/cjs/maybe/operators/fmap.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var compose_1 = require("../../compose");
+var identity_1 = require("../../identity");
+var maybe_1 = require("../maybe");
+var permutation_2_1 = require("../../permutation/permutation-2");
+var fold_1 = require("./fold");
+var guards_1 = require("./guards");
+var ternary_1 = require("../../ternary");
+function fmap() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return permutation_2_1.default(function (monad, transition) {
+        return ternary_1.default(guards_1.isJust, compose_1.default(maybe_1.default, transition, fold_1.default), identity_1.default)(monad);
+    }).apply(void 0, args);
+}
+exports.default = fmap;

package/cjs/maybe/operators/fold-map.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var compose_1 = require("../../compose");
+var ternary_1 = require("../../ternary");
+var permutation_2_1 = require("../../permutation/permutation-2");
+var fold_1 = require("./fold");
+var guards_1 = require("./guards");
+function foldMap() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return permutation_2_1.default(function (monad, transition) {
+        return ternary_1.default(guards_1.isJust, compose_1.default(transition, fold_1.default), function () { return null; })(monad);
+    }).apply(void 0, args);
+}
+exports.default = foldMap;

package/cjs/maybe/operators/fold.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var just_1 = require("../just");
+var nothing_1 = require("../nothing");
+var guards_1 = require("./guards");
+/**
+ * Returns the value of the provided `monad`.
+ */
+function fold(monad) {
+    return guards_1.isJust(monad)
+        ? monad[just_1.jid]
+        : monad[nothing_1.nid];
+}
+exports.default = fold;

package/cjs/maybe/operators/guards.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @module Maybe Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNothing = exports.isJust = void 0;
+var just_1 = require("../just");
+var nothing_1 = require("../nothing");
+/**
+ * Type guard function to tell if the provided `monad` is `Just`.
+ */
+function isJust(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, just_1.jid);
+}
+exports.isJust = isJust;
+/**
+ * Type guard function to tell if the provided `monad` is `Nothing`.
+ */
+function isNothing(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, nothing_1.nid);
+}
+exports.isNothing = isNothing;

package/cjs/maybe/operators/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldMap = exports.isNothing = exports.isJust = exports.fold = exports.bind = exports.fmap = void 0;
+var fmap_1 = require("./fmap");
+Object.defineProperty(exports, "fmap", { enumerable: true, get: function () { return fmap_1.default; } });
+var bind_1 = require("./bind");
+Object.defineProperty(exports, "bind", { enumerable: true, get: function () { return bind_1.default; } });
+var fold_1 = require("./fold");
+Object.defineProperty(exports, "fold", { enumerable: true, get: function () { return fold_1.default; } });
+var guards_1 = require("./guards");
+Object.defineProperty(exports, "isJust", { enumerable: true, get: function () { return guards_1.isJust; } });
+Object.defineProperty(exports, "isNothing", { enumerable: true, get: function () { return guards_1.isNothing; } });
+var fold_map_1 = require("./fold-map");
+Object.defineProperty(exports, "foldMap", { enumerable: true, get: function () { return fold_map_1.default; } });

package/cjs/permutation/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permutation3 = exports.permutation2 = void 0;
+var permutation_2_1 = require("./permutation-2");
+Object.defineProperty(exports, "permutation2", { enumerable: true, get: function () { return permutation_2_1.default; } });
+var permutation_3_1 = require("./permutation-3");
+Object.defineProperty(exports, "permutation3", { enumerable: true, get: function () { return permutation_3_1.default; } });

package/cjs/permutation/permutation-2.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @module Permutation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function permutation2(fn, shouldCurry) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var a1 = args[0], b = args[1];
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b)) || args.length < fn.length
+            ? function (a2) { return fn(a2, a1); }
+            : fn(a1, b);
+    };
+}
+exports.default = permutation2;

package/cjs/permutation/permutation-3.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @module Permutation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function permutation3(fn, shouldCurry) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var a1 = args[0], b = args[1], c = args[2];
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b, c)) || args.length < fn.length
+            ? function (a2) { return fn(a2, a1, b); }
+            : fn(a1, b, c);
+    };
+}
+exports.default = permutation3;

package/cjs/pipe.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @module Composition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Applies all of the provided `functions` one-by-one in left-to-right order
+ * starting from the `argument`.
+ */
+function pipe() {
+    var functions = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        functions[_i] = arguments[_i];
+    }
+    return function (arg) {
+        var length = functions.length;
+        var pipeline = arg;
+        for (var index = 0; index < length; index += 1) {
+            var current = functions[index];
+            pipeline = current(pipeline);
+        }
+        return pipeline;
+    };
+}
+exports.default = pipe;

package/cjs/rethrow.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @module Side Effects
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var inject_1 = require("./inject");
+/**
+ * Rethrows a received error
+ * performing an optional side effect.
+ */
+function rethrow(effect) {
+    return inject_1.default(function (error) {
+        throw error;
+    }, effect);
+}
+exports.default = rethrow;

package/cjs/tap.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @module Side Effects
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var inject_1 = require("./inject");
+var identity_1 = require("./identity");
+/**
+ * Performs a side effect
+ * passing the received argument through itself.
+ */
+function tap(effect) {
+    return inject_1.default(identity_1.default, effect);
+}
+exports.default = tap;

package/cjs/ternary.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @module Ternary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Functional alternative to the ternary operator.
+ * Enforces the same return type for both branches,
+ * the result is evaluated lazily.
+ */
+function ternary(predicate, left, right) {
+    return function (value) {
+        return predicate(value) ? left(value) : right(value);
+    };
+}
+exports.default = ternary;

package/compose.d.ts

@@ -1,4 +1,7 @@
-import type { Last } from './.internal/last';
+/**
+ * @module Composition
+ */
+import type { Last } from './types/last';
 /**
  * Creates a `Composition` type which parses all of the provided functions' types.
  * Any function with either an incorrect argument or a return type will not fit
@@ -17,5 +20,4 @@ export declare type Composition<Functions extends Array<(...args: any[]) => any>
  * Applies all of the provided `functions` one-by-one in right-to-left order
  * starting from the `argument`.
  */
-export declare const compose: <Functions extends ((arg: any) => any)[]>(...functions: Composition<Functions, Functions["length"]>) => (arg: Parameters<Last<Functions>>[0]) => ReturnType<Functions[0]>;
-export default compose;
+export default function compose<Functions extends Array<(arg: any) => any>>(...functions: Composition<Functions>): (arg: Parameters<Last<Functions>>[0]) => ReturnType<Functions[0]>;

package/curry.d.ts

@@ -1,5 +1,8 @@
-import type { Slice } from './.internal/slice';
-import type { Gradual } from './.internal/gradual';
+/**
+ * @module Curry
+ */
+import type { Slice } from './types/slice';
+import type { Gradual } from './types/gradual';
 /**
  * Creates a type for an auto-curried function.
  */
@@ -12,5 +15,4 @@ export declare type Currying<Function extends (...args: any[]) => any, Length ex
  * of arguments.
  * Any excess arguments will not be applied.
  */
-export declare const curry: <Function_1 extends (...args: any[]) => any, Length extends number = Parameters<Function_1>["length"]>(fn: Function_1, length?: Length) => Currying<Function_1, Length>;
-export default curry;
+export default function curry<Function extends (...args: any[]) => any, Length extends number = Parameters<Function>['length']>(fn: Function, length?: Length): Currying<Function, Length>;

package/either/either-sync.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Either
+ */
+import type { Either } from './either';
+/**
+ * Type constructor for `Either`.
+ * Creates either `Right` of the value provided,
+ * or `Left` of the thrown error.
+ */
+export default function eitherSync<LeftValue, RightValue>(value: () => RightValue): Either<LeftValue, RightValue>;

package/either/either.d.ts

@@ -1,49 +1,17 @@
 /**
- * Internal unique identifier for `Left`.
+ * @module Either
  */
-export declare const lid: unique symbol;
-/**
- * Type constructor for `Left`.
- * Describes the special object with one property, represented as unique symbol
- * key, holding the provided value type.
- */
-export declare type Left<Value> = {
-    [lid]: Value;
-};
-/**
- * Constructor function for `Left`.
- * Creates the special object with one property, represented as unique symbol
- * key, holding the provided value.
- */
-export declare const left: <Value>(value: Value) => Left<Value>;
-/**
- * Internal unique identifier for `Right`.
- */
-export declare const rid: unique symbol;
-/**
- * Type constructor for `Right`.
- * Describes the special object with one property, represented as unique symbol
- * key, holding the provided value type.
- */
-export declare type Right<Value> = {
-    [rid]: Value;
-};
-/**
- * Constructor function for `Right`.
- * Creates the special object with one property, represented as unique symbol
- * key, holding the provided value.
- */
-export declare const right: <Value>(value: Value) => Right<Value>;
+import { Left } from './left';
+import { Right } from './right';
 /**
  * Type constructor for `Either`.
- * This can be either `Right` of the resolved promise provided,
- * or `Left` of the rejected one.
+ * Can be either `Right` of the value provided,
+ * or `Left` of the error thrown.
  */
 export declare type Either<LeftValue, RightValue> = Left<LeftValue> | Right<RightValue>;
 /**
  * Type constructor for `Either`.
- * This creates either `Right` of the resolved promise provided,
- * or `Left` of the rejected one.
+ * Creates either `Right` of the value provided,
+ * or `Left` of the error thrown.
  */
-export declare const either: <LeftValue, RightValue>(value: () => Promise<RightValue>) => Promise<Either<LeftValue, RightValue>>;
-export default either;
+export default function either<LeftValue, RightValue>(value: () => Promise<RightValue>): Promise<Either<LeftValue, RightValue>>;

package/either/index.d.ts

@@ -1 +1,4 @@
-export { default, left, Left, right, Right, either, Either } from './either';
+export { default, Either } from './either';
+export { default as left, Left } from './left';
+export { default as right, Right } from './right';
+export { default as eitherSync } from './either-sync';

package/either/left.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Either
+ */
+/**
+ * Internal unique identifier for `Left`.
+ */
+export declare const lid: unique symbol;
+/**
+ * Type constructor for `Left`.
+ * Describes the special object with one property, represented as unique symbol
+ * key, holding the provided value type.
+ */
+export declare type Left<Value> = {
+    [lid]: Value;
+};
+/**
+ * Constructor function for `Left`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the provided value.
+ */
+export default function left<Value>(value: Value): Left<Value>;

package/either/operators/bifold/bifold.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import type { Left } from '../../left';
+import type { Right } from '../../right';
+import type { Either } from '../../either';
+/**
+ * A type to unwrap either the left or the right value type
+ * of the provided `Monad`.
+ */
+export declare type Bifold<Monad extends Either<any, any>> = Monad extends Left<infer LeftValue> ? LeftValue : Monad extends Right<infer RightValue> ? RightValue : never;
+/**
+ * Unwraps either the left or the right value of the provided `monad`.
+ */
+export default function bifold<Monad extends Either<any, any>>(monad: Monad): Bifold<Monad>;

package/either/operators/bifold/bifoldl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import { Left } from '../../left';
+import type { Either } from '../../either';
+/**
+ * A type to unwrap the left value type of the provided `Monad`.
+ * If the `Monad` is `Right`, returns `undefined`.
+ */
+export declare type Bifoldl<Monad extends Either<any, any>> = Monad extends Left<infer LeftValue> ? LeftValue : undefined;
+/**
+ * Returns the left value of the provided `monad`.
+ * If the `monad` is `Right`, returns `undefined`.
+ */
+export default function bifoldl<Monad extends Either<any, any>>(monad: Monad): Bifoldl<Monad>;

package/either/operators/bifold/bifoldr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import { Right } from '../../right';
+import type { Either } from '../../either';
+/**
+ * A type to unwrap the right value type of the provided `Monad`.
+ * If the `Monad` is `Left`, returns `undefined`.
+ */
+export declare type Bifoldr<Monad extends Either<any, any>> = Monad extends Right<infer RightValue> ? RightValue : undefined;
+/**
+ * Returns the right value of the provided `monad`.
+ * If the `monad` is `Left`, returns `undefined`.
+ */
+export default function bifoldr<Monad extends Either<any, any>>(monad: Monad): Bifoldr<Monad>;

package/either/operators/bifold/index.d.ts

@@ -0,0 +1,3 @@
+export { default, Bifold } from './bifold';
+export { default as bifoldl, Bifoldl } from './bifoldl';
+export { default as bifoldr, Bifoldr } from './bifoldr';

package/either/operators/bifold-map.d.ts

@@ -1,12 +1,15 @@
+/**
+ * @module Either Operators
+ */
 import type { Either } from '../either';
-import type { Map } from '../../.internal/map';
-interface BifoldMap {
-    <LeftValue, RightValue, MappedValue>(mapLeft: Map<LeftValue, MappedValue>, mapRight: Map<RightValue, MappedValue>): (monad: Either<LeftValue, RightValue>) => MappedValue;
-    <LeftValue, RightValue, MappedValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, MappedValue>, mapRight: Map<RightValue, MappedValue>): MappedValue;
-}
+import type { Map } from '../../types/map';
+/**
+ * Maps left and right values of the provided `monad` to a value,
+ * then returns it.
+ */
+export default function bifoldMap<LeftValue, RightValue, MappedValue>(mapLeft: Map<LeftValue, MappedValue>, mapRight: Map<RightValue, MappedValue>): (monad: Either<LeftValue, RightValue>) => MappedValue;
 /**
  * Maps left and right values of the provided `monad` to a value,
  * then returns it.
  */
-export declare const bifoldMap: BifoldMap;
-export default bifoldMap;
+export default function bifoldMap<LeftValue, RightValue, MappedValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, MappedValue>, mapRight: Map<RightValue, MappedValue>): MappedValue;

package/either/operators/bimap/bimap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Either Operators
+ */
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+/**
+ * Maps left and right values of the provided `monad` to a new `Either` monad.
+ */
+export default function bimap<LeftValue, RightValue, NextLeftValue, NextRightValue>(mapLeft: Map<LeftValue, NextLeftValue>, mapRight: Map<RightValue, NextRightValue>): (monad: Either<LeftValue, RightValue>) => Either<NextLeftValue, NextRightValue>;
+/**
+ * Maps left and right values of the provided `monad` to a new `Either` monad.
+ */
+export default function bimap<LeftValue, RightValue, NextLeftValue, NextRightValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, NextLeftValue>, mapRight: Map<RightValue, NextRightValue>): Either<NextLeftValue, NextRightValue>;

package/either/operators/bimap/first.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+/**
+ * Maps the left value of the provided `monad` to a new `Either` monad
+ * with the same right value.
+ */
+export default function first<LeftValue, RightValue, NextLeftValue>(mapLeft: Map<LeftValue, NextLeftValue>): (monad: Either<LeftValue, RightValue>) => Either<NextLeftValue, RightValue>;
+/**
+ * Maps the left value of the provided `monad` to a new `Either` monad
+ * with the same right value.
+ */
+export default function first<LeftValue, RightValue, NextLeftValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, NextLeftValue>): Either<NextLeftValue, RightValue>;

package/either/operators/bimap/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './bimap';
+export { default as first } from './first';
+export { default as second } from './second';

package/either/operators/bimap/second.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+/**
+ * Maps the right value of the provided `monad` to a new `Either` monad
+ * with the same left value.
+ */
+export default function second<LeftValue, RightValue, NextRightValue>(mapRight: Map<RightValue, NextRightValue>): (monad: Either<LeftValue, RightValue>) => Either<LeftValue, NextRightValue>;
+/**
+ * Maps the right value of the provided `monad` to a new `Either` monad
+ * with the same left value.
+ */
+export default function second<LeftValue, RightValue, NextRightValue>(monad: Either<LeftValue, RightValue>, mapRight: Map<RightValue, NextRightValue>): Either<LeftValue, NextRightValue>;

package/either/operators/guards.d.ts

@@ -1,9 +1,14 @@
-import { Either, Left, Right } from '../either';
+/**
+ * @module Either Operators
+ */
+import { Left } from '../left';
+import { Right } from '../right';
+import type { Either } from '../either';
 /**
  * Type guard function to tell if the provided `monad` is `Left`.
  */
-export declare const isLeft: <LeftValue>(monad: Either<LeftValue, any>) => monad is Left<LeftValue>;
+export declare function isLeft<LeftValue>(monad: Either<LeftValue, any>): monad is Left<LeftValue>;
 /**
  * Type guard function to tell if the provided `monad` is `Right`.
  */
-export declare const isRight: <RightValue>(monad: Either<any, RightValue>) => monad is Right<RightValue>;
+export declare function isRight<RightValue>(monad: Either<any, RightValue>): monad is Right<RightValue>;

package/either/operators/index.d.ts

@@ -1,4 +1,4 @@
-export * from './bimap';
-export * from './bifold';
+export { bifoldl, Bifoldl, bifoldr, Bifoldr, default as bifold, Bifold, } from './bifold';
 export * from './guards';
-export * from './bifold-map';
+export { default as bifoldMap } from './bifold-map';
+export { default as bimap, first, second } from './bimap';

package/either/right.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Either
+ */
+/**
+ * Internal unique identifier for `Right`.
+ */
+export declare const rid: unique symbol;
+/**
+ * Type constructor for `Right`.
+ * Describes the special object with one property, represented as unique symbol
+ * key, holding the provided value type.
+ */
+export declare type Right<Value> = {
+    [rid]: Value;
+};
+/**
+ * Constructor function for `Right`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the provided value.
+ */
+export default function right<Value>(value: Value): Right<Value>;

package/esm/compose.js

@@ -0,0 +1,18 @@
+/**
+ * @module Composition
+ */
+/**
+ * Applies all of the provided `functions` one-by-one in right-to-left order
+ * starting from the `argument`.
+ */
+export default function compose(...functions) {
+    return (arg) => {
+        const length = functions.length;
+        let composition = arg;
+        for (let index = length - 1; index >= 0; index -= 1) {
+            const current = functions[index];
+            composition = current(composition);
+        }
+        return composition;
+    };
+}

package/esm/curry.js

@@ -0,0 +1,23 @@
+/**
+ * @module Curry
+ */
+/**
+ * Creates an auto-curried function from the one provided.
+ * Until the curried function receives an expected number of arguments,
+ * defined by either its `length` property or the `length` argument of `curry`,
+ * it will return new function which receives from one to the remaining amount
+ * of arguments.
+ * Any excess arguments will not be applied.
+ */
+export default function curry(fn, length = fn.length) {
+    return (...args) => {
+        const argsLength = args.length;
+        if (argsLength === length) {
+            return fn(...args);
+        }
+        if (argsLength > length) {
+            return fn(...args.slice(0, length));
+        }
+        return curry((...nextArgs) => fn(...args.concat(nextArgs)), length - argsLength);
+    };
+}

package/esm/either/either-sync.js

@@ -0,0 +1,18 @@
+/**
+ * @module Either
+ */
+import left from './left';
+import right from './right';
+/**
+ * Type constructor for `Either`.
+ * Creates either `Right` of the value provided,
+ * or `Left` of the thrown error.
+ */
+export default function eitherSync(value) {
+    try {
+        return right(value());
+    }
+    catch (error) {
+        return left(error);
+    }
+}

package/esm/either/either.js

@@ -0,0 +1,15 @@
+/**
+ * @module Either
+ */
+import left from './left';
+import right from './right';
+/**
+ * Type constructor for `Either`.
+ * Creates either `Right` of the value provided,
+ * or `Left` of the error thrown.
+ */
+export default function either(value) {
+    return value()
+        .then(right)
+        .catch(left);
+}

package/esm/either/index.js

@@ -0,0 +1,4 @@
+export { default } from './either';
+export { default as left } from './left';
+export { default as right } from './right';
+export { default as eitherSync } from './either-sync';

package/esm/either/left.js

@@ -0,0 +1,17 @@
+/**
+ * @module Either
+ */
+/**
+ * Internal unique identifier for `Left`.
+ */
+export const lid = Symbol.for('@@functional/left');
+/**
+ * Constructor function for `Left`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the provided value.
+ */
+export default function left(value) {
+    return {
+        [lid]: value
+    };
+}