Improving Correctness With Type - Goto Con Berlin

Improving Correctness
with Types
GOTO Berlin December 2015

Iain Hull
iain.hull@workday.com
@IainHull
http://workday.github.io

What is a function ?
f
x y
Domain Range

Never use nulls … period
“Null references, my billion dollar mistake”
- Tony Hoare, QCon 2009

case class Customer(name: String,
preferredCurrency: String) {
require(Currency.isValid(preferredCurrency))
}
val customer = Customer(name = "Joe Bloggs",
preferredCurrency = "TXL")
This is an airport?

class Currency private (val code: String) extends AnyVal
object Currency {
val USD: Currency = new Currency("USD")
val EUR: Currency = new Currency("EUR")
// ...
def from(code: String): Option[Currency] = ???
}

preferredCurrency: Currency)
def creditCardRate(customer: Customer): BigDecimal = {
if (customer.preferredCurrency == "USD")
BigDecimal("0.015")
else
BigDecimal("0.025")
}
Always false

import org.scalactic.TypeCheckedTripleEquals._
if (customer.preferredCurrency === "USD")
BigDecimal("0.015")
else
BigDecimal("0.025")
}
Does not compile

import org.scalactic.TypeCheckedTripleEquals._
if (customer.preferredCurrency === Currency.USD)
BigDecimal("0.015")
else
BigDecimal("0.025")
}

val order: Order = ???
val customer: Customer = ???
val creditCardCharge = order.amount + creditCardRate(customer)
Eeek this a bug

class MoneyAmount(val amount: BigDecimal) extends AnyVal {
def + (rhs: MoneyAmount): MoneyAmount =
new MoneyAmount(amount + rhs.amount)
def - (rhs: MoneyAmount): MoneyAmount =
new MoneyAmount(amount - rhs.amount)
def * (rhs: Rate): MoneyAmount =
new MoneyAmount(amount * rhs.size)
}
class Rate(val size: BigDecimal) extends AnyVal {
def * (rhs: Rate): MoneyAmount = rhs * this
}

val order: Order = ???
val customer: Customer = ???
val creditCardCharge = order.amount + creditCardRate(customer)
Does not compile

Using wrapper types
• Do not abuse primitives
• Control the available values
• Control the available operations
• Move validation to the correct place

def average(items: List[Int]): Int = items.sum / items.size
scala> average(List(5))
res1: Int = 5
scala> average(List(5, 10, 15))
res2: Int = 10
scala> average(List())
java.lang.ArithmeticException: / by zero
at .average0(<console>:8)
... 35 elided

import org.scalactic.Every
def average(items: Every[Int]): Int = items.sum / items.size
scala> average(Every(5))
res1: Int = 5
scala> average(Every(5, 10, 15))
res2: Int = 10
scala> average(Every())
<console>:10: error: not enough arguments for method apply:
(firstElement: T, otherElements: T*)org.scalactic.Every[T] in
object Every.
Unspecified value parameters firstElement, otherElements.
average(Every())

import org.scalactic.Every
def average(items: Every[Int]): Int = items.sum / items.size
def average(first: Int, rest: Int*): Int =
average(Every(first, rest: _*))
scala> average(5)
res1: Int = 5
scala> average(5, 10, 15)
res2: Int = 10
scala> average()
<console>:11: error: not enough arguments for method average:
(first: Int, rest: Int*)Int.
Unspecified value parameters first, rest.
average()

def describeSomeList(items: List[Int]): String = {
val ave = average(items)
s"A list with average $ave"
}
Does not compile

def maybeNonEmpty(items: List[Int]): Option[Every[Int]] = {
items match {
case head :: tail => Some(Every(head, tail))
case Nil => None
}
}
scala> maybeNonEmpty(List(5, 10, 15))
res1: Option[Every[Int]] = Some(Every(5, 10, 15))
scala> maybeNonEmpty(List())
res2: Option[Every[Int]] = None

