Is there a canonical definition of “pure” function? StackOverflow pointed me here, so the question might be a bit in a layman's terms.

Wikipedia defines pure functions as


  In computer programming, a function may be described as a pure
  function 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 or between different executions of the program, nor can it
  depend on any external input from I/O devices.
  Evaluation of the result does not cause any semantically observable side effect or
  output, such as mutation of mutable objects or output to I/O devices.
  


However it does not seem to cite any sources -- so it is hard to say whether this is an accepted definition, or who defined it this way.

When I look at what the languages do when they include a syntax/annotation for "pure" functions, there are quite a few different approaches:


In D the only limitation is non-mutation of global state. "Pure" functions can mutate its arguments.
In GCC there are two types of "pure": pure (no side-effects, but can read global state) and const (stricly pure as per wikipedia definition).
In C#, it is defined as "does not make any visible state changes" (whatever that is).
Haskell follows the Wikipedia definition.


So my question is: is there a canonical definition of pure function?
And if there is, what is its source?
As noted in this paper Imperative Functional Programming, (1993) by Peyton-Jones and Wadler (among the group of researchers that created Haskell):


  We focus on purely-functional solutions, which rule out side effects,
  for two reasons. Firstly, the absence of side effects permits
  unrestricted use of equational reasoning and program transformation...


the focus is on absence of side-effects to enable program transformations (i.e compiler optimisations).

What are side-effects? This paper in turn points to Integrating functional and imperative programming (1986) by Gifford and Lucassen, which mentions four types of effect classes: Pure, Function, Observer and Procedure. So, the term "pure function" derives from this paper.


  
  a PURE is referentially transparent: it does not cause side-effects,
  its value is not affected by side-effects, and it returns the same
  value each time it is evaluated.
  


Note, however, that Peyton-Jones and Wadler mentioned shortcomings in this approach. Worth noticing, they say, is the programming language Clean that uses linear types to introduce side-effects in a safe manner (i.e. safe for the compiler). Basically, it threads the World as a variable in all I/O related functions, including the main entry point.

With that, it is possible to have a pure functional language interacting with the world and having side-effects (I/O, the OS, the Windowing system, etc), contradicting partially your wikipedia definition. One can in fact say that Haskell has Clean as one of its influencers; although it departs from linear types and uses another type-level construct (monads) to guarantee linearity, i.e. a single-reference at all times.