How can you optimize closure performance using memoization?

A closure's memoize() method wraps it in a caching layer that stores the result of each unique set of input arguments the first time it's computed, so subsequent calls with the same arguments return the cached result instead of recomputing it - useful for expensive, pure computations called repeatedly with a limited set of distinct inputs.

Because the cache is keyed on the exact argument values, memoization only helps when calls genuinely repeat with the same inputs; applying it to a closure whose arguments are essentially always unique adds caching overhead with little or no benefit, since nothing is ever actually reused from the cache.

Groovy also provides memoizeAtMost and memoizeAtLeast variants that bound the cache's size, which matters for long-running processes where an unbounded cache built from unbounded distinct inputs would otherwise grow indefinitely and become its own memory problem.

Memoization is best applied to genuinely pure functions - if the closure has side effects or depends on external mutable state beyond its arguments, caching by argument value alone can silently return a stale or simply wrong result on a later call where that external state has since changed.