fnts 1.8.0 → 2.0.0-rc.1

package/compose.d.ts

@@ -1,20 +1,11 @@
 /**
  * @module Composition
  */
-import type { Last } from './types/last';
-import type { UnaryFunction, VariadicFunction } from './types/function';
 /**
- * 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
- * into the composition and should be typed according to it, so that its argument's
- * type matches the return type of the next function and its return type
- * matches the type of the previous function's argument.
+ * Applies first onto second onto args.
  */
-export declare type Composition<Functions extends [...UnaryFunction[], VariadicFunction], Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [...infer Rest, infer Penultimate, infer Last] ? [
-    ...Composition<Rest extends UnaryFunction[] ? Last extends UnaryFunction ? Penultimate extends UnaryFunction ? [...Rest, (arg: ReturnType<Last>) => ReturnType<Penultimate>] : never : Last extends VariadicFunction ? Penultimate extends UnaryFunction ? [...Rest, (arg: ReturnType<Last>) => ReturnType<Penultimate>] : never : never : never>,
-    Last
-] : Functions;
+export default function compose<First, Argument, Return>(first: (arg: First) => Return, second: (arg: Argument) => First): (arg: Argument) => Return;
 /**
- * Applies all of the provided `functions` one-by-one in right-to-left order.
+ * Applies first onto second onto args.
  */
-export default function compose<Functions extends [...UnaryFunction[], VariadicFunction]>(...functions: Composition<Functions>): (...args: Parameters<Last<Functions>>) => ReturnType<Functions[0]>;
+export default function compose<First, Arguments extends any[], Return>(first: (arg: First) => Return, second: (...args: Arguments) => First): (...args: Arguments) => Return;

package/compose.js

@@ -4,26 +4,15 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Applies all of the provided `functions` one-by-one in right-to-left order.
+ * Applies first onto second onto args.
  */
-function compose() {
-    var functions = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        functions[_i] = arguments[_i];
-    }
+function compose(first, second) {
     return function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var length = functions.length;
-        var composition = functions[length - 1].apply(functions, args);
-        if (length > 1) {
-            for (var index = length - 2; index >= 0; index -= 1) {
-                composition = functions[index](composition);
-            }
-        }
-        return composition;
+        return first(second.apply(void 0, args));
     };
 }
 exports.default = compose;

package/either/left.d.ts

