Operators.( .. .. ) throws an ArgumentException when ^Step does not implement IComparable

[JanWosnitza]

Operators.( .. .. ) throws an ArgumentException when ^Step does not implement non-generic System.IComparable.

Repro steps

Run the following code:

type Step(value:int) =
    member __.Value = value
    
    static member Zero = Step 0

type Value(value:int) =
    member __.Value = value
    
    static member (+)(a:Value, b:Step) = Value(a.Value + b.Value)
    
    interface System.IComparable with
        member a.CompareTo(b) =
            match b with
            | :? Value as b' -> compare a.Value b'.Value
            | _ -> failwith "unsupported"
    
[Value 0 .. Step 2 .. Value 2]

Expected behavior

I would expect a compiler error. Similar to

• Step.Zero not implemented
• Value.(+) not implemented
• Value not implementing System.IComparable

Actual behavior

The last line throws this exception:

System.ArgumentException: Failure during generic comparison: the type 'FSI_0006+Step' does not implement the System.IComparable interface. This error may be arise from the use of a function such as 'compare', 'max'
or 'min' or a data structure such as 'Set' or 'Map' whose keys contain instances of this type.
   at Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.FailGenericComparison[a](Object obj)
   at Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.GenericCompare(GenericComparer comp, Object xobj, Object yobj)
   at Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.GenericLessThanIntrinsic[T](T x, T y)
   at Microsoft.FSharp.Core.Operators.OperatorIntrinsics.gen@4848-3[TStep,T](TStep zero, FSharpFunc`2 add, T start, TStep step, T stop, Unit unitVar0)
   at Microsoft.FSharp.Core.Operators.OperatorIntrinsics.RangeStepGeneric@4936-1.System-Collections-Generic-IEnumerable`1-GetEnumerator()
   at Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1.MoveNextImpl()
   at Microsoft.FSharp.Collections.SeqModule.ToList[T](IEnumerable`1 source)
   at <StartupCode$FSI_0006>.$FSI_0006.main@()

Known workarounds

Run the code and realize you need to implement the interface System.IComparable on Step:

    interface System.IComparable with
        member a.CompareTo(b) = 
            match b with
            | :? Step as b' -> compare a.Value b'.Value
            | _ -> failwith "unsupported"

Or not using the start .. step .. finish operator, but generate the sequence somehow different (where step is not required to be comparable to Zero at runtime).

Related information

I had this issue when using 2 structs defined in C# and tried to iterate over them.

• Microsoft (R) F# Interactive version 10.2.3 for F# 4.5
• Microsoft Windows 10

[brianrourkeboll]

This seems odd at first glance. The implementation of RangeStepGeneric in prim-types.fs, which is called in this case for (.. ..), uses =, >, and < on step, which would normally force the equality and comparison constraints to bubble up:

fsharp/src/FSharp.Core/prim-types.fs

Lines 5790 to 5796 in fc42ec9

	let inline integralRangeStepEnumerator (zero,add,n,step,m,f) : IEnumerator<_> =
	// Generates sequence z_i where z_i = f (n + i.step) while n + i.step is in region (n,m)
	if n = m then
	new SingletonEnumerator<_> (f n) |> enumerator
	else
	let up = (n < m)
	let canStart = not (if up then step < zero else step > zero) // check for interval increasing, step decreasing

fsharp/src/FSharp.Core/prim-types.fs

Lines 5942 to 5944 in fc42ec9

	let inline integralRangeStep<'T,'Step> (zero:'Step) (add:'T -> 'Step -> 'T) (n:'T, step:'Step, m:'T) =
	if step = zero then invalidArg "step" (SR.GetString(SR.stepCannotBeZero));
	let gen() = integralRangeStepEnumerator (zero, add, n, step, m, id)

fsharp/src/FSharp.Core/prim-types.fs

Line 6032 in fc42ec9

let RangeStepGeneric zero add start step stop : seq<'T> = integralRangeStep zero add (start,step,stop)

fsharp/src/FSharp.Core/prim-types.fs

Lines 6911 to 6912 in fc42ec9

	let inline (.. ..) (start: ^T) (step: ^U) (finish: ^T) =
	RangeStepGeneric (GenericZero< (^U) >) Checked.(+) start step finish

The signature for (.. ..) in prim-types.fsi, however, specifies neither the equality constraint nor the comparison constraint for ^Step, unless ^Step is unified with ^T. I wonder if that plays into it at all?

fsharp/src/FSharp.Core/prim-types.fsi

Lines 3756 to 3762 in fc42ec9

	val inline (.. ..): start: ^T -> step: ^Step -> finish: ^T -> seq< ^T >
	when (^T or ^Step): (static member (+): ^T * ^Step -> ^T)
	and ^Step: (static member Zero: ^Step)
	and ^T: equality
	and ^T: comparison
	and default ^Step: ^T
	and default ^T: int

It would be a compile-time breaking change to update the signature for (.. ..) to include and ^Step: equality and ^Step: comparison, but since any existing code where ^Step doesn't conform to those constraints already fails at runtime, maybe it could be done?