fnts 1.0.2 → 1.3.0

package/esm/either/operators/bifold/bifold.js

@@ -0,0 +1,12 @@
+/**
+ * @module Either Operators
+ */
+import bifoldl from './bifoldl';
+import bifoldr from './bifoldr';
+/**
+ * Unwraps either the left or the right value of the provided `monad`.
+ */
+export default function bifold(monad) {
+    var _a;
+    return (_a = bifoldl(monad)) !== null && _a !== void 0 ? _a : bifoldr(monad);
+}

package/esm/either/operators/bifold/bifoldl.js

@@ -0,0 +1,14 @@
+/**
+ * @module Either Operators
+ */
+import { isLeft } from '../guards';
+import { lid } from '../../left';
+/**
+ * Returns the left value of the provided `monad`.
+ * If the `monad` is `Right`, returns `undefined`.
+ */
+export default function bifoldl(monad) {
+    return isLeft(monad)
+        ? monad[lid]
+        : undefined;
+}

package/esm/either/operators/bifold/bifoldr.js

@@ -0,0 +1,14 @@
+/**
+ * @module Either Operators
+ */
+import { isRight } from '../guards';
+import { rid } from '../../right';
+/**
+ * Returns the right value of the provided `monad`.
+ * If the `monad` is `Left`, returns `undefined`.
+ */
+export default function bifoldr(monad) {
+    return isRight(monad)
+        ? monad[rid]
+        : undefined;
+}

package/esm/either/operators/bifold/index.js

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

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

@@ -0,0 +1,13 @@
+/**
+ * @module Either Operators
+ */
+import compose from '../../compose';
+import ternary from '../../ternary';
+import permutation3 from '../../permutation/permutation-3';
+import { isLeft } from './guards';
+import { bifoldl, bifoldr } from './bifold';
+export default function bifoldMap(...args) {
+    return permutation3((monad, mapLeft, mapRight) => {
+        return ternary(isLeft, compose(mapLeft, bifoldl), compose(mapRight, bifoldr))(monad);
+    })(...args);
+}

package/esm/either/operators/bimap/bimap.js

@@ -0,0 +1,13 @@
+/**
+ * @module Either Operators
+ */
+import { isLeft } from '../guards';
+import ternary from '../../../ternary';
+import permutation3 from '../../../permutation/permutation-3';
+import first from './first';
+import second from './second';
+export default function bimap(...args) {
+    return permutation3((monad, mapLeft, mapRight) => {
+        return ternary(isLeft, first(mapLeft), second(mapRight))(monad);
+    })(...args);
+}

package/esm/either/operators/bimap/first.js

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import { isLeft } from '../guards';
+import { bifoldl } from '../bifold';
+import compose from '../../../compose';
+import left from '../../left';
+import identity from '../../../identity';
+import ternary from '../../../ternary';
+import permutation2 from '../../../permutation/permutation-2';
+export default function first(...args) {
+    return permutation2((monad, mapLeft) => {
+        return ternary(isLeft, compose(left, mapLeft, bifoldl), identity)(monad);
+    })(...args);
+}

package/esm/either/operators/bimap/index.js

@@ -0,0 +1,3 @@
+export { default } from './bimap';
+export { default as first } from './first';
+export { default as second } from './second';

package/esm/either/operators/bimap/second.js

@@ -0,0 +1,15 @@
+/**
+ * @module Either Operators
+ */
+import { bifoldr } from '../bifold';
+import { isRight } from '../guards';
+import compose from '../../../compose';
+import identity from '../../../identity';
+import right from '../../right';
+import ternary from '../../../ternary';
+import permutation2 from '../../../permutation/permutation-2';
+export default function second(...args) {
+    return permutation2((monad, mapRight) => {
+        return ternary(isRight, compose(right, mapRight, bifoldr), identity)(monad);
+    })(...args);
+}

package/esm/either/operators/guards.js

@@ -0,0 +1,17 @@
+/**
+ * @module Either Operators
+ */
+import { lid } from '../left';
+import { rid } from '../right';
+/**
+ * Type guard function to tell if the provided `monad` is `Left`.
+ */
+export function isLeft(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, lid);
+}
+/**
+ * Type guard function to tell if the provided `monad` is `Right`.
+ */
+export function isRight(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, rid);
+}

package/esm/either/operators/index.js

@@ -0,0 +1,4 @@
+export { bifoldl, bifoldr, default as bifold, } from './bifold';
+export * from './guards';
+export { default as bifoldMap } from './bifold-map';
+export { default as bimap, first, second } from './bimap';

package/esm/either/right.js

@@ -0,0 +1,17 @@
+/**
+ * @module Either
+ */
+/**
+ * Internal unique identifier for `Right`.
+ */
+export const rid = Symbol.for('@@functional/right');
+/**
+ * Constructor function for `Right`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the provided value.
+ */
+export default function right(value) {
+    return {
+        [rid]: value
+    };
+}

