Type Annotations

When declaring a constant or variable, an optional type annotation can be provided, to make it explicit what type the declaration has.

If no type annotation is provided, the type of the declaration is inferred from the initial value.

For function parameters a type annotation must be provided.

1
// Declare a variable named `boolVarWithAnnotation`, which has an explicit type annotation.
2
//
3
// `Bool` is the type of booleans.
4
//
5
var boolVarWithAnnotation: Bool = false
6
7
// Declare a constant named `integerWithoutAnnotation`, which has no type annotation
8
// and for which the type is inferred to be `Int`, the type of arbitrary-precision integers.
9
//
10
// This is based on the initial value which is an integer literal.
11
// Integer literals are always inferred to be of type `Int`.
12
//
13
let integerWithoutAnnotation = 1
14
15
// Declare a constant named `smallIntegerWithAnnotation`, which has an explicit type annotation.
16
// Because of the explicit type annotation, the type is not inferred.
17
// This declaration is valid because the integer literal `1` fits into the range of the type `Int8`,
18
// the type of 8-bit signed integers.
19
//
20
let smallIntegerWithAnnotation: Int8 = 1

If a type annotation is provided, the initial value must be of this type. All new values assigned to variables must match its type. This type safety is explained in more detail in a separate section.

1
// Invalid: declare a variable with an explicit type `Bool`,
2
// but the initial value has type `Int`.
3
//
4
let booleanConstant: Bool = 1
5
6
// Declare a variable that has the inferred type `Bool`.
7
//
8
var booleanVariable = false
9
10
// Invalid: assign a value with type `Int` to a variable which has the inferred type `Bool`.
11
//
12
booleanVariable = 1