#include <vector>
#include <iostream>
#include <boost/range/join.hpp>

template <typename R1, typename R2, typename ... Other>
auto join_ranges(const R1 & r1, const R2 & r2, const Other& ... other)
{
    if constexpr (sizeof ... (other) == 0)
        return boost::range::join(r1, r2);
    else
        return join_ranges(boost::range::join(r1, r2), other...);
}

int main()
{
    std::vector<int> v = {1, 2, 3};
    auto joined = join_ranges(v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v);
    for (int i : joined)
        std::cout << i;
}

template <typename Ret, typename Item, typename ... Other>
void join_ranges_impl(Ret & result, const Item & range, const Other& ... other)
{
    result = boost::range::join(result, range);
    if constexpr (sizeof ... (other) != 0)
        join_ranges_impl(result, other...);
}

template <typename Item, typename ... Other>
auto join_ranges(const Item & range, const Other& ... other)
{
    using T = std::remove_reference_t<decltype(*std::begin(range))>;
    boost::any_range<const T, boost::random_access_traversal_tag, const T> result = range;
    join_ranges_impl(result, other...);
    return result;
}

    std::vector<int> v = {1, 2, 3};

    auto joined1 = boost::range::join(v, v);
    std::cout << sizeof(joined1) << std::endl;

    auto joined2 = boost::range::join(joined1, v);
    std::cout << sizeof(joined2) << std::endl;

    auto joined3 = boost::range::join(joined2, v);
    std::cout << sizeof(joined3) << std::endl;

    auto joined4 = boost::range::join(joined3, v);
    std::cout << sizeof(joined4) << std::endl;

    auto joined5 = boost::range::join(joined4, v);
    std::cout << sizeof(joined5) << std::endl;

    auto joined6 = boost::range::join(joined5, v);
    std::cout << sizeof(joined6) << std::endl;

    auto joined7 = boost::range::join(joined6, v);
    std::cout << sizeof(joined7) << std::endl;

    auto joined8 = boost::range::join(joined7, v);
    std::cout << sizeof(joined8) << std::endl;

    auto joined9 = boost::range::join(joined8, v);
    std::cout << sizeof(joined9) << std::endl;

    auto joined10 = boost::range::join(joined9, v);
    std::cout << sizeof(joined10) << std::endl;

80
216
488
1032
2120
4296
8648
17352
34760
69576

AD>80
AD>216
AD>488
AD>1032
AD>2120
AD>4296
AD>8648
AD>17352
AD>34760
AD>69576
AD>

AD>Но почему

template <typename R1, typename R2, typename ... Other>
auto join_ranges(const R1 & r1, const R2 & r2, const Other& ... other)
{
    if constexpr (sizeof ... (other) == 0)
        return boost::range::join(r1, r2);

    if constexpr (sizeof ... (other) == 1)
        return join_ranges(boost::range::join(r1, r2), other...);

  return boost::range::join(boost::range::join(r1, r2), join_ranges(other...);
}

#include <vector>
#include <iostream>
#include <memory>
#include <boost/range/join.hpp>

template <typename R1, typename R2, typename ... Other>
auto join_ranges(const R1 & r1, const R2 & r2, const Other& ... other)
{
    using joined_range_t = boost::range::joined_range<const R1, const R2>;

    auto joined_r1_r2 = std::make_unique<joined_range_t>(r1, r2);

    if constexpr (sizeof ... (other) == 0)
        return joined_r1_r2;
    else
        return join_ranges(*joined_r1_r2, other...);
}

int main()
{
    std::vector<int> v = {1, 2, 3};
    auto joined = join_ranges(v, v, v, v, v, v, v, v, v, v, v, v, v, v);

    for (int i : *joined)
        std::cout << i;
}

template <typename R, typename ... Other>
decltype(auto) join_ranges(R&& r, Other&& ... other)
{
    if constexpr (sizeof ... (other) == 0)
        return std::forward<R>(r);
    else
        return boost::range::join(std::forward<R>(r), join_ranges(std::forward<Other>(other)...));
}

/* main.cpp */

#include <CCore/inc/Print.h>
#include <CCore/inc/Array.h>

using namespace CCore;

/* JoinRange */

template <class F,class T>
struct JoinRange
 {
  F f;
  T t;

  JoinRange(const F &f_,const T &t_) : f(f_),t(t_) {}

  bool operator + () const { return +f || +t ; }

  bool operator ! () const { return !f && !t ; } 

  auto operator * () const { return (+f)? *f : *t ; }

  void operator ++ () { if( +f ) ++f; else ++t; }

  bool operator != (NothingType) const { return +(*this); }
 };

template <class F,class T>
auto begin(JoinRange<F,T> r) { return r; }

template <class F,class T>
NothingType end(JoinRange<F,T>) { return Null; }

/* JoinRanges() */

template <class T>
auto JoinRanges(const T &t)
 {
  return Range(t);
 }

template <class T,class ... TT>
auto JoinRanges(const T &t,const TT & ... tt)
 {
  return JoinRange(Range(t),JoinRanges(tt...));
 }

/* main() */

template <class T>
void Show(const T &list)
 {
  for(const auto &obj : list ) Printf(Con,"#; , ",obj);

  Putobj(Con,"\n\n"_c);
 }

int main() 
 {
  DynArray<int> v{1,2,3,4,5};

  Show(v);  

  Show(JoinRanges(v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v,v));

  return 0;
 }