播放2.4参数化代数数据类型JSON验证

Question

Is it possible to do something like that in Scala / Play 2.4:

sealed trait Location { val `type`: String }
case class CityLocation(zip_code: String, override val `type`: String = "city") extends Location
case class AddressLocation(
  society: Option[String],
  first_name: String,
  last_name: String,
  ...
  override val `type`: String = "address"
) extends Location

sealed trait Point[T <: Location] { val `type`: String; val location: T }
case class ShippingPoint[T](override val location: T, override val `type`: String = "shipping") extends Point[T]
case class PickupPoint[T](override val location: T, override val `type`: String = "pickup") extends Point[T]

object CityLocation {
  implicit val format = Json.format[CityLocation]
}
object AddressLocation {
  implicit val format = Json.format[AddressLocation]
}
object ShippingPoint {
  implicit def write[T] = Json.writes[ShippingPoint[T]]
  implicit def read[T]: Reads[ShippingPoint[T]] = (
    (__ \ "location").read[T] and
      (__ \ "type").read[String](exactWordRead("shipping", "error.route.shipping.type"))
  )(ShippingPoint[T].apply _)
}
object PickupPoint {
  implicit def write[T] = Json.writes[ShippingPoint[T]]
  implicit def read[T]: Reads[PickupPoint[T]] = (
    (__ \ "location").read[T] and
      (__ \ "type").read[String](exactWordRead("pickup", "error.route.pickup.type"))
  )(PickupPoint[T].apply _)
}

??

For now, It does not compile.

The exactWordRead method is defined as follow :

def exactWordRead(word: String, errorMessage: String): Reads[String] = Reads.constraints.pattern(s"^$word${"$"}".r, errorMessage)

---

Edit :

It seems that I maid a step forward thanks to this answer https://stackoverflow.com/a/29834113/2431728 :

sealed trait Location { val `type`: String }
case class CityLocation(zip_code: String, override val `type`: String = "city") extends Location
case class AddressLocation(
  society: Option[String],
  first_name: String,
  last_name: String,
  ...
  override val `type`: String = "address"
) extends Location

sealed trait Point[T <: Location] { val location: T; val `type`: String }
case class ShippingPoint[T](override val location: T, override val `type`: String = "shipping") extends Point[T]
case class PickupPoint[T](override val location: T, override val `type`: String = "pickup") extends Point[T]

object CityLocation {
  implicit val format = Json.format[CityLocation]
}
object AddressLocation {
  implicit val format = Json.format[AddressLocation]
}
object ShippingPoint {
  implicit def format[T: Format]: Format[ShippingPoint[T]] = (
    (__ \ "location").format[T] and
      (__ \ "type").format[String](exactWordRead("shipping", "error.route.shipping.type"))
  )(ShippingPoint.apply, unlift(ShippingPoint.unapply))
}
object PickupPoint {
  implicit def format[T: Format]: Format[PickupPoint[T]] = (
    (__ \ "location").format[T] and
      (__ \ "type").format[String](exactWordRead("pickup", "error.route.pickup.type"))
  )(PickupPoint.apply, unlift(PickupPoint.unapply))
}

However, I doesn't compile yet. The compile error is :

[error] type arguments [T] do not conform to trait Point's type parameter bounds [T <: services.coliswebApi.data.Location]
[error] case class ShippingPoint[T](override val location: T, override val `type`: String = "shipping") extends Point[T]
[error]                                                                                                         ^
[error] type arguments [T] do not conform to trait Point's type parameter bounds [T <: services.coliswebApi.data.Location]
[error] case class PickupPoint[T](override val location: T, override val `type`: String = "pickup") extends Point[T]

Answer 1

As said by the compiler, on one side you have,

sealed trait Point[T <: Location]

... and on the other side,

case class ShippingPoint[T](???) extends Point[T]
case class PickupPoint[T](???) extends Point[T]

But nothing in the declarations of ShippingPoint and PickupPoint is proving the type parameter is compatible with the constraint <: Location , required to extend Point .

So you need to fix that.

case class ShippingPoint[T <: Location](???) extends Point[T]
case class PickupPoint[T <: Location](???) extends Point[T]

Answer 2

I think you also need to bound your type in your format like this

implicit def format[T <: Location: Format]: Format[ShippingPoint[T]] = (
        (__ \ "location").format[T] and
        (__ \ "type").format[String](exactWordRead("shipping",   "error.route.shipping.type"))
    )(ShippingPoint.apply, unlift(ShippingPoint.unapply))