如何从类型中提取类型参数

Question

给定以下类：

abstract class Foo[B] 
abstract class Baz[B, F <: Foo[B]] {
    def get(foo: F): B
    // other methods
} 

我讨厌在Baz 中需要两个类型参数，而第一个是多余的。我想写这样的东西：

abstract class Baz[F <: Foo[B]] {
  def get(foo: F): B
}

我是否可以在 Baz 中引用 B 类型（F 的）而不使用多个类型参数？这感觉应该是可能的，但我似乎无法弄清楚语法。

Answer 1

1. 你能让B 成为类型成员而不是类型参数吗？

   abstract class Foo { type B }
   abstract class Baz[F <: Foo] {
     def get(foo: F): F#B
     // other methods
   }
   

   如果你需要类型参数和类型成员，你可以使用辅助模式

   abstract class Foo { type B }
   // Foo.Aux[B] instead of Foo[B]
   object Foo {
     type Aux[B0] = Foo { type B = B0 }
   }
   abstract class Baz[F <: Foo] {
     def get(foo: F): F#B
     // other methods
   }
   

2. 你能让F更高级和get多态吗？ （看起来有点像“无标签最终”方法。）

   abstract class Foo[B]
   abstract class Baz[F[X] <: Foo[X]] {
     def get[B](foo: F[B]): B
     // other methods
   }
   

3. 你能让Foo 成为一个类型类吗？

   abstract class Foo[F] {
     type B
   }
   object Foo {
     type Aux[F, B0] = Foo[F] { type B = B0 }
     def instance[F, B0]: Aux[F, B0] = new Foo[F] { type B = B0 }
   
     //instead of  class F1 extends Foo[B1]
     implicit val foo1: Aux[F1, B1] = instance
   }
   
   abstract class Baz[F](implicit val foo: Foo[F]) {
     def get: foo.B
     // other methods
   }
   

   或

   abstract class Baz[F: Foo] {
     val foo: Foo[F] = implicitly
     def get: foo.B
     // other methods
   }
   

4. 你能把这两个类型参数提取到一个新的类吗？

   abstract class Foo[B]
   
   abstract class Tuple {
     type B
     type F <: Foo[B]
   }
   
   abstract class Baz[T <: Tuple] {
     def get(foo: T#F): T#B
     // other methods
   }
   

   或

   abstract class Baz[T <: Tuple](t: T) {
     def get(foo: t.F): t.B
     // other methods
   }
   

Answer 2

我讨厌在 Baz 中需要两个类型参数，而第一个是多余的。

没有冗余。如果 Baz 代码引用了 2 个不同的类型，那么我们需要为它们设置 2 个不同的名称（F 和 B，或 X 和 Y，或 THIS 和 THAT，它没关系）。

如果 Baz 代码仅引用 1 种类型，但该类型需要限制为 Foo 已实现的内容，那么您可以添加该限制：

class Baz[X](implicit ev: Foo[X]) { ...

这可以简化为：

class Baz[X: Foo] { ...

---

如果无法推断类型，并且您希望简化实例创建，也许可以使用类型成员/别名。

abstract class Baz[B] {
  type F = Foo[B]
  def get(foo: F): B
}

但通常把事情写出来会更清楚。

abstract class Baz[B] {
  def get(foo: Foo[B]): B
}

但这当然排除了子类型的可能性。