CompileTimeError:部分实例化中的类型参数必须实例化，因此不允许依赖于类型参数

Question

当我尝试调用listenEventReducer时，我得到这个奇怪的错误。该方法知道类型，仍然不确定我哪里出错了。

import 'package:test/test.dart';
enum ObjectChangeType { added, modified, removed }
typedef UpdateItem<T extends ListenEventItem> = T Function(T oldItem, T newItem);
T _defaultUpdate<T extends ListenEventItem>(T oldItem, T newItem) => newItem;
abstract class ListenEventItem {
String get id;
ObjectChangeType get changeType;
}
abstract class ListenEvent<T extends ListenEventItem> {
List<T> get data;
Map<ObjectChangeType, List<T>> get typedData {
return data.fold(
<ObjectChangeType, List<T>>{},
(Map<ObjectChangeType, List<T>> map, T element) {
map[element.changeType] = (map[element.changeType] ?? <T>[])..add(element);
return map;
},
);
}
}
Map<String, T> listenEventReducer<T extends ListenEventItem>(Map<String, T> state, ListenEvent<T> action,
[UpdateItem<T> update = _defaultUpdate]) {
update ??= _defaultUpdate;
final Map<String, T> b = Map<String, T>.from(state);
for (ObjectChangeType type in ObjectChangeType.values) {
final List<T> data = action.typedData[type];
if (data == null || data.isEmpty) {
continue;
}
if (type == ObjectChangeType.added) {
for (T item in data) {
b[item.id] == item;
}
} else if (type == ObjectChangeType.modified) {
for (T item in data) {
b[item.id] = update(b[item.id], item);
}
} else if (type == ObjectChangeType.removed) {
final List<String> ids = data.map((T it) => it.id).toList();
b.removeWhere((String id, _) => ids.contains(id));
}
}
return b;
}
class Data extends ListenEventItem {
Data(this.id, this.changeType, this.metadata);
final String metadata;
@override
final String id;
@override
final ObjectChangeType changeType;
}
class DataEvent extends ListenEvent<Data> {
DataEvent(this.data);
@override
final List<Data> data;
}
void main() {
final List<Data> items = List<Data>();
items.add(Data('0', ObjectChangeType.added, 'a'));
items.add(Data('1', ObjectChangeType.added, 'b'));
items.add(Data('0', ObjectChangeType.removed, 'a'));
items.add(Data('2', ObjectChangeType.added, 'c'));
items.add(Data('1', ObjectChangeType.modified, 'd'));
items.add(Data('3', ObjectChangeType.added, 'e'));
final DataEvent event = DataEvent(items);
final Map<String, Data> state = Map<String, Data>();
final Map<String, Data> newState = listenEventReducer<Data>(state, event);
expect(newState, isNotNull);
expect(newState.length, 3);
expect(newState['0'], isNull);
expect(newState['1'].metadata, 'd');
expect(newState['2'].metadata, 'c');
expect(newState['3'].metadata, 'e');
}

Answer 1

问题是typedef和函数类型_defaultUpdate不完全匹配，并向编译器提供有关类型泛型的完整信息。

初始化[UpdateItem<T> update = _defaultUpdate]时，编译器期望 UpdateItem 的类型为T，但它不知道_defaultUpdate是否真的返回TT extends ListenEventItem，_defaultUpdate可以返回任何类型SS extends ListenEventItem。

例如，假设您有两个类扩展ListenEventItem

class A extends ListenEventItem {}

和

class B extends ListenEventItem {}

现在，当没有传递泛型参数时，_defaultUpdate函数可以返回A或B。 当您尝试像

UpdateItem<A> update = _defaultUpdate

编译器不知道_defaultUpdate是否返回A或B使其在编译时失败。

---

你可以解决这个问题，使typedef函数接受泛型参数，这样编译器就知道需要任何扩展ListenEventItem的类

例：

typedef UpdateItem = T Function<T extends ListenEventItem>(T oldItem, T newItem);
T _defaultUpdate<T extends ListenEventItem>(T oldItem, T newItem) => newItem;

完整代码：

