In computer programming, a pure function is a function that has the following properties:

Examples

Pure functions

The following examples of C++ functions are pure:

Impure functions

The following C++ functions are impure as they lack the above property 1: The following C++ functions are impure as they lack the above property 2: The following C++ functions are impure as they lack both the above properties 1 and 2:

I/O in pure functions

I/O is inherently impure: input operations undermine referential transparency, and output operations create side effects. Nevertheless, there is a sense in which a function can perform input or output and still be pure, if the sequence of operations on the relevant I/O devices is modeled explicitly as both an argument and a result, and I/O operations are taken to fail when the input sequence does not describe the operations actually taken since the program began execution. The second point ensures that the only sequence usable as an argument must change with each I/O action; the first allows different calls to an I/O-performing function to return different results on account of the sequence arguments having changed. The I/O monad is a programming idiom typically used to perform I/O in pure functional languages.

Memoization

The outputs of a pure function can be precomputed and cached in a look-up table. In a technique called memoization, any result that is returned from a given function is cached, and the next time the function is called with the same input parameters, the cached result is returned instead of computing the function again. Memoization can be performed by wrapping the function in another function (wrapper function). By means of memoization, the computational effort involved in the computations of the function itself can be reduced, at the cost of the overhead for managing the cache and an increase of memory requirements. A C program for cached computation of factorial ( aborts with an error message if its argument is false; on a 32-bit machine, values beyond cannot be represented anyway.

Compiler optimizations

Functions that have just the above property 2 – that is, have no side effects – allow for compiler optimization techniques such as common subexpression elimination and loop optimization similar to arithmetic operators. A C++ example is the method, returning the size of a string, which depends on the memory contents where the string points to, therefore lacking the above property 1. Nevertheless, in a single-threaded environment, the following C++ code can be optimized such that the value of is computed only once, before the loop. Some programming languages allow for declaring a pure property to a function:

Unit testing

Since pure functions have identical return values for identical arguments, they are well suited to unit testing.