C++ container output stream header file

This header file provides extensions to the iostream << operator so you can pretty print C++ containers. It has a few interesting examples of template metaprogramming and uses some of the more modern C++ (2017) features. The repo code is evolving: https://github.com/adrianfreed/containerostream [1]

//
// Created by AdrianFreed on 9/24/20.
// << overloads for printing containers
// requires C++17
//
#ifndef CONTAINER_O_STREAM_H
#define CONTAINER_O_STREAM_H
#include <iostream>
#include <array>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <tuple>
#include <deque>
#include <list>
#include <forward_list>
//Pairs
template<typename TA, typename TB>
auto &operator;<<(std::ostream &os;, const std::pair<TA, TB> &p;) {
    os << '(' << p.first << ',' << p.second << ')';
    return os;
}
//Tuples
// variadic template metaprogram to iterate over the tuple elements
// requires C++17, replace with messier folds if using earlier version
template<size_t I = 0, typename... Tp>
void tuple_element_print(const std::tuple<Tp...> &t;, std::ostream &os;) {
    os << std::get<I>(t);
    if constexpr(I + 1 != sizeof...(Tp)) {
        os << ", ";
        tuple_element_print<I + 1>(t, os);
    }
}
template<typename ...Types>
auto &operator;<<(std::ostream &os;, const std::tuple<Types ...> &t;) {
    os << "(T ";
    tuple_element_print(t, os);
    os << ")";
    return os;
}
namespace CONTAINERSTREAM {
//Maps
    template<typename C>
    std::ostream &output;(std::ostream &os;, C &v;, const char *first, const char *separator, const char *last) {
        os << first;
        for (auto it = v.cbegin(); it != v.cend(); ++it) {
            os << it->first << ':' << it->second;
            if (std::next(it) != v.cend())
                os << separator;
        }
        os << last;
        return os;
    }
}
template<typename T, typename Tbis>
std::ostream &operator;<<(std::ostream &os;, const std::unordered_map<T, Tbis> &v;) {
    return CONTAINERSTREAM::output(os, v, "[Unorderedmap ", ", ", "]");
}
template<typename T, typename Tbis>
std::ostream &operator;<<(std::ostream &os;, const std::map<T, Tbis> &v;) {
    return CONTAINERSTREAM::output(os, v, "[Map ", ", ", "]");
}
template<typename T, typename Tbis>
std::ostream &operator;<<(std::ostream &os;, const std::multimap<T, Tbis> &v;) {
    return CONTAINERSTREAM::output(os, v, "[Multimap ", ", ", "]");
}
namespace CONTAINERSTREAM {
// The Rest
    template<typename C>
    std::ostream &
    vectorarrayoutput(std::ostream &os;, C &v;, const char *first, const char *separator, const char *last) {
        os << first;
        for (auto it = v.cbegin(); it != v.cend(); ++it) {
            os << *it;
            if (std::next(it) != v.cend())
                os << separator;
        }
        os << last;
        return os;
    }
}
// There may appear to be a lot of repetition in these functions
// The idea behind that is that you are invited to change the styling of
// each separator and bracket according to your own aesthetics or conventions
template<typename T, std::size_t N>
auto &operator;<<(std::ostream &os;, const std::array<T, N> &a;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, a, "[Array ", ", ", "]");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::vector<T> &v;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, v, "[Vector ", ", ", "]");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::set<T> &v;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, v, "[Set ", ", ", "]");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::multiset<T> &v;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, v, "[Multiset ", ", ", "]");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::list<T> &l;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, l, "(List ", ", ", ")");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::forward_list<T> &l;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, l, "(ForwardList ", ", ", ")");
}
template<typename T>
std::ostream &operator;<<(std::ostream &os;, const std::deque<T> &d;) {
    return CONTAINERSTREAM::vectorarrayoutput(os, d, "(Deque ", ", ", ")");
}
#endif //TEST_CONTAINER_O_STREAM_H