This document discusses different types of computations in functional programming such as Option, List, Future, State, and IO. It explains how to create computations of these types by wrapping values, and how to use computations by mapping and applying functions to the wrapped values. It also covers applicative functors and how they allow applying functions to multiple arguments wrapped in computations. Some examples of applicative operations on Option, List, Future, State and IO are given. Finally, it briefly discusses traversals, which allow transforming data structures of type F[A] to F[B] by applying a function A => F[B] to each element.

2. Computati Functo
on r
APPLICATIVE For loop
Traverse

3. Computation
K[T]
A type of A type of value
computation

4. Computations
Zero or one Option[T]
Zero or more List[T]
Later Future[T]
Depend on S State[S, T]
Ext. effects IO[T]

5. Create computations?
Option[T] Some(t)
List[T] List(t)
Future[T] future(t)
State[S, T] state(s => (s, t))
IO[T] IO(t)

6. Pointed
K[T].point(t)
Compute a value

7. Use computations?
Option[T] Some(2)
List[T] List(1, 2)
Future[T] future(calculate)
State[S, T] state(s => (s, s+1))
IO[T] IO(println(“hello”))

8. Functor
K[T] map f
Use the value

9. Functors map
Option[T] modify the value
List[T] modify the values
Future[T] modify later
State[S, T] modify ts
IO[T] modify the action

10. Applicative
Before
getUser(props: Properties): String
getPassword(props: Properties): String
getConnection(user: String, pw: String):
Connection = {
if (user != null && pw != null)
....
}
getConnection(getUser(p), getPassword(p))

11. Applicative
After
getUser(props: Properties): Option[String]
getPassword(props: Properties): Option[String]
getConnection(user: String, pw: String):
Connection = {
if (user != null && pw != null)
....
}
getConnection(?, ?)

12. Applicative
f(a, b)
How?
f(K[a], K[b])

13. Use Pointed
f(a:A, b:B): C
point
fk: K[A => B => C]

14. Applicative
K[A => B] <*> K[A]
==
K[B]
Apply the function

15. Applicative
K[A => B => C] <*>
K[A] <*> K[B]
==
K[B => C] <*> K[B]
==
Currying ftw!
K[C]

16. Applicative
K(f) <*> K(a) <*> K(b)
Apply „f‟ to „a‟ and „b‟ “inside” „K‟

17. Applicative
K(f) <*> K(a) <*> K(b)
Apply „f‟ to „a‟ and „b‟ “inside” „K‟

18. Applicative
Option
Some(getConnection.curried) <*>
user(p) <*>
password(p)

19. Applicative
Option
(user(p) <**> password(p))(mkConnection)
mkConnection <$> user(p) <*> password(p)

20. Applicative
Future
future(discount(_,_))) <*>
future(amount) <*>
future(rate)
: Future[Double]

21. Applicative
List
List(plus1) <*> List(1, 2, 3)
List(2, 3, 4)

22. Applicative
List
List(plus1, plus2) <*> List(1, 2, 3)
== List(2, 3, 4, 3, 4, 5)
ratings <*> clients

23. Applicative
ZipList
List(plus1, plus2, plus3) <*>
List(1, 2, 3)
== List(1, 4, 6)

24. Applicative State
val add = (i: Int) => (j: Int) => i+j
val times = (i: Int) => (j: Int) => i*j
// 0 -> 1, 2, 3, 4
val s1 = modify((i: Int) => i+1)
(add <$> s1 <*> s1)(1) == ?
(times <$> s1 <*> s1)(1) == ?

25. Applicative State
current state
+1=2 +1=3
(add <$> s1 <*> s1)(1) == (3, 5)
add 2 previous states
+1=2 +1=3
(times <$> s1 <*> s1)(1) == (3, 6)
multiply 2 previous states

26. Monad, remember?
Unit
def unit[A](a: =>A): M[A]
Bind
def bind[A, B](ma: M[A])(f: A => M[B]): M[B]

27. Monad => Applicative
Point
def point(a: =>A) = Monad[M].unit(a)
Apply
def <*>[A, B](mf: M[A=>B])(ma: M[A]):M[B] =
Monad[M].bind(mf) { f =>
Monad[M].bind(ma) { a =>
f(a) // M[B]
} // M[B]
} // M[B]

28. The “for” loop
val basket = Basket(orange, apple)
var count = 0
val juices = Basket[Juice]()
accumulation
for (fruit <- basket) {
count = count + 1
juices.add(fruit.press) “mapping”
}
same container for the result

30. Traverse
Traversable
def traverse(f: A => F[B]): T[A] => F[T[B]]
Applicative Same
structure

31. Traverse a List
List(x, y, z): List[A]
f: A => F[B]

32. Traverse a List
Apply „f‟ to „z‟
F(::) <*> F(z) <*> F(Nil)
“Rebuild” the list
F(z :: Nil)

