fold_left() [2/2]

template<typename Function , product_type T, typename Value >

constexpr auto kumi::fold_left ( Function  f, T &&  t, Value  init  )

inlineconstexpr

Computes the generalized combination of all elements using a tail recursive call.

Parameters

f	Binary callable function to apply
t	Product type to operate on
init	Optional initial value of the fold

Returns

The value of f( f( f(init, get<0>(t)), ...), get<N-1>(t))

Helper type

namespace kumi::result
{
  template<typename Function, product_type T, typename Value> struct fold_left;
 
  template<typename Function, product_type T, typename Value>
  using fold_left_t = typename fold_left<Function,T,Value>::type;
}

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

Examples:

 
#include <kumi/kumi.hpp>
#include <iostream>
#include <vector>
 
int main()
{
  auto t = kumi::tuple{2.,1,short{55},'z'};
 
  auto output  = kumi::fold_left( [](auto a, auto m) { a.push_back(sizeof(m)); return a; }
                                , t
                                , std::vector<std::size_t>{}
                                );
 
  for(auto s : output) std::cout << s << " ";
  std::cout << "\n";
 
  auto u = kumi::tuple{1,3,2,4,0,5,9,6,7};
 
  std::cout << kumi::fold_left( [](auto acc, auto e)
                                {
                                    std::cout << '(' << acc << ',' << e << ")\n";
                                    return (e <acc) ? e : acc;
                                }
                              , u
                              )
            << "\n";
}

 
#include <kumi/kumi.hpp>
#include <iostream>
#include <vector>
 
int main()
{
  using namespace kumi::literals;
 
  auto t = kumi::record{"a"_f = 2.,"b"_f = 1,"c"_f = short{55},"d"_f = 'z'};
 
  auto output  = kumi::fold_left( [](auto a, auto m) { a.push_back(sizeof(m)); return a; }
                                , t
                                , std::vector<std::size_t>{}
                                );
 
  for(auto s : output) std::cout << s << " ";
  std::cout << "\n";
 
  auto u = kumi::record{"a"_f = 1,"b"_f = 3,"c"_f = 2,"d"_f = 4,"e"_f = 0,
                        "f"_f = 5,"g"_f = 9,"h"_f = 6,"i"_f = 7};
 
  std::cout << kumi::fold_left( [](auto acc, auto e)
                                {
                                    std::cout << '(' << acc << ',' << e << ")\n";
                                    return (e <acc) ? e : acc;
                                }
                              , u
                              )
            << "\n";
}