The document discusses the concept of parametricity in programming. Parametricity means that polymorphic functions behave consistently across all data types. The types of a polymorphic function serve as documentation for what it can and cannot do. Observing the types of a function reveals constraints on its possible implementations without looking at the implementation itself.

1. Parametricity
Shyamendra Solanki

2. Key Idea: Generalize Abstractions
 Generalize an abstraction because removing non-essential information
clarifies its independent meaning.
 Reuse is Accidental.

3. Parametricity: Definition
 parametricity is an abstract uniformity property enjoyed by parametrically
polymorphic functions, which captures the intuition that all instances of a
polymorphic function act the same way.

4. Types are documentation
 Parametricity is an efficient and reliable tool to assist code-readability to
assist non-trivial software in a team environment.
 A function is specified by its parametric type and its tests.
 Parametric Type: proof-positive
 Test: proof-negative

5. Observe the types
 def add10(n: Int): Int

6. What does the function do?
 def add10(n: Int): Int

7. What does the function do?
 def add10(n: Int): Int
 Theorem: it returns one of the 2^32 values of int.
 Otherwise, it would not have compiled.

8. What does the function do?
 def function(elements: List[Int]): List[Int]

9. What does the function do?
 def function(elements: List[Int]): List[Int]
 The number of potential implementations is HUGE.
 -> It can return list of prime numbers.
 -> It can add 17 to every 11th element.
 -> It can return empty list.
 -> It can concatenate list with itself.

10. What does the function do?
 def function(elements: List[Int]): List[Int]
 What if we make it polymorphic?

11. What does the function do?
 def function(elements: List[Int]): List[Int]
 i.e. Abstract over type of list.

12. What does the function do?
 def function[A](elements: List[A]): List[A]
 Theorem:
 Every element in output list comes from input list.
 Otherwise, it would not have compiled.

13. What does the function do?
 def function[A](elements: List[A]): List[A]
 Theorem:
 Every element in output list comes from input list.
 Otherwise, it would not have compiled.
 By adding freedom in types, we have constrained the implementations.

14. Parametricity works on language subset
 These things break parametricity:
 Null
 Exception
 isInstanceOf
 asInstanceOf
 Side effects
 toString, hashCode, equals
 Notify/wait
 classOf
 recursion

15. Observe the types
 def irrelevant[A, B](in: List[A]): List[B]

16. Observe the types
 def irrelevant[A, B](in: A): B

17. Observe the types
 def irrelevant[A](a: A): A

18. Observe the types
 def irrelevant[A](a: A): (A, A, A, A)

19. Observe the types
 def irrelevant[A](a, A: b: A): A

20. Observe the types
 def irrelevant[A](abcd:(A, A, A, A)): A

21. Observe the types
 def irrelevant[A](a: String, b: A): A

22. Observe the types
 def irrelevant[A, B](la: List[A], lb: List[B]): Option[A]

23. Observe the types
 def irrelevant[A, B](f: A => B, i: Int): A => (B, B)

24. Observe the types
 def irrelevant[A, B, C](f: A => B, g: B => C, a: A): C

25. Observe the types
 def irrelevant[A](maybe: Option[A]): List[A]

26. Observe the types
 def irrelevant[A](elements: List[A]): Int

27. Observe the types
 def irrelevant[A, B: Monoid](f: A => B, elements: List[A]): B

28. Observe the types
 def irrelevant[A, B, F: Monad](fa: F[A], fb: F[B]): F[B]

29. Observe the types
 def irrelevant[A, B, F: Functor](fab: F[A => B], a: A): F[B]

30. Types are documentation
 Use them to your advantage.