diff --git a/docs/headers.md b/docs/headers.md
index 5f4eef1..033cd8a 100644
--- a/docs/headers.md
+++ b/docs/headers.md
@@ -91,16 +91,16 @@ See [SL.str.5: Use `std::byte` to refer to byte values that do not necessarily r
 ### Non-member functions
 
 ```cpp
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept;
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte operator<<(byte b, IntegerType shift) noexcept;
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept;
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte operator>>(byte b, IntegerType shift) noexcept;
 ```
 
@@ -134,7 +134,7 @@ constexpr byte operator~(byte b) noexcept;
 Bitwise negation of a `byte`. Flips all bits. Zeroes become ones, ones become zeroes.
 
 ```cpp
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr IntegerType to_integer(byte b) noexcept;
 ```
 
@@ -310,7 +310,7 @@ auto make_not_null(T&& t) noexcept;
 Creates a `gsl::not_null` object, deducing the target type from the type of the argument.
 
 ```cpp
-template <typename T, typename = std::enable_if_t<std::is_move_assignable<T>::value && std::is_move_constructible<T>::value>>
+template <typename T, std::enable_if_t<std::is_move_assignable<T>::value && std::is_move_constructible<T>::value, bool> = true>
 void swap(not_null<T>& a, not_null<T>& b);
 ```
 
diff --git a/include/gsl/byte b/include/gsl/byte
index 87d007e..72044bb 100644
--- a/include/gsl/byte
+++ b/include/gsl/byte
@@ -91,25 +91,25 @@ enum class byte_may_alias byte : unsigned char
 {
 };
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
 {
     return b = byte(static_cast<unsigned char>(b) << shift);
 }
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte operator<<(byte b, IntegerType shift) noexcept
 {
     return byte(static_cast<unsigned char>(b) << shift);
 }
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
 {
     return b = byte(static_cast<unsigned char>(b) >> shift);
 }
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr byte operator>>(byte b, IntegerType shift) noexcept
 {
     return byte(static_cast<unsigned char>(b) >> shift);
@@ -147,7 +147,7 @@ constexpr byte operator^(byte l, byte r) noexcept
 
 constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
 
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
 constexpr IntegerType to_integer(byte b) noexcept
 {
     return static_cast<IntegerType>(b);
diff --git a/include/gsl/pointers b/include/gsl/pointers
index cd07939..78d191c 100644
--- a/include/gsl/pointers
+++ b/include/gsl/pointers
@@ -145,7 +145,7 @@ private:
     T ptr_;
 };
 
-template <typename T, typename = std::enable_if_t<std::is_move_assignable<T>::value && std::is_move_constructible<T>::value>>
+template <typename T, std::enable_if_t<std::is_move_assignable<T>::value && std::is_move_constructible<T>::value, bool> = true>
 void swap(not_null<T>& a, not_null<T>& b)
 {
     a.swap(b);
diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp
index 0308992..b37b90a 100644
--- a/tests/byte_tests.cpp
+++ b/tests/byte_tests.cpp
@@ -136,36 +136,36 @@ template <typename U, typename = void>
 static constexpr bool LShiftCompilesFor = false;
 template <typename U>
 static constexpr bool LShiftCompilesFor<
-    U, std::void_t<decltype(gsl::operator<< <float, void>(declval<gsl::byte>(), declval<U>()))>> = true;
-static_assert(LShiftCompilesFor<float>, "LShiftCompilesFor<float>");
+    U, std::void_t<decltype(gsl::operator<< <float>(declval<gsl::byte>(), declval<U>()))>> = true;
+static_assert(!LShiftCompilesFor<float>, "!LShiftCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool RShiftCompilesFor = false;
 template <typename U>
 static constexpr bool RShiftCompilesFor<
-    U, std::void_t<decltype(gsl::operator>> <U, void>(declval<gsl::byte>(), declval<U>()))>> = true;
-static_assert(RShiftCompilesFor<float>, "RShiftCompilesFor<float>");
+    U, std::void_t<decltype(gsl::operator>> <U>(declval<gsl::byte>(), declval<U>()))>> = true;
+static_assert(!RShiftCompilesFor<float>, "!RShiftCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool LShiftAssignCompilesFor = false;
 template <typename U>
 static constexpr bool LShiftAssignCompilesFor<
-    U, std::void_t<decltype(gsl::operator<<= <U, void>(declval<gsl::byte&>(), declval<U>()))>> = true;
-static_assert(LShiftAssignCompilesFor<float>, "LShiftAssignCompilesFor<float>");
+    U, std::void_t<decltype(gsl::operator<<= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
+static_assert(!LShiftAssignCompilesFor<float>, "!LShiftAssignCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool RShiftAssignCompilesFor = false;
 template <typename U>
 static constexpr bool RShiftAssignCompilesFor<
-    U, std::void_t<decltype(gsl::operator>>= <U, void>(declval<gsl::byte&>(), declval<U>()))>> = true;
-static_assert(RShiftAssignCompilesFor<float>, "RShiftAssignCompilesFor<float>");
+    U, std::void_t<decltype(gsl::operator>>= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
+static_assert(!RShiftAssignCompilesFor<float>, "!RShiftAssignCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool ToIntegerCompilesFor = false;
 template <typename U>
-static constexpr bool ToIntegerCompilesFor<
-    U, std::void_t<decltype(gsl::to_integer<U, void>(gsl::byte{}))>> = true;
-static_assert(ToIntegerCompilesFor<float>, "ToIntegerCompilesFor<float>");
+static constexpr bool
+    ToIntegerCompilesFor<U, std::void_t<decltype(gsl::to_integer<U>(gsl::byte{}))>> = true;
+static_assert(!ToIntegerCompilesFor<float>, "!ToIntegerCompilesFor<float>");
 
 } // namespace
 
diff --git a/tests/pointers_tests.cpp b/tests/pointers_tests.cpp
index cbb476b..a88d209 100644
--- a/tests/pointers_tests.cpp
+++ b/tests/pointers_tests.cpp
@@ -33,10 +33,10 @@ struct NotMovable
 template <typename U, typename = void>
 static constexpr bool SwapCompilesFor = false;
 template <typename U>
-static constexpr bool SwapCompilesFor<
-    U, std::void_t<decltype(gsl::swap<U, void>(std::declval<gsl::not_null<U>&>(),
-                                               std::declval<gsl::not_null<U>&>()))>> =
-    true;
-static_assert(SwapCompilesFor<NotMovable>, "SwapCompilesFor<NotMovable>");
+static constexpr bool
+    SwapCompilesFor<U, std::void_t<decltype(gsl::swap<U>(std::declval<gsl::not_null<U>&>(),
+                                                         std::declval<gsl::not_null<U>&>()))>> =
+        true;
+static_assert(!SwapCompilesFor<NotMovable>, "!SwapCompilesFor<NotMovable>");
 
 } // namespace