fnts 1.1.0 → 1.3.1

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

@@ -1,9 +1,41 @@
-import type { Map } from '../../.internal/map';
-import type { Maybe, Nothing } from '../maybe';
-export declare function foldMap<Value, NextValue>(monad: Nothing, transition: Map<Value, NextValue>): null;
+/**
+ * @module Maybe Operators
+ */
+import type { Just } from '../just';
+import type { Maybe } from '../maybe';
+import type { Nothing } from '../nothing';
+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;
+/**
+ * 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: Just<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>(transition: Map<Value, NextValue>): (monad: Nothing) => null;
+/**
+ * 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;
+/**
+ * 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: Just<Value>, transition: Map<Value, NextValue>): 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: Nothing, transition: Map<Value, NextValue>): null;
 /**
  * Maps the value of the provided `monad` through the `transition` function
  * and returns the mapped value or `null`.
  */
-export declare function foldMap<Value, NextValue>(monad: Maybe<Value>, transition: Map<Value, NextValue>): NextValue | null;
-export default foldMap;
+export default function foldMap<Value, NextValue = Value>(monad: Maybe<Value>, transition: Map<Value, NextValue>): NextValue | null;

package/maybe/operators/fold-map.js

@@ -1 +1,20 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.foldMap=foldMap,exports.default=void 0;var _compose=_interopRequireDefault(require("../../compose")),_permutationOf=_interopRequireDefault(require("../../.internal/permutation-of-2")),_fold=_interopRequireDefault(require("./fold")),_guards=require("./guards");function _interopRequireDefault(a){return a&&a.__esModule?a:{default:a}}function foldMap(){return(0,_permutationOf.default)((a,b)=>(0,_guards.isJust)(a)?(0,_compose.default)(b,_fold.default)(a):null)(...arguments)}var _default=foldMap;exports.default=_default;
+"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/maybe/operators/fold.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Maybe Operators
+ */
 import { Just } from '../just';
 import type { Maybe } from '../maybe';
 import { Nothing } from '../nothing';
@@ -8,5 +11,4 @@ export declare type Fold<Monad extends Maybe<any>> = Monad extends Just<infer Va
 /**
  * Returns the value of the provided `monad`.
  */
-export declare function fold<Monad extends Maybe<any>>(monad: Monad): Fold<Monad>;
-export default fold;
+export default function fold<Monad extends Maybe<any>>(monad: Monad): Fold<Monad>;

package/maybe/operators/fold.js

@@ -1 +1,17 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.fold=fold,exports.default=void 0;var _just=require("../just"),_nothing=require("../nothing"),_guards=require("./guards");function fold(a){return(0,_guards.isJust)(a)?a[_just.jid]:a[_nothing.nid]}var _default=fold;exports.default=_default;
+"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/maybe/operators/guards.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Maybe Operators
+ */
 import { Just } from '../just';
 import type { Maybe } from '../maybe';
 import { Nothing } from '../nothing';

package/maybe/operators/guards.js

@@ -1 +1,22 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.isJust=isJust,exports.isNothing=isNothing;var _just=require("../just"),_nothing=require("../nothing");function isJust(a){return Object.prototype.hasOwnProperty.call(a,_just.jid)}function isNothing(a){return Object.prototype.hasOwnProperty.call(a,_nothing.nid)}
+"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/maybe/operators/index.d.ts

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

package/maybe/operators/index.js

@@ -1 +1,14 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"fmap",{enumerable:!0,get:function get(){return _fmap.fmap}}),Object.defineProperty(exports,"bind",{enumerable:!0,get:function get(){return _bind.bind}}),Object.defineProperty(exports,"fold",{enumerable:!0,get:function get(){return _fold.fold}}),Object.defineProperty(exports,"isJust",{enumerable:!0,get:function get(){return _guards.isJust}}),Object.defineProperty(exports,"isNothing",{enumerable:!0,get:function get(){return _guards.isNothing}}),Object.defineProperty(exports,"foldMap",{enumerable:!0,get:function get(){return _foldMap.foldMap}}),Object.defineProperty(exports,"FoldMap",{enumerable:!0,get:function get(){return _foldMap.FoldMap}});var _fmap=require("./fmap"),_bind=require("./bind"),_fold=require("./fold"),_guards=require("./guards"),_foldMap=require("./fold-map");
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fnts",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",
@@ -12,9 +12,15 @@
     "typescript",
     "javascript"
   ],
