fold_right() [1/2]

template<typename Function , concepts::sized_product_type_or_more< 1 > T>

constexpr auto kumi::fold_right ( Function  f, T &&  t  )

inlineconstexpr

Computes the generalized associative combinationof all elements using a non-tail recursive call.

Parameters

f	Associative binary callable function to apply
t	Product type of size 1 or more to operate on

Returns

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

Helper type

namespace kumi::result
{
  template<typename Function, product_type T> struct fold_right;
 
  template<typename Function, product_type T>
  using fold_right_t = typename fold_right<Function,T>::type;
}

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

Examples:

 
#include <kumi/kumi.hpp>
#include <iostream>
#include <vector>
 
int main()
{
  auto t = kumi::tuple{2.,1,short{55},'z'};
 
  auto output  = kumi::fold_right( [](auto m, auto a) { 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_right(  [](auto e, auto acc)
                                  {
                                      std::cout << '(' << acc << ',' << e << ")\n";
                                      return (e <acc) ? e : acc;
                                  }
                                , u
                                )
            << "\n";
}

 
#include <kumi/kumi.hpp>
#include <iostream>
#include <vector>
 
int main()
{
  auto t = kumi::tuple{2.,1,short{55},'z'};
 
  auto output  = kumi::fold_right( [](auto m, auto a) { 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_right(  [](auto e, auto acc)
                                  {
                                      std::cout << '(' << acc << ',' << e << ")\n";
                                      return (e <acc) ? e : acc;
                                  }
                                , u
                                )
            << "\n";
}