Double backticks do not follow syntax rules in function arguments, i.e. can be used without spaces

[abelbraaksma]

Arguments to a function must be separated by spaces. But if an argument is an identifier written with double backticks (between `` ... ``), adjacent arguments can be given without spaces.

Same is true for combining backtick-identifiers with non-back-identifiers.

Repro steps

Minimal repro:

let ``hi`` = 12
let ``bye`` = 13
let f x y = x + y
let g = f``hi````bye``   // no spaces between f, ``hi`` and ``bye``

Or even sillier:

let ``hi`` = 12
let ``bye`` = 13
let hi2 = 14
let bye2 = 15
let f w x y z = w + x + y + z
let g = f``hi``hi2``bye``bye2    // no spaces between backticked and non-backticked idents

Expected behavior

This syntax is illegal according to the F# Spec. Identifiers must be separated by spaces.

Actual behavior

No syntax error is thrown.

Known workarounds

n/a

Related information

Seen on F# 4.0, F# 4.1, VS2015, VS2017.

[abelbraaksma]

In fact, it is worse. I thought it was only when the idents are used, but it also happens on definition, this appears legal:

let ``hi````bye`` = 3     // creates a function ``hi`` with argument ``bye``, not expected

but the spec clearly says (p27):

Any sequence of characters that is enclosed in double-backtick marks (`` ``), excluding newlines,
tabs, and double-backtick pairs themselves, is treated as an identifier.

[dsyme]

I think we would adjust/clarify the spec in these cases. Do you have a section reference for "Identifiers must be separated by spaces"? A better wording would be must be separate tokens

On the second one - to me the spec says that hi and bye are separate tokens? Hence one is a function and one an argument

[abelbraaksma]

@dsyme, I checked, but couldn't find it. But the syntax, which sends some variant of ebnf does require spaces between about every token. When we were writing the XPath specification, we had a general statement on whitespace being allowed between tokens, except when marked as whitespace explicit (for instance in F# that would be with UL and the like, abs a minority of the operators).

If this isn't meant to be whitespace specific, it behaves differently from the section I copied in in the original post. If it is, I think it's ambiguous in the spec. If we cab solve this by fixing the spec retrospectively it would be great.

Does an annotated ebnf exist for f#? Or something more parsable or readable than what's used in the spec?

[dsyme]

Closing this out by adding it to fsharp/fsharp.org#841