Pure function

The following examples of C++ functions are pure:

• floor, returning the floor of a number;
• max, returning the maximum of two values.
• the function f, defined as

void f() {
  static std::atomic<unsigned int> x = 0;
  ++x;
}

Although this code sample looks like it is not pure, it actually is. The value of x can be only observed inside other invocations of f(), and as f() does not communicate the value of x to its environment, it is indistinguishable from function void f() {} that does nothing. Note that x is std::atomic so that modifications from multiple threads executing f() concurrently do not result in a data race, which has undefined behavior in C and C++.

Pure functions can be implemented in Wolfram Language using # to refer to inputs and & to indicate the end of the function. For example, the following code defines the Factorial function, such that Factorial[n] is equivalent to n!.[5]

Factorial = If[#1 == 1, 1, #1 #0[#1 - 1]] &

#1 refers to the first input, while #0 refers to the function itself, making a pure recursive function simple to implement.

The following C++ functions are impure as they lack the above property 1:

• because of return value variation with a non-local variable

int f() {
  return x;
}

For the same reason, e.g. the C++ library function sin() is not pure, since its result depends on the IEEE rounding mode which can be changed at runtime.

• because of return value variation with a mutable reference argument

int f(int* x) {
  return *x;
}

• because of inconsistent defined/undefined behavior:

void f() {
  static int x = 0;
  ++x;
}

Overflow of a signed integer is an undefined behavior per C++ specification. Also, if f() is called concurrently, the code exhibits a data race. Pure functions can fail or never return, but they must do this consistently (for the same input). However, f() may, or may not, fail, depending on whether the upper bound of allowed signed int value was reached or a data race happens, or not.

The following C++ functions are impure as they lack the above property 2:

• because of mutation of a local static variable

void f() {
  static int x = 0;
  ++x;
}

• because of mutation of a non-local variable

void f() {
  ++x;
}

• because of mutation of a mutable reference argument

void f(int* x) {
  ++*x;
}

• because of mutation of an output stream

void f() {
  std::cout << "Hello, world!" << std::endl;
}

The following C++ functions are impure as they lack both the above properties 1 and 2:

• because of return value variation with a local static variable and mutation of a local static variable

int f() {
  static int x = 0;
  ++x;
  return x;
}

• because of return value variation with an input stream and mutation of an input stream

int f() {
  int x = 0;
  std::cin >> x;
  return x;
}