docs: def broadcast(*args, **kwargs):
      """Explicitly broadcast any number of DataArray or Dataset objects against
      one another.
  
      xarray objects automatically broadcast against each other in arithmetic
      operations, so this function should not be necessary for normal use.
  
      If no change is needed, the input data is returned to the output without
      being copied.
  
      Parameters
      ----------
      *args : DataArray or Dataset objects
          Arrays to broadcast against each other.
      exclude : sequence of str, optional
          Dimensions that must not be broadcasted
  
      Returns
      -------
      broadcast : tuple of xarray objects
          The same data as the input arrays, but with additional dimensions
          inserted so that all data arrays have the same dimensions and shape.
  
      Examples
      --------
  
      Broadcast two data arrays against one another to fill out their dimensions:
  
      >>> a = xr.DataArray([1, 2, 3], dims='x')
      >>> b = xr.DataArray([5, 6], dims='y')
      >>> a
      <xarray.DataArray (x: 3)>
      array([1, 2, 3])
      Coordinates:
        * x        (x) int64 0 1 2
      >>> b
      <xarray.DataArray (y: 2)>
      array([5, 6])
      Coordinates:
        * y        (y) int64 0 1
      >>> a2, b2 = xr.broadcast(a, b)
      >>> a2
      <xarray.DataArray (x: 3, y: 2)>
      array([[1, 1],
             [2, 2],
             [3, 3]])
      Coordinates:
        * x        (x) int64 0 1 2
        * y        (y) int64 0 1
      >>> b2
      <xarray.DataArray (x: 3, y: 2)>
      array([[5, 6],
             [5, 6],
             [5, 6]])
      Coordinates:
        * y        (y) int64 0 1
        * x        (x) int64 0 1 2
  
      Fill out the dimensions of all data variables in a dataset:
  
      >>> ds = xr.Dataset({'a': a, 'b': b})
      >>> ds2, = xr.broadcast(ds)  # use tuple unpacking to extract one dataset
      >>> ds2
      <xarray.Dataset>
      Dimensions:  (x: 3, y: 2)
      Coordinates:
        * x        (x) int64 0 1 2
        * y        (y) int64 0 1
      Data variables:
          a        (x, y) int64 1 1 2 2 3 3
          b        (x, y) int64 5 6 5 6 5 6
      """
      from .dataarray import DataArray
      from .dataset import Dataset
  
      exclude = kwargs.pop('exclude', None)
      if exclude is None:
          exclude = set()
      if kwargs:
          raise TypeError('broadcast() got unexpected keyword arguments: %s'
                          % list(kwargs))
  
      args = align(*args, join='outer', copy=False, exclude=exclude)
  
      common_coords = OrderedDict()
      dims_map = OrderedDict()
      for arg in args:
          for dim in arg.dims:
              if dim not in common_coords and dim not in exclude:
                  dims_map[dim] = arg.sizes[dim]
                  if dim in arg.coords:
                      common_coords[dim] = arg.coords[dim].variable
  
      def _set_dims(var):
          # Add excluded dims to a copy of dims_map
          var_dims_map = dims_map.copy()
          for dim in exclude:
              with suppress(ValueError):
                  # ignore dim not in var.dims
                  var_dims_map[dim] = var.shape[var.dims.index(dim)]
  
          return var.set_dims(var_dims_map)
  
      def _broadcast_array(array):
          data = _set_dims(array.variable)
          coords = OrderedDict(array.coords)
          coords.update(common_coords)
          return DataArray(data, coords, data.dims, name=array.name,
                           attrs=array.attrs)
  
      def _broadcast_dataset(ds):
          data_vars = OrderedDict(
              (k, _set_dims(ds.variables[k]))
              for k in ds.data_vars)
          coords = OrderedDict(ds.coords)
          coords.update(common_coords)
          return Dataset(data_vars, coords, ds.attrs)
  
      result = []
      for arg in args:
          if isinstance(arg, DataArray):
              result.append(_broadcast_array(arg))
          elif isinstance(arg, Dataset):
              result.append(_broadcast_dataset(arg))
          else:
              raise ValueError('all input must be Dataset or DataArray objects')
  
      return tuple(result)