docstr: ivy.Container instance method variant of ivy.stack. This method
  simply wraps the function, and so the docstring for ivy.stack also
  applies to this method with minimal changes.
  
  Parameters
  ----------
  self
      Container with leaves to join with leaves of other arrays/containers.
       Each array leave must have the same shape.
  xs
      Container with other leaves to join.
      Each array leave must have the same shape.
  axis
      axis along which the array leaves will be joined. More details can be found
      in the docstring for ivy.stack.
  key_chains
      The key-chains to apply or not apply the method to. Default is ``None``.
  to_apply
      If True, the method will be applied to key_chains, otherwise key_chains
      will be skipped. Default is ``True``.
  prune_unapplied
      Whether to prune key_chains for which the function was not applied.
      Default is ``False``.
  map_sequences
      Whether to also map method to sequences (lists, tuples).
      Default is ``False``.
  out
      optional output array, for writing the result to. It must have a shape
      that the inputs broadcast to.
  
  Returns
  -------
  ret
      an output container with the results.
  
  Examples
  --------
  >>> x = ivy.Container(a=ivy.array([[0, 1], [2,3]]), b=ivy.array([[4, 5]]))
  >>> y = ivy.Container(a=ivy.array([[3, 2], [1,0]]), b=ivy.array([[1, 0]]))
  >>> x.stack([y])
  {
      a: ivy.array([[[0, 1],
                  [2, 3]],
                  [[3, 2],
                  [1, 0]]]),
      b: ivy.array([[[4, 5]],
                  [[1, 0]]])
  }
code: def stack(
      self: ivy.Container,
      /,
      xs: Union[
          Tuple[Union[ivy.Array, ivy.NativeArray, ivy.Container]],
          List[Union[ivy.Array, ivy.NativeArray, ivy.Container]],
      ],
      *,
      axis: Union[int, ivy.Container] = 0,
      key_chains: Optional[
          Union[List[str], Dict[str, str], ivy.Container]
      ] = None,
      to_apply: Union[bool, ivy.Container] = True,
      prune_unapplied: Union[bool, ivy.Container] = False,
      map_sequences: Union[bool, ivy.Container] = False,
      out: Optional[ivy.Container] = None,
  ) -> ivy.Container:
      """ivy.Container instance method variant of ivy.stack. This method
      simply wraps the function, and so the docstring for ivy.stack also
      applies to this method with minimal changes.
  
      Parameters
      ----------
      self
          Container with leaves to join with leaves of other arrays/containers.
           Each array leave must have the same shape.
      xs
          Container with other leaves to join.
          Each array leave must have the same shape.
      axis
          axis along which the array leaves will be joined. More details can be found
          in the docstring for ivy.stack.
      key_chains
          The key-chains to apply or not apply the method to. Default is ``None``.
      to_apply
          If True, the method will be applied to key_chains, otherwise key_chains
          will be skipped. Default is ``True``.
      prune_unapplied
          Whether to prune key_chains for which the function was not applied.
          Default is ``False``.
      map_sequences
          Whether to also map method to sequences (lists, tuples).
          Default is ``False``.
      out
          optional output array, for writing the result to. It must have a shape
          that the inputs broadcast to.
  
      Returns
      -------
      ret
          an output container with the results.
  
      Examples
      --------
      >>> x = ivy.Container(a=ivy.array([[0, 1], [2,3]]), b=ivy.array([[4, 5]]))
      >>> y = ivy.Container(a=ivy.array([[3, 2], [1,0]]), b=ivy.array([[1, 0]]))
      >>> x.stack([y])
      {
          a: ivy.array([[[0, 1],
                      [2, 3]],
                      [[3, 2],
                      [1, 0]]]),
          b: ivy.array([[[4, 5]],
                      [[1, 0]]])
      }
      """
      new_xs = xs.cont_copy() if ivy.is_ivy_container(xs) else xs.copy()
      new_xs.insert(0, self.cont_copy())
      return self._static_stack(
          new_xs,
          axis=axis,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
          out=out,
      )
  
imports: from typing import Optional, Union, List, Tuple, Dict, Iterable, Sequence
  from numbers import Number
  import ivy
  from ivy.data_classes.container.base import ContainerBase
label_desc: Use image node_id 18 for calling the _ContainerWithManipulation obj's underlying member method code with example usage: obj.stack(xs) and returns: self