How about aligning these types with Map<K, V>?

Or maybe how about using Map compatible type for cache option, like Map<unknown, ReturnType<Fn>>? Then the users can get cache size like memoized.cache.size

Or maybe how about using Map compatible type for cache option, like Map<unknown, ReturnType<Fn>>? Then the users can get cache size like memoized.cache.size

Map<unknown, ReturnType<Fn>> is probably too restrictive, as I can't think of any reason to require things like forEach, clear, etc. to be implemented given they're not called internally, nor for implementation details like set returning this. It'd also place an unnecessary burden on consumers using non-Map-inherited cache implementations to implement new methods if the spec/TS types change.

Good point about size though, I'll try adding another type param to memoize to allow for accessing size and other props/methods where Map-inherited caches are used.

Fair enough. MemoizationCache type makes sense to me now

Types for memoizedFn.cache are now correct, but the internal type logic is kinda disgusting, and it's now compulsory to explicitly supply type params for LruCache, which is less-than-ideal:

const fn = (x: 1) => x;

// good (cache is Map<string, 1>)
memoize(fn);

// good (cache is Map<string, 1>)
memoize(fn, {});

// good (cache is Map<2, 1>)
memoize(fn, { getKey() { return 2 as const } });

// ok-ish but cache is now Map<any, any>
memoize(fn, {
  cache: new Map(),
});

// TS error "Type 'LruCache<unknown, unknown>' is not assignable to type 'MemoizationCache<string, 1>'."
memoize(fn, {
  cache: new LruCache(99),
});

// ok but more verbose
memoize(fn, {
  cache: new LruCache<string, 1>(99),
});

Any ideas on how to fix this without breaking type inference elsewhere would be much appreciated. Fixing it is like whack-a-mole — everything I've tried seems to either result in Key type becoming string where it should be something else (i.e. getKey's return type is something other than string, yet Key is inferred as string), types getting widened to any, unknowns refusing to narrow to something more specific, LruCache<K, V>s getting widened to MemoizationCache<K, V>, etc.