Scala Validation with Functional Programming

Validation with Functional Programming
Sukant Hajra / @shajra
April 14, 2016
Sukant Hajra / @shajra Validation with Functional Programming April 14, 2016 1 / 61

Some Goals
explore data structures for managing errors
use type classes to get nice APIs (DSLs)
see some examples with parsing

scalaz./
Construction
scala> import scalaz.syntax.either._
import scalaz.syntax.either._
scala> 1.right[String]
res0: scalaz./[String,Int] = /-(1)
scala> "fail".left[Int]
res1: scalaz./[String,Int] = -/(fail)

scalaz./
Monadic Syntax
scala> 1.right[String].flatMap { a =>
| 2.right[String].map { b =>
| a + b
| }
| }
scala> for {
| a <- 1.right[String]
| b <- 2.right[String]
| } yield a + b

scalaz./
Applicative Syntax
scala> import scalaz.syntax.apply._
import scalaz.syntax.apply._
scala> 1.right[String] |@| 2.right[String] apply { _ + _ }

scalaz./
Semantics
scala> (1.right[String] |@| 2.right[String]).
| apply { _ + _ }
scala> (1.right[String] |@| "fail 2".left[Int]).
| apply { _ + _ }
res6: scalaz./[String,Int] = -/(fail 2)
scala> ("fail 1".left[Int] |@| 2.right[String]).
| apply { _ + _ }
scala> ("fail 1".left[Int] |@| "fail 2".left[Int]).
| apply { _ + _ }

scalaz.ValidationNel
Construction
scala> import scalaz.syntax.validation._
import scalaz.syntax.validation._
scala> 1.success[String]
res9: scalaz.Validation[String,Int] = Success(1)
scala> "fail".failure[Int]
res10: scalaz.Validation[String,Int] = Failure(fail)
scala> 1.successNel[String]
res11: scalaz.ValidationNel[String,Int] = Success(1)
scala> "fail".failureNel[Int]
res12: scalaz.ValidationNel[String,Int] =
Failure(NonEmptyList(fail))

Semantics
scala> (1.successNel[String] |@| 2.successNel[String]).
| apply { _ + _ }
res13: scalaz.Validation[scalaz.NonEmptyList[String],Int] =
Success(3)
scala> (1.successNel[String] |@| "fail 2".failureNel[Int]).
| apply { _ + _ }
Failure(NonEmptyList(fail 2))
scala> ("fail 1".failureNel[Int] |@| "fail 2".failureNel[Int]).
| apply { _ + _ }
Failure(NonEmptyList(fail 1, fail 2))

Dangerous ﬂatMap
scala> "fail 1".failureNel[Int].flatMap { a =>
| "fail 2".failureNel[Int].map { b =>
| a + b
| }
| }
warning: there was one deprecation warning; re-run with
-deprecation for details
Failure(NonEmptyList(fail 1))

Composition
Deﬁning some functions
import scalaz.std.function._
import scalaz.syntax.compose._
def add: Int => Int => Int = a => b => a + b
val mult: Int => Int => Int = a => b => a * b
Usage
scala> add(2) >>> mult(10) >>> add(3) apply 0
res18: Int = 23
scala> add(2) <<< mult(10) <<< add(3) apply 0
res19: Int = 32

What more is possible?
Consider this broken conﬁg
val confText = """
name = "Donald Trump"
year_born = 1946
nemesis {
year_born = "Age of Enlightment"
name = 1650
}
"""
Both nemesis.year_born and nemesis.name have the wrong type.

What more is possible?
Could we catch both defects with this API?
case class UserData(name: String, yearBorn: Int)
def sub(key: String): ConfRead[Json] = ???
def required[A : Readable](key: String): ConfRead[A] = ???
val userRead: ConfRead[UserData] =
(required[String]("name") |@| required[Int]("year_born")).
apply(UserData)
def fullRead: ConfRead[(UserData, UserData)] =
(userRead |@| (sub("nemesis") >>> userRead)).tupled
Config.parse map fullRead.read

Type Classes (a review)

