.. title:: clang-tidy - bugprone-fold-init-type

bugprone-fold-init-type
=======================

The check flags type mismatches in
`folds <https://en.wikipedia.org/wiki/Fold_(higher-order_function)>`_
that might result in loss of precision.

The check supports the following functions:

- ``std::accumulate``
- ``std::reduce``
- ``std::inner_product``

These functions fold an input range into an initial value using the type of the
latter. By default, ``std::accumulate`` and ``std::reduce`` use ``operator+``
while ``std::inner_product`` uses ``operator+`` and ``operator*``. This can
cause loss of precision through:

- Truncation: The following code uses a floating point range and an int
  initial value, so truncation will happen at every application of
  ``operator+``  and the result will be `0`, which might not be what the
  user expected.

.. code-block:: c++

  auto a = {0.5f, 0.5f, 0.5f, 0.5f};
  return std::accumulate(std::begin(a), std::end(a), 0);

- Overflow: The following code also returns `0`.

.. code-block:: c++

  auto a = {65536LL * 65536 * 65536};
  return std::accumulate(std::begin(a), std::end(a), 0);

The check handles overloads with the following transparent standard functors:

- ``std::plus``
- ``std::minus``
- ``std::multiplies``
- ``std::divides``
- ``std::bit_and``
- ``std::bit_or``
- ``std::bit_xor``
