#include <algorithm>
#include <cstddef>
#include <cstring>
#include <cwctype>
#include <functional>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>

using namespace std;

#ifdef _MSC_VER
#pragma warning(disable: 4555)
#endif

namespace detail
{
  template <size_t N, size_t Max>
  struct fold
  {
    template <typename T, typename Z, typename F>
    static decltype(auto) apply(T&& t, Z&& z, F f)
    {
      return fold<N+1, Max>::template apply(
          std::forward<T>(t),
          f(std::forward<Z>(z), get<N>(std::forward<T>(t))),
          f);
    }
  };

  template <size_t Max>
  struct fold<Max, Max>
  {
    template <typename T, typename Z, typename F>
    static decltype(auto) apply(T, Z& z, F)
    {
      return z;
    }
    template <typename T, typename Z, typename F>
    static auto apply(T, const Z& z, F)
    {
      return z;
    }
  };
}

template <typename F, typename Z, typename... Ts>
decltype(auto) fold(const tuple<Ts...>& t, Z&& z, F&& f)
{
  return detail::fold<0, sizeof...(Ts)>::template apply(
      t, std::forward<Z>(z), std::forward<F>(f));
}

template <typename F, typename Z, typename... Ts>
decltype(auto) fold(tuple<Ts...>&& t, Z&& z, F&& f)
{
  return detail::fold<0, sizeof...(Ts)>::template apply(
      std::move(t), std::forward<Z>(z), std::forward<F>(f));
}

size_t string_len(const string& s) { return s.size(); }
size_t string_len(const char* s) { return strlen(s); }
size_t string_len(bool) { return 1; }
size_t string_len(char) { return 1; }
template <typename T>
size_t string_len(T t) { return to_string(t).size(); }

int main()
{
  auto t = make_tuple("Hello", 3.14, 1729, 'a');

  {
    auto f = [] (ostream& s, const auto& x) -> ostream& {
      return s << x << '\n';
    };
    decltype(auto) s = fold(t, cout, f);
    s << "done" << endl;
  }

  {
    auto f = [] (size_t l, const auto& x) {
      return l + string_len(x);
    };
    decltype(auto) s = fold(t, size_t{}, f);
    cout << s << endl;
  }
}