Pure vs. Impure values

In FP, we frequently talk about purity & impurity of values.
In this brief post, we’ll brush up our concepts of the same, along with some examples.

What could an impure value be?

@ val pureFunctionValue: Int => String = (i) => s"$i was entered"
pureFunctionValue: Int => String = ammonite.$sess.cmd7$$$Lambda$2092/943512909@25533bba

@ pureFunctionValue(42)
res8: String = "42 was entered"

@ val impureFunctionValue: Int => String = (i) => { println("now executing some side effecting code"); s"$i was entered" }
impureFunctionValue: Int => String = ammonite.$sess.cmd9$$$Lambda$2116/1958462067@a0d875d

@ impureFunctionValue(42)
now executing some side effecting code
res10: String = "42 was entered"

As we can see, a value is pure, if it conforms very strictly to its type. In case of pureFunctionValue the declared type said that it was a function which takes an Int and returns a String, and that was indeed what it did. It could take an Int and it gave us back a reference to a String value and did nothing else.

In case of impureFunctionValue the declared type said that it was a function which takes an Int and returns a String. Indeed we could feed it an Int, but when we did so, it did something else apart from returning us a String. It printed stuff out to the console. This, friends, was not expressed in the type, thus it is a side-effect of the function and thus the value in question is impure, and not exactly a function in the mathematical sense.

Another Impure Value

@ val randomValuesGenerator = new scala.util.Random
randomValuesGenerator: scala.util.Random = scala.util.Random@13087c75

@ randomValuesGenerator.nextInt
res20: Int = -1981430922

@ randomValuesGenerator.nextInt
res21: Int = 666650962

Here, randomValuesGenerator is an impure value again. Because, when we called the same function again on it, a different result was returned. Thus, nextInt is not really a function on randomValuesGenerator in the mathematical sense, because, otherwise, in all its invocations, it would’ve returned us the exact same result. Thus it is an impure value because it doesn’t exactly do what it says it does.

Let’s convert randomValuesGenerator.nextInt to a function value and see what its type is:

@ val x = randomValuesGenerator.nextInt _
x: () => Int = ammonite.$sess.cmd22$$$Lambda$2151/374123858@738ae785

So apparently, randomValuesGenerator.nextInt is a function, to which we can apply the unit value and get back an Int. Let’s do it.

@ x()
res24: Int = -2068951855

@ x()
res25: Int = -1255655781

As we can see, we applied the same value () (the only instance of Unit, by the way) to x and got back different results. It’s doing something else apart from returning us an Int. Maybe it’s mutating its own internal state. That, friends, is a side effect that x is performing on itself. Hence, x is an impure value and not exactly a function in the mathematical sense. IOW, x is a liar!

There. We built a little model for thinking about pure/impure values and we’ll use it for thinking about more complex FP ideas.
If you guys want to explore further into this topic, you can explore What Purity Is and Isn’t.
Stay tuned for more!