MathGroup Archive 2008

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Pure functions?

  • To: mathgroup at
  • Subject: [mg93247] Re: [mg93204] Pure functions?
  • From: Andrzej Kozlowski <akoz at>
  • Date: Sat, 1 Nov 2008 05:07:21 -0500 (EST)
  • References: <>

Mathematica's notion of "pure-function" is the same as the  
mathematical (or logical) notion of function in Alonzo Church's lambda- 
calculus. Such a function is determined by a set of bound variables  
and a body which may contain free variables (same as what you call  
parameters). This always has the form: Function[{variables},body].  
Mathematica's function Function[{x,y},x^2+y^2] (2 bound variables) or  
Function[{x,y},x^2+ k y^2] (2 bound variables and one free variable)  
are exactly the same as functions in lambda-calculus. This (though not  
necessarily the name "pure function") has been standard in logic since  
1936, rather longer than computers and programming languages.
Wikipedia's definition refers only to one meaning of pure function in  
connection with computers - this meaning is much newer and much less  

Anonymous functions are a somewhat different matter. They are merely a  
matter of convenience and allow one to avoid having to choose names  
both for the functions themselves and for bound variables. Using names  
for bound variables is not only inconvenient but also somewhat  
deceptive, since Function[x, x^2] and Function[y, y^2] are exactly the  
same function, but different as Mathematica expressions. Using  
Function[#^2] or #^2 & is not only more compact but also less  
ambiguous (in the case of complex expression using named bound  
variables it may not be easy to see if they are the same functions or  
not. Note that evaluating
Function[x, x^2] == Function[y, y^2]
will not tell you that.

I do not know how standard is the Mathematica usage of "pure" in this  
context. In other functional languages pure functions are usually  
simply called functions, but that is because they normally have only  
"pure functions". Mathematica, however, also has "functios" defined by  
means of patterns


so there was a need to distinguish the two kinds. The word "anonymous"  
does refer to this distinction, in fact a pure function may have a name:


and, in any case, "anonymous" normally refers not only to the fact  
that the function does not have a name but that the bound variables  
have unique standard names #1, #2,....

That's all, I think, there is to this issue and the Wikipedia article  
seems to me a bit or a red herring.

Andrzej Kozlowski

On 31 Oct 2008, at 17:05, AES wrote:

> This is a follow-on to the thread "Notation using # with exponents and
> &", renamed to focus on the question in the Subject line.
> In asking questions about the term pure function, I'm not trying to be
> contentious or argumentative.  I'm just trying to learn a bit about  
> the
> concept.
> When I search on this term in Google, Wikipedia is the first hit that
> comes up, with the opening statement:
> --------------------
>   In computer programming, a function may be described as pure
>   if both these statements about the function hold:
>   1. 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 I/O devices.
>   2. 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.
>   The result value need not depend on all (or any) of the argument
>   values. However, it must depend on nothing other than the
>   argument values.
> ---------------------
> I appreciate that Wikipedia is not always authoritative; and its
> coverage of this particular topic is neither lengthy nor particularly
> detailed.  Still, it's what's in there, at the moment.
> The Mathematica documentation for & opens with:
> ---------------------
>   'body &' is a pure function. The formal parameters are
>   # (or #1), #2, etc.
> ---------------------
> and then shortly thereafter:
> ---------------------
>   When Function[body] or body& is applied to a set of arguments,
>   # (or #1) is replaced by the first argument, #2 by the second,
>   and so on. #0 is replaced by the function itself.
> ---------------------
> So let's consider the constructs:
>        f1 = #1^3 + #2^4 &
>        f2 = #1^x + #2^y &
> both of which function perfectly well (I think) as pure functions in  
> the
> Mathematica sense.
> My initial (and admittedly naive) interpretation is that f1 is also a
> pure function per the Wiki definition, because  it "always evaluates  
> the
> same result value given the same argument value(s)" and "the function
> result value [does not] depend on any hidden information or state that
> may change as program execution proceeds" (unless of course someone
> goes so far as to redefine the meanings of "3" or of "4"!).
> The function f2 is not pure in the Wiki sense, however (at least,  
> that's
> my again admittedly naive interpretation), because f2[arg1,arg2] can
> give very different results when used in different parts of a program,
> since its result depends on "hidden" information (hidden in some  
> sense,
> anyway) about the values that may have been assigned to the  
> parameters x
> and y elsewhere in the program.
> And, given the quotes from the Mathematica definition, it seems clear
> that x and y are not "formal parameters" or accessible "arguments" of
> the function  f2.  So, the result of f2 does clearly "depend on
> [something] other than [just] the argument values".
> Finally, Mathematica seems to put some focus on the _unnamed_ (or
> "anonymous") property of its pure functions, while the Wiki statement
> makes no mention at all of this.
> So, what _is_ the real story on "pure functions"?

  • Prev by Date: Re: Pure functions?
  • Next by Date: Re: Pure functions?
  • Previous by thread: Re: Pure functions?
  • Next by thread: Re: Pure functions?