Purely Functional I/O

Purely Functional I/O
Rúnar Bjarnason
@runarorama
QCon New York 2013

Thursday, June 13, 13

Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/io-functional-side-effects

InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month

Presented at QCon New York
www.qconnewyork.com
Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide

Who is this jackass?
•
•
•


Enterprise Java refugee

Author, Functional Programming in Scala
manning.com/bjarnason

Partially responsible for Scalaz and
Functional Java

What you should take
away from this talk
•
•
•


I/O can be done with pure functional
programming.
It really is purely functional.
How it’s done and why it’s done that way.

What is purely functional?


Functional programming is not
about lack of I/O


about first-class functions
or higher-order procedures.


about immutability.


Functional programming is
programming with pure functions


Functional programming is
programming with functions


A function of type (a → b) maps every value of type a
to exactly one value of type b.

(and nothing else)


No side-effects.


Side-effects
•
•
•
•
•

Reading from a file
Writing to the console
Starting threads
Throwing exceptions
Mutating memory

An expression e is referentially transparent if for all
programs p every occurrence of e in p can be replaced
with the result of evaluating e without changing the
meaning of p.


A function f is pure if f(x) is RT when x is RT.


A pure function always returns the same value
given the same input.


A pure function does not depend on anything
other than its argument.


The result of calling a pure function can be understood
completely by looking at the returned value.


x = 2
y = 4
p = x + y


y = 4
p = 2 + y


p = 2 + 4


def x = new Date().getTime
def y = 4
def p = x + y


def y = 4
def p = 1369250684475 + y


A side-effect is anything that violates referential
transparency.


Problems with sideeffecting I/O
•
•
•
•
•

Any function can perform I/O
Monolithic, non-modular, limited reuse
Novel compositions difficult
Difficult to test
Difficult to scale

What we want
•
•
•
•


Clear separation of I/O concern
Modular and compositional API
Easy to test
Scales well

class Cafe {
def buyCoffee(cc: CreditCard): Coffee = {
val cup = new Coffee()
Payments.charge(cc, cup.price)
cup
}
}


class Cafe {
def buyCoffee(cc: CreditCard, p: Payments): Coffee = {
p.charge(cc, cup.price)
cup
}
}


class Cafe {
def buyCoffee(cc: CreditCard): (Coffee, Charge) = {
(cup, new Charge(cc, cup.price))
}
}


First-class I/O
Instead of performing I/O as a side-effect,
return a value to the caller that describes an
interaction with the external system.


Java

class App {
public static void main(String[] args) {}
}


Java

class App {
public static IO main(String[] args) {}
}


Haskell

main :: IO ()


Haskell

getLine :: IO String
putStrLn :: String -> IO ()


Haskell

getInt :: IO Int
getInt = fmap read getLine
fmap :: (a -> b) -> IO a -> IO b
read :: String -> Int


Haskell

echo = getLine >>= putStrLn
(>>=) :: IO a -> (a -> IO b) -> IO b


Haskell

cat = forever echo
forever x = x >> forever x
(>>) :: IO a -> IO b -> IO b


Haskell

cat = forever do
x <- getLine
putStrLn x
forever x = do { x; forever x }


Scala

println("What is your name?")
println("Hello, " + readLine)


Haskell

do
putStrLn "What is your name?"
putStrLn ("Hello, " ++ getLine)


Haskell
do

putStrLn ("Hello, " ++ getLine)

