Concrete Abstraction with Scalaz • Scala Leipzig 2015

Introducing some of the core Abstractions from Scalaz and practical use cases:
• Monoids
• Monads
• Applicative Functors

Transcript

1. Concrete Abstraction with Scalaz Martin Kühl, EWERK IT @mkhl Scala User Group Leipzig · 2015-02-26
2. Monoids Monads Applicative Functors 1
3. Motivation • Scalaz is underused • Abstractions are shunned 2
4. Abstractions • abstract data types (interface without implementation) • provide practical value 3
5. Compare: Design Patterns • provide common vocabulary • recognize that they were used • recognize when they could be used 4
6. We will focus on • use cases 5
7. We will skip • laws • maths • theory 6
8. We will assume • Scala standard library • Typeclass pattern 7
9. Monoids 8
10. Have: Map("a" -> List(1), "b" -> List(2, 2), "c" -> List(3, 4, 5)) Want: Map("a" -> Agree(1), "b" -> Agree(2), "c" -> Disagree(3, 4, 5)) 9
11. trait Consensus[A] case object Unknown extends Consensus[Nothing] case class Agree[A](get: A) extends Consensus[A] case class Disagree[A](all: Set[A]) extends Consensus[A] 10
12. Have: Map("a" -> List(1), "b" -> List(2, 2), "c" -> List(3, 4, 5)) Want: Map("a" -> Agree(1), "b" -> Agree(2), "c" -> Disagree(3, 4, 5)) 11
13. def aggregate[A](c: Consensus[A], a: A): Consensus[A] = c match { case Unknown => Agree(a) case Disagree(as) => Disagree(as + a) case Agree(b) => if (a == b) c else Disagree(Set(b, a)) } 12
14. trait Monoid[A] { def zero: A def append(l: A, r: => A): A // ... } 13
16. Monoids • aggregate data • paralellise easily • enable .foldMap 15
17. trait Foldable[F[_]] { def foldMap[A, B: Monoid](fa: F[A])(f: A => B): B // ... } 16
18. Foldable.foldMap • generalises: – .sum/.product – .min/.max – .toList/.toSet – … 17
19. scala> List(2, 3, 4).sum res0: Int = 9 scala> List[Int]().sum res1: Int = 0 18
20. scala> List(2, 3, 4) foldMap (x=>x) res2: Int = 9 scala> List[Int]() foldMap (x=>x) res3: Int = 0 19
21. scala> List(2, 3, 4).toSet res8: Set[Int] = Set(2, 3, 4) scala> List[Int]().toSet res9: Set[Int] = Set() 20
22. scala> List(2, 3, 4) foldMap (Set(_)) res10: Set[Int] = Set(2, 3, 4) scala> List[Int]() foldMap (Set(_)) res11: Set[Int] = Set() 21
23. trait Consensus[A] case object Unknown extends Consensus[Nothing] case class Agree[A](get: A) extends Consensus[A] case class Disagree[A](all: Set[A]) extends Consensus[A] 22
24. scala> Map("a" -> List(1), | "b" -> List(2, 2), | "c" -> List(3, 4, 5)) | mapValues (_ foldMap (agree(_))) res13: Map[String,Consensus[Int]] = Map(a -> Agree(1), b -> Agree(2), c -> Disagree(Set(3, 4, 5))) 23
25. scala> val l: Map[String, Consensus[Int]] = | Map("a" -> Agree(1), "b" -> Agree(2), | "c" -> Disagree(Set(3, 4))) scala> val r: Map[String, Consensus[Int]] = | Map("a" -> Agree(1), "b" -> Agree(1), | "c" -> Disagree(Set(4, 5))) scala> l mappend r res17: Map[String,Consensus[Int]] = Map(a -> Agree(1), b -> Disagree(Set(1, 2)), c -> Disagree(Set(3, 4, 5))) 24
26. More Uses • collect histograms • Summingbird • CRDTs 25
27. Intermission: Functors 26
28. trait Functor[F[_]] { def map[A, B](fa: F[A])(f: A => B): F[B] // ... } 27
29. Functor.map ⇒ ⇒ 28
30. Functor.map ⇒ ⇒ 29
31. Functor.map ⇒ ⇒ 30
32. Functor.map ⇒ ⇒ 31
33. Functors • wrap context around data • generalise .map 32
34. Common Functors • List • Option • Future 33
35. Applicative Functors 34
36. trait TwitterService[F[_]] { def text(id: Long): F[String] def retweets(id: Long): F[Long] def favourites(id: Long): F[Long] } case class Tweet( text: String, retweets: Long, favourites: Long) 35
37. trait Applicative[F[_]] extends Functor[F] { def pure[A](a: => A): F[A] def ap[A, B](fa: F[A])(f: F[A => B]): F[B] // ... } 36
38. Applicative.ap ⇒ ⇒ ⇒ 37
39. Applicative.ap ⇒ ⇒ ⇒ 38
40. Applicative.ap ⇒ ⇒ ⇒ 39
41. Applicative.ap ⇒ ⇒ ⇒ ⇒ 40
42. Applicative.ap ⇒ ⇒ ⇒ ⇒ 41
43. Applicative Functors • generalise .zipWith (like a.zip(b).map(f)) • combine independent computations 42
44. Common Applicative Functors • List • Option • Future • Writer 43
45. Applicative Functors enable ApplicativeBuilder 44
46. scala> (text(id) |@| retweets(id) |@| favourites(id)) | { Tweet } res0: Option[Tweet] = Some(Tweet(BONG BONG BONG BONG,98,48)) 45
47. scala> (text(id) |@| retweets(id) |@| favourites(id)) | { Tweet } res1: Future[Tweet] = Promise$DefaultPromise@4b4257a5 scala> res1 foreach println Tweet(BONG BONG BONG BONG,98,48) 46
48. scala> retweets(id) res2: (List[String], Long) = (List(fetching retweets…),98) scala> (text(id) |@| retweets(id) |@| favourites(id)) | { Tweet } res3: (List[String], Tweet) = (List(fetching text…, fetching retweets…, fetching favourites…), Tweet(BONG BONG BONG BONG,98,48)) 47
49. Monads 48
50. trait ProfileService[F[_]] { def author(id: Long): F[String] def name(screenname: String): F[String] def url(screenname: String): F[String] } case class Profile( screenname: String, name: String, url: String) 49
51. trait Monad[F[_]] extends Applicative[F] { def point[A](a: => A): F[A] def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B] // ... } 50
52. Monad.flatMap ⇒ ⇒ 51
53. Monad.flatMap ⇒ ⇒ 52
54. Monad.flatMap ⇒ ⇒ 53
55. Monad.flatMap ⇒ ⇒ 54
56. Monads • generalise .flatMap • combine (possibly dependent) computations 55
57. Common Monads • List • Option • Future • Writer 56
58. Monads enable for/yield 57
59. scala> for { | screenname <- author(id) | name <- name(screenname) | url <- url(screenname) | } yield Profile(screenname, name, url) res0: Option[Profile] = Some(Profile(big_ben_clock, Big Ben, twitter.com/big_ben_clock)) 58
60. scala> for { | screenname <- author(id) | name <- name(screenname) | url <- url(screenname) | } yield Profile(screenname, name, url) res1: Future[Profile] = Promise$DefaultPromise@6329614f scala> res1 foreach println Profile(big_ben_clock, Big Ben, twitter.com/big_ben_clock)) 59
61. scala> for { | screenname <- author(id) | (name, url) <- | (name(screenname) |@| url(screenname)) {(_,_)} | } yield Profile(screenname, name, url) res2: Future[Profile] = Promise$DefaultPromise@1feca79a scala> res2 foreach println Profile(big_ben_clock, Big Ben, twitter.com/big_ben_clock)) 60
62. scala> for { | screenname <- author(id) | name <- name(screenname) | url <- url(screenname) | } yield Profile(screenname, name, url) res2: WriterT[Id.Id,List[String],Profile] = WriterT((List(fetching author…, fetching name…, fetching URL…), Profile(big_ben_clock, Big Ben, twitter.com/big_ben_clock))) 61
63. Discovering abstractions 62
64. def choice[A](cond: Par[Boolean]) (t: Par[A], f: Par[A]): Par[A] 63
65. def choiceList[A](n: Par[Int]) (choices: List[Par[A]]): Par[A] 64
66. def choiceMap[K,V](key: Par[K]) (choices: Map[K,Par[V]]): Par[V] 65
67. def chooser[A,B](pa: Par[A]) (choices: A => Par[B]): Par[B] 66
68. def flatMap[A,B](a: Par[A]) (f: A => Par[B]): Par[B] 67
69. Summary 68
70. Summary Monoids aggregate data (possibly in parallel) Applicative Functors combine independent computations Monads combine (possibly dependent) computations 69
71. Summary • These abstractions provide practical value • Scalaz provides high-quality implementation • Learn more about them • Try using them on your problems 70
72. Further Reading • Functional Programming in Scala • Typeclassopedia • Learning Scalaz • Typeclass 101 • Life After Monoids • Realtime MapReduce at Twitter • Eventually consistent computation with CRDTs • Comonads, Applicative Functors, Monads and Other Principled Things • Of Algebirds, Monoids, Monads, and Other Bestiary for Large-Scale Data Analytics • Functors, Applicatives, And Monads In Pictures • Abstraction, intuition, and the “monad tutorial fallacy” • Monads Are Not Metaphors • Scalaz Resources for Beginners • Rúnar Bjarnason • Paul Chiusano • Typelevel • Underscore 71
73. Alternatives • mpilquist/Structures • non/cats 72
74. Questions? Martin Kühl, EWERK IT @mkhl