时间戳

首页 > 解决方案 > scala 伴生对象可以有抽象成员吗？

scala - scala 伴生对象可以有抽象成员吗？

问题描述

编辑：使问题更清楚

我有一个尝试将 a 解析Map[String, String]为ReadRequestsand的函数WriteRequests。我需要MapConvert从抽象类隐式访问Request。

// Conversion methods to make conversions from Map[String, String] to ReadRequest and WriteRequest implicit

trait MapConvert[A] {
    def convert(values: Map[String, String]): A
}

object Map2ClassHelpers {
    implicit class Map2Class(values: Map[String, String]) {
        def extract[A](implicit mapper: MapConvert[A]): A = mapper convert values
    }
}

// abstract Request class

abstract class Request[R <: Request[R]]() {
    def companion: RequestCompanion[R]
}

trait RequestCompanion[R <: Request[R]] {
    implicit val m: MapConvert[R]
}

// ReadRequest and companion object

case class ReadRequest(source: String, data: String)
    extends Request[ReadRequest] {
    override def companion: RequestCompanion[ReadRequest] = ReadRequest
}

object ReadRequest extends RequestCompanion[ReadRequest] {
    implicit val m = new MapConvert[ReadRequest] {
        def convert(values: Map[String, String]) = ReadRequest(
            source = values("source"),
            data = values("data")
        )
    }
}

// WriteRequest and companion object

case class WriteRequest(destination: String, data: String)
    extends Request[WriteRequest] {
    override def companion: RequestCompanion[WriteRequest] = WriteRequest
}

object WriteRequest extends RequestCompanion[WriteRequest] {
    implicit val m = new MapConvert[WriteRequest] {
        def convert(values: Map[String, String]) = WriteRequest(
            destination = values("destination"),
            data = values("data")
        )
    }
}

case class Spec(requestType: String, args: Map[String, String])

def fromMapToRequest[R <: Request[R]](spec: Spec)(implicit mR: Manifest[R]): R = {
    /* this extract method comes from Map2ClassHelpers
     * the result should be either a ReadRequest or a WriteRequest
     * the error happens at this call saying "could not find implicit value for parameter mapper
     * my guess is because it can't implicitly find the correct MapConvert from the abstract Request class
     */

    // a bunch of checks ...
    spec.args.extract[R]
}

def runExample() = {
    val spec1: Spec = Spec("read", Map("source" -> "/readPath", "data" -> "ABC"))
    val spec2: Spec = Spec("write", Map("destination" -> "/writePath", "data" -> "ABC"))

    val specs = Seq(spec1, spec2)

    specs.map(spec => {
        spec.requestType match {
            case "read" => fromMapToRequest[ReadRequest](spec)
            case "write" => fromMapToRequest[WriteRequest](spec)
        }
    })
}

当我将其更改为：

def fromMapToRequest[R <: Request[R]](spec: Spec)(eval: spec => Request)(implicit mR: Manifest[R]): R = {
    // a bunch of checks ...
    import Map2ClassHelpers._
    eval(spec)
}

def runExample() = {
    val spec1: Spec = Spec("read", Map("source" -> "/readPath", "data" -> "ABC"))
    val spec2: Spec = Spec("write", Map("destination" -> "/writePath", "data" -> "ABC"))

    val specs = Seq(spec1, spec2)
    import Map2ClassHelpers._
    specs.map(spec => {
        // this part is kind of ugly compared to the first way
        spec.requestType match {
            case "read" => fromMapToRequest[ReadRequest](spec)(_.args.extract[ReadRequest])
            case "write" => fromMapToRequest[WriteRequest](spec)(_.args.extract[WriteRequest])
        }
    })
}

但我想要更通用的第一个选项，因此只需在 fromMapToRequest 中指定一次类型。

标签： scalaimplicit

解决方案

（可能由于问题编辑而过时）

为伴生对象定义一个特征：

trait FoobarCompanion[X <: Foobar[X]] {
  implicit val m: Converter[X]
}

让伴生对象扩展它：

object Foo extends FoobarCompanion[Foo] {
  implicit val m = Converter[Foo] { ... }
}

object Bar extends FoobarCompanion[Bar] {
  implicit val m = Converter[Bar] { ... }
}

companion为自身添加一个方法Foobar：

abstract class Foobar[F <: Foobar[F]] {
  def companion: FoobarCompanion[F]
}

现在，只要您Foobar通过companion.

您可能想看看GenericCompanion周围的代码是如何组织的。

推荐阅读