diff --git a/ppdemo.cpp b/ppdemo.cpp
index 5e5eba3..817e5c8 100644
--- a/ppdemo.cpp
+++ b/ppdemo.cpp
@@ -84,10 +84,9 @@ int main(int argc, char * argv[])
   ;
 
   /* Demo: Here we use our reusable delimiter class MyDelims by directly accessing some interna. */
-  std::cout << pretty_print::print_container_helper<std::vector<std::string>, char, std::char_traits<char>, MyDelims>(v) << std::endl;
-
-  /* Demo: Here we achieve the same using a type-erasing helper class. */
-  std::cout << pretty_print::custom_delims<MyDelims>(v) << std::endl;
+  std::cout << "Reusable delimiters: "
+            << pretty_print::print_container_helper<std::vector<std::string>, char, std::char_traits<char>, MyDelims>(v)
+            << std::endl;
 
   /* Demo: We can pretty-print std::pair and std::tuple.
      (You already saw pairs in the associative containers above.)
@@ -97,6 +96,13 @@ int main(int argc, char * argv[])
   auto a3 = std::make_tuple("Qrgh", a1, 11);
   auto a4 = std::make_tuple(1729, 2875, std::pair<double, std::string>(1.5, "abc"));
 
+  /* Demo: Here we achieve the same using a type-erasing helper class. */
+  std::cout << "Custom, type-erased delimiters: "
+            << pretty_print::custom_delims<MyDelims>(v) << std::endl;
+  std::cout << "Custom, type-erased delimiters: "
+            << pretty_print::custom_delims<MyDelims>(a2) << std::endl;
+  std::cout << "Custom, type-erased delimiters: "
+            << pretty_print::custom_delims<MyDelims>(a3) << std::endl;
 
   /* Demo: raw arrays can be printed with a helper wrapper. */
   int arr[] = { 1, 4, 9, 16 };
@@ -104,9 +110,11 @@ int main(int argc, char * argv[])
 
   std::cout << "Static C array: " << arr << std::endl
             << "Static C array: " << err << std::endl
+            << "Static C array with length: " << pretty_print_array(arr + 1, 2) << std::endl
             << "Pair:    " << a1 << std::endl
             << "1-tuple: " << a2 << std::endl
             << "n-tuple: " << a3 << std::endl
             << "n-tuple: " << a4 << std::endl
+            << "Hashmap bucket: " << bucket_print(um, 0) << std::endl
   ;
 }
diff --git a/prettyprint.hpp b/prettyprint.hpp
index 6ef1fb7..1cc5023 100644
--- a/prettyprint.hpp
+++ b/prettyprint.hpp
@@ -2,209 +2,119 @@
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-
+//
+// A pretty printing library for C++
+//
+// Usage:
+// Include this header, and operator<< will "just work".
 
 #ifndef H_PRETTY_PRINT
 #define H_PRETTY_PRINT
 
-
-#include <type_traits>
+#include <iterator>
 #include <memory>
 #include <ostream>
-#include <utility>
-#include <tuple>
-#include <iterator>
 #include <set>
+#include <tuple>
+#include <type_traits>
 #include <unordered_set>
