Dart firstWhere orElse: generic function return type

user_500936 0
Viewed 79

The code below defines a generic myFirstWhereFunction with 3 arguments:

  • Generic list
  • Generic value to search in the list
  • Generic default value to return if the searched value is not in the passed generic list

The code:

void main() {
  const List<int> intLst = [1, 2, 3, 4];

  print(myFirstWhereFunc(intLst, 4, -1));
  print(myFirstWhereFunc(intLst, 5, -1));

  const List<String> strLst = ['coucou', 'go', 'bold', 'tooltip'];

  print(myFirstWhereFunc(strLst, 'go', 'not exist'));
  print(myFirstWhereFunc(strLst, 'ok', 'not exist'));
}

T myFirstWhereFunc<T>(List<T> lst, T searchVal, T defaultVal) {
  return lst.firstWhere((element) => element == searchVal, orElse: <T> () {
    return defaultVal;
  });
}

But this code generates an exception.

One solution is to replace the generic myFirstWhereFunc return type by dynamic (code below):

dynamic myFirstWhereFunc<T>(List<T> lst, T searchVal, T defaultVal) {
  return lst.firstWhere((element) => element == searchVal,
      orElse: () => defaultVal);
}

But is there another way of solving the problem ?

dart generics
1 Answers

I believe that the problem is that when you do:

print(myFirstWhereFunc(intLst, 4, -1));

there are two possible ways to infer the type of myFirstWhereFunc:

  • Bottom-up (inside-out): myFirstWhereFunc is called with a List<int> and with int arguments, so its type could be myFirstWhereFunc<int>. This is what you want.
  • Top-down (outside-in): print has an Object? parameter, so myFirstWhereFunc could be myFirstWhereFunc<Object?> so that it returns an Object?. This is what actually happens and is what you do not want.

Dart ends up with two possible ways to infer the generic type parameter, both seem equally valid at compilation-time, and it picks the one that you happen to not want. Picking the other approach likely would result in undesirable outcomes for different code examples. Arguably inference could try both ways and pick the narrower type if one approach leads to a subtype of the other. I'm not sure offhand if that would break code, but I wouldn't be surprised. (I also suspect that it's been suggested in https://github.com/dart-lang/language/issues somewhere...)

Changing myFirstWhereFunc's return type to dynamic is a crude workaround to the problem because it makes myFirsyWhereFunc's type no longer inferrable from print's parameter type.

If you split the line up and use a temporary variable, inference can infer myFirstWhereFunc independently of print and then should do what you want:

var intResult = myFirstWhereFunc(intLst, 4, -1);
print(intResult);
user_1797150
Related