How do I write an ADL-enabled trailing return type, or noexcept specification?

Question

Imagine I'm writing some container template or something. And the time comes to specialize std::swap for it. As a good citizen, I'll enable ADL by doing something like this:

template <typename T> void swap(my_template<T>& x, my_template<T>& y) {     using std::swap;     swap(x.something_that_is_a_T, y.something_that_is_a_T); } 

This is very neat and all. Until I want to add an exception specification. My swap is noexcept as long as the swap for T is noexcept. So, I'd be writing something like:

template <typename T> void swap(my_template<T>& x, my_template<T>& y)     noexcept(noexcept(swap(std::declval<T>(), std::declval<T>()))) 

Problem is, the swap in there needs to be the ADL-discovered swap or std::swap. How do I handle this?

Answer 1

I think I would move it into a separate namespace

namespace tricks {     using std::swap;      template <typename T, typename U>     void swap(T &t, U &u) noexcept(noexcept(swap(t, u))); }  template <typename T> void swap(my_template<T>& x, my_template<T>& y)   noexcept(noexcept(tricks::swap(std::declval<T>(), std::declval<T>())))  {     using std::swap;     swap(x.something_that_is_a_T, y.something_that_is_a_T); } 

Alternatively you can move the whole code up into tricks and delegate to there.