Vamos supor que eu tenha uma classe de caso com a seguinte configuração:

case class Place(id:java.util.UUID, name:String)

Eu posso escrever um serializador (de trabalho!) Para esse tipo da seguinte maneira:

class placeSerializer extends CustomSerializer[Place]( format => (
        {
            case JObject(JField("id", JString(s)) :: JField("name",JString(x)) :: Nil ) =>
                Place(UUID.fromString(s), x)
        },
        {
            case x:Place =>
                JObject(
                  JField("id", JString(x.id.toString())) :: 
                  JField("name", JString(x.name)) :: Nil)
        }
        )
    )

Mas, supondo que minha classe de caso eventualmente tenha muito mais campos, isso poderia me levar a enumerar toda a estrutura do objeto com o AST, criando algo muito detalhado apenas para codificar os primitivos.

O json4s parece ter serializadores de campo que podem atuar apenas em campos específicos, com métodos padronizados incluídos para transformar facilmente nomes e descartar campos. Estes, no entanto, têm a seguinte assinatura paraserialize edeserialize funções parciais:

case class FieldSerializer[A: Manifest](
  serializer:   PartialFunction[(String, Any), Option[(String, Any)]] = Map(),
  deserializer: PartialFunction[JField, JField] = Map()
)

Desde aJField (o tipo que representa uma chave -> val do json) é seu próprio tipo e não uma subclasse deJValue, como posso combinar esses dois tipos de serializadores para codificar corretamente oid chave pelo seu nome para umUUID, mantendo a manipulação padrão dos outros campos (que são tipos de dados primitivos).

Essencialmente, eu gostaria de uma cadeia de formatos que entenda o campo dentroPlace é um UUID, sem precisar especificar a estrutura AST para todos os campos queDefaultFormats já pode lidar.

O que estou procurando especificamente é imitar um padrão semelhante aoJSONEncoder eJSONDecoder interfaces em python, que pode usar o nome da chave e o tipo de valor para determinar como lidar com a organização do campo.