如何在编译时以编程方式创建验证合约？

Question

如果这是 XY 问题，我提前道歉。

tl;博士：

我想要一个 [Request.type, Response.type] 类型的编译时映射，这样我就可以有效地说如果我发送消息 Request，CLI 应该在编译时知道如何反序列化它的预期 Response，不管它直到运行时才知道发送的是什么类型的请求。

太长了；仍在阅读：

我有一个与 HTTP 服务器通信的 CLI，根据发送到 HTTP 服务器的消息类型，我想根据案例验证 JSON 响应。

例如，如果我向 HTTP 服务器发送 AddFoo 消息，我可能想验证 JSON 响应是否可以反序列化为 AddedFoo，等等。

我目前的解决方案很老套。使用 play-json，我试图使用从 config.mode（即向 CLI 发出的命令）到预期响应的隐式 Reads 的映射来解析 JSON 响应].

我的代码看起来像这样：

val modeToResponseReads: Map[String, Reads[_]] = Map(
  Modes.ADD_FOO -> AddedFoo.addedFooReads,
  Modes.ADD_BOO -> AddedBoo.addedBooReads,
  Modes.GET_WOO -> GetWooResponse.getWooReads,
)

parser.parse(args, MyConfig()) match {

  case Some(config) => try {
    val exec = new MyHttpExecutor(remoteUri, config)
    val res = Await.result(exec.getResponse, 100.seconds)

    // passing `Reads` to `as` because JsValue#as[T] cannot be
    // applied at runtime -- only compile-time.
    val _ = Json.parse(res.json.toString)
                .as(modeToResponseReads(config.mode))
    
    exec.actorSystem.terminate()
    exec.wsClient.close()
  } catch {
    case t: Throwable => logger.error(t.getMessage)
  }

  case None => {
    logger.error("Bad arguments.")
    sys.exit(1)
  }
}

虽然这可行，但随着消息数量的增加，它变得越来越难以维护。此外，我发现这种模式需要在任何需要进行某种类型的验证或转换的地方复制（例如，Future[Any] 被转换为 Future[AddedFoo]）。

我的方法肯定不正确...传统上是如何完成的？如果是正确的方法（请否），是否可以进行优化？

Answer 1

我设法通过将合同直接编码到子 Request classes 中来实现这一点。即，子 Request classes 将持有 ResponseType 类型，基础 class 强制执行协变类型。

所以我可以这样做：

abstract class Response
abstract class Request[+A <: Response]

case class Foo(id: String)

object Foo {
  implicit val fooReads = Json.reads[Foo]
  implicit val fooFormat = Json.format[Foo]
}

case class FooResponse(foo: Foo) extends Response {
  def greet = println("woo hoo!")
}

object FooResponse {
  implicit val fooRespReads = Json.reads[FooResponse]
  implicit val fooRespFormat = Json.format[FooResponse]
}

case class FooRequest() extends Request[FooResponse] {
  type ResponseType = FooResponse
}

object Main extends App {
  val req: FooRequest = new FooRequest()
  val foo = Foo("12345")
  val resp = new FooResponse(foo)

  val respJsonString = Json.toJson(resp).toString
  println(Json.parse(respJsonString).as[req.ResponseType])
}

如何在编译时以编程方式创建验证合约？

How can I programmatically create a validation contract at compile-time?

validation

json

scala

json-deserialization

play-json

tl;博士：

太长了；仍在阅读：