val ave = average(items)
s”A list with average $ave"
}
maybeNonEmpty(items) match {
case Some(is) =>
val ave = average(is)
s"A list with average $ave"
case None =>
"An empty list"
}
}
Does not compile

Non empty lists
• Some lists cannot be empty
• Tell the compiler
• One-plus-var-args idiom

Agent Id Type Status Host In Use By
A01 1 Active 10.0.0.1
A02 1 Failed 10.0.0.2 J01
A03 2 Active 10.0.0.3 J03
A04 2 Waiting 10.0.0.4
Job Id Type Status Submitted By Processed By
J01 1 Waiting Fred
J02 1 Active Wilma A01
J03 2 Complete Barney A03
Jobs
Agents

case class Agent(agentId: String,
jobType: Int,
host: String,
port: Int,
status: String, // Waiting | Active | Failed
maybeLastAccessed: Option[DateTime],
inUse: Boolean,
maybeInUseBy: Option[String])
case class Job(referenceId: String,
jobType: Int,
status: String, // Waiting | Active | Complete
submittedBy: String,
submittedAt: DateTime,
maybeStartedAt: Option[DateTime],
maybeProcessedBy: Option[String],
maybeCompletedAt: Option[DateTime])

case class Agent(agentId: String,
jobType: JobType,
address: AgentAddress,
status: AgentStatus,
lastAccessed: Option[DateTime],
inUse: Boolean,
maybeInUseBy: Option[String])
case class Job(referenceId: String,
jobType: JobType,
status: JobStatus,
submittedBy: User,
maybeProcessedBy: Option[String],

sealed abstract class JobType(val value: Int)
case object SmallJob extends JobType(1)
case object LargeJob extends JobType(2)
case object BatchJob extends JobType(3)
sealed abstract class AgentStatus(val value: String)
case object AgentWaiting extends AgentStatus("Waiting")
case object AgentActive extends AgentStatus("Active")
case object AgentFailed extends AgentStatus("Failed")
sealed abstract class JobStatus(val value: String)
case object JobWaiting extends JobStatus("Waiting")
case object JobActive extends JobStatus("Active")
case object JobCompelete extends JobStatus("Complete")
case class AgentAddress(host: String, port: Int)
case class User(name: String)

import tag.@@
trait Foo
def onlyFoo(value: String @@ Foo): String = s"It a foo: $value"
scala> onlyFoo("simple string")
<console>:13: error: type mismatch;
found : String("simple string")
required: tag.@@[String,Foo]
(which expands to) String with tag.Tagged[Foo]
onlyFoo("simple string")
^
scala> val foo = tag[Foo]("Foo String")
foo: tag.@@[String,Foo] = Foo String
scala> onlyFoo(foo)
res2: String = It a foo: Foo String
def anyString(value: String): String = s"Just a string: $value”
scala> anyString(foo)
res6: String = Just a string: Foo String

case class Agent(agentId: String @@ Agent,
jobType: JobType,
address: AgentAddress,
status: AgentStatus,
lastAccessed: Option[DateTime],
inUse: Boolean,
maybeInUseBy: Option[String @@ Job])
case class Job(referenceId: String @@ Job,
jobType: JobType,
status: JobStatus,
submittedBy: User,
maybeProcessedBy: Option[String @@ Agent],

case class Job(referenceId: String @@ Agent,
jobType: JobType,
status: JobStatus,
submittedBy: User,
maybeProcessedBy: Option[String @@ Job],
Waiting | Active | Complete

def recordCompletionMetrics(job: Job): Unit = {
for( startedAt <- job.maybeStartedAt ;
completedAt <- job.maybeCompletedAt ) {
writeJobEvent(
event = "Completed",
time = completedAt,
referenceId = job.referenceId,
waitingTime = (startedAt - job.submittedAt),
executionTime = (completedAt - startedAt))
}
}

def recordCompletionMetrics(job: Job): Unit = {
require(job.status = JobComplete)
require(job.maybeStartedAt.isDefined)
require(job.maybeCompletedAt.isDefined)
for (startedAt <- job.maybeStartedAt ;
completedAt <- job.maybeCompletedAt ) {
writeJobEvent (
time = completedAt,
waitingTime = (startedAt - job.submittedAt),
executionTime = (completedAt - startedAt))
}
}

sealed trait Job {
def referenceId: String @@ Job
def status: JobStatus
def submittedBy: User
def submittedAt: DateTime
}
case class WaitingJob(referenceId: String @@ Job,
submittedBy: User,
submittedAt: DateTime)
extends Job {
val status: JobStatus = JobWaiting
}

sealed trait Job {
}
case class ActiveJob(referenceId: String @@ Job,
submittedBy: User,
startedAt: DateTime,
processedBy: String @@ Agent)
extends Job {
val status: JobStatus = JobActive
}

sealed trait Job {
}
case class CompleteJob(referenceId: String @@ Job,
submittedBy: User,
startedAt: DateTime,
processedBy: String @@ Agent,
completedAt: DateTime)
extends Job {
val status: JobStatus = JobComplete
}

def recordCompletionMetrics(job: CompleteJob): Unit = {
writeJobEvent(
time = job.completedAt,
waitingTime = (job.startedAt - job.submittedAt),
executionTime = (job.completedAt - job.startedAt))
}

Algebraic data types
• Simply sealed traits and case classes
• Exposes the shape of your data
• Use this shape to control possible states

trait Handle {
def name: Name
def owner: User
}
trait Data {
def stream: InputStream
}
trait Storage {
def create(name: Name, owner: User,
data: InputStream): Handle
def find(name: Name): Option[Handle]
def read(handle: Handle): Try[Data]
}

case class HandleImpl(id: Long,
name: Name,
owner: User) extends Handle
case class DataImpl(stream: InputStream) extends Data
class StorageImpl extends Storage {
// ...
def read(entryDesc: Handle): Try[Data] = {
require(entryDesc.isInstanceOf[HandleImpl])
val impl = entryDesc.asInstanceOf[HandleImpl]
dataStore.read(impl.id)
}

val riakStorage: Storage = ???
val maybeData = for {
handle <- riakStorage.find(someName)
data <- riakStorage.read(handle).toOption
} yield data

val memoryStorage: Storage = ???
data <- memoryStorage.read(handle).toOption
} yield data
IllegalArgumentException

trait HandleLike {
def name: Name
def owner: User
}
trait DataLike {
def stream: InputStream
}
trait Storage {
type Handle <: HandleLike
type Data <: DataLike
def create(name: Name, owner: User,
data: InputStream): Handle
def find(name: Name): Option[Handle]
def read(handle: Handle): Try[Data]
}

private[impl] class StorageImpl extends Storage {
type Handle = HandleImpl
type Data = DataImpl
case class HandleImpl(id: Long,
name: Name,
owner: User) extends HandleLike
case class DataImpl(stream: InputStream) extends DataLike
// ...
def read(entryDesc: Handle): Try[Data] = {
dataStore.read(entryDesc.id)
}
}

val memoryStorage: Storage = ???
} yield data
error: type mismatch;
found : handle.type (with underlying type riakStorage.Handle)
required: memoryStorage.Handle
^

val riakStorage1: Storage = ???
val riakStorage2: Storage = ???
handle <- riakStorage1.find(someName)
data <- riakStorage2.read(handle).toOption
} yield data
error: type mismatch;
found : handle.type (with underlying type riakStorage1.Handle)
required: riakStorage2.Handle
data <- riakStorage2.read(handle).toOption
^

Path dependent types
• Family polymorphism
• Remove casts
• Bound to instances not classes

More advanced techniques
• Self-recursive types
• Phantom types
• Shapeless
References: workday.github.io

“Types = For All
Tests = There Exists”
- Amanda Laucher

“A mind is like a parachute,
it doesn’t work unless its open”
- Frank Zappa

http://workday.github.io

Improving Correctness With Type - Goto Con Berlin

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Improving Correctness With Type - Goto Con Berlin (20)

Recently uploaded (20)

Improving Correctness With Type - Goto Con Berlin

Editor's Notes