New Build

dist/app/functions/F.d.ts

@@ -0,0 +1 @@
+export declare const F: (...ignored: unknown[]) => false;

dist/app/functions/F.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.F = void 0;
+exports.F = (...ignored) => false;

dist/app/functions/T.d.ts

@@ -0,0 +1 @@
+export declare const T: (...ignored: unknown[]) => true;

dist/app/functions/T.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.T = void 0;
+exports.T = (...ignored) => true;

dist/app/functions/always.d.ts

@@ -0,0 +1 @@
+export declare const always: <A>(a: A) => (...bs: unknown[]) => A;

dist/app/functions/always.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.always = void 0;
+exports.always = (a) => (...bs) => a;

dist/app/functions/assoc.d.ts

@@ -0,0 +1,3 @@
+export declare const assoc: <K extends string | number | symbol>(k: K) => <B>(b: B) => <A>(a: A) => A | {
+    K: B;
+};

dist/app/functions/assoc.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assoc = void 0;
+const clone_1 = require("./clone");
+exports.assoc = (k) => (b) => (a) => Object.assign(clone_1.clone(a), { [k]: b });

dist/app/functions/bind.d.ts

@@ -0,0 +1 @@
+export declare const bind: <M extends CallableFunction>(m: M) => (b: ThisParameterType<M>) => OmitThisParameter<M>;

dist/app/functions/bind.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bind = void 0;
+exports.bind = (m) => (b) => m.bind(b);

dist/app/functions/blackbird.d.ts

@@ -0,0 +1 @@
+export declare const blackbird: <BS extends any[], C>(converging: (...bs: BS) => C) => <A>(...parts: ((a: A) => unknown)[]) => (a: A) => C;

dist/app/functions/blackbird.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blackbird = void 0;
+exports.blackbird = (converging) => (...parts) => (a) => {
+    const bs = parts.map((part) => part(a));
+    return converging(...bs);
+};

dist/app/functions/both.d.ts

@@ -0,0 +1 @@
+export declare const both: <A, B>(first: (a: A) => B) => <C>(second: (a: A) => C) => (a: A) => B | C;

dist/app/functions/both.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.both = void 0;
+exports.both = (first) => (second) => (a) => first(a) && second(a);

dist/app/functions/cap.d.ts

@@ -0,0 +1 @@
+export declare const cap: (word: string) => string;

dist/functions/cap.js → dist/app/functions/cap.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cap = void 0;
-/**
- * ```
- * cap :: s => s
- * ```
- * @param {string} word word we want to capitalize
- */
 exports.cap = (word) => typeof word === "string" && word.length > 0
     ? word[0].toLocaleUpperCase() + word.substr(1)
     : word;

dist/app/functions/clone.d.ts

@@ -0,0 +1 @@
+export declare function clone<A>(a: A): A;

dist/functions/clone.js → dist/app/functions/clone.js

@@ -1,8 +1,10 @@
 "use strict";
-/* eslint-disable @typescript-eslint/ban-types -- WeakMap needs an object type */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clone = void 0;
-const functions_1 = require("../functions");
+const isArray_1 = require("./isArray");
+const isDate_1 = require("./isDate");
+const isObject_1 = require("./isObject");
+const isDefined_1 = require("./isDefined");
 function cloneObject(a, map) {
     if (map.has(a)) {
         return map.get(a);
@@ -33,26 +35,17 @@ function cloneArray(a, map) {
     }
 }
 function cloneUnknown(a, map) {
-    const t = functions_1.isDefined(a)
-        ? functions_1.isDate(a)
+    const t = isDefined_1.isDefined(a)
+        ? isDate_1.isDate(a)
             ? cloneDate(a)
-            : functions_1.isArray(a)
+            : isArray_1.isArray(a)
                 ? cloneArray(a, map)
-                : functions_1.isObject(a)
+                : isObject_1.isObject(a)
                     ? cloneObject(a, map)
                     : a
         : a;
     return t;
 }
-/**
- * ```
- * clone :: a => a
- * ```
- * @export
- * @template A
- * @param {A} a
- * @returns {A}
- */
 function clone(a) {
     const map = new WeakMap();
     return cloneUnknown(a, map);

dist/app/functions/complement.d.ts

@@ -0,0 +1 @@
+export declare const complement: <A>(predicate: (a: A) => boolean) => (a: A) => boolean;

dist/app/functions/complement.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complement = void 0;
+exports.complement = (predicate) => (a) => !predicate(a);

dist/app/functions/compose.d.ts

@@ -0,0 +1,9 @@
+import { Last } from "../types";
+export declare type Compose<B, A> = {
+    (b: B): A;
+    call(a: A): B;
+    from<C>(f: (c: C) => B): Compose<C, A>;
+};
+export declare const compose: (<FS extends ((x: any) => any)[]>(...fs: FS) => (a: Parameters<Last<FS>>[0]) => ReturnType<FS[0]>) & {
+    fluent: <B, A>(f: (b: B) => A) => Compose<B, A>;
+};

dist/app/functions/compose.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const fluent = (f) => {
+    function call(b) {
+        return f(b);
+    }
+    const p = Object.assign(call.bind(null), {
+        from: (f) => {
+            return after(p, f);
+        },
+        call,
+    });
+    return p;
+};
+const after = (next, f) => {
+    function call(c) {
+        return next(f(c));
+    }
+    const p = Object.assign(call.bind(null), {
+        from: (f) => {
+            return after(p, f);
+        },
+        call,
+    });
+    return p;
+};
+exports.compose = Object.assign((...fs) => {
+    return (a) => fs.reduceRight((v, f) => f(v), a);
+}, { fluent });

dist/app/functions/concat.d.ts

@@ -0,0 +1 @@
+export declare const concat: <A extends readonly unknown[]>(as: A) => <B extends readonly unknown[]>(bs: B) => [...A, ...B];

dist/app/functions/concat.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = void 0;
+exports.concat = (as) => (bs) => [...as, ...bs];

dist/app/functions/curry.d.ts

@@ -0,0 +1 @@
+export declare const curry: <F extends Function>(f: F) => Function;

dist/app/functions/curry.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curry = void 0;
+const curryN_1 = require("./curryN");
+exports.curry = (f) => curryN_1.curryN(f.length)(f);

dist/app/functions/curryN.d.ts

@@ -0,0 +1 @@
+export declare const curryN: (n: number) => <F extends Function>(f: F) => Function;

dist/functions/curryN.js → dist/app/functions/curryN.js

@@ -13,14 +13,4 @@ const gather = (n, f, previous = []) => {
     });
     return curried;
 };