33. Traverse a List
F(::) <*> F(y) <*> F(z :: Nil)
F(y :: z :: Nil)
F(::) <*> F(x) <*> F(y::z::Nil)
F(x :: y :: z :: Nil)

34. Traverse a
Binary Tree
f
x
y z
x
x
y z y z
y z

35. `sequence`
def sequence[F: Applicative]:
T[F[A]] => F[T[A]] =
traverse(identity)

36. `sequence`
Execute concurrently?
val examples: Seq[Example] =
Seq(e1, e2, e3)
Sequence of promises
val executing: Seq[Promise[Result]] =
examples.map(e => promise(e.execute))
val results: Promise[Seq[Result]] =
executing.sequence
Promise of a sequence

37. Measure with
Monoids
trait Monoid[A] {
val zero: A; def append(a: A, b: A): A
}
def measure[T: Traversable, M : Monoid]
(f: A => M): T[A] => M
Count elements: Int Monoid
Accumulate elements: List Monoid

38. `measure`
def measure[T: Traversable, M : Monoid]
(f: A => M) =
traverse(a => f(a))

39. `Const`
“Phantom “ type
case class Const[M, +A](value: M)
new Applicative[Const[M, *]] {
def point(a: =>A) = Const(Monoid[M].zero)
def <*>(f: Const[M, A=>B], a: Const[M, A]) =
Const(Monoid[M].append(f.value, a.value))
}

40. Applicative => Monad
Unit
def unit[A](a: =>A) = Const(Monoid[M].zero)
Bind
def bind[A, B](ma: Const[M, A])
(f: A => Const[M, B]) =
=> but no value `a: A` to be found!

41. `measure`
Sum up all sizes
def sumSizes[A : Size](seq: Seq[A]) =
measure(a => Size[A].size(a))(seq)
Collect all sizes
def collectSizes[A : Size](seq: Seq[A]) =
measure(a => List(Size[A].size(a)))(seq)

42. `contents`
def contents[A](tree: Tree[A]): List[A] =
measure(a => List(a))(tree)
x
=> List(x, y, z)
y z

43. `shape`
def shape[A](tree: Tree[A]): Tree[Unit] =
map(a => ())(tree)
x
=> .
y z . .
def map[A, B](f: A => B): T[A] =>
traverse(a => Ident(f(a)))
Identity monad

44. `decompose`
def decompose[A](tree: Tree[A]) =
(contents(tree), shape(tree))
List(x, y, z)
x
=>
y z .
. .
Not very efficient…

45. Applicative products
case class Product[F1[_], F2[_], A](
first: F1[A], second: F2[A])
F1: Applicative, F2: Applicative
def point[A, B](a: => A) =
Product[F1, F2, B](Pointed[F1].point(a),
Pointed[F2].point(a))
def <*>[A, B](f: Product[F1, F2, A => B]) =
(c: Product[F1, F2, A]) =>
Product[F1, F2, B](f.first <*> c.first,
f.second <*> c.second)

46. `contents ⊗ shape`
F1 = Const[List[A], *]
F2 = Ident[*]
val contents = (a: A) => Const[List[A], Unit](List(a))
val shape = (a: A) => Ident(())
val contentsAndShape:
A => Product[Const[List[A], _], Ident[_], *] =
contents ⊗ shape
tree.traverse(contentsAndShape)

47. Type indifference 
One parameter type constructor
trait Apply[F[_]] {
def <*>[A, B](f: F[A => B]): F[A] => F[B]
}
List[Int]: Monoid Applicative => Const[List[Int], _]
({type l[a]=Const[List[Int], a]})#l

48. Type indifference 
Anonymous type
({type l[a]=Const[List[Int], a]})#l
Type member
({type l[a]=Const[List[Int], a]})#l
Type projection
({type l[a]=Const[List[Int], a]})#l
type ApplicativeProduct =
({type l[a]=Product[Const[List[A],_],Ident[_],a]})#l

49. Type indifference 
Measure
def measure[M : Monoid](f: T => M): M =
traverse(t => Monoid[M].unit(f(t))).value
For real…
def measure[M : Monoid](f: A => M): M =
traverse[(type l[a]=Const[M, a]})#l, A, Any] { t =>
Monoid[M].point(f(t))
}.value

50. `collect`
Accumulate and map
def collect[F[_] : Applicative, A, B]
(f: A => F[Unit], g: A => B) = {
traverse { a: A =>
Applicative[F].point((u: Unit) => g(a)) <*> f(a))
}
}
val count = (i: Int) => state((n: Int) => (n+1, ()))
val map = (i: Int) => i.toString
tree.collect(count, map).apply(0)
 (2, Bin(Leaf("1"), Leaf("2")))

