code: def map(process, paths, threads=None):
      
      paths = [mwtypes.files.normalize_path(path) for path in paths]
  
      def process_path(path):
          dump = Dump.from_file(mwtypes.files.reader(path))
          yield from process(dump, path)
  
      yield from para.map(process_path, paths, mappers=threads)
docs: Implements a distributed stategy for processing XML files.  This
      function constructs a set of py:mod:`multiprocessing` threads (spread over
      multiple cores) and uses an internal queue to aggregate outputs.  To use
      this function, implement a `process()` function that takes two arguments
      -- a :class:`mwxml.Dump` and the path the dump was loaded
      from. Anything that this function ``yield``s will be `yielded` in turn
      from the :func:`mwxml.map` function.
  
      :Parameters:
          paths : `iterable` ( `str` | `file` )
              a list of paths to dump files to process
          process : `func`
              A function that takes a :class:`~mwxml.iteration.dump.Dump` and the
              path the dump was loaded from and yields
          threads : int
              the number of individual processing threads to spool up
  
      :Example:
  
          >>> import mwxml
          >>> files = ["examples/dump.xml", "examples/dump2.xml"]
          >>>
          >>> def page_info(dump, path):
          ...     for page in dump:
          ...         yield page.id, page.namespace, page.title
          ...
          >>> for id, namespace, title in mwxml.map(page_info, files):
          ...     print(id, namespace, title)
          ...