2. 1.
2.
3.
4.
5.
6.
7.
8.

3. https://github.com/vpavkin/
recursive-implicit-proofs-talk

7. Ordering[A]
implicit val intOrdering = new
Ordering[Int] {…}

8. def sortBy[B](f: A => B) (implicit ord:
Ordering[B])
//or
def sortBy[B: Ordering](f: A => B)
implicit val intOrdering = …
implicit def optOrdering[T:Ordering] =
new Ordering[Option[T]] { … }
// Ok
implicitly[Ordering[Option[Int]]]
// Can’t prove
implicitly[Ordering[Option[String]]]

11. // type A = Int
implicit val intOrdering: Ordering[Int] = …

12. // type B = Option[A]
implicit def optOrdering[A]
(implicit ev: Ordering[A]): Ordering[Option[A]] = …

13. // type C = (A, B)
implicit def tuple2Ordering[A, B]
(implicit A: Ordering[A],
B: Ordering[B]): Ordering[(A, B)] = …
implicit def contravariantOrdering[A, B]
(implicit C: Converts[A, B],
O: Ordering[B]): Ordering[A] =

14. implicit def ordered[C <% Comparable[C]]: Ordering[C] = …
implicit def comparatorToOrdering[C]
(implicit cmp: Comparator[C]): Ordering[C] = …
A => C
+
B => C
Avoid ambiguous implicits!

15. You can’t ask for an absence of implicit

16. 1 -> Container(Option(Container("a")))
(Int, Container[Option[Container[String]]])
String Container[String] Option[Container[String]]
Container[Option[Container[String]]] (Int, Container[Option[Container[String]]])
A A => B
Ord[T] => Ord[Container[T]]
A => B
Ord[T] => Ord[Option[T]]
A => B
Ord[T] => Ord[Container[T]]
A & B => C
Ord[A] & Ord[B] => Ord[(A,B)]
Int
A

18. Scala List shapeless.HList
Root type List HList
Cons
case class ::[A](
head: A,
tail: List[A])
case class ::[H, T <: HList](
head: H,
tail: T)
Nil Nil (singleton) HNil (singleton)
Type of
1 :: Nil
::[Int] Int :: HNil
Type of
1 :: “a” :: Nil
::[Any] Int :: String :: HNil
Type of
1 :: “a” :: true ::
Nil
::[Any] Int :: String :: Boolean :: HNil

19. •
•
•
•
•

20. final class HListOps[L <: HList](l : L) {
def at[N <: Nat](implicit at: At[L, N]): at.Out = at(l)
}
•
•
•
•
•

21. case class Person(name: String, age:Int)  String :: Int :: HNil
(Int, Boolean)  Int :: Boolean :: HNil
•
•
2nd most important property (along with keeping precise types):

25. OddProduct[Int :: String :: Boolean :: Int :: Int :: HNil]
Int :: HNil Boolean :: Int :: Int :: HNil
Int :: String:: Boolean :: Int :: Int :: HNil
A => B
Odd[T <: HList] => Odd[H1 :: H2 :: T]
A => B
Odd[T <: HList] => Odd[H1 :: H2 :: T]
A
Odd[T :: HNil]
Recursive step – resolving to the same implicit def

28. Generic.Aux[T, Repr] – Isomorphism, that
allows us to get Repr from T and vice versa.
Repr – some generic representation of T
Property[Repr] – our Property is proved for
type Repr.
We can (almost always) derive the
Property[T] by converting to/from Repr
and using Property[Repr]
Hint:
Repr here is going to be
an HList
Looks similar to
A & B => C.
Let’s encode the proof!

30. Person(name: String, age: Int)
Int :: HNil
A & B => C
Show[A] & Show[B] => Show[A :: B]
Int
A
Show[Int]
HNil
A
Show[HNil]
String
A
Show[String]
String :: Int :: HNil
A & B => C
Show[A] & Show[B] => Show[A :: B]
Generic.Aux[Person, String :: Int :: HNil]
A (macro)
Generic[T]
Person
A & B => C
Show[R] & Generic.Aux[T,R] => Show[T]

32. 1.
2.
3.
4.
5.

35. 1.
2.
3.
4.
5.
6.