fix(types): avoid inferring memo return type from key option

src/curry/memo.ts

@@ -1,3 +1,5 @@
+import type { NoInfer } from 'radashi'
+
 type Cache<T> = Record<string, { exp: number | null; value: T }>
 
 function memoize<TArgs extends any[], TResult>(
@@ -56,7 +58,7 @@ export interface MemoOptions<TArgs extends any[]> {
  */
 export function memo<TArgs extends any[], TResult>(
   func: (...args: TArgs) => TResult,
-  options: MemoOptions<TArgs> = {},
+  options: MemoOptions<NoInfer<TArgs>> = {},
 ): (...args: TArgs) => TResult {
   return memoize({}, func, options.key ?? null, options.ttl ?? null)
 }

src/types.ts

@@ -37,6 +37,13 @@ export type ExtractNotAny<T, U> = Extract<[T] extends [Any] ? never : T, U>
 export type SwitchAny<T, U> = [T] extends [Any] ? U : T
 export type SwitchNever<T, U> = [T] extends [never] ? U : T
 
+/**
+ * Prevent type inference on type `T`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546
+ */
+export type NoInfer<T> = [T][T extends any ? 0 : never]
+
 /**
  * Extract types in `T` that are assignable to `U`. Coerce `any` and
  * `never` types to unknown.

tests/curry/memo.test-d.ts

@@ -0,0 +1,18 @@
+import * as _ from 'radashi'
+
+describe('memo return type', () => {
+  test('memo with single argument key function', () => {
+    const foo = _.memo((a: string, b?: string) => {}, { key: a => a })
+    expectTypeOf(foo).toEqualTypeOf<
+      (a: string, b?: string | undefined) => void
+    >()
+  })
+
+  test('memo with two argument key function', () => {
+    const foo = _.memo((a: string, b?: string) => {}, { key: (a, b) => a })
+    expectTypeOf(foo).toEqualTypeOf<
+      (a: string, b?: string | undefined) => void
+    >()
+    foo('a')
+  })
+})