How does a compiler infer a value's type?

var myVariable = 42
myVariable = 50
let myConstant = 42


A constant or variable must have the same type as the value you want to assign to it. However, you don’t always have to write the type explicitly. Providing a value when you create a constant or variable lets the compiler infer its type. In the example above, the compiler infers that myVariable is an integer because its initial value is an integer.

How does this work?

• Roughly: the compiler looks carefully at the program. For example in the program M+N the very presence of + forces both M and N to be of type Integer. Now apply this recursively to the whole program. Details are much more complicated, and explained in great detail in the wonderful textbook Types and Programming Languages, one of the best textbooks in all of computer science. (This is probably not the answer you want.) – Martin Berger May 24 at 10:10
• I don't think Swift actually does full type inference/type reconstruction (Algorithm W), rather it does bidirectional type checking. There are some subtle differences between them. – xuq01 May 24 at 21:48

2 Answers

You did not provide an explicit type identifier in the left part of the variable declaration & initialization statement. However, by implicitly specifying an initialization value in the right part to have type int, which the compiler can infer from values of 42/50, these statements triggered the procedure of the compiler to handle S-Attributed Grammar.

• Just to add to the Answer from Zeyi: The compiler does type inference to assign a type to the variable. This is done to do static type checking. Here would be a link to Type inference: en.wikipedia.org/wiki/Type_inference – ErebosM May 24 at 5:06

When the compiler sees the var <identifier> = <expression>; construct it can parse the <expression> out of which a type will emerge.

That type is then used as the declared variable's type.

It is the same logic for type checking when you do declare the type explicitly or assign to a variable, only with the difference that when the type is already fixed and it doesn't match it emits an compiler error.