TypeScript Language Specification

eference (section 4.1) and the type of the non-compound operation to be assignable to the type of
VarExpr.
4.18 Contextually Typed Expressions
In certain situations, parameter and return types of function expressions are automatically inferred from
the contexts in which the function expressions occur. For example, given the declaration
the assignment
var f: (s: string) => string;
f = function(s) { return s.toLowerCase(); }
infers the type of the ‘s’ parameter to be the String primitive type even though there is no type annotation
to that effect. The function expression is said to be contextually typed by the variable to which it is being
assigned. Contextual typing occurs in the following situations:
� In variable and member declarations with a type annotation and an initializer, the initializer
expression is contextually typed by the type of the variable or property.
� In assignment expressions, the right hand expression is contextually typed by the type of the left
hand expression.
� In typed function calls, argument expressions are contextually typed by their parameter types.
� In return statements, if the containing function has a known return type, the expression is
contextually typed by that return type. A function’s return type is known if the function includes a
return type annotation or is itself contextually typed.
� In contextually typed object literals, property assignments are contextually typed by their property
types.
� In contextually typed array literals, element expressions are contextually typed by the array
element type.
Contextual typing of an expression e by a type T proceeds as follows:
� If e is an ObjectLiteral and T is an object type, e is processed with the contextual type T, as
described in section 4.5.
� If e is an ArrayLiteral and T is an array type, e is processed with the contextual type T, as described
in section 4.6.
� If e is a FunctionExpression or ArrowFunctionExpression with no parameter or return type
annotations and T is an object type with exactly one call signature, e is processed with the
contextual type T, as described in section 4.9.
� Otherwise, e is processed without a contextual type.
The rules above require expressions be of the exact syntactic forms specified in order to be processed as
contextually typed constructs. For example, given the declaration of the variable ‘f’ above, the assignment
f = s => s.toLowerCase();
44