本文介绍了如何避免在Scala中调用asInstanceOf的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着小编来一起学习吧!

问题描述

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

Here is a simplified version of my code.

我该如何避免调用 asInstanceOf (因为这对于设计不佳的解决方案来说是一种气味)?

How can I avoid to call asInstanceOf (because it is a smell for a poorly design solution) ?

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")
    }
}

推荐答案

尝试类型类

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}")
}

通常,类型类是模式匹配的编译时替代.

Normally a type class is a compile-time replacement for pattern matching.

我必须将 getSinglePath 公开,并将 path 设置为 val ,以便在 GetPaths 中提供对它们的访问.如果您不想这样做,可以将类型类嵌套到 Log

I had to make getSinglePath public and path a val in order to provide access to them inside GetPaths. If you don't want to do so you can make the type class nested into 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 是零参数类型类,与磁铁图案.

这篇关于如何避免在Scala中调用asInstanceOf的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!

08-04 12:22