This document discusses referential transparency and how embracing functional programming principles can improve code quality. Referential transparency means that replacing an expression with one that evaluates to the same value does not change the program. This allows for optimizations like memoization and parallelization. The document advocates using monads to model effects as first-class values in a pure language in order to separate pure and effectful code in a type-safe way.

1. What Referential Transparency can
do for you

2. What exactly is referential
transparency?

3. Referential transparency is mostly
synonymous with purity, meaning
lack of side-effects

4. As functional programmers we want to avoid
side-effects.
But what exactly is a side-effect?

5. No mutability?
Always returns the same thing given the same
input?
Definition of a pure function

6. def sum(list: List[Int]): Int = {
launchNukes()
list.foldLeft(0)(_ + _)
}
Is this pure?

7. def sum(list: List[Int]): Int = {
var z = 0
for (i <- list) {
z += i
}
z
}
Is this pure?

8. Referential transparency just means
that exchanging a term for any other
term that refers to the same entity
does not change the program.

9. def sum(list: List[Int]): Int = {
var z = 0
for (i <- list) {
z += i
}
z
}
Is this referentially transparent?

10. sum(List(1,2,3)) + sum(List(1,2,3))
val x = sum(List(1,2,3))
x + x
Are these two programs equivalent?

11. - Testability! Pure functions are extremely easy to test
- Know when and where our effects occur.
- Both you and the compiler now have guarantees that your code can be
reasoned with, this makes refactoring a walk in the park.
Why is this useful?

12. - Memoization; If we can guarantee a function to always return the same
thing given the same input, the compiler can easily memoize the result.
- Parallelization; Without sharing state, we can easily run multiple functions in
parallel without having to worry about deadlocks or data races.
- Common Subexpression Elimination; The compiler can know exactly when
multiple expressions evaluate to the same value and can optimize this away
Potential optimizations

13. Effectful and non-effectful code
should be separated!

14. - C++’s constexpr
- Fortran’s PURE FUNCTION
- D’s pure
Examples

15. impure def launchNukes(): Unit = {
... //call impure code here
}
impure def main(): Unit = {
sum(List(1,2,3))
launchNukes()
}
Impurity annotations!

16. Then what about async?

17. async impure def launchNukes(): Unit = {
... //call impure code here
}
async impure def main(): Unit = {
sum(List(1,2,3))
await launchNukes()
}
Async annotations!

18. We’d need to add language feature
for every different kind of effect

19. Effects shouldn’t be “to the side”, they
should be first class values that we can
supply to our runtime.
Realization:

20. type Effect = () => Unit
type Effects = List[SideEffect]
def main(): Effects = List(
() => println(“Launching Nukes”),
() => launchNukes()
)
How should we model our effects?

21. type Effects = List[Any => Any]
def performSideEffects(effs: Effects): Unit = {
effs.foldLeft(())((acc, cur) => cur(acc))
}
def main(): Effects = List(
_ => localStorage.getItem("foo"),
foo => println(foo),
_ => new Date().getFullYear(),
year => println(year) //no access to foo here
)
Hmmmm...

22. trait Effect[A] {
def chain[B](f: A => Eff[B]): Eff[B]
}
def main(): Effect[Unit] =
localStorage.getItem("foo")
.chain(foo => putStrLn(foo))
Let’s try again!

23. trait IO[A] {
def flatMap[B](f: A => IO[B]): IO[B]
}
def main(): IO[Unit] = for {
foo <- localStorage.getItem("foo")
_ <- putStrLn(foo)
date <- Date.currentYear()
_ <- putStrLn(s"It's $date, $foo")
} yield ()
Expressed differently

24. We accidentally invented Monads!

25. class SimpleIO[A](unsafeRun: () => A) extends IO[A] {
def flatMap[B](f: A => SimpleIO[B]): SimpleIO[B] =
SimpleIO(() => f(unsafeRun()).unsafeRun())
}
object SimpleIO {
def pure(a: A): SimpleIO[A] =
SimpleIO(() => a)
}
Most simple implementation

26. Monads allow us to treat
computations as values that can be
passed around as first-class citizens
within the pure host language

27. Where can I find this?
- cats-effect IO
- Monix Task
- fs2

28. Eliminating only some side-effects can
only get us so far.
Only by fully embracing purity can we
achieve the safety we’re looking for.
Conclusion

29. Thank you for listening!
Twitter: @LukaJacobowitz