51. `disperse`
Label and map
def disperse(F[_] : Applicative, A, B, C]
(f: F[B], g: A => B => C): T[A] => F[T[C]]
val tree = Bin(Leaf(1.1), Bin(Leaf(2.2), Leaf(3.3)))
val label = modify((n:Int) => n+1)
val name = (p1:Double) => (p2:Int) => p1+" node is "+p2
tree.disperse(label, name).apply(0)._2
 Bin(Leaf("1.1 node is 1"),
Bin(Leaf("2.2 node is 2"), Leaf("3.3 node is 3")))

52. EIP `measure`
Map and count
def measure[F[_] : Applicative, A, B]
(f: F[B], g: A => C): T[A] => F[C]
val crosses = modify((s: String) => s+"x")
val map = (i: Int) => i.toString
tree.measure(crosses, map).apply("")
("xxx", Bin(Leaf("1"), Bin(Leaf("2"),
Leaf("3"))))

53. Traversals
mapped depend state depend on
function map element create state
on state element
collect X X X
disperse X X X
measure X X
traverse X X X X
reduce X X
reduceConst X
map X

54. Quizz
def findMatches(divs: Seq[Int], nums: Seq[Int])
findMatches(Seq(2, 3, 4), Seq(1, 6, 7, 8, 9))
=> Seq((2, 6), (3, 9), (4, 8))
With Traverse?

55. Quizz
def findMatches(divs: Seq[Int], nums: Seq[Int]) = {
case class S(matches: Seq[(Int, Int)] = Seq[(Int, Int)](),
remaining: Seq[Int])
val initialState = S(remaining = nums)
def find(div: Int) = modify { (s: S) =>
s.remaining.find(_ % div == 0).map { (n: Int) =>
S(s.matches :+ div -> n, s.remaining - n)
}.getOrElse(s)
}
divs.traverse(find).exec(initialState).matches
}

56. Composition
val results = new ListBuffer
for (a <- as) {
val currentSize = a.size
total += currentSize
results.add(total)
}
F1 (map) then F2 (sum)
F2 [F1[_]] => Applicative?

57. `assemble`
Shape + content => assembled
def assemble[F[_] : Applicative, A]:
(f: F[Unit], g: List[A]): T[A] => F[A]
val shape: BinaryTree[Unit] = Bin(Leaf(()), Leaf(()))
shape.assemble(List(1, 2))
 (List(), Some(Bin(Leaf(1), Leaf(2))))
shape.assemble(List(1, 2, 3))
 (List(3), Some(Bin(Leaf(1), Leaf(2))))
shape.assemble(List(1))
 (List(), None)

58. `assemble`
def takeHead: State[List[B], Option[B]] =
state { s: List[B] =>
s match {
case Nil => (Nil, None)
case x :: xs => (xs, Some(x))
}
}
F1: Option[_] An element to insert
F2 :State[List[A], _] the rest of the list
F2 [F1]: State[List[A], Option[_]] An applicative

59. `assemble`
def assemble[F[_] : Applicative, A]
(f: F[Unit], list: List[A]) =
traverse(takeHead).apply(list)

60. Monadic composition
M : Monad
val f: B => M[C]
val g: A => M[B]
val h: A => M[C] = f • g
Fusion?
traverse(f) • traverse(g) == traverse(f • g)

61. Monadic composition
Yes if the Monad is commutative
val xy = for { val yx = for {
x <- (mx: M[X]) y <- (my: M[Y])
xy == yx
y <- (my: M[Y]) x <- (mx: M[X])
} yield (x, y) } yield (x, y)
State is *not* commutative
val mx = state((n: Int) => (n+1, n+1))
val my = state((n: Int) => (n+1, n+1))
xy.apply(0) == (2, (1, 2))
yx.apply(0) == (2, (2, 1))

62. Applicative composition vs
Monadic composition
Not commutative functions => fusion
Seq(1,2,3).traverse(times2 ⊙ plus1) == 4
 State[Int, State[Int, Seq[Int]]]
Seq(1,2,3).traverse(times2) ⊙
Seq(1,2,3).traverse(plus1) == 4
 State[Int, Seq[State[Int, Int]]

63. Monadic composition:
conjecture
Commutative functions
val plus1 = (a: A) => state((n: Int) => (n+1, a))
val plus2 = (a: A) => state((n: Int) => (n+2, a))
val times2 = (a: A) => state((n: Int) => (n*2, a))
plus1 and plus2 are commutative
plus1 and times2 are not commutative:
(0 + 1) * 2 != (0 * 2) + 1

64. Monadic composition:
conjecture
Commutative functions => fusion
Seq(1,2,3).traverse(plus2 ∎ plus1) == 10
Seq(1,2,3).traverse(plus2) ∎
Seq(1,2,3).traverse(plus1) == 10
Not commutative functions => no fusion
Seq(1,2,3).traverse(times2 ∎ plus1) == 22
Seq(1,2,3).traverse(times2) ∎
Seq(1,2,3).traverse(plus1) == 32