+#include <utility>
 #include <valarray>
 
 namespace pretty_print
 {
-
-    // SFINAE type trait to detect whether T::const_iterator exists.
-
-    template<typename T>
-    struct has_const_iterator
+    namespace detail
     {
-    private:
-        typedef char                      yes;
-        typedef struct { char array[2]; } no;
-
-        template <typename C> static yes test(typename C::const_iterator*);
-        template <typename C> static no  test(...);
-    public:
-        static const bool value = sizeof(test<T>(0)) == sizeof(yes);
-        typedef T type;
-    };
-
-    // SFINAE type trait to detect whether "T::const_iterator T::begin/end() const" exist.
-
-    template <typename T>
-    struct has_begin_end_OLD
-    {
-        struct Dummy { typedef void const_iterator; };
-        typedef typename std::conditional<has_const_iterator<T>::value, T, Dummy>::type TType;
-        typedef typename TType::const_iterator iter;
-
-        struct Fallback { iter begin() const; iter end() const; };
-        struct Derived : TType, Fallback { };
-
-        template<typename C, C> struct ChT;
-
-        template<typename C> static char (&f(ChT<iter (Fallback::*)() const, &C::begin>*))[1];
-        template<typename C> static char (&f(...))[2];
-        template<typename C> static char (&g(ChT<iter (Fallback::*)() const, &C::end>*))[1];
-        template<typename C> static char (&g(...))[2];
-
-        static bool const beg_value = sizeof(f<Derived>(0)) == 2;
-        static bool const end_value = sizeof(g<Derived>(0)) == 2;
-    };
-
-    template <typename T>
-    struct has_begin_end
-    {
-        template<typename C> static char (&f(typename std::enable_if<
-          std::is_same<decltype(static_cast<typename C::const_iterator (C::*)() const>(&C::begin)),
-          typename C::const_iterator(C::*)() const>::value, void>::type*))[1];
-
-        template<typename C> static char (&f(...))[2];
+        // SFINAE type trait to detect whether T::const_iterator exists.
 
-        template<typename C> static char (&g(typename std::enable_if<
-          std::is_same<decltype(static_cast<typename C::const_iterator (C::*)() const>(&C::end)),
-          typename C::const_iterator(C::*)() const>::value, void>::type*))[1];
-
-        template<typename C> static char (&g(...))[2];
+        struct sfinae_base
+        {
+            using yes = char;
+            using no  = yes[2];
+        };
 
-        static bool const beg_value = sizeof(f<T>(0)) == 1;
-        static bool const end_value = sizeof(g<T>(0)) == 1;
-    };
+        template <typename T>
+        struct has_const_iterator : private sfinae_base
+        {
+        private:
+            template <typename C> static yes & test(typename C::const_iterator*);
+            template <typename C> static no  & test(...);
+        public:
+            static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
+            using type =  T;
+        };
+
+        template <typename T>
+        struct has_begin_end : private sfinae_base
+        {
+        private:
+            template <typename C>
+            static yes & f(typename std::enable_if<
+                std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::begin)),
+                             typename C::const_iterator(C::*)() const>::value>::type *);
 
-    // Basic is_container template; specialize to derive from std::true_type for all desired container types
+            template <typename C> static no & f(...);
 
-    template<typename T> struct is_container : public ::std::integral_constant<bool,
-      has_const_iterator<T>::value && has_begin_end<T>::beg_value && has_begin_end<T>::end_value> { };
+            template <typename C>
+            static yes & g(typename std::enable_if<
+                std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::end)),
+                             typename C::const_iterator(C::*)() const>::value, void>::type*);
 
-    template<typename T, std::size_t N> struct is_container<T[N]> : public ::std::true_type { };
+            template <typename C> static no & g(...);
 
-    template<std::size_t N> struct is_container<char[N]> : public ::std::false_type { };
+        public:
+            static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
+            static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
+        };
 
-    template <typename T> struct is_container< ::std::valarray<T>> : public ::std::true_type { };
+    }  // namespace detail
 
 
     // Holds the delimiter values for a specific character type
 
-    template<typename TChar>
+    template <typename TChar>
     struct delimiters_values
     {
-        typedef TChar char_type;
-        const TChar * prefix;
-        const TChar * delimiter;
-        const TChar * postfix;
+        using char_type = TChar;
+        const char_type * prefix;
+        const char_type * delimiter;
+        const char_type * postfix;
     };
 
 
     // Defines the delimiter values for a specific container and character type
 
-    template<typename T, typename TChar>
+    template <typename T, typename TChar>
     struct delimiters
     {
-        typedef delimiters_values<TChar> type;
+        using type = delimiters_values<TChar>;
         static const type values; 
     };
 
 
-    // Default delimiters
-
-    template<typename T> struct delimiters<T, char> { static const delimiters_values<char> values; };
-    template<typename T> const delimiters_values<char> delimiters<T, char>::values = { "[", ", ", "]" };
-    template<typename T> struct delimiters<T, wchar_t> { static const delimiters_values<wchar_t> values; };
-    template<typename T> const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = { L"[", L", ", L"]" };
-
-
-    // Delimiters for (multi)set and unordered_(multi)set
-
-    template<typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::set<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
-
-    template<typename T, typename TComp, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::set<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
-
-    template<typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::set<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
-
-    template<typename T, typename TComp, typename TAllocator>
-    const delimiters_values<wchar_t> delimiters< ::std::set<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
-
-    template<typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::multiset<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
-
-    template<typename T, typename TComp, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::multiset<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
+    // Functor to print containers. You can use this directly if you want
+    // to specificy a non-default delimiters type. The printing logic can
+    // be customized by specializing the nested template.
 