-/**
- * ```
- * curryN :: n => ((a¹, a², ..., aⁿ) => b) =>  a¹ => a²... => aⁿ => b
- * ```
- * -----------------------------------------------------------------------------
- * Converts a function that accepts an arity, __n__, number of arguments into a
- * series of _Unary_ functions that produce the same final value.
- *
- * @todo add support for Variadic Tuples in TypeScript 4
- */
 exports.curryN = (n) => (f) => gather(n, f);

dist/app/functions/defaultTo.d.ts

@@ -0,0 +1 @@
+export declare const defaultTo: <A>(a: A) => <B>(b: B) => A | B;

dist/app/functions/defaultTo.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTo = void 0;
+const isDefined_1 = require("./isDefined");
+const isNaN_1 = require("./isNaN");
+exports.defaultTo = (a) => (b) => isNaN_1.isNaN(b) ? a : isDefined_1.isDefined(b) ? b : a;

dist/app/functions/either.d.ts

@@ -0,0 +1 @@
+export declare const either: <A, B>(mapAB: (a: A) => B) => <C>(mapAC: (a: A) => C) => (a: A) => B | C;

dist/app/functions/either.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.either = void 0;
+exports.either = (mapAB) => (mapAC) => (a) => mapAB(a) || mapAC(a);

dist/app/functions/equals.d.ts

@@ -0,0 +1 @@
+export declare const equals: (a: unknown) => (b: unknown) => boolean;

dist/app/functions/equals.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = void 0;
+exports.equals = (a) => (b) => a === b;

dist/app/functions/filter.d.ts

@@ -0,0 +1 @@
+export declare const filter: <A>(p: (a: A) => boolean) => (as: A[]) => A[];

dist/app/functions/filter.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = void 0;
+exports.filter = (p) => (as) => as.filter(p);

dist/app/functions/has.d.ts

@@ -0,0 +1 @@
+export declare const has: <K extends string | number | symbol>(k: K) => (a: unknown) => a is { [P in K]: unknown; };

dist/app/functions/has.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.has = void 0;
+exports.has = (k) => (a) => Object.prototype.hasOwnProperty.call(a, k);

dist/app/functions/head.d.ts

@@ -0,0 +1 @@
+export declare const head: <A>(as: A[]) => A;

dist/app/functions/head.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.head = void 0;
+exports.head = (as) => as[0];

dist/app/functions/identity.d.ts

@@ -0,0 +1 @@
+export declare const identity: <A>(a: A) => A;

dist/app/functions/identity.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = void 0;
+exports.identity = (a) => a;

dist/app/functions/iife.d.ts

@@ -0,0 +1 @@
+export declare const iife: <AS extends unknown[], B>(f: (...as: AS) => B, ...as: AS) => B;

dist/app/functions/iife.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iife = void 0;
+exports.iife = (f, ...as) => f(...as);

dist/app/functions/init.d.ts

@@ -0,0 +1 @@
+export declare const init: <A>(as: A[]) => A[];

dist/app/functions/init.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+exports.init = (as) => as.slice(0, as.length - 1);

dist/app/functions/invoker.d.ts

@@ -0,0 +1 @@
+export declare const invoker: <K extends string | number | symbol>(k: K) => <AS extends unknown[]>(...as: AS) => <B>(c: { [_ in K]: (...as: AS) => B; }) => B;

