Why _Map<String, String> is not in [Map<String, String>, bool]

I need to do runtime type check.

void main() {
  final type = [Map<String, String>, bool];
  final mapTest = {"A": "B"};
  if (type.contains(mapTest.runtimeType)) {
    print("yes");
  } else {
    print("no, ${mapTest.runtimeType} is not in $type");
  }
  bool boobool = true;
  if (type.contains(boobool.runtimeType)) {
    print("yes, ${boobool.runtimeType} is in $type");
  } else {
    print("no, ${mapTest.runtimeType} is not in $type");
  }
}

mapTest should pass the test. But it doesn't. What's wrong ?

no, _Map<String, String> is not in {Map<String, String>, bool}
yes, bool is in {Map<String, String>, bool}

1. Map<K, V> is an abstract type. It is impossible for any object to have a runtimeType of Map<K, V>; any object will be an instance of some concrete type.
2. Type objects usually are equal only for the exact same Type; it does not check if one Type represents a subtype of the other.

Consequently, it is impossible for mapTest.runtimeType to ever compare equal to Map<K, V>.

You also will not be able to use is; mapTest is type[0] is not legal since is requires that the right operand be statically known.

At best, for this case, you could check for static types instead of runtime types:

/// Provides a [staticType] getter on all non-`dynamic` objects.
extension StaticTypeExtension<T> on T {
  /// Returns the static type of this object.
  ///
  /// This can be used to report the static type of an object (which might not
  /// always be obvious due to inference or when dealing with generics), which
  /// might be different from [Object.runtimeType].
  Type get staticType => T;
}

void main() {
  final type = [Map<String, String>, bool];
  final mapTest = {"A": "B"};
  if (type.contains(mapTest.staticType)) {
    print("yes");
  } else {
    print("no, ${mapTest.staticType} is not in $type");
  }
  bool boobool = true;
  if (type.contains(boobool.staticType)) {
    print("yes, ${boobool.staticType} is in $type");
  } else {
    print("no, ${mapTest.staticType} is not in $type");
  }
}

which prints:

yes
yes, bool is in [Map<String, String>, bool]

That said, whatever it is you ultimately want to do with this is probably pretty questionable. It's usually not a good idea to rely on specific Type values because, as mentioned, subtypes won't be automatically handled.

It is because mapTest's runtime type is _InternalLinkedHashMap<String, String>, which is different from Map<String, String> so it fails the type check.

To make the type check pass, you can consider converting the mapTest to Map<String,String explicitly.

final type = [Map<String, String>, bool];
final mapTest = {"A": "B"};
if (type.contains(mapTest.runtimeType) || type.contains(mapTest.runtimeType.toString())) {
  print("yes");
} else if (mapTest is Map<String, String> && type.contains(Map<String, String>)) {
  print("yes, ${mapTest.runtimeType} is in $type");
} else {
  print("no, ${mapTest.runtimeType} is not in $type");
}

Dart create a Map by using constructor of _Map which inherited by class Map, and you directly mentioned type of Map<String, String> in in type.

So I suggest you to go with the way of creating a runtimeType in a variable type.

void main() {
  final type = [{"A": "B"} .runtimeType, bool];
  final mapTest = {"A": "B"} as Map<String, String>;
  if (type.contains(mapTest.runtimeType)) {
    print("yes");
  } else {
    print("no, ${mapTest.runtimeType} is not in $type");
  }
  bool boobool = true;
  if (type.contains(boobool.runtimeType)) {
    print("yes, ${boobool.runtimeType} is in $type");
  } else {
    print("no, ${mapTest.runtimeType} is not in $type");
  }
}

Various answers but I found the simplest solution.

Change

final type = [Map<String, String>, bool];

to

final type = [Map<String, String>().runtimeType, bool];

It seems to fulfill the purpose

yes, _Map<String, String> is in [_Map<String, String>, bool, List<String>]