Applicative for Chunk[A] (A \/ StreamT[Future, A])

Chunk.scala

import scala.concurrent.{Future, ExecutionContext}
import scalaz._, Scalaz._

object Chunk {
  type Chunk[A] = A \/ StreamT[Future, A]

  implicit def ApplicativeChunk: Applicative[Chunk] = new Applicative[Chunk] {
    def point[A](a: => A) = a.left
    override def map[A, B](fa: Chunk[A])(f: A => B): Chunk[B] =
      fa match {
        case -\/(a) => f(a).left
        case \/-(s) => (s map f).right
      }
    def ap[A, B](fa: => Chunk[A])(ff: => Chunk[A => B]): Chunk[B] =
      fa match {
        case -\/(a) => ff match {
          case -\/(f) => f(a).left
          case \/-(s) => s.map(f => f(a)).right
        }
        case \/-(as) => ff match {
          case -\/(f) => as.map(a => f(a)).right
          case \/-(s) => as.flatMap(a => s.map(f => f(a))).right
        }
      }
  }


  // Not sure what Future you meant, but I assume you can have an applicative for it...
  implicit def Bletch: ExecutionContext = sys.error("Use a better future!")

  implicit def FutureApplicative(implicit ctx: ExecutionContext): Applicative[Future] = new Applicative[Future] {
    def point[A](a: => A) = Future(a)(ctx)
    override def map[A, B](fa: Future[A])(f: A => B): Future[B] =
      fa.map(f)(ctx)
    def ap[A, B](fa: => Future[A])(f: => Future[A => B]): Future[B] =
      fa.zip(f).map({case (a, f) => f(a)})(ctx)
  }
}