dist/app/functions/invoker.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invoker = void 0;
+exports.invoker = (k) => (...as) => (c) => c[k](...as);

dist/app/functions/isArray.d.ts

@@ -0,0 +1 @@
+export declare const isArray: (arg: any) => arg is any[];

dist/app/functions/isArray.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = void 0;
+exports.isArray = Array.isArray;

dist/app/functions/isDate.d.ts

@@ -0,0 +1 @@
+export declare const isDate: (a: unknown) => a is Date;

dist/app/functions/isDate.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDate = void 0;
+exports.isDate = (a) => a instanceof Date;

dist/app/functions/isDefined.d.ts

@@ -0,0 +1 @@
+export declare const isDefined: <A>(a: A) => a is Exclude<A, null> & Exclude<A, undefined>;

dist/app/functions/isDefined.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = void 0;
+exports.isDefined = (a) => a != null;

dist/app/functions/isEmpty.d.ts

@@ -0,0 +1 @@
+export declare const isEmpty: (a: unknown) => boolean;

dist/app/functions/isEmpty.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = void 0;
+exports.isEmpty = (a) => (Array.isArray(a) && a.length === 0) ||
+    (typeof a === "string" && a.length === 0) ||
+    (typeof a === "object" && a !== null && Object.keys(a).length === 0);

dist/app/functions/isFunction.d.ts

@@ -0,0 +1 @@
+export declare const isFunction: (a: unknown) => a is Function;

dist/app/functions/isFunction.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunction = void 0;
+exports.isFunction = (a) => typeof a === "function";

dist/app/functions/isNaN.d.ts

@@ -0,0 +1 @@
+export declare const isNaN: (a: unknown) => a is number;

dist/app/functions/isNaN.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNaN = void 0;
+exports.isNaN = (a) => Number.isNaN(a);

dist/app/functions/isNil.d.ts

@@ -0,0 +1 @@
+export declare const isNil: (a: unknown) => a is null | undefined;

dist/app/functions/isNil.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNil = void 0;
+exports.isNil = (a) => a === null || a === undefined;

dist/app/functions/isNumber.d.ts

@@ -0,0 +1 @@
+export declare const isNumber: (a: unknown) => a is number;

dist/app/functions/isNumber.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = void 0;
+exports.isNumber = (a) => typeof a === "number";

dist/app/functions/isObject.d.ts

@@ -0,0 +1 @@
+export declare const isObject: (a: unknown) => a is object;

dist/app/functions/isObject.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+exports.isObject = (a) => typeof a === "object";

dist/app/functions/isString.d.ts

@@ -0,0 +1 @@
+export declare const isString: (a: unknown) => a is string;

dist/app/functions/isString.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = void 0;
+exports.isString = (a) => typeof a === "string";

dist/app/functions/join.d.ts

@@ -0,0 +1 @@
+export declare const join: (a: string | undefined) => <A>(bs: A[]) => string;

dist/app/functions/join.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = void 0;
+exports.join = (a) => (bs) => bs.join(a);

dist/app/functions/last.d.ts

@@ -0,0 +1 @@
+export declare const last: <A>(as: A[]) => A;

dist/app/functions/last.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.last = void 0;
+exports.last = (as) => as[as.length - 1];

dist/app/functions/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (s: string) => <A>(a: A) => A;

dist/app/functions/log.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+exports.log = (s) => (a) => {
+    console.groupCollapsed(s);
+    console.log(a);
+    console.groupEnd();
+    return a;
+};

dist/app/functions/merge.d.ts

@@ -0,0 +1 @@
+export declare const merge: <A>(a: A) => <B>(b: B) => A & B;

dist/app/functions/merge.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = void 0;
+exports.merge = (a) => (b) => Object.assign({}, a, b);

dist/app/functions/not.d.ts

@@ -0,0 +1 @@
+export declare const not: (a: unknown) => boolean;

dist/app/functions/not.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not = void 0;
+exports.not = (a) => !a;

dist/app/functions/partial.d.ts

@@ -0,0 +1,2 @@
+export declare const partial: <AS extends Args>(...as: AS) => <BS extends Args, C>(f: (...args_0: AS, ...args_1: BS) => C) => (...bs: BS) => C;
+export declare type Args = readonly unknown[];

dist/app/functions/partial.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partial = void 0;
+exports.partial = (...as) => (f) => (...bs) => f(...as, ...bs);

dist/app/functions/pipe.d.ts

@@ -0,0 +1,9 @@
+import { Last } from "../types";
+export declare type Pipe<A, B> = {
+    (a: A): B;
+    then: <C>(f: (b: B) => C) => Pipe<A, C>;
+    invoke(a: A): B;
+};
+export declare const pipe: (<FS extends ((x: any) => any)[]>(...fs: FS) => (a: Parameters<FS[0]>[0]) => ReturnType<Last<FS>>) & {
+    fluent: <A, B>(f: (a: A) => B) => Pipe<A, B>;
+};