AndThen

A function type of a single input that can do function composition (via andThen and compose) in constant stack space with amortized linear time application (in the number of constituent functions).

Example:

 val seed = AndThen((x: Int) => x + 1)
 val f = (0 until 10000).foldLeft(seed)((acc, _) => acc.andThen(_ + 1))

 // This should not trigger stack overflow ;-)
 f(0)

This can be used to build stack safe data structures that make use of lambdas. The perfect candidates for usage with AndThen are the data structures using a signature like this (where F[_] is a monadic type):

 A => F[B]

As an example, if we described this data structure, the naive solution for that map is stack unsafe:

 case class Resource[F[_], A, B](
   acquire: F[A],
   use: A => F[B],
   release: A => F[Unit]) {

   def flatMap[C](f: B => C)(implicit F: Functor[F]): Resource[F, A, C] = {
     Resource(
       ra.acquire,
       // Stack Unsafe!
       a => ra.use(a).map(f),
       ra.release)
   }
 }

To describe a flatMap operation for this data type, AndThen can save the day:

 def flatMap[C](f: B => C)(implicit F: Functor[F]): Resource[F, A, C] = {
   Resource(
     ra.acquire,
     AndThen(ra.use).andThen(_.map(f)),
     ra.release)
 }