High Wizardry in the Land of Scala

High Wizardry in the Land
of Scala
Daniel Spiewak

Agenda

• Higher-Kinds
• Typeclasses
• Type-Level Encodings
• Continuations

Higher-Kinds

• What is a “kind system”?

Higher-Kinds

• What is a “kind system”?
• What is a “type system”?

A type system is a tractable syntactic method for
proving the absence of certain program behaviors
by classifying phrases according to the kinds of
values they compute. – Benjamin Pierce

val i: Int = 42
val j: Int = 21

val s: String = "foo"

val f: Int => String = { _.toString }

val xs: List[Int] = List(1, 1, 2, 3, 5, 8)

Higher-Kinds

• Type systems classify values
• Kind systems classify types
• Values are to types as types are to kinds

type Int :: *

type String :: *

type (Int => String) :: *

type List[Int] :: *

type List :: ???

type Function1 :: ???

type List :: * => *

type Function1 :: (* × *) => *

// id : Int => Int
def id(x: Int) = x

// Id :: * => *
type Id[A] = A

// id : ((Int => Int), Int) => Int
def id(f: Int => Int, x: Int) = f(x)

// Id :: ((* => *) × *) => *
type Id[A[_], B] = A[B]

val map: Map[Option[Any], List[Any]] = Map(
Some("foo") -> List("foo", "bar", "baz"),
Some(42) -> List(1, 1, 2, 3, 5, 8),
Some(true) -> List(true, false, true, true))

// ugly cast!
val xs: List[String] =
map(Some("foo")).asInstanceOf[List[String]]

// ditto!
val ys: List[Int] =
map(Some(42)).asInstanceOf[List[Int]]

val map: HOMap[Option, List] = HOMap[Option, List](
Some("foo") -> List("foo", "bar", "baz"),
Some(42) -> List(1, 1, 2, 3, 5, 8),
Some(true) -> List(true, false, true, true))

// blissful type safety!
val xs: List[String] = map(Some("foo"))

// ditto!
val ys: List[Int] = map(Some(42))

// HOMap :: ((* => *) × (* => *)) => *
class HOMap[K[_], V[_]](delegate: Map[K[Any], V[Any]]) {
def apply[A](key: K[A]): V[A] =
delegate(key.asInstanceOf[K[Any]]).asInstanceOf[V[A]]
}

object HOMap {
def apply[K[_], V[_]](tuples: (K[Any], V[Any])*) =
new HOMap[K, V](Map(tuples: _*))
}

(credit: Jorge Ortiz)

Higher-Kinds
• Kind systems classify types
• Values are to types as types are to kinds
• “Higher” kinds are the kinds of type
constructors
• Type functions
• Use any time one type is logically a function
of another

Typeclasses

• Forget everything you know about classes
• (it won’t help you anyway)
• Instead of “class”, think “category”
• If you’ve ever looked at Haskell…

sum(List(1, 2, 3, 4)) // => 10
sum(List(3.14, 2.72)) // => 5.86
sum(List("me", "you")) // shouldn't compile!

trait Num[A] {
val zero: A

def add(x: A, y: A): A
}

def sum[A](nums: List[A])(tc: Num[A]) =
nums.foldLeft(tc.zero)(tc.add)

object IntNum extends Num[Int] {
val zero = 0

def add(x: Int, y: Int) = x + y
}

object DoubleNum extends Num[Double] {
val zero = 0d

def add(x: Double, y: Double) = x + y
}

// works!
sum(List(1, 2, 3, 4))(IntNum)
sum(List(3.14, 2.72))(DoubleNum)

Typeclasses

• This is functional, but ugly
• We have to explicitly provide the relevant
instance of Num[A]

def sum[A](nums: Seq[A])(tc: Num[A]) =

def sum[A](nums: Seq[A])(implicit tc: Num[A]) =

implicit object IntNum extends Num[Int] {
val zero = 0

def add(x: Int, y: Int) = x + y
}

implicit object DoubleNum extends Num[Double] {
val zero = 0d

def add(x: Double, y: Double) = x + y
}

sum(List(1, 2, 3, 4))(IntNum)
sum(List(3.14, 2.72))(DoubleNum)

sum(List(1, 2, 3, 4))
sum(List(3.14, 2.72))

Typeclasses

• Typeclasses are categories of types
• If you have a set of types with well-deﬁned
commonalities, think about typeclasses
• Collections in 2.8
• Numeric in 2.8

