Provides a mechanism to convert between two higher kinded types.

This is commonly used to interleave other types into an interpreted uniform journey (for example API calls returning a Future[A] could be mapped to WebMonad[Html, A] in an interpretation targetting WebMonad[Html, *]).

If the journey contains convert(x: E[A]) then there must be an implicit Converter[E, F, A] in scope when interpreting to the F higher kinded type.

The most general way is to use a natural transformation E ~> F (from all possible A convert E[A] to F[A]), which will be implicitly converted into an Converter as needed

The intermediate form is to use a function from E[A] => F[A], which is specific to the type A, and could differ from E[B] => F[B] in implementation. As with a natural transformation this will be converted as needed.

The least general form is to extend Converter, this makes it possible to change the way the conversion is handled by key as well as by datatype.

implicit val converter = new Converter[List, Option, Int] {
  def apply(key: String, in: () => List[Int]): Option[Int] =
    key match {
      case "reverse" => in().lastOption
      case _ => in().headOption
    }
}