docs: def recursedir(self, pattern=None, top_down=True, follow_links=False,
                     handle_errors=None):
          """Recursively lists all files under this directory.
  
          :param pattern: An extended patterns, where:
  
              * a slash '/' always represents the path separator
              * a backslash '\' escapes other special characters
              * an initial slash '/' anchors the match at the beginning of the
                (relative) path
              * a trailing '/' suffix is removed
              * an asterisk '*'  matches a sequence of any length (including 0)
                of any characters (except the path separator)
              * a '?' matches exactly one character (except the path separator)
              * '[abc]' matches characters 'a', 'b' or 'c'
              * two asterisks '**' matches one or more path components (might
                match '/' characters)
          :type pattern: NoneType | Callable | Pattern | unicode | bytes
  
          :param follow_links: If False, symbolic links will not be followed (the
              default). Else, they will be followed, but directories reached
              through different names will *not* be listed multiple times.
  
          :param handle_errors: Can be set to a callback that will be called when
              an error is encountered while accessing the filesystem (such as a
              permission issue). If set to None (the default), exceptions will be
              propagated.
          """
          if not self.is_dir():
              raise ValueError("recursedir() called on non-directory %s" % self)
  
          start = ''
          int_pattern = None
          if pattern is None:
              pattern = lambda p: True
          elif callable(pattern):
              pass
          else:
              if isinstance(pattern, backend_types):
                  if isinstance(pattern, bytes):
                      pattern = pattern.decode(self._encoding, 'replace')
                  start, full_re, int_re = pattern2re(pattern)
              elif isinstance(pattern, Pattern):
                  start, full_re, int_re = \
                      pattern.start_dir, pattern.full_regex, pattern.int_regex
              else:
                  raise TypeError("recursedir() expects pattern to be a "
                                  "callable, a regular expression or a string "
                                  "pattern, got %r" % type(pattern))
              if self._lib.sep != '/':
                  pattern = lambda p: full_re.search(
                      unicode(p).replace(self._lib.sep, '/'))
                  if int_re is not None:
                      int_pattern = lambda p: int_re.search(
                          unicode(p).replace(self._lib.sep, '/'))
              else:
                  pattern = lambda p: full_re.search(unicode(p))
                  if int_re is not None:
                      int_pattern = lambda p: int_re.search(unicode(p))
          if not start:
              path = self
          else:
              path = self / start
              if not path.exists():
                  return []
              elif not path.is_dir():
                  return [path]
          return path._recursedir(pattern=pattern, int_pattern=int_pattern,
                                  top_down=top_down, seen=set(),
                                  path=self.__class__(start),
                                  follow_links=follow_links,
                                  handle_errors=handle_errors)