如何避免在 Scala 中调用 asInstanceOf

Question

这是我的代码的简化版本。

我怎样才能避免打电话asInstanceOf（因为这是设计不佳的解决方案的味道）？

sealed trait Location
final case class Single(bucket: String)     extends Location
final case class Multi(buckets: Seq[String]) extends Location

@SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
class Log[L <: Location](location: L, path: String) { // I prefer composition over inheritance
  // I don't want to pass location to this method because it's a property of the object
  // It's a separated function because there is another caller
  private def getSinglePath()(implicit ev: L <:< Single): String = s"fs://${location.bucket}/$path"

  def getPaths(): Seq[String] =
    location match {
      case _: Single => Seq(this.asInstanceOf[Log[_ <: Single]].getSinglePath())
      case m: Multi  => m.buckets.map(bucket => s"fs://${bucket}/$path")
    }
}

Answer 1

尝试类型类

class Log[L <: Location](location: L, val path: String) {
  def getSinglePath()(implicit ev: L <:< Single): String = s"fs://${location.bucket}/$path"
  def getPaths()(implicit gp: GetPaths[L]): Seq[String] = gp.getPaths(location, this)
}

trait GetPaths[L <: Location] {
  def getPaths(location: L, log: Log[L]): Seq[String]
}
object GetPaths {
  implicit val single: GetPaths[Single] = (_, log) => Seq(log.getSinglePath())
  implicit val multi:  GetPaths[Multi]  = (m, log) => m.buckets.map(bucket => s"fs://${bucket}/${log.path}")
}

通常，类型类是模式匹配的编译时替换。

我必须getSinglePath公开和pathaval以提供对它们内部的访问GetPaths。如果您不想这样做，您可以将类型类嵌套到Log

class Log[L <: Location](location: L, path: String) {
  private def getSinglePath()(implicit ev: L <:< Single): String = s"fs://${location.bucket}/$path"
  def getPaths()(implicit gp: GetPaths[L]): Seq[String] = gp.getPaths(location)

  private trait GetPaths[L1 <: Location] {
    def getPaths(location: L1): Seq[String]
  }
  private object GetPaths {
    implicit def single(implicit ev: L <:< Single): GetPaths[L] = _ => Seq(getSinglePath())
    implicit val multi: GetPaths[Multi] = _.buckets.map(bucket => s"fs://${bucket}/$path")
  }
}

实际上，我们不必location显式通过，也不需要L1

class Log[L <: Location](location: L, path: String) {
  private def getSinglePath()(implicit ev: L <:< Single): String = s"fs://${location.bucket}/$path"
  def getPaths()(implicit gp: GetPaths): Seq[String] = gp.getPaths()

  private trait GetPaths {
    def getPaths(): Seq[String]
  }
  private object GetPaths {
    implicit def single(implicit ev: L <:< Single): GetPaths = () => Seq(getSinglePath())
    implicit def multi(implicit ev: L <:< Multi):   GetPaths = () => location.buckets.map(bucket => s"fs://${bucket}/$path")
  }
}

现在GetPaths是零参数类型类，与磁铁模式略相似。