Dart ssmple to explain Enum with generics inference

enum_generics_inferance.dart

enum ManyGenerics<T> {
  myInt<int>(defaultValue: 3),
  myString<String>(defaultValue: 'hello');

  final T defaultValue;

  const ManyGenerics({required this.defaultValue});
}

typedef WrappedAccess = ({ManyGenerics val});

class GenWrapper {
  final Map<ManyGenerics, dynamic> data;

  GenWrapper([this.data = const {}]);

  ///  T? operator [](ManyGenerics<T> g) => data[g]; // do not provide a typed value
  T? get<T>(ManyGenerics<T> g) => data[g];
}

void main() {
  final dataMap = GenWrapper({
    ManyGenerics.myInt: 100,
    ManyGenerics.myString: 'oucocu',
  });

  print(ManyGenerics.myString.defaultValue.length);
  print(ManyGenerics.myInt.defaultValue.isFinite);

  final methodAccess = dataMap.get(ManyGenerics.myInt)?.isFinite;
  print(['method access', methodAccess]);
  // don't work with operator access
  // final operatorAccess = dataMap[ManyGenerics.myInt];

  print([methodAccess]);

  dynamic items = [];

  try {
    items = ManyGenerics.values.where((g) {
      final s = g;

      /// failure
      if (s == ManyGenerics.myInt) {
        s.defaultValue.isNoEmpty;
      }

      return switch (s) {
        /// completion don't work here and will crash since it's dynamics
        ManyGenerics.myInt => g.defaultValue.isFinite, //
        ManyGenerics.myString => g.defaultValue.isFinite, //
      };
    });
    print(items);
  } catch (e, stackTrace) {
    print(e);
    print(stackTrace);
  }

  items = ManyGenerics.values.where((g) {
    return switch (g) {
      ManyGenerics<int>(defaultValue: var value) => value.isFinite, //
      ManyGenerics<String>(defaultValue: var value) => value.isNotEmpty, //
    };
  });
  print(items);

  items = ManyGenerics.values.where((g) {
    return switch (g) {
      ManyGenerics(defaultValue: int value) => value.isFinite, //
      ManyGenerics(defaultValue: String value) => value.isNotEmpty, //
    };
  });
  print(items);

  try {
    final Iterable<WrappedAccess> enumValues =
        ManyGenerics.values.map((e) => (val: e));
    items = enumValues.where((g) {
      return switch (g) {
        WrappedAccess(val: var val) when val == ManyGenerics.myInt =>
          val.defaultValue.isFinite, //
        WrappedAccess(val: var val) when val == ManyGenerics.myString =>
          val.defaultValue.isFinite, // will crash
        _ => true, // <- cannot avoid a default case
        /// won't work since enum is not a type
        // -> WrappedAccess(val: ManyGenerics.myInt val) when val == ManyGenerics.myInt => val.defaultValue.isFinite, //
      };
    });
    print(items);
  } catch (e) {
    print(e);
  }
}