The_Swift_Programming_Language

Lexical Structure

The lexical structure of Swift describes what sequence of characters form valid tokens of the language. These valid tokens form the lowest-level building blocks of the language and are used to describe the rest of the language in subsequent chapters.

In most cases, tokens are generated from the characters of a Swift source file by considering the longest possible substring from the input text, within the constraints of the grammar that are specified below. This behavior is referred to as longest match or maximal munch.

Whitespace and Comments

Whitespace has two uses: to separate tokens in the source file and to help determine whether an operator is a prefix or postfix (see Operators), but is otherwise ignored. The following characters are considered whitespace: space (U+0020), line feed (U+000A), carriage return (U+000D), horizontal tab (U+0009), vertical tab (U+000B), form feed (U+000C) and null (U+0000).

Comments are treated as whitespace by the compiler. Single line comments begin with // and continue until the end of the line. Multiline comments begin with /* and end with */. Nesting is allowed, but the comment markers must be balanced.

Identifiers

Identifiers begin with an upper case or lower case letter A through Z, an underscore (_), a noncombining alphanumeric Unicode character in the Basic Multilingual Plane, or a character outside the Basic Multilingual Plan that isn’t in a Private Use Area. After the first character, digits and combining Unicode characters are also allowed.

To use a reserved word as an identifier, put a backtick (`) before and after it. For example, class is not a valid identifier, but `class` is valid. The backticks are not considered part of the identifier; `x` and x have the same meaning.

Inside a closure with no explicit parameter names, the parameters are implicitly named $0, $1, $2, and so on. These names are valid identifiers within the scope of the closure.

G R A M M A R O F A N I D E N T I F I E R

​identifier → identifier-head identifier-characters opt

​identifier → ` identifier-head identifier-characters opt ` ​identifier → implicit-parameter-name

​identifier-list → identifier identifier , identifier-list

​identifier-head → Upperor lowercase letter A through Z

​identifier-head → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA

​identifier-head → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF

​identifier-head → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF

​identifier-head → U+1E00–U+1FFF

​identifier-head → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F

​identifier-head → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793

​identifier-head → U+2C00–U+2DFF or U+2E80–U+2FFF

​identifier-head → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF

​identifier-head → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44

​identifier-head → U+FE47–U+FFFD

​identifier-head → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD

​identifier-head → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD

​identifier-head → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD

​identifier-head → U+D0000–U+DFFFD or U+E0000–U+EFFFD

​identifier-character → Digit 0 through 9

​identifier-character → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F

​identifier-character → identifier-head

​identifier-characters → identifier-character identifier-characters opt

​implicit-parameter-name → $ decimal-digits

Keywords

The following keywords are reserved and may not be used as identifiers, unless they’re escaped with backticks, as described above in Identifiers.

Keywords used in declarations: class, deinit, enum, extension, func, import, init, let, protocol, static, struct, subscript, typealias, and var.

Keywords used in statements: break, case, continue, default, do, else, fallthrough, if, in, for, return, switch, where, and while.

Keywords used in expressions and types: as, dynamicType, is, new, super, self, Self,

Type, __COLUMN__, __FILE__, __FUNCTION__, and __LINE__.

Keywords reserved in particular contexts: associativity, didSet, get, infix, inout, left,

mutating, none, nonmutating, operator, override, postfix, precedence, prefix, right, set, unowned, unowned(safe), unowned(unsafe), weak and willSet. Outside the context in which they

appear in the grammar, they can be used as identifiers.

Literals

A literal is the source code representation of a value of an integer, floating-point number, or string type. The following are examples of literals:

G R A M M A R O F A L I T E R A L

​literal → integer-literal floating-point-literal string-literal

Integer Literals

Integer literals represent integer values of unspecified precision. By default, integer literals are expressed in decimal; you can specify an alternate base using a prefix. Binary literals begin with 0b, octal literals begin with 0o, and hexadecimal literals begin with 0x.

Decimal literals contain the digits 0 through 9. Binary literals contain 0 and 1, octal literals contain 0 through 7, and hexadecimal literals contain 0 through 9 as well as A through F in upperor lowercase.

Negative integers literals are expressed by prepending a minus sign (-) to an integer literal, as in -42.

Underscores (_) are allowed between digits for readability, but are ignored and therefore don’t affect the value of the literal. Integer literals can begin with leading

upperor lowercase e prefix followed by sequence of decimal digits that indicates what power of 10 the value preceding the e is multiplied by. For example, 1.25e2 represents

Hexadecimal floating-point literals consist of a 0x prefix, followed by an optional hexadecimal fraction, followed by a hexadecimal exponent. The hexadecimal fraction consists of a decimal point followed by a sequence of hexadecimal digits. The exponent consists of an upperor lowercase p prefix followed by sequence of decimal digits that indicates what power of 2 the value preceding the p is multiplied by. For example, 0xFp2 represents 15 22, which evaluates to 60. Similarly, 0xFp-2 represents 15 2-2, which evaluates to 3.75.

Unlike with integer literals, negative floating-point numbers are expressed by applying the unary minus operator (-) to a floating-point literal, as in -42.0. The result is an expression, not a floating-point integer literal.

Underscores (_) are allowed between digits for readability, but are ignored and therefore don’t affect the value of the literal. Floating-point literals can begin with leading zeros (0), but are likewise ignored and don’t affect the base or value of the literal.

Unless otherwise specified, the default type of a floating-point literal is the Swift standard library type Double, which represents a 64-bit floating-point number. The Swift standard library also defines a Float type, which represents a 32-bit floating-point number.

G R A M M A R O F A F L O A T I N G - P O I N T L I T E R A L

​floating-point-literal → decimal-literal decimal-fractionopt decimal-exponent opt ​floating-point-literal → hexadecimal-literal hexadecimal-fractionopt hexadecimal-

exponent

​decimal-fraction → . decimal-literal

​decimal-exponent → floating-point-e signopt decimal-literal

​hexadecimal-fraction → . hexadecimal-literal opt ​hexadecimal-exponent → floating-point-p signopt hexadecimal-literal

​floating-point-e → e E ​floating-point-p → p P ​sign → + -

String Literals

A string literal is a sequence of characters surrounded by double quotes, with the

following form:

" characters "

String literals cannot contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed.

Special characters can be included in string literals using the following escape sequences:

Null Character (\0)

Backslash (\\)

Horizontal Tab (\t)

Line Feed (\n)

Carriage Return (\r)

Double Quote (\")

Single Quote (\')

Characters can also be expressed by \x followed by two hexadecimal digits, \u followed by four hexadecimal digits, or \U followed by eight hexadecimal digits. The digits in these escape sequences identify a Unicode codepoint.

The value of an expression can be inserted into a string literal by placing the expression in parentheses after a backslash (\). The interpolated expression must not contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed. The expression must evaluate to a value of a type that the String class has an initializer for.

For example, all the following string literals have the same value:

The default type of a string literal is String. The characters that make up a string are of type Character. For more information about the String and Character types, see Strings and Characters.

G R A M M A R O F A S T R I N G L I T E R A L

​string-literal → " quoted-text "

​quoted-text → quoted-text-item quoted-text opt

​quoted-text-item → escaped-character ​quoted-text-item → \( expression )

​quoted-text-item → Any Unicode extended grapheme cluster except " , \ , U+000A, or U+000D

​escaped-character → \0 \\ \t \n \r \" \' ​escaped-character → \x hexadecimal-digit hexadecimal-digit

​escaped-character → \u hexadecimal-digit hexadecimal-digit hexadecimaldigit hexadecimal-digit

​escaped-character → \U hexadecimal-digit hexadecimal-digit hexadecimaldigit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimaldigit hexadecimal-digit

Operators

The Swift standard library defines a number of operators for your use, many of which are discussed in Basic Operators and Advanced Operators. The present section describes which characters can be used as operators.

Operators are made up of one or more of the following characters: /, =, -, +, !, *, %, <, >, &, |, ^, ~, and .. That said, the tokens =, ->, //, /*, */, ., and the unary prefix operator & are reserved. These tokens can’t be overloaded, nor can they be used to define custom operators.

The whitespace around an operator is used to determine whether an operator is used as a prefix operator, a postfix operator, or a binary operator. This behavior is summarized in the following rules:

If an operator has whitespace around both sides or around neither side, it is treated as a binary operator. As an example, the + operator in a+b and a + b is treated as a binary operator.

If an operator has whitespace on the left side only, it is treated as a prefix unary operator. As an example, the ++ operator in a ++b is treated as a prefix unary operator.

If an operator has whitespace on the right side only, it is treated as a postfix unary operator. As an example, the ++ operator in a++ b is treated as a postfix unary operator.

If an operator has no whitespace on the left but is followed immediately by a dot (.), it is treated as a postfix unary operator. As an example, the ++ operator in a++.b is treated as a postfix unary operator (a++ . b rather than a ++ .b).

For the purposes of these rules, the characters (, [, and { before an operator, the