Useful type classes
We’ll quickly review:
Semigroup
Compose
Covariant Functor
Applicative Functor
Monad
Also useful, but not discussed today:
Profunctor
Arrow or Strong Profunctor

High quality type classes
Type classes are statically dispatched interfaces that should
be implementable for many data types
provide functions that lead to rich libraries
have only one instance per type (global uniqueness) 1
have laws (strong contracts).
Auto-deriving instances is also nice.
1
Global uniqueness is debated by a few

Semigroup
Deﬁnition
trait Semigroup[A] {
def append(x: A, y: A): A
}
object Semigroup {
def apply[A](implicit ev: Semigroup[A]): Semigroup[A] = ev
}

Semigroup
Laws
trait SemigroupLaws[A] extends Semigroup[A] {
def semigroupAssociativity(x: A, y: A, z: A) =
append(x, append(y, z)) == append(append(x, y), z)
}

Semigroup
Syntax
implicit class SemigroupOps[A : Semigroup](a1: A) {
def |+|(a2: A): A = Semigroup[A].append(a1, a2)
}

Compose
Deﬁnition
trait Compose[F[_, _]] {
def compose[A, B, C](fbc: F[B, C], fab: F[A, B]): F[A, C]
}
object Compose {
def apply[F[_, _]](implicit ev: Compose[F]): Compose[F] = ev
}

Compose
Laws
trait ComposeLaws[F[_, _]] extends Compose[F] {
def composeAssociativity[A, B, C, D]
(fab: F[A, B], fbc: F[B, C], fcd: F[C, D]) =
compose(fcd, compose(fbc, fab)) ==
compose(compose(fcd, fbc), fab)
}

Compose
Syntax
implicit class ComposeOps[F[_, _], A, B](f1: F[A, B])(
implicit ev: Compose[F]) {
def <<<[C](f2: F[C, A]): F[C, B] = Compose[F].compose(f1, f2)
def >>>[C](f2: F[B, C]): F[A, C] = Compose[F].compose(f2, f1)
}

(Covariant) Functor
Deﬁnition
trait Functor[F[_]] {
def map[A, B](fa: F[A])(f: A => B): F[B]
}
object Functor {
def apply[F[_]](implicit ev: Functor[F]): Functor[F] = ev
}

(Covariant) Functor
Laws
trait FunctorLaws[F[_]] extends Functor[F] {
def functorIdentity[A](fa: F[A]) =
map(fa)(identity[A]) == fa
def functorComposition[A, B, C]
(fa: F[A], f: A => B, g: B => C) =
map(map(fa)(f))(g) == map(fa)(f andThen g)
}

Functor
Syntax
implicit class FunctorOps[F[_] : Functor, A](fa: F[A]) {
def map[B](f: A => B): F[B] = Functor[F].map(fa)(f)
def fpair: F[(A, A)] = map { a => (a, a) }
def fproduct[B](f: A => B): F[(A, B)] =
map { a => (a, f(a)) }
}

Applicative (Functor)
Deﬁnition
trait Applicative[F[_]] extends Functor[F] {
def pure[A](a: A): F[A]
def ap[A, B](fa: F[A])(fab: F[A => B]): F[B]
}
object Applicative {
def apply[F[_]](implicit ev: Applicative[F])
: Applicative[F] = ev
}

Laws
trait ApplicativeLaws1[F[_]] extends
Applicative[F] with
FunctorLaws[F] {
def applicativeIdentity[A](fa: F[A]) =
ap(fa)(pure[A => A](identity)) == fa
def applicativeHomomorphism[A, B](a: A, ab: A => B) =
ap(pure(a))(pure(ab)) == pure(ab(a))
def applicativeInterchange[A, B](a: A, f: F[A => B]) =
ap(pure(a))(f) == ap(f)(pure { (ff: A => B) => ff(a) })
}

