fnts 2.0.0-rc.1 → 2.0.1

package/README.md

@@ -21,7 +21,7 @@ TypeScript / JavaScript functional programming utilities inspired by the
 
 ## Installation
 
-**TypeScript 4.2.2 is required for this package's typings to work properly.**
+**TypeScript 4.7 is required for this package's typings to work properly.**
 
 ```shell
 npm i fnts

package/compose.d.ts

@@ -1,11 +1,20 @@
 /**
  * @module Composition
  */
+import type { UnaryFunction } from './types/function';
 /**
- * Applies first onto second onto args.
+ * Makes a composition of functions from received arguments.
  */
-export default function compose<First, Argument, Return>(first: (arg: First) => Return, second: (arg: Argument) => First): (arg: Argument) => Return;
+export type Compose<Arguments extends any[], Functions extends any[] = []> = Arguments['length'] extends 0 ? Functions : Arguments extends [infer A, infer B] ? [...Functions, (arg: A) => B] : Arguments extends [infer A, ...infer Rest, infer P, infer L] ? Compose<[A, ...Rest, P], [...Functions, (arg: P) => L]> : [];
 /**
- * Applies first onto second onto args.
+ * Destructures a composition of functions into arguments.
  */
-export default function compose<First, Arguments extends any[], Return>(first: (arg: First) => Return, second: (...args: Arguments) => First): (...args: Arguments) => Return;
+export type Decompose<Functions extends UnaryFunction[], Arguments extends any[] = []> = Functions extends [(arg: infer Arg) => infer Return] ? [...Arguments, Arg, Return] : Functions extends [...infer Rest extends UnaryFunction[], (arg: infer Arg) => any] ? Decompose<Rest, [...Arguments, Arg]> : [];
+/**
+ * (B -> C) . (A -> B) = A -> C
+ */
+export default function compose<A extends any[], B, C>(f: (arg: B) => C, g: (...args: A) => B): (...args: A) => C;
+/**
+ * (B -> C) . (A -> B) = A -> C
+ */
+export default function compose<A extends any[], B, C>(f: (arg: B) => C, g: (...args: A) => B, ...args: A): C;

package/compose.js

@@ -4,15 +4,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Applies first onto second onto args.
+ * (B -> C) . (A -> B) = A -> C
  */
-function compose(first, second) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+function compose(f, g) {
+    var maybeArgs = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        maybeArgs[_i - 2] = arguments[_i];
+    }
+    return maybeArgs.length === 0
+        ? function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return f(g.apply(void 0, args));
         }
-        return first(second.apply(void 0, args));
-    };
+        : f(g.apply(void 0, maybeArgs));
 }
 exports.default = compose;

package/curry.d.ts

@@ -7,7 +7,7 @@ import type { VariadicFunction } from './types/function';
 /**
  * Creates a type for an auto-curried function.
  */
-export declare type Currying<Function extends VariadicFunction, Length extends number = Parameters<Function>['length']> = <Args extends Gradual<Parameters<Function>>>(...args: Args) => Args['length'] extends Length ? ReturnType<Function> : Currying<(...args: Slice<Parameters<Function>, Args['length']>) => ReturnType<Function>>;
+export type Curry<Function extends VariadicFunction, Length extends number = Parameters<Function>['length']> = <Args extends Gradual<Parameters<Function>>>(...args: Args) => Args['length'] extends Length ? ReturnType<Function> : Curry<(...args: Slice<Parameters<Function>, Args['length']>) => ReturnType<Function>>;
 /**
  * Creates an auto-curried function from the one provided.
  * Until the curried function receives an expected number of arguments,
@@ -16,4 +16,4 @@ export declare type Currying<Function extends VariadicFunction, Length extends n
  * of arguments.
  * Any excess arguments will not be applied.
  */
-export default function curry<Function extends VariadicFunction, Length extends number = Parameters<Function>['length']>(fn: Function, length?: Length): Currying<Function, Length>;
+export default function curry<Function extends VariadicFunction, Length extends number = Parameters<Function>['length']>(fn: Function, length?: Length): Curry<Function, Length>;

package/either/either.d.ts

@@ -8,7 +8,7 @@ import { Right } from './right';
  * Can be either `Right` of the value provided,
  * or `Left` of the error thrown.
  */
-export declare type Either<LeftValue, RightValue> = Left<LeftValue> | Right<RightValue>;
+export type Either<LeftValue, RightValue> = Left<LeftValue> | Right<RightValue>;
 /**
  * Type constructor for `Either`.
  * Creates either `Right` of the value provided,

package/either/left.d.ts

@@ -10,7 +10,7 @@ export declare const lid: unique symbol;
  * Describes the special object with one property, represented as unique symbol
  * key, holding the provided value type.
  */
-export declare type Left<Value> = {
+export type Left<Value> = {
     [lid]: Value;
 };
 /**

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

@@ -8,8 +8,12 @@ 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 : Monad extends Either<infer LeftValue, infer RightValue> ? LeftValue | RightValue : never;
+export 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<LeftValue, RightValue>(monad: Either<LeftValue, RightValue>): LeftValue | RightValue;
+/**
+ * Unwraps either the left or the right value of the provided `monad`.
+ */
+export default function bifold<Monad extends Either<any, any>>(monad: Monad): Bifold<Monad>;

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

@@ -7,7 +7,12 @@ 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 : Monad extends Either<infer LeftValue, any> ? LeftValue | undefined : never;
+export 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 Left<any>>(monad: Monad): Bifoldl<Monad>;
 /**
  * Returns the left value of the provided `monad`.
  * If the `monad` is `Right`, returns `undefined`.

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

@@ -7,7 +7,12 @@ 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 : Monad extends Either<any, infer RightValue> ? RightValue | undefined : never;
+export 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 Right<any>>(monad: Monad): Bifoldr<Monad>;
 /**
  * Returns the right value of the provided `monad`.
  * If the `monad` is `Left`, returns `undefined`.

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

@@ -3,13 +3,12 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var bifold_1 = require("../bifold");
 var compose_1 = require("../../../compose");
-var ternary_1 = require("../../../ternary");
+var guards_1 = require("../guards");
 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++) {
@@ -17,14 +16,16 @@ function bifoldMap() {
     }
     if (args.length === 1) {
         return function (monad) {
-            return (0, compose_1.default)(args[0], bifold_1.default)(monad);
+            return (0, compose_1.default)(args[0], bifold_1.default, monad);
         };
     }
     if (args.length === 2 && (0, guards_1.isEither)(args[0])) {
-        return (0, compose_1.default)(args[1], bifold_1.default)(args[0]);
+        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, bifoldl_map_1.default)(mapLeft), (0, bifoldr_map_1.default)(mapRight))(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

@@ -1,8 +1,10 @@
 /**
  * @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`.
