Scale By the Bay 2017 Index your State

Transcript

1. Indexed Your State for safer functional APIs 
 SCALE BY THE BAY 2017
2. Vincent Marquez @runT1ME github/vmarquez
3. working at verizon labs Scalaz Contributor/Committer Hazelcast Contributor Scodec Contributor? (merge my PR mpilquist :-)
4. trait Conn { def setDest(u: URI): Unit def initCredentials(s: String): Unit def connect(): Unit def sendData(a: Array[Byte]): Unit }
5. 2nd Try trait Conn { def setDest(str: URI): Conn def initCredentials(s: String): Future[Conn] def connect(): Future[Conn] def sendData(a: Array[Byte]): Future[Conn] }
6. Using the API is kind of weird…
 
 for { c1 <- conn.initCredentials("asdf") c2 <- c1.connect() c3 <- c2.sendData(arr) } yield ()
7. Using the API is kind of weird…
 
 for { c1 <- conn.initCredentiasl("asdf") c2 <- c1.connect() c3 <- c2.sendData(arr) } yield ()
8. Using the API is kind of weird…
 
 for { c1 <- conn.initCredentiasl("asdf") c2 <- c1.connect() c3 <- c2.sendData(arr) } yield ()
9. Would be ‘cleaner’ if we could implicitly thread through our ‘connection ‘state’ as we go
10. State Monad!
11. What is a State Monad? LYAHFGG: We’ll say that a stateful computation is a function that takes some state and returns a value along with some new state. That function would have the following type: A => (A, B)

