apply()

template<typename Function , product_type Tuple>
requires _::supports_apply<Function, Tuple>

constexpr decltype(auto) kumi::apply ( Function &&  f, Tuple &&  t  )

inlineconstexprnoexcept

Invoke the Callable object f with a product_type of arguments. f is applied on the values if the given product_type is a kumi::record.

Parameters

f	Callable object to be invoked
t	kumi::product_type whose elements to be used as arguments to f

Returns

The value returned by f.

Helper type

namespace kumi::result
{
  template<typename Function, product_type Tuple> struct apply;
 
  template<typename Function, product_type Tuple>
  using apply_t = typename apply<Function,Tuple>::type;
}

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

Example

 
#include <kumi/kumi.hpp>
#include <iostream>
 
template<kumi::product_type Tuple>
void print(std::ostream& os, Tuple const& t)
{
  kumi::apply
  (
    [&os](auto const&... args)
    {
      os << '[';
      std::size_t n{0};
      ((os << args << (++n != kumi::size<Tuple>::value ? ", " : "")), ...);
      os << ']';
    }, t
  );
 
  os << '\n';
}
 
int main()
{
  auto t = kumi::tuple{1,2.,3.f};
 
  // Simple operation: sum all values
  std::cout << kumi::apply( [](auto... m) { return (m + ...); }, t) << "\n";
 
  // Advanced usage
  print(std::cout, t);
}

 
#include <kumi/kumi.hpp>
#include <iostream>
 
template<kumi::record_type Record>
void print(std::ostream& os, Record const& t)
{
  kumi::apply
  (
    [&os](auto const&... args)
    {
      os << '[';
      std::size_t n{0};
      ((os << args << (++n != kumi::size<Record>::value ? ", " : "")), ...);
      os << ']';
    }, t
  );
 
  os << '\n';
}
 
int main()
{
  using namespace kumi::literals;
 
  auto r = kumi::record{"x"_f = 1, "y"_f = 2., "z"_f = 3.f};
 
  // Simple operation: sum all values
  std::cout << kumi::apply( [](auto... m) { return (m + ...); }, r) << "\n";
 
  // Advanced usage
  print(std::cout, r);
}