Pure function
From Wikipedia, the free encyclopedia
In computer programming, a function may be described as pure if both these statements about the function hold.
- The function always evaluates the same result value given the same argument value(s). The function result value cannot depend on any hidden information or state that may change as program execution proceeds, nor can it depend on any external input from IO devices.
- Evaluation of the result does not cause any semantically observable side effect or output, such as mutation of mutable objects or output to IO devices.
Note that it is not a requirement that the result value is dependent on all (or any) of the argument values. The requirement is that it should be dependent on nothing other than the argument values.
Contents |
[edit] Examples of pure functions
sin(x), returning the sine of a number x
length(s), returning the size of a string s
encrypt(d), running an encryption algorithm on a piece of data d
[edit] Examples of impure functions
today() is impure because at different times it will yield different results: it refers to some global state.
Similarly, any function that uses global state or a static variable is potentially impure.
random() is impure because each call potentially yields a different value. (This is because pseudorandom generators use and update a global "seed" state. If we modify it to take the seed as an argument, i.e. random(seed); then random becomes pure, because multiple calls with the same seed value returns the same random number.)
printf() is impure because it causes output as an effect.
[edit] Pure expressions
Pure functions are required to construct pure expressions. Constant expressions are pure by definition. An expression consisting of a function subexpression applied to one or more argument subexpressions is pure if both these statements about the subexpressions hold.
- The function and argument subexpressions are pure expressions.
- The function subexpression yields a pure function.
Typically the function subexpression is simply a function identifier. Pure expressions are often referred to as being referentially transparent.
Evaluation of a given pure expression will yield the same result regardless of when or how many times evaluation occurs during program execution. This property is what makes it meaningful to talk about an expressions "value". It also makes it possible to replace an expression with the corresponding value (or it with an equivalent alternative expression) without changing the meaning of a program.
[edit] Impure functions in pure expressions
The definitions above still allow some laxity with regard to purity. It is possible for a pure expression to yield an impure function (or more generally a value which contains one or more impure functions).
It is also possible for an expression to be pure even if one or more of the argument subexpressions yields an impure function (or a value which contains one or more impure functions). In this case the impure function(s) in the argument must not be applied during evaluation (but may be incorporated in the result somehow). However, dealing with programs that have impure and pure functions to be mixed like this can quite difficult in practice, so purely functional programming languages do not allow impure functions to be defined.
