A long while back I posted a recipe for using annotations for type checking. I'm certainly not the first person to do this, and what I did was deliberately simple:
The approach I used was to use per-function decorators to say that a given function should be type checked. The type system I enforce in that recipe is much less than what mypy allows, but I can't see a real reason that it couldn't be extended to cover exactly the same range of type specifiers.
The advantage I perceive in this approach is that it is purely optional, per module and per function. As well, it doesn't actually require making ANY change to Python 3.5 to implement it. Or as a minimal change, an extra decorator could simply be available in functools or elsewhere in the standard library, which implemented the full semantics of mypy.
Now admittedly, this would be type checking, but not *static* type checking. There may not be an easy way to make a pre-runtime "lint" tool do the checking there. On the other hand, as a number of posters have noted, there's also no way to enforce, e.g. 'Iterable[String]' either statically.
I'm not the BDFL of course, but I do not really get what advantage there is to the pre-runtime check that can catch a fairly small subset of type constraints rather than check at runtime everything that is available then (as the decorator approach could get you).