docs: def add(self, handler, name=None, exception_handlers=()):
          """Add a handler to the route.
  
          :param handler: The "handler" callable to add.
          :param name: Optional. When specified, the return value of this
              handler will be added to the context under ``name``.
          :param exception_handlers: Optional. A list of ``(types, handler)``
              tuples, where ``types`` is an exception type (or tuple of types)
              to handle, and ``handler`` is a callable. See below for example.
  
          **Exception Handlers**
  
          When an exception occurs in a handler, ``exc_info`` will be
          temporarily added to the context and the list of exception handlers
          will be checked for an appropriate handler. If no handler can be
          found, the exception will be re-raised to the caller of the route.
  
          If an appropriate exception handler is found, it will be called (the
          context will be injected, so handlers may take an ``exc_info``
          argument), and its return value will be used in place of the original
          handler's return value.
  
          Examples:
  
              >>> from potpy.context import Context
  
              >>> route = Route()
              >>> route.add(lambda: {}['foo'], exception_handlers=[
              ...     (KeyError, lambda: 'bar')
              ... ])
              >>> route(Context())
              'bar'
  
              >>> def read_line_from_file():
              ...     raise IOError()     # simulate a failed read
              ...
              >>> def retry_read():
              ...     return 'success!'   # simulate retrying the read
              ...
              >>> def process_line(line):
              ...     return line.upper()
              ...
              >>> route = Route()
              >>> route.add(read_line_from_file, 'line', [
              ...     # return value will be added to context as 'line'
              ...     ((OSError, IOError), retry_read)
              ... ])
              >>> route.add(process_line)
              >>> route(Context())
              'SUCCESS!'
  
              >>> route = Route()
              >>> route.add(lambda: {}['foo'], exception_handlers=[
              ...     (IndexError, lambda: 'bar') # does not handle KeyError
              ... ])
              >>> route(Context())    # so exception will be re-raised here
              Traceback (most recent call last):
                  ...
              KeyError: 'foo'
          """
          self.route.append((name, handler, exception_handlers))