TypeScript Language Specification v1.5

In a contextually typed parenthesized expression, the contained expression is contextually typed
by the same type.
In a type assertion, the expression is contextually typed by the indicated type.
In a || operator expression, if the expression is contextually typed, the operands are contextually
typed by the same type. Otherwise, the right expression is contextually typed by the type of the
left expression.
In a contextually typed conditional operator expression, the operands are contextually typed by
the same type.
In an assignment expression, the right hand expression is contextually typed by the type of the
left hand expression.
In the following example
interface EventObject {
x: number;
y: number;
}
interface EventHandlers {
mousedown?: (event: EventObject) => void;
mouseup?: (event: EventObject) => void;
mousemove?: (event: EventObject) => void;
}
function setEventHandlers(handlers: EventHandlers) { ... }
setEventHandlers({
mousedown: e => { startTracking(e.x, e.y); },
mouseup: e => { endTracking(); }
});
the object literal passed to 'setEventHandlers' is contextually typed to the 'EventHandlers' type. This
causes the two property assignments to be contextually typed to the unnamed function type '(event:
EventObject) => void', which in turn causes the 'e' parameters in the arrow function expressions to
automatically be typed as 'EventObject'.
4.20 Type Guards
Type guards are particular expression patterns involving the 'typeof' and 'instanceof' operators that cause
the types of variables or parameters to be narrowed to more specific types. For example, in the code
below, knowledge of the static type of 'x' in combination with a 'typeof' check makes it safe to narrow the
type of 'x' to string in the first branch of the 'if' statement and number in the second branch of the 'if'
statement.
81