This document summarizes a talk on using the Scalaz library. It introduces key Scalaz concepts like typeclasses, monoids, and validation. Typeclasses allow uniform implementation of common patterns across types. Monoids represent structures with an associative binary operation and an identity. Validation provides an applicative way to represent failure without exceptions. The document gives examples of using these concepts to represent positions, filters, and compose validations.

1. GSA CapitalPractical Scalaz(or)How to make your life easier the hard wayChris Marshall Aug 2011@oxbow_lakes

2. Overview of talkThe library is confusingWhat’s with all this maths anyway?The method names are all stupidGSA Capital

3. Where is the love?KindsM[A] ~> MA[M, A]A ~> Identity[A] M[A, B] ~> MAB[M, A, B]Wrappers OptionW, ListW, BooleanWData TypesValidationNonEmptyListGSA Capital

4. TypeclassesCommon “patterns” “retrofitted” in a uniform way to many typesUses implicits to do this...InterfacesLike being able to retrofit an interface onto classes which “logically implement” that interface...AdaptersAdapt existing types to our structuresGSA Capital

5. Example typeclass traitEach[-E[_]]{ defeach[A](e: E[A], f: A => Unit): Unit }GSA Capitalimplicit def OptionEach: Each[Option] = new Each[Option] { def each[A](e: Option[A], f: A => Unit) = eforeachf }

6. MonoidsThere are monoids everywhereA setWith an associative operationAnd an identity under that operationGSA Capital

7. Numbersscala> 1 |+| 2res0: Int3scala> 1.2 |+| 3.4res1: Double 4.6GSA Capital

8. Your ownscala> 200.GBP|+|350.GBPres2: oxbow.Money550.00 GBPGSA Capital

9. Monoids Beget MonoidsOption[A] is a Monoidif A is a monoid(A, B, .. N) is a Monoidif A, B..N are monoidsA => B is a Monoidif B is a MonoidMap[A, B] is a Monoidif B is a MonoidA => A is a monoidUnder function compositionGSA Capital

10. ...scala> some(4) |+|none[Int]res4: Option[Int] Some(4)scala> none[Int] |+|none[Int]res5: Option[Int]Nonescala> some(4) |+|some(5)res6: Option[Int]Some(9)scala> (1, “a”, 4.5) |+| (2, “b”, 3.2)res7: (Int, String, Double)(3, “ab”, 7.7)GSA Capital

11. What does this mean?Winning!GSA Capital

12. traitTradingPosition {definventoryPnL(implicitprices: Map[Ticker, Double]) : DoubledeftradingPnL(implicit prices: Map[Ticker, Double]) : Double final def totalPnL(implicitprices: Map[Ticker, Double]) = inventoryPnL->tradingPnL }GSA Capitalvalpositions: Seq[TradingPosition] = db.latestPositions()val (totalTrad, totalInv) = positions.map(_.totalPnL).asMA.sum

13. traitTradingPosition {definventoryPnL(implicit pxs: Map[Ticker, Double]): Option[Double]deftradingPnL(implicit pxs: Map[Ticker, Double]): Option[Double]final def totalPnL(implicit pxs: Map[Ticker, Double]) = inventoryPnL|+|tradingPnL }GSA Capitalvalposns: Seq[TradingPosition] = db.latestPositions()valmaybePnL: Option[Double] = posns.map(_.totalPnL).asMA.sum

14. traitTradingPosition {defsym: Tickerdefqty: Int }GSA Capitalvalpete: Map[Ticker, Int] = positions1.map(p => p.sym -> p.qty).toMapvalfred: Map[Ticker, Int] = positions2.map(p => p.sym->p.qty).toMap

15. valtotalPositions = pete|+|fredGSA Capitalfor any key, if book1(key) == nand book2(key) == m, then the resulting map hasn |+| mat keyAdding across a bunch of Maps now becomes as easy as... allBooks.asMA.sum

16. traitTradingPosition {defsym: Tickerdefqty: Int }type Filter = TradingPosition => BooleanGSA CapitalFilters

17. Observe: filters are monoidsGSA Capitalvallondon: Filter = (_ : TradingPositon).sym.idendsWith“.L”valny: Filter = (_ : TradingPositon).sym.idendsWith“.O”positionsfilter (london|+|ny)

18. Conjunction typeFilter = TradingPosition => BooleanConjunctionGSA Capitalvallondon= (t : TradingPositon) => (t.sym.idendsWith“.L”) |∧|valbig = (t : TradingPositon) => (t.qty> 100000) |∧|positionsfilter (london|+|big)

19. Monoid = Semigroup + ZeroMonoid is actually split in 2Semigroup (the associative bit)Zero (the identity bit)~ is “or zero” on OptionWA unary method (declared unary_~)It is really usefulEh?GSA Capital

20. varposns: Map[Ticker, Int] = Map.emptydefnewTrade(trd: Trade) {posns += (trd.sym-> ( (posns.get(trd.sym) getOrElse0) + trd.qty)) }GSA CapitalBut observe the equivalence of the following:(posns.get(trd.sym) getOrElse0) And:~posns.get(trd.sym)

21. GSA CapitaldefnewTrade(trd: Trade) {posns += (trd.sym-> (~posns.get(trd.sym) |+|trd.qty)) } We can change the value type

22. To Double?