-  "homepage": "https://github.com/drizzer14/fnts",
-  "repository": "github:drizzer14/fnts",
+  "homepage": "https://drizzer14.github.io/fnts",
+  "repository": "https://github.com/drizzer14/fnts",
   "peerDependencies": {
     "typescript": ">=4.2.2"
-  }
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "main": "index.js"
 }

package/permutation/index.d.ts

@@ -0,0 +1,2 @@
+export { default as permutation2 } from './permutation-2';
+export { default as permutation3 } from './permutation-3';

package/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/permutation/permutation-2.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module Permutation
+ */
+export declare type BinaryFunction = (a: any, b: any) => any;
+export declare type FirstParameter<Function extends (...args: any[]) => any> = Parameters<Function>[0];
+export declare type SecondParameter<Function extends (...args: any[]) => any> = Parameters<Function>[1];
+export default function permutation2<Function extends BinaryFunction>(fn: Function, shouldCurry?: (a: FirstParameter<Function> | SecondParameter<Function>, b: SecondParameter<Function> | undefined) => boolean): (...args: any[]) => any;

package/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/permutation/permutation-3.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module Permutation
+ */
+import type { FirstParameter, SecondParameter } from './permutation-2';
+export declare type TernaryFunction = (a: any, b: any, c: any) => any;
+export declare type ThirdParameter<Function extends (...args: any[]) => any> = Parameters<Function>[2];
+export default function permutation3<Function extends TernaryFunction>(fn: Function, shouldCurry?: (a: FirstParameter<Function> | SecondParameter<Function>, b: SecondParameter<Function> | ThirdParameter<Function>, c: ThirdParameter<Function> | undefined) => boolean): (...args: any[]) => any;

package/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/pipe.d.ts

@@ -1,4 +1,7 @@
-import type { Last } from './.internal/last';
+/**
+ * @module Composition
+ */
+import type { Last } from './types/last';
 /**
  * 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
@@ -17,5 +20,4 @@ export declare type Pipeline<Functions extends Array<(...args: any[]) => any>, L
  * Applies all of the provided `functions` one-by-one in left-to-right order
  * starting from the `argument`.
  */
-export declare function pipe<Functions extends Array<(arg: any) => any>>(...functions: Pipeline<Functions>): (arg: Parameters<Functions[0]>[0]) => ReturnType<Last<Functions>>;
-export default pipe;
+export default function pipe<Functions extends Array<(arg: any) => any>>(...functions: Pipeline<Functions>): (arg: Parameters<Functions[0]>[0]) => ReturnType<Last<Functions>>;

package/pipe.js

@@ -1 +1,25 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.pipe=pipe,exports.default=void 0;function pipe(){for(var a=arguments.length,b=Array(a),c=0;c<a;c++)b[c]=arguments[c];return a=>{for(var c,d=b.length,e=a,f=0;f<d;f+=1)c=b[f],e=c(e);return e}}var _default=pipe;exports.default=_default;
+"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/rethrow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Side Effects
+ */
+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;

package/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/tap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module Side Effects
+ */
+import type { Map } from './types/map';
+import type { Identity } from './identity';
+import type { Effect } from './types/effect';
+/**
+ * Performs a side effect
+ * passing the received argument through itself.
+ */
+export default function tap<Value>(effect: Effect<Map<Value, any>>): Identity<Value>;

package/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/ternary.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Ternary
+ */
+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.
+ */
+export default function ternary<Value, Return>(predicate: Map<Value, boolean>, left: Map<Value, Return>, right: Map<Value, Return>): Map<Value, Return>;

