a4z_blog_2017_02_14_v2, C++ (gcc)

Language: Layout:

#include <array>
#include <iostream>
#include <utility>

template<typename... Args>
constexpr
std::array<typename std::common_type<Args...>::type, sizeof...(Args)>
make_array(Args&&... args)
{
  return std::array<typename std::common_type<Args...>::type,
      sizeof...(Args)>{  std::forward<Args>(args)... };
}

template<typename T, size_t S, std::size_t... Idx>
constexpr auto
append (std::array<T, S>&& data, T&& elem, std::index_sequence<Idx...>)
  ->  std::array<T, S+1>
{
  return {std::get<Idx>(std::forward<std::array<T, S>>(data))...,
          std::forward<T>(elem)} ;
}

template<typename T, size_t S>
constexpr auto
append (std::array<T, S> data, T elem)
{
    return append(std::move(data),
                  std::move(elem),
                  std::make_index_sequence<S>{});
}

template<typename T, size_t S, std::size_t... Idx>
constexpr auto
prepend (std::array<T, S>&& data, T&& elem, std::index_sequence<Idx...>)
  ->  std::array<T, S+1>
{
  return {std::forward<T>(elem),
          std::get<Idx>(std::forward<std::array<T, S>>(data))...} ;
}

template<typename T, size_t S>
constexpr auto
prepend (T elem, std::array<T, S> data)
  -> std::array<T, S+1>
{
    return prepend(std::move(data),
                  std::move(elem),
                  std::make_index_sequence<S>{});
}

template<typename T, size_t S, typename... Ts, std::size_t... Idx>
constexpr auto
appendx(std::index_sequence<Idx...>, std::array<T, S>&& data, Ts&&... elems)
->  std::array<T, S + sizeof...(Ts)>
{
   return {std::get<Idx>(std::forward<std::array<T, S>>(data))...,
           std::forward<Ts>(elems)...} ;
}

template<typename T, size_t S, typename... Ts>
constexpr auto
appendx(std::array<T, S> data, Ts... elems)
{
   return appendx(std::make_index_sequence<S>{},
                 std::move(data), std::move(elems)...);
}

template<typename T, size_t S1, std::size_t... Idx1,
                     size_t S2, std::size_t... Idx2>
auto join(std::index_sequence<Idx1...>, std::array<T, S1>&& a1,
                std::index_sequence<Idx2...>, std::array<T, S2>&& a2)
-> std::array<T, S1 + S2>
{
   return {std::get<Idx1>(std::forward<std::array<T, S1>>(a1))...,
           std::get<Idx2>(std::forward<std::array<T, S2>>(a2))...} ;
}

template<typename T, size_t S1, size_t S2>
auto join (std::array<T, S1> a1, std::array<T, S2> a2)
-> std::array<T, S1 + S2>
{
  return join (std::make_index_sequence<S1>{},
               std::move(a1),
               std::make_index_sequence<S2>{},
               std::move(a2)
              ) ;
}

int main()
{
  std::array<char, 2> a2 = {'b', 'c'} ;

for (auto& e : append(a2, 'd'))
    std::cout << e ;
  std::cout << std::endl ;

for (auto& e : prepend('a', a2))
    std::cout << e ;
  std::cout << std::endl ;

for (auto& e : appendx(a2, 'd', 'e', 'f'))
    std::cout << e ;
  std::cout << std::endl ;

auto aa = join(make_array('z', 'a'), std::move(a2));
  for (auto& e : aa)
    std::cout <<  e;

std::cout << std::endl ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.32 sec, absolute running time: 0.14 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,46 sec