add new typeclass EncodeJsonKey

src/main/scala/argonaut/EncodeJson.scala

@@ -153,10 +153,10 @@ trait EncodeJsons extends GeneratedEncodeJsons {
       e => jSingleObject("Failure", ea(e)), a => jSingleObject("Success", eb(a))
     ))
 
-  implicit def MapLikeEncodeJson[M[K, +V] <: Map[K, V], V](implicit e: EncodeJson[V]): EncodeJson[M[String, V]] =
+  implicit def MapLikeEncodeJson[M[K, +V] <: Map[K, V], K, V](implicit K: EncodeJsonKey[K], e: EncodeJson[V]): EncodeJson[M[K, V]] =
     EncodeJson(x => jObjectAssocList(
       x.toList map {
-        case (k, v) => (k, e(v))
+        case (k, v) => (K.toJsonKey(k), e(v))
       }
     ))
 
@@ -175,10 +175,10 @@ trait EncodeJsons extends GeneratedEncodeJsons {
   implicit def NonEmptyListEncodeJson[A: EncodeJson]: EncodeJson[NonEmptyList[A]] =
     fromFoldable[NonEmptyList, A]
 
-  implicit def IMapEncodeJson[A](implicit A: EncodeJson[A]): EncodeJson[String ==>> A] =
+  implicit def IMapEncodeJson[A, B](implicit A: EncodeJsonKey[A], B: EncodeJson[B]): EncodeJson[A ==>> B] =
     EncodeJson(x => jObjectAssocList(
       x.foldrWithKey(Nil: List[(String, Json)])(
-        (k, v, list) => (k, A(v)) :: list
+        (k, v, list) => (A.toJsonKey(k), B(v)) :: list
       )
     ))
 

src/main/scala/argonaut/EncodeJsonKey.scala

@@ -0,0 +1,47 @@
+package argonaut
+
+import scalaz.Contravariant
+
+/** A typeclass for encode an arbitrary value as a JSON key.
+ *
+ * @example {{{
+ * final case class Foo(value: String)
+ * object Foo {
+ *   implicit val instance: EncodeJsonKey[Foo] =
+ *     EncodeJsonKey.from(_.value)
+ * }
+ *
+ * EncodeJson.of[Map[Foo, Int]]
+ * }}}
+ */
+trait EncodeJsonKey[A] { self =>
+
+  def toJsonKey(key: A): String
+
+  final def contramap[B](f: B => A): EncodeJsonKey[B] =
+    new EncodeJsonKey[B] {
+      def toJsonKey(key: B) =
+        self.toJsonKey(f(key))
+    }
+
+}
+
+object EncodeJsonKey {
+
+  @inline def apply[A](implicit A: EncodeJsonKey[A]): EncodeJsonKey[A] = A
+
+  implicit val encodeJsonKeyInstance: Contravariant[EncodeJsonKey] =
+    new Contravariant[EncodeJsonKey] {
+      def contramap[A, B](r: EncodeJsonKey[A])(f: B => A) =
+        r contramap f
+    }
+
+  def from[A](f: A => String): EncodeJsonKey[A] =
+    new EncodeJsonKey[A] {
+      def toJsonKey(key: A) = f(key)
+    }
+
+  implicit val StringEncodeJsonKey: EncodeJsonKey[String] =
+    from(x => x)
+
+}

src/test/scala/argonaut/EncodeJsonSpecification.scala

@@ -34,6 +34,16 @@ object EncodeJsonSpecification extends Specification with ScalaCheck { def is =
     EncodeJson.of[(String, Int, Boolean, Long, Double)]
   }
 
+  object encodeJsonKey {
+    final case class Foo(value: String)
+    object Foo {
+      implicit val instance: EncodeJsonKey[Foo] =
+        EncodeJsonKey.from(_.value)
+    }
+
+    EncodeJson.of[Map[Foo, Int]]
+  }
+
   object derived {
     import TestTypes._