The Essence of the Iterator Pattern (pdf version)

2. Computation Functor
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