fnts 1.7.0 → 1.9.0-rc.1

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,14 @@ 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;
+/**
+ * Returns the left value of the provided `monad`.
+ * If the `monad` is `Right`, returns `undefined`.
+ */
+export default function bifoldl<Monad extends Left<any>>(monad: Monad): Bifoldl<Monad>;

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,14 @@ 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;
+/**
+ * Returns the right value of the provided `monad`.
+ * If the `monad` is `Left`, returns `undefined`.
+ */
+export default function bifoldr<Monad extends Right<any>>(monad: Monad): Bifoldr<Monad>;

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,12 @@
  * @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 bifold_1 = require("../bifold");
+var compose_1 = require("../../../compose");
+var guards_1 = require("../guards");
+var permutation_3_1 = require("../../../permutation/permutation-3");
+var bifoldl_map_1 = require("./bifoldl-map");
+var bifoldr_map_1 = require("./bifoldr-map");
 function bifoldMap() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -22,7 +23,9 @@ 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, guards_1.isLeft)(monad)
+            ? (0, bifoldl_map_1.default)(monad, mapLeft)
+            : (0, bifoldr_map_1.default)(monad, mapRight));
     }).apply(void 0, args);
 }
 exports.default = bifoldMap;

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

@@ -0,0 +1,27 @@
+/**
+ * @module Either Operators
+ */
+import type { Left } from '../../left';
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+import { Bifoldl } from '../bifold/bifoldl';
+/**
+ * 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;
+/**
+ * Maps provided `monad`'s left value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldlMap<Monad extends Left<any>, Value>(map: Map<Bifoldl<Monad>, Value>): (monad: Monad) => Value;
+/**
+ * Maps provided `monad`'s left value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldlMap<Monad extends Left<any>, Value>(monad: Monad, map: Map<Bifoldl<Monad>, Value>): Value;

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @module Either Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var guards_1 = require("../guards");
+var compose_1 = require("../../../compose");
+var bifoldl_1 = require("../bifold/bifoldl");
+var permutation_2_1 = require("../../../permutation/permutation-2");
+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, guards_1.isLeft)(monad)
+            ? (0, compose_1.default)(map, bifoldl_1.default)(monad)
+            : undefined;
+    }).apply(void 0, args);
+}
+exports.default = bifoldlMap;

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

@@ -0,0 +1,27 @@
+/**
+ * @module Either Operators
+ */
+import { Right } from '../../right';
+import type { Either } from '../../either';
+import type { Map } from '../../../types/map';
+import { Bifoldr } from '../bifold/bifoldr';
+/**
+ * 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;
+/**
+ * Maps provided `monad`'s right value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldrMap<Monad extends Right<any>, Value>(map: Map<Bifoldr<Monad>, Value>): (monad: Monad) => Value;
+/**
+ * Maps provided `monad`'s right value to a new value,
+ * then returns it or `undefined`.
+ */
+export default function bifoldrMap<Monad extends Right<any>, Value>(monad: Monad, map: Map<Bifoldr<Monad>, Value>): Value;

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @module Either Operators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var guards_1 = require("../guards");
+var compose_1 = require("../../../compose");
+var bifoldr_1 = require("../bifold/bifoldr");
+var permutation_2_1 = require("../../../permutation/permutation-2");
+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, guards_1.isRight)(monad)
+            ? (0, compose_1.default)(map, bifoldr_1.default)(monad)
+            : undefined;
+    }).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/bimap.js

@@ -4,7 +4,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var guards_1 = require("../guards");
-var ternary_1 = require("../../../ternary");
 var permutation_3_1 = require("../../../permutation/permutation-3");
 var first_1 = require("./first");
 var second_1 = require("./second");
@@ -14,7 +13,9 @@ function bimap() {
         args[_i] = arguments[_i];
     }
     return (0, permutation_3_1.default)(function (monad, mapLeft, mapRight) {
-        return (0, ternary_1.default)(guards_1.isLeft, (0, first_1.default)(mapLeft), (0, second_1.default)(mapRight))(monad);
+        return (0, guards_1.isLeft)(monad)
+            ? (0, first_1.default)(monad, mapLeft)
+            : (0, second_1.default)(monad, mapRight);
     }).apply(void 0, args);
 }
 exports.default = bimap;

package/either/operators/bimap/first.js

@@ -3,11 +3,10 @@
  * @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 bifoldl_1 = require("../bifold/bifoldl");
 var identity_1 = require("../../../identity");
 var permutation_2_1 = require("../../../permutation/permutation-2");
 function first() {
@@ -16,7 +15,9 @@ 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, guards_1.isLeft)(monad)
+            ? (0, compose_1.default)((left_1.default), mapLeft, bifoldl_1.default)(monad)
+            : (0, identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = first;

package/either/operators/bimap/second.js

@@ -3,12 +3,11 @@
  * @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 +15,9 @@ 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, guards_1.isRight)(monad)
