如何在Scala 3 / Dotty中实现MapK这类高阶类型？

问题描述 #

我尝试在Scala 3中实现带类型关联的高阶Map容器MapK，原Scala 2版本的实现逻辑如下（已适配Scala 3语法占位符）：

type TupleK[K[*], V[*], A] = (K[A], V[A]) 

final class MapK[K[*], V[*]] private (val rawMap: Map[K[?], V[?]]) {
    
  def foreach(f: TupleK[K, V, ?] => Unit): Unit = {
    rawMap.foreach(f.asInstanceOf[Tuple2[K[?], V[?]] => Any])
  }
}

object MapK {
  
  def apply[K[*], V[*]](entries: TupleK[K, V, ?]*): MapK[K, V] = {
    new MapK[K, V](Map(entries: _*))
  }
}

预期的使用方式如下：

class Key[A]()
  
type Id[A] = A
  
val intKey = Key[Int]
val strKey = Key[String]

MapK[Key, Id](intKey -> 1, strKey -> "a")

上述实现逻辑在Scala 2中可以正常运行，仅需要将代码中的*、?通配符替换为_（_*可变参数场景除外）即可。但在Scala 3中编译时几乎每行都会报unreducible application of higher-kinded type to wildcard arguments错误。

核心疑问 #

Scala 3官方已明确移除了存在类型（existential types）特性，官方文档提到“存在类型的能力大部分和路径依赖类型重叠”，但没有给出这类高阶类型容器场景的适配示例。我查阅了相关技术讨论后，还是不清楚怎么用路径依赖类型实现MapK，也不确定是否可行。如果路径依赖类型无法实现，还有什么其他兼容方案？

解决方案 #

Scala 3中确实可以通过路径依赖类型实现MapK的全部功能，核心思路是用带类型成员的封装类保留键和值的类型关联，避免直接使用高阶类型通配符：

1. 定义键值对封装类型Entry #

用Entry的类型成员A关联键和值的类型参数，替代原来的TupleK：

type Entry[K[_], V[_]] = Entry.Any[K, V]
object Entry:
  sealed trait Any[K[_], V[_]]:
    // 路径依赖类型成员，关联key和value的类型参数
    type A
    def key: K[A]
    def value: V[A]
  
  def apply[K[_], V[_], T](k: K[T], v: V[T]): Any[K, V] =
    new Any[K, V]:
      override type A = T
      override val key: K[A] = k
      override val value: V[A] = v

2. 实现MapK容器 #

内部用Entry存储键值对，避免直接使用K[?]/V[?]通配符导致的类型关联丢失：

final class MapK[K[_], V[_]] private (private val rawMap: Map[K[Any], Entry[K, V]]):
  // 按key取值，保留类型安全
  def get[T](key: K[T]): Option[V[T]] =
    rawMap.get(key.asInstanceOf[K[Any]]).map(_.value.asInstanceOf[V[T]])

  // 遍历方法，使用Scala 3多态函数类型保留参数类型关联
  def foreach(f: [A] => (K[A], V[A]) => Unit): Unit =
    rawMap.values.foreach(entry => f(entry.key, entry.value))

object MapK:
  def apply[K[_], V[_]](entries: Entry[K, V]*): MapK[K, V] =
    val rawEntries = entries.map(entry => entry.key.asInstanceOf[K[Any]] -> entry)
    new MapK[K, V](rawEntries.toMap)

3. 兼容原有用法 #

如果要保留原来的key -> value写法，可以添加扩展方法自动封装为Entry：

extension [K[_], V[_], T](kv: (K[T], V[T]))
  def toEntry: Entry[K, V] = Entry(kv._1, kv._2)

调整后的使用示例：

class Key[A]()
type Id[A] = A

val intKey = Key[Int]
val strKey = Key[String]

// 两种构造方式均可
val map = MapK[Key, Id](
  Entry(intKey, 1),
  (strKey -> "a").toEntry
)

// 测试遍历
map.foreach([A] => (key: Key[A], value: Id[A]) => println(s"键:$key, 值:$value"))
// 测试类型安全取值
val intValue: Option[Int] = map.get(intKey) // 正确返回Some(1)
val strValue: Option[String] = map.get(strKey) // 正确返回Some("a")

方案说明 #

这种实现方式完全利用了Scala 3的路径依赖类型和多态函数特性，完全规避了被移除的存在类型语法，同时保留了MapK的全部类型安全能力，没有额外的运行时性能损耗。

内容的提问来源于stack exchange，提问作者Nikita