61

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?

Improve this question
1
  • 3
    I particularly miss ². Scala kind of promises one can make code that uses clever variable (and method) names. But you cannot give a value to a variable x². Illegal character. Commented Dec 3, 2012 at 18:28

3 Answers 3

Reset to default
74

Working from the EBNF syntax in the specification:

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... (drum roll):

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

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 and 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 ←

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Thanks. Also, as the spec says, we are limited to Unicode Basic Multilingual Plane characters, i.e. 2-byte characters up \ufffd. Thus from So, \u262f the Yin Yang operator is legal, but \u1f360 the Roasted Sweet Potato operator is not supported (it's interpreted as \u1f36 + '0').
In Scala 2.9, £ is now reported as an illegal character (presumably the correct behavior wrt the spec).
The § character is also not valid. Any ideas why?
10

The language specification. gives the rule in Chapter 1, lexical syntax (on page 3):

  1. Operator characters. These consist of all printable ASCII characters \u0020-\u007F. which are in none of the sets above, mathematical sym- bols(Sm) and other symbols(So).

This is basically the same as your extract of Programming in Programming in Scala. + is not an Unicode mathematical symbol, but it is definitely an ASCII printable character not listed above (not a letter, including _ or $, a digit, a paranthesis, a delimiter).

In your list:

  1. # is illegal not because the character is not an operator character (#^ is legal), but because it is a reserved word (on page 4), for type projection.
  2. &2 is illegal because you mix an operator character & and a non-operator character, digit 2
  3. £2 is legal because £ is not an operator character: it is not a seven bit ASCII, but 8 bit extended ASCII. It is not nice, as $ is not one either (it is considered a letter).
Improve this answer

1 Comment

The "mathematical sym- bols(Sm) and other symbols(So)" is the object of "consist of" or "in none of"?
2

Use backticks to escape limitations and use Unicode symbols:

val `r→f` = 150 println(`r→f`)
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.