fnts 1.3.1 → 1.3.2

package/compose.d.ts

@@ -2,6 +2,7 @@
  * @module Composition
  */
 import type { Last } from './types/last';
+import type { UnaryFunction } from './types/function';
 /**
  * Creates a `Composition` type which parses all of the provided functions' types.
  * Any function with either an incorrect argument or a return type will not fit
@@ -9,15 +10,12 @@ import type { Last } from './types/last';
  * type matches the return type of the next function and its return type
  * matches the type of the previous function's argument.
  */
-export declare type Composition<Functions extends Array<(...args: any[]) => any>, Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [...infer Rest, infer Penultimate, infer Last] ? [
-    ...Composition<[
-        ...Rest,
-        (arg: ReturnType<Last>) => ReturnType<Penultimate>
-    ]>,
+export declare type Composition<Functions extends UnaryFunction[], Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [...infer Rest, infer Penultimate, infer Last] ? [
+    ...Composition<Rest extends UnaryFunction[] ? Last extends UnaryFunction ? Penultimate extends UnaryFunction ? [...Rest, (arg: ReturnType<Last>) => ReturnType<Penultimate>] : never : never : never>,
     Last
-] : any;
+] : Functions;
 /**
  * Applies all of the provided `functions` one-by-one in right-to-left order
  * starting from the `argument`.
  */
-export default function compose<Functions extends Array<(arg: any) => any>>(...functions: Composition<Functions>): (arg: Parameters<Last<Functions>>[0]) => ReturnType<Functions[0]>;
+export default function compose<Functions extends UnaryFunction[]>(...functions: Composition<Functions>): (arg: Parameters<Last<Functions>>[0]) => ReturnType<Functions[0]>;

package/compose.js

@@ -16,8 +16,7 @@ function compose() {
         var length = functions.length;
         var composition = arg;
         for (var index = length - 1; index >= 0; index -= 1) {
-            var current = functions[index];
-            composition = current(composition);
+            composition = functions[index](composition);
         }
         return composition;
     };

package/curry.d.ts

@@ -3,10 +3,11 @@
  */
 import type { Slice } from './types/slice';
 import type { Gradual } from './types/gradual';
+import type { VariadicFunction } from './types/function';
 /**
  * Creates a type for an auto-curried function.
  */
-export declare type Currying<Function extends (...args: any[]) => any, Length extends number = Parameters<Function>['length']> = <Args extends Gradual<Parameters<Function>>>(...args: Args) => Args['length'] extends 1 ? (arg: Parameters<Function>[0]) => ReturnType<Function> : Args['length'] extends Length ? ReturnType<Function> : Currying<(...args: Slice<Parameters<Function>, Args['length']>) => ReturnType<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>>;
 /**
  * Creates an auto-curried function from the one provided.
  * Until the curried function receives an expected number of arguments,
@@ -15,4 +16,4 @@ export declare type Currying<Function extends (...args: any[]) => any, Length ex
  * of arguments.
  * Any excess arguments will not be applied.
  */
-export default function curry<Function extends (...args: any[]) => any, 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): Currying<Function, Length>;

package/either/operators/bimap/first.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var guards_1 = require("../guards");
 var bifold_1 = require("../bifold");
 var compose_1 = require("../../../compose");
+var ternary_1 = require("../../../ternary");
 var left_1 = require("../../left");
 var identity_1 = require("../../../identity");
