Boring Usecases for Exciting Types

Boring Usecases
for Exciting Types
Itamar Ravid - FLIP '18
Itamar Ravid - @itrvd 1

About me
• Freelance software developer
• Doing functional programming, microservices, DevOps
• Co-organize the Underscore Scala meetup
• Hit me up if you want to work together!

Agenda
• Why I wrote this talk
• Three data types and their usecases

Programming with functions

How do we grow
as functional programmers

Classic "draw an owl" problem
How do we go from this:
quicksort [] = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
where
lesser = filter (< p) xs
greater = filter ( >= p) xs

Classic "draw an owl" problem
To this:
-- | Fokkinga's postpromorphism
postpro
:: Recursive t
=> (forall b. Base t b -> Base t b) -- natural transformation
-> (a -> Base t a) -- a (Base t)-coalgebra
-> a -- seed
-> t
postpro e g = a where a = embed . fmap (ana (e . project) . a) . g

Examples

Examples
We are sorely lacking!

Actual agenda
Purely functional and type-safe:
• Time measurement and instrumentation
• State machines
• Resource allocation and release
• Let's go!

Examples ahead assume:
import cats._, cats.data._, cats.implicits._
import cats.effect._

Time measurement and instrumentation
Problem: I have a bunch of computations, and I want to measure
them.
def computeCv(data: Data): IO[Double] =
for {
sample <- computeSample(data)
mean <- computeMean(sample)
variance <- computeVariance(sample)
} yield mean / variance