-    template<typename T, typename TComp, typename TAllocator>
-    struct delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
-
-    template<typename T, typename TComp, typename TAllocator>
-    const delimiters_values<wchar_t> delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<wchar_t> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<char> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
-
-    template<typename T, typename THash, typename TEqual, typename TAllocator>
-    const delimiters_values<wchar_t> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
-
-
-    // Delimiters for pair (reused for tuple, see below)
-
-    template<typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, char> { static const delimiters_values<char> values; };
-    template<typename T1, typename T2> const delimiters_values<char> delimiters< ::std::pair<T1, T2>, char>::values = { "(", ", ", ")" };
-    template<typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, wchar_t> { static const delimiters_values<wchar_t> values; };
-    template<typename T1, typename T2> const delimiters_values<wchar_t> delimiters< ::std::pair<T1, T2>, wchar_t>::values = { L"(", L", ", L")" };
-
-
-    // Functor to print containers. You can use this directly if you want to specificy a non-default delimiters type.
-
-    template<typename T, typename TChar = char, typename TCharTraits = ::std::char_traits<TChar>, typename TDelimiters = delimiters<T, TChar>>
+    template <typename T,
+              typename TChar = char,
+              typename TCharTraits = ::std::char_traits<TChar>,
+              typename TDelimiters = delimiters<T, TChar>>
     struct print_container_helper
     {
-        typedef TChar char_type;
-        typedef TDelimiters delimiters_type;
-        typedef std::basic_ostream<TChar, TCharTraits> ostream_type;
-
-        print_container_helper(const T & container)
-        : _container(container)
-        {
-        }
+        using delimiters_type = TDelimiters;
+        using ostream_type = std::basic_ostream<TChar, TCharTraits>;
 
-        inline void operator()(ostream_type & stream) const
+        template <typename U>
+        struct printer
         {
-            if (delimiters_type::values.prefix != NULL)
-                stream << delimiters_type::values.prefix;
-
+            static void print_body(const U & c, ostream_type & stream)
             {
                 using std::begin;
                 using std::end;
 
-                auto it = begin(_container);
-                const auto the_end = end(_container);
+                auto it = begin(c);
+                const auto the_end = end(c);
 
                 if (it != the_end)
                 {
@@ -219,187 +129,240 @@ namespace pretty_print
                     }
                 }
             }
+        };
+
+        print_container_helper(const T & container)
+        : container_(container)
+        { }
+
+        inline void operator()(ostream_type & stream) const
+        {
+            if (delimiters_type::values.prefix != NULL)
+                stream << delimiters_type::values.prefix;
+
+            printer<T>::print_body(container_, stream);
 
             if (delimiters_type::values.postfix != NULL)
                 stream << delimiters_type::values.postfix;
         }
 
     private:
-        const T & _container;
+        const T & container_;
     };
 
+    // Specialization for pairs
 
-    // Type-erasing helper class for easy use of custom delimiters.
-    // Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t, and MyDelims needs to be defined for TChar.
-    // Usage: "cout << pretty_print::custom_delims<MyDelims>(x)".
-
-    struct custom_delims_base
+    template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
+    template <typename T1, typename T2>
+    struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::pair<T1, T2>>
     {
-        virtual ~custom_delims_base() { }
-        virtual ::std::ostream & stream(::std::ostream &) = 0;
-        virtual ::std::wostream & stream(::std::wostream &) = 0;
+        using ostream_type = print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
+
+        static void print_body(const std::pair<T1, T2> & c, ostream_type & stream)
+        {
+            stream << c.first;
+            if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
+                stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
+            stream << c.second;
+        }
     };
 
-    template<typename T, typename Delims>
-    struct custom_delims_wrapper : public custom_delims_base
+    // Specialization for tuples
+
+    template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
+    template <typename ...Args>
+    struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::tuple<Args...>>
     {
-        custom_delims_wrapper(const T & t_) : t(t_) { }
+        using ostream_type = print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
+        using element_type = std::tuple<Args...>;
 
-        ::std::ostream & stream(::std::ostream & s)
+        template <std::size_t I> struct Int { };
+
+        static void print_body(const element_type & c, ostream_type & stream)
         {
-          return s << ::pretty_print::print_container_helper<T, char, ::std::char_traits<char>, Delims>(t);
+            tuple_print(c, stream, Int<0>());
         }
-        ::std::wostream & stream(::std::wostream & s)
+
+        static void tuple_print(const element_type &, ostream_type &, Int<sizeof...(Args)>)
         {
-          return s << ::pretty_print::print_container_helper<T, wchar_t, ::std::char_traits<wchar_t>, Delims>(t);
         }
 
-    private:
-        const T & t;
+        static typename std::enable_if<sizeof...(Args) != 0>::type
+        tuple_print(const element_type & c, ostream_type & stream, Int<0>)
+        {
+            stream << std::get<0>(c);
+            tuple_print(c, stream, Int<1>());
+        }
+
+        template <std::size_t N>
+        static void tuple_print(const element_type & c, ostream_type & stream, Int<N>)
+        {
+            if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
+                stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
+
+            stream << std::get<N>(c);
+
+            tuple_print(c, stream, Int<N + 1>());
+        }
     };
 
