如何使用固定类型参数子类化 Scala immutable.Map ？

Question

如果映射只能存储其值的不变类型，我无法弄清楚如何处理不可变映射中的重写“+”。

类似于：

class FixedMap(val impl : Map[String, Int])
    extends immutable.Map[String, Int] with immutable.MapLike[String, Int, FixedMap] {
    // This should return FixedMap if B1 is Int, and Map[String,B1]
    // if B1 is a superclass of Int; but there's no way to do that.
    // It is possible to return FixedMap here but then you have to
    // throw at runtime if B1 is not Int
    override def +[B1 >: Int](kv : (String, B1)) : Map[String, B1] = {
        kv match {
            case (k, v : Int) =>
                new FixedMap(impl + Pair(k, v))
            case _ =>
                impl + kv
        }
    }
    // ...
}

我希望它像使用 CanBuildFrom 的方法一样工作，并且如果可能的话始终保留原始类型。有办法吗？或者 Map 子类总是必须将值类型保留为类型参数？

这是一个完整的可编译示例：

import scala.collection.immutable

// pointless class that wraps another map and adds one method
class FixedMap(val impl : Map[String, Int])
    extends immutable.Map[String, Int] with immutable.MapLike[String, Int, FixedMap] {

    override val empty : FixedMap = FixedMap.empty

    // This should return FixedMap if B1 is Int, and Map[String,B1]
    // if B1 is a superclass of Int; but there's no way to do that.
    // It is possible to return FixedMap here but then you have to
    // throw at runtime if B1 is not Int
    override def +[B1 >: Int](kv : (String, B1)) : Map[String, B1] = {
        kv match {
            case (k, v : Int) =>
                new FixedMap(impl + Pair(k, v))
            case _ =>
                impl + kv
        }
    }

    override def -(key : String) : FixedMap = {
        new FixedMap(impl - key)
    }

    override def get(key : String) : Option[Int] = {
        impl.get(key)
    }

    override def iterator : Iterator[(String, Int)] = {
        impl.iterator
    }

    def somethingOnlyPossibleOnFixedMap() = {
        println("FixedMap says hi")
    }
}

object FixedMap {
    val empty : FixedMap = new FixedMap(Map.empty)
}

object TestIt {
    val empty = FixedMap.empty
    empty.somethingOnlyPossibleOnFixedMap()
    val one = empty + Pair("a", 1)
    // Can't do the below because one is a Map[String,Int] not a FixedMap
    // one.somethingOnlyPossibleOnFixedMap()
}

Answer 1

这是我要尝试的：

class FixedMap(val impl: immutable.Map[String, Int])
    extends immutable.Map[String, Int] with immutable.MapLike[String, Int, FixedMap] {

  override def +[B1 >: Int](kv: (String, B1)): immutable.Map[String, B1] = impl + kv

  def +(kv: (String, Int))(implicit d: DummyImplicit): FixedMap = new FixedMap(impl + kv)

  // ...

}

你是对的：你不能覆盖已经存在的 + ，所以你必须把它留在那里 - 否则你的子类将无法做超类的事情可以这样做，这违反了里氏替换原则。但是您可以添加一个包含所需确切参数的附加方法（在这种特殊情况下，您不需要 CanBuildFrom）。

唯一的问题是新方法与您尝试覆盖的方法具有完全相同的类型擦除，但具有不兼容的签名。为了解决这个问题，您可以添加在 Predef 中定义的 DummyImplicit ，作为一个隐式值始终可用的类。它的主要用途是在像这样的重载情况下解决类型擦除问题。

请注意，要在其上调用重载方法的地图的静态类型必须是 FixedMap 才能正常工作。如果对象的运行时类型为 FixedType，但静态类型为常规 Map[String, Int]，则编译器不会调用新的重载方法。

Answer 2

可以使用 CanBuildFrom 实现您想要的功能。问题是 - 你真的想要/需要成功吗？ SO中有几个类似的问题，这是其中之一（希望您能在那里找到答案）：

扩展 Scala 集合

一般来说，Scala 提供了足够的工具来避免这种情况（扩展集合）。你确实需要一个充分的理由来开始这样做。

Answer 3

如果您添加另一个 + 重载，它看起来确实有效（到目前为止我能说的最好）：

def +(kv : (String, Int))(implicit bf : CanBuildFrom[FixedMap, (String, Int), FixedMap]) : FixedMap = {
    val b = bf(empty)
    b ++= this
    b += kv
    b.result
}

我之前看到这样做的问题是由从覆盖的 + 返回固定地图引起的，从而阻止了对通用地图的任何升级。我想这允许对 + 的隐式转换起作用。但是，如果您修复该重写的 + 方法以再次返回 Map[String,B1]，则无法再对该对的值使用隐式转换。编译器无法知道是否转到超类映射（即 Map[String,Any]）或隐式转换为 Int 以坚持使用 FixMap。有趣的是，无论是否使用隐式转换，方法的返回类型都会改变；我猜想给定一个固定映射返回类型，编译器可以推断出 B1 始终只是 B（或类似的东西！）。

无论如何，这似乎是我的错误；您只是不能在传递给 + 的pair._2 上使用隐式转换，同时与 Map 接口兼容，甚至在概念上也是如此。现在我放弃了，我认为重载的 + 会工作得很好。