Can I memoize retroactively?

Question

I have a function defined something like this:

f[x_] := Module[...];

I can easily write a memoized version of it like this:

f2[x_] := f2[x] = f[x];

And then replace every instance of f[...] with f2[...] in my code.

However, I have code that uses f directly in many places (the actual situation is more complicated: I have several such functions that call each other).

Can I retroactively memoize f? Something like this:

(* set ftemp to the original version of f *)
ftemp = f;
(* memoize the original f *)
f[x_] := f[x] = ftemp[x];

This (and several variants) don't work, probably because f is defined as := and = (ie, it's evaluated when called).

When I do ?f, I see the definition of f. If I could somehow copy this to ftemp, I think my trick above would work.

Any thoughts on how I could do this and/or solve the general problem of memoizing retroactively?

Answer 1

f[x_] := x^2

DownValues[h] = DownValues[f] /. f -> h;
f[x_] := f[x] = h[x]

h is now equal to the original f, and f is a memoized version of it.

Some kinds of definitions would require a more specific replacement rule than /. f -> h, for example recursive functions.