docs: def compare(times_list=None,
              name=None,
              include_list=True,
              include_stats=True,
              delim_mode=False,
              format_options=None):
      """
      Produce a formatted comparison of timing datas.
  
      Notes:
          If no times_list is provided, produces comparison reports on all parallel
          subdivisions present at the root level of the current timer.  To compare
          parallel subdivisions at a lower level, get the times data, navigate
          within it to the parallel list of interest, and provide that as input
          here.  As with report(), any further parallel subdivisions encountered
          have only their member with the greatest total time reported on (no
          branching).
  
      Args:
          times_list (Times, optional): list or tuple of Times objects.  If not
              provided, uses current root timer.
          name (any, optional): Identifier, passed through str().
          include_list (bool, optional): Display stamps hierarchy.
          include_stats (bool, optional): Display stamp comparison statistics.
          delim_mode (bool, optional): If True, format for spreadsheet.
          format_options (None, optional): Formatting options, see below.
  
      Formatting Keywords & Defaults:
          Human-readable Mode
              - 'stamp_name_width': 18
              - 'list_column_width': 12
              - 'list_tab_width': 2
              - 'stat_column_width': 8
              - 'stat_tab_width': 2
              - 'indent_symbol: ' ' (one space)
          Delimited Mode
              - 'delimiter': '\t' (tab)
              - 'ident_symbol': '+'
  
      Returns:
          str: Times data comparison as formatted string.
  
      Raises:
          TypeError: If any element of provided collection is not a Times object.
      """
      if times_list is None:
          rep = ''
          for par_dict in itervalues(f.root.times.par_subdvsn):
              for par_name, par_list in iteritems(par_dict):
                  rep += report_loc.compare(par_list,
                                            par_name,
                                            include_list,
                                            include_stats,
                                            delim_mode,
                                            format_options)
      else:
          if not isinstance(times_list, (list, tuple)):
              raise TypeError("Expected a list/tuple of times instances for param 'times_list'.")
          if not all([isinstance(times, Times) for times in times_list]):
              raise TypeError("At least one member of param 'times_list' is not a Times object.")
          rep = report_loc.compare(times_list,
                                   name,
                                   include_list,
                                   include_stats,
                                   delim_mode,
                                   format_options)
      return rep