@@ -13,3 +15,13 @@ export default function bifoldlMap<LeftValue, Value>(map: Map<LeftValue, 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

@@ -3,18 +3,19 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var guards_1 = require("../guards");
 var compose_1 = require("../../../compose");
-var ternary_1 = require("../../../ternary");
+var bifoldl_1 = require("../bifold/bifoldl");
 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);
+        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

@@ -1,8 +1,10 @@
 /**
  * @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`.
@@ -13,3 +15,13 @@ export default function bifoldrMap<RightValue, Value>(map: Map<RightValue, 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

@@ -3,18 +3,19 @@
  * @module Either Operators
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var guards_1 = require("../guards");
 var compose_1 = require("../../../compose");
-var ternary_1 = require("../../../ternary");
+var bifoldr_1 = require("../bifold/bifoldr");
 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);
+        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/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.d.ts

@@ -1,8 +1,10 @@
 /**
  * @module Either Operators
  */
+import { Left } from '../../left';
 import type { Either } from '../../either';
 import type { Map } from '../../../types/map';
+export type First<Monad extends Either<any, any>> = Monad extends Left<infer LeftValue> ? LeftValue : Monad extends Either<infer LeftValue, any> ? LeftValue : never;
 /**
  * Maps the left value of the provided `monad` to a new `Either` monad
  * with the same right value.

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 bifoldl_1 = require("../bifold/bifoldl");
+var left_1 = require("../../left");
 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)((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)((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.d.ts

@@ -2,7 +2,9 @@
  * @module Either Operators
  */
 import type { Either } from '../../either';
