map

map_t kumi::map {}

inlineconstexprnodiscard

Callable object applying the Callable object f on each product types' elements.

Applies the given function to all the product types passed as arguments and stores the result in another product type, keeping the original elements order. On records, the order is determined via the order of definition of the fields.

Note

Does not participate in overload resolution if product types' size are not equal or if f can't be called on each product type's elements. All product type must either be record types or product types, mixing is not supported.

Header file

#include <kumi/algorithm/map.hpp>

Call Signature

template<typename Function, product_type T, product_type... Ts>
constexpr auto map(Function && f, T && t, Ts &&... ts);

Parameters

• f: Callable object to apply
• t: Product Type to operate on
• ts: Other Product Types to operate on

Return value

• The product type matching the common_product_type of the input containing f calls results.

Helper type

    template<typename Function,
             kumi::concepts::product_type T,
             kumi::concepts::sized_product_type<kumi::size_v<T>>... Ts>
    struct map
    {
      using type = decltype(kumi::map(std::declval<Function>(), std::declval<T>(), std::declval<Ts>()...));
    };
 
    template<typename Function,
             kumi::concepts::product_type T,
             kumi::concepts::sized_product_type<kumi::size_v<T>>... Ts>
    using map_t = typename kumi::result::map<Function, T, Ts...>::type;
 

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

See also

kumi::map_index

kumi::map_field

Examples

• Tuple

  
  #include <kumi/kumi.hpp>
  #include <iostream>
   
  int main()
  {
    auto lhs = kumi::tuple{1,2,3};
    auto rhs = kumi::tuple{2.5,3.6,4.7};
   
    auto res = kumi::map( [](auto l, auto r) { return l*r; }, lhs, rhs);
   
    std::cout << res << "\n";
  }

• Record

  
  #include <kumi/kumi.hpp>
  #include <iostream>
   
  int main()
  {
    using namespace kumi::literals;
    auto lhs = kumi::record{"a"_id = 1,"b"_id = 2,"c"_id = 3};
    auto rhs = kumi::record{"a"_id = 2.5,"b"_id = 3.6,"c"_id = 4.7};
   
    auto res = kumi::map( [](auto l, auto r) { return l*r; }, lhs, rhs);
   
    std::cout << res << "\n";
  }