Method naming convention in Scala — mutable and not version?

Question

This example is trivial just to show the point.

Let's say I use matrix library, but is lacks some power, let's say doubling every element in matrix is so crucial for me, I decide to write a method doubleIt . However, I could write 2 versions of this method

1. mutable -- doubleItInPlace
2. non mutable -- doubleItByCreatingNewOne

This is a bit lengthy, so one could think of naming convention, adding to mutable version _! suffix, or prefixing it with word "mut".

Is there any establishing naming convention for making such difference?

Answer 1

The convention is to name the mutable (in general, side-effecting) version with a verb in imperative form. Additionally, and more importantly, use the empty parameter list () at the end:

def double()
def doubleIt()

The immutable version, ie one producing a new object, you should name via verb in the passive form. More importantly, do not use the empty parameter list () at the end:

def doubled
def doubledMatrix

Note that naming the non-side-effecting method in the passive form is not always adhered (eg the standard collections library), but is a good idea unless it makes the name overly verbose.

Source: Scala styleguide .