Scala underscores in names

Question

I've read multiple style guidelines and other resources stating it's a bad idea to use underscores in method/variable/other names.

What are the technical reasons behind this?

I'm very accustomed to e.g. prepending helper functions with _. There are also functions that should be private that I want to make public so I can access them via the REPL. Other naming conventions like using a "helper" suffix just seem cumbersome.

Any thoughts would be appreciated!

Answer 1

i think those specs just talk about underscores in names.

in what (sane) way should you write the following, if not this way?

object getterSetter {
    var _variable: Option[Double] = None
    def variable = _variable
    def variable_=(newVal: Double) { _variable = Some(newVal) }
}

i think the reason for camelCase instead of embedded_underscores is simply that java uses that and when working with java libraries, consistency can be only kept like that.

Answer 2

The wildcard operator _ is used heavily in Scala. So:

xs map (_.x)  // Call the x method of every element
xs map (_x)   // Pass every element through the _x method

is confusing. You have to look very carefully to see if the underscore is prepended.

However, internal underscores are harder to confuse:

xs map (my_method)  // No similar form where _ stands for the list element

So these are less problematic, but the underscores still catch the eye a little when one is looking for closures. This is probably why they're discouraged, but to be honest, I use them all the time, particularly in things like implicit defs and internal variables where they won't have much or any exposure in an interface.