Enum .sort() Throws an Error Unless Explicit Comparator is Provided

[bgoncharuck]

Enum .sort() Throws an Error Unless Explicit Comparator is Provided

Description

I encountered an inconsistency when sorting a list of enums in Dart. Calling .sort() directly on a List<Enum> throws an error, but providing an explicit comparator using .index.compareTo() works as expected.

Steps to Reproduce

enum SortableType { A, B, C }

void main() {
  var list1 = SortableType.values.toList();
  var list2 = SortableType.values.toList();

  list1.sort(); // Throws an error
  list2.sort((a, b) => a.index.compareTo(b.index)); // Works fine
}

Expected Behavior

• Since sorting an enum by its index is the most logical behavior, list1.sort(); should work without requiring a custom comparator.

Actual Behavior

• list1.sort(); throws an error.
• list2.sort((a, b) => a.index.compareTo(b.index)); works fine.

Proposal

Would it make sense for Enum to implement Comparable by default using its index?

Environment Details

Any.
Dartpad: https://dartpad.dev/

[lrhn]

This is deliberate.

Enums are not Comparable because it's not a given that they have a natural order.

The index order is accidental. It's like sorting people alphabetically - you can, but it doesn't mean anything.
We generally prefer to not introduce something that the author hasn't asked for, suggesting a meaning which isn't there.

It's easy to make an enum comparable,

enum SortableType implements Comparable<SortableType> {
  A, B, C;
  int compareTo(SortableType other) => index.compareTo(other.index);
}

It's so easy you can have a mixin for it:

mixin OrderedEnum<T extends Enum> on Enum implements Comparable<T> {
  int compareTo(T other) => index.compareTo(other.index);
}

enum SortableEnum with OrderedEnum<SortableEnum> {
  A, B, C;
}

Anything instance member added to all enums is also a name that can't be used for an enum value.

I don't expect to make enums automatically comparable.

[eernstg]

@bgoncharuck, I think it might be useful to add a comment that doesn't actually have anything to do with the sortability of enum declarations. It's more about sort:

List.sort has a quite loosely typed signature, for historic reasons. But you can choose to access it through a couple of other methods (which will be inlined, so there's no extra cost at run time):

extension<E extends Comparable<E>> on List<E> {
  void sortComparable([int compare(E a, E b)?]) => sort(compare);
}

extension<E> on List<E> {
  void sortAny(int compare(E a, E b)) => sort(compare);
}

enum SortableType { A, B, C }

void main() {
  var list1 = SortableType.values.toList();
  var list2 = SortableType.values.toList();

  list1.sortComparable(); // Compile-time error: Isn't comparable.
  list1.sortAny(); // Compile-time error: Missing argument.
  list2.sortAny((a, b) => a.index.compareTo(b.index)); // OK.
}

This means that you will only be allowed to omit the compare argument in the case where it is known at compile time that the given list contains comparable elements, with sortComparable, otherwise you can call sortAny with any kind of list, but then the compare argument must be provided.

[bgoncharuck]

Thank you for the clarification. True, enums are not inherently comparable because their order is not always meaningful. However, in most real-world cases, enums do have an implicit ordering based on their declaration.

If automatic comparability is not an option, would it make sense to provide a built-in mixin like OrderedEnum in dart:core? This would offer a clean, consistent approach without modifying all enums manually.