Как выразить этот тип в Scala? Экзистенциальный с ограничением класса типа (т. е. неявным)?

Поскольку каждое поле имеет свой тип, вам потребуется один параметр типа для каждого поля. Это связано с тем, что для записи этих полей вам необходимо предоставить (неявно) экземпляры Writes для соответствующих типов (для метода toJson), и они разрешаются статически.

Одним из решений для обхода этого является разделение процесса на две части: один метод, который вы вызываете для каждого поля, чтобы извлечь метод доступа к полю и упаковать его с соответствующим экземпляром WriteS (это можно даже сделать неявным преобразованием из пар, которые вы уже проходят), и один метод, который берет все и создает окончательный экземпляр WriteS. Что-то вроде этого (иллюстративный, непроверенный):

class WriteSFieldAccessor[C,T] private ( val title: String, val accessor: C => Any )( implicit val writes: Writes[T] )

implicit def toWriteSFieldAccessor[C,T:Writes]( titleAndAccessor: (String, C => T) ): WriteSFieldAccessor = {
  new WriteSFieldAccessor[C,T]( titleAndAccessor._1, titleAndAccessor._2 )
}
def makeSimpleWrites[C](fields: WriteSFieldAccessor[C,_]*) : Writes[C] = {
  new Writes[C] {
    def writes(c: C) : JsValue = {
      val jsFields = fields map { f: WriteSFieldAccessor => 
        val jsField = toJson[Any](f.accessor(c))(f.writes.asInstanceOf[Writes[Any]])
        (f.title, jsField)
      }
      JsObject(jsFields)
    }
  }
}

// Each pair below is implicitly converted to a WriteSFieldAccessor  instance, capturing the required information and passing it to makeSimpleWrites
implicit val fooWrites : Writes[Foo] = makeSimpleWrites[Foo]("title" -> {_.title}, "lines" -> {_.lines}) 

Самое интересное toJson[Any](f.accessor(c))(f.writes..asInstanceOf[Writes[Any]]). Вы просто передаете Any как статический тип, но явно передаете (обычно неявный) экземпляр Writes.

При попытке устранить ограничение, согласно которому в моем первом решении нужно писать "title" -> {s:Section => s.title} вместо "title" -> {_.title}, я немного повозился с ним, только чтобы все время работать с ограничением вывода scala. Поэтому я решил попробовать решить эту проблему с другой стороны и нашел совершенно другое решение. Это в основном квази-DSL:

class ExpandableWrites[C]( val fields: Vector[(String, C => Any, Writes[_])] ) extends Writes[C] {
  def and[T:Writes](fieldAccessor: C => T)(fieldName: String): ExpandableWrites[C] = {
    new ExpandableWrites( fields :+ (fieldName, fieldAccessor, implicitly[Writes[T]]) )
  }
  def writes(c: C) : JsValue = {
    val jsFields = fields map { case (name, get, writes) => (name, toJson[Any](get(c))(writes.asInstanceOf[Writes[Any]]) )}
    JsObject(jsFields)
  }
}

class UnaryExpandableWritesFactory[C] {
  def using[T:Writes](fieldAccessor: C => T)(fieldName: String): ExpandableWrites[C] = {
    new ExpandableWrites[C]( Vector( (fieldName, fieldAccessor, implicitly[Writes[T]] ) ) )
  }
}

def makeSimpleWritesFor[C] = new UnaryExpandableWritesFactory[C]

implicit val fooWrites : Writes[Foo] = 
  makeSimpleWritesFor[Foo].using(_.title)("title") .and (_.lines)("lines") .and (_.date)("date")

Идея состоит в том, что вы шаг за шагом создаете экземпляр Writes и добавляете в него новые поля одно за другим. Единственное раздражение заключается в том, что вам нужен разделитель .and, включая точку. Без точки (то есть с использованием инфиксной нотации) компилятор, кажется, снова запутался и жалуется, если мы просто делаем (_.title) вместо (s:Section => s.title).

По крайней мере, на 25 января 2015 года play-json уже имеет встроенный способ делать то, что вы хотите:

import play.api.libs.json._
import play.api.libs.functional.syntax._

sealed case class Foo(title: String, lines: List[String])  // the `sealed` bit is not relevant but I always seal my ADTs

implicit val fooWrites = (
  (__ \ "title").write[String] ~
  (__ \ "lines").write[List[String]]
)(unlift(Foo.unapply))

на самом деле это работает и с Reads[T]

implicit val fooReads = (
  (__ \ "title").read[String] ~
  (-- \ "lines").read[List[String]]
)(Foo.apply _)

и Format[T]:

implicit val fooFormat = (
  (__ \ "title").format[String] ~
  (-- \ "lines").format[List[String]]
)(Foo.apply _, unlift(Foo.unapply))

вы также можете применять преобразования, например:

implicit val fooReads = (
  (__ \ "title").read[String].map(_.toLowerCase) ~
  (-- \ "lines").read[List[String]].map(_.filter(_.nonEmpty))
)(Foo.apply _)

или даже двусторонние преобразования:

implicit val fooFormat = (
  (__ \ "title").format[String].inmap(_.toLowerCase, _.toUpperCase) ~
  (-- \ "lines").format[List[String]]
)(Foo.apply _, unlift(Foo.unapply))