code: def constant_pad(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      pad_width: Iterable[Tuple[int]],
      *,
      value: Number = 0,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Pad an array with a constant value.
  
      Parameters
      ----------
      x
          Input array to pad.
      pad_width
          Number of values padded to the edges of each axis.
          Specified as ((before_1, after_1), … (before_N, after_N)), where N is number of
          axes of x.
      value
          The constant value to pad the array with.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          Padded array of rank equal to x with shape increased according to pad_width.
  
  
      Both the description and the type hints above assumes an array input for simplicity,
      but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x = ivy.array([1, 2, 3, 4, 5])
      >>> y = ivy.constant_pad(x, pad_width = [[2, 3]])
      >>> print(y)
      ivy.array([0, 0, 1, 2, 3, 4, 5, 0, 0, 0])
  
      >>> x = ivy.array([[1, 2], [3, 4]])
      >>> y = ivy.constant_pad(x, pad_width=[(2, 3), (2, 3)])
      >>> print(y)
      ivy.array([[0, 0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 2, 0, 0, 0],
              [0, 0, 3, 4, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0, 0]])
  
      >>> x = ivy.array([[1, 2], [3, 4]])
      >>> y = ivy.constant_pad(x, pad_width = [[3, 2], [2, 3]])
      >>> print(y)
      ivy.array([[0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 1, 2, 0, 0, 0],
                  [0, 0, 3, 4, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0]])
  
      >>> x = ivy.array([[2.], [3.]])
      >>> y = ivy.zeros((4, 3))
      >>> ivy.constant_pad(x, pad_width = [(1, 1), (1, 1)], value = 5.0, out= y)
      >>> print(y)
      ivy.array([[5., 5., 5.],
             [5., 2., 5.],
             [5., 3., 5.],
             [5., 5., 5.]])
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a = ivy.array([1., 2., 3.]),
      ...                   b = ivy.array([3., 4., 5.]))
      >>> y = ivy.constant_pad(x, pad_width = [[2, 3]], value = 5.0)
      >>> print(y)
      {
          a: ivy.array([5., 5., 1., 2., 3., 5., 5., 5.]),
          b: ivy.array([5., 5., 3., 4., 5., 5., 5., 5.])
      }
      """
      return current_backend(x).constant_pad(
          x, pad_width=pad_width, value=value, out=out
      )
  
imports: from typing import Union, Optional, Tuple, List, Iterable, Sequence
  from numbers import Number
  from numpy.core.numeric import normalize_axis_tuple
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, to_native_arrays_and_back, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_view, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 11 for calling a global function with example usage: constant_pad(pad_width) and returns: current_backend