package/esm/guard.js

@@ -0,0 +1,26 @@
+/**
+ * @module Guard
+ */
+/**
+ * A function which accepts the pairs of guards:
+ * the first one is the `validator`, expected to return a boolean value.
+ *
+ * If the value is `true`, it's `executor` should run with the provided `args`
+ * and return from the `guards` function.
+ * If the value is `false`, the process continues to the next `validator`.
+ *
+ * When no `validator` succeeds, the default executor is run.
+ */
+export default function guard(...qualifiers) {
+    return (...args) => {
+        const length = qualifiers.length - 1;
+        const defaultExpression = qualifiers[length];
+        for (let index = 0; index < length; index += 1) {
+            const [validator, expression] = qualifiers[index];
+            if (validator(...args)) {
+                return expression(...args);
+            }
+        }
+        return defaultExpression(...args);
+    };
+}

package/esm/identity.js

@@ -0,0 +1,9 @@
+/**
+ * @module Identity
+ */
+/**
+ * A function which returns the provided value.
+ */
+export default function identity(x) {
+    return x;
+}

package/esm/index.js

@@ -0,0 +1,9 @@
+export { default as tap } from './tap';
+export { default as pipe } from './pipe';
+export { default as curry } from './curry';
+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/esm/inject.js

@@ -0,0 +1,12 @@
+/**
+ * @module Side Effects
+ */
+import permutation2 from './permutation/permutation-2';
+export default function inject(...args) {
+    return permutation2((fn, effect) => {
+        return ((...args) => {
+            effect(...args);
+            return fn(...args);
+        });
+    })(...args);
+}

package/esm/maybe/index.js

@@ -0,0 +1,3 @@
+export { default } from './maybe';
+export { default as just } from './just';
+export { default as nothing } from './nothing';

package/esm/maybe/just.js

@@ -0,0 +1,17 @@
+/**
+ * @module Maybe
+ */
+/**
+ * Internal unique identifier for `Just`.
+ */
+export const jid = Symbol.for('@@functional/just');
+/**
+ * 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) {
+    return {
+        [jid]: value
+    };
+}

package/esm/maybe/maybe.js

@@ -0,0 +1,14 @@
+/**
+ * @module Maybe
+ */
+import just from './just';
+import nothing from './nothing';
+/**
+ * Constructor function for `Maybe`.
+ * Creates either `just` of a provided value, or `nothing`.
+ */
+export default function maybe(value) {
+    return value === null || value === undefined
+        ? nothing()
+        : just(value);
+}

package/esm/maybe/nothing.js

@@ -0,0 +1,17 @@
+/**
+ * @module Maybe
+ */
+/**
+ * Internal unique identifier for `Nothing`.
+ */
+export const nid = Symbol.for('@@functional/nothing');
+/**
+ * Constructor function for `Nothing`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the `null` value.
+ */
+export default function nothing() {
+    return {
+        [nid]: null
+    };
+}

package/esm/maybe/operators/bind.js

@@ -0,0 +1,14 @@
+/**
+ * @module Maybe Operators
+ */
+import compose from '../../compose';
+import ternary from '../../ternary';
+import identity from '../../identity';
+import permutation2 from '../../permutation/permutation-2';
+import fold from './fold';
+import { isJust } from './guards';
+export default function bind(...args) {
+    return permutation2((monad, transition) => {
+        return ternary(isJust, compose(transition, fold), identity)(monad);
+    })(...args);
+}

package/esm/maybe/operators/fmap.js

@@ -0,0 +1,15 @@
+/**
+ * @module Maybe Operators
+ */
+import compose from '../../compose';
+import identity from '../../identity';
+import maybe from '../maybe';
+import permutation2 from '../../permutation/permutation-2';
+import fold from './fold';
+import { isJust } from './guards';
+import ternary from '../../ternary';
+export default function fmap(...args) {
+    return permutation2((monad, transition) => {
+        return ternary(isJust, compose(maybe, transition, fold), identity)(monad);
+    })(...args);
+}

package/esm/maybe/operators/fold-map.js

@@ -0,0 +1,13 @@
+/**
+ * @module Maybe Operators
+ */
+import compose from '../../compose';
+import ternary from '../../ternary';
+import permutation2 from '../../permutation/permutation-2';
+import fold from './fold';
+import { isJust } from './guards';
+export default function foldMap(...args) {
+    return permutation2((monad, transition) => {
+        return ternary(isJust, compose(transition, fold), () => null)(monad);
+    })(...args);
+}

package/esm/maybe/operators/fold.js

