If a class/object/trait extends anything, the same general rule applies,put it on one line unless it goes over about 100 characters, and thenput each item on its own line withtrailing commas;closing parenthesis provides visual separation between constructor arguments and extensions;empty line should be added to further separate extensions from class implementation:

  name: String,
  age: Int,
  birthdate: Date,
  astrologicalSign: String,
  shoeSize: Int,
  favoriteColor: java.awt.Color,
) extends Entity
  with Logging
  with Identifiable
  with Serializable {
  def firstMethod: Foo = …
}

All class/object/trait members should be declared interleaved withnewlines. The only exceptions to this rule are var and val. Thesemay be declared without the intervening newline, but only if none of thefields have Scaladoc and if all of the fields have simple (max of 20-ishchars, one line) definitions:

class Foo {
  val bar = 42
  val baz = "Daniel"
  def doSomething(): Unit = { ... }
  def add(x: Int, y: Int): Int = x + y
}

Fields should precede methods in a scope. The only exception is if theval has a block definition (more than one expression) and performsoperations which may be deemed “method-like” (e.g. computing the lengthof a List). In such cases, the non-trivial val may be declared at alater point in the file as logical member ordering would dictate. Thisrule only applies to val and lazy val! It becomes very difficultto track changing aliases if var declarations are strewn throughoutclass file.

Methods should be declared according to the following pattern:

def foo(bar: Baz): Bin = expr

Methods with default parameter values should be declared in an analogousfashion, with a space on either side of the equals sign:

You should specify a return type for all public members.Consider it documentation checked by the compiler.It also helps in preserving binary compatibility in the face of changing type inference (changes to the method implementation may propagate to the return type if it is inferred).

Local methods or private methods may omit their return type:

private def foo(x: Int = 6, y: Int = 7) = x + y

Procedure Syntax

Avoid the procedure syntax, as it tends to be confusing for very little gain in brevity.

// don't do this
def printBar(bar: Baz) {
  println(bar)
}
// write this instead
def printBar(bar: Bar): Unit = {
  println(bar)
}

Modifiers

Method modifiers should be given in the following order (when each isapplicable):

• Annotations, each on their own line
• Override modifier (override)
• Access modifier (protected, private)
• Implicit modifier (implicit)
• Final modifier (final)
• def

Body

When a method body comprises a single expression which is less than 30(or so) characters, it should be given on a single line with the method:

def add(a: Int, b: Int): Int = a + b

def sum(ls: List[String]): Int =
  ls.map(_.toInt).foldLeft(0)(_ + _)

The distinction between these two cases is somewhat artificial.Generally speaking, you should choose whichever style is more readableon a case-by-case basis. For example, your method declaration may bevery long, while the expression body may be quite short. In such a case,it may be more readable to put the expression on the next line ratherthan making the declaration line too long.

When the body of a method cannot be concisely expressed in a single lineor is of a non-functional nature (some mutable state, local orotherwise), the body must be enclosed in braces:

def sum(ls: List[String]): Int = {
  val ints = ls map (_.toInt)
  ints.foldLeft(0)(_ + _)
}

Methods which contain a single match expression should be declared inthe following way:

// right!
def sum(ls: List[Int]): Int = ls match {
  case hd :: tail => hd + sum(tail)
}

Not like this:

// wrong!
  ls match {
    case hd :: tail => hd + sum(tail)
    case Nil => 0
  }
}

Multiple Parameter Lists

In general, you should only use multiple parameter lists if there is agood reason to do so. These methods (or similarly declared functions)have a more verbose declaration and invocation syntax and are harder forless-experienced Scala developers to understand.

There are three main reasons you should do this:

• For a fluent API

Multiple parameter lists allow you to create your own “controlstructures”:

def unless(exp: Boolean)(code: => Unit): Unit = if (!exp) code
unless(x < 5) {
  println("x was not less than five")
}

• Implicit Parameters

When using implicit parameters, and you use the implicit keyword,it applies to the entire parameter list. Thus, if you want only someparameters to be implicit, you must use multiple parameter lists.

• For type inference

When invoking a method using only some of the parameter lists, thetype inferencer can allow a simpler syntax when invoking theremaining parameter lists. Consider fold:

For complex DSLs, or with type-names that are long, it can be difficultto fit the entire signature on one line. In those cases, align theopen-paren of the parameter lists, one list per line (i.e. if you can’tput them all on one line, put one each per line):

protected def forResource(resourceInfo: Any)
                         (f: (JsonNode) => Any)
                         (implicit urlCreator: URLCreator, configurer: OAuthConfiguration): Any = {
  ...
}

Higher-Order Functions

fun foldl (f: ('b * 'a) -> 'b) (init: 'b) (ls: 'a list) = ...

In Scala, the preferred style is the exact inverse:

def foldLeft[A, B](ls: List[A])(init: B)(f: (B, A) => B): B = ...

By placing the function parameter last, we have enabled invocationsyntax like the following:

foldLeft(List(1, 2, 3, 4))(0)(_ + _)

The function value in this invocation is not wrapped in parentheses; itis syntactically quite disconnected from the function itself(foldLeft). This style is preferred for its brevity and cleanliness.

Fields should follow the declaration rules for methods, taking specialnote of access modifier ordering and annotation conventions.

Lazy vals should use the lazy keyword directly before the val:

private lazy val foo = bar()

Function Values

Scala provides a number of different syntactic options for declaringfunction values. For example, the following declarations are exactlyequivalent:

• val f1 = ((a: Int, b: Int) => a + b)
• val f2 = (a: Int, b: Int) => a + b
• val f3 = (: Int) + (: Int)
• val f4: (Int, Int) => Int = ( + )Of these styles, (1) and (4) are to be preferred at all times. (2)appears shorter in this example, but whenever the function value spansmultiple lines (as is normally the case), this syntax becomes extremelyunwieldy. Similarly, (3) is concise, but obtuse. It is difficult for theuntrained eye to decipher the fact that this is even producing afunction value.

When styles (1) and (4) are used exclusively, it becomes very easy todistinguish places in the source code where function values are used.Both styles make use of parentheses, since they look clean on a single line.

There should be no space between parentheses and the code they contain.Curly braces should be separated from the code within them by a one-space gap,to give the visually busy braces “breathing room”.

Most function values are less trivial than the examples given above.Many contain more than one expression. In such cases, it is often morereadable to split the function value across multiple lines. When thishappens, only style (1) should be used, substituting braces for parentheses.Style (4) becomes extremely difficult to follow when enclosed in large amountsof code. The declaration itself should loosely follow the declaration style formethods, with the opening brace on the same line as the assignment orinvocation, while the closing brace is on its own line immediatelyfollowing the last line of the function. Parameters should be on thesame line as the opening brace, as should the “arrow” (=>):

val f1 = { (a: Int, b: Int) =>
  val sum = a + b
}

As noted earlier, function values should leverage type inferencewhenever possible.