Inheriting IComparable should satisfy a comparison constraint

[kentcb]

The following does not compile:

type Wrapper<'T when 'T :> IComparable> = {
    Values: Set<'T>
}

It insists on a comparison constraint on 'T even though the documentation (and intuition) suggests that inheriting from IComparable is the same thing:

'T must implement IComparable, or be an array type with comparable elements, or be System.IntPtr or System.UIntPtr. Also, 'T must not have the NoComparison attribute.

It doesn't matter whether the constraint is for IComparable, IComparable<'T>, IStructuralComparable, or all of them.

Expected behavior

The code should compile.

Actual behavior

A type parameter is missing a constraint 'when 'T : comparison'

Known workarounds

• Add an additional constraint. But note that this is exactly what I'm trying to avoid. I have my own interface which is intended to amalgamate all type requirements, including the need for comparison. By adding a single constraint of inheriting from that interface, the compiler should know it supports comparison.
• Don't use Map<'T> and use HashSet<'T> instead. This isn't really an acceptable workaround in my case, since it introduces mutability.

[cartermp]

Sorry if I don't understand - is the following not sufficient for your needs?

type Wrapper<'T when 'T : comparison> = {
    Values: Set<'T>
}

There's no additional constraint if you do this.

[kentcb]

@cartermp Thanks for the reply. No, it's not because my real scenario is more like this:

type IMyBaseType =
    inherit IComparable
    inherit ISomething
    inherit ISomethingElse

type Wrapper<'T when 'T :> IMyBaseType> = {
    Values: Set<'T>
}

I don't want to have to constrain to both IMyBaseType and comparison because I feel like I'm repeating myself as IMyBaseType already inherits from IComparable.

[DalekBaldwin]

There are further requirements for a type to be comparison that are not mentioned on that page. From section 5.2.10 of the spec:

The constraint type : comparison is a comparison constraint. Such a constraint is met if all the following conditions hold: • If the type is a named type, then the type definition does not have, and is not inferred to have, the NoComparison attribute, and the type definition implements System.IComparable or is an array type or is System.IntPtr or is System.UIntPtr. • If the type has comparison dependencies ty_1, ..., ty_n, then each of these must satisfy ty_i : comparison

[kentcb]

@DalekBaldwin Thanks, but which of those requirements is not satisfied in my example?

[DalekBaldwin]

You can't guarantee the second bullet point will be satisfied for every type that could ever be created that implements IMyBaseType, e.g. with the standard pattern for propagating equality and comparison constraints through generic types:

type MyGenericType<[EqualityConditionalOn; ComparisonConditionalOn] 'T> (value:'T) =
    override this.Equals thatObj =
        // uses Unchecked.equals
        // ...
    override this.GetHashCode () =
        // uses Unchecked.hash
        // ...
    interface System.IComparable with
        member this.CompareTo thatObj =
            // uses Unchecked.compare
            // ...

There are a number of fslang-suggestions issues along the lines making these constraints more flexible, but as it is currently defined, comparison does not subsume IComparable.

[dsyme]

I'll close this, as it is indeed by design (@DalekBaldwin feel free to link through to the issues on fslang-suggestions)