Valid identifier characters in Scala

Question

One thing I find quite confusing is knowing which characters and combinations I can use in method and variable names. For instance

val #^ = 1 // legal val #  = 1 // illegal val +  = 1 // legal val &+ = 1 // legal val &2 = 1 // illegal val £2 = 1 // legal val ¬  = 1 // legal 

As I understand it, there is a distinction between alphanumeric identifiers and operator identifiers. You can mix an match one or the other but not both, unless separated by an underscore (a mixed identifier).

From Programming in Scala section 6.10,

An operator identifier consists of one or more operator characters. Operator characters are printable ASCII characters such as +, :, ?, ~ or #.

More precisely, an operator character belongs to the Unicode set of mathematical symbols(Sm) or other symbols(So), or to the 7-bit ASCII characters that are not letters, digits, parentheses, square brackets, curly braces, single or double quote, or an underscore, period, semi-colon, comma, or back tick character.

So we are excluded from using ()[]{}'"_.;, and `

I looked up Unicode mathematical symbols on Wikipedia, but the ones I found didn't include +, :, ? etc. Is there a definitive list somewhere of what the operator characters are?

Also, any ideas why Unicode mathematical operators (rather than symbols) do not count as operators?

Answer 1

Working from the EBNF syntax in the spec:

upper ::= ‘A’ | ... | ‘Z’ | ‘$’ | ‘_’ and Unicode category Lu lower ::= ‘a’ | ... | ‘z’ and Unicode category Ll letter ::= upper | lower and Unicode categories Lo, Lt, Nl digit ::= ‘0’ | ... | ‘9’ opchar ::= “all other characters in \u0020-007F and Unicode             categories Sm, So except parentheses ([]) and periods” 

But also taking into account the very beginning on Lexical Syntax that defines:

Parentheses ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’. Delimiter characters ‘‘’ | ‘’’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ 

Here is what I come up with. Working by elimination in the range \u0020-007F, eliminating letters, digits, parentheses and delimiters, we have for opchar... (drumroll):

! # % & * + - / : < = > ? @ \ ^ | ~ and also Sm and So - except for parentheses and periods.

(Edit: adding valid examples here:). In summary, here are some valid examples that highlights all cases - watch out for \ in the REPL, I had to escape as \\:

val !#%&*+-/:<=>?@\^|~ = 1 // all simple opchars val simpleName = 1  val withDigitsAndUnderscores_ab_12_ab12 = 1  val wordEndingInOpChars_!#%&*+-/:<=>?@\^|~ = 1 val !^©® = 1 // opchars ans symbols val abcαβγ_!^©® = 1 // mixing unicode letters and symbols 

---

^{Note 1:}

I found this Unicode category index to figure out Lu, Ll, Lo, Lt, Nl:

• Lu (uppercase letters)
• Ll (lowercase letters)
• Lo (other letters)
• Lt (titlecase)
• Nl (letter numbers like roman numerals)
• Sm (symbol math)
• So (symbol other)

^{Note 2:}

val #^ = 1 // legal   - two opchars val #  = 1 // illegal - reserved word like class or => or @ val +  = 1 // legal   - opchar val &+ = 1 // legal   - two opchars val &2 = 1 // illegal - opchar and letter do not mix arbitrarily val £2 = 1 // working - £ is part of Sc (Symbol currency) - undefined by spec val ¬  = 1 // legal   - part of Sm 

^{Note 3:}

Other operator-looking things that are reserved words: _ : = => <- <: <% >: # @ and also \u21D2 ⇒ and \u2190 ←