Order of anonymous record types properties

[lucasteles]

Recently I got this issue on how F# anonyomous record types handle the type property order.

Unlike C# anonymous types, F# creates the definition of anonymous records with properties in alphabetic order which I think is not a usual expected behavior.

The signature shows how the type is internally created.

I believe this takes out control over the type definitions and can cause unexpected behaviors.

Is this an intended behavior? if not, would it be a breaking change?

[brianrourkeboll]

That was part of the original design, yeah: https://github.com/fsharp/fslang-design/blob/71cd2e04bc181264a6a68c731ff018369848d1f9/FSharp-4.6/FS-1030-anonymous-records.md#field-ordering

Field Ordering

Fields are placed in a canonical order by the compiler, so type {| A : int; B : int |} is type-equivalent to {| B: int; A : int |}.

I don't know what the complete rationale was, but it kind of makes sense that F# might do it differently from C#, since anonymous object types in C# can't be expressed across method/function boundaries, while they can in F#.

It does make it easier to tell at a glance when inspecting these functions' signatures that they return the same type, for example:

let f () = {| A = 1; B = 3; Z = 99 |}
let g () = {| Z = 99; B = 3; A = 1 |}

The RFC does however call out the fact that ordering the fields alphabetically may result in mismatches with other orderings: https://github.com/fsharp/fslang-design/blob/71cd2e04bc181264a6a68c731ff018369848d1f9/FSharp-4.6/FS-1030-anonymous-records.md#alternative-do-not-sort-fields-by-name

Alternative: Do not sort fields by name

Sorting by field name is the natural thing for the programmer from a type-system usability perspective.

However it does have some downsides. For example, when using anonymous record data for rows in tabular data the fields will not imply a column ordering.

[vzarytovskii]

Was about to say that it might be a breaking change, but Brian beat me to it :) Thanks!

[brianrourkeboll]

Or, perhaps more compelling — these return the same type now, but would return different types if the type depended on field declaration/assignment order, and there would be no way to reorder the fields without completely reconstructing the record (of potentially many fields):

let f (x : {| Z : int |}) = {| x with A = 3 |}
let g (x : {| A : int |}) = {| x with Z = 3 |}