reduce

reduce_t kumi::reduce {}

inlineconstexprnodiscard

Callable object performing a tree-like reduction of all elements of a product type.

On record types, this function operates on the underlying values, not on the fields themselves.

Note

For associative operations, this produces the same result as a left or right fold, but have different intermediate evaluation order.

inline constexpr

Header file

#include <kumi/algorithm/reduce.hpp>

Call Signature

template<monoid M, product_type T>
constexpr auto reduce(M && m, T && t);

template<monoid M, product_type T, typename V>
constexpr auto reduce(M && m, T && t, V init);

Parameters

• m: Monoid callable function to apply
• t: Product Type to reduce
• init: Optional initial value of the reduction.

Return value

The result of reducing the elements of `t` by `m`, recursively combining elements in a tree structure.

Helper type

namespace kumi::result
{
  template<monoid M, product_type T> struct reduce;
 
  template<monoid M, product_type T>
  using reduce_t = typename reduce<M,T>::type;
 
  template<monoid M, product_type T, typename Value> struct reduce;
 
  template<monoid M, product_type T, typename Value>
  using reduce_t = typename reduce<M,T,Value>::type;
}

Computes the return type of a call to kumi::reduce

Examples

Tuple

#include <kumi/kumi.hpp>
#include <iostream>
 
int main()
{
  auto t1 = kumi::tuple{14,short{7}, 255ULL};
  std::cout << kumi::reduce(kumi::function::bit_and, t1)        << "\n";
  std::cout << kumi::reduce(kumi::function::bit_and, t1, 65535) << "\n";
 
  auto t2 = kumi::tuple{1 ,short{8},' ', 4ULL};
  std::cout << kumi::reduce(kumi::function::bit_or, t2)         << "\n";
  std::cout << kumi::reduce(kumi::function::bit_or, t2, 0)      << "\n";
 
  auto t3 = kumi::tuple{3, short{23}, '\t'};
  std::cout << kumi::reduce(kumi::function::bit_xor, t3)        << "\n";
  std::cout << kumi::reduce(kumi::function::bit_xor, t3, 1)     << "\n";
 
  auto t4 = kumi::tuple{2.,5,short{3},'\4'};
  std::cout << kumi::reduce(kumi::function::multiplies, t4)     << "\n";
  std::cout << kumi::reduce(kumi::function::multiplies, t4, 1)  << "\n";
 
  auto t5 = kumi::tuple{2.,1,short{55},' '};
  std::cout << kumi::reduce(kumi::function::plus, t5)           << "\n";
  std::cout << kumi::reduce(kumi::function::plus, t5, 42)        << "\n";
}

Record

#include <kumi/kumi.hpp>
#include <iostream>
 
int main()
{
  using namespace kumi::literals;
 
  auto r1 = kumi::record{"a"_id = 14,"b"_id = short{7}, "c"_id = 255ULL};
  std::cout << kumi::reduce(kumi::function::bit_and, r1)        << "\n";
  std::cout << kumi::reduce(kumi::function::bit_and, r1, 65535) << "\n";
 
  auto r2 = kumi::record{"a"_id = 1 ,"b"_id = short{8},"c"_id = ' ', "d"_id = 4ULL};
  std::cout << kumi::reduce(kumi::function::bit_or, r2)         << "\n";
  std::cout << kumi::reduce(kumi::function::bit_or, r2, 0)      << "\n";
 
  auto r3 = kumi::record{"a"_id = 3, "b"_id = short{23}, "c"_id = '\t'};
  std::cout << kumi::reduce(kumi::function::bit_xor, r3)        << "\n";
  std::cout << kumi::reduce(kumi::function::bit_xor, r3, 1)     << "\n";
 
  auto r4 = kumi::record{"a"_id = 2.,"b"_id = 5,"c"_id = short{3},"d"_id = '\4'};
  std::cout << kumi::reduce(kumi::function::multiplies, r4)     << "\n";
  std::cout << kumi::reduce(kumi::function::multiplies, r4, 1)  << "\n";
 
  auto r5 = kumi::record{"a"_id = 2.,"b"_id = 1,"c"_id = short{55},"d"_id = ' '};
  std::cout << kumi::reduce(kumi::function::plus, r5)           << "\n";
  std::cout << kumi::reduce(kumi::function::plus, r5, 42)        << "\n";
}