Address CR

Author: pkch

pep-0484.txt

@@ -288,7 +288,7 @@ elements.  Example::
 
   def notify_by_email(employees: Set[Employee], overrides: Mapping[str, str]) -> None: ...
 
-Generics can be parametrized by using a new factory available in
+Generics can be parameterized by using a new factory available in
 ``typing`` called ``TypeVar``.  Example::
 
   from typing import Sequence, TypeVar
@@ -583,7 +583,7 @@ argument(s) is substituted.  Otherwise, ``Any`` is assumed.  Example::
   class Node(Generic[T]):
       def __init__(self, label: T = None) -> None:
           ...
-      x: None  # Type: T
+      x = None  # Type: T
 
   x = Node('')  # Inferred type is Node[str]
   y = Node(0)   # Inferred type is Node[int]
@@ -611,20 +611,23 @@ the runtime class of the objects created by instantiating them doesn't
 record the distinction. This behavior is called "type erasure"; it is
 common practice in languages with generics (e.g. Java, TypeScript).
 
-Class attribute of a generic class can be looked up only through the instance
-of the class; any attempt to use generic classes (parametrized or not) to
-access attributes will result in both type check failure and runtime error::
+Using generic classes (parameterized or not) to access attributes will result
+in both type check failure and runtime error. Outside the class definition
+body, a class attribute cannot be assigned, and can only be looked up by
+accessing it through the class instance that does not have same-named
+instance attribute::
 
   # (continued from previous example)
   Node[int].x = 1  # Error
   Node[int].x      # Error
   Node.x = 1       # Error
   Node.x           # Error
   type(p).x        # Error
-  p.x              # Ok
-  Node[int]().x    # Ok
+  p.x              # Ok (evaluates to None)
+  Node[int]().x    # Ok (evaluates to None)
+  p.x = 1          # Will assign to instance attribute
 
-In addition, ``ClassVar`` cannot be parametrized.
+In addition, ``ClassVar`` cannot be parameterized.
 
 Generic versions of abstract collections like ``Mapping`` or ``Sequence``
 and generic versions of built-in classes -- ``List``, ``Dict``, ``Set``,