CODEWITHSUNDEEP
darttypescasting
niclassic
niclassic

Reputation: 117

Dart passing types to functions fails

I have a map consisting of different types and strings:

const Map<Type, String> hiveTableNames = {
  BreakTimeDto: "breaktime",
  WorkTimeDto: "worktime"
};

And I want to loop through it because I want to call a function for each type which takes a type parameter:

Future<void> sendAll<T>(List item) async {
...
}

My attempt was to use the forEach-loop:

hiveTableNames.forEach((key, value) async {
        final box = await Hive.openBox(value);
        _helper.sendAll<key>(box.values.cast<key>().toList());
      });

But the App throws an error: Error: 'key' isn*t a type.

Why is that? I declared the map to store types and from my understanding i pass these types in the function.

Upvotes: 0

Views: 194

Answers (1)

lrn
lrn

Reputation: 71613

Dart separates actual types and objects of type Type. The latter are not types, and cannot be used as types, they're more like mirrors of types. A Type object can only really be used for two things: as tokens to use with dart:mirrors and comparing for equality (which isn't particularly useful except for very simple types).

The only things that can be used as type arguments to generic functions or classes are actual literal types or other type variables.

In your case, you have a Type object and wants to use the corresponding type as a type argument. That won't work, there is no way to go from a Type object to a real type. That's a deliberate choice, it means that the compiler can see that if a type is never used as a type argument in the source code, then it will never be the type bound to a type parameter, so if you have foo<T>(T value) => ... then you know that T will never be Bar if Bar doesn't occur as a type argument, something<Bar>(), anywhere in the program.

In your case, what you can do is to keep the type around as a type by using a more complicated key object.

Perhaps:

class MyType<T> {
  const MyType();
  R use<R>(R Function<X>() action) => action<T>();
  int get hashCode => T.hashCode;
  bool operator==(Object other) => other is MyType && other.use(<S>() => T == S);
}

This allows you to store the type as a type:

final Map<MyType, String> hiveTableNames = {
  const MyType<BreakTimeDto>(): "breaktime",
  const MyType<WorkTimeDto>(): "worktime"
};

(I'm not making the map const because const maps must not have keys which override operator==). Then you can use it as:

hiveTableNames.forEach((key, value) async {
  final box = await Hive.openBox(value);
  key.use(<K>() => 
    _helper.sendAll<K>([for (var v in box.values) v as K]);
}

(If all you are using your map for is iterating the key/value pairs, then it's really just a list of pairs, not a map, so I assume you are using it for lookups, which is why MyType override operator==).

In general, you should avoid using Type objects for anything, they're very rarely the right tool for any job.

Upvotes: 1

Related Questions