Bxdty

The two conditions that define a function as pure are as follows:

1. No side effects (i.e. only changes to local scope are allowed)


2. Always return the same output, given the same input

If the first condition is always true, are there any times the second condition is not true?

I.e. is it really only necessary with the first condition?

Here are a few counterexamples that do not change the outer scope but are still considered impure:

• function a() { return Date.now(); }


• function b() { return window.globalMutableVar; }


• function c() { return prompt("you choose"); }


• 
  function d() { return Math.random(); } (which admittedly does change the PRNG, but is not considered observable)

Accessing non-constant non-local variables is enough to be able to violate the second condition, the function doesn't need to have any side effect itself if it is going to be affected by other side effects.

You could have a source of randomness from outside the system. Say part of your calculation includes the room temperature. Executing the function will yield different results each time (depending on the external random element) but you don't really change the state of your program by executing it.

All I can think of, anyway.

It seems to me that the second condition you have described is a weaker constraint than the first.

Let me give you an example, suppose you have a function to add one that also logs to the console:

function addOneAndLog(x) {

  console.log(x);

  return x + 1;

}

The second condition you supplied is satisfied: this function always returns the same output when given the same input. It is, however, not a pure function because it includes the side effect of logging to the console.

A pure function is, strictly speaking, a function that satisfies the property of referential transparency. That is the property that we can replace a function application with the value it produces without changing the behaviour of the program.

Suppose we have a function that simply adds:

function addOne(x) {

  return x + 1;

}

We can replace addOne(5) with 6 anywhere in our program and nothing will change.

By contrast, we cannot replace addOneAndLog(x) with the value 6 anywhere in our program without changing behaviour because the first expression results in something being written to the console whereas the second one does not.

We consider any of this extra behaviour that addOneAndLog(x) performs besides returning output as a side-effect.

I would say that the point 2 (Always return the same output, given the same input) is not a condition but a consequence of point 1 : a function without side effects will always return the same output given the same input.