Applicative and Traversable Functors

An example from the standard library

One of the most useful functions when working with scala.concurrent.Future is Future.traverse, presented below in a simplified form.

import scala.concurrent.{ExecutionContext, Future}

def traverseFuture[A, B](as: List[A])(f: A => Future[B])(implicit ec: ExecutionContext): Future[List[B]] =

traverseFuture takes a List[A] and for each A in the list applies the function f to it, gathering results as it goes along. f is often referred to as an effectful function, where the Future effect is running the computation concurrently, presumably on another thread. This effect is apparent in the result of the function, which has gathered results inside Future.

But what if the effect we wanted wasn’t Future? What if instead of concurrency for our effect we wanted validation (Option, Either, Validated) or State ? It turns out we can abstract out the commonalities between all these data types and write a generic traverse function once and for all. We can even go further and abstract over data types that can be traversed over such as List, Vector, and Option.

In this series we will build up the machinery needed to generalize the standard library’s Future.traverse into its fully abstract and most reusable form.

If you’d like to read the published literature on these ideas, some good starting points are “Applicative Programming with Effects” by McBride and Patterson, and “The Essence of the Iterator Pattern” by Gibbons and Oliveira.