play-json на AST с параметрами типа

Хотя я думаю, что вам следует попробовать какую-нибудь библиотеку на основе макросов, которую можно найти, погуглив «запечатанную черту воспроизведения json», например Воспроизведите кодеки, производные от JSON , вот написанное от руки решение, которое может вам подойти:

object PlayJson {

  import play.api.libs.json._

  // fake types instead of your real ones
  type ResStart = Int
  type ResEnd = Int
  type Center = Int

  sealed trait Rule[A] {
    def roomId: Option[Long] = None

    def valid(in: A): Boolean
  }

  sealed trait ValueRule[A, B] extends Rule[A] {
    def value: B
  }

  sealed trait NoValueRule[A] extends Rule[A]

  case class OnlyDuringWorkHours(override val roomId: Option[Long] = None) extends NoValueRule[((ResStart, ResEnd), Center)] {
    override def valid(in: ((ResStart, ResEnd), Center)): Boolean = true
  }

  case class MaxLeadTime(override val roomId: Option[Long] = None, override val value: Int) extends ValueRule[ResStart, Int] {
    override def valid(in: ResStart): Boolean = true
  }

  case class MaxDuration(override val roomId: Option[Long] = None, override val value: String) extends ValueRule[(ResStart, ResEnd), String] {
    override def valid(in: (ResStart, ResEnd)): Boolean = true
  }

  case class Rules(centerId: Long, ruleList: Seq[Rule[_]])


  object CompoundFormat {
    final val discriminatorKey = "$type$"

    private case class UnsafeFormatWrapper[U, R <: U : ClassTag](format: OFormat[R]) extends OFormat[U] {
      def typeName: String = {
        val clazz = implicitly[ClassTag[R]].runtimeClass
        try {
          clazz.getSimpleName
        }
        catch {
          // getSimpleName might fail for inner classes because of the name mangling
          case _: InternalError => clazz.getName
        }
      }

      override def reads(json: JsValue): JsResult[U] = format.reads(json)

      override def writes(o: U): JsObject = {
        val base = format.writes(o.asInstanceOf[R])
        base + (discriminatorKey, JsString(typeName))
      }
    }

  }

  class CompoundFormat[A]() extends OFormat[A] {

    import CompoundFormat._

    private val innerFormatsByName = mutable.Map.empty[String, UnsafeFormatWrapper[A, _]]
    private val innerFormatsByClass = mutable.Map.empty[Class[_], UnsafeFormatWrapper[A, _]]

    override def reads(json: JsValue): JsResult[A] = {
      val jsObject = json.asInstanceOf[JsObject]
      val name = jsObject(discriminatorKey).asInstanceOf[JsString].value
      val innerFormat = innerFormatsByName.getOrElse(name, throw new RuntimeException(s"Unknown child type $name"))
      innerFormat.reads(jsObject)
    }

    override def writes(o: A): JsObject = {
      val innerFormat = innerFormatsByClass.getOrElse(o.getClass, throw new RuntimeException(s"Unknown child type ${o.getClass}"))
      innerFormat.writes(o)
    }

    def addSubType[R <: A : ClassTag](format: OFormat[R]): Unit = {
      val wrapper = new UnsafeFormatWrapper[A, R](format)
      innerFormatsByName.put(wrapper.typeName, wrapper)
      innerFormatsByClass.put(implicitly[ClassTag[R]].runtimeClass, wrapper)
    }
  }

  def buildRuleFormat: OFormat[Rule[_]] = {
    val compoundFormat = new CompoundFormat[Rule[_]]
    compoundFormat.addSubType(Json.format[OnlyDuringWorkHours])
    compoundFormat.addSubType(Json.format[MaxLeadTime])
    compoundFormat.addSubType(Json.format[MaxDuration])
    compoundFormat
  }

