## 7 Miscellaneous

In this chapter, a number of miscellaneous features of Erlang are described.

### 7.1 Token Syntax

In Erlang 4.8 (OTP R5A) the syntax of Erlang tokens have been extended to allow the use of the full ISO-8859-1 (Latin-1) character set. This is noticeable in the following ways:

- All the Latin-1 printable characters can be used and are shown without the escape backslash convention.
- Atoms and variables can use all Latin-1 letters.

The new characters from Latin-1 have the following classifications in Erlang:

Character classes
Octal | Decimal |  | Class
200 - 237 | 128 - 159 |  | Control characters
240 - 277 | 160 - 191 | - ¿ | Punctuation characters
300 - 326 | 192 - 214 | À - Ö | Uppercase letters
327 | 215 | × | Punctuation character
330 - 336 | 216 - 222 | Ø - Þ | Uppercase letters
337 - 366 | 223 - 246 | ß - ö | Lowercase letters
367 | 247 | ÷ | Punctuation character
370 - 377 | 248 - 255 | ø - ÿ | Lowercase letters

### 7.2 String Concatenation

Two adjacent string literals are concatenated into one. This is done already at compile-time, and doesn't incur any runtime overhead. Example:

            "string" "42"

is equivalent to

            "string42"

This feature is convenient in at least two situations:

- when one of the strings is the result of a macro expansion;
- when a string is very long, and would otherwise either have to wrap, making the source code harder to read, or force the use of some runtime append operation.

### 7.3 The ++ list Concatenation Operator

Since list concatenation is a very common operation, it is convenient to have a terse way of expressing it. The ++ operator appends its second argument to its first. Example:

            X = [1,2,3],
            Y = [4,5],
            X ++ Y.

results in `[1,2,3,4,5]`.

The ++ operator has precedence between the binary '+' operator and the comparison operators.

### 7.4 The - - list Subtraction Operator

The - - operator produces a list which is a copy of the first argument, subjected to the following procedure: for each element in the second argument, its first occurrence in the first argument is removed.

            X = [1,2,3,2,1,2],
            Y = [2,1,2],
            X -- Y.

results in `[3,1,2]`.

The - - operator has precedence between the binary '+' operator and the comparison operators.

### 7.5 Bitwise Operator bnot

Apart from the binary bitwise operators `band`, `bor` and `bxor`, there is a unary operator `bnot` with the same precedence as the other unary operators + and -, i.e., higher than the binary operators. Example:

            bnot 7.

returns -8.

### 7.6 Logical Operators

The atoms `true` and `false` are usually used for representing Boolean values. With the binary operators `and`, `or` and `xor`, and the unary operator `not`, Boolean values can be combined. Example:

            M1 = lists:member(A, List1),
            M2 = lists:member(A, List2),
            M1 and M2.

Note that the operators are strict, i.e., they always evaluate both their arguments.

`not` has the same priority as the other unary operators. The binary logical operators have precedence between the `=` operator and the comparison operators, the `and` operator having higher precedence than `or` and `xor`.

### 7.7 Match Operator = In Patterns

This extension was added in Erlang 4.8 (OTP R5A).

The = operator is also called the `match' operator. The match operator can now be used in a pattern, so that `P1 = P2` is a valid pattern, where both `P1` and `P2` are patterns. This compound pattern when matched against a term causes the term to be matched against both `P1` and `P2`.

One use for this construction is to avoid reconstructing a term which was part of an argument to a function. Example:

            f({'+',X,Y}=T) -> {X+Y,T}.

It also makes it possible to rewrite the construction

            f(X) when X == #rec{x=1, y=a} -> ...

as

            f(#rec{x=1, y=a} = X) -> ...

In the absence of optimization for the former case, the latter case is more efficient.

### 7.8 Literal String Prefix in Patterns

This extension was added in Erlang 4.8 (OTP R5A).

A new construction is allowed in patterns, namely a literal string as the first operand of the ++ operator. Example:

            f("prefix" ++ L) -> ...

This is syntactic sugar for the equivalent, but harder to read

            f([$p,$r,$e,$f,$i,$x | L]) -> ...

### 7.9 Disjunctions in Guards

This extension was added in Erlang 4.9 (OTP R6A).

A new construction is allowed in guards, the disjunction operator ';'. The construction is syntactic sugar which removes the bother of writing the same body after several guards.

            f(X) when xxx ; yyy ; zzz ->
                    pop(X).

This is syntactic sugar for the equivalent

            f(X) when xxx ->
                    pop(X);
            f(X) when yyy ->
                    pop(X);
            f(X) when zzz ->
                    pop(X).

The abstract format has been changed accordingly to contain a list of (conjunctive) guards where there was previously only one guard.

### 7.10 Expressions in Patterns

This extension was added in Erlang 5.0 (OTP R7A).

An arithmetic expression can be used within a pattern, if it uses only numeric or bitwise operators, and if its value can be evaluated to a constant at compile-time. This is especially useful when the expression is defined by a macro.

Example:

            case X of
                   {1+2, T} -> T
            end.

### 7.11 Boolean expresions in guards

This extension was added in Erlang 5.1 (OTP R8).

In guards, the use of `and`, `or` and `not` is now allowed. Guard expressions can combine these with parenthesis. This allows for more elaborate guards than what may be given with `,` and `;`.

| The guard expressions written with these operators are boolean expressions, and the boolean functions `is_list`, `is_integer` etc. should be used, rather than `list`, `integer` etc.

Example 1:

            f(X) when not (is_tuple(X) or is_list(X)) ->
                    ...

Example 2:

            g(A, B) when (A > 0) and (B > 0) and not (A*A < B*B) ->
                    ...

### 7.12 Short-circuit boolean expressions

This extension was added in Erlang 5.1 (OTP R8).

In a boolean expression it is unnecessary to always evaluate all terms. If the first term gives a result that determines the result, the second term is not needed. In Erlang two new keywords handles boolean expressions without evaluating both terms, if it's unnecessary. (This is called short-curcuit boolean evaluation.)

The keyword `andalso` is a short-curcuit version of `and`. The keyword `orelse` is a short-curcuit version of `or`. They can be used in boolean expressions (not guards) instead of `and` and `or`.

Example 1:

            case A >= -1.0 andalso math:sqrt(A+1) > B of

This will work even if `A` is less than `-1.0`, since in that case, the second term (after `andalso`) is never evaluated. (Of course, the same effects could have been done using guards. In guards, evaluation is always short-circuited, since guard tests are known to be free of side-effects.)

Example 2:

            OnlyOne = is_atom(L) orelse
                    (is_list(L) andalso length(L) == 1),

Copyright © 1991-2002 Ericsson Utvecklings AB