Does @memoize() need to be a function? It looks like we never parameterize it. Could we rewrite it to just do @memoize?

Updated.

This requires that arguments are serializable to JSON. A quick look at the algorithm's explanation (unofficial) shows that non-serializable arguments (such as a function) return 'null', which could lead to surprising bugs. Ideally we wouldn't have a serializability requirement and I think that's possible with some kind of recursive Map<first param, Map<second param, Map<..., result>>>.

That would be pretty complicated, so I think we should at least document the serializability requirement and possibly check the arguments to make sure they are serializable. For example, we could JSON.stringify() each arg and make sure the result is only 'null' if the actual value is null. There might be other cases, and getters might still cause confusion, but that would probably be "good enough" safety for what we're doing here.

Updated. PTAL

This seems quite involved, I'm wondering if we can simplify this by just checking if each argument serializes independently? For example:

function isJSONSerializable(values: unknown[]): boolean {
  for (const value of values) {
    if (JSON.stringify(value) === undefined) {
      return false;
    }
  }

  return true;
}

This probably isn't as thorough as your implementation, since it won't catch deeper issues ([0, NaN, 1], {foo: () => {}}, ...), but I think this would be good enough to catch mistakes like memoizing a callback function.

One other nit: If the function is checking multiple values, it should probably be named areJSONSerializable(). Alternatively it could just accept one parameter and @memoize could be responsible for iterating over the arguments and checking each one.

There are also some edge cases which likely can be encountered. For example passing a Set as argument which isn't take unlikely.

JSON.stringify(new Set([1])) 
'{}'
JSON.stringify({}) 
'{}'