Custom formatting of a record type is not consistent when nested within other types

[christiandaley]

The following code displays inconsistent behavior for how different types are formatted when printing:

[<StructuredFormatDisplayAttribute("Custom structured format")>]
type MyRecord = {
    a: int
} with
    override _.ToString() = "Custom ToString()"

    interface System.IFormattable with
        member _.ToString (_format, _provider) = "Custom IFormattable"

type OtherRecord = {
    b: MyRecord
}

type MyUnion = | MyUnion of MyRecord

[<EntryPoint>]
let main argv =
    let myRec = {
        a = 10
    }

    let otherRec = {
        b = myRec
    }

    let myUnion = MyUnion myRec

    printfn $"{myRec}"

    printfn $"{otherRec}"

    printfn $"{myUnion}"

    let myTuple = (myRec, myRec)

    printfn $"{myTuple}"

    0

ConsoleApp1.zip

Expected behavior
Ideally The above code would print

Custom IFormattable
{ b = { a = Custom IFormattable } }
MyUnion { a = Custom IFormattable }
(Custom IFormattable, Custom IFormattable)

OR

Custom ToString()
{ b = { a = Custom ToString() } }
MyUnion { a = Custom ToString() }
(Custom ToString(), Custom ToString())

OR

Custom structured format
{ b = Custom structured format }
MyUnion Custom structured format
(Custom structured format,Custom structured format)

In order for the formatting behavior of different types to be consistent.

Actual behavior

The above code prints

Custom IFormattable
{ b = Custom structured format }
MyUnion Custom structured format
(Custom ToString(), Custom ToString())

So it seems that direct string interpolation calls the System.IFormattable.ToString function. Tuple types on the other hand call
ToString() on each of their components. Record types and discriminated union types use the StructuredFormatDisplayAttribute. This behavior is inconsistent and results in a headache when you want to define a custom way for your record type to be printed, and want to have it "just work" regardless of the context in which it is being printed.

Known workarounds

Doing this

[<StructuredFormatDisplayAttribute("Custom structured format")>]
type MyRecord = {
    a: int
} with
    override _.ToString() = "Custom ToString()"

    interface System.IFormattable with
        member this.ToString (_format, _provider) = this.ToString ()

Will bring the direct string interpolation and tuple printing in line with each other, but does not solve the issue for nested record types and discriminated unions. Passing something like "{ToString()}" to the StructuredFormatDisplayAttribute does not work. At runtime it results in <StructuredFormatDisplay exception: Method 'Program+MyRecord.this.ToString()' not found.>.

I cannot find any way to solve the problem I am trying to solve, which is that any time an instance of MyRecord is printed, it should always result in the exact same string, regardless of whether it is printed directly, or printed because it's a member of another record that's being printed, or printed because it's a member of a record that's inside a tuple that's inside another record that's inside of a DU case that's inside of a tuple that's....etc.

Related information

• Operating system: Windows 10
• .NET Runtime kind: .NET 5.0
• F# 6.0.1
• Visual Studio 2019 16.11.9

[dsyme]

• Direct string interpolation calls the System.IFormattable.ToString function.
• Tuple types call ToString() on each of their components
• Record types and discriminated union types use the StructuredFormatDisplayAttribute on each of their components

Yes, this is really unfortunate and I agree it's inconsistent. However there's not a lot we can do about it

• Tuple types are defined in .NET and don't know about StructuredFormatDisplayAttribute
• Direct string interpolation is defined to use System.IFormattable.ToString if present

[dsyme]

@christiandaley Could you see if this formulation works for you to get the consistency you're after?

There are still some issues with this - the recursive invocations of structured formatting can be problematic for stack depth - and some formatting context can be lost by recursive calls.

type MyRecord = 
    { a: int }
    override x.ToString() = sprintf "%+A" x

        
type OtherRecord =
    { b: MyRecord }

type MyUnion = | MyUnion of MyRecord
let myRec = { a = 10 }

let otherRec = { b = myRec }

let myUnion = MyUnion myRec

let s1 = sprintf $"{myRec}"

let s2 = sprintf $"{otherRec}"

let s3 = sprintf $"{myUnion}"

let myTuple = (myRec, myRec)

let s4 = sprintf $"{myTuple}"

I get

val s1: string = "{ a = 10 }"
val s2: string = "{ b = { a = 10 } }"
val s3: string = "MyUnion { a = 10 }"
val myTuple: MyRecord * MyRecord = ({ a = 10 }, { a = 10 })
val s4: string = "({ a = 10 }, { a = 10 })"

[christiandaley]

@dsyme If I use

override this.ToString() = sprintf "Custom %+A" this

Then it prints out

Custom { a = 10 }
{ b = { a = 10 } }
MyUnion { a = 10 }
(Custom { a = 10 }, Custom { a = 10 })

So this approach seems to work for both string interpolation and tuples. Unfortunately it still doesn't work for record types and unions. I didn't consider that .NET would make it difficult to accomplish this, though it does make sense because F# needs to be compatible with what C# is doing.

Thanks for your response.

[dsyme]

So part of the problem is you're not using %A to print (interpolations use %O, i.e. ToString() by default)

Try this:

[<StructuredFormatDisplayAttribute("{DisplayText}")>]
type MyRecord = 
    { a: int }
    member  x.DisplayText = $"CustomA({x.a})"

[<StructuredFormatDisplayAttribute("{DisplayText}")>]
type OtherRecord = 
    { b: MyRecord }
    member  x.DisplayText = $"CustomB(%A{x.b})"

type MyUnion = | MyUnion of MyRecord
let myRec = {
    a = 10
}

let otherRec = {
    b = myRec
}

This gives

val myRec: MyRecord = CustomA(10)
val otherRec: OtherRecord = CustomB(CustomA(10))
val myUnion: MyUnion = MyUnion CustomA(10)
val s1: string = "CustomA(10)"
val s2: string = "CustomB(CustomA(10))"
val s3: string = "MyUnion CustomA(10)"
val myTuple: MyRecord * MyRecord = (CustomA(10), CustomA(10))
val s4: string = "(CustomA(10), CustomA(10))"

[christiandaley]

@dsyme So if I do this

[<StructuredFormatDisplay("{Stringify}")>]
type MyRecord = {
    a: int
} with
    member this.Stringify = this.ToString()

    override this.ToString() = "Custom ToString"

    interface System.IFormattable with
        member this.ToString (_format, _formatProvider) = this.ToString ()

Then I get the following output

Custom ToString
{ b = Custom ToString}
MyUnion Custom ToString
(Custom ToString, Custom ToString)

The ToString function is used to print in all cases. This seems to be an acceptable workaround for what I'm trying to accomplish. It's a bit annoying, but since I only need to do it for a couple types this works fine.

[dsyme]

I think you can omit the IFormattable implementation and get the same result?

[dsyme]

[<StructuredFormatDisplay("{Stringify}")>]
type MyRecord =
    {
        a: int
    } 
    member this.Stringify = this.ToString()

    override this.ToString() = "Custom ToString"

[dsyme]

I've clarified this in the docs here: dotnet/docs#28257