docs: def dispatch(
          self, view_func, path_info=None, method=None, catch_http_exceptions=False
      ):
          """Does the complete dispatching process.  `view_func` is called with
          the endpoint and a dict with the values for the view.  It should
          look up the view function, call it, and return a response object
          or WSGI application.  http exceptions are not caught by default
          so that applications can display nicer error messages by just
          catching them by hand.  If you want to stick with the default
          error messages you can pass it ``catch_http_exceptions=True`` and
          it will catch the http exceptions.
  
          Here a small example for the dispatch usage::
  
              from werkzeug.wrappers import Request, Response
              from werkzeug.wsgi import responder
              from werkzeug.routing import Map, Rule
  
              def on_index(request):
                  return Response('Hello from the index')
  
              url_map = Map([Rule('/', endpoint='index')])
              views = {'index': on_index}
  
              @responder
              def application(environ, start_response):
                  request = Request(environ)
                  urls = url_map.bind_to_environ(environ)
                  return urls.dispatch(lambda e, v: views[e](request, **v),
                                       catch_http_exceptions=True)
  
          Keep in mind that this method might return exception objects, too, so
          use :class:`Response.force_type` to get a response object.
  
          :param view_func: a function that is called with the endpoint as
                            first argument and the value dict as second.  Has
                            to dispatch to the actual view function with this
                            information.  (see above)
          :param path_info: the path info to use for matching.  Overrides the
                            path info specified on binding.
          :param method: the HTTP method used for matching.  Overrides the
                         method specified on binding.
          :param catch_http_exceptions: set to `True` to catch any of the
                                        werkzeug :class:`HTTPException`\\s.
          """
          try:
              try:
                  endpoint, args = self.match(path_info, method)
              except RequestRedirect as e:
                  return e
              return view_func(endpoint, args)
          except HTTPException as e:
              if catch_http_exceptions:
                  return e
              raise