docs: def distance_function_match(l1, l2, thresh, dist_fn, norm_funcs=[]):
      """Returns pairs of matching indices from l1 and l2."""
      common = []
      # We will keep track of the global index in the source list as we
      # will successively reduce their sizes.
      l1 = list(enumerate(l1))
      l2 = list(enumerate(l2))
  
      # Use the distance function and threshold on hints given by normalization.
      # See _match_by_norm_func for implementation details.
      # Also wrap the list element function function to ignore the global list
      # index computed above.
      for norm_fn in norm_funcs:
          new_common, l1, l2 = _match_by_norm_func(
                  l1, l2,
                  lambda a: norm_fn(a[1]),
                  lambda a1, a2: dist_fn(a1[1], a2[1]),
                  thresh)
          # Keep only the global list index in the end result.
          common.extend((c1[0], c2[0]) for c1, c2 in new_common)
  
      # Take any remaining umatched entries and try to match them using the
      # Munkres algorithm.
      dist_matrix = [[dist_fn(e1, e2) for i2, e2 in l2] for i1, e1 in l1]
  
      # Call Munkres on connected components on the remaining bipartite graph.
      # An edge links an element from l1 with an element from l2 only if
      # the distance between the elements is less (or equal) than the theshold.
      components = BipartiteConnectedComponents()
      for l1_i in range(len(l1)):
          for l2_i in range(len(l2)):
              if dist_matrix[l1_i][l2_i] > thresh:
                  continue
              components.add_edge(l1_i, l2_i)
  
      for l1_indices, l2_indices in components.get_connected_components():
          # Build a partial distance matrix for each connected component.
          part_l1 = [l1[i] for i in l1_indices]
          part_l2 = [l2[i] for i in l2_indices]
  
          part_dist_matrix = [[dist_matrix[l1_i][l2_i] for l2_i in l2_indices]
                              for l1_i in l1_indices]
          part_cmn = _match_munkres(part_l1, part_l2, part_dist_matrix, thresh)
  
          common.extend((c1[0], c2[0]) for c1, c2 in part_cmn)
  
      return common