[RFC FS-1352] Interpolated strings in constant expressions

[xperiandri]

Discussion thread for RFC FS-1352: #853

• Language suggestion: Support (a subset of) interpolated strings in Attribute parameters fslang-suggestions#1347 (not yet approved in principle)
• RFC: RFCs/FS-1352-interpolated-strings-in-constant-expressions.md (PR branch until merged)

The RFC makes an interpolated string a constant expression when each hole is a non-null constant string expression without alignment or format specifiers. These are the rules of C# 10 constant interpolated strings. [<Literal>] values, attribute arguments and type provider static arguments can then use interpolation, as they already use +:

[<Literal>]
let Root = "api/v2"

[<Literal>]
let ItemById = $"{Root}/items/{{id}}"   // "api/v2/items/{id}"

[<Obsolete($"Use {nameof getItemV2} instead")>]
let getItem id = getItemV2 id

Design points:

• The value is the text that the same expression gives at run time, with {{, }} and %% escapes processed. So a constant interpolated string can also be a printf format literal.
• Holes of int, char and bool types are rejected for parity with C#, although F# formats them with the invariant culture. A plain %s{e} hole is rejected for the same reason.
• A null constant hole is an error, as in C# (CS0133) and as for + in F# today.
• Outside constant contexts nothing changes. The RFC does not require compile-time folding there.

[brianrourkeboll]

Holes of int, char and bool types are rejected for parity with C#, although F# formats them with the invariant culture. A plain %s{e} hole is rejected for the same reason.

Is there a good reason to aim for "parity with C#" in this case? F# format specifiers are already an inherent difference with no equivalent in C#. Assuming invariant culture actually guarantees consistent formatting, then being able to take advantage of that in F# seems useful.

[baronfel]

This is my take too - the final values are const-embedded in the attribute, so as long as we're not emitting things that other languages can't consume in IL metadata we should feel free to make use of F#'s extended grammar here.

[T-Gro]

Not a practical use case, but still an edge case worth mentioning:

...except for differences in runtime's string representation of special values (think floats and -0.0), therefore depending on the compiler's runtime (net core vs net472) for your IL constants.

[xperiandri]

Implemented both ways: dotnet/fsharp#20753 follows the merged RFC (string holes only, as in C#), and dotnet/fsharp#20754 adds what was asked here, integer, decimal, char, bool and plain %s holes, with the RFC amendment in #859.

Floats stay out for the reason given above: (-0.0).ToString(null, CultureInfo.InvariantCulture) is 0 on .NET Framework 4.8 and -0 on .NET 10, so the constant would depend on the compiler's runtime. decimal text, scale included, is the same on both.