Laws
trait ApplicativeLaws2[F[_]] extends ApplicativeLaws1[F] {
def applicativeDerivedMap[A, B](f: A => B, fa: F[A]) =
map(fa)(f) == ap(fa)(pure(f))
def applicativeComposition[A, B, C]
(fa: F[A], fab: F[A => B], fbc: F[B => C]) =
ap(ap(fa)(fab))(fbc) ==
ap(fa)(
ap(fab)(
map[B=>C, (A=>B)=>(A=>C)](fbc) {
bc => ab => bc compose ab }))
}

Syntax
implicit class ApplicativeOps1[F[_] : Applicative, A](
fa: F[A]) {
def <*>[A, B](f: F[A => B]) = Applicative[F].ap(fa)(f)
def *>[B](fb: F[B]): F[B] =
Applicative[F].ap(fa)(Functor[F].map(fb)(Function.const))
def <*[B](fb: F[B]): F[A] =
Applicative[F].ap(fb)(fa map Function.const)
}
implicit class ApplicativeOps2[A](a: A) {
def pure[F[_] : Applicative]: F[A] = Applicative[F].pure(a)
}

Monad
Deﬁnition
trait Monad[F[_]] extends Applicative[F] {
def bind[A, B](fa: F[A])(fab: A => F[B]): F[B]
}
object Monad {
def apply[F[_]](implicit ev: Monad[F]): Monad[F] = ev
}

Monad
Laws
trait MonadLaws[F[_]] extends Monad[F] {
def monadRightIdentity[A](fa: F[A]) =
bind(fa)(pure) == fa
def monadLeftIdentity[A, B](a: A, f: A => F[B]) =
bind(pure(a))(f) == f(a)
def monadAssociativity[A, B, C]
(fa: F[A], f: A => F[B], g: B => F[C]) =
bind(bind(fa)(f))(g) == bind(fa) { a => bind(f(a))(g) }
def monadDerivedAp[A, B](fab: F[A => B], fa: F[A]) =
bind(fa) { a => map(fab) { f => f(a) } } == ap(fa)(fab)
}

Monad
Syntax
implicit class MonadOps[F[_] : Monad, A](fa: F[A]) {
def flatMap[B](f: A => F[B]): F[B] = Monad[F].bind(fa)(f)
def >>=[B](f: A => F[B]): F[B] = flatMap(f)
def >>![B](f: A => F[B]): F[A] =
flatMap { a => Monad[F].map(f(a)) { b => a } }
def >>[B](fb: F[B]): F[B] = flatMap(Function.const(fb))
import scalaz.Leibniz.===
def join[B](implicit ev: A === F[B]): F[B] =
Monad[F].bind(ev.subst[F](fa))(identity)
}

Data types

Non-empty List
Deﬁnition
object nel {
case class Nel[A](head: A, tail: List[A]) {
def toList: List[A] = head :: tail
override def toString: String =
s"""Nel(${head}, ${tail mkString ","})"""
}
object Nel {
def of[A](head: A, tail: A*): Nel[A] =
new Nel(head, tail.toList)
}
}; import nel._

Non-empty List
Semigroup Instance
import scalaz.Semigroup
import scalaz.std.list._
import scalaz.syntax.semigroup._
implicit def nelSemigroup[A]: Semigroup[Nel[A]] =
new Semigroup[Nel[A]] {
def append(x: Nel[A], y: => Nel[A]) =
Nel[A](x.head, x.tail |+| (y.head :: y.tail))
}

Non-empty List
Monad Instance
import scalaz.Monad
import scalaz.syntax.monad._
implicit val nelMonad: Monad[Nel] =
new Monad[Nel] {
def point[A](a: => A) = Nel(a, List.empty)
def bind[A, B](as: Nel[A])(f: A => Nel[B]) = {
val front = f(as.head)
Nel(
front.head,
front.tail |+| (as.tail >>= (f andThen { _.toList })))
}
}

Non-empty List
Usage
scala> Nel.of(1,2,3) |+| Nel.of(4,5,6)
res2: nel.Nel[Int] = Nel(1, 2,3,4,5,6)
scala> Nel.of(1,2) >>= { x => Nel.of(x, x+10) }
res3: nel.Nel[Int] = Nel(1, 11,2,12)
scala> (Nel.of(1,2) |@| Nel.of(10,100)).apply { _ * _ }
res4: nel.Nel[Int] = Nel(10, 100,20,200)

