Pure Functions

📄 Wiki page | 🕑 Last updated: Apr 19, 2022

A pure function is a function which:

  1. is referentially transparent - it will always return the same output for the same input

  2. have no side effects - it doesn't affect the outside world

Example (JavaScript)

function calc(num) {
  return num + 42

This function is reasonably pure - it always returns the same output for the same input and it produces no side effects.

How about this:

let factor = 2
function calc(num) {
  return factor * (num + 42)

If the factor would never change, this function could also be considered pure. And const declaration can help us with that:

const factor = 2

OK, that's better. But that only works because numbers are immutable in JS.

What if we have something like this:

cost o = {factor: 42}
function calc(num) {
  return o.factor * (num + 42)

Objects are mutable in Javascript, and to make matters worse, their prototypes are also mutable. In such a language, it's very hard to guarantee anything.

Things like immutable.js (implementation of persistent data structures) can help us to get closer, but keep in mind that in a practical sense, purity is a spectrum, not a binary thing.


Both the referential transparency and the lack of side effects make pure functions much easier to reason about.

Other benefits: better composability, unit testing, parallelization, easier debugging, etc.


The biggest challenge with writing pure functions is separating/isolating the side effects from the pure code. See Functional core, imperative shell for more on this topic.

See also:

Ask me anything / Suggestions

If you have any suggestions or questions (related to this or any other topic), feel free to contact me. ℹī¸

If you find this site useful in any way, please consider supporting it.