Lazy evaluation, also known as call-by-need evaluation, is an evaluation strategy employed by Haskell. It means that expressions are not evaluated until their values are actually needed. This approach stands in contrast to eager evaluation, where all expressions are evaluated as soon as they are bound to variables.

In Haskell, lazy evaluation works as follows :

1. Delayed Evaluation : When a value is bound to a variable, it is not immediately evaluated. Instead, Haskell creates a thunk, which is a suspended computation representing the expression. The thunk holds the expression unevaluated until its value is required.

2. Non-Strict Evaluation : Haskell follows a non-strict evaluation policy, meaning that it evaluates expressions only when the results are demanded. When a value is needed, the thunk is forced, triggering its evaluation.

3. Memoization : Once a thunk is evaluated, Haskell remembers the computed value and replaces the thunk with the result. This memoization ensures that subsequent references to the same value are efficient, as the evaluation is not repeated.

4. Infinite Data Structures : Lazy evaluation enables the creation and manipulation of potentially infinite data structures in Haskell. Since values are only evaluated when needed, it is possible to work with sequences, streams, or lists that are conceptually infinite but are evaluated only as much as required by the program.

5. Control Flow : Lazy evaluation affects control flow in Haskell. It allows for powerful constructs such as infinite recursion, where a recursive function generates an infinite sequence by lazily generating each element as needed. Lazy evaluation also enables the use of control structures like "if-then-else" and "case" expressions, as only the relevant branch or pattern is evaluated.