Warning when comparing sequences

[esbenbjerre]

I propose we issue a warning when comparing sequences.

As of now the behaviour of equals/comparison on sequences depends on use of constants and/or what the sequence is backed by.

seq { 1 .. 3 } = seq { 1 .. 3 } // false
seq [ 1; 2; 3 ] = seq [ 1; 2; 3 ] // true

Another example is Seq.groupBy that in some cases will produce unexpected results.

open System

let n = 10

type A = {
  I: int
  Xs: int seq
}

let someSeq =
  Seq.init n (fun i ->
    {
      I = i
      Xs =
        if i >= n / 2 then
          seq [ 1; 2; 3 ]
        else
          seq [ 3; 2; 1 ]
    })

// 2
let ok =
  someSeq
  |> Seq.groupBy (fun x -> x.Xs |> Seq.map id |> List.ofSeq)
  |> Seq.map (fun (_, xs) -> Seq.length xs)
  |> Seq.length

// 10
let unexpected =
  someSeq
  |> Seq.groupBy (fun x -> x.Xs |> Seq.map id)
  |> Seq.map (fun (_, xs) -> Seq.length xs)
  |> Seq.length

Pros and Cons

The advantage of making this adjustment to F# is that it would be more clear that equality between two sequences does not always use structural comparison.

A disadvantage of making this adjustment to F# is that the source of the warning may be confusing (as in the case of Seq.groupBy.

Extra information

Estimated cost (XS, S, M, L, XL, XXL): S

Affidavit (please submit!)

Please tick these items by placing a cross in the box:

• This is not a question (e.g. like one you might ask on StackOverflow) and I have searched StackOverflow for discussions of this issue
• This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to the compiler and tooling repository
• This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it
• I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• This is not a breaking change to the F# language design
• I or my company would be willing to help implement and/or test this

For Readers

If you would like to see this issue implemented, please click the 👍 emoji on this issue. These counts are used to generally order the suggestions by engagement.

[vzarytovskii]

Probably good case for analyzer

[charlesroddie]

What is the implementation of this? I thought that seq is a word for IEnumerable'<'T> and interfaces are equal if they are reference equal. If that is the case, an analyzer which warns when equality is reference equality would be very valuable and would include this.

However this does not explain why the following is true:

seq [ 1; 2; 3 ] = seq [ 1; 2; 3 ] // true

That is very surprising to me.