Disjunction
Deﬁnition
object disj {
sealed trait Disj[A, B] {
def fold[C](ifLeft: A => C)(ifRight: B => C) =
this match {
case LeftD(a) => ifLeft(a)
case RightD(b) => ifRight(b)
}
}
case class LeftD[A, B](a: A) extends Disj[A, B]
case class RightD[A, B](b: B) extends Disj[A, B]
}; import disj._

Disjunction
Syntax
implicit class DisjOps[A](a: A) {
def left[B]: Disj[A, B] = LeftD(a)
def right[B]: Disj[B, A] = RightD(a)
}

Disjunction
Instances
implicit def disjMonad[E]: Monad[Disj[E, ?]] =
new Monad[Disj[E, ?]] {
def point[A](a: => A) = a.right
def bind[A, B](d: Disj[E, A])(f: A => Disj[E, B]) =
d.fold { _.left[B] } { f(_) }
}

Disjunction
Usage
scala> (1.right[String] |@| 2.right[String]).
| apply { _ + _ }
res5: disj.Disj[String,Int] = RightD(3)
scala> ("fail 1".left[Int] |@| "fail 2".left[Int]).
| apply { _ + _ }
res6: disj.Disj[String,Int] = LeftD(fail 1)

Validation
Deﬁnition
object checked {
sealed trait Checked[A, B] {
def fold[C](ifFail: A => C)(ifPass: B => C) =
this match {
case Fail(a) => ifFail(a)
case Pass(b) => ifPass(b)
}
}
case class Fail[A, B](a: A) extends Checked[A, B]
case class Pass[A, B](b: B) extends Checked[A, B]
}; import checked._

Validation
Syntax
implicit class CheckedOps1[A](a: A) {
def pass[B]: Checked[B, A] = Pass(a)
def fail[B]: Checked[A, B] = Fail(a)
def passNel[B]: Checked[Nel[B], A] = Pass(a)
def failNel[B]: Checked[Nel[A], B] = Fail(Nel of a)
}

Validation
Instances
import scalaz.Applicative
implicit def checkedApplicative[E : Semigroup]
: Applicative[Checked[E, ?]] =
new Applicative[Checked[E, ?]] {
def point[A](a: => A) = a.pass[E]
def ap[A, B](c: => Checked[E, A])(f: => Checked[E, A=>B]) =
c.fold { e1 =>
f.fold(e2 => (e1 |+| e2).fail[B])(_ => e1.fail[B])
} { a =>
f.fold(_.fail[B])(_.apply(a).pass[E])
}
}

Validation
Usage
scala> (1.passNel[String] |@| 2.passNel[String]).
| apply { _ + _ }
res8: checked.Checked[nel.Nel[String],Int] = Pass(3)
scala> ("fail 1".failNel[Int] |@| "fail 2".failNel[Int]).
| apply { _ + _ }
res9: checked.Checked[nel.Nel[String],Int] = Fail(Nel(fail 2,
fail 1))

Read
Deﬁnition
case class Read[F[_], A, B](read: A => F[B])

Read
Compose Instance
import scalaz.Compose
implicit def readCompose[F[_] : Monad]
: Compose[Read[F, ?, ?]] =
new Compose[Read[F, ?, ?]] {
def compose[A, B, C](f: Read[F, B, C], g: Read[F, A, B]) =
Read { a => g.read(a) >>= f.read }
}

Read
Applicative Instance
implicit def readApplicative[F[_] : Applicative, A]
: Applicative[Read[F, A, ?]] =
new Applicative[Read[F, A, ?]] {
def point[B](b: => B) = Read { a => b.pure[F] }
def ap[B, C](r: => Read[F, A, B])(f: => Read[F, A, B=>C]) =
Read { a => (f.read(a) |@| r.read(a)) { _ apply _ } }
}