@@ -18,4 +18,4 @@ export declare type Left<Value> = {
  * 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>;
+export default function left<Value = undefined>(value?: Value): Left<Value>;

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

@@ -1,15 +1,15 @@
 /**
  * @module Either Operators
  */
-import type { Left } from '../../left';
-import type { Right } from '../../right';
+import { Left } from '../../left';
+import { 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;
+export declare type Bifold<Monad extends Either<any, any>> = Monad extends Left<infer LeftValue> ? LeftValue : Monad extends Right<infer RightValue> ? RightValue : Monad extends Either<infer LeftValue, infer RightValue> ? LeftValue | 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>;
+export default function bifold<LeftValue, RightValue>(monad: Either<LeftValue, RightValue>): LeftValue | RightValue;

package/either/operators/bifold/bifold.js

@@ -3,13 +3,15 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var bifoldl_1 = require("./bifoldl");
-var bifoldr_1 = require("./bifoldr");
+var guards_1 = require("../guards");
+var left_1 = require("../../left");
+var right_1 = require("../../right");
 /**
  * Unwraps either the left or the right value of the provided `monad`.
  */
 function bifold(monad) {
-    var _a;
-    return (_a = (0, bifoldl_1.default)(monad)) !== null && _a !== void 0 ? _a : (0, bifoldr_1.default)(monad);
+    return (0, guards_1.isLeft)(monad)
+        ? monad[left_1.lid]
+        : monad[right_1.rid];
 }
 exports.default = bifold;

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

@@ -7,9 +7,9 @@ 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;
+export declare type Bifoldl<Monad extends Either<any, any>> = Monad extends Left<infer LeftValue> ? LeftValue : Monad extends Either<infer LeftValue, any> ? LeftValue | undefined : never;
 /**
  * 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>;
+export default function bifoldl<LeftValue>(monad: Either<LeftValue, any>): LeftValue | undefined;

package/either/operators/bifold/bifoldl.js

@@ -10,8 +10,8 @@ var left_1 = require("../../left");
  * If the `monad` is `Right`, returns `undefined`.
  */
 function bifoldl(monad) {
-    return ((0, guards_1.isLeft)(monad)
+    return (0, guards_1.isLeft)(monad)
         ? monad[left_1.lid]
-        : undefined);
+        : undefined;
 }
 exports.default = bifoldl;

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

@@ -7,9 +7,9 @@ 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;
+export declare type Bifoldr<Monad extends Either<any, any>> = Monad extends Right<infer RightValue> ? RightValue : Monad extends Either<any, infer RightValue> ? RightValue | undefined : never;
 /**
  * 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>;
+export default function bifoldr<RightValue>(monad: Either<any, RightValue>): RightValue | undefined;

package/either/operators/bifold/bifoldr.js

@@ -10,8 +10,8 @@ var right_1 = require("../../right");
  * If the `monad` is `Left`, returns `undefined`.
  */
 function bifoldr(monad) {
-    return ((0, guards_1.isRight)(monad)
+    return (0, guards_1.isRight)(monad)
         ? monad[right_1.rid]
-        : undefined);
+        : undefined;
 }
 exports.default = bifoldr;

package/either/operators/{bifold-map.d.ts → bifold-map/bifold-map.d.ts}

@@ -1,8 +1,8 @@
 /**
  * @module Either Operators
  */
-import type { Either } from '../either';
-import type { Map } from '../../types/map';
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
 /**
  * Maps provided `monad` to a value,
  * then returns it.

package/either/operators/{bifold-map.js → bifold-map/bifold-map.js}

@@ -3,11 +3,13 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var compose_1 = require("../../compose");
-var ternary_1 = require("../../ternary");
-var permutation_3_1 = require("../../permutation/permutation-3");
-var guards_1 = require("./guards");
-var bifold_1 = require("./bifold");
+var compose_1 = require("../../../compose");
+var ternary_1 = require("../../../ternary");
+var permutation_3_1 = require("../../../permutation/permutation-3");
+var bifold_1 = require("../bifold");
+var bifoldl_map_1 = require("./bifoldl-map");
+var bifoldr_map_1 = require("./bifoldr-map");
+var guards_1 = require("../guards");
 function bifoldMap() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -22,7 +24,7 @@ function bifoldMap() {
         return (0, compose_1.default)(args[1], bifold_1.default)(args[0]);
     }
     return (0, permutation_3_1.default)(function (monad, mapLeft, mapRight) {
-        return (0, ternary_1.default)(guards_1.isLeft, (0, compose_1.default)(mapLeft, bifold_1.bifoldl), (0, compose_1.default)(mapRight, bifold_1.bifoldr))(monad);
+        return (0, ternary_1.default)(guards_1.isLeft, (0, bifoldl_map_1.default)(mapLeft), (0, bifoldr_map_1.default)(mapRight))(monad);
     }).apply(void 0, args);
 }
 exports.default = bifoldMap;

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

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+/**
+ * Maps provided `monad`'s left value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldlMap<LeftValue, Value>(map: Map<LeftValue, Value>): (monad: Either<LeftValue, any>) => Value | undefined;
+/**
+ * Maps provided `monad`'s left value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldlMap<LeftValue, Value>(monad: Either<LeftValue, any>, map: Map<LeftValue, Value>): Value | undefined;

package/either/operators/bifold-map/bifoldl-map.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @module Either 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 guards_1 = require("../guards");
+var bifold_1 = require("../bifold");
+function bifoldlMap() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (0, permutation_2_1.default)(function (monad, map) {
+        return (0, ternary_1.default)(guards_1.isLeft, (0, compose_1.default)(map, bifold_1.bifoldl), function () { return undefined; })(monad);
+    }).apply(void 0, args);
+}
+exports.default = bifoldlMap;

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

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+/**
+ * Maps provided `monad`'s right value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldrMap<RightValue, Value>(map: Map<RightValue, Value>): (monad: Either<any, RightValue>) => Value | undefined;
+/**
+ * Maps provided `monad`'s right value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldrMap<RightValue, Value>(monad: Either<any, RightValue>, map: Map<RightValue, Value>): Value | undefined;

package/either/operators/bifold-map/bifoldr-map.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @module Either 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 guards_1 = require("../guards");
+var bifold_1 = require("../bifold");
+function bifoldrMap() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (0, permutation_2_1.default)(function (monad, map) {
+        return (0, ternary_1.default)(guards_1.isRight, (0, compose_1.default)(map, bifold_1.bifoldr), function () { return undefined; })(monad);
+    }).apply(void 0, args);
+}
+exports.default = bifoldrMap;

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

@@ -0,0 +1,3 @@
+export { default } from './bifold-map';
+export { default as bifoldlMap } from './bifoldl-map';
+export { default as bifoldrMap } from './bifoldr-map';

package/either/operators/bifold-map/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bifoldrMap = exports.bifoldlMap = exports.default = void 0;
+var bifold_map_1 = require("./bifold-map");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return bifold_map_1.default; } });
+var bifoldl_map_1 = require("./bifoldl-map");
+Object.defineProperty(exports, "bifoldlMap", { enumerable: true, get: function () { return bifoldl_map_1.default; } });
+var bifoldr_map_1 = require("./bifoldr-map");
+Object.defineProperty(exports, "bifoldrMap", { enumerable: true, get: function () { return bifoldr_map_1.default; } });

package/either/operators/bimap/first.js

@@ -3,11 +3,11 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var left_1 = require("../../left");
 var guards_1 = require("../guards");
 var bifold_1 = require("../bifold");
 var compose_1 = require("../../../compose");
 var ternary_1 = require("../../../ternary");
-var left_1 = require("../../left");
 var identity_1 = require("../../../identity");
 var permutation_2_1 = require("../../../permutation/permutation-2");
 function first() {
@@ -16,7 +16,7 @@ function first() {
         args[_i] = arguments[_i];
     }
     return (0, permutation_2_1.default)(function (monad, mapLeft) {
-        return (0, ternary_1.default)(guards_1.isLeft, (0, compose_1.default)(left_1.default, mapLeft, bifold_1.bifoldl), identity_1.default)(monad);
+        return (0, ternary_1.default)(guards_1.isLeft, (0, compose_1.default)((0, compose_1.default)(left_1.default, mapLeft), bifold_1.bifoldl), identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = first;

package/either/operators/bimap/second.js

@@ -3,12 +3,12 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var right_1 = require("../../right");
 var bifold_1 = require("../bifold");
 var guards_1 = require("../guards");
 var compose_1 = require("../../../compose");
 var ternary_1 = require("../../../ternary");
 var identity_1 = require("../../../identity");
-var right_1 = require("../../right");
 var permutation_2_1 = require("../../../permutation/permutation-2");
 function second() {
     var args = [];
@@ -16,7 +16,7 @@ function second() {
         args[_i] = arguments[_i];
     }
     return (0, permutation_2_1.default)(function (monad, mapRight) {
-        return (0, ternary_1.default)(guards_1.isRight, (0, compose_1.default)(right_1.default, mapRight, bifold_1.bifoldr), identity_1.default)(monad);
+        return (0, ternary_1.default)(guards_1.isRight, (0, compose_1.default)((0, compose_1.default)(right_1.default, mapRight), bifold_1.bifoldr), identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = second;

package/either/operators/guards.d.ts

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

package/either/operators/guards.js

@@ -7,17 +7,17 @@ exports.isEither = exports.isRight = exports.isLeft = void 0;
 var left_1 = require("../left");
 var right_1 = require("../right");
 /**
- * Type guard function to tell if the provided `monad` is `Left`.
+ * Type guard function to tell if the provided `value` is `Left`.
  */
-function isLeft(monad) {
-    return Object.prototype.hasOwnProperty.call(monad, left_1.lid);
+function isLeft(value) {
+    return Object.prototype.hasOwnProperty.call(value, left_1.lid);
 }
 exports.isLeft = isLeft;
 /**
- * Type guard function to tell if the provided `monad` is `Right`.
+ * Type guard function to tell if the provided `value` is `Right`.
  */
-function isRight(monad) {
-    return Object.prototype.hasOwnProperty.call(monad, right_1.rid);
+function isRight(value) {
+    return Object.prototype.hasOwnProperty.call(value, right_1.rid);
 }
 exports.isRight = isRight;
 /**

package/either/right.d.ts

@@ -18,4 +18,4 @@ export declare type Right<Value> = {
  * 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>;
+export default function right<Value = undefined>(value?: Value): Right<Value>;

package/guard.d.ts

@@ -16,4 +16,4 @@ export declare type GuardQualifier<Function extends VariadicFunction> = [
  *
  * When no `validator` succeeds, the default executor is run.
  */
-export default function guard<Function extends VariadicFunction>(...qualifiers: [...GuardQualifier<Function>[], Function]): (...args: Parameters<Function>) => ReturnType<Function>;
+export default function guard<Function extends VariadicFunction>(...qualifiers: [...GuardQualifier<Function>[], Function]): Function;

package/guard.js

@@ -18,7 +18,7 @@ function guard() {
     for (var _i = 0; _i < arguments.length; _i++) {
         qualifiers[_i] = arguments[_i];
     }
-    return function () {
+    return (function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
@@ -31,6 +31,6 @@ function guard() {
             }
         }
         return qualifiers[length].apply(qualifiers, args);
-    };
+    });
 }
 exports.default = guard;

package/maybe/just.d.ts

@@ -11,11 +11,11 @@ export declare const jid: unique symbol;
  * key, holding the provided value type.
  */
 export declare type Just<Value> = {
-    [jid]: NonNullable<Value>;
+    [jid]: Value;
 };
 /**
  * Constructor function for `Just`.
  * Creates the special object with one property, represented as unique symbol
  * key, holding the provided value.
  */
-export default function just<Value extends NonNullable<any>>(value: Value): Just<Value>;
+export default function just<Value>(value: Value): Just<Value>;

package/maybe/maybe.d.ts

@@ -12,9 +12,4 @@ export declare type Maybe<Value> = Just<Value> | Nothing;
  * Constructor function for `Maybe`.
  * Creates either `just` of a provided value, or `nothing`.
  */
-export default function maybe(value: null | undefined): Nothing;
-/**
- * Constructor function for `Maybe`.
- * Creates either `just` of a provided value, or `nothing`.
- */
-export default function maybe<Value>(value: Value | null | undefined): Just<Value>;
+export default function maybe<Value>(value: Value | null | undefined): Maybe<Value>;

package/maybe/nothing.d.ts

@@ -11,7 +11,7 @@ export declare const nid: unique symbol;
  * key, holding the `null` value type.
  */
 export declare type Nothing = {
-    [nid]: null;
+    [nid]: undefined;
 };
 /**
  * Constructor function for `Nothing`.

package/maybe/nothing.js

@@ -16,7 +16,7 @@ exports.nid = Symbol.for('@@functional/nothing');
 function nothing() {
     var _a;
     return _a = {},
-        _a[exports.nid] = null,
+        _a[exports.nid] = undefined,
         // @ts-expect-error: Undocumented API for external use
         _a.toString = function () {
             return 'Nothing';

package/maybe/operators/bind.d.ts

@@ -7,9 +7,9 @@ import type { Map } from '../../types/map';
  * Binds the value of the `monad` to new monad created
  * by the `transition` function.
  */
-export default function bind<Value, NextValue>(map: Map<Value, Maybe<NextValue>>): (monad: Maybe<Value>) => Maybe<NonNullable<NextValue>>;
+export default function bind<Value, NextValue>(map: Map<Value, Maybe<NextValue>>): (monad: Maybe<Value>) => Maybe<NextValue>;
 /**
  * Binds the value of the `monad` to new monad created
  * by the `transition` function.
  */
-export default function bind<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, Maybe<NextValue>>): Maybe<NonNullable<NextValue>>;
+export default function bind<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, Maybe<NextValue>>): Maybe<NextValue>;

