Mappy.scala

import scala.language.higherKinds
import scalaz.{Applicative, Traverse}

import scalaz.\/
import scalaz.std.list._
import scalaz.std.option._
import scalaz.syntax.either._
import scalaz.syntax.traverse._

object Mappy {

  implicit def mapTrav[K] = new Traverse[Map[K, ?]] {
    def traverseImpl[G[_], A, B](fa: Map[K, A])(f: A => G[B])
                                (implicit ap: Applicative[G]): G[Map[K, B]] =
      ap.map(fa.toList.map { case (s,a) =>
        ap.apply2(ap.point(s), f(a))((s,g) => (s,g))
      }.sequenceU)(_.toMap)
  }

  def happy[F[_],A,B](m:Map[A, F[B]])
                     (implicit ap: Applicative[F]): F[Map[A,B]] = m.sequence

  def main(args: Array[String]): Unit = {
    println(happy(Map("hi" -> List(1,2), "bye" -> List(3,4))))
    println(happy(Map("hi" -> Some(1),   "bye" -> None)))
    println(happy(Map("hi" -> Option(1), "bye" -> Option(2))))

    type T[A] = String \/ A
    println(happy[T,String,Int](
      Map("hi" -> 1.right, "bye" -> 2.right))
    )
    println(happy[T,String,Int](
      Map("hi" -> 1.right, "err" -> "err".left, "bye" -> 2.right))
    )
  }
}

/*
Output from main:

List(Map(hi -> 1, bye -> 3), Map(hi -> 1, bye -> 4), Map(hi -> 2, bye -> 3), Map(hi -> 2, bye -> 4))
None
Some(Map(hi -> 1, bye -> 2))
\/-(Map(hi -> 1, bye -> 2))
-\/(err)

*/