-    template<typename Delims>
-    struct custom_delims
+    // Prints a print_container_helper to the specified stream.
+
+    template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
+    inline std::basic_ostream<TChar, TCharTraits> & operator<<(
+        std::basic_ostream<TChar, TCharTraits> & stream,
+        const print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
     {
-        template<typename Container>
-        custom_delims(const Container & c)
-        : base(new custom_delims_wrapper<Container, Delims>(c)) { }
+        helper(stream);
+        return stream;
+    }
 
-        std::unique_ptr<custom_delims_base> base;
-    };
 
-} // namespace pretty_print
+    // Basic is_container template; specialize to derive from std::true_type for all desired container types
 
+    template <typename T>
+    struct is_container : public std::integral_constant<bool,
+                                                        detail::has_const_iterator<T>::value &&
+                                                        detail::has_begin_end<T>::beg_value  &&
+                                                        detail::has_begin_end<T>::end_value> { };
 
-template<typename TChar, typename TCharTraits, typename Delims>
-inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & s, const pretty_print::custom_delims<Delims> & p)
-{
-    return p.base->stream(s);
-}
+    template <typename T, std::size_t N>
+    struct is_container<T[N]> : std::true_type { };
 
+    template <std::size_t N>
+    struct is_container<char[N]> : std::false_type { };
 
-// Template aliases for char and wchar_t delimiters
-// Enable these if you have compiler support
-//
-// Implement as "template<T, C, A> const sdelims::type sdelims<std::set<T,C,A>>::values = { ... }."
+    template <typename T>
+    struct is_container<std::valarray<T>> : std::true_type { };
 
-//template<typename T> using pp_sdelims = pretty_print::delimiters<T, char>;
-//template<typename T> using pp_wsdelims = pretty_print::delimiters<T, wchar_t>;
+    template <typename T1, typename T2>
+    struct is_container<std::pair<T1, T2>> : std::true_type { };
 
+    template <typename ...Args>
+    struct is_container<std::tuple<Args...>> : std::true_type { };
 
-namespace std
-{
-    // Prints a print_container_helper to the specified stream.
 
-    template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
-    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream,
-                                                          const ::pretty_print::print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
-    {
-        helper(stream);
-        return stream;
-    }
+    // Default delimiters
 
-    // Prints a container to the stream using default delimiters
+    template <typename T> struct delimiters<T, char> { static const delimiters_values<char> values; };
+    template <typename T> const delimiters_values<char> delimiters<T, char>::values = { "[", ", ", "]" };
+    template <typename T> struct delimiters<T, wchar_t> { static const delimiters_values<wchar_t> values; };
+    template <typename T> const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = { L"[", L", ", L"]" };
 
-    template<typename T, typename TChar, typename TCharTraits>
-    inline typename enable_if< ::pretty_print::is_container<T>::value, basic_ostream<TChar, TCharTraits>&>::type
-    operator<<(basic_ostream<TChar, TCharTraits> & stream, const T & container)
-    {
-        return stream << ::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
-    }
 
-    // Prints a pair to the stream using delimiters from delimiters<std::pair<T1, T2>>.
-    template<typename T1, typename T2, typename TChar, typename TCharTraits>
-    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream, const pair<T1, T2> & value)
-    {
-        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.prefix != NULL)
-            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.prefix;
+    // Delimiters for (multi)set and unordered_(multi)set
+
+    template <typename T, typename TComp, typename TAllocator>
+    struct delimiters< ::std::set<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
 
-        stream << value.first;
+    template <typename T, typename TComp, typename TAllocator>
+    const delimiters_values<char> delimiters< ::std::set<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
 
