A strong type system helps you catch compilation errors early on and point you in the right direction, but how far can we push it to express the correctness of our programs? In this talk, we'll explore what type level programming is and how we can leverage Scala's powerful type system not only to catch compilation errors, but begin supplying proofs of correctness to our programs. We'll take a stroll from programming at the value level to expressing our intentions at the type level.

1. Introduction to Type Level
Programming
Or: How to blame the Scala compiler when nothing works
Yuval Itzchakov
13/02/2018

2. YuvalItzchakov
2
• Developer @ Clicktale for the past 3 years
• Previously developer @ IDF (8200)
@yuvalitzchakov
https://stackoverflow.com/users/1870803/yuval-itzchakov
h http://asyncified.io
https://fpchat-invite.herokuapp.com/ (yuval.Itzchakov)

3. Agenda
3
• Type Level Programming In a Nutshell
• Show[A]
• Implicits
• Typeclass Pattern
• Generic Derivation

4. TypeLevelProgramming
4
• The compiler is the verification tool for our program.
• Can we make it do more?
• How about generating types at compile time for us?

5. TypeLevelProgramming
5
Giuseppe Peano

6. Show[A]
6
trait Show[A] {
def show(a: A): String
}
• Defines a string representation for a type.
• Allows us to define custom representations for closed types.

7. PrintingaArray[Byte]
7
We want to print a byte array:
val bytes = Array[Byte](30, 57, 92)
println(bytes) // [B@6615435c
On the other hand, given a Show instance:
val showBytes = new Show[Array[Byte]] {
override def show(arr: Array[Byte]): String = arr.map("%02X" format _).mkString(",")
}
println(showBytes.show(bytes)) // 1E,39,5C

8. Wherewe’regoing
8
Given any case class:
case class Person(firstName: String, lastName: String, age: Int)
We’ll be able to automatically derive a Show instance for it:
val p = Person("yuval", "itzchakov", 30)
val personShower: Show[Person] = ??? // Magic
personShower.show(p) // yuval, itzchakov, 30

9. Startingsimple
9
Let’s see how we define Show instances for primitive types

10. Nice,butalittleugly
10
• Can we do better?
• YES! IMPLICITS!
implicit val intEncoder: Show[Int] = new Show[Int] {
override def show(i: Int): String = i.toString
}

11. Implicits
11
• An implicit parameter is used to summon the Show[A] trait.
• Scala compiler searches for a suitable implicit in scope.
• If found, the compiler fills in the right instance at compile
time.
• Implicit resolution works recursively.

12. TypeclassPattern
13
• Defining common behavior for types, without
inheritance.
• Trait definition with a polymorphic type
• Concrete implicit instances
• Originated in Haskell
• A form of ad-hoc polymorphism (A.K.A
overloading)

13. TypeclassDefinition
14
Any method requiring the type class, asks for it implicitly from the
compiler:
def log[A](a: A)(implicit shower: Show[A]): String = {
shower.show(a)
}
println(log(10)) // log(10)(intEncoder) -> 10

14. TypeclassPattern
15
The implicit value must be in scope, otherwise:
Error:(45, 19) could not find implicit value for parameter
show: Show[Int]
println(log(10))

15. TypeclassPattern
16
Who uses the typeclass pattern?
• Scala Collections – Ordering[A], CanBuildFrom[A]
• Circe – Encoder[A] / Decoder[A]
• Avro4S – ToRecord[A] / FromRecord[A]
• Cats / Scalaz – Functor[A], Monoid[A], Applicative[A]
• Many more!

16. Canwedo better?
17
• Can the compiler resolve, based on existing primitive implicits,
more complex types?
• How about a Tuple2 of primitives?
type Person = (String, (String, Int))
type Person = Tuple2[String, Tuple2[String, Int]]

17. 18

18. RecursiveImplicitResolution
19
type Person = Tuple2[String, Tuple2[String, Int]]
implicit def tupleShow[Head, Tail](
implicit
headShow: Show[Head],
tailShow: Show[Tail])
Show[String]
Do I have an implicit for Tuple2?
Show[Tuple[String, Int]]
Recurse

19. RecursiveImplicitResolution
20
type Person = Tuple2[String, Tuple2[String, Int]]
Do I have an implicit for Tuple2?
implicit def tupleShow[Head, Tail](
implicit
headShow: Show[Head],
tailShow: Show[Tail])
Show[String]
Show[Int]

20. But…
21
• In real life, we usually don’t encode types as tuples
• And we want to abstract over arity (Tuple3, Tuple4,
TupleN)
• We really want to encode with case classes
• Can we do that?

21. Whatarecaseclasses,really?
22
• Named tuples on steroids.
• Compiler generated method implementations.
• Can be of any arity ( >= Scala 2.11).
• How do we deal with that? Can they be represented
generically?

22. Yes,wecan!
23
• Using HList (Heterogenous List)
• Heterogenous for holding different types
val hlist: ::[String, ::[Boolean, ::[Int, HNil]]] =
"Scala-IL" :: true :: 42 :: HNil
val meetUp: String = hlist.head // “Scala-IL”
val isItAwesome: Boolean = hlist.tail.head // true

23. 24

24. shapeless
25
“shapeless is a type class and dependent type based generic
programming library for Scala” (from GitHub).
• Provides us with a vast amount of building blocks for TLP
• Consumed by many popular libraries in the ecosystem:
• circe
• avro4s
• scodec
• spray

25. Interesting..
26
• Can we rework our example to derive a Show[A] instance
for any case class using HList?
• Let’s try!

26. Evolution
27
type Person = Tuple2[String, Tuple2[String, Int]]
case class Person(firstName: String, lastName: String, age: Int)
type Person =
shapeless.::[String, shapeless.::[String, shapeless.::[Int, HNil]]]

27. 28Confidential
• Implicit resolution error messages
• Use tek/splain (https://github.com/tek/splain)
• Things can become… complex
def collect[HL <: HList,
RL <: HList,
KL <: HList,
ZL <: HList]
(implicit
iso: LabelledGeneric.Aux[C, HL] ,
annot: Annotations.Aux[A, C, RL] ,
keys: Keys.Aux[HL, KL] ,
zip: Zip.Aux[KL :: RL :: HNil, ZL] ,
leftFolder: LeftFolder.Aux[ZL, B, Collector.type, B]): B
Limitations

28. 29Confidential
• Compile times – Take care of your implicit scope!
Limitations

29. 30Confidential
• You’re probably using it already
• Building codecs (JSON, Avro, XML, or custom)
• Abstracting over arity
• Updating nested data structured (lenses)
• Type safe casts (when you really must)
Where TLP Meets You

30. 31Confidential
• The Scala compiler is a powerful tool.
• We can leverage it to do amazing things, like generically derive
types for us.
• shapeless is a powerful building block in that process.
• Mixing it all together, type level programming becomes
immensely powerful.
Conclusion

31. 32Confidential
https://github.com/YuvalItzchakov/tlp-underscore
Presentation Code

32. 33Confidential
• The Type Astronaut’s Guide to Shapeless (Dave Gurnell)
https://github.com/davegurnell/shapeless-guide
• Daniel Spiewak – High Wizardy in the Land Of Scala
https://vimeo.com/28793245
• Aaron Levin – Mastering Typeclass Induction
https://www.youtube.com/watch?v=Nm4OIhjjA2o
• Li Haoyi - Implicit Design Patterns in Scala
http://www.lihaoyi.com/post/ImplicitDesignPatternsinScala.html
Resources

33. Thank you for listening!
Questions?