Functional programming in Scala: From error handling to fp

FUNCTIONAL PROGRAMMING IN SCALA
(from error handling to fp)

TEXT
About me…
▸ Jordi Pradel
▸ Agile software developer
▸ Learning functional programming
▸ @agile_jordi

FP IS JUST PROGRAMMING WITH FUNCTIONS. FUNCTIONS ARE:
1. TOTAL: THEY RETURN AN OUTPUT FOR EVERY INPUT.
2. DETERMINISTIC: THEY RETURN THE SAME OUTPUT FOR THE SAME
INPUT.
3. PURE: THEIR ONLY EFFECT IS COMPUTING THE OUTPUT.
THE REST IS JUST COMPOSITION YOU CAN LEARN OVER TIME.
John De Goes
TEXT

; aka andThen aka flatMap
▸ Whats the meaning of this program?
expressionA; expressionB

https://github.com/agile-jordi/error-handling-to-fp
SHOW ME THE CODE!

IMPERATIVE
class DocumentService(documentRepository: DocumentRepository) {
def saveDocumentIfNotFound(document: Document): Unit = {
val documentExists =
documentRepository.getDocument(document.id).nonEmpty
if (documentExists) {
documentRepository.updateDocument(document)
} else {
documentRepository.insertDocument(document)
}
}
}

FUNCTIONAL
class DocumentService[F[_] : Monad : DocumentRepository] {
private val documentRepository = implicitly[DocumentRepository[F]]
def saveDocumentIfNotFound(document: Document): F[Unit] = {
for {
doc <- documentRepository.getDocument(document.id)
_ <- if (doc.nonEmpty) {
} else {
}
} yield ()
}
}

FUNCTIONAL
trait DocumentRepository[F[_]] {
def getDocument(documentId: DocumentId): F[Option[Document]]
def insertDocument(document: Document): F[Unit]
def updateDocument(document: Document): F[Unit]
}

IMPERATIVE
class DocumentService(
documentRepository: DocumentRepository,
transactionController: TransactionController) {
def saveDocumentIfNotFound(document: Document): Unit = {
transactionController.inTransaction {
conn =>
val documentExists =
documentRepository.getDocument(document.id)(conn).nonEmpty
if (documentExists) {
documentRepository.updateDocument(document)(conn)
} else {
documentRepository.insertDocument(document)(conn)
}
}
}
}

IMPERATIVE
class TransactionController(dataSource: DataSource) {
def inTransaction[T](f: Connection => T): T = {
val conn = dataSource.getConnection()
try {
conn.beginTransaction()
val res = f(conn)
conn.commit()
res
} catch {
case NonFatal(t) =>
//TODO: Proper error handling of rollback
conn.rollback()
throw t
}
}
}

FUNCTIONAL
def saveDocumentIfNotFound(document: Document): F[Unit] = {
for {
} else {
}
} yield ()
}
}
}

FUNCTIONAL
trait DocumentRepository {
def getDocument(documentId: DocumentId): TxAction[Option[Document]]
def insertDocument(document: Document): TxAction[Unit]
def updateDocument(document: Document): TxAction[Unit]
}

FUNCTIONAL
trait TransactionController {
def begin(): F[Transaction]
def commit(tx: Transaction): F[Unit]
def rollback(tx: Transaction): F[Unit]
def inTransaction[T](f: TxAction[T]): F[T] = {
for {
tx <- begin()
res <- f.run(tx)
_ <- commit(tx)
} yield res
}
}

FUNCTIONAL
trait Documents[F[_]] {
implicit def M:Monad[F]
type Transaction
type TxAction[A] = Kleisli[F, Transaction, A]
// ~= Transaction => F[A]
object TxAction{
def apply[A](f: Transaction => F[A]): TxAction[A] = Kleisli(f)
}
class DocumentService(…) {…}
trait TransactionController {…}
trait DocumentRepository {…}
}

IMPERATIVE
def saveDocumentIfNotFound(document: Document):
Either[ConnectionError, Unit] = {
for {
} else {
}
} yield ()
}
}
}

IMPERATIVE
def getDocument(documentId: DocumentId)(conn: Connection):
Either[ConnectionError, Option[Document]]
def insertDocument(document: Document)(conn: Connection):
Either[InsertDocumentError, Unit]
def updateDocument(document: Document)(conn: Connection):
Either[UpdateDocumentError, Unit]
}

FUNCTIONAL
▸ I was preparing a blog post or a talk about pure functional
error handling
▸ It was about typeclasses like ApplicativeError,
MonadError… (similar to how Future handles errors)
▸ I may still talk about them
▸ But suddenly….

FUNCTIONAL
▸ So I’ll simplify and use F[Either[E,A]] for any F Monad you
choose
type Action[E, A] = F[Either[E, A]

FUNCTIONAL
Action[ConnectionError, Unit] = {
for {
} else {
}
} yield ()
}
}
}

FUNCTIONAL
def getDocument(documentId: DocumentId):
TxAction[ConnectionError, Option[Document]]
def insertDocument(document: Document):
TxAction[InsertDocumentError, Unit]
def updateDocument(document: Document):
TxAction[UpdateDocumentError, Unit]
}

FUNCTIONAL
trait Documents[F[_]] {
implicit def M: Monad[F]
type Transaction
type Action[E, A] = EitherT[F, E, A] // ~= F[Either[E,A]]
object Action {
def apply[E, A](s: F[Either[E, A]]): EitherT[F, E, A] = EitherT.fromEither(s)
}
type TxAction[E, A] = Kleisli[Action[E, ?], Transaction, A] // ~= Transaction => Action[E,A]
object TxAction {
def apply[E, A](f: Transaction => Action[E, A]): TxAction[E, A] =
Kleisli[Action[E, ?], Transaction, A](f)
}
implicit def txActionBifunctor: Bifunctor[TxAction] = new Bifunctor[TxAction] {
override def bimap[A, B, C, D](fab: TxAction[A, B])(f: A => C, g: B => D):
TxAction[C, D] =
TxAction { tx => fab.run(tx).bimap(f, g)}
}
…
}

EITHERT AND MONADTRANSFORMERS
▸ https://github.com/scalaz/scalaz/pull/1708

FUNCTIONAL
F[ConnectionError, Unit] = {
for {
} else {
}
} yield ()
}
}
}

FUNCTIONAL
trait Documents[F[+ _, + _]] extends Transactional[F] {
implicit def M[E]: Monad[F[E, ?]]
class DocumentService(…) {…}
trait TransactionController {…}
trait DocumentRepository {…}
}

FUNCTIONAL
trait Transactional[F[+_,+_]]{
implicit def B:Bitraverse[F]
type Transaction
type TxAction[E, A] = Kleisli[F[E, ?], Transaction, A]
// ~== Transaction => F[E,A]
object TxAction {
def apply[E, A](f: Transaction => F[E, A]): TxAction[E, A] =
Kleisli[F[E, ?], Transaction, A](f)
}
protected implicit val BT: Bifunctor[TxAction] =
KleisiUtils.kleisliBifunctor[F,Transaction]
}

Functional programming in Scala: From error handling to fp

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Functional programming in Scala: From error handling to fp

Similar to Functional programming in Scala: From error handling to fp (20)

Recently uploaded

Recently uploaded (20)

Functional programming in Scala: From error handling to fp