[RFC FS-1132] Interpolated strings syntax with multiple dollar signs

[abonie]

Let's discuss RFC FS-1132 (PR link)
Suggestion: Allow double dollar signs for interpolated strings as in C# 11

FYI this RFC is merged now.

Edit: a preliminary implementation can be found here: dotnet/fsharp#14640

[abonie]

Not to anchor the discussion around this, but I am wondering about:

Do we want to also provide a way to easily input percent signs in interpolated string literals?

Can anyone maybe help estimate how feasible this is (and how much work)?
Currently there's really no good way of including % in content of an interpolated string literal (doubling to escape works with printfn and not interpolated string literals in general). So I would really like to do this if it is feasible at all. It could work similarly to curly braces - N $ signs mean that N consecutive %s in content will be treated as beginning of format specifier and any less will just count as %s in content

[abonie]

I agree, but if we think it might be worth it, I can try to get a feeling for how much extra work would approach 2 take. If we end up doing the 2nd option, we could then also consider @MecuSorin's alternative suggestion for interpolation delimiters (I am assuming scanning would be very similar there, so it wouldn't take that much extra work on top of doing option 2)

[abonie]

So FYI I went with option 1 while implementing, should I make a PR to update the RFC? It's going to be a bit wordy to precisely describe, but bascially as @abelbraaksma suggested, same relation as $s and curlies have, applies to $s and %s in my implementation.

(and BTW correct syntax coloring for %s in interpolated strings is maybe the last missing functionality to implement)

[abelbraaksma]

Great! Can you link the PR? Wordy isn’t a problem, but maybe let’s first see how the PR goes before having to update multiple times. We can use the PR to discuss implementation details until we’ve done to an accepted solution. Then it’s time to align the RFC as well.

[abonie]

Makes sense, here is draft PR with implementation: dotnet/fsharp#14640

[abelbraaksma]

Tx, I’ve added it to the OP here, for easy discovery, hope you don’t mind :)

[MecuSorin]

In my opinion this adds too much complexity for a minimal gain.

Good old VIM have a way to solve this by specifying the separator (for searches for example), but I don't know how easy will be to implement something similar in our compiler parser:

$/"my / 1 + 1 / cents"

[abonie]

It looks quite tempting, a couple of things to consider:

1. From the user perspective, is it a better approach than what is proposed in the RFC?
2. Is it so much better that it is worth to forgo alignment with corresponding C# feature?
3. Is it at all feasible to implement in F# compiler?

Regarding 1., I do think it is nicer in usage, at least at first glance.

Regarding 2., I'll admit I was much more excited about aligning with C# before I realized they handle single-$ case differently than F#, so it would be a breaking change to fully align. But still, I think there's some value in partially aligning.

3rd point is the biggest obstacle in my mind. My impression so far is that it is not feasible to implement this without pretty much rewriting how lexing/parsing is done. I'll give it some more thought and if someone with more experience/knowledge can chime in, that would be very welcome.

[abelbraaksma]

The biggest issue here is that it is a completely different syntax than C# is using. Perhaps it would’ve been a feasible idea if ‘F# came up with it first’, but having two entirely different syntaxes for string interpolation isn’t going to be a good way forward.

I do like the idea of being able to define the delimiter, though. It’s a feature/idea that has its roots in Perl. Note that in the original string interpolation RFC, this idea was discussed and ultimately dismissed. Probably in part because of the added complexity of the lexing/parsing. Not impossible, but a massive amount of work.

[abonie]

I have added one more open question - whether regular string literals (single quoted) should be supported as well.

I am leaning towards no to be honest, since the idea here is to have string literals with as little escaping as possible, and single quoted string literals rely on escaping (as opposed to triple quoted ones). Curious to hear what others think though.

[abelbraaksma]

I agree. It’s a whole new can of worms for $"xyz" and $@"xyz" to also be allowed. While the latter may be easier than the former, this feature is meant specifically for larger strings that have C-style brackets in them.

The use case is too limited to warrant the cost, unless perhaps while implementing this it turns out to be relatively cheap to do. I do like how it would bring orthogonality to the feature, though.

[abonie]

The implementation is IMO ready to be reviewed: dotnet/fsharp#14640 (brace matching in VS does not quite work, but I want to time box it for now and in the worst case tackle in a separate PR).

What is the next step here, PR review or some final design review first?

cc: @abelbraaksma

[abonie]

Actually, good news - I think I got brace matching to work, PR is updated, just thinking of some edge cases to test.

[Happypig375]

I wonder if this suggestion can also be extended to make " usable directly by requiring the string end to repeat the same number of $s.
e.g.

$$$"{{{1}}}"yo""$$$

->

 1 "yo" 

Single $ will remain the same as is for back compat. Optionally, $ can still be added after the string, e.g. $"{1}"$ and $"{1}" both work.

[abonie]

Hmm...

So first of all, note that this RFC only touches triple quote strings, that means $$$"{{{1}}}" remains invalid anyway (as opposed to $$$"""{{{1}}}""" which is what this RFC wants to introduce).

In triple quote strings, you can use " or "" without escaping, but 3x or more becomes problematic (I think you'd have to actually use interpolation or some other form of composing strings). So this is a valid request.

In C# (link) they handle it by allowing string literals to start with more than 3x " (and then you can have any sequence of consecutive " as long as it's shorter than whatever the string literal started with). Closing quotes have to match opening quotes in length. But they also have some different rules about where to put opening and closing quotes, that probably make parsing easier, but wouldn't be backward compatible with F#'s syntax.

So I think it should be possible to do what C# does, but skipping their restrictions on opening/closing quotes placement, however I am not entirely sure yet.

Otherwise, your suggestion @Happypig375 seems quite elegant on its own, but then we'd have a weird mixture of trying to align with C# + making exceptions to maintain our backward compat + inventing completely new syntax...

Eh... I think I have to defer to @abelbraaksma or @dsyme

[Happypig375]

F# cannot just copy C# design here because they interpret """""" as a start of a string to end with the same number of double quotes, unlike F# which interprets this as the empty string.

[abonie]

You are right, I suppose that's why in C#, in multiline raw string literals, the opening and closing quotes have to be on their own lines (and they ignore first and last newline in content).

[abonie]

FYI there will be a community review session for this feature tomorrow, March 28, at 8PM UTC+2, link to join the meeting will be posted later under this issue: fsharp/fsharp.org#932