F# values display badly in default formatting, esp plaintext

[dsyme]

Therer are lots of cases where default formatting for F# values is way off. I'll document a few here and try and make progress on this.

1. Evaluate a method info, e..d

   match <@ display("") @> with Quotations.Patterns.Call(_,mi,_) -> mi
   

   Expect: something reasonable
   Actual: a big mess

2. Evaluate "<@ 1 @>" in a notebook.

   Expect: Some reasonable of the quotation.
   Actual, a big mess, see image at bottom

   Best would really be just the ToString() I think:

   Value (1)
   

   For reference FSI shows this, which is not great but not awful.

       val it : Quotations.Expr<int> =
     Value (1)
    {CustomAttributes = [NewTuple (Value ("DebugRange"),
          NewTuple (Value ("stdin"), Value (1), Value (3), Value (1), Value (4)))];
     Raw = ...;
     Type = System.Int32;}
   

Quotation image:

[dsyme]

@brettfo @KevinRansom I'd like to iterate on the design here.

I know we have extensible type-direct formatting through Formatter<_>.Register(f) but we need to get the basic default printing of a whole swathe of F# data values to be decent without use customization.

Here's a full list of values we need to consider, I'll update these as I think of more, and start to cross them off as I check current status

• Constants (integers, floating point, strings, decimal)
• Constants from .NET libraries (bigint, DateTime, TimeSpan)
• Tuples
• Struct tuples
• Records
• Single case unions without data
• Single case unions with data
• Multi case unions all without data
• Multi case unions some with data
• Enums
• .NET Object values from core libraries (e.g. Type, MethodInfo, Assembly)
• Lists of all of the above
• Arrays of all of the above
• Sequences of all of the above
• Sequences that are slow to compute
• Nested cases of the above (where applicable)
• Quotations (raw and typed)
• Function values (unapplied and partially applied)
• Async values
• Task values
• Lazy values
• IDictionary values
• ICollection values
• Map values
• Set values
• dict values
• values returned by List.groupBy, Seq.groupBy and so on

Then a set of things from important libraries which will need customization

• Data Frames
• Charting
• Tensors
• many other examples

[dsyme]

FWIW I think the best approach here in the short term would be "revert to printing plain text of F# values unless we are sure the result is going to look nice"

And use #646 to control printing in plain text.

Exactly what this means in detail I'm not sure

[dsyme]

@jonsequitur and I had an adhoc chat mostly about plaintext formats and went through the existing structured plaintext formattting mechanisms in F#. Eventually the notes got turned into

https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/plaintext-formatting

Questions for us about plaintext

1. What is the gesture for plaintext?

   • Current: mimetype
   • F# has other options like sprintf "%A"
   • Could add "display_text(x)"

2. What are the defaults for plaintext?

3. What is the extension author viewpoint for F#?

• Typical case study: XPlot, nteract data explorer

• We would really like the extension author not to have to think about F#

• Equally if their extension needs to resort plaintext at "tips", then it may be sensible to allow them to get consistency of plaintext display at those tips. (So encourage extenstion authors to recurse rather than calling ToString at the tips)

4. What is the library author's viewpoint? Do they implement StructuredDisplayFormat attribute? ToString? DebuggerProxy etc? What's a "good" library look like that gives good structured plain text. Case study: DiffSharp tensors

Questions that came up about HTML display

1. How many columns maximum?

2. How to populate the properties by default? Only .NET metadata? Which special cases? PropertyBag cases?

3. How about heterogeneous data?

4. When do we know the HTML is actually better or at least no worse?

5. Is what happens for leaf data consistent with plain text? e..g numeric formats? Do we care if there are differences?

6. When do we use plaintext at tips of the HTML structure? How are those values formatted?

    e.g. sprintf "%A" is an option, but we can also add tweaks to this
   

Don also had a question about How to set the default mimetype

[dsyme]

@jonsequitur @KevinRansom @cartermp I have added a page to the F# docs on F# structured plaintext formatting, see

• Pull request: F# plaintext printing documentation docs#19632

• New doc page

• Additions to F# Interactive docs

[dsyme]

As part of looking at this issue I'm doing a deep dive on what the current spec for Formatting actually is, see #692 (comment) for my mini-spec

[dsyme]

I've been starting to work with build where F# notebooks default to F# Interactive structured plaintext formatting, building on #694

Here's an example:

This is definitely the correct default for F# for when plain text formatting is selected (even if HTML is the default mime type)

One thing I just noticed is the left/right justification diference with HTML formatting. Interesting how different the visuals are

I'm now going to go through the big list of items up above and check that the F# defaults are good for these, both in HTML and plain text.