fnts 1.5.1 → 1.6.0

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

@@ -3,13 +3,23 @@
  */
 import type { Either } from '../either';
 import type { Map } from '../../types/map';
+/**
+ * Maps provided `monad` to a value,
+ * then returns it.
+ */
+export default function bifoldMap<LeftValue, RightValue, Value>(map: Map<LeftValue | RightValue, Value>): (monad: Either<LeftValue, RightValue>) => Value;
+/**
+ * Maps provided `monad` to a value,
+ * then returns it.
+ */
+export default function bifoldMap<LeftValue, RightValue, Value>(monad: Either<LeftValue, RightValue>, map: Map<LeftValue | RightValue, Value>): Value;
 /**
  * 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;
+export default function bifoldMap<LeftValue, RightValue, Value>(mapLeft: Map<LeftValue, Value>, mapRight: Map<RightValue, Value>): (monad: Either<LeftValue, RightValue>) => Value;
 /**
  * Maps left and right values of the provided `monad` to a value,
  * then returns it.
  */
-export default function bifoldMap<LeftValue, RightValue, MappedValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, MappedValue>, mapRight: Map<RightValue, MappedValue>): MappedValue;
+export default function bifoldMap<LeftValue, RightValue, Value>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, Value>, mapRight: Map<RightValue, Value>): Value;

package/either/operators/bifold-map.js

@@ -13,6 +13,12 @@ function bifoldMap() {
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
+    if (args.length === 1) {
+        return function (monad) { return args[0](monad); };
+    }
+    if (args.length === 2 && guards_1.isEither(args[0])) {
+        return compose_1.default(args[1], bifold_1.default)(args[0]);
+    }
     return permutation_3_1.default(function (monad, mapLeft, mapRight) {
         return ternary_1.default(guards_1.isLeft, compose_1.default(mapLeft, bifold_1.bifoldl), compose_1.default(mapRight, bifold_1.bifoldr))(monad);
     }).apply(void 0, args);

package/either/operators/guards.d.ts

@@ -12,3 +12,7 @@ export declare function isLeft<LeftValue>(monad: Either<LeftValue, any>): monad
  * Type guard function to tell if the provided `monad` is `Right`.
  */
 export declare function isRight<RightValue>(monad: Either<any, RightValue>): monad is Right<RightValue>;
+/**
+ * Type guard function to tell if the provided `value` is `Either`.
+ */
+export declare function isEither<LeftValue, RightValue>(value: any): value is Either<LeftValue, RightValue>;

package/either/operators/guards.js

@@ -3,7 +3,7 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRight = exports.isLeft = void 0;
+exports.isEither = exports.isRight = exports.isLeft = void 0;
 var left_1 = require("../left");
 var right_1 = require("../right");
 /**
@@ -20,3 +20,10 @@ function isRight(monad) {
     return Object.prototype.hasOwnProperty.call(monad, right_1.rid);
 }
 exports.isRight = isRight;
+/**
+ * Type guard function to tell if the provided `value` is `Either`.
+ */
+function isEither(value) {
+    return isLeft(value) || isRight(value);
+}
+exports.isEither = isEither;

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]: Exclude<Value, null | undefined>;
+    [jid]: NonNullable<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>(value: Value): Just<Value>;
+export default function just<Value extends NonNullable<any>>(value: Value): Just<Value>;

package/maybe/maybe.d.ts

@@ -12,4 +12,9 @@ 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>(value: Value | null | undefined): Maybe<Value>;
+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>;

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>(transition: Map<Value, Maybe<NextValue>>): (monad: Maybe<Value>) => Maybe<NextValue>;
+export default function bind<Value, NextValue>(map: Map<Value, Maybe<NextValue>>): (monad: Maybe<Value>) => Maybe<NonNullable<NextValue>>;
 /**
  * Binds the value of the `monad` to new monad created
  * by the `transition` function.
  */
-export default function bind<Value, NextValue>(monad: Maybe<Value>, transition: Map<Value, Maybe<NextValue>>): Maybe<NextValue>;
+export default function bind<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, Maybe<NextValue>>): Maybe<NonNullable<NextValue>>;

