functional-programming-learning-path/javascript/referentially_transparent_function.js at master · imteekay/functional-programming-learning-path · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*
  If a function consistently yields the same result for the same input,
  it is referentially transparent.
*/

const square = (x) => x * x;

console.log(square(4)) /* 16 */
console.log(square(4)) /* 16 */
console.log(square(4)) /* 16 */
console.log(square(4)) /* 16 */

/*
  “well, doesn't every function return the same result for the same input?”.
  Consider this function that handle a random number
*/

const getRandomNumber = (max, min) => Math.random() * (max - min) + min;

getRandomNumber(10, 2)
getRandomNumber(10, 2)
getRandomNumber(10, 2)

/*
  referential transparency gives us the ability to freely replace an expression
  with its value and not change the behavior of the program.

  f(4) can be replaced with 16,
  g(4) can be replaced with 20,
  and the result is not changed.

  f(x) = x * x
  f(4) = 16

  g(x) = f(x) + x
  g(4) = f(4) + 4
  g(4) = 16 + 4
  g(4) = 20

  Pure functions + immutable data = referential transparency

  Some benefits:
    It makes it much easier to refactor and rewrite programs.
      - Since a pure, referentially transparent function can be freely replaced by it’s value,
        the only thing we have to worry about when we refactor it is that we get the same
        value for a given input.

      - The function doesn’t have any side effects or external dependencies.
        This lets us focus on refactoring the single function without having
        to worry about all the baggage associated with the function in the outside world.
*/