least one completely blank line (i.e a line which contains no

printable characters), then two `nl` tokens are inserted.

contains productions where optional `nl` tokens, but not

semicolons, are accepted. This has the effect that a newline in one of these

positions does not terminate an expression or statement. These positions can

- in front of an opening brace ‘{’, if that brace is a legal

continuation of the current statement or expression,

if the first token on the next line can start an expression,

- in front of a [parameter clause](04-basic-declarations-and-definitions.html#function-declarations-and-definitions), and

- after an [annotation](11-user-defined-annotations.html#user-defined-annotations).

Method `stripMargin` is defined in class

Because there is a predefined

[implicit conversion](06-expressions.html#implicit-conversions) from `String` to

`StringLike`, the method is applicable to all strings.

_conforms to its bounds_, i.e. $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the

substitution $[ a_1 := T_1 , \ldots , a_n := T_n ]$.

Given the partial type definitions:

the following types are ill-formed:

arbitrary identifier.

All type infix operators have the same precedence; parentheses have to

of a type operator is determined as for term operators: type operators

ending in a colon ‘:’ are right-associative; all other

operators are left-associative.

Note that the linearization of a class refines the inheritance

relation: if $C$ is a subclass of $D$, then $C$ precedes $D$ in any

linearization where both $C$ and $D$ occur.

a linearization of a class always contains the linearization of its direct superclass as a suffix.

For instance, the linearization of `StringIterator` is

The following class can be created only from its companion module.

a _selection_.

A simple name $x$ refers to a value as specified

If $x$ is bound by a definition or declaration in an enclosing class

or object $C$, it is taken to be equivalent to the selection

`$C$.this.$x$` where $C$ is taken to refer to the class containing $x$

occurrence of $x$.

If $r$ is a [stable identifier](03-types.html#paths) of type $T$, the selection $r.x$ refers

|`x.f(i) = e` | `x.f.update(i, e)` |

|`x.f(i, j) = e` | `x.f.update(i, j, e)`|

Here is the usual imperative code for matrix multiplication.

A try expression is of the form `try { $b$ } catch $h$`

where the handler $h$ is a

{ case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ }

The `implicit` modifier is illegal for all

type members, as well as for [top-level objects](09-top-level-definitions.html#packagings).

The following code defines an abstract class of monoids and

two concrete implementations, `StringMonoid` and

`IntMonoid`. The two implementations are marked implicit.

dominate any of the other types in the set.

Here, a core type $T$ _dominates_ a type $U$ if $T$ is

to $U$, or if the top-level type constructors of $T$ and $U$ have a

common element and $T$ is more complex than $U$.

if there are several possible candidates (of either the call-by-value

or the call-by-name category).

Class `scala.Ordered[A]` contains a method

An infix operation pattern $p;\mathit{op};q$ is a shorthand for the

constructor or extractor pattern $\mathit{op}(p, q)$. The precedence and

associativity of operators in patterns is the same as in

An infix operation pattern $p;\mathit{op};(q_1 , \ldots , q_n)$ is a

shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1