import 'package:test/test.dart';
enum ObjectChangeType { added, modified, removed }
typedef UpdateItem = T Function<T extends ListenEventItem>(T oldItem, T newItem);
T _defaultUpdate<T extends ListenEventItem>(T oldItem, T newItem) => newItem;
abstract class ListenEventItem {
String get id;
ObjectChangeType get changeType;
}
abstract class ListenEvent<T extends ListenEventItem> {
List<T> get data;
Map<ObjectChangeType, List<T>> get typedData {
return data.fold(
<ObjectChangeType, List<T>>{},
(Map<ObjectChangeType, List<T>> map, T element) {
map[element.changeType] = (map[element.changeType] ?? <T>[])
..add(element);
return map;
},
);
}
}
Map<String, T> listenEventReducer<T extends ListenEventItem>(
Map<String, T> state, ListenEvent<T> action,
[UpdateItem update = _defaultUpdate]) {
update ??= _defaultUpdate;
final Map<String, T> b = Map<String, T>.from(state);
for (ObjectChangeType type in ObjectChangeType.values) {
final List<T> data = action.typedData[type];
if (data == null || data.isEmpty) {
continue;
}
if (type == ObjectChangeType.added) {
for (T item in data) {
b[item.id] = item;
}
} else if (type == ObjectChangeType.modified) {
for (T item in data) {
b[item.id] = update(b[item.id], item);
}
} else if (type == ObjectChangeType.removed) {
final List<String> ids = data.map((T it) => it.id).toList();
b.removeWhere((String id, _) => ids.contains(id));
}
}
return b;
}
class Data extends ListenEventItem {
Data(this.id, this.changeType, this.metadata);
final String metadata;
@override
final String id;
@override
final ObjectChangeType changeType;
}
class DataEvent extends ListenEvent<Data> {
DataEvent(this.data);
@override
final List<Data> data;
}
void main() {
final List<Data> items = List<Data>();
items.add(Data('0', ObjectChangeType.added, 'a'));
items.add(Data('1', ObjectChangeType.added, 'b'));
items.add(Data('0', ObjectChangeType.removed, 'a'));
items.add(Data('2', ObjectChangeType.added, 'c'));
items.add(Data('1', ObjectChangeType.modified, 'd'));
items.add(Data('3', ObjectChangeType.added, 'e'));
final DataEvent event = DataEvent(items);
final Map<String, Data> state = Map<String, Data>();
final Map<String, Data> newState = listenEventReducer<Data>(state, event);
test('Test', () {
expect(newState, isNotNull);
expect(newState.length, 3);
expect(newState['0'], isNull);
expect(newState['1'].metadata, 'd');
expect(newState['2'].metadata, 'c');
expect(newState['3'].metadata, 'e');
});
}

Answer 2

实际上没有必要将参数声明为[UpdateItem update = _defaultUpdate]，语句update ??= _defaultUpdate;确保update无论如何都会获得所需的值。因此，仅使用[UpdateItem update]即可解决默认值不是恒定值的问题。

update的类型T Function(T, T)(其中T是给定类型，在调用时由listenEventReducer作为实际类型参数接收)与_defaultUpdate的类型T Function<T extends ListenEventItem>(T , T)(其中T由函数类型本身声明)之间的不匹配通过"泛型函数实例化"解决。下面是一个简单的示例：

X foo<X>(X x) => x;
main() {
int Function(int) f = foo;
print(f(42));
// But `f('Hello!')` is a type error.
}

关键是foo是一个泛型函数，但它可以通过推理将其实际类型参数作为函数接收，结果是类型int Function(int)的函数(即非泛型函数)。它将接受一个int并返回一个int，并且即使您动态调用它(例如，(f as dynamic)('Hello!')会抛出)，也会强制执行此纪律;所以得到的函数对象是一个正确的int Function(int)，而不仅仅是foo在不同的名称下。

如果你想显式模拟同样的东西，那么你可以编写一个包装函数：

X foo<X>(X x) => x;
main() {
int Function(int) f = (int x) => foo<int>(x);
print(f(42));
// But `f('Hello!')` is a type error.
}