MathGroup Archive 2008

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

Search the Archive

Re: Pure functions?

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

In case what I wrote was not entirely clear: the point about Church's  
and Mathematica's notion of "pure function" is that you can "apply it"  
at "the same time" as "defining it" as in :

Function[x, x^2][3]

As you can see - there was no separate function definition and  
application. Compare this with

f[x_] := x^2

It is not the absence of name but the absence of separation between  
definition and application that matters.
Andrzej Kozlowski

On 31 Oct 2008, at 23:34, Andrzej Kozlowski wrote:

> 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 established.
> 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
> f[x_]:=x^2
> 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:
> f=Function[x,x^2]
> 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: Sum[n^(-n), {n, 1, Infinity}]
  • Previous by thread: Re: Pure functions?
  • Next by thread: Re: newbie question