Higher order function returns pure function

Question

Here's an example of an higher order function called functionA that has customValue as input and returns a function that gets an input and uses the custom value to elaborate a result:

let functionA = (customValue) => {
  let value = customValue || 1;
  return input => input * value;
};

Here's some results:

functionA()(4)             
// => returns 4

functionA(2)(4)
// => returns 8

functionA(3)(4)
// => returns 12

functionA(4)(4)
// => returns 16

Can the function returned by functionA be considered pure?

UPDATE: the examples above are only using numeric input. As described by @CRice, the returned function can be considered pure only when customValue is constant and doesn't have internal state (like classes).

Answer 1

Using this definition of Pure Function:

In computer programming, a pure function is a function that has the following properties:

1. Its return value is the same for the same arguments (no variation with local static variables, non-local variables, mutable reference arguments or input streams from I/O devices).

2. Its evaluation has no side effects (no mutation of local static variables, non-local variables, mutable reference arguments or I/O streams).

Then, no, functionA will not always return a pure function.

Here is a way to use functionA so that it does not return a pure function:

let functionA = (customValue) => {
  let value = customValue || 1;
  return input => input * value;
};

class Mutater {
  constructor() {
    this.i = 0;
  }
  valueOf() {
    return this.i++;
  }
}

const nonPureFunction = functionA(new Mutater());

// Produces different results for same input, eg: not pure.
console.log(nonPureFunction(10));
console.log(nonPureFunction(10));

As you can see, the returned function, when given the same input (10), produces a different result. This violates the first condition from the above definition (and using the same trick you could also violate the second).