package/maybe/operators/bind.js

@@ -14,8 +14,8 @@ function bind() {
     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), identity_1.default)(monad);
+    return permutation_2_1.default(function (monad, map) {
+        return ternary_1.default(guards_1.isJust, compose_1.default(map, fold_1.default), 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>(transition: Map<Value, NextValue>): (monad: Maybe<Value>) => Maybe<NextValue>;
+export default function fmap<Value, NextValue = Value>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => Maybe<NonNullable<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>, transition: Map<Value, NextValue>): Maybe<NextValue>;
+export default function fmap<Value, NextValue = Value>(monad: Maybe<Value>, map: Map<Value, NextValue>): Maybe<NonNullable<NextValue>>;

package/maybe/operators/fmap.js

@@ -15,8 +15,8 @@ function fmap() {
     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);
+    return permutation_2_1.default(function (monad, map) {
+        return ternary_1.default(guards_1.isJust, compose_1.default(maybe_1.default, map, fold_1.default), 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> ? NextValue : Monad extends Nothing ? null : never;
+export declare type FoldMap<Monad extends Maybe<any>, NextValue> = Monad extends Just<any> ? NonNullable<NextValue> : Monad extends Nothing ? null : 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>(transition: Map<Value, NextValue>): (monad: Maybe<Value>) => NextValue | null;
+export default function foldMap<Value, NextValue = Value>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => FoldMap<Maybe<Value>, NextValue>;
 /**
  * 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>, transition: Map<Value, NextValue>): NextValue | null;
+export default function foldMap<Value, NextValue = Value>(monad: Maybe<Value>, map: Map<Value, NextValue>): FoldMap<Maybe<Value>, NextValue>;

package/maybe/operators/fold-map.js

@@ -13,8 +13,8 @@ function foldMap() {
     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);
+    return permutation_2_1.default(function (monad, map) {
+        return ternary_1.default(guards_1.isJust, compose_1.default(map, fold_1.default), function () { return null; })(monad);
     }).apply(void 0, args);
 }
 exports.default = foldMap;

package/maybe/operators/guards.d.ts

@@ -12,3 +12,7 @@ export declare function isJust<Value>(monad: Maybe<Value>): monad is Just<Value>
  * Type guard function to tell if the provided `monad` is `Nothing`.
  */
 export declare function isNothing<Value>(monad: Maybe<Value>): monad is Nothing;
+/**
+ * Type guard function to tell if the provided `value` is `Maybe`.
+ */
+export declare function isMaybe<Value>(value: any): value is Maybe<Value>;

package/maybe/operators/guards.js

@@ -3,7 +3,7 @@
  * @module Maybe Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNothing = exports.isJust = void 0;
+exports.isMaybe = exports.isNothing = exports.isJust = void 0;
 var just_1 = require("../just");
 var nothing_1 = require("../nothing");
 /**
@@ -20,3 +20,10 @@ function isNothing(monad) {
     return Object.prototype.hasOwnProperty.call(monad, nothing_1.nid);
 }
 exports.isNothing = isNothing;
+/**
+ * Type guard function to tell if the provided `value` is `Maybe`.
+ */
+function isMaybe(value) {
+    return isJust(value) || isNothing(value);
+}
+exports.isMaybe = isMaybe;

package/maybe/operators/index.d.ts

@@ -1,5 +1,5 @@
+export * from './guards';
 export { default as fmap } from './fmap';
 export { default as bind } from './bind';
 export { default as fold } from './fold';
-export { isJust, isNothing } from './guards';
 export { default as foldMap, FoldMap } from './fold-map';

package/maybe/operators/index.js

@@ -1,14 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.foldMap = exports.isNothing = exports.isJust = exports.fold = exports.bind = exports.fmap = void 0;
+exports.foldMap = exports.fold = exports.bind = exports.fmap = void 0;
+__exportStar(require("./guards"), exports);
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fnts",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",