-        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.delimiter != NULL)
-            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.delimiter;
+    template <typename T, typename TComp, typename TAllocator>
+    struct delimiters< ::std::set<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
 
-        stream << value.second;
+    template <typename T, typename TComp, typename TAllocator>
+    const delimiters_values<wchar_t> delimiters< ::std::set<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
 
-        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.postfix != NULL)
-            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.postfix;
+    template <typename T, typename TComp, typename TAllocator>
+    struct delimiters< ::std::multiset<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
 
-        return stream;
-    }
-} // namespace std
+    template <typename T, typename TComp, typename TAllocator>
+    const delimiters_values<char> delimiters< ::std::multiset<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
 
-// Prints a tuple to the stream using delimiters from delimiters<std::pair<tuple_dummy_t, tuple_dummy_t>>.
+    template <typename T, typename TComp, typename TAllocator>
+    struct delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
 
-namespace pretty_print
-{
-    struct tuple_dummy_t { }; // Just if you want special delimiters for tuples.
+    template <typename T, typename TComp, typename TAllocator>
+    const delimiters_values<wchar_t> delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
 
-    typedef std::pair<tuple_dummy_t, tuple_dummy_t> tuple_dummy_pair;
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
 
-    template<typename Tuple, size_t N, typename TChar, typename TCharTraits>
-    struct pretty_tuple_helper
-    {
-        static inline void print(::std::basic_ostream<TChar, TCharTraits> & stream, const Tuple & value)
-        {
-            pretty_tuple_helper<Tuple, N - 1, TChar, TCharTraits>::print(stream, value);
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    const delimiters_values<char> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
 
-            if (delimiters<tuple_dummy_pair, TChar>::values.delimiter != NULL)
-                stream << delimiters<tuple_dummy_pair, TChar>::values.delimiter;
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
 
-            stream << std::get<N - 1>(value);
-        }
-    };
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    const delimiters_values<wchar_t> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
+
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
+
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    const delimiters_values<char> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
+
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
+
+    template <typename T, typename THash, typename TEqual, typename TAllocator>
+    const delimiters_values<wchar_t> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
+
+
+    // Delimiters for pair and tuple
 
-    template<typename Tuple, typename TChar, typename TCharTraits>
-    struct pretty_tuple_helper<Tuple, 1, TChar, TCharTraits>
+    template <typename T1, typename T2> struct delimiters<std::pair<T1, T2>, char> { static const delimiters_values<char> values; };
+    template <typename T1, typename T2> const delimiters_values<char> delimiters<std::pair<T1, T2>, char>::values = { "(", ", ", ")" };
+    template <typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, wchar_t> { static const delimiters_values<wchar_t> values; };
+    template <typename T1, typename T2> const delimiters_values<wchar_t> delimiters< ::std::pair<T1, T2>, wchar_t>::values = { L"(", L", ", L")" };
+
+    template <typename ...Args> struct delimiters<std::tuple<Args...>, char> { static const delimiters_values<char> values; };
+    template <typename ...Args> const delimiters_values<char> delimiters<std::tuple<Args...>, char>::values = { "(", ", ", ")" };
+    template <typename ...Args> struct delimiters< ::std::tuple<Args...>, wchar_t> { static const delimiters_values<wchar_t> values; };
+    template <typename ...Args> const delimiters_values<wchar_t> delimiters< ::std::tuple<Args...>, wchar_t>::values = { L"(", L", ", L")" };
+
+
+    // Type-erasing helper class for easy use of custom delimiters.
+    // Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t, and MyDelims needs to be defined for TChar.
+    // Usage: "cout << pretty_print::custom_delims<MyDelims>(x)".
+
+    struct custom_delims_base
     {
-        static inline void print(::std::basic_ostream<TChar, TCharTraits> & stream, const Tuple & value)
-        {
-            stream << ::std::get<0>(value);
-        }
+        virtual ~custom_delims_base() { }
+        virtual std::ostream & stream(::std::ostream &) = 0;
+        virtual std::wostream & stream(::std::wostream &) = 0;
     };
-} // namespace pretty_print
 
