Practical scalaz

GSA Capital
Practical Scalaz(or)How to make your life easier the hard way
Chris Marshall Aug 2011
@oxbow_lakes

Overview of talk
The library is confusing
What’s with all this maths anyway?
The method names are all stupid
GSA Capital

Where is the love?
Kinds
M[A] ~> MA[M, A]
A ~> Identity[A]
M[A, B] ~> MAB[M, A, B]
Wrappers
OptionW, ListW, BooleanW
Data Types
Validation
NonEmptyList
GSA Capital

Typeclasses
Common “patterns”
“retrofitted” in a uniform way to many types
Uses implicits to do this
...Interfaces
Like being able to retrofit an interface onto classes which “logically implement” that interface
...Adapters
Adapt existing types to our structures
GSA Capital

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

Monoids
There are monoids everywhere
A set
With an associative operation
And an identity under that operation
GSA Capital

Numbers
scala> 1 |+| 2
res0: Int3
scala> 1.2 |+| 3.4
res1: Double 4.6
GSA Capital

Your own
scala> 200.GBP|+|350.GBP
res2: oxbow.Money550.00 GBP
GSA Capital

Monoids Beget Monoids
Option[A] is a Monoid
if A is a monoid
(A, B, .. N) is a Monoid
if A, B..N are monoids
A => B is a Monoid
if B is a Monoid
Map[A, B] is a Monoid
if B is a Monoid
A => A is a monoid
Under function composition
GSA Capital

...
scala> some(4) |+|none[Int]
res4: Option[Int] Some(4)
scala> none[Int] |+|none[Int]
res5: Option[Int]None
scala> 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

What does this mean?
Winning!
GSA Capital

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

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 Capital
valposns: Seq[TradingPosition] = db.latestPositions()valmaybePnL: Option[Double] = posns.map(_.totalPnL).asMA.sum

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

valtotalPositions = pete|+|fred
GSA Capital
for any key, if book1(key) == nand book2(key) == m, then the resulting map hasn |+| mat key
Adding across a bunch of Maps now becomes as easy as...
allBooks.asMA.sum

traitTradingPosition {defsym: Tickerdefqty: Int }type Filter = TradingPosition => Boolean
GSA Capital
Filters

Observe: filters are monoids
GSA Capital
vallondon: Filter = (_ : TradingPositon).sym.idendsWith“.L”
valny: Filter = (_ : TradingPositon).sym.idendsWith“.O”
positionsfilter (london|+|ny)

Conjunction
typeFilter = TradingPosition => BooleanConjunction
GSA Capital
vallondon= (t : TradingPositon) => (t.sym.idendsWith“.L”) |∧|
valbig = (t : TradingPositon) => (t.qty> 100000) |∧|
positionsfilter (london|+|big)

Monoid = Semigroup + Zero
Monoid is actually split in 2
Semigroup (the associative bit)
Zero (the identity bit)
~ is “or zero” on OptionW
A unary method (declared unary_~)
It is really useful
Eh?
GSA Capital

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

GSA Capital
defnewTrade(trd: Trade) {posns += (trd.sym-> (~posns.get(trd.sym) |+|trd.qty)) }
We can change the value type
To Double?
To any Monoid!
Your own?
Is logically...

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

BooleanW, OptionW
Consistency with ? and |
Option[A] | A == getOrElse
Boolean ? a | b == ternary
Boolean ?? A == raise into zero
Boolean !? A == same same but different
Boolean guard / prevent
GSA Capital

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

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>

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

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

Validation
Validation is the killer app for me
Opened my eyes to how appalling java Exceptions are
Let your types do the talking!
GSA Capital

Aside: composition
Functors:
M[A] plus A => B equals M[B]
Monads
M[A] plus A => M[B] equals M[B]
Applicative
M[A] plus M[A => B] equals M[B]
GSA Capital

Composing validations
//MAP
Validation[X, A] ~>A => B~> Validation[X, B]
//FLATMAP
Validation[X, A] ~> A => Validation[X, B] ~> Validation[X, B]
//APPLY
Validation[X1, A], Validation[X2, B] ~> (A, B) => C
~> Validation[X1 |+| X2, C]
GSA Capital

ValidationNEL
Validation[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

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

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

Using for-comprehensions
for {
f <- file(“C:/tmp/trades.csv”).liftFailNel
ts <- trades(f)
} yield ts
GSA Capital

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

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

So why do I care?
Your program logic is no longer forked
Catching exceptions
Throwing exceptions
Ability to compose
Via map, flatMap and applicative
Keeps signatures simple
Accumulate errors
GSA Capital

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

Far too much stuff
Iteratees
Kleisli
F: A => M[B]
If M is a functor and I have g : B => C, then I should be able to compose these
If M is a Monad and I have h : B => M[C] etc
Arrows
Useful methods for applying functions across data structures, like pairs
GSA Capital

And More
IO
Deferring side effects
Writers
Logging
Readers
Configuration
Typesafe equals
HeikoSeeberger at scaladays
GSA Capital

Great references
Tony Morris’ blog
Runar & Mark Harrah’s Apocalisp
Nick Partridge’s Deriving Scalaz
Jason Zaugg at scalaeXchange
GSA Capital

Practical scalaz

by oxbow_lakes

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 12

Statistics

Practical scalaz Presentation Transcript

http://us-w1.rockmelt.com	6
http://paper.li	6