如何强制Dart泛型参数的多个实例解析为同一类型？

问题背景 #

Dart分析器的类型推断在处理泛型时存在超出预期的宽松度——允许同一泛型参数V绑定到协变的不同类型，导致不符合预期的类型检查结果。

示例代码 #

abstract class Doodad {}

class DoodadOne extends Doodad {}

class DoodadTwo extends Doodad {}

abstract class Whatchamacallit<T extends Doodad> {}

class What1<T extends Doodad> extends Whatchamacallit<T> {}

class What2<T extends Doodad> extends Whatchamacallit<T> {}

class ThingyBox<U extends Whatchamacallit<V>, V extends Doodad> {
  final U thingies;

  const ThingyBox(this.thingies);

  bool interrogate(U whatcha) {
    return true;
  }

  bool compare(V thingy) {
    return true;
  }
}

void main(List<String> args) {
  final thingyBox = ThingyBox(What1<DoodadOne>());
  print(thingyBox.interrogate(What1())); // 通过静态分析
  print(thingyBox.interrogate(What2())); // 静态分析不通过
  print(thingyBox.compare(DoodadOne())); // 通过静态分析
  print(thingyBox.compare(DoodadTwo())); // 通过静态分析 (?!)
}

问题分析 #

上述代码中，thingyBox被推断为ThingyBox<What1<DoodadOne>, Doodad>，而非预期的ThingyBox<What1<DoodadOne>, DoodadOne>。这是因为Dart的类型推断会选择限制性最弱的合法类型作为泛型参数：U被绑定为What1<DoodadOne>，而V只需满足U extends Whatchamacallit<V>——由于What1<DoodadOne>是Whatchamacallit<Doodad>的子类型（Dart泛型的协变特性），所以V被推断为Doodad，最终导致compare(DoodadTwo())能通过检查，违背了设计意图。

现有解决方式的不足 #

1. 显式声明类型参数 #

可以手动指定泛型参数，强制V为DoodadOne：

void main(List<String> args) {
  final thingyBox = ThingyBox<What1<DoodadOne>, DoodadOne>(What1<DoodadOne>());
  print(thingyBox.compare(DoodadOne())); // 通过静态分析
  print(thingyBox.compare(DoodadTwo())); // 静态分析不通过
}

缺点：需要编写冗长的类型声明，无法依赖类型推断提升开发体验，且使用者仍能手动指定更宽松的V（如Doodad）来绕过限制。

2. 添加冗余参数辅助推断 #

在构造函数中添加一个V类型的参数，让分析器能准确推断V的类型：

// ... 之前的类定义不变

class TypedThingyBox<U extends Whatchamacallit<V>, V extends Doodad> {
  final U thingies;

  const TypedThingyBox(this.thingies, {V? type});

  bool interrogate(U whatcha) {
    return true;
  }

  bool compare(V thingy) {
    return true;
  }
}

void main(List<String> args) {
  final thingyBox =
      TypedThingyBox(What1<DoodadOne>(), type: DoodadOne());
  thingyBox.interrogate(What1()); // 通过静态分析
  thingyBox.interrogate(What2()); // 静态分析不通过
  thingyBox.compare(DoodadOne()); // 通过静态分析
  thingyBox.compare(DoodadTwo()); // 静态分析不通过
}

缺点：需要使用者传入无业务意义的冗余参数，增加了使用成本和代码冗余度。

最优解决方案：重构泛型约束 #

通过调整ThingyBox的泛型参数顺序，直接以V为核心泛型参数，再约束U必须是Whatchamacallit<V>的子类型，让类型推断能直接从U的类型中锁定V的具体类型：

重构后的代码 #

abstract class Doodad {}

class DoodadOne extends Doodad {}

class DoodadTwo extends Doodad {}

abstract class Whatchamacallit<T extends Doodad> {}

class What1<T extends Doodad> extends Whatchamacallit<T> {}

class What2<T extends Doodad> extends Whatchamacallit<T> {}

// 重构泛型定义：先声明V，再约束U必须是Whatchamacallit<V>的子类型
class ThingyBox<V extends Doodad, U extends Whatchamacallit<V>> {
  final U thingies;

  const ThingyBox(this.thingies);

  bool interrogate(U whatcha) {
    return true;
  }

  bool compare(V thingy) {
    return true;
  }
}

void main(List<String> args) {
  final thingyBox = ThingyBox(What1<DoodadOne>());
  // 此时thingyBox被推断为ThingyBox<DoodadOne, What1<DoodadOne>>
  print(thingyBox.interrogate(What1())); // 通过静态分析
  print(thingyBox.interrogate(What2())); // 静态分析不通过
  print(thingyBox.compare(DoodadOne())); // 通过静态分析
  print(thingyBox.compare(DoodadTwo())); // 静态分析不通过 ✅
}

原理说明 #

调整泛型参数顺序后，Dart的类型推断会先从传入的What1<DoodadOne>中提取出其泛型参数DoodadOne作为V，再根据U extends Whatchamacallit<V>的约束确定U的类型。这样既不需要显式声明类型，也不需要冗余参数，同时强制V与U的泛型参数严格一致，完全符合设计意图。

可选优化：用typedef简化约束 #

如果觉得泛型约束的写法不够直观，可以用typedef简化：

typedef WhatchamacallitOf<V extends Doodad> = Whatchamacallit<V>;

class ThingyBox<V extends Doodad, U extends WhatchamacallitOf<V>> {
  final U thingies;

  const ThingyBox(this.thingies);

  // ... 方法定义不变
}

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