6

我正在使用 Play 框架的 JSON 库，它使用类型类来实现Json.toJson函数。（我可能会决定使用另一种静态类型较少的技术，比如反射；但现在我想使用这个库，因为它可以帮助我学习 Scala 类型系统。）

我有一堆需要传递给的简单案例类toJson，所以我必须Writes[T]为它们中的每一个实现一个隐式对象。对于每个类，第一次剪辑可能看起来像这样。

// An example class
case class Foo(title: String, lines: List[String])

// Make 'Foo' a member of the 'Writes' typeclass
implicit object FooWrites extends Writes[Foo] {
  def writes(f: Foo) : JsValue = {
    val fields = Seq("title" -> toJson(f.title), 
                     "lines" -> toJson(f.lines))                        
    JsObject(fields)
  }
}

每个类都有一个相似的隐含值，所以我可以抽象出公共部分，如下所示。但这不会编译，因为我不确定如何声明类型。

def makeSimpleWrites[C](fields: (String, C => T??)*) : Writes[C] = {
  new Writes[C] {
    def writes(c: C) : JsValue = {
      val jsFields = fields map { case (name, get) => (name, toJson(get(c)))}
      JsObject(jsFields)
    }
  }
}

implicit val fooWrites : Writes[Foo] = 
    makeSimpleWrites[Foo]("title" -> {_.title}, "lines" -> {_.lines})                                 
implicit val otherWrites ...

问题是T我要传递给的类型makeSimpleWrites。它不能是普通类型参数，因为 T 中的每个项目都不同fields。这是存在主义的类型吗？我还没有使用其中之一。在语法上挥舞...

def makeSimpleWrites[C](fields: (String, C=>T forSome { type T; implicit Writes[T] })*)

这在 Scala 中可行吗？如果是这样，语法是什么？

4

3 回答 3

3

因为每个字段都有不同的类型，所以每个字段都需要一个类型参数。这是因为要编写这些字段，您需要（隐式）提供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实例。

于 2012-12-13T19:00:00.073 回答
1

当试图解决我的第一个解决方案必须写"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).

于 2012-12-14T08:59:27.800 回答
1

至少截至 2015 年 1 月 25 日，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 _)

甚至2路转换：

implicit val fooFormat = (
  (__ \ "title").format[String].inmap(_.toLowerCase, _.toUpperCase) ~
  (-- \ "lines").format[List[String]]
)(Foo.apply _, unlift(Foo.unapply))
于 2015-01-25T14:41:19.777 回答