Thesis
?Download as PPT, PDF?
1 like?207 views
Monads are functional programming abstractions that allow computations to be structured and composed in a purely functional way. They provide a way to compose functions of different types by lifting them to work on a computational context. Functors are containers that lift functions of one argument to work on their context. Applicative functors generalize this to lift functions of multiple arguments. Monads build on applicative functors by allowing computations to be chained sequentially through flatMap. In Scala, monadic code can be written using for-comprehensions, which recognize monadic patterns.
![Functors are containers
Type Constructors - F[A]](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-8-320.jpg)
Apply the function f to each element
Higher Order Functions
Higher Order Functions](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-10-320.jpg)
 {
def map[B](f: A => B) = Identity(f(value))
def flatMap[B](f: A => Identity[B]) (value)
def unit(a: A) = Identity(a)
}](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-23-320.jpg)
![object Monoid {
def append(a1: List[A], a2: List[A]) = a1 ::: a2
def empty = Nil
}](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-24-320.jpg)
 {
def map[B](f: A => B) = Writer(log, f(value))
def flatMap[B](f: A => Writer[Log, B])(m: Monoid[Log]) = {
val x: Writer[Log,B] = f(value)
Writer(m.append(log, x.log), x.value)
}
def unit[Log, A](value: A)(m: Monoid[Log]) =
Writer(m.empty, value)
}](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-25-320.jpg)
![def main(args: Array[String]) {
val start = 3
val finalWriter =
for(a <- addOne(start);
b <- intString(a);
c <- lengthGreaterThan5(b);
d <- noLog(oneOrZero(c));
e <- squareOf(d)
) yield e
}
¡°Adding one to 3.
Changing 4 to a String.
Checking if length is greater than 5.
Squaring 1.¡±](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-26-320.jpg)
![case class Transaction(memberInfo: Option[MemberInfo], id: String)
case class MemberInfo(privateInfo: Option[PrivateMember], birthdate:
String)
case class PrivateInfo(socialSecurityNumber: String)
val ssNumber = ¡°389-39-2983¡±
val priv = PrivateInfo(ssNumber)
val member = MemberInfo(priv, ¡°10-20-87¡±)
val optionalTransaction = Transaction(member, ¡°28948¡±)
for {
transaction <- optionalTransaction
memberInfo <- transaction.memberInfo
privInformation <- memberInfo.privateInfo
}
yield privInformation.socialSecurityNumber](https://image.slidesharecdn.com/thesis-121213231343-phpapp01/85/Thesis-31-320.jpg)
Thesis
- 2. Paradigm Blend Knowledge Gap for Devs
- 3. Those interested in Monads have no good starting places Category Theory
- 4. Functional abstractions are patterns Origin in math
- 5. What¡¯s a Monad? A Monad is just a Monoid in the category of endofunctors
- 7. Functors From the ground up
- 8. Functors are containers Type Constructors - F[A]
- 9. Functors need to have a Map function map You did take PLP with Wallingford, right?
- 10. def map[A,B](cont: List[A], f: A => B) Apply the function f to each element Higher Order Functions Higher Order Functions
- 11. Functors need a map method Functors are containers Lift arity-1 function to a function that works on computational context
- 12. Applicative Functors Applicative Functors currying functions is fun
- 13. Lifts an n-arity function to work on computational context through currying. Currying? x => (y => x + y)
- 14. Applicative is just a more generalized Functor
- 15. Applicative Style pure(+) <*> pure(3) <*> pure(4)
- 16. Recap: Functors lift 1-arity Applic lift n-arity
- 18. Type-class which have values that can be combined Binary operation must be associative
- 19. object StringMonoid { def mAppend(x: String, y: String): String = x + y def mEmpty: String = "" }
- 21. Structure computations Compose functions of different types that can be logically combined
- 22. Monads in a purely functional language (Haskell) Monads in Scala
- 23. case class Identity[A](value: A) { def map[B](f: A => B) = Identity(f(value)) def flatMap[B](f: A => Identity[B]) (value) def unit(a: A) = Identity(a) }
- 24. object Monoid { def append(a1: List[A], a2: List[A]) = a1 ::: a2 def empty = Nil }
- 25. case class Writer[Log, A](log: Log, value: A) { def map[B](f: A => B) = Writer(log, f(value)) def flatMap[B](f: A => Writer[Log, B])(m: Monoid[Log]) = { val x: Writer[Log,B] = f(value) Writer(m.append(log, x.log), x.value) } def unit[Log, A](value: A)(m: Monoid[Log]) = Writer(m.empty, value) }
- 26. def main(args: Array[String]) { val start = 3 val finalWriter = for(a <- addOne(start); b <- intString(a); c <- lengthGreaterThan5(b); d <- noLog(oneOrZero(c)); e <- squareOf(d) ) yield e } ¡°Adding one to 3. Changing 4 to a String. Checking if length is greater than 5. Squaring 1.¡±
- 27. FIN?
- 28. Monads and Scala For - Comprehensions
- 29. Scala has Monads everywhere! Scala recognizes monadic code.
- 30. val first = List(1) val second = List(4) val third = List(8) for { first flatMap { x <- first x => second flatMap { y <- second y=> third map { z <- third z => x + y + z } ) yield ( x + y + z) ) )
- 31. case class Transaction(memberInfo: Option[MemberInfo], id: String) case class MemberInfo(privateInfo: Option[PrivateMember], birthdate: String) case class PrivateInfo(socialSecurityNumber: String) val ssNumber = ¡°389-39-2983¡± val priv = PrivateInfo(ssNumber) val member = MemberInfo(priv, ¡°10-20-87¡±) val optionalTransaction = Transaction(member, ¡°28948¡±) for { transaction <- optionalTransaction memberInfo <- transaction.memberInfo privInformation <- memberInfo.privateInfo } yield privInformation.socialSecurityNumber