::operator<<(tuple-like)

#include <array>
#include <ostream>
#include <tuple>
#include <type_traits>
#include <utility>

namespace details {

  template<typename>
  struct is_tuple_like : std::false_type { };

  template<typename... Types>
  struct is_tuple_like<std::tuple<Types...>> : std::true_type { };

  template<typename ValueType, std::size_t Size>
  struct is_tuple_like<std::array<ValueType, Size>> : std::true_type { };

  template<typename T1, typename T2>
  struct is_tuple_like<std::pair<T1, T2>> : std::true_type { };

  template<std::size_t Value>
  using index_t = std::integral_constant<std::size_t, Value>;

  template<std::size_t Index, typename CharT, typename Traits, typename Type>
  void print_tuple_element(index_t<Index>, std::basic_ostream<CharT, Traits>& stream, Type&& object) {
    stream << ", " << std::forward<Type>(object);
  }

  template<typename CharT, typename Traits, typename Type>
  void print_tuple_element(index_t<0>, std::basic_ostream<CharT, Traits>& stream, Type&& object) {
    stream << std::forward<Type>(object);
  }

  template<typename CharT, typename Traits, typename Tuple, std::size_t... Indexes>
  void print_tuple(std::basic_ostream<CharT, Traits>& ostream,
                            Tuple&& tuple, std::index_sequence<Indexes...>) {

    using Swallow = bool[];

    ostream << '(';
    Swallow{(print_tuple_element(index_t<Indexes>{}, ostream,
                                 std::get<Indexes>(std::forward<Tuple>(tuple))), false)...};
    ostream << ')';

  }

  // overload for empty tuple-like types
  template<typename CharT, typename Traits, typename Tuple>
  void print_tuple(std::basic_ostream<CharT, Traits>& ostream, Tuple&&, std::index_sequence<>) {
    ostream << "()";
  }

  template<typename T>
  using enable_if_is_tuple = std::enable_if_t<is_tuple_like<std::decay_t<T>>::value>;

  template<typename Tuple>
  using index_sequence_for_tuple = std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>;

}

template<typename CharT, typename Traits, typename Tuple, typename = details::enable_if_is_tuple<Tuple>>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& ostream, Tuple&& tuple) {
  using index_sequence = details::index_sequence_for_tuple<Tuple>;
  details::print_tuple(ostream, std::forward<Tuple>(tuple), index_sequence{});
  return ostream;
}