Может кто-нибудь объяснить трюк с индексами?

Проблема в том, что у нас есть std::tuple<T1, T2, ...> и некоторая функция f, которую мы можем вызывать для каждого элемента, где f возвращает int, и мы хотим сохранить эти результаты в массиве.

Начнем с конкретного случая:

template <typename T> int f(T ) { return sizeof(T); }

std::tuple<int, char, double> tup{42, 'x', 3.14};
std::array<int, 3> arr{ f(std::get<0>(tup)), 
                        f(std::get<1>(tup)),
                        f(std::get<2>(tup)) );

За исключением того, что запись всех этих get в лучшем случае неудобна и избыточна, а в худшем - подвержена ошибкам.

Сначала нам нужно включить заголовок утилиты для std::index_sequence и std::make_index_sequence:

#include <utility>

Теперь предположим, что у нас есть тип index_sequence<0, 1, 2>. Мы могли бы использовать это, чтобы свернуть эту инициализацию массива в расширение вариационного пакета:

template <typename Tuple, size_t... Indices>
std::array<int, sizeof...(Indices)> 
call_f_detail(Tuple& tuple, std::index_sequence<Indices...> ) {
    return { f(std::get<Indices>(tuple))... };
}

Это потому, что внутри функции f(std::get<Indices>(tuple))... расширяется до f(std::get<0>(tuple)), f(std::get<1>(tuple)), f(std::get<2>(tuple)). Это именно то, что мы хотим.

Последней деталью проблемы является просто создание этой конкретной последовательности индексов. В C++14 есть такая утилита с именем make_index_sequence.

template <typename Tuple>
std::array<int, std::tuple_size<Tuple>::value>
call_f(Tuple& tuple) {
    return call_f_detail(tuple,
        // make the sequence type sequence<0, 1, 2, ..., N-1>
        std::make_index_sequence<std::tuple_size<Tuple>::value>{}
        );
}

тогда как статья, на которую вы ссылаетесь, просто объясняет, как можно реализовать такую ​​​​метафункцию.

Bare, вероятно, что-то вроде ответа Люка Дантона:

template<typename T>
using Bare = typename std::remove_cv<typename std::remove_reference<T>::type>::type;