如何在Scala中为键类型和对应的值类型之间的关系建模

Question

我想为每小时或每天的日志文件建模

sealed trait Level
case object Hour extends Level
case object Day extends Level

sealed trait Log[L <: Level]

我想要一种返回给定级别的所有日志的方法。 这是签名

def byLevel[L <: Level](l: L) : Seq[Log[L]]

给定一些具体的日志实例（实际代码还有很多）：

case object HourlyLog extends Log[Hour.type]
case object DailyLog extends Log[Day.type]

我想出了以下实现：

object Log {
  case class Pair[L <: Level](level : L, logs: Seq[Log[L]])
  val logs = Seq(
    Pair(Hour, Seq(HourlyLog)),
    Pair(Day, Seq(DailyLog))
  )

  def byLevel[L <: Level](l: L) : Seq[Log[L]] = logs.find(_.level == l).get.logs.asInstanceOf[Seq[Log[L]]]
}

我的问题是：

• 我们可以摆脱.asInstanceOf吗？
• 我们可以摆脱Pair包装吗？
• 有没有一种更好的方法可以解决此问题，而无需使用无HMap （我知道HMap可以解决问题）？

Answer 1

似乎您无论如何都在伴随对象上使用简单的对象比较，那么为什么要将所有类型与类型复杂化，而不是将Hour和Day视为一个很好的旧枚举？ 如果要将Seq[DailyLog]和Seq[HourlyLog]在同一列表中，则无论是否喜欢，都需要一个asInstanceOf 。

---

无论如何，您可以执行以下操作来消除Pair和asInstanceOf ：

1. 完全忘记类型，将Hour和Day视为枚举的值（仅值，无类型）
2. 使用隐式将类型直接映射到正确的列表（仅类型，无值）
3. 使用两种方法的奇怪组合（虽然最接近您的代码，但是我不确定为什么会这样）

这三种方法都没有使用Pair ，也没有使用asInstanceOf （一种方法是使用Map ，尽管如此，这仍然是您Pair所做的事情）。 三层代码墙中的每一层都可以独立编译。

---

只有值，没有类型，本质上是枚举

sealed trait Level
case object Hour extends Level
case object Day extends Level

sealed trait Log
case object HourlyLog extends Log
case object DailyLog extends Log

object Log {
  val logs = Map[Level, Seq[Log]](
    Hour -> Seq(HourlyLog, HourlyLog, HourlyLog, HourlyLog),
    Day -> Seq(DailyLog)
  )

  def byLevel(l: Level): Seq[Log] = logs(l)
}

import Log._

println(byLevel(Hour))
println(byLevel(Day))

输出：

List(HourlyLog, HourlyLog, HourlyLog, HourlyLog)
List(DailyLog)

---

仅类型，无对象值，隐式

sealed trait Level
sealed trait Hour extends Level
sealed trait Day extends Level

abstract class Log[L <: Level]

case object HourlyLog extends Log[Hour]
case object DailyLog extends Log[Day]

object Log {
  case class Logs[L <: Level](val logs: Seq[Log[L]])
  implicit val hourlyLogs = Logs[Hour](Seq(
    HourlyLog, HourlyLog, HourlyLog, HourlyLog
  ))
  implicit val dailyLogs = Logs[Day](Seq(
    DailyLog
  ))

  def byLevel[L <: Level](implicit logs: Logs[L]): Seq[Log[L]] =
    logs.logs
}

import Log._
println(byLevel[Hour])
println(byLevel[Day])

输出：

List(HourlyLog, HourlyLog, HourlyLog, HourlyLog)
List(DailyLog)

---

混合方式，一切都混合在一起

sealed trait Level
case object Hour extends Level
case object Day extends Level

sealed trait Log[L <: Level]

case object HourlyLog extends Log[Hour.type]
case object DailyLog extends Log[Day.type]

object Log {
  case class Logs[L <: Level](val logs: Seq[Log[L]])
  implicit val hourlyLogs = Logs[Hour.type](Seq(
    HourlyLog, HourlyLog, HourlyLog, HourlyLog
  ))
  implicit val dailyLogs = Logs[Day.type](Seq(
    DailyLog
  ))

  def byLevel[L <: Level](l: L)(implicit logs: Logs[L]): Seq[Log[L]] =
    logs.logs

}

import Log._
println(byLevel(Hour))
println(byLevel(Day))

输出：

List(HourlyLog, HourlyLog, HourlyLog, HourlyLog)
List(DailyLog)

Answer 2

根据情况，有不同的摆脱铸造的方法。

1. 如果要将Log[Hour]视为Log[Level]特例（因此，每次需要Log [Level]时都可以用Log[Hour]替代它），请使用协方差： [+L <: Level]

   您需要使用它才能将HourlyLog视为Log的子类型（ sealed trait Log[+L <: Level] ）

2. 如果遇到某种情况是可能混合的子类型的集合，则可以使用collect：

    def byLevel[L <: Level](l: L): Seq[Log[L]] = logs.collect { case Pair(l2, logs: Seq[Log[L]]) if l2 == l => logs }.flatten 

好了，您仍然需要注释日志的类型，但是它要干净得多，并且不需要使用无变形而不是其他任何魔术。

至于摆脱对包装器-在JVM上，您将有类型擦除。 您将需要与运行时检查的内容进行比较。 我可以想到类似ClassTag或TypeTag ...的东西，但是您仍然需要将其存储在某个位置（例如，作为隐式构造函数参数sealed trait Log[+L <: Level: ClassTag] ），然后与之进行比较。 因此，我确定是的，但这会产生一些样板。

另外，您可以使用HourlyLog过滤/收集，但随后您必须将其显式存储以将Hour映射到HourlyLog进行过滤...，我不确定是否值得这样做。 如果您是在常规基础上进行的，那么可能值得推出专用的类型类并提供隐式...但这是您的要求。 取决于您的用例，可能出于过度纯正而过度设计和纯粹化……或使代码库可维护的情况。 以我的卑鄙经验，有时“肮脏”的解决方案做得很好。