When the function takes one primitive argument (number, string, boolean), a plain Map is the cleanest cache: O(1) lookup, structural equality on keys, and no JSON.stringify overhead. Memoizing a recursive function flips a naive O(2^n) Fibonacci to O(n) by sharing sub-results, which is why DP problems get a speed-up just by adding this wrapper. The body must recurse through fib (the memoized binding) rather than a self-referencing inner name, otherwise the recursion bypasses the cache. Use this version any time the input space is small and primitive.

Stringifying arguments (JSON.stringify(args)) is the lazy way to support many arguments, but it breaks for objects (key order), Functions, BigInts, and circular refs. A trie of nested Maps sidesteps all of that: each argument carves one layer deeper, and the leaf holds the cached value under a sentinel key. This also gives correct identity semantics for object arguments (two distinct {} are different keys, just like in a normal Map). The trade-off is memory: every distinct prefix of arguments allocates a Map, so for cheap functions the overhead can outweigh the benefit.

The unbounded Map cache leaks memory in long-running services where the input space is huge or unbounded (per-request URLs, user IDs, file paths). Promoting the just-accessed key to the end of the Map's insertion order on every hit, then evicting keys().next().value when the size exceeds max, gives you a correct LRU in eight extra lines. JavaScript Map preserves insertion order specifically so this pattern works without extra data structures. Tune max based on the size of the cached values and the working-set size of your traffic.