+import { Right } from '../../right';
 import type { Map } from '../../../types/map';
+export type Second<Monad extends Either<any, any>> = Monad extends Right<infer RightValue> ? RightValue : Monad extends Either<any, infer RightValue> ? RightValue : never;
 /**
  * Maps the right value of the provided `monad` to a new `Either` monad
  * with the same left value.

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)((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)((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/right.d.ts

@@ -10,7 +10,7 @@ export declare const rid: unique symbol;
  * Describes the special object with one property, represented as unique symbol
  * key, holding the provided value type.
  */
-export declare type Right<Value> = {
+export type Right<Value> = {
     [rid]: Value;
 };
 /**

package/get.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module Get
+ */
+/**
+ * Recursively flattens object type to a union of its keys
+ * combined through dot-notation.
+ */
+export type Flatten<Source extends Record<string, unknown> | any[]> = keyof Source extends keyof any[] ? `${number}` : (keyof Source | keyof {
+    [Key in keyof Source as Source[Key] extends Record<string, unknown> ? `${Key}.${Flatten<Source[Key]>}` : Source[Key] extends any[] ? Source[Key] extends Array<any[]> | Record<string, unknown>[] ? `${Key}.${number}` | `${Key}.${number}.${Flatten<Source[Key][number]>}` : `${Key}.${number}` : Key]: never;
+});
+/**
+ * Gets the value type inside a nested object type `Source` by provided `Path`
+ * written in dot-notation.
+ */
+export type Get<Source, Path extends string> = Source extends Record<string, unknown> ? Path extends `${infer Index extends number}.${infer Right}` ? Get<Source, Right> : Path extends `${infer Left extends keyof Source}.${infer Right}` ? Get<Exclude<Source[Left], undefined>, Right> | Extract<Source[Left], undefined> : Path extends keyof Source ? Source[Path] : never : Source extends any[] ? Path extends `${infer Left extends number}.${infer Right}` ? Get<Exclude<Source[Left], undefined>, Right> | Extract<Source[Left], undefined> : Path extends `${infer Index extends number}` ? Source[Index] : never : never;
+/**
+ * Gets the value inside a nested `source` object by provided `path`
+ * written in dot-notation.
+ */
+export default function get<Source extends Record<string, unknown> | any[], Path extends Flatten<Source>>(path: Path): (source: Source) => Get<Source, Path>;
+/**
+ * Gets the value inside a nested `source` object by provided `path`
+ * written in dot-notation.
+ */
+export default function get<Source extends Record<string, unknown> | any[], Path extends Flatten<Source>>(source: Source, path: Path): Get<Source, Path>;

package/get.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @module Get
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var permutation_2_1 = require("./permutation/permutation-2");
+/**
+ * Gets the value inside a nested `source` object by provided `path`
+ * written in dot-notation.
+ */
+function get() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (0, permutation_2_1.default)(function (source, path) {
+        var keys = path.split('.');
+        var length = keys.length;
+        var result = source;
+        for (var index = 0; index < length; index += 1) {
+            result = result[keys[index]];
+        }
+        return result;
+    }).apply(void 0, args);
+}
+exports.default = get;

package/guard.d.ts

@@ -2,7 +2,7 @@
  * @module Guard
  */
 import type { VariadicFunction } from './types/function';