12. State example: Counter def countState = SState[Int, String]((i: Int) => (i+1, i.toString)) for { a <- countState b <- countState } yield (a + b).toUpperCase
13. Simple State case class SState[A, B](f: (A => (A,B))) { def flatMap[C](fc: B => SState[A, C]): SState[A, C] = SState((a: A) => f(a) match { case (a, b) => fc(b).f(a) }) }
14. Simple State flatMap case class SState[A, B](f: (A => (A,B))) { def flatMap[C](fc: B => SState[A, C]): SState[A, C] = SState((a: A) => f(a) match { case (a, b) => fc(b).f(a) }) }
15. Simple State flatMap case class SState[A, B](f: (A => (A,B))) { def flatMap[C](fc: B => SState[A, C]): SState[A, C] = SState((a: A) => f(a) match { case (a, b) => fc(b).f(a) }) }
16. Simple State flatMap case class SState[A, B](f: (A => (A,B))) { def flatMap[C](fc: B => SState[A, C]): SState[A, C] = SState((a: A) => f(a) match { case (a, b) => fc(b).f(a) }) }
17. Simple State flatMap case class SState[A, B](f: (A => (A,B))) { def flatMap[C](fc: B => SState[A, C]): SState[A, C] = SState((a: A) => f(a) match { case (a, b) => fc(b).f(a) }) }
18. Cool let’s check out the Scalaz State Monad… found : scalaz.State[Int,String] (which expands to) scalaz.IndexedStateT[scalaz.Id.Id,Int,Int,String]
19. type State[S, A] = StateT[Id, S, A]
20. type StateT[F[_], S, A] = IndexedStateT[F, S, S, A]
21. Let’s look at the source:
 sealed abstract class IndexedStateT[F[_], -S1, S2, A] { self => def getF[S <: S1]: Monad[F] => F[S => F[(S2, A)]] /** Run and return the final value and state in the context of `F` */ def apply(initial: S1)(implicit F: Monad[F]): F[(S2, A)] = F.join(F.map[S1 => F[(S2, A)], F[(S2, A)]](getF(F))(sf => sf(initial))) …
22. Lol wut
23. StateT time
 Tuple is inside the Context case class SStateT[F[_], A, B](f: (A => F[(A, B)]))
24. StateT time Our tuple is inside the context case class SStateT[F[_], A, B](f: (A => F[(A, B)])) { def flatMap[C](fc: B => SStateT[F, A, C]) (implicit M: Monad[F]) = SStateT[F, A, C](a => { f(a).flatMap(aa => aa match { //returns the F[(A,C)] case (aaa, b) => fc(b).f(aaa) }) }) }
25. StateT flatMap Use the M instance to flatMap case class SStateT[F[_], A, B](f: (A => F[(A, B)])) { def flatMap[C](fc: B => SStateT[F, A, C]) (implicit M: Monad[F]) = SStateT[F, A, C](a => { f(a).flatMap(aa => aa match { //returns the F[(A,C)] case (aaa, b) => fc(b).f(aaa) }) }) }
26. StateT flatMap Use the M instance to flatMap case class SStateT[F[_], A, B](f: (A => F[(A, B)])) { def flatMap[C](fc: B => SStateT[F, A, C]) (implicit M: Monad[F]) = SStateT[F, A, C](a => { f(a).flatMap(aa => aa match { //returns the F[(A,C)] case (aaa, b) => fc(b).f(aaa) }) }) }
27. StateT flatMap Use the M instance to flatMap case class SStateT[F[_], A, B](f: (A => F[(A, B)])) { def flatMap[C](fc: B => SStateT[F, A, C]) (implicit M: Monad[F]) = SStateT[F, A, C](a => { f(a).flatMap(aa => aa match { //returns the F[(A,C)] case (aaa, b) => fc(b).f(aaa) }) }) }
28. StateT Example: Counter def countState = SStateT[Future, Int, String]( (i: Int) => Future { (i+1, i.toString) }) for { a <- countState b <- countState } yield (a + b).toUpperCase
29. But Why do we need IndexedStateT?
30. An API with StateT case class CachedState(map: IMap[Int, Item]) def viewItem(i: Int): StateT[Task, CachedState, Item] = ??? def lockItem(i: Int): StateT[Task, CachedState, Unit] = ??? def updateItemName(id: Int, name: String): StateT[Task, CachedState, Item] = ??? def commitChange(): StateT[Task, CachedState, Unit] = ???
31. An API with StateT case class CachedState(map: IMap[Int, Item]) def viewItem(i: Int): StateT[Task, CachedState, Item] = ??? def lockItem(i: Int): StateT[Task, CachedState, Unit] = ??? def updateItemName(id: Int, name: String): StateT[Task, CachedState, Item] = ??? def commitChange(): StateT[Task, CachedState, Unit] = ???
32. An API with StateT case class CachedState(map: IMap[Int, Item]) def viewItem(i: Int): StateT[Task, CachedState, Item] = ??? def lockItem(i: Int): StateT[Task, CachedState, Unit] = ??? def updateItemName(id: Int, name: String): StateT[Task, CachedState, Item] = ??? def commitChange(): StateT[Task, CachedState, Unit] = ???
33. An API with StateT case class CachedState(map: IMap[Int, Item]) def viewItem(i: Int): StateT[Task, CachedState, Item] = ??? def lockItem(i: Int): StateT[Task, CachedState, Unit] = ??? def updateItemName(id: Int, name: String): StateT[Task, CachedState, Item] = ??? def commitChange(): StateT[Task, CachedState, Unit] = ???
34. An API with StateT case class CachedState(map: IMap[Int, Item]) def viewItem(i: Int): StateT[Task, CachedState, Item] = ??? def lockItem(i: Int): StateT[Task, CachedState, Unit] = ??? def updateItemName(id: Int, name: String): StateT[Task, CachedState, Item] = ??? def commitChange(): StateT[Task, CachedState, Unit] = ???
35. def viewItem(i: Int): StateT[Task, CachedState, Item] = StateT((cis: CachedState) => Task { cis.map.lookup(i) match { case Some(item) => (cis, item) case None => val item = viewItemUnsafe(i) val nmap = cis.map + (i -> item) (CachedState(nmap), item) } })
36. Usage of our API for { a <- viewItem(4) _ <- lockItem(4) _ <- updateItemName(4, "asdf") } yield (a)
37. So what’s the problem?
38. We are threading ‘through’ state, not modeling it
39. Sadly this compiles! for { a <- viewItem(4) _ <- updateItemName(4, "asdf") _ <- lockItem(4) } yield (a)
40. Indexed StateT flatMap case class ISStateT[F[_], -A, B, C](f: (A => F[(B, C)])) { def flatMap[D, E](fc: C => ISStateT[F, B, D, E])(implicit M: Monad[F]): ISStateT[F, A, D, E] = ISStateT(a => { f(a).flatMap(t => t match { case (b, c) => fc(c).f(b) }) }) }
41. Indexed StateT flatMap case class ISStateT[F[_], -A, B, C](f: (A => F[(B, C)])) { def flatMap[D, E](fc: C => ISStateT[F, B, D, E])(implicit M: Monad[F]): ISStateT[F, A, D, E] = ISStateT(a => { f(a).flatMap(t => t match { case (b, c) => fc(c).f(b) }) }) }
42. Indexed StateT flatMap case class ISStateT[F[_], -A, B, C](f: (A => F[(B, C)])) { def flatMap[D, E](fc: C => ISStateT[F, B, D, E])(implicit M: Monad[F]): ISStateT[F, A, D, E] = ISStateT(a => { f(a).flatMap(t => t match { case (b, c) => fc(c).f(b) }) }) }
43. Indexed StateT flatMap case class ISStateT[F[_], -A, B, C](f: (A => F[(B, C)])) { def flatMap[D, E](fc: C => ISStateT[F, B, D, E])(implicit M: Monad[F]): ISStateT[F, A, D, E] = ISStateT(a => { f(a).flatMap(t => t match { case (b, c) => fc(c).f(b) }) }) }
44. Let’s model more ‘states’ type Item = String case class CacheState(map: IMap[Int, Item]) class LockedState(map: IMap[Int, Item]) extends CacheState(map) class UpdatedState(map: IMap[Int, Item]) extends LockedState(map)
45. Our new API def viewItem(i: Int): IndexedStateT[Task, CacheState, CacheState, Item] = ??? def lockItem(i: Int): IndexedStateT[Task, CacheState, LockedState, Unit] = ??? def updateItemName(id: Int, item: Item): IndexedStateT[Task, LockedState, UpdatedState, Item] = ??? def commitChange(): IndexedStateT[Task, UpdatedState, CacheState, Unit] = ???
46. Our new API def viewItem(i: Int): IndexedStateT[Task, CacheState, CacheState, Item] = ??? def lockItem(i: Int): IndexedStateT[Task, CacheState, LockedState, Unit] = ??? def updateItemName(id: Int, item: Item): IndexedStateT[Task, LockedState, UpdatedState, Item] = ??? def commitChange(): IndexedStateT[Task, UpdatedState, CacheState, Unit] = ???
47. Our new API def viewItem(i: Int): IndexedStateT[Task, CacheState, CacheState, Item] = ??? def lockItem(i: Int): IndexedStateT[Task, CacheState, LockedState, Unit] = ??? def updateItemName(id: Int, item: Item): IndexedStateT[Task, LockedState, UpdatedState, Item] = ??? def commitChange(): IndexedStateT[Task, UpdatedState, CacheState, Unit] = ???
48. Our new API def viewItem(i: Int): IndexedStateT[Task, CacheState, CacheState, Item] = ??? def lockItem(i: Int): IndexedStateT[Task, CacheState, LockedState, Unit] = ??? def updateItemName(id: Int, item: Item): IndexedStateT[Task, LockedState, UpdatedState, Item] = ??? def commitChange(): IndexedStateT[Task, UpdatedState, CacheState, Unit] = ???
49. Our new API def viewItem(i: Int): IndexedStateT[Task, CacheState, CacheState, Item] = ??? def lockItem(i: Int): IndexedStateT[Task, CacheState, LockedState, Unit] = ??? def updateItemName(id: Int, item: Item): IndexedStateT[Task, LockedState, UpdatedState, Item] = ??? def commitChange(): IndexedStateT[Task, UpdatedState, CacheState, Unit] = ???
50. Now… for { a <- viewItem(4) _ <- updateItemName(4, "asdf") _ <- lockItem(4) } yield (a) Has the following error: found : IndexedStateT[Task,cmd5.LockedState,LockedState, Item] (which expands to) IndexedStateT[Task, cmd5.LockedState,LockedState,String] required: IndexedStateT[Task,cmd4.CachedState,?,?] _ <- updateItemName(4, “asdf") We need a regular CachedState, not a Locked State!
 View Item doesn’t return a LockedItem
51. Explaining the error
 
 found : IndexedStateT[Task,cmd5.LockedState,LockedState, Item] (which expands to) IndexedStateT[Task, cmd5.LockedState,LockedState,String] required: IndexedStateT[Task,cmd4.CachedState,?,?] _ <- updateItemName(4, “asdf")
 
 We can’t pass in a CacheState to something expecting a LockedState, so the types don’t work out!
52. What else can we do? 
 Thoughts?
53. Now go forth and make safe APIs