Traverse allows running actions over data structures and accumulating results. It traverses data like lists and vectors, running an applicative functor like Future or Option for each element. Variations include parallel, non-empty, unordered, and flat traversals. Traverse underpins many operations and is a powerful abstraction for representing imperative loops in a functional way.

1. TRAVERSALS FOR ALL
OCCASIONS
Luka Jacobowitz

2. Software Developer at codecentric
Co-organizer of ScalaDus and
IdrisDus
Maintainer of cats, cats-effect,
cats-mtl, OutWatch
Enthusiastic about FP
About me

3. Motivation
● Traversable is my favorite type class
● Not enough people know about it
● Even less people know about some of the less common traversals out there
● Have some fun while learning!

4. Motivation

5. Teaser
How do you create a List of Http Requests run them all in parallel and if errors
occur accumulate them?
userIdList.parTraverse(request).value

6. Traverse
[T[_]: Traverse, F[_]: Applicative, A]: T[F[A]] => F[T[A]]
E.g.
List[Future[A]] => Future[List[A]]
Vector[Option[A]] => Option[Vector[A]]

7. Traverse
[T[_]: Traverse, F[_]: Applicative, A]: T[F[A]] => F[T[A]]
Traverse runs an action(F[_]) for every element in a data structure (T[_]), and
accumulates the results.

8. Traverse
trait Applicative[F[_]] {
def map2[A, B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C]
def pure[A](a: A): F[A]
}
Applicatives allow us to combine two or more independent values inside a
context.

9. Traverse
trait Traverse[T[_]] {
def sequence[F[_]: Applicative, A](tfa: T[F[A]]): F[T[A]]
def traverse[F[_]: Applicative, A, B](ta: T[A], f: A => F[B]): F[T[B]]
}
t.traverse(f) <-> t.map(f).sequence

10. Traverse
List[Future[A]] => Future[List[A]]
Vector[Option[A]] => Option[Vector[A]]
Either[E, IO[A]] => IO[Either[E, A]]
type EitherE[A] = Either[E, A]
List[Validated[E, A]] => Validated[E, List[A]]

11. FoldMap
trait Foldable[T[_]] {
def foldMap[A, M: Monoid](ta: T[A], f: A => M): M
def fold[M: Monoid](ta: T[M]): M
}
t.foldMap(f) <-> t.map(f).fold
def foldMap[A, M: Monoid](ta: T[A], f: A => M): M =
ta.traverse(a => Const(f(a))).getConst

12. NonEmpty
trait Reducible[T[_]] {
def reduceMap[A, S: Semigroup](ta: T[A], f: A => S): S
def reduce[S: Semigroup](ta: T[S]): S
}
trait NonEmptyTraverse[T[_]] {
def nonEmptyTraverse[F[_]: Apply](ta: T[A], f: A => F[B]): F[T[B]]
def nonEmptySequence[F[_]: Apply](ta: T[F[A]]): F[T[A]]
}
t.reduceMap(f) <-> t.map(f).reduce
t.nonEmptyTraverse(f) <-> t.map(f).nonEmptySequence

13. NonEmpty
def maximum[A: Order](nel: NonEmptyList[A]): A =
reduceMap(nel)(Max)
def minimum[A: Order](nel: NonEmptyList[A]): A =
reduceMap(nel)(Min)

14. NonEmpty
def countWords(text: String): Map[String, Int] =
words.split(" ").groupBy(identity).mapValues(_.length)
val lines: NonEmptyList[String]
val result: Map[String, NonEmptyList[Int]] =
lines.nonEmptyTraverse(countWords)

15. Commutativity
trait UnorderedFoldable[T[_]] {
def unorderedFold[M: CommutativeMonoid](ta: T[M]): M
}
trait UnorderedTraverse[T[_]] {
def unorderedSequence[F[_]: CommutativeApplicative, A]
(ta: T[F[A]]): F[T[A]]
}

16. Commutativity
CommutativeMonoid:
a |+| b <-> b |+| a
E.g: Int, Set[String]

17. Commutativity
val users: HashSet[User]
val result =
users.unorderedFoldMap(_.billableHours)

18. Commutativity
CommutativeApplicative:
map2(fa, fb)((a, b) => f(a, b)) <-> map2(fb, fa)((b, a) => f(a, b))
fa *> fb <-> fb <* fa
E.g. Option, ValidatedNes

19. Commutativity
type ValidatedNes[E, A] = Validated[NonEmptySet[E], A]
val result: ValidatedNes[Error, RDD[User]] =
users.unorderedTraverse(validate)

20. FlatTraverse
trait Traverse[T[_]] {
def flatTraverse[G[_]: Applicative, A, B](ta: T[A])
(f: A => G[T[B]])(implicit T: FlatMap[T]): G[T[B]]
}
ta.traverse(f).map(_.flatten) <-> ta.flatTraverse(f)

21. FlatTraverse
val maybeUser: Option[User]
def fetchAddress(user: User): IO[Option[Address]]
val result: IO[Option[Address]] =
maybeUser.flatTraverse(fetchAddress)

22. Parallelism
trait Parallel[M[_]: Monad, F[_]: Applicative] {
def parallel: FunctionK[M, F]
def sequential: FunctionK[F, M]
}
def parSequence[T[_], M[_], F[_], A](ta: T[M[A]])
(implicit P: Parallel[M, F], T: Traverse[T]): M[T[A]]

23. Revisiting the teaser
def request(userId: Int): EitherT[IO, Nel[Error], User]
val result: IO[EitherNel[Error, List[User]]] =
userIdList.parTraverse(request).value
EitherT[IO, E, A] ⇔ Nested[ParIO, Validated[E, ?], A]
IO[Either[E, A]] ⇔ ParIO[Validated[E, A]]

24. Other traversals
traverseWithIndex
unorderedFlatTraverse
traverseWithIndexM
traverse_
parFlatTraverse
nonEmptyFlatTraverse
parNonEmptyFlatTraverse
parNonEmptyUnorderedTraverse

25. Other traversals
traverseWithIndex
unorderedFlatTraverse
traverseWithIndexM
traverse_
parFlatTraverse
nonEmptyFlatTraverse
parNonEmptyFlatTraverse
parNonEmptyUnorderedTraverse
+ Sequence versions
+ Almost every other
conceivable
combination

26. Useful stuff!
def parNonEmptyUnorderedSequence
[T[_]: NonEmptyUnorderedTraverse, M[_], F[_], A](ta: T[M[A]])
(implicit P: NonEmptyCommutativeParallel[M, F]): M[T[A]]
What could possibly be an instance for this???
NonEmptyUnorderedTraverse: NonEmptyRDD, NonEmptyHashMap
NonEmptyCommutativeParallel: NonEmptyList ⇔ NonEmptyZipList

27. Useful stuff!
def groupByNem[A, K](nel: NonEmptyList[A])
(f: A => K): NonEmptyHashMap[K, NonEmptyList[A]]
users.groupByNem(_.address)
.parNonEmptyUnorderedSequence

28. Summary
Traverse is a great abstraction, because it allows us to traverse data structures
using Applicative Functors, which represent independent computations.
These traversals capture the essence of imperative loops over these data
structures.
We can add or remove constraints to the action(F[_]) or the structure types(T[_])
to get slightly different traversals.

29. Thank you all for
listening!
Twitter:
@LukaJacobowitz
GitHub:
LukaJCB