การทำเคอร์รีและการประกอบคลอเชอร์

You already know closures as anonymous blocks of code. Groovy also lets you transform closures themselves — fixing arguments, chaining them, and caching results — for powerful functional patterns.

Currying creates a new closure with some arguments pre-filled. The result takes the remaining arguments. This turns a general function into a specialized one.

Call curry to bind the leftmost arguments.

Use rcurry to fix the rightmost argument and ncurry to fix one at a specific index.

The >> and << operators compose closures so the output of one feeds the next, forming a pipeline.

f >> g means apply f first then g, while f << g applies g first. Pick the direction that reads naturally.

memoize wraps a closure so repeated calls with the same arguments return a cached result instead of recomputing — ideal for expensive pure functions.

Variants like memoizeAtMost and memoizeAtLeast cap cache size so memory stays bounded.

Because closures are first-class, you can store them in maps and select behaviour at runtime — a clean replacement for big switch statements.

For deep recursion, trampoline converts recursive closure calls into a loop, avoiding stack overflow.

A closure resolves unqualified names against its delegate. Setting resolveStrategy to DELEGATE_FIRST lets you build DSL blocks where calls target a configured object — the basis of builders.

You learned advanced closure techniques:

• curry/rcurry/ncurry pre-bind arguments
• >> and << compose closures into pipelines
• memoize caches results of pure functions
• Closures stored in maps act as runtime strategies
• trampoline makes deep recursion stack-safe