How to name something when the logical option is a reserved keyword?

Question

Occasionally, the most logical name for something (e.g. a variable) is a reserved keyword in the language or environment of choice. When there is no equally appropriate synonym, how does one name it?

I imagine there are best practice heuristics for this problem. These could be provided by the creators or governors of programming languages and environments. For example, if python.org (or Guido van Rossum) says how to deal with it in Python, that would be a good guideline in my book. An MSDN link on how to deal with it in C# would be good too.
Alternatively, guidelines provided by major influencers in software engineering should also be valuable. Perhaps Google/Alphabet has a nice style guide that teaches us how to deal with it?

Here's just an example: in the C# language, "default" is a reserved keyword. When I use an enum, I might like to name the default value "default" (analogous to "switch" statements), but can't.
(C# is case-sensitive, and enum constants should be capitalized, so "Default" is the obvious choice here, but let's assume our current style guide dictates all enum constants are to be lower-case.)
We could consider the word "defaultus", but this does not adhere to the Principle of Least Astonishment. We should also consider "standard" and "initial", but unfortunately "default" is the word that exactly conveys its purpose in this situation.

Answer 1

For an enum option you should use title case like Default. Since C# is case-sensitive it will not collide with the reserved keyword. See .net Naming Guidelines.

Since all public members should be title case in .net, and all reserved names are lower case, you shouldn't really encounter this except with local variables (including parameters). And locals would typically have nouns or phrases as names, so it is pretty rare the most natural name would collide with a keyword. Eg. defaultValue would typically be a more natural name than default. So in practice this is not a big issue.

In C# you can use the "@" prefix to escape reserved keywords so they can be used as identifers (like @default). But this should only be used if you really have no other option, i.e. if you are interfacing with a third-party library which uses a reserved keywords as an identifier.

---

Of course other languages have different syntax and keywords and therefore different solutions this problem.

SQL have quite a lot of keywords, but it is very common to simply escape identifiers, like [Table]. Some even do so for all identifiers, regardless of whether they clash with a keyword or not. (After all, a clashing keyword could be introduced in the future!)

Powershell (and a bunch of other scripting languages) prefixes all variables with a sigil like $ which means they will never collide with keywords.

Lisp does not have keywords at all, at least not in the conventional sense.

Python have an officially recognized convention in PEP-8:

Always use cls for the first argument to class methods.

If a function argument's name clashes with a reserved keyword, it is generally better to append a single trailing underscore rather than use an abbreviation or spelling corruption. Thus class_ is better than clss. (Perhaps better is to avoid such clashes by using a synonym.)

Some languages like Brainfuck or Whitespace avoids defining words at all, elegantly sidestepping the problem.

In short there is no language-independent answer to your question, since it highly depending on the syntax and conventions of the specific language.

Answer 2

I would append an underscore (default_)

Pros:

• simple
• obvious(why else would you append an underscore?)
• consistent
• easy to use
• works in all modern languages I know
• closest to the logical option

Why I dont like other solutions:

Synonym:

• hard to find
• often not the exact same meaning(nuances)

Appending/Prepending a word:

• inconsistent(defaultValue, defaultItem)
• increased verbosity without increased readability

Changing letters(clazz instead of class):

• inconsistent(clazz, klass, klazz)

Appending a number(default1):

• raises the question for default2

Appending/Prepending a letter:

• non obvious(programmer has to guess that it was used for namecollision and not a shortcut for something else)

Escaping a Keyword(@default(c#), `default`(scala))

• only possible in some languages
• rarely used feature, mainly for compatibility to other languages
• makes it harder to use for users of your api(they have to know how to do it and remember how to do it)

When would I not use it:

• existing, widely used other convention
• I already know a fitting synonym
• in your specific enum case I would follow @JacquesB answer

Answer 3

"Default" is probably not a helpful enum value. It represents a behavior that may change depending on the context where it is used.

That being said, if your language is case sensitive, then use a different case for the word. (Default vs default)

Or better yet, make the extra effort to type a few more letters and call it DefaultValue.

Answer 4

I would highly recommend NOT changing naming convention locally (or adding meaningless characters) for the purpose of disambiguation (like have been suggested in other posts). It creates confusion if intent is not obvious and may raise questions as to why was it named this way. It can be solved without it.

In every case it should be possible to either use a word with synonymous meaning or make the name more specific (or even verbose). Even when it may introduce repetition of context it may be a better solution.

For example, lets say you have an enum Mode that should expose a default value like in your case. Naming it default_mode may not seem the best due to the repetition, but it avoids ambiguity while conveying desired meaning.

Answer 5

You'll need to use different or modified word(s), that is clear.
So this usually means either

• a completely different word
• a prefix
• a suffix

Another factor to determine is how to join the multiple words and the options are usually

• allonewordnoseparators
• words_with_underscores-or-dashes (snake_case)
• CapitalizationForClarityAndReadability (CamelCase)

My suggestion is to use a prefix or suffix and underscores/dashes, e.g.

local_default, my_default, a_default, domain_specific_default
default_local, default_me, default_a, default_domain_specific

local_default has the advantage that all the locals are aligned and thus stand out quickly but the disadvantage that you always have to read on to the second portion to get the unique name. default_local has the converse advantage that the unique variable name is quickly seen, but locals are not always so easily grouped visually.

A couple of examples for the the domain_specific approach I have seen are: vehicle_model instead of model which was a reserved word; room_table for a SQL table as table is a reserved word.

The other two options I have seen languages or scripts use are:

• quotes or backtips to surround variables names and thus allow the use of reserved words. Similar to this I could imagine some languages might allow a special character such as a backspace to escape a name.
• spaces in variables names.

Answer 6

Obviously, do what you can to avoid that situation. I've been writing software since the late 1970s and the times I've really, really had to fudge a reserved word is well under ten, probably closer to five.

There are lots of things you can do, such as doubling the first or last letter (reservedd) or adding a leading or trailing underscore (reserved_). What's appropriate will depend a lot on the conventions used language you're writing, especially with regard to leading or trailing underscores. Also try not to do things with case that could be misread by humans (e.g., using Reserved when it differs from reserved).

Once you've picked something, put it in your coding guidelines, make sure people know about it and that it's used consistently. I even go so far as to add a reminder comment so readers don't think it's a typo and know they'll be seeing it again:

int ccase;  // Name dodges a reserved word

Answer 7

In C#, you can prepend the name of an identifier with @. This tells the compiler to treat the name as the name of an identifier and not as a possible keyword.

enum @default {Sat, Sun, Mon, Tue, Wed, Thu, Fri};