@@ -0,0 +1,14 @@
+/**
+ * @module Maybe Operators
+ */
+import { jid } from '../just';
+import { nid } from '../nothing';
+import { isJust } from './guards';
+/**
+ * Returns the value of the provided `monad`.
+ */
+export default function fold(monad) {
+    return isJust(monad)
+        ? monad[jid]
+        : monad[nid];
+}

package/esm/maybe/operators/guards.js

@@ -0,0 +1,17 @@
+/**
+ * @module Maybe Operators
+ */
+import { jid } from '../just';
+import { nid } from '../nothing';
+/**
+ * Type guard function to tell if the provided `monad` is `Just`.
+ */
+export function isJust(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, jid);
+}
+/**
+ * Type guard function to tell if the provided `monad` is `Nothing`.
+ */
+export function isNothing(monad) {
+    return Object.prototype.hasOwnProperty.call(monad, nid);
+}

package/esm/maybe/operators/index.js

@@ -0,0 +1,5 @@
+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 } from './fold-map';

package/esm/permutation/index.js

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

package/esm/permutation/permutation-2.js

@@ -0,0 +1,11 @@
+/**
+ * @module Permutation
+ */
+export default function permutation2(fn, shouldCurry) {
+    return (...args) => {
+        const [a1, b] = args;
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b)) || args.length < fn.length
+            ? (a2) => fn(a2, a1)
+            : fn(a1, b);
+    };
+}

package/esm/permutation/permutation-3.js

@@ -0,0 +1,11 @@
+/**
+ * @module Permutation
+ */
+export default function permutation3(fn, shouldCurry) {
+    return (...args) => {
+        const [a1, b, c] = args;
+        return (shouldCurry === null || shouldCurry === void 0 ? void 0 : shouldCurry(a1, b, c)) || args.length < fn.length
+            ? (a2) => fn(a2, a1, b)
+            : fn(a1, b, c);
+    };
+}

package/esm/pipe.js

@@ -0,0 +1,18 @@
+/**
+ * @module Composition
+ */
+/**
+ * Applies all of the provided `functions` one-by-one in left-to-right order
+ * starting from the `argument`.
+ */
+export default function pipe(...functions) {
+    return (arg) => {
+        const length = functions.length;
+        let pipeline = arg;
+        for (let index = 0; index < length; index += 1) {
+            const current = functions[index];
+            pipeline = current(pipeline);
+        }
+        return pipeline;
+    };
+}

package/esm/rethrow.js

@@ -0,0 +1,13 @@
+/**
+ * @module Side Effects
+ */
+import inject from './inject';
+/**
+ * Rethrows a received error
+ * performing an optional side effect.
+ */
+export default function rethrow(effect) {
+    return inject((error) => {
+        throw error;
+    }, effect);
+}

package/esm/tap.js

@@ -0,0 +1,12 @@
+/**
+ * @module Side Effects
+ */
+import inject from './inject';
+import identity from './identity';
+/**
+ * Performs a side effect
+ * passing the received argument through itself.
+ */
+export default function tap(effect) {
+    return inject(identity, effect);
+}

package/esm/ternary.js

@@ -0,0 +1,13 @@
+/**
+ * @module Ternary
+ */
+/**
+ * Functional alternative to the ternary operator.
+ * Enforces the same return type for both branches,
+ * the result is evaluated lazily.
+ */
+export default function ternary(predicate, left, right) {
+    return (value) => {
+        return predicate(value) ? left(value) : right(value);
+    };
+}

package/guard.d.ts