-export declare type GuardQualifier<Function extends VariadicFunction> = [
+export type GuardQualifier<Function extends VariadicFunction> = [
     validator: <Result extends boolean>(...args: Parameters<Function>) => Result,
     executor: Function
 ];

package/identity.d.ts

@@ -4,7 +4,7 @@
 /**
  * A type describing the `identity` function.
  */
-export declare type Identity<T> = (x: T) => T;
+export type Identity<T> = (x: T) => T;
 /**
  * A function which returns the provided value.
  */

package/index.d.ts

@@ -1,3 +1,4 @@
+export { default as get } from './get';
 export { default as tap } from './tap';
 export { default as pipe } from './pipe';
 export { default as curry } from './curry';
@@ -5,5 +6,4 @@ export { default as match } from './guard';
 export { default as inject } from './inject';
 export { default as compose } from './compose';
 export { default as rethrow } from './rethrow';
-export { default as ternary } from './ternary';
 export { default as identity } from './identity';

package/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identity = exports.ternary = exports.rethrow = exports.compose = exports.inject = exports.match = exports.curry = exports.pipe = exports.tap = void 0;
+exports.identity = exports.rethrow = exports.compose = exports.inject = exports.match = exports.curry = exports.pipe = exports.tap = exports.get = void 0;
+var get_1 = require("./get");
+Object.defineProperty(exports, "get", { enumerable: true, get: function () { return get_1.default; } });
 var tap_1 = require("./tap");
 Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return tap_1.default; } });
 var pipe_1 = require("./pipe");
@@ -15,7 +17,5 @@ var compose_1 = require("./compose");
 Object.defineProperty(exports, "compose", { enumerable: true, get: function () { return compose_1.default; } });
 var rethrow_1 = require("./rethrow");
 Object.defineProperty(exports, "rethrow", { enumerable: true, get: function () { return rethrow_1.default; } });
-var ternary_1 = require("./ternary");
-Object.defineProperty(exports, "ternary", { enumerable: true, get: function () { return ternary_1.default; } });
 var identity_1 = require("./identity");
 Object.defineProperty(exports, "identity", { enumerable: true, get: function () { return identity_1.default; } });

package/maybe/just.d.ts

@@ -10,7 +10,7 @@ export declare const jid: unique symbol;
  * Describes the special object with one property, represented as unique symbol
  * key, holding the provided value type.
  */