ReadC
Deﬁnition
case class ReadC[A, E, B](read: A => Checked[E, B])

ReadC
Instances
implicit def readCCompose[E]: Compose[ReadC[?, E, ?]] =
new Compose[ReadC[?, E, ?]] {
def compose[A, B, C]
(f: ReadC[B, E, C], g: ReadC[A, E, B]) =
ReadC { a => g.read(a).fold(_.fail[C])(f.read) }
}
implicit def readCApplicative[A, E : Semigroup]
: Applicative[ReadC[A, E, ?]] =
new Applicative[ReadC[A, E, ?]] {
def point[B](b: => B) =
ReadC { a => b.pure[Checked[E, ?]] }
def ap[B, C]
(r: => ReadC[A, E, B])(f: => ReadC[A, E, B=>C]) =
ReadC { a => (f.read(a) |@| r.read(a)) { _ apply _ } }
}

Parsing Example

Knobs library extension
Tracking path traversed
import scalaz.Show
import scalaz.std.string._
import scalaz.syntax.foldable._
case class Path(elems: List[String]) {
def -(elem: String) = new Path(elem.trim +: elems)
override def toString = elems.reverse intercalate "."
}
def emptyPath: Path = new Path(List.empty)

Path-Conﬁg pair
import knobs.Config
case class Knobs(path: Path, config: Config) {
def -(elem: String): Knobs =
Knobs(path - elem, config subconfig elem)
}
def rootKnobs(config: Config): Knobs =
Knobs(emptyPath, config)

Faults
import scala.reflect.runtime.universe.{ typeTag, TypeTag }
sealed abstract class ParseFault { def path: Path }
final case class KeyNotFound(path: Path) extends ParseFault
final case class WrongType(path: Path, typetag: TypeTag[_])
extends ParseFault
def keyNotFound(path: Path): ParseFault =
KeyNotFound(path)
def wrongType[A : TypeTag](path: Path): ParseFault =
WrongType(path, typeTag[A])

Type alias
type Parse[A, B] = ReadC[A, Nel[ParseFault], B]
type KnobsRead[A] = Parse[Knobs, A]

Read subconﬁg
def sub(path: String): KnobsRead[Knobs] =
ReadC { _ - path passNel }

Lookup conﬁguration
import knobs.{ CfgValue, Configured }
def required[A : Configured : TypeTag](path: String):
KnobsRead[A] =
ReadC { conf =>
val reportedPath = conf.path - path
conf.config
.lookup[CfgValue](path)
.fold(keyNotFound(reportedPath).fail[CfgValue])(_.pass)
.fold(_.failNel[A]) { v =>
v.convertTo[A]
.fold(wrongType[A](reportedPath).failNel[A])(_.passNel)
}
}

Conﬁg reader
import scalaz.syntax.compose._
case class UserData(name: String, yearBorn: Int)
val userRead: KnobsRead[UserData] =
(required[String]("name") |@| required[Int]("year_born")).
apply(UserData)
def fullRead: KnobsRead[(UserData, UserData)] =
(userRead |@| (sub("nemesis") >>> userRead)).tupled

Broken conﬁg example
val confText = """
name = "Donald Trump"
year_born = 1946
nemesis {
year_born = "Age of Enlightment"
name = 1650
}
"""

Conﬁg reader
scala> Config.parse(confText).map { conf =>
| fullRead read rootKnobs(conf)
| }
res25:
scalaz./[Throwable,checked.Checked[nel.Nel[ParseFault],(UserD
UserData)]] =
/-(Fail(Nel(WrongType(nemesis.year_born,TypeTag[Int]),
WrongType(nemesis.name,TypeTag[String]))))

Wrapping up

This material
is compiler-checked (half-literate programming) using:
Rob Norris’s tut SBT plugin
pandoc
LATEX
Beamer
is at https://github.com/shajra/shajra-presentations.

Scala Validation with Functional Programming

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Scala Validation with Functional Programming

Similar to Scala Validation with Functional Programming (20)

Recently uploaded

Recently uploaded (20)

Scala Validation with Functional Programming