typed curry function

src/__tests__/curry.spec.ts

@@ -1,22 +1,32 @@
-import { curry } from "../curry";
+import {curry} from "../curry";
 
 describe("curry", () => {
   it("returns a curried sum function", () => {
-    const sum = curry((a, b, c, d) => a + b + c + d);
-    expect(sum(1, 2, 3, 4)).toEqual(10);
+    const sum = curry((a: number) => a + 10);
+    expect(sum(1)).toEqual(11);
+
+    const sum2 = curry((a: number, b: number) => a + b);
+    expect(sum2(1, 2)).toEqual(3);
+
+    const sum3 = curry((a: number, b: number, c: number) => a + b + c);
+    expect(sum3(1, 2, 3)).toEqual(6);
+
+    const sum4 = curry((a: number, b: number, c: number, d: number) => a + b + c + d);
+    expect(sum4(1, 2, 3, 4)).toEqual(10);
   });
 
   it("returns a function if you miss the params", () => {
     const sum = curry((a: number, b: number, c: number, d: number) => a + b + c + d);
-
     const sum1 = sum(1);
     const sum2 = sum1(2);
     const sum3 = sum2(3);
-    expect(sum3(4)).toEqual(10);
+    const sum4 = sum3(4);
+
+    expect(sum4).toEqual(10);
   });
 
   it("combines the two approaches and still returns correct values", () => {
-    const sum = curry((a, b, c, d) => a + b + c + d);
+    const sum = curry((a: number, b: number, c: number, d: number) => a + b + c + d);
 
     const sum1 = sum(1, 2);
     const sum2 = sum1(3);

src/__tests__/has.spec.ts

@@ -0,0 +1,8 @@
+import {has} from "../has";
+
+describe("has", () => {
+  it("checks if object has a property", () => {
+    expect(has('name', {name: 'John'})).toEqual(true);
+    expect(has('surname', {name: 'John', surname: undefined})).toEqual(false);
+  });
+});

src/curry.ts

@@ -1,11 +1,70 @@
-export const curry = <F extends (...args: any) => any>(fn: F) => {
-  const result = args => {
+export interface CurryFunction1<T1, R> {
+  (arg1: T1): R;
+}
+
+export interface CurryFunction2<T1, T2, R> {
+  (arg1: T1): CurryFunction1<T2, R>;
+
+  (arg1: T1, arg2: T2): R;
+}
+
+export interface CurryFunction3<T1, T2, T3, R> {
+  (arg1: T1): CurryFunction2<T2, T3, R>;
+
+  (arg1: T1, arg2: T2): CurryFunction1<T3, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3): R;
+}
+
+export interface CurryFunction4<T1, T2, T3, T4, R> {
+  (arg1: T1): CurryFunction3<T2, T3, T4, R>;
+
+  (arg1: T1, arg2: T2): CurryFunction2<T3, T4, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3): CurryFunction1<T4, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4): R;
+}
+
+export interface CurryFunction5<T1, T2, T3, T4, T5, R> {
+  (arg1: T1): CurryFunction4<T2, T3, T4, T5, R>;
+
+  (arg1: T1, arg2: T2): CurryFunction3<T3, T4, T5, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3): CurryFunction2<T4, T5, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4): CurryFunction1<T5, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): R;
+}
+
+export interface CurryFunction6<T1, T2, T3, T4, T5, T6, R> {
+  (arg1: T1): CurryFunction5<T2, T3, T4, T5, T6, R>;
+
+  (arg1: T1, arg2: T2): CurryFunction4<T3, T4, T5, T6, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3): CurryFunction3<T4, T5, T6, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4): CurryFunction2<T5, T6, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): CurryFunction1<T6, R>;
+
+  (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6): R;
+}
+
+
+export function curry<T1, R>(fn: (arg1: T1) => R): CurryFunction1<T1, R>;
+export function curry<T1, T2, R>(fn: (arg1: T1, arg2: T2) => R): CurryFunction2<T1, T2, R>;
+export function curry<T1, T2, T3, R>(fn: (arg1: T1, arg2: T2, arg3: T3) => R): CurryFunction3<T1, T2, T3, R>;
+export function curry<T1, T2, T3, T4, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): CurryFunction4<T1, T2, T3, T4, R>;
+export function curry<T1, T2, T3, T4, T5, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => R): CurryFunction5<T1, T2, T3, T4, T5, R>;
+export function curry<T1, T2, T3, T4, T5, T6, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => R): CurryFunction6<T1, T2, T3, T4, T5, T6, R>;
+export function curry(fn: Function) {
+  return function curried(...args: any[]) {
     if (args.length >= fn.length) {
       return fn(...args);
+    } else {
+      return (...args2: any[]) => curried(...args, ...args2);
     }
-    return (...secArgs) => result([...args, ...secArgs]);
   };
-
-  return (...args) => result(args);
-};
-
+}

src/has.ts

@@ -1,7 +1,8 @@
-import { curry } from './curry';
+import {curry} from './curry';
 
 type IHas = {
   <T extends object>(property: keyof T): (object: T) => boolean;
   <T extends object>(property: keyof T, object: T): boolean;
 }
-export const has: IHas = curry((property, obj) => !!obj[property]);
+
+export const has: IHas = curry(<T extends object>(property: keyof T, obj: T) => !!obj[property]);

src/lenses/lens.ts

@@ -1,7 +1,7 @@
 import { curry } from '../curry';
 import { prop } from '../prop';
 import { path } from '../path';
-import { Optional, ValueOf } from '../common';
+import { ValueOf } from '../common';
 import { assoc } from '../assoc';
 import { assocPath } from '../assocPath';
 
@@ -34,4 +34,3 @@ export const over = curry((lens, fn, obj) => set(lens)(fn(view(lens)(obj)))(obj)
 export const lensProp = (key: string) => lens(prop(key), assoc(key));
 
 export const lensPath = (key: string[]) => lens(path(key))(assocPath(key));
-