package/maybe/operators/fmap.d.ts

@@ -7,9 +7,9 @@ import type { Map } from '../../types/map';
  * Maps the value of the provided `monad` through the `transition` function
  * and returns a new `Maybe` of the mapped value.
  */
-export default function fmap<Value, NextValue = Value>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => Maybe<NonNullable<NextValue>>;
+export default function fmap<Value, NextValue>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => Maybe<NextValue>;
 /**
  * Maps the value of the provided `monad` through the `transition` function
  * and returns a new `Maybe` of the mapped value.
  */
-export default function fmap<Value, NextValue = Value>(monad: Maybe<Value>, map: Map<Value, NextValue>): Maybe<NonNullable<NextValue>>;
+export default function fmap<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, NextValue>): Maybe<NextValue>;

package/maybe/operators/fmap.js

@@ -7,7 +7,7 @@ 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 fold_map_1 = require("./fold-map");
 var guards_1 = require("./guards");
 var ternary_1 = require("../../ternary");
 function fmap() {
@@ -16,7 +16,7 @@ function fmap() {
         args[_i] = arguments[_i];
     }
     return (0, permutation_2_1.default)(function (monad, map) {
-        return (0, ternary_1.default)(guards_1.isJust, (0, compose_1.default)(maybe_1.default, map, fold_1.default), identity_1.default)(monad);
+        return (0, ternary_1.default)(guards_1.isJust, (0, compose_1.default)((maybe_1.default), (0, fold_map_1.default)(map)), identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = fmap;

package/maybe/operators/fold-map.d.ts

@@ -8,14 +8,14 @@ import type { Map } from '../../types/map';
 /**
  * A type to unwrap the provided `Monad` into the new value type.
  */
-export declare type FoldMap<Monad extends Maybe<any>, NextValue> = Monad extends Just<any> ? NonNullable<NextValue> : Monad extends Nothing ? null : never;
+export declare type FoldMap<Monad extends Maybe<any>, NextValue> = Monad extends Just<any> ? NextValue : Monad extends Nothing ? undefined : Monad extends Maybe<any> ? NextValue | undefined : never;
 /**
  * Maps the value of the provided `monad` through the `transition` function
  * and returns the mapped value or `null`.
  */
-export default function foldMap<Value, NextValue = Value>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => FoldMap<Maybe<Value>, NextValue>;
+export default function foldMap<Value, NextValue = Value>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => NextValue | undefined;
 /**
  * Maps the value of the provided `monad` through the `transition` function
  * and returns the mapped value or `null`.
  */
-export default function foldMap<Value, NextValue = Value>(monad: Maybe<Value>, map: Map<Value, NextValue>): FoldMap<Maybe<Value>, NextValue>;
+export default function foldMap<Value, NextValue = Value>(monad: Maybe<Value>, map: Map<Value, NextValue>): NextValue | undefined;

package/maybe/operators/fold-map.js

@@ -14,7 +14,7 @@ function foldMap() {
         args[_i] = arguments[_i];
     }
     return (0, permutation_2_1.default)(function (monad, map) {
-        return (0, ternary_1.default)(guards_1.isJust, (0, compose_1.default)(map, fold_1.default), function () { return null; })(monad);
+        return (0, ternary_1.default)(guards_1.isJust, (0, compose_1.default)(map, fold_1.default), function () { return undefined; })(monad);
     }).apply(void 0, args);
 }
 exports.default = foldMap;

package/maybe/operators/fold.d.ts

@@ -7,8 +7,8 @@ import { Nothing } from '../nothing';
 /**
  * A type to unwrap the value type of the provided `Monad`.
  */
-export declare type Fold<Monad extends Maybe<any>> = Monad extends Just<infer Value> ? Value : Monad extends Nothing ? null : never;
+export declare type Fold<Monad extends Maybe<any>> = Monad extends Just<infer Value> ? Value : Monad extends Nothing ? undefined : Monad extends Maybe<infer Value> ? Value | undefined : never;
 /**
  * Returns the value of the provided `monad`.
  */
-export default function fold<Monad extends Maybe<any>>(monad: Monad): Fold<Monad>;
+export default function fold<Value>(monad: Maybe<Value>): Value | undefined;

package/maybe/operators/guards.d.ts

@@ -5,13 +5,13 @@ import { Just } from '../just';
 import type { Maybe } from '../maybe';
 import { Nothing } from '../nothing';
 /**
- * Type guard function to tell if the provided `monad` is `Just`.
+ * Type guard function to tell if the provided `value` is `Just`.
  */
-export declare function isJust<Value>(monad: Maybe<Value>): monad is Just<Value>;
+export declare function isJust<Value>(value: any): value is Just<Value>;
 /**
- * Type guard function to tell if the provided `monad` is `Nothing`.
+ * Type guard function to tell if the provided `value` is `Nothing`.
  */
-export declare function isNothing<Value>(monad: Maybe<Value>): monad is Nothing;
+export declare function isNothing(value: any): value is Nothing;
 /**
  * Type guard function to tell if the provided `value` is `Maybe`.
  */

package/maybe/operators/guards.js

@@ -7,17 +7,17 @@ exports.isMaybe = 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`.
+ * Type guard function to tell if the provided `value` is `Just`.
  */
-function isJust(monad) {
-    return Object.prototype.hasOwnProperty.call(monad, just_1.jid);
+function isJust(value) {
+    return Object.prototype.hasOwnProperty.call(value, just_1.jid);
 }
 exports.isJust = isJust;
 /**
- * Type guard function to tell if the provided `monad` is `Nothing`.
+ * Type guard function to tell if the provided `value` is `Nothing`.
  */
-function isNothing(monad) {
-    return Object.prototype.hasOwnProperty.call(monad, nothing_1.nid);
+function isNothing(value) {
+    return Object.prototype.hasOwnProperty.call(value, nothing_1.nid);
 }
 exports.isNothing = isNothing;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fnts",
-  "version": "1.8.0",
+  "version": "2.0.0-rc.1",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",

package/pipe.d.ts

@@ -1,20 +1,11 @@
 /**
  * @module Composition
  */
-import type { Last } from './types/last';
-import type { UnaryFunction, VariadicFunction } from './types/function';
 /**
- * Creates a `Pipeline` type which parses all of the provided functions' types.
- * Any function with either an incorrect argument or a return type will not fit
- * into the pipeline and should be typed according to it, so that its argument's
- * type matches the return type of the previous function and its return type
- * matches the type of the next function's argument.
+ * Applies second onto first onto args.
  */
-export declare type Pipeline<Functions extends [VariadicFunction, ...UnaryFunction[]], Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [infer First, infer Second, ...infer Rest] ? [
-    First,
-    ...Pipeline<First extends UnaryFunction ? Second extends UnaryFunction ? Rest extends UnaryFunction[] ? [(arg: ReturnType<First>) => ReturnType<Second>, ...Rest] : never : never : First extends VariadicFunction ? Second extends UnaryFunction ? Rest extends UnaryFunction[] ? [(arg: ReturnType<First>) => ReturnType<Second>, ...Rest] : never : never : never>
-] : Functions;
+export default function pipe<First, Argument, Return>(first: (arg: Argument) => First, second: (arg: First) => Return): (arg: Argument) => Return;
 /**
- * Applies all of the provided `functions` one-by-one in left-to-right order.
+ * Applies second onto first onto args.
  */
-export default function pipe<Functions extends [VariadicFunction, ...UnaryFunction[]]>(...functions: Pipeline<Functions>): (...args: Parameters<Functions[0]>) => ReturnType<Last<Functions>>;
+export default function pipe<First, Arguments extends any[], Return>(first: (...args: Arguments) => First, second: (arg: First) => Return): (...args: Arguments) => Return;

package/pipe.js

@@ -4,26 +4,15 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Applies all of the provided `functions` one-by-one in left-to-right order.
+ * Applies second onto first onto args.
  */
-function pipe() {
-    var functions = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        functions[_i] = arguments[_i];
-    }
+function pipe(first, second) {
     return function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var length = functions.length;
-        var pipeline = functions[0].apply(functions, args);
-        if (length > 1) {
-            for (var index = 1; index < length; index += 1) {
-                pipeline = functions[index](pipeline);
-            }
-        }
-        return pipeline;
+        return second(first.apply(void 0, args));
     };
 }
 exports.default = pipe;