-export declare type Just<Value> = {
+export type Just<Value> = {
     [jid]: Value;
 };
 /**

package/maybe/maybe.d.ts

@@ -7,7 +7,7 @@ import { Nothing } from './nothing';
  * Type constructor for `Maybe`.
  * Can be either `Just` of a provided value type, or `Nothing`.
  */
-export declare type Maybe<Value> = Just<Value> | Nothing;
+export type Maybe<Value> = Just<Value> | Nothing;
 /**
  * Constructor function for `Maybe`.
  * Creates either `just` of a provided value, or `nothing`.

package/maybe/nothing.d.ts

@@ -10,7 +10,7 @@ export declare const nid: unique symbol;
  * Describes the special object with one property, represented as unique symbol
  * key, holding the `null` value type.
  */
-export declare type Nothing = {
+export type Nothing = {
     [nid]: undefined;
 };
 /**

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>(map: Map<Value, NextValue>): (monad: Maybe<Value>) => Maybe<NextValue>;
+export default function fmap<Value, NextValue>(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>(monad: Maybe<Value>, map: Map<Value, NextValue>): Maybe<NextValue>;
+export default function fmap<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, NextValue>): Maybe<NonNullable<NextValue>>;

package/maybe/operators/fmap.js

@@ -9,14 +9,15 @@ var maybe_1 = require("../maybe");
 var permutation_2_1 = require("../../permutation/permutation-2");
 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), (0, fold_map_1.default)(map)), 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

@@ -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 ? undefined : Monad extends Maybe<any> ? NextValue | undefined : never;
+export 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>) => NextValue | undefined;
+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>): NextValue | undefined;
+export default function foldMap<Value, NextValue>(monad: Maybe<Value>, map: Map<Value, NextValue>): NextValue | undefined;

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 undefined; })(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 ? undefined : Monad extends Maybe<infer Value> ? Value | undefined : never;
+export 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 Just<any>>(monad: Monad): Fold<Monad>;
 /**
  * Returns the value of the provided `monad`.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fnts",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.1",
   "license": "MIT",
   "author": "Dmytro Vasylkivskyi",
   "description": "TypeScript / JavaScript FP utilities",
@@ -15,7 +15,7 @@
   "homepage": "https://drizzer14.github.io/fnts",
   "repository": "https://github.com/drizzer14/fnts",
   "peerDependencies": {
-    "typescript": ">=4.2.2"
+    "typescript": ">=4.7"
   },
   "peerDependenciesMeta": {
     "typescript": {

package/permutation/permutation-2.d.ts

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

package/permutation/permutation-3.d.ts

@@ -3,6 +3,6 @@
  */
 import type { VariadicFunction } from './../types/function';
 import type { FirstParameter, SecondParameter } from './permutation-2';
-export declare type TernaryFunction = (a: any, b: any, c: any) => any;
-export declare type ThirdParameter<Function extends VariadicFunction> = Parameters<Function>[2];
+export type TernaryFunction = (a: any, b: any, c: any) => any;
+export type ThirdParameter<Function extends VariadicFunction> = 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): VariadicFunction;

package/pipe.d.ts

@@ -1,11 +1,24 @@
 /**
  * @module Composition
  */
+import type { UnaryFunction } from './types/function';
 /**
- * Applies second onto first onto args.
+ * Makes a pipeline of functions from received arguments.
  */
-export default function pipe<First, Argument, Return>(first: (arg: Argument) => First, second: (arg: First) => Return): (arg: Argument) => Return;
+export type Pipe<Arguments extends any[], Functions extends any[] = []> = Arguments['length'] extends 0 ? Functions : Arguments extends [infer A, infer B] ? [(arg: A) => B, ...Functions] : Arguments extends [infer A, ...infer Rest, infer P, infer L] ? Pipe<[A, ...Rest, P], [(arg: P) => L, ...Functions]> : [];
 /**
- * Applies second onto first onto args.
+ * Destructures a pipeline of functions into arguments.
  */
-export default function pipe<First, Arguments extends any[], Return>(first: (...args: Arguments) => First, second: (arg: First) => Return): (...args: Arguments) => Return;
+export type Depipe<Functions extends UnaryFunction[], Arguments extends any[] = []> = Functions extends [(arg: infer Arg) => infer Return] ? [...Arguments, Arg, Return] : Functions extends [(arg: infer Arg) => any, ...infer Rest extends UnaryFunction[]] ? Depipe<Rest, [...Arguments, Arg]> : [];
+/**
+ * (A -> B) . (B -> C) = A -> C
+ */
+export default function pipe<A extends any[], B, C>(first: (...args: A) => B, second: (arg: B) => C): (...args: A) => C;
+/**
+ * (A -> B) . (B -> C) = A -> C
+ */
+export default function pipe<A extends any[], B, C>(...args: [
+    ...args: A,
+    first: (...args: A) => B,
+    second: (arg: B) => C
+]): C;

package/pipe.js

@@ -4,15 +4,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Applies second onto first onto args.
+ * (A -> B) . (B -> C) = A -> C
  */
-function pipe(first, second) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+function pipe() {
+    var maybeArgs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        maybeArgs[_i] = arguments[_i];
+    }
+    return maybeArgs.length === 2
+        ? function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return maybeArgs[1](maybeArgs[0].apply(maybeArgs, args));
         }
-        return second(first.apply(void 0, args));
-    };
+        : maybeArgs[maybeArgs.length - 1](maybeArgs[maybeArgs.length - 2].apply(maybeArgs, maybeArgs.slice(0, -2)));
 }
 exports.default = pipe;

package/tsconfig.json

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

package/ternary.d.ts

@@ -1,10 +0,0 @@
-/**
- * @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

@@ -1,16 +0,0 @@
-"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;