A type system is, roughly, a mechanism for classifying the expressions of a language. Type systems for programming languages, sequential and concurrent, are useful for several reasons, most notably:

• (1) to detect programming errors statically

• (2) to extract information that is useful for reasoning about the behaviour of programs

• (3) to improve the efficiency of code generated by a compiler

• (4) to make programs easier to understand.

Types are an important part of the theory and of the pragmatics of the π-calculus, and they are one of the most important differences between π-calculus and CCS-like languages. Many of the type systems that have been studied for the π-calculus were suggested by well-known type systems for sequential languages, especially λ-calculi. In addition, however, type systems specific to processes have been proposed, for instance for preventing certain forms of interference among processes or certain forms of deadlock.

In the book we will be mainly interested in the purposes (1) and (2) of types; purposes (3) and (4) are more specific to programming languages (as opposed to calculi). In this Part of the book we introduce several important type systems and present their basic properties. In the next Part we study the effect of types on process behaviour and reasoning.

We formalize type systems by means of typing rules. The terms that can be typed using these rules are the well-typed terms. The most fundamental property of a type system is its agreement with the reduction relation of the calculus, the subject reduction property. A consequence of this property is type soundness, asserting that well-typed processes do not give rise to run-time errors under reduction. We use a special term wrong to represent a process inside which such an error has occurred. Therefore, type soundness will mean that a well-typed process cannot reduce to a process containing wrong.

We discussed run-time errors informally in Section 3.1, when we introduced the polvadic π-calculus. There, we used sorting as a mechanism for avoiding errors. Sorting is an example of a type system where equality between types is by name, as opposed to by structure. In the by-name approach, each type has a name (a sort, in the case of a sorting), and two types are equal if they have the same name. In the by-structure approach, two types are equal if they have the same structure.