+            ? (0, compose_1.default)((right_1.default), mapRight, bifold_1.bifoldr)(monad)
+            : (0, identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = second;

package/either/operators/bindr.js

@@ -4,7 +4,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var compose_1 = require("../../compose");
-var ternary_1 = require("../../ternary");
 var identity_1 = require("../../identity");
 var permutation_2_1 = require("../../permutation/permutation-2");
 var bifold_1 = require("./bifold");
@@ -15,7 +14,9 @@ function bindr() {
         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)(mapRight, bifold_1.bifoldr), identity_1.default)(monad);
+        return (0, guards_1.isRight)(monad)
+            ? (0, compose_1.default)(mapRight, bifold_1.bifoldr)(monad)
+            : (0, identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = bindr;

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/bind.js

@@ -4,7 +4,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var compose_1 = require("../../compose");
-var ternary_1 = require("../../ternary");
 var identity_1 = require("../../identity");
 var permutation_2_1 = require("../../permutation/permutation-2");
 var fold_1 = require("./fold");
@@ -15,7 +14,9 @@ function bind() {
         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), identity_1.default)(monad);
+        return (0, guards_1.isJust)(monad)
+            ? (0, compose_1.default)(map, fold_1.default)(monad)
+            : (0, identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = bind;

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,16 +7,17 @@ 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() {
     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.isJust, (0, compose_1.default)(maybe_1.default, map, fold_1.default), identity_1.default)(monad);
+        return (0, guards_1.isJust)(monad)
+            ? (0, compose_1.default)((maybe_1.default), (0, fold_map_1.default)(map))(monad)
+            : (0, identity_1.default)(monad);
     }).apply(void 0, args);
 }
 exports.default = fmap;

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

@@ -5,17 +5,28 @@ import type { Just } from '../just';
 import type { Maybe } from '../maybe';
 import type { Nothing } from '../nothing';
 import type { Map } from '../../types/map';
+import { Fold } from './fold';
 /**
  * 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>(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>(monad: Maybe<Value>, map: Map<Value, NextValue>): NextValue | undefined;
+/**
+ * Maps the value of the provided `monad` through the `transition` function
+ * and returns the mapped value or `null`.
+ */
+export default function foldMap<Monad extends Just<any>, NextValue>(map: Map<Fold<Monad>, NextValue>): (monad: Monad) => NextValue;
+/**
+ * Maps the value of the provided `monad` through the `transition` function
+ * and returns the mapped value or `null`.
+ */
+export default function foldMap<Monad extends Just<any>, NextValue>(monad: Monad, map: Map<Fold<Monad>, NextValue>): NextValue;

package/maybe/operators/fold-map.js

@@ -4,17 +4,18 @@
  */
 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");
+var fold_1 = require("./fold");
 function foldMap() {
     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.isJust, (0, compose_1.default)(map, fold_1.default), function () { return null; })(monad);
+        return (0, guards_1.isJust)(monad)
+            ? (0, compose_1.default)(map, fold_1.default)(monad)
+            : undefined;
     }).apply(void 0, args);
 }
 exports.default = foldMap;

package/maybe/operators/fold.d.ts

@@ -7,7 +7,11 @@ 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<Value>(monad: Maybe<Value>): Value | undefined;
 /**
  * Returns the value of the provided `monad`.
  */

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.7.0",
+  "version": "1.9.0-rc.1",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",

package/rethrow.d.ts

@@ -6,4 +6,4 @@ import type { Effect } from './types/effect';
  * Rethrows a received error
  * performing an optional side effect.
  */
-export default function rethrow<Error>(effect: Effect<(error: Error) => never>): (error: Error) => never;
+export default function rethrow<Error>(effect?: Effect<(error: Error) => never>): (error: Error) => never;

package/rethrow.js

@@ -3,14 +3,14 @@
  * @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 (0, inject_1.default)(function (error) {
+    return function (error) {
+        effect === null || effect === void 0 ? void 0 : effect(error);
         throw error;
-    }, effect);
+    };
 }
 exports.default = rethrow;

package/ternary.d.ts

@@ -6,5 +6,7 @@ import type { Map } from './types/map';
  * Functional alternative to the ternary operator.
  * Enforces the same return type for both branches,
  * the result is evaluated lazily.
+ *
+ * @deprecated
  */
 export default function ternary<Value, Return>(predicate: Map<Value, boolean>, left: Map<Value, Return>, right: Map<Value, Return>): Map<Value, Return>;

package/ternary.js

@@ -7,6 +7,8 @@ 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.
+ *
+ * @deprecated
  */
 function ternary(predicate, left, right) {
     return function (value) {

package/tsconfig.json

@@ -11,10 +11,10 @@
     "alwaysStrict": true,
     "skipLibCheck": true,
     "noImplicitAny": true,
-    "noUnusedLocals": true,
+    "noUnusedLocals": false,
     "strictNullChecks": true,
     "noImplicitReturns": true,
-    "noUnusedParameters": true,
+    "noUnusedParameters": false,
     "strictFunctionTypes": true,
     "strictBindCallApply": true,
     "noStrictGenericChecks": true,