Non-solution: manually instrument.
for {
startTime <- time()
sample <- computeSample(data)
sampleTime <- time()
mean <- computeMean(sample)
meanTime <- time()
variance <- computeVariance(sample)
varTime <- time()

To start, we deﬁne a timed combinator:
def timed[A](fa: IO[A]): IO[(FiniteDuration, A)] =
for {
startTime <- time()
a <- fa
endTime <- time()
} yield ((endTime - startTime).millis, a)
fa is pure, so we can just pass it around.

We can also name this computation:
def timed[A](fa: IO[A],
name: String): IO[((String, FiniteDuration), A)] =
for {
startTime <- time()
a <- fa
endTime <- time()
} yield (name -> (endTime - startTime).millis, a)

We can now use our new timed function:
for {
(sampleTime, sample) <- timed(computeSample(data), "sample")
(meanTime, mean) <- timed(computeMean(sample), "mean")
(varTime, variance) <- timed(computeVariance(sample), "var")
Kinda tedious though!

To save us from that bookeeping, comes WriterT:
case class WriterT[F[_], Log, Value](
run: F[(Log, Value)]
)

To save us from that bookeeping, comes WriterT:
case class WriterT[F[_], Log, Value](
run: F[(Log, Value)]
)
If Log: Semigroup- we can merge logs.

We modify timed to return a WriterT:
type Timing = Map[String, FiniteDuration]
def timed(name: String, fa: IO[A]): WriterT[IO, Timing, A] =
WriterT {
for {
startTime <- time()
a <- fa
endTime <- time()
} yield (Map(name -> (endTime - startTime).millis), a)
}

And we can call this Timed[A] for nicety:
type Timed[A] = WriterT[IO, Map[String, FiniteDuration], A]
def timed(name: String, fa: IO[A]): Timed[A] =
WriterT {
for {
startTime <- time()
a <- fa
endTime <- time()
} yield (Map(name -> (endTime - startTime).millis), a)
}

Our original program is only slightly changed:
def computeCv(data: Data): Timed[Double] =
for {
sample <- timed(computeSample(data), "sample")
mean <- timed(computeMean(sample), "mean")
variance <- timed(computeVariance(sample), "var")

To unpack the timing data, we can deﬁne another function:
def logTimings[A](timed: Timed[A]): IO[A] =
for {
(timing, a) <- timed.run
_ <- IO(println(timing))
} yield a

And use it:
logTimings {
for {
sample <- timed(computeSample(data), "sample")
mean <- timed(computeMean(sample), "mean")
variance <- timed(computeVariance(sample), "var")
}

Summary
• You can add inﬁx syntax using implicit class for nicety:
computeSample(data).timed("sample").logTimings,
etc.
• WriterT is a Monad and an Applicative

Safe state machines
Problem: I want to safely model an authentication protocol:
case class Connection()
trait Authentication {
def connect(): IO[Connection]
def handshake(connection: Connection): IO[Unit]
def sendCreds(connection: Connection): IO[Unit]
def authenticate(connection: Connection): IO[Unit]
}

Safe state machines
Sure, I can just use the functions:
val api: Authentication
import api._
for {
conn <- connect()
_ <- handshake(conn)
_ <- authenticate(conn)
_ <- sendCreds(conn)
} yield data

Safe state machines
Sure, I can just use the functions:
import api._
for {
conn <- connect()
_ <- handshake(conn)
_ <- authenticate(conn)
_ <- sendCreds(conn)
} yield data
But there's a bug here!

Safe state machines
Two problems:
1. Nothing enforces the proper call order
2. Carrying the connection around is not ergonomic

Safe state machines
Static types to the rescue! We will modify Connection:
case class Handshake()
case class Credentials()
case class Auth()
case class Done()
case class Connection[S]()

Safe state machines
And the API:
def connect(): IO[Connection[Handshake]]
def handshake(connection: Connection[Handshake]): IO[Connection[Credentials]]
def sendCreds(connection: Connection[Credentials]): IO[Connection[Auth]]
def authenticate(connection: Connection[Auth]): IO[Connection[Done]]
}

Safe state machines
Now we need to carry even more connections around:
import api._
for {
connHandshake <- connect()
connCreds <- handshake(connHandshake)
connAuth <- sendCreds(connCreds)
connDone <- authenticate(connAuth)
} yield connDone
Safe, but ugly.

Safe state machines
FP saves the day! This is IndexedStateT:
case class IndexedStateT[F, SA, SB, A](
run: SA => F[(SB, A)]
)

Safe state machines
FP saves the day! This is IndexedStateT:
case class IndexedStateT[F, SA, SB, A](
run: SA => F[(SB, A)]
)
For example:
SA = Connection[Handshake], SB = Connection[Credentials]
F = IO, A = Unit

Safe state machines
val handshake: Connection[Handshake] =>
IO[(Connection[Credentials], Unit)]

Safe state machines
We can modify our API to use it:
def connect: IndexedStateT[IO, Unit, Connection[Handshake], Unit]
def handshake: IndexedStateT[IO, Connection[Handshake], Connection[Credentials], Unit]
def sendCreds: IndexedStateT[IO, Connection[Credentials], Connection[Auth], Unit]
def authenticate: IndexedStateT[IO, Connection[Auth], Connection[Done], Unit]
}

Safe state machines
And this is how the usage looks like:
import api._
val authenticate: IndexedStateT[IO, Unit, Connection[Done], Unit] =
for {
_ <- connect
_ <- handshake
_ <- sendCreds
_ <- authenticate
} yield data

Safe state machines
The original example, by the way, errors out:
import api._
for {
_ <- connect
_ <- handshake
_ <- authenticate
_ <- sendCreds
} yield data

Safe state machines
cmd6.sc:6: polymorphic expression cannot be instantiated to expected type;
found : [B, SC]IndexedStateT[IO,Connection[Auth],SC,B]
required: IndexedStateT[IO,Connection[Credentials],?,?]
_ <- authenticate
^

Summary
• IndexedStateT is very cool for type-safe transitions
• It is a Monad and an Applicative when SA = SB
• For non-linear transitions: shapeless.Coproduct and
shapeless.HList
• IxStateT in Haskell is in the indexed-extras package

Resource allocation and release
Problem: I have many resources allocated in my app.
I need to manage their acquisition and release.
def createKafkaConsumer: IO[KafkaConsumer]
trait KafkaConsumer {
def close: IO[Unit]
}
def createDBConnection: IO[DBConnection]
trait DBConnection {
def close: IO[Unit]
}

How should my initialization look like?

def runApp(): IO[Unit] =
for {
consumer <- createKafkaConsumer
conn <- createDBConnection
_ <- doSomething(consumer, conn)
_ <- conn.close
_ <- consumer.close
} yield ()

def runApp(): IO[Unit] =
for {
consumer <- createKafkaConsumer
conn <- createDBConnection
_ <- doSomething(consumer, conn)
_ <- ignoreFailures(conn.close)
_ <- ignoreFailures(consumer.close)
} yield ()

The smell is strong with you!

If you know Java, you're probably aware of try-with-
resources:
try (BufferedReader br =
new BufferedReader(new FileReader(path))) {
return br.readLine();
}
This works for any T <: AutoCloseable.

Our example would look like this:
try (Consumer consumer = new Consumer()) {
try (DBConnection conn = new DBConnection()) {
doSomething(consumer, conn);
}
}

These are not the abstractions you're looking for!

IO monads offer us the bracket operation:
object IO {
def bracket[R, A](acquire: IO[R])
(release: R => IO[Unit])
(use: R => IO[A]): IO[A]
}

But this gets us to the same place:
def createConsumer: IO[Consumer]
bracket(createConsumer)(_.close) { consumer =>
// use consumer
}

But this gets us to the same place:
def createConsumer: IO[Consumer]
bracket(createConsumer)(_.close) { consumer =>
bracket(createDBConnection)(_.close) { conn =>
// use both
}
}

There's an interesting data type called Codensity in Scalaz:
abstract class Codensity[F[_], A] {
def apply[B](f: A => F[B]): F[B]
}

When we set F = IO, A = R, B = A, apply looks like this:
def apply(f: R => IO[A]): IO[A]

This is remarkably similar to part of bracket!
def bracket[R, A](acquire: IO[R])
(release: R => IO[Unit])
(use: R => IO[A]): IO[A]
def apply (f: R => IO[A]): IO[A]
Remember: type signatures are never a coincidence ;-)

Let's adapt bracket to ﬁt Codensity:
def resource[R](acquire: IO[R])(release: R => IO[Unit]) =
new Codensity[IO, R] {
def apply[A](use: R => IO[A]): IO[A] =
IO.bracket(acquire)(release)(use)
}

So now, when we write a resource, we get back a value:
val consumer: Codensity[IO, Consumer] =
resource(createKafkaConsumer)(_.close)

So now, when we write a resource, we get back a value:
val consumer: Codensity[IO, Consumer] =
resource(createKafkaConsumer)(_.close)
And we can use it:
val things: IO[List[Thing]] =
consumer { c =>
c.consumeSomeThings
}

Composition
of resources, using Codensity

It just so happens that Codensity is a Monad.
So I can do this:
val resources: Codensity[IO, (Consumer, DBConnection)] =
for {
consumer <- resource(createKafkaConsumer)(_.close)
dbConn <- resource(createDBConnection)(_.close)
} yield (consumer, dbConn)

Finally, I can do something with these!
val something: IO[Something] =
resources { case (consumer, conn) =>
doSomething(consumer, dbConn)
}
Finalizers will run in reverse order of acquisition.

• Codensity is 18 lines of code in total
• I wrote a post on this
• cats-effect includes Resource[F, R]
• In Haskell, you can use ResourceT or Managed

Summary
• Don't be afraid of the exotic data types!
• Be on the lookout for examples

Boring Usecases for Exciting Types

Recommended

Recommended

More Related Content

Similar to Boring Usecases for Exciting Types

Similar to Boring Usecases for Exciting Types (20)

Recently uploaded

Recently uploaded (20)

Boring Usecases for Exciting Types