23. To any Monoid!

24. Your own?Is logically...

25. varcharges: Map[Ticker, Money] = Map.emptyimplicit valChargeCcy = Currency.USDdefnewTrade(trd: Trade) {charges += (trd.sym -> ( ~charges.get(trd.sym) |+|trd.charges)) } Where we have defined our own thusimplicit defMoneyZero(implicit ccy: Currency) : Zero[Money] = zero(Money.zero(ccy))implicit valMoneySemigroup: Semigroup[Money] = semigroup(_ add _)GSA Capital

26. BooleanW, OptionWConsistency with ? and |Option[A] | A == getOrElseBoolean ? a | b == ternaryBoolean ?? A == raise into zeroBoolean !? A == same same but differentBoolean guard / preventGSA Capital

27. EndoAn Endo in scalaz is just a function:A => AIt’s a translation (e.g. negation)BooleanW plus Zero[Endo]“If this condition holds, apply this transformation”GSA Capital

28. We don’t want to repeat ourselves!for { e <- xml \ “instruments” f <- e.attribute(“filter”) } yield (if (f == “incl”) new Filter(instr(e)) elsenew Filter(instr(e)).neg)^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ GSA Capital<instruments filter=“incl”> <symbol value=“VOD.L” /> <symbol value=“MSFT.O” /> </instruments>

29. We can do this...GSA CapitalvalreverseFilter = EndoTo((_ : Filter).neg)for {e <- xml \ “instruments”f <- e.attribute(“filter”) } yield (f == “incl”) !?reverseFilterapplynew Filter(instr(e))

30. Aside: playing aroundscala> EndoTo(-(_ : Double))res0: scalaz.Endo[Double] scalaz.Endo@6754642scala> true?? res0 apply2.3res1: Double -2.3scala> false?? res0 apply2.3res2: Double 2.3scala> implicitly[Zero[Endo[Double]]] res3: scalaz.Endo[Double] scalaz.Endo@8ae765GSA Capital

31. ValidationValidation is the killer app for meOpened my eyes to how appalling java Exceptions areLet your types do the talking!GSA Capital

32. Aside: compositionFunctors:M[A] plus A => B equals M[B]MonadsM[A] plus A => M[B] equals M[B]ApplicativeM[A] plus M[A => B] equals M[B]GSA Capital

33. Composing validations//MAPValidation[X, A] ~>A => B~> Validation[X, B]//FLATMAPValidation[X, A] ~> A => Validation[X, B] ~> Validation[X, B]//APPLYValidation[X1, A], Validation[X2, B] ~> (A, B) => C~> Validation[X1 |+| X2, C]GSA Capital

34. ValidationNELValidation[NonEmptyList[F], S] = ValidationNEL[F, S]scala> “Bah!”.failNel[Int]res1 : scalaz.Validation[NonEmptyList[String], Int]Failure(NonEmptyList(Bah!))scala> 1.successNel[String]res2 : scalaz.Validation[NonEmptyList[String], Int] Success(1)GSA Capital

35. Using Validation deffile(s: String) : Validation[String, File] deftrades(file: File): List[Trade]GSA Capitalvalts = file(“C:/tmp/trades.csv”) maptrades //ts of type Validation[String, List[Trade]]

36. More realisticallydeftrades(f: File): ValidationNEL[String, List[Trade]]GSA Capitalfile(“C:/tmp/trades.csv”).liftFailNelflatMaptradesmatch {case Failure(msgs) => case Success(trades) => }

37. Using for-comprehensionsfor { f <- file(“C:/tmp/trades.csv”).liftFailNelts <- trades(f) } yield tsGSA Capital

38. What does trades look like?deftrades(f: File): ValidationNEL[String, Trade] = {//List[String]valls = io.Source.fromFile(f).getLines().toListdefparse(line: String): Validation[String, Trade] = sys.error(“TODO”)lsmapparse<<SOMETHING with List[Validation[String, Trade]]>> }GSA Capital

39. What does trades look like?deftrades(f: File): ValidationNEL[String, List[Trade]] = {//List[String]valls = io.Source.fromFile(f).getLines().toListdefparse(line: String): Validation[String, Trade] = sys.error(“TODO”) (lsmap (l => parse(l).liftFailNel)) .sequence[({type l[a]=ValidationNEL[String, a]})#l, Trade] }GSA Capital

40. So why do I care?Your program logic is no longer forkedCatching exceptionsThrowing exceptionsAbility to composeVia map, flatMap and applicativeKeeps signatures simpleAccumulate errorsGSA Capital

41. Aside: other applicatives List[Promise[A]].sequence~> Promise[List[A]] f: (A, B) => C (Promise[A] |@| Promise[B]) applyf~> Promise[C]GSA Capital

42. Far too much stuffIterateesKleisliF: A => M[B]If M is a functor and I have g : B => C, then I should be able to compose theseIf M is a Monad and I have h : B => M[C] etcArrowsUseful methods for applying functions across data structures, like pairsGSA Capital

43. And MoreIODeferring side effectsWritersLoggingReadersConfigurationTypesafe equals HeikoSeeberger at scaladaysGSA Capital

44. Great referencesTony Morris’ blogRunar & Mark Harrah’s ApocalispNick Partridge’s Deriving ScalazJason Zaugg at scalaeXchangeGSA Capital