+    template <typename T, typename Delims>
+    struct custom_delims_wrapper : custom_delims_base
+    {
+        custom_delims_wrapper(const T & t_) : t(t_) { }
 
-/* The following macros allow us to write "template <TUPLE_PARAMAS> std::tuple<TUPLE_ARGS>"
- * uniformly in C++0x compilers and in MS Visual Studio 2010.
- * Credits to STL: http://channel9.msdn.com/Shows/Going+Deep/C9-Lectures-Stephan-T-Lavavej-Advanced-STL-6-of-n
- */
+        std::ostream & stream(std::ostream & s)
+        {
+            return s << print_container_helper<T, char, std::char_traits<char>, Delims>(t);
+        }
 
-#if defined(_MSC_VER) && _MSC_VER == 1600
-    #define TUPLE_PARAMS \
-        typename T0, typename T1, typename T2, typename T3, typename T4, \
-        typename T5, typename T6, typename T7, typename T8, typename T9
-    #define TUPLE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
-#else
-    #define TUPLE_PARAMS typename ...Args
-    #define TUPLE_ARGS Args...
-#endif
+        std::wostream & stream(std::wostream & s)
+        {
+            return s << print_container_helper<T, wchar_t, std::char_traits<wchar_t>, Delims>(t);
+        }
 
+    private:
+        const T & t;
+    };
 
-namespace std
-{
-    template<typename TChar, typename TCharTraits, TUPLE_PARAMS>
-    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream, const tuple<TUPLE_ARGS> & value)
+    template <typename Delims>
+    struct custom_delims
     {
-        if (::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.prefix != NULL)
-            stream << ::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.prefix;
+        template <typename Container>
+        custom_delims(const Container & c) : base(new custom_delims_wrapper<Container, Delims>(c)) { }
 
-        ::pretty_print::pretty_tuple_helper<const tuple<TUPLE_ARGS> &, tuple_size<tuple<TUPLE_ARGS>>::value, TChar, TCharTraits>::print(stream, value);
-
-        if (::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.postfix != NULL)
-            stream << ::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.postfix;
+        std::unique_ptr<custom_delims_base> base;
+    };
 
-        return stream;
+    template <typename TChar, typename TCharTraits, typename Delims>
+    inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & s, const custom_delims<Delims> & p)
+    {
+        return p.base->stream(s);
     }
-} // namespace std
 
 
-// A wrapper for raw C-style arrays. Usage: int arr[] = { 1, 2, 4, 8, 16 };  std::cout << wrap_array(arr) << ...
+    // A wrapper for a C-style array given as pointer-plus-size.
+    // Usage: std::cout << pretty_print_array(arr, n) << std::endl;
 
-namespace pretty_print
-{
     template<typename T>
     struct array_wrapper_n
     {
@@ -414,20 +377,11 @@ namespace pretty_print
         const T * const _array;
         size_t _n;
     };
-} // namespace pretty_print
 
-template<typename T>
-inline pretty_print::array_wrapper_n<T> pretty_print_array(const T * const a, size_t n)
-{
-  return pretty_print::array_wrapper_n<T>(a, n);
-}
 
+    // A wrapper for hash-table based containers that offer local iterators to each bucket.
+    // Usage: std::cout << bucket_print(m, 4) << std::endl;  (Prints bucket 5 of container m.)
 
-// A wrapper for hash-table based containers that offer local iterators to each bucket.
-// Usage: std::cout << bucket_print(m, 4) << std::endl;  (Prints bucket 5 of container m.)
-
-namespace pretty_print
-{
     template <typename T>
     struct bucket_print_wrapper
     {
@@ -450,7 +404,17 @@ namespace pretty_print
         const T & m_map;
         const size_type n;
     };
-} // namespace pretty_print
+
+}   // namespace pretty_print
+
+
+// Global accessor functions for the convenience wrappers
+
+template<typename T>
+inline pretty_print::array_wrapper_n<T> pretty_print_array(const T * const a, size_t n)
+{
+    return pretty_print::array_wrapper_n<T>(a, n);
+}
 
 template <typename T> pretty_print::bucket_print_wrapper<T>
 bucket_print(const T & m, typename T::size_type n)
@@ -459,4 +423,22 @@ bucket_print(const T & m, typename T::size_type n)
 }
 
 
-#endif
+// Main magic entry point: An overload snuck into namespace std.
+// Can we do better?
+
+namespace std
+{
+    // Prints a container to the stream using default delimiters
+
+    template<typename T, typename TChar, typename TCharTraits>
+    inline typename enable_if< ::pretty_print::is_container<T>::value,
+                              basic_ostream<TChar, TCharTraits> &>::type
+    operator<<(basic_ostream<TChar, TCharTraits> & stream, const T & container)
+    {
+        return stream << ::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
+    }
+}
+
+
+
+#endif  // H_PRETTY_PRINT