package/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/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es2019",
+    "target": "esnext",
     "module": "esnext",
     "moduleResolution": "node",
     "lib": [

package/types/effect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Types
+ */
+
+/**
+ * A simple side effect function descriptor.
+ */
+export type Effect<Function extends (...args: any[]) => any> =
+  (...args: Parameters<Function>) => void

package/types/gradual.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module Types
+ */
+
+/**
+ * Gradual defines a tuple type which accepts any amount
+ * of entries from the original one.
+ * 
+ * ```typescript
+ * Gradual<[1, 2, 3]> === [1] | [1, 2] | [1, 2, 3]
+ * ```
+ */
+export type Gradual<T extends any[] | readonly any[]> = T extends [...infer R, any]
+  ? R['length'] extends 0
+    ? T
+    : T | Gradual<R>
+  : T

package/{.internal → types}/last.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @module Types
+ */
+
+/**
+ * Picks the last entry from the tuple or array.
+ */
 export type Last<T extends any[]> =
   T extends [...any[], infer L]
     ? L

package/types/map.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module Types
+ */
+
+/**
+ * A type of a function which maps the original value type to another one.
+ */
+export type Map<From, To> = (value: From) => To

package/{.internal → types}/slice.d.ts

@@ -1,5 +1,12 @@
+/**
+ * @module Types
+ */
+
 import type { Tuple } from './tuple'
 
+/**
+ * Slices the tuple by `C` amount of entries from the **end**.
+ */
 export type Slice<
   T extends any[] | readonly any[],
   C extends number

package/{.internal → types}/tuple.d.ts

@@ -1,4 +1,10 @@
 /**
+ * @module Types
+ */
+
+/**
+ * Creates a tuple of specified length.
+ * 
  * {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f Gracefully borrowed from here}
  */
 export type Tuple<L extends number, T extends any[] | readonly any[] = []> =

package/.internal/gradual.d.ts

@@ -1,5 +0,0 @@
-export type Gradual<T extends any[] | readonly any[]> = T extends [...infer R, any]
-  ? R['length'] extends 0
-    ? T
-    : T | Gradual<R>
-  : T

package/.internal/map.d.ts

@@ -1 +0,0 @@
-export type Map<From, To> = (value: From) => To

package/.internal/permutation-of-2.d.ts

@@ -1 +0,0 @@
-export {};

package/.internal/permutation-of-2.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=exports.permutationOf2=void 0;var permutationOf2=(a,c)=>function(){for(var d=arguments.length,e=Array(d),f=0;f<d;f++)e[f]=arguments[f];var[g,h]=e;return null!==c&&void 0!==c&&c(g,h)||e.length<a.length?b=>a(b,g):a(g,h)};exports.permutationOf2=permutationOf2;var _default=permutationOf2;exports.default=_default;

package/.internal/permutation-of-3.d.ts

@@ -1 +0,0 @@
-export {};

package/.internal/permutation-of-3.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=exports.permutationOf3=void 0;var permutationOf3=a=>function(){for(var d=arguments.length,e=Array(d),f=0;f<d;f++)e[f]=arguments[f];var[g,h,b]=e;return e.length<a.length?b=>a(b,g,h):a(g,h,b)};exports.permutationOf3=permutationOf3;var _default=permutationOf3;exports.default=_default;

package/either/operators/bifold.d.ts

@@ -1,31 +0,0 @@
-import { Either, Left, Right } 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 declare const bifoldl: <Monad extends Either<any, any>>(monad: Monad) => Bifoldl<Monad>;
-/**
- * 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 declare const bifoldr: <Monad extends Either<any, any>>(monad: Monad) => Bifoldr<Monad>;
-/**
- * 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 declare const bifold: <Monad extends Either<any, any>>(monad: Monad) => Bifold<Monad>;
-export default bifold;

package/either/operators/bimap.d.ts

@@ -1,29 +0,0 @@
-import type { Map } from '../../.internal/map';
-import { Either } from '../either';
-interface First {
-    <LeftValue, RightValue, NextLeftValue>(mapLeft: Map<LeftValue, NextLeftValue>): (monad: Either<LeftValue, RightValue>) => Either<NextLeftValue, RightValue>;
-    <LeftValue, RightValue, NextLeftValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, NextLeftValue>): Either<NextLeftValue, RightValue>;
-}
-/**
- * Maps the left value of the provided `monad` to a new `Either` monad
- * with the same right value.
- */
-export declare const first: First;
-interface Second {
-    <LeftValue, RightValue, NextRightValue>(mapRight: Map<RightValue, NextRightValue>): (monad: Either<LeftValue, RightValue>) => Either<LeftValue, NextRightValue>;
-    <LeftValue, RightValue, NextRightValue>(monad: Either<LeftValue, RightValue>, mapRight: Map<RightValue, NextRightValue>): Either<LeftValue, NextRightValue>;
-}
-/**
- * Maps the right value of the provided `monad` to a new `Either` monad
- * with the same left value.
- */
-export declare const second: Second;
-interface Bimap {
-    <LeftValue, RightValue, NextLeftValue, NextRightValue>(mapLeft: Map<LeftValue, NextLeftValue>, mapRight: Map<RightValue, NextRightValue>): (monad: Either<LeftValue, RightValue>) => Either<NextLeftValue, NextRightValue>;
-    <LeftValue, RightValue, NextLeftValue, NextRightValue>(monad: Either<LeftValue, RightValue>, mapLeft: Map<LeftValue, NextLeftValue>, mapRight: Map<RightValue, NextRightValue>): Either<NextLeftValue, NextRightValue>;
-}
-/**
- * Maps left and right values of the provided `monad` to a new `Either` monad.
- */
-export declare const bimap: Bimap;
-export default bimap;