Couldn't match expected type `String' with
actual type `IO String'
In the second argument of `(++)', namely
`getLine'


Haskell

putStrLn "What is your name?" >>
getLine >>= greet
greet name = putStrLn ("Hello, " ++ name)


Haskell

do
name <- getLine
putStrLn ("Hello, " ++ name)


In Haskell, every program is
a single referentially transparent expression.


Benefits of IO
datatype
•
•
•


No side-effects. An IO action is a RT
description.
Effects are external to our program.
Action-manipulating functions!

Library of I/O
functions
sequence
mapM
replicateM
liftM2
forever
while

::
::
::
::
::
::

[IO a] -> IO [a]
(a -> IO b) -> [a] -> IO [b]
Int -> IO a -> IO [a]
(a -> b -> c) -> IO a -> IO b -> IO c
IO a -> IO b
IO Bool -> IO ()

And many more


Novel compositions

getTenLines :: IO [String]
getTenLines = sequence (replicate 10 getLine)


The world-as-state
model
class IO[A](val apply: RealWorld => (A, RealWorld))


The world-as-state
model
class IO[A](val apply: () => A)


The end of the world
sealed trait RealWorld
abstract class Program {
private val realWorld = new RealWorld {}
final def main(args: Array[String]): Unit =
pureMain(args).apply()
def pureMain(args: IndexedSeq[String]): IO[Unit]
}


Example IO actions
def io[A](a: => A): IO[A] =
new IO(() => a)
def putStrLn(s: String): IO[Unit] =
io(println(s))
def getLine: IO[String] =
io(readLine)


Composing actions

main = getLine >>= putStrLn >> main


Composing actions
class IO[A](val apply: () => A) {
def >>=[B](f: A => IO[B]): IO[B] = new IO[B](() => {
apply(rw)
f(a).apply(rw2)
})
def >>[B](b: => IO[B]): IO[B] = >>=(_ => b)
}


Composing actions
new Program {
def pureMain(args: IndexedSeq[String]): IO[Unit] =
(getLine >>= putStrLn) >> pureMain(args)
}


Composing actions
main = do
x <- getLine
putStrLn x
main


Composing actions
new Program {
def pureMain(args: IndexedSeq[String]): IO[Unit] =
for {
line <- getLine
_ <- putStrLn(line)
_ <- pureMain(args)
} yield ()
}


Composing actions
class IO[A](val apply: RealWorld => (A, RealWorld)) {
def >>=[B](f: A => IO[B]): IO[B] = new IO[B] { rw =>
val (a, rw2) = apply(rw)
f(a)
}
def >>[B](b: => IO[B]): IO[B] = >>=(_ => b)

}


def flatMap[B](f: A => IO[B]): IO[B] = >>=(f)
def map[B](f: A => B): IO[B] = >>=(a => io(f(a)))

Issues with
world-as-state
An IO[A] could do anything at all.


Issues with
world-as-state
This implementation overflows the stack in Scala.
Solved with trampolining.


Issues with
world-as-state
main = forever (getLine >>= putStrLn)
main = main


The “free monad”
model
sealed trait IO[A]
case class Pure[A](a: A) extends IO[A]
case class Request[I,A](
req: External[I],
k: I => IO[A]) extends IO[A]


The “free monad”
model
sealed trait IO[F[_],A]
case class Pure[F[_],A](a: A) extends IO[F,A]
case class Request[F[_],I,A](
req: F[I],
k: I => IO[A]) extends IO[A]


Any effect
trait Runnable[A] { def run: A }
def delay[A](a: => A) =
new Runnable[A] {
def run = a
}
type AnyIO[A] = IO[Runnable,A]


Console I/O
trait Console[A]
case object ReadLine extends Console[Option[String]]
case class PrintLn(s: String) extends Console[Unit]
type ConsoleIO[A] = IO[Console,A]


The end of the world
trait Run[F[_]] {
def apply[A](expr: F[A]): (A, Run[F])
}
abstract class App[F[_]](R: Run[F]) {
def main(a: Array[String]): IO[F,Unit] =
run(pureMain(a))
def pureMain(a: Array[String]): IO[F,Unit]

}

def run[A](io: IO[F,A]): A =
io match {
case Pure(a) => a
case Request(req, k) =>
val (e, r2) = R(expr)
run(r2)(k(e))
}

Console I/O
object RunConsole extends Run[Console] {
def apply[A](c: Console[A]) = c match {
case ReadLine => (Option(readLine), RunConsole)
case PrintLn(s) => (println(s), RunConsole)
}
}
IO.run(RunConsole): IO[Console,A] => A


We can use this same model for

•
•
•
•
•
•


file system access
network sockets
HTTP requests
JDBC actions
system clock access
non-blocking I/O

Summary
•
•
•

It really is purely functional.

•

I/O can be done with pure functional
programming.

Now you know how it’s done.

You don’t need a purely functional
language to do it.

Afterword
•
•
•
•

There’s a lot more to be said
This presentation is simplified
Streaming I/O
Mutable arrays and references

Chapter 13
Functional Programming
in Scala
manning.com/bjarnason


Questions?


Watch the video with slide synchronization on
InfoQ.com!
http://www.infoq.com/presentations/iofunctional-side-effects

Purely Functional I/O

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (6)

Destacado

Destacado (10)

Similar a Purely Functional I/O

Similar a Purely Functional I/O (20)

Más de C4Media

Más de C4Media (20)

Último

Último (20)

Purely Functional I/O