-var ternary_1 = require("../../../ternary");
 var permutation_2_1 = require("../../../permutation/permutation-2");
 function first() {
     var args = [];

package/either/operators/bimap/second.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 ternary_1 = require("../../../ternary");
 var permutation_2_1 = require("../../../permutation/permutation-2");
 function second() {
     var args = [];

package/guard.d.ts

@@ -1,7 +1,8 @@
 /**
  * @module Guard
  */
-export declare type GuardQualifier<Function extends (...args: any[]) => any> = [
+import type { VariadicFunction } from './types/function';
+export declare type GuardQualifier<Function extends VariadicFunction> = [
     validator: <Result extends boolean>(...args: Parameters<Function>) => Result,
     executor: Function
 ];
@@ -15,4 +16,4 @@ export declare type GuardQualifier<Function extends (...args: any[]) => any> = [
  *
  * When no `validator` succeeds, the default executor is run.
  */
-export default function guard<Function extends (...args: any[]) => any>(...qualifiers: [...GuardQualifier<Function>[], Function]): (...args: Parameters<Function>) => ReturnType<Function>;
+export default function guard<Function extends VariadicFunction>(...qualifiers: [...GuardQualifier<Function>[], Function]): (...args: Parameters<Function>) => ReturnType<Function>;

package/guard.js

@@ -24,14 +24,13 @@ function guard() {
             args[_i] = arguments[_i];
         }
         var length = qualifiers.length - 1;
-        var defaultExpression = qualifiers[length];
         for (var index = 0; index < length; index += 1) {
             var _a = qualifiers[index], validator = _a[0], expression = _a[1];
             if (validator.apply(void 0, args)) {
                 return expression.apply(void 0, args);
             }
         }
-        return defaultExpression.apply(void 0, args);
+        return qualifiers[length].apply(qualifiers, args);
     };
 }
 exports.default = guard;

package/inject.d.ts

@@ -2,13 +2,14 @@
  * @module Side Effects
  */
 import type { Effect } from './types/effect';
+import type { VariadicFunction } from './types/function';
 /**
  * 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;
+export default function inject<Function extends VariadicFunction>(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;
+export default function inject<Function extends VariadicFunction>(fn: Function, effect: Effect<Function>): Function;

package/package.json

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

package/permutation/permutation-2.d.ts

@@ -1,7 +1,8 @@
 /**
  * @module Permutation
  */
+import type { VariadicFunction } from './../types/function';
 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;
+export declare type FirstParameter<Function extends VariadicFunction> = Parameters<Function>[0];
+export declare 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

@@ -1,7 +1,8 @@
 /**
  * @module Permutation
  */
+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 (...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;
+export declare 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

@@ -2,6 +2,7 @@
  * @module Composition
  */
 import type { Last } from './types/last';
+import type { UnaryFunction } from './types/function';
 /**
  * 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
@@ -9,13 +10,10 @@ import type { Last } from './types/last';
  * type matches the return type of the previous function and its return type
  * matches the type of the next function's argument.
  */
-export declare type Pipeline<Functions extends Array<(...args: any[]) => any>, Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [infer First, infer Second, ...infer Rest] ? [
+export declare type Pipeline<Functions extends UnaryFunction[], Length extends number = Functions['length']> = Length extends 1 ? Functions : Functions extends [infer First, infer Second, ...infer Rest] ? [
     First,
-    ...Pipeline<[
-        (arg: ReturnType<First>) => ReturnType<Second>,
-        ...Rest
-    ]>
-] : any;
+    ...Pipeline<First extends UnaryFunction ? Second extends UnaryFunction ? Rest extends UnaryFunction[] ? [(arg: ReturnType<First>) => ReturnType<Second>, ...Rest] : never : never : never>
+] : Functions;
 /**
  * Applies all of the provided `functions` one-by-one in left-to-right order
  * starting from the `argument`.

package/pipe.js

@@ -16,8 +16,7 @@ function pipe() {
         var length = functions.length;
         var pipeline = arg;
         for (var index = 0; index < length; index += 1) {
-            var current = functions[index];
-            pipeline = current(pipeline);
+            pipeline = functions[index](pipeline);
         }
         return pipeline;
     };

package/types/effect.d.ts

@@ -2,8 +2,10 @@
  * @module Types
  */
 
+import type { VariadicFunction } from './function';
+
 /**
  * A simple side effect function descriptor.
  */
-export type Effect<Function extends (...args: any[]) => any> =
+export type Effect<Function extends VariadicFunction> =
   (...args: Parameters<Function>) => void

package/types/function.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Types
+ */
+
+/**
+ * A type of a function accepting exactly one argument
+ */
+export type UnaryFunction = (arg: any) => any
+
+/**
+ * A type of a function accepting an arbitrary amount of arguments
+ */
+export type VariadicFunction = (...args: any[]) => any

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { Map } from './map';
+export type { Last } from './last';
+export type { Slice } from './slice';
+export type { Tuple } from './tuple';
+export type { Effect } from './effect';
+export type { Gradual } from './gradual';
+export type { UnaryFunction, VariadicFunction } from './function';