Improved flow type

.flowconfig

@@ -6,6 +6,8 @@
 
 [options]
 
+experimental.strict_call_arity=true
+
 # Provides a way to suppress flow errors in the following line.
 # Example: // $FlowFixMe: This following line is borked because of reasons.
 suppress_comment= \\(.\\|\n\\)*\\$FlowFixMe

src/index.js

@@ -1,22 +1,22 @@
 // @flow
-type EqualityFn = (a: any, b: any) => boolean;
+type EqualityFn = (a: mixed, b: mixed) => boolean;
 
-const simpleIsEqual = (a: any, b: any): boolean => a === b;
+const simpleIsEqual: EqualityFn = (a: mixed, b: mixed): boolean => a === b;
 
-export default function (resultFn: Function, isEqual?: EqualityFn = simpleIsEqual) {
-  let lastThis: any;
-  let lastArgs: Array<any> = [];
-  let lastResult: any;
+export default function <ResultFn: (...Array<any>) => mixed>(resultFn: ResultFn, isEqual?: EqualityFn = simpleIsEqual): ResultFn {
+  let lastThis: mixed;
+  let lastArgs: Array<mixed> = [];
+  let lastResult: mixed;
   let calledOnce: boolean = false;
 
-  const isNewArgEqualToLast = (newArg, index) => isEqual(newArg, lastArgs[index]);
+  const isNewArgEqualToLast = (newArg: mixed, index: number): boolean => isEqual(newArg, lastArgs[index]);
 
-    // breaking cache when context (this) or arguments change
-  return function (...newArgs: Array<any>) {
+  // breaking cache when context (this) or arguments change
+  const result = function (...newArgs: Array<mixed>) {
     if (calledOnce &&
-            lastThis === this &&
-            newArgs.length === lastArgs.length &&
-            newArgs.every(isNewArgEqualToLast)) {
+      lastThis === this &&
+      newArgs.length === lastArgs.length &&
+      newArgs.every(isNewArgEqualToLast)) {
       return lastResult;
     }
 
@@ -26,4 +26,7 @@ export default function (resultFn: Function, isEqual?: EqualityFn = simpleIsEqua
     lastResult = resultFn.apply(this, newArgs);
     return lastResult;
   };
-}
+
+  // telling flow to ignore the type of `result` as we know it is `ResultFn`
+  return (result: any);
+}

test/index.js

@@ -482,5 +482,23 @@ describe('memoizeOne', () => {
       expect(add.callCount).to.equal(2);
     });
   });
+
+  describe('flow typing', () => {
+    it('should maintain the type of the original function', () => {
+      // this test will create a flow error if the typing is incorrect
+      type SubtractFn = (a: number, b: number) => number;
+      const subtract: SubtractFn = (a: number, b: number): number => a - b;
+      const requiresASubtractFn = (fn: SubtractFn): number => fn(2, 1);
+
+      const memoizedSubtract: SubtractFn = memoizeOne(subtract);
+
+      // will cause a flow error if `fn` is not of type `SubtractFn`
+      const result1 = requiresASubtractFn(memoizedSubtract);
+      const result2 = requiresASubtractFn(memoizeOne(subtract));
+
+      expect(result1).to.equal(1);
+      expect(result2).to.equal(1);
+    });
+  });
 });