In Dart, what does the F-bound T extends Comparable<T> require, and why does maxOf(3, 7) with that bound infer num rather than int?

## What an F-bound is A type-parameter bound that mentions the parameter itself is called an **F-bound**, or a self-referential bound. The dart.dev generics page gives the canonical example: ```dart int compareAndOffset<T extends Comparable<T>>(T t1, T t2) => t1.compareTo(t2) + 1; ``` `T extends Comparable<T>` means *`T` must be comparable to itself*: `t1.compareTo(t2)` is statically valid because `t1` is a `Comparable<T>` and `t2` is a `T`. A class `A implements Comparable<A>` satisfies it; so do the core types that implement `Comparable` of themselves. ## Which core types fit | Type | Declared as | Satisfies `T extends Comparable<T>` with `T` = itself? | |---|---|---| | `String` | `implements Comparable<String>` | yes | | `DateTime` | `implements Comparable<DateTime>` | yes | | `Duration` | `implements Comparable<Duration>` | yes | | `num` | `implements Comparable<num>` | yes | | `int`, `double` | `extends num`, so `Comparable<num>` | **no** | The last row is the trap. `int` is a `Comparable<num>`. For it to be a `Comparable<int>`, `Comparable<num>` would have to be a subtype of `Comparable<int>`, which in Dart's covariant generics requires `num` to be a subtype of `int`. It is not, so `int` fails the bound. ## What happens at a call site ```dart T maxOf<T extends Comparable<T>>(T a, T b) => a.compareTo(b) >= 0 ? a : b; ``` 1. `maxOf('a', 'b')` infers `T = String` and returns a `String`. 2. `maxOf(3, 7)` cannot use `T = int`. With **inference using bounds**, added in Dart 3.7, inference takes the bound into account and settles on `T = num`, which satisfies `num extends Comparable<num>`. The call compiles and returns `7`, but its **static type is `num`**, so `int x = maxOf(3, 7);` does not compile without a cast. 3. `maxOf<int>(3, 7)` is a **compile-time error**, because the explicit argument violates the bound. 4. Before Dart 3.7, `maxOf(3, 7)` failed to infer at all and you had to write `maxOf<num>(3, 7)`. ## Ways to handle it - **Accept `num`.** If callers only need ordering, a `num` result is often fine. - **Loosen the bound** to `T extends Comparable<Object?>`. `int` satisfies it, because `Comparable<num>` is a `Comparable<Object?>`, so `maxOf<int>` compiles and returns `int`. The price is a weaker static guarantee: the bound no longer says that `T` compares against `T` specifically. - **Take a comparator** instead of a bound: `T maxBy<T>(T a, T b, Comparator<T> compare)`. Callers pass `(a, b) => a.compareTo(b)` or any ordering, and no bound is needed at all. ## Why Dart's core types look like this `num` is the common supertype of `int` and `double`, and it declares `compareTo(num other)` so that `3.compareTo(2.5)` works across both. Implementing `Comparable<num>` once, on `num`, is what makes mixed comparisons legal. The cost is exactly this bound problem: the subtypes cannot also claim to be `Comparable` of themselves, because a class cannot implement the same generic interface twice with different type arguments. It is a deliberate choice in the core library, not an oversight, and it is why generic numeric helpers in Dart usually bound by `num` or take a comparator rather than using a self-referential bound. ## F-bounds in your own hierarchies F-bounds also appear on class hierarchies, such as `class Node<T extends Node<T>>`. The dart.dev type-system page uses `class A<X extends A<X>>`, `class B extends A<B>` and `class C extends B` to show that `f(C())` for `f<X extends A<X>>` now infers `X = B`, because `C` itself is not an `A<C>`. The same rule is at work as with `int`: the subclass inherits its parent's self-reference, not its own. ## Common mistakes - Assuming `int` is a `Comparable<int>` because it is comparable to other ints. - Adding an F-bound where a `Comparator<T>` parameter would be simpler and more flexible. - Being surprised that a helper's result is `num` rather than `int`, and adding casts instead of revisiting the bound.