Referential Transparency
You'll learn why expressions that can be swapped with their values make functional code predictable and optimizable.
What It Means
Referential transparency is a property where an expression can be replaced by its resulting value without changing the program's behavior. If calling a function with the same inputs always returns the same output and produces no side effects, that call is referentially transparent.
Think of it like math: in y = 2 + 3, you can replace 2 + 3 with 5 anywhere, and nothing changes. You never worry that adding 2 and 3 might print something, modify a global variable, or return different values on different days.
Why It Matters
Reasoning: When expressions are referentially transparent, you can substitute equals for equals—just like algebra. You don't need to track hidden state or execution order. The expression add(2, 3) means the same thing everywhere.
Optimization: Compilers can freely:
- Cache results (memoization)
- Reorder computations
- Eliminate redundant calls
If compute(x) is referentially transparent, calling it twice with the same x is wasteful—the compiler can call it once and reuse the result.
Examples in Context
Referentially transparent:
square(5) // always 25, no side effects
Not referentially transparent:
getTimestamp() // different value each call
print("Hi") // side effect: output
Referential transparency builds directly on pure functions and immutability—the foundation you learned earlier. Pure functions guarantee referential transparency; mutable state breaks it.
Key Takeaway:
Referential transparency means expressions behave like values—predictable, replaceable, and safe to optimize without changing program meaning.