Scala中path-dependent type与type projection两种类型引用机制的区别是什么？

刚巧对这个点研究过，这俩都是Scala里引用嵌套类型的方式，但核心区别在于和实例的绑定关系，给你掰扯清楚：

先从一个简单的代码例子入手，咱们先定义一个带嵌套类的外部类：

class Outer {
  class Inner
  val inner = new Inner
}

核心区别1：绑定对象不同 #

• Path-dependent Type（.）：它绑定的是具体的外部类实例。换句话说，每个Outer实例的Inner都是独一无二的类型——outer1.Inner和outer2.Inner就像String和Int那样完全不兼容。
  看这段代码的编译错误就懂了：

  val outer1 = new Outer
  val outer2 = new Outer
  // 编译报错：type mismatch; found: outer2.Inner, required: outer1.Inner
  val wrongInner: outer1.Inner = outer2.inner
  

• Type Projection（#）：它绑定的是外部类本身，和具体实例无关。Outer#Inner代表的是“任意Outer实例的Inner类型”，所有Outer实例的Inner对象都可以赋值给这个类型的变量：

  val validInner1: Outer#Inner = outer1.inner // 没问题
  val validInner2: Outer#Inner = outer2.inner // 同样没问题
  

核心区别2：使用场景不同 #

• 用Path-dependent Type的场景：你需要确保嵌套类型的实例和某个特定外部实例强绑定的时候。比如设计API时，要求传入的配置必须属于当前服务实例，避免跨实例混用：

  class Service {
    class Config(val endpoint: String)
    def launch(config: Config): Unit = println(s"Connecting to ${config.endpoint}")
  }
  
  val myService = new Service
  val myConfig = new myService.Config("https://my-service.com")
  myService.launch(myConfig) // 正常运行
  // myService.launch(new new Service().Config("https://other-service.com")) // 编译报错，防止跨实例混用
  

• 用Type Projection的场景：你只关心嵌套类型的结构，不关心它来自哪个外部实例的时候。比如写一个通用工具方法，处理任意Service实例的Config：

  def printEndpoint(config: Service#Config): Unit = println(s"Endpoint: ${config.endpoint}")
  printEndpoint(myConfig) // 正常
  val anotherService = new Service
  val anotherConfig = new anotherService.Config("https://another-service.com")
  printEndpoint(anotherConfig) // 也正常
  

一句话总结 #

• .是“属于某个特定实例的类型”，强调唯一性和绑定性；
• #是“属于某类实例的通用类型”，强调通用性和兼容性。

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