  def test(): Unit = {
    implicit val ruleFormat = buildRuleFormat
    implicit val rulesFormat = Json.format[Rules]

    val rules0 = Rules(1, List(
      OnlyDuringWorkHours(Some(1)),
      MaxLeadTime(Some(2), 2),
      MaxDuration(Some(3), "Abc")
    ))

    val json = Json.toJsObject(rules0)
    println(s"encoded: '$json'")
    val rulesDecoded = Json.fromJson[Rules](json)
    println(s"decoded: $rulesDecoded")
  }
}

вызов PlayJson.test печатает

закодировано: '{"centerId":1,"ruleList":[{"roomId":1,"$type$":"OnlyDuringWorkHours"},{"roomId":2,"value":2,"$type$ ":"MaxLeadTime"},{"roomId":3,"value":"Abc","$type$":"MaxDuration"}]}'

расшифровано: JsSuccess(Rules(1,List(OnlyDuringWorkHours(Some(1)), MaxLeadTime(Some(2),2), MaxDuration(Some(3),Abc))),)

Основная идея состоит в том, чтобы иметь CompoundFormat для запечатанного признака, который хранит сопоставление между именем класса и соответствующим OFormat для каждого дочернего элемента.

Обновление (о проблемах с отражением)

Вот неуниверсальная версия CompoundFormat, которая, как я ожидаю, будет похожа на то, что может генерировать библиотека на основе макросов (на самом деле я ожидаю, что хорошая библиотека на основе макросов также обработает случай, когда некоторые из потомков запечатанного типажа являются одноэлементными object, а не чем class, который этот код не обрабатывает):

object ExplicitRuleFormat {
  implicit val format: OFormat[Rule[_]] = new ExplicitRuleFormat()

  private object InnerFormats {

    final val discriminatorKey = "$type$"
    implicit val onlyDuringWorkHoursFormat = Json.format[OnlyDuringWorkHours]
    final val onlyDuringWorkHoursTypeName = "OnlyDuringWorkHours"
    implicit val maxLeadTimeFormat = Json.format[MaxLeadTime]
    final val maxLeadTimeTypeName = "MaxLeadTime"
    implicit val maxDurationFormat = Json.format[MaxDuration]
    final val maxDurationTypeName = "MaxDuration"
  }

}

class ExplicitRuleFormat extends OFormat[Rule[_]] {

  import ExplicitRuleFormat.InnerFormats._

  override def reads(json: JsValue): JsResult[Rule[_]] = {
    val jsObject = json.asInstanceOf[JsObject]
    val name = jsObject(discriminatorKey).asInstanceOf[JsString].value
    name match {
      case s if onlyDuringWorkHoursTypeName.equals(s) => Json.fromJson[OnlyDuringWorkHours](jsObject)
      case s if maxLeadTimeTypeName.equals(s) => Json.fromJson[MaxLeadTime](jsObject)
      case s if maxDurationTypeName.equals(s) => Json.fromJson[MaxDuration](jsObject)
    }
  }

  override def writes(r: Rule[_]): JsObject = r match {
    case rr: OnlyDuringWorkHours => writeImpl(rr, onlyDuringWorkHoursTypeName)
    case rr: MaxLeadTime => writeImpl(rr, maxLeadTimeTypeName)
    case rr: MaxDuration => writeImpl(rr, maxDurationTypeName)
  }

  def writeImpl[R <: Rule[_]](r: R, typeName: String)(implicit w: OWrites[R]): JsObject = {
    Json.toJsObject(r) + (discriminatorKey, JsString(typeName))
  }
}

и с этим test становится:

def test(): Unit = {
  import ExplicitRuleFormat.format
  implicit val rulesFormat = Json.format[Rules]

  val rules0 = Rules(1, List(
    OnlyDuringWorkHours(Some(1)),
    MaxLeadTime(Some(2), 2),
    MaxDuration(Some(3), "Abc")
  ))

  val json = Json.toJsObject(rules0)
  println(s"encoded: '$json'")
  val rulesDecoded = Json.fromJson[Rules](json)
  println(s"decoded: $rulesDecoded")
}

Фактически вы просто заменяете implicit val ruleFormat = buildRuleFormat на import ExplicitRuleFormat.format.