单例对象的抽象类型成员

Question

抽象成员方法在单例对象中是非法的

scala> object Foo {
     |   def g: Int
     | }
         def g: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

作为抽象值成员

scala> object Foo {
     |   val x: Int
     | }
         val x: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

然而抽象类型成员在单例对象中是合法的

scala> object Foo {
     |   type A
     | }
object Foo

很明显，类型成员是抽象的意义与其他抽象成员不同。有什么区别？由于对象是最终的，抽象类型成员似乎无法具体化，它怎么能有用？

Answer 1

嗯，type 不一定是具体的。你可以写：

type Arbitrary

在 Ammonite 中，它编译并运行。您甚至可以将其用作参数！

type Arbitrary

def foo(a: Arbitrary): List[Arbitrary] = List(a)

唯一的问题是，编译器不知道任何关于 Arbitrary 的信息（例如 <: String 或其他东西），这将允许您合法地创建这种类型的值。

从这个角度来看，抽象类型成员只是一种我们一无所知的类型，但我们可以只知道它存在并且值属于这种类型。

但是，我们也可以override 这个空定义，例如使其更具体

type Arbitrary = String
type Arbitrary <: AnyVal
type Arbitrary >: User

那么任何实现它的人都可以访问完整的类型信息，而程序员编写在范围内具有抽象定义的代码只能传递类型。

偶然地，这就是我们重新发现路径依赖类型的方式，或者更确切地说，如果我们想要拥有路径依赖类型而不需要手动维护我们不想要的情况列表，那么能够创建抽象类型是必要的他们。

在 Scala 2 中的 Cats 中，这有另一个用例。 Edward Kmett 显然发现了一种模式，它使用抽象类型成员和 .asInstanceOf 来解决缺少的多态函数，我们可以将其提升到类型类：

trait DoubleSize[F[_]] {
  def double[A](fa: F[A]): F[A]
}
object DoubleSize {

  type Arbitrary
  def instance[F[_]](fun: F[Arbitrary] => F[Arbitrary]): DoubleSize[F] = new DoubleSize[F] {
    def double[A](fa: F[A]): F[A] = fun(fa.asInstanceOf[F[Arbitrary]]).asInstanceOf[F[A]]
  }

  // in Dotty we could do
  // def instance[F[_]](fun: [A] => F[A] => F[A]) = new DoubleSize[F] {
  //    def double[A](fa: F[A]): F[A] = fun[A](fa)
  // }
  // but in Scala 2 it's impossible
}

val doubleSize = DoubleSize.instance[List] { list =>
  list ++ list
}

doubleSize.double(List(1,2,3))
doubleSize.double(List("a", "b", "c"))

如果我们排除抽象类型成员，这种变通方法就不可能了，尽管在 Dotty 中这种特殊的变通方法将不再需要。

Answer 2

基于@tpolecat 和Dmytro，抽象类型成员似乎与存在类型相关

scala> object O {
     |   type A
     |   implicitly[A <:< (x forSome { type x })]
     | }
object O