The Fortress Language Specification - CiteSeerX

Chapter 20
Type Inference
Type inference in Fortress is performed independently on each simple component (described in Chapter 22). For
separation of concerns, in this chapter, we describe the Fortress type inference as a procedure performed over a whole
Fortress program. We explain how this procedure can be adapted to perform type inference over a simple program
component in Section 22.5. Note that type inference cannot be performed on each functional (function or method)
declaration in isolation because it may be declared mutually recursively or may contain free variables.
20.1 What Is Inferred
Types of functional parameters, functional results, and variables may be elided in a program where they can be inferred
automatically. Similarly, instantiations of static parameters of generic functional invocations may be elided where they
can be inferred automatically. A Fortress compiler must allow types and static arguments inferable via the procedure
described in Section 20.2 to be elided, no more and no less. This strict requirement is made for the sake of source-code
portability; it is important that a program that compiles on one compiler will compile on all compilers. Of course,
there is nothing preventing a development environment from aiding programmers by performing more sophisticated
analyses and filling in additional information, but the text produced is not a valid Fortress program unless all elided
types and static arguments can be inferred via the described procedure.
20.2 Type Inference Procedure
To perform type inference, we first infer any elided parameter type in each functional declaration that can be inferred
from other declaration as follows:
1. If the declaration is a functional declaration and the type of the declared functional is declared via a separate
declaration, any elided parameter type is inferred to have the type provided by the separate declaration.
2. Otherwise, if the declaration is a method declaration that overloads a method declaration provided by a supertrait,
any elided parameter type is inferred to have the type provided (or inferred) by the overloaded method
declaration.
All remaining parameter types are inferred along with instantiations of static parameters.
In the following, we adopt the convention of writing “primed” static variables, T ′ 0, ..., T ′ m, U ′ 0, ..., to stand for fresh
static variables. Our procedure will introduce primed static variables as placeholders that are to be replaced with
153