纯函数可以返回一个随机时间后解析的承诺吗？

Question

I know this example is quite contrived but I am still curious wether or not this can be considered a pure function:

const addAsync = (x, y) => new Promise((resolve, reject) => {
    setTimeout(
        () => resolve(x + y),
        Math.random() * 1000
    );
});

Every call to this function returns a Promise that resolves to the sum of the two arguments. The promise resolves after a random amount of time between 0 and 1 seconds.

For all intends and purposes, this seems to be perfectly pure, meaning that I can treat this function in tests or in my code as a pure function (a, b) -> Promise(a + b) . However, since we are using Math.random() , we cannot transform this function into a lookup table and back without losing functionality (we lose the delay). So can this considered to be pure or not?

Answer 1

I believe it can be consider as a pure function. A pure function is defined as a function where the return value is only determined by its input values, without observable side effects.

In this case the output is only determined by its input and it doesn't produce any side effects. The fact that it takes different amount of time to compute the result should not have an effect on its pureness.

But i would warn that i am not a functional programming expert and i may be wrong

Answer 2

Let's clarify the term pure first. Purity means referential transparency, ie. one can replace an expression with its evaluated result without altering the behavior of the program. Here is an action that returns a promise. To visualize the computation I perform logging as a side effect:

 const addAsync = (x, y) => new Promise((r, e) => { setTimeout( z => (console.log(z), r(z)), Math.random() * 1000, x + y ); }); console.log("before"); addAsync(2, 3); console.log("after"); // logs "before" "after" 5 

Next I substitute the expression addAsync(2, 3) with its result, which is a fulfilled Promise containing 5 . Since there is no Promise literal in Javascript, I represent an already settled promise with Promise.resolve :

 console.log("before"); Promise.resolve(console.log(5), 5); console.log("after"); // logs "before" 5 "after" 

Looking at the code there seems to be no difference. The expression addAsync(2, 3) yields a settled promise (kind of like Promise(5) ). Promise.resolve(console.log(5), 5) on the other hand represents this very settled promise. But by observing the console.log side effects we can see that the evaluation order has changed, that is a function that returns a promise actually alters the behavior of a program. Hence such a function is impure.

Answer 3

No.

I would argue that the state the returned Promise is in, is unknown to us, just like the life of the cat of Schroedinger . The Promise is either resolved or rejected or pending, but we cannot predict when it is in what state. A snippet that outlines this:

 let a = 0;
 addAsync(1,2).then(res => a += res).then(console.log);
 addAsync(0, 1).then(res => a += res).then(console.log);

If addAsync would be pure, it would always log the same.

Answer 4

Simple answer is NO. But I offer a simple way to push the impurity elsewhere

In the pure part of your code

const incRandomDelay = addAsync.bind(null,1)

Now somewhere in the effects part of your code

incRandomDelay(10).then( sum => writeToFile(sum) )