Callbyneed

Call-by-need is a non-strict evaluation strategy used by some programming languages to delay computation of function arguments until their values are actually required, and to reuse the computed results thereafter. It is a form of lazy evaluation that adds memoization: once an argument is forced, its value is stored, and subsequent references reuse the stored value rather than re-evaluating the expression.

Implementation typically uses thunks—deferred computations—and a sharing mechanism. When the parameter is first demanded, the runtime evaluates the thunk and updates the reference to the resulting value; any later use of the argument accesses the stored value directly. In practice, many implementations use graph reduction or related techniques to track dependencies and sharing.

Relation to other strategies: Call-by-need is a refinement of call-by-name with memoization; unlike call-by-name, which may re-evaluate duplicates, call-by-need guarantees each expression is evaluated at most once. Compared to call-by-value, arguments are not evaluated until required, which can improve performance for expensive or unused arguments but may complicate reasoning about side effects.

Advantages: supports processing of infinite data structures and modular lazy composition; can reduce unnecessary work. Drawbacks: can cause space leaks due to unevaluated thunks accumulating; memory usage and unpredictable performance; reasoning about program behavior becomes harder in presence of side effects; interactions with strict IO or mutability require careful sequencing.

Examples: In a language with call-by-need, evaluating take 5 (map f [1..]) would force only as many elements as needed, and the results would be cached for reuse on subsequent accesses.