@@ -457,6 +457,44 @@ or properties, and generic classes can also have ABCs as base
 classes without a metaclass conflict.
 
 
+Type variables with an upper bound
+----------------------------------
+
+A type variable may specify an upper bound using ``bound=<type>``.
+This means that an actual type substituted (explicitly or implictly)
+for the type variable must be a subclass of the boundary type.  A
+common example is the definition of a Comparable type that works well
+enough to catch the most common errors::
+
+  class Comparable(metaclass=ABCMeta):
+      @abstractmethod
+      def __lt__(self, other: Any) -> bool: ...
+      ... # __gt__ etc. as well
+
+  CT = TypeVar('CT', bound=Comparable)
+
+  def min(x: CT, y: CT) -> CT:
+      if x < y:
+          return x
+      else:
+          return y
+
+  min(1, 2) # ok, return type int
+  min('x', 'y') # ok, return type str
+
+(Note that this is not ideal -- for example ``min('x', 1)`` is invalid
+at runtime but a type checker would simply infer the return type
+``Comparable``.  Unfortunately, addressing this would require
+introducing a much more powerful and also much more complicated
+concept, F-bounded polymorphism.  We may revisit this in the future.)
+
+An upper bound cannot be combined with type constraints (as in used
+``AnyStr``, see the example earlier); type constraints cause the
+inferred type to be _exactly_ one of the constraint types, while an
+upper bound just requires that the actual type is a subclass of the
+boundary type.
+
+
 The numeric tower
 -----------------
 
 
@@ -147,6 +147,10 @@ def test_basic_constrained(self):
         # A is a subclass of itself.
         assert issubclass(A, A)
 
+    def test_constrained_error(self):
+        with self.assertRaises(TypeError):
+            X = TypeVar('X', int)
+
     def test_union_unique(self):
         X = TypeVar('X')
         Y = TypeVar('Y')
@@ -181,7 +185,8 @@ def test_subclass_as_unions(self):
         # None of these are true -- each type var is its own world.
         self.assertFalse(issubclass(TypeVar('T', int, str),
                                     TypeVar('T', int, str)))
-        self.assertFalse(issubclass(TypeVar('T', int), TypeVar('T', int, str)))
+        self.assertFalse(issubclass(TypeVar('T', int, float),
+                                    TypeVar('T', int, float, str)))
         self.assertFalse(issubclass(TypeVar('T', int, str),
                                     TypeVar('T', str, int)))
         A = TypeVar('A', int, str)
@@ -203,6 +208,18 @@ def test_cannot_instantiate_vars(self):
         with self.assertRaises(TypeError):
             TypeVar('A')()
 
+    def test_bound(self):
+        X = TypeVar('X', bound=Employee)
+        assert issubclass(Employee, X)
+        assert issubclass(Manager, X)
+        assert not issubclass(int, X)
+
+    def test_bound_errors(self):
+        with self.assertRaises(TypeError):
+            TypeVar('X', bound=42)
+        with self.assertRaises(TypeError):
+            TypeVar('X', str, float, bound=Employee)
+
 
 class UnionTests(TestCase):
 
@@ -345,7 +362,7 @@ def test_var_union_subclass(self):
         self.assertTrue(issubclass(KT, Union[KT, VT]))
 
     def test_var_union(self):
-        TU = TypeVar('TU', Union[int, float])
+        TU = TypeVar('TU', Union[int, float], None)
         assert issubclass(int, TU)
         assert issubclass(float, TU)
         with self.assertRaises(TypeError):
 
@@ -374,14 +374,23 @@ def longest(x: A, y: A) -> A:
       A.__constraints__ == (str, bytes)
     """
 
-    def __new__(cls, name, *constraints, covariant=False, contravariant=False):
+    def __new__(cls, name, *constraints, bound=None,
+                covariant=False, contravariant=False):
         self = super().__new__(cls, name, (Final,), {}, _root=True)
         if covariant and contravariant:
-            raise ValueError("bivariant type variables are not supported")
-        msg = "TypeVar(name, constraint, ...): constraints must be types."
+            raise ValueError("Bivariant type variables are not supported.")
         self.__covariant__ = bool(covariant)
         self.__contravariant__ = bool(contravariant)
+        if constraints and bound is not None:
+            raise TypeError("Constraints cannot be combined with bound=<type>.")
+        if constraints and len(constraints) == 1:
+            raise TypeError("A single constraint is not allowed")
+        msg = "TypeVar(name, constraint, ...): constraints must be types."
         self.__constraints__ = tuple(_type_check(t, msg) for t in constraints)
+        if bound:
+            self.__bound__ = _type_check(bound, "Bound must be a type.")
+        else:
+            self.__bound__ = None
         return self
 
     def _has_type_var(self):
@@ -401,13 +410,15 @@ def __instancecheck__(self, instance):
 
     def __subclasscheck__(self, cls):
         # TODO: Make this raise TypeError too?
-        if not self.__constraints__:
-            return True
         if cls is self:
             return True
         if cls is Any:
             return True
-        return any(issubclass(cls, c) for c in self.__constraints__)
+        if self.__bound__ is not None:
+            return issubclass(cls, self.__bound__)
+        if self.__constraints__:
+            return any(issubclass(cls, c) for c in self.__constraints__)
+        return True
 
 
 # Some unconstrained type variables.  These are used by the container types.