#include <functional>
#include <utility>
#include <type_traits>

template<typename L>
struct AtResult
{
   AtResult(L && l) : l{std::forward<L>(l)} {}
   
   template<typename T>
   operator T ()

template <class T>
std::make_signed_t<T> signed_cast(T x)
{
   static_assert(std::is_unsigned<T>::value);

   using signed_type = std::make_signed_t<T>;
   auto const min = std::numeric_limits<signed_type>::min();
   auto const max = std::numeric_limits<signed_type>::max();

   if (x <= max)
       return static_cast<signed_type>(x);
   if (x >= min)
       return static_cast<signed_type>(x-min)+min;

   // x=2^(n-1), min=-2^(n-1)+1, max=2^(n-1)-1
   // this is possible on platforms with signed magnitude
   // or ones complement integer representation
   throw std::range_error("signed_cast: impossible to convert");
}

int main(int argc, char** argv) {
   return signed_cast(-1u);
}