docs: def _dataset_concat(datasets, dim, data_vars, coords, compat, positions):
      """
      Concatenate a sequence of datasets along a new or existing dimension
      """
      from .dataset import Dataset
  
      if compat not in ['equals', 'identical']:
          raise ValueError("compat=%r invalid: must be 'equals' "
                           "or 'identical'" % compat)
  
      dim, coord = _calc_concat_dim_coord(dim)
      # Make sure we're working on a copy (we'll be loading variables)
      datasets = [ds.copy() for ds in datasets]
      datasets = align(*datasets, join='outer', copy=False, exclude=[dim])
  
      concat_over, equals = _calc_concat_over(datasets, dim, data_vars, coords)
  
      def insert_result_variable(k, v):
          assert isinstance(v, Variable)
          if k in datasets[0].coords:
              result_coord_names.add(k)
          result_vars[k] = v
  
      # create the new dataset and add constant variables
      result_vars = OrderedDict()
      result_coord_names = set(datasets[0].coords)
      result_attrs = datasets[0].attrs
      result_encoding = datasets[0].encoding
  
      for k, v in datasets[0].variables.items():
          if k not in concat_over:
              insert_result_variable(k, v)
  
      # check that global attributes and non-concatenated variables are fixed
      # across all datasets
      for ds in datasets[1:]:
          if (compat == 'identical' and
                  not utils.dict_equiv(ds.attrs, result_attrs)):
              raise ValueError('dataset global attributes not equal')
          for k, v in ds.variables.items():
              if k not in result_vars and k not in concat_over:
                  raise ValueError('encountered unexpected variable %r' % k)
              elif (k in result_coord_names) != (k in ds.coords):
                  raise ValueError('%r is a coordinate in some datasets but not '
                                   'others' % k)
              elif k in result_vars and k != dim:
                  # Don't use Variable.identical as it internally invokes
                  # Variable.equals, and we may already know the answer
                  if compat == 'identical' and not utils.dict_equiv(
                          v.attrs, result_vars[k].attrs):
                      raise ValueError(
                          'variable %s not identical across datasets' % k)
  
                  # Proceed with equals()
                  try:
                      # May be populated when using the "different" method
                      is_equal = equals[k]
                  except KeyError:
                      result_vars[k].load()
                      is_equal = v.equals(result_vars[k])
                  if not is_equal:
                      raise ValueError(
                          'variable %s not equal across datasets' % k)
  
      # we've already verified everything is consistent; now, calculate
      # shared dimension sizes so we can expand the necessary variables
      dim_lengths = [ds.dims.get(dim, 1) for ds in datasets]
      non_concat_dims = {}
      for ds in datasets:
          non_concat_dims.update(ds.dims)
      non_concat_dims.pop(dim, None)
  
      def ensure_common_dims(vars):
          # ensure each variable with the given name shares the same
          # dimensions and the same shape for all of them except along the
          # concat dimension
          common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))
          if dim not in common_dims:
              common_dims = (dim,) + common_dims
          for var, dim_len in zip(vars, dim_lengths):
              if var.dims != common_dims:
                  common_shape = tuple(non_concat_dims.get(d, dim_len)
                                       for d in common_dims)
                  var = var.set_dims(common_dims, common_shape)
              yield var
  
      # stack up each variable to fill-out the dataset (in order)
      for k in datasets[0].variables:
          if k in concat_over:
              vars = ensure_common_dims([ds.variables[k] for ds in datasets])
              combined = concat_vars(vars, dim, positions)
              insert_result_variable(k, combined)
  
      result = Dataset(result_vars, attrs=result_attrs)
      result = result.set_coords(result_coord_names)
      result.encoding = result_encoding
  
      if coord is not None:
          # add concat dimension last to ensure that its in the final Dataset
          result[coord.name] = coord
  
      return result