Memoize.function: fix cross-closure cache collision

[yannrichet]

Bug

Memoize.function(fun)'s cache (R.cache::loadCache/saveCache) keys purely on the call arguments -- not on which fun is being wrapped. Two independent Memoize.function(fun) wrappers that happen to share the default cache suffix and are called with the same argument value will collide: the second wrapper silently gets served the first wrapper's cached result instead of ever evaluating its own fun.

Reproduced:

make_fun <- function(offset) function(x) x + offset
f1 <- Memoize.function(make_fun(3000))
f2 <- Memoize.function(make_fun(4000))
f1(5)  # 3005 (correct)
f2(5)  # 3005 -- WRONG, should be 4005. Silently returned f1's cached value.

Where this actually bites

This is exactly the shape produced by wrapping a fresh closure in a loop over several models/datasets -- e.g. cristalgo's EGRI/EGRIw/WEGRI robust-inversion algorithms, which do mesh_exsets(f = Memoize.function(fi), ...) once per seed inside a for (seed in ...) loop, where fi closes over that seed's own fitted Kriging/WarpKriging model. Since root()'s bisection deterministically probes similar midpoints over the same fixed input domain across seeds, a later seed's fi(xi) can be silently served an earlier seed's stale cached value at the same xi.

root() assumes f is a single, self-consistent function throughout its bisection; a corrupted value breaks that invariant. root() also has no working recursion-depth guard (max.rec defaults to NA, so isTRUE(rec > max.rec) never fires), so a single bad value is enough to make it recurse until R's node/pointer-protection stack overflows -- observed in practice as a Slurm job hanging 80+ minutes with zero progress on one seed (while 9 other seeds using the identical code completed normally in under a minute each). Confirmed by reproducing the exact hung state and showing that (a) the underlying model's predict() and the wrapped criterion function are both fast and well-behaved in isolation, (b) the same call through mesh_exsets() reproduces the hang, and (c) removing only the Memoize.function() wrapper (or, as here, fixing it) makes the identical call complete normally.

Fix

Each call to Memoize.function() now gets its own private cache namespace (.memoize_id, generated once per wrapping via tempfile() and folded into the cache key), so independent wrappings can never collide regardless of argument overlap. The documented single-wrapper behavior (F <- Memoize.function(f); F(5); F(6); F(5) -- second F(5) hits cache) is unchanged; verified with identical() before/after.

🤖 Generated with Claude Code

https://claude.ai/code/session_01A5w4ZLUZpoHhtsbGyWcVtc