@@ -1,4 +1,7 @@
-export declare type Guard<Function extends (...args: any[]) => any> = [
+/**
+ * @module Guard
+ */
+export declare type GuardQualifier<Function extends (...args: any[]) => any> = [
     validator: <Result extends boolean>(...args: Parameters<Function>) => Result,
     executor: Function
 ];
@@ -12,5 +15,4 @@ export declare type Guard<Function extends (...args: any[]) => any> = [
  *
  * When no `validator` succeeds, the default executor is run.
  */
-export declare const guard: <Function_1 extends (...args: any[]) => any>(...guards: [...Guard<Function_1>[], Function_1]) => (...args: Parameters<Function_1>) => ReturnType<Function_1>;
-export default guard;
+export default function guard<Function extends (...args: any[]) => any>(...qualifiers: [...GuardQualifier<Function>[], Function]): (...args: Parameters<Function>) => ReturnType<Function>;

package/identity.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @module Identity
+ */
 /**
  * A type describing the `identity` function.
  */
@@ -5,5 +8,4 @@ export declare type Identity<T> = (x: T) => T;
 /**
  * A function which returns the provided value.
  */
-export declare const identity: <T>(x: T) => T;
-export default identity;
+export default function identity<T>(x: T): T;

package/index.d.ts

@@ -1,7 +1,9 @@
-export * from './pipe';
-export * from './curry';
-export * from './guard';
-export * from './maybe';
-export * from './either';
-export * from './compose';
-export * from './identity';
+export { default as tap } from './tap';
+export { default as pipe } from './pipe';
+export { default as curry } from './curry';
+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/inject.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module Side Effects
+ */
+import type { Effect } from './types/effect';
+/**
+ * Injects a function with a side effect.
+ * Returns the copy of the original function.
+ */
+export default function inject<Function extends (...args: any[]) => any>(effect: Effect<Function>): (fn: Function) => Function;
+/**
+ * Injects a function with a side effect.
+ * Returns the copy of the original function.
+ */
+export default function inject<Function extends (...args: any[]) => any>(fn: Function, effect: Effect<Function>): Function;

package/maybe/index.d.ts

@@ -1 +1,3 @@
-export { default, just, Just, nothing, Nothing, maybe, Maybe } from './maybe';
+export { default, Maybe } from './maybe';
+export { default as just, Just } from './just';
+export { default as nothing, Nothing } from './nothing';

package/maybe/just.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Maybe
+ */
+/**
+ * Internal unique identifier for `Just`.
+ */
+export declare const jid: unique symbol;
+/**
+ * Type constructor for `Just`.
+ * Describes the special object with one property, represented as unique symbol
+ * key, holding the provided value type.
+ */
+export declare type Just<Value> = {
+    [jid]: Exclude<Value, null | undefined>;
+};
+/**
+ * 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>;

package/maybe/maybe.d.ts

@@ -1,47 +1,15 @@
 /**
- * Internal unique identifier for `Just`.
+ * @module Maybe
  */
-export declare const jid: unique symbol;
-/**
- * Type constructor for `Just`.
- * Describes the special object with one property, represented as unique symbol
- * key, holding the provided value type.
- */
-export declare type Just<Value> = {
-    [jid]: Exclude<Value, null | undefined>;
-};
-/**
- * Constructor function for `Just`.
- * Creates the special object with one property, represented as unique symbol
- * key, holding the provided value.
- */
-export declare const just: <Value>(value: Value) => Just<Value>;
-/**
- * Internal unique identifier for `Nothing`.
- */
-export declare const nid: unique symbol;
-/**
- * Type constructor for `Nothing`.
- * Describes the special object with one property, represented as unique symbol
- * key, holding the `null` value type.
- */
-export declare type Nothing = {
-    [nid]: null;
-};
-/**
- * Constructor function for `Nothing`.
- * Creates the special object with one property, represented as unique symbol
- * key, holding the `null` value.
- */
-export declare const nothing: () => Nothing;
+import { Just } from './just';
+import { Nothing } from './nothing';
 /**
  * Type constructor for `Maybe`.
- * This can be either `Just` of a provided value type, or `Nothing`.
+ * Can be either `Just` of a provided value type, or `Nothing`.
  */
 export declare type Maybe<Value> = Just<Value> | Nothing;
 /**
  * Constructor function for `Maybe`.
- * This creates either `just` of a provided value, or `nothing`.
+ * Creates either `just` of a provided value, or `nothing`.
  */
-export declare const maybe: <Value>(value: Value | null | undefined) => Maybe<Value>;
-export default maybe;
+export default function maybe<Value>(value: Value | null | undefined): Maybe<Value>;

package/maybe/nothing.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Maybe
+ */
+/**
+ * Internal unique identifier for `Nothing`.
+ */
+export declare const nid: unique symbol;
+/**
+ * Type constructor for `Nothing`.
+ * Describes the special object with one property, represented as unique symbol
+ * key, holding the `null` value type.
+ */
+export declare type Nothing = {
+    [nid]: null;
+};
+/**
+ * Constructor function for `Nothing`.
+ * Creates the special object with one property, represented as unique symbol
+ * key, holding the `null` value.
+ */
+export default function nothing(): Nothing;

package/maybe/operators/bind.d.ts

@@ -1,12 +1,15 @@
+/**
+ * @module Maybe Operators
+ */
 import type { Maybe } from '../maybe';
-import type { Map } from '../../.internal/map';
-interface Bind {
-    <Value, NextValue>(transition: Map<Value, Maybe<NextValue>>): (monad: Maybe<Value>) => Maybe<NextValue>;
-    <Value, NextValue>(monad: Maybe<Value>, transition: Map<Value, Maybe<NextValue>>): Maybe<NextValue>;
-}
+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>;
 /**
  * Binds the value of the `monad` to new monad created
  * by the `transition` function.
  */
-export declare const bind: Bind;
-export default bind;
+export default function bind<Value, NextValue>(monad: Maybe<Value>, transition: Map<Value, Maybe<NextValue>>): Maybe<NextValue>;