Is it pure?

index.js

// A: is this pure function?
function sum(a, b) { return a + b }
// B: is this a pure function?
const k = 2
function addK(a) { return a + k }
// C: is this a pure function?
function sub(a, b) { return sum(a, -b) }
// D: is this a pure function?
function sub(a, b, summer) { return summer(a, b) }
// E: is this a pure function?
var sum = (a, b) => a + b
function sub(a, b) { return sum(a, -b) }
// F: is this a pure function?
const sum = require('./sum')
function sub(a, b) { return sum(a, -b) }
// G: is this a pure function?
const foo = eval('(function sum(a, b) { return a + b })')
// H: is sub a pure function?
const K = 10
function sub(a, b) {
  return function () {
    return a - b + K
  }
}
// I: is sub a pure function?
// module sum.js
module.exports = {
  sum: function sum(a, b) { return a + b }
}
// module index.js
const sumThem = require('./sum').sum
function sub(a, b) {
  return sumThem(a - b)
}

B:
addK is pure, it does not rely on external state. k is a constant, than can be replaced with value in addK without side effects. If k was a dictionary and e.g. k.foo was referred, then addK would be impure

G:
Pure in this case, param to eval is a constant. Undecidable in the general case (I can make-up a case, where you pass something awfully coupled with external state to eval, that still happens to return a pure function).

C and D are tricky, because calling a function can be considered a side effect, even if the function being called is pure. C is also technically dependent on external state.

@gunar s definition really depends on your definition of side effect, which is a tricky subject in js because even accessing a property can be an observable interaction because of defineproperty and proxies

Thanks guys for trying, I think everything can be thought of pure if we rewrite top level sum by substituting external variables with their values. This is why I disagree with everyone at least in case of E: it is NOT pure.

// E: is this a pure function?
var sum = (a, b) => a + b
function sub(a, b) { return sum(a, -b) }
sub(10, 1) // 9
sum = (a,b) => 0
sub(10, 1) // 0

Function statements also have two states due to hoisting.

@bahmutov damn! Nice catch on E.

@jethrolarson I assume that every function has been hoisted already and we don't override functions with variables with same name