Type-Level Encodings

• Kinds make our types into superheroes
• Typeclasses allow us to abstract over types
• How can we abuse our new-found power?


• Kinds make our types into superheroes
• Typeclasses allow us to abstract over types
• How can we abuse our new-found power?
• Maybe…data structures at the type level?


• HList is a linked-list implemented in types

• …and values
• Sort of like Tuple, but unbounded

import HList._

val xs = 42 :: "foo" :: 3.14 :: HNil

xs.head // => 42: Int
xs.tail.head // => "foo": String

val xs1 = 42 :: false :: HNil
val xs2 = "Hello" :: "World" :: HNil

val xs = xs1 ++ xs2

xs.head // => 42: Int
xs.tail.tail.head // => "Hello": String

object HList {
sealed trait HList {
type Head
type Tail <: HList
type Append[L <: HList] <: HList

def head: Head
def tail: Tail

def ++[L <: HList](xs: L): Append[L]
}

// ...
}

val x: List[Int] = ...
val y: List[Int] = ...

x ++ y

x 1 2 3 4

y 5 6 7 8 9


x ++ y

x 2 3 4

y 5 6 7 8 9


x ++ y

x 3 4

y 5 6 7 8 9


x ++ y

x 4

y 5 6 7 8 9


x ++ y

x’

y 5 6 7 8 9


x ++ y

x’ 4

y 5 6 7 8 9


x ++ y

x’ 3 4

y 5 6 7 8 9


x ++ y

x’ 2 3 4

y 5 6 7 8 9


x ++ y

x’ 1 2 3 4

y 5 6 7 8 9

object HList {
// ...

final class HNil extends HList {
type Head = Nothing
type Tail = Nothing
type Append[L <: HList] = L

def head = error("Head of an empty HList")
def tail = error("Tail of an empty HList")

def ::[A](a: A) = HCons(a, this)

def ++[L <: HList](xs: L) = xs
}

val HNil = new HNil
}

object HList {
// ...

case class HCons[A, B <: HList](head: A, tail: B)
extends HList {

type Head = A
type Tail = B

type Append[L <: HList] =
HCons[Head, Tail#Append[L]]

def ::[C](c: C) = HCons(c, this)

def ++[L <: HList](xs: L) =
head :: (tail ++ xs)
}

type ::[A, B <: HList] = HCons[A, B]
}

• What about an nth(Int) function?

• Not today!
• Church Numerals
• λ-Calculus

• Not today!
• Church Numerals
• λ-Calculus
• We could do a lot more
• Just not in a 45 minute talk

Continuations

• Actually, delimited continuations
• Very different from plain continuations!
• Not like callcc
• Not considered harmful
• …though they can simulate goto!

case class JumpException(i: Int)
extends RuntimeException

val res = try {
val i = 42
println("before")

throw JumpException(i) // basically: `break`

val j: Int = i / 2

println("after")
println(j + 2)
j // needed for type checker
} catch {
case JumpException(i) => i
}

println("outside")

val (res, func) = {
val i = 42
println("before")

(i, { j: Int =>
println("after")
println(j + 2)
})
}

println("outside")
func(res / 2)
func(res / 6)

val (res, func) = reset {
val i = 42
println("before")

val j = shift { (k: Int => Unit) => (i, k) }

println("after")
println(j + 2)
}

println("outside")
func(res / 2)
func(res / 6)

def gen() = {
var x = 1
var y = 1

while (true) {
shift { (k: Unit => Result) => Result(x, k) }
y += x
x = y - x
}
}

val res = reset {
gen()
error("It never ends that way, too!"): Result
}

val fib: Stream[Int] = res.toStream

(credit: PEP-255)

Continuations

• This is cool and all, but what’s it good for?

Continuations

• Not as much as you would think

reset {
for (i <- 0 to 10) {
shift { (k: Unit => Unit) => i }
}
}

Continuations

• Not as much as you would think
• Nonblocking I/O
• Multi-page wizards
• Framework support is needed

Conclusion

• Higher-Kinds • Type Encodings
• Classify types • Are really cool!

• Typeclasses • Continuations
• Categorize types • Powerful

• ...but useless

High Wizardry in the Land of Scala

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (6)

Similar to High Wizardry in the Land of Scala

Similar to High Wizardry in the Land of Scala (20)

Recently uploaded

Recently uploaded (20)

High Wizardry in the Land of Scala

Editor's Notes