From the comp.lang.functional FAQ:
-
- The term "purely functional" is often used to describe languages that perform all their computations via function application. This is in contrast to languages, such as Scheme and Standard ML, that are predominantly functional but also allow `side effects' (computational effects caused by expression evaluation that persist after the evaluation is completed).
-
- Sometimes, the term "purely functional" is also used in a broader sense to mean languages that might incorporate computational effects, but without altering the notion of `function' (as evidenced by the fact that the essential properties of functions are preserved.) Typically, the evaluation of an expression can yield a `task', which is then executed separately to cause computational effects. The evaluation and execution phases are separated in such a way that the evaluation phase does not compromise the standard properties of expressions and functions. The input/output mechanisms of Haskell, for example, are of this kind.
Any subset of a language that describes only values and transformations upon them may be considered
purely functional. This can be done by separating evaluation and execution, e.g. by allowing the language to conveniently describe and calculate values that describe executions, but not allowing them to execute without being hit with an executional primitive (such as a 'Just do it!' imperative).
The language as a whole may be considered
purely functional if it
only allows the description of values and transformations upon them.
In contrast: An
ImpureFunctionalLanguage, as used presently, is one that provides functional capabilities but also allows the mixing of evaluation and execution -- e.g. if you can put a 'print' statement inside a calculation, and that print statement is executed when that calculation is evaluated, then the language is impure.
LispLanguage,
SchemeLanguage, and
ObjectiveCaml are impure. An
ImperativeLanguage is any that allows description of evaluation by describing
what to do or
how to do it. Any language with
MutableState (as in: mutable by the programmer) is necessarily Imperative. A
PureImperativeLanguage would be one that defines all evaluations in terms of executions, and forbids you to describe things in terms of
what you want... allowing, instead, only descriptions of
what to do. Assembler language and
CeeLanguage are decent examples of
PureImperativeLanguages.
HaskellLanguage is nearly a
PureFunctionalLanguage, excepting only the special treatment it gives functions returning an IO type called from a function named "main". By standardizing that particular use, it allows one to describe execution by assignment of a description of execution to a special name.
See also
FunctionalProgrammingLanguage,
PurelyFunctional
CategoryFunctionalProgramming