diff --git a/include/gsl/span b/include/gsl/span
index 8f73b1c..cffe043 100644
--- a/include/gsl/span
+++ b/include/gsl/span
@@ -105,19 +105,19 @@ namespace details
     };
 
     template <class T>
-    struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>>
+    struct is_std_array : is_std_array_oracle<std::remove_cv_t<T>>
     {
     };
 
     template <std::size_t From, std::size_t To>
     struct is_allowed_extent_conversion
-        : public std::integral_constant<bool, From == To || To == gsl::dynamic_extent>
+        : std::integral_constant<bool, From == To || To == gsl::dynamic_extent>
     {
     };
 
     template <class From, class To>
     struct is_allowed_element_type_conversion
-        : public std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
+        : std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
     {
     };
 
@@ -460,13 +460,12 @@ public:
         : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
     {}
 
-    // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement
+    // NB: the SFINAE here uses .data() as an incomplete/imperfect proxy for the requirement
     // on Container to be a contiguous sequence container.
     template <class Container,
               class = std::enable_if_t<
                   !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<pointer, typename Container::pointer>::value &&
                   std::is_convertible<decltype(std::declval<Container&>().data()), pointer>::value>>
     constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
     {}
@@ -671,7 +670,7 @@ private:
 
     // The rest is needed to remove unnecessary null check
     // in subspans and constructors from arrays
-    constexpr span(KnownNotNull ptr, size_type count) : storage_(ptr, count) {}
+    constexpr span(KnownNotNull ptr, size_type count) noexcept : storage_(ptr, count) {}
 
     template <std::size_t CallerExtent>
     class subspan_selector
@@ -680,7 +679,7 @@ private:
 
     template <std::size_t CallerExtent>
     constexpr span<element_type, dynamic_extent> make_subspan(size_type offset, size_type count,
-                                                              subspan_selector<CallerExtent>) const
+                                                              subspan_selector<CallerExtent>) const noexcept
     {
         const span<element_type, dynamic_extent> tmp(*this);
         return tmp.subspan(offset, count);
@@ -690,7 +689,7 @@ private:
     GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
     // clang-format on
     constexpr span<element_type, dynamic_extent>
-    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const
+    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
     {
         Expects(size() >= offset);
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3a6163c..38dbb85 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -153,6 +153,7 @@ function(add_gsl_test name)
 endfunction()
 
 add_gsl_test(span_tests)
+add_gsl_test(span_compatibility_tests)
 add_gsl_test(multi_span_tests)
 add_gsl_test(strided_span_tests)
 add_gsl_test(string_span_tests)
diff --git a/tests/span_compatibility_tests.cpp b/tests/span_compatibility_tests.cpp
new file mode 100644
index 0000000..cdf0bff
--- /dev/null
+++ b/tests/span_compatibility_tests.cpp
@@ -0,0 +1,1066 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/gsl_byte> // for byte
+#include <gsl/span>     // for span, span_iterator, operator==, operator!=
+
+#include <array>       // for array
+#include <cstddef>     // for ptrdiff_t
+#include <iterator>    // for reverse_iterator, operator-, operator==
+#include <type_traits> // for integral_constant<>::value, is_default_co...
+#include <utility>
+
+using namespace std;
+using namespace gsl;
+
+// Below are tests that verify the gsl interface support the same things as the std
+// Ranges and Concepts support need to be added later.
+
+struct Base
+{
+};
+struct Derived : Base
+{
+};
+static_assert(std::is_convertible<Derived*, Base*>::value, "std::is_convertible<Derived*, Base*>");
+static_assert(!std::is_convertible<Derived (*)[], Base (*)[]>::value,
+              "!std::is_convertible<Derived(*)[], Base(*)[]>");
+
+template <typename U, typename = void>
+constexpr bool AsWritableBytesCompilesFor = false;
+
+template <typename U>
+constexpr bool AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> =
+    true;
+
+TEST(span_test, std_span_compatibilty_assertion_tests)
+{
+    int arr[3]{10, 20, 30};
+    std::array<int, 3> stl{{100, 200, 300}};
+
+    {
+        gsl::span<int> sp_dyn;
+        assert(sp_dyn.data() == nullptr);
+        assert(sp_dyn.size() == 0);
+        assert(sp_dyn.empty());
+    }
+    {
+        gsl::span<int, 0> sp_zero;
+        assert(sp_zero.data() == nullptr);
+        assert(sp_zero.size() == 0);
+        assert(sp_zero.empty());
+
+        gsl::span<int> sp_dyn_a(arr, 3);
+        gsl::span<int> sp_dyn_b(begin(arr), 3);
+        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_dyn_b.data() == std::begin(arr));
+        EXPECT_TRUE(sp_dyn_a.size() == 3);
+        EXPECT_TRUE(sp_dyn_b.size() == 3);
+
+        gsl::span<int, 3> sp_three_a(arr, 3);
+        gsl::span<int, 3> sp_three_b(begin(arr), 3);
+        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_three_b.data() == std::begin(arr));
+        EXPECT_TRUE(sp_three_a.size() == 3);
+        EXPECT_TRUE(sp_three_b.size() == 3);
+
+        gsl::span<const int> sp_const_a(arr, 3);
+        gsl::span<const int> sp_const_b(begin(arr), 3);
+        EXPECT_TRUE(sp_const_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_b.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_a.size() == 3);
+        EXPECT_TRUE(sp_const_b.size() == 3);
+
+#if __cplusplus >= 201703l
+        gsl::span<const int> sp_const_c(std::as_const(arr), 3);
+        EXPECT_TRUE(sp_const_c.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_c.size() == 3);
+#endif // __cplusplus >= 201703l
+
+        gsl::span<const int> sp_const_d(cbegin(arr), 3);
+        EXPECT_TRUE(sp_const_d.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_d.size() == 3);
+    }
+    {
+        gsl::span<int> sp_dyn_a(begin(arr), std::end(arr));
+        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_dyn_a.size() == 3);
+
+        gsl::span<int, 3> sp_three_a(begin(arr), std::end(arr));
+        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_three_a.size() == 3);
+
+        gsl::span<const int> sp_const_a(begin(arr), std::end(arr));
+        gsl::span<const int> sp_const_b(begin(arr), std::cend(arr));
+        gsl::span<const int> sp_const_c(cbegin(arr), std::end(arr));
+        gsl::span<const int> sp_const_d(cbegin(arr), std::cend(arr));
+        EXPECT_TRUE(sp_const_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_b.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_c.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_d.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_a.size() == 3);
+        EXPECT_TRUE(sp_const_b.size() == 3);
+        EXPECT_TRUE(sp_const_c.size() == 3);
+        EXPECT_TRUE(sp_const_d.size() == 3);
+    }
+    {
+        gsl::span<int> sp_dyn_a(arr);
+        gsl::span<int> sp_dyn_b(stl);
+        gsl::span<int> sp_dyn_c{stl};
+        gsl::span<const int> sp_dyn_d{stl};
+        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_dyn_b.data() == stl.data());
+        EXPECT_TRUE(sp_dyn_a.size() == 3);
+        EXPECT_TRUE(sp_dyn_b.size() == 3);
+
+        gsl::span<int, 3> sp_three_a(arr);
+        gsl::span<int, 3> sp_three_b(stl);
+        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_three_b.data() == stl.data());
+        EXPECT_TRUE(sp_three_a.size() == 3);
+        EXPECT_TRUE(sp_three_b.size() == 3);
+
+        gsl::span<const int> sp_const_w(arr);
+        gsl::span<const int> sp_const_y(stl);
+        EXPECT_TRUE(sp_const_w.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_y.data() == stl.data());
+        EXPECT_TRUE(sp_const_w.size() == 3);
+        EXPECT_TRUE(sp_const_y.size() == 3);
+
+#if __cplusplus >= 201703l
+        gsl::span<const int> sp_const_x(std::as_const(arr));
+        EXPECT_TRUE(sp_const_x.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_x.size() == 3);
+
+        gsl::span<const int> sp_const_z(std::as_const(stl));
+        EXPECT_TRUE(sp_const_z.data() == stl.data());
+        EXPECT_TRUE(sp_const_z.size() == 3);
+#endif // __cplusplus >= 201703l
+    }
+    {
+        const gsl::span<int> orig_dyn(arr);
+        const gsl::span<int, 3> orig_three(arr);
+        const gsl::span<const int> orig_const_dyn(arr);
+        const gsl::span<const int, 3> orig_const_three(arr);
+
+        gsl::span<int> sp_a(orig_dyn);
+        gsl::span<int> sp_b(orig_three);
+
+        gsl::span<int, 3> sp_c(orig_three);
+
+        gsl::span<const int> sp_d(orig_dyn);
+        gsl::span<const int> sp_e(orig_three);
+        gsl::span<const int> sp_f(orig_const_dyn);
+        gsl::span<const int> sp_g(orig_const_three);
+
+        gsl::span<const int, 3> sp_h(orig_three);
+        gsl::span<const int, 3> sp_i(orig_const_three);
+
+        EXPECT_TRUE(sp_a.data() == std::begin(arr));
+        EXPECT_TRUE(sp_b.data() == std::begin(arr));
+        EXPECT_TRUE(sp_c.data() == std::begin(arr));
+        EXPECT_TRUE(sp_d.data() == std::begin(arr));
+        EXPECT_TRUE(sp_e.data() == std::begin(arr));
+        EXPECT_TRUE(sp_f.data() == std::begin(arr));
+        EXPECT_TRUE(sp_g.data() == std::begin(arr));
+        EXPECT_TRUE(sp_h.data() == std::begin(arr));
+        EXPECT_TRUE(sp_i.data() == std::begin(arr));
+        EXPECT_TRUE(sp_a.size() == 3);
+        EXPECT_TRUE(sp_b.size() == 3);
+        EXPECT_TRUE(sp_c.size() == 3);
+        EXPECT_TRUE(sp_d.size() == 3);
+        EXPECT_TRUE(sp_e.size() == 3);
+        EXPECT_TRUE(sp_f.size() == 3);
+        EXPECT_TRUE(sp_g.size() == 3);
+        EXPECT_TRUE(sp_h.size() == 3);
+        EXPECT_TRUE(sp_i.size() == 3);
+    }
+    {
+        gsl::span<int> sp_dyn(arr);
+        gsl::span<int, 3> sp_three(arr);
+        gsl::span<const int> sp_const_dyn(arr);
+        gsl::span<const int, 3> sp_const_three(arr);
+
+        EXPECT_TRUE(sp_dyn.data() == std::begin(arr));
+        EXPECT_TRUE(sp_three.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_dyn.data() == std::begin(arr));
+        EXPECT_TRUE(sp_const_three.data() == std::begin(arr));
+        EXPECT_TRUE(sp_dyn.size() == 3);
+        EXPECT_TRUE(sp_three.size() == 3);
+        EXPECT_TRUE(sp_const_dyn.size() == 3);
+        EXPECT_TRUE(sp_const_three.size() == 3);
+
+        int other[4]{12, 34, 56, 78};
+
+        sp_dyn = gsl::span<int>{other};
+        sp_three = gsl::span<int, 3>{stl};
+        sp_const_dyn = gsl::span<const int>{other};
+        sp_const_three = gsl::span<const int, 3>{stl};
+
+        EXPECT_TRUE(sp_dyn.data() == std::begin(other));
+        EXPECT_TRUE(sp_three.data() == stl.data());
+        EXPECT_TRUE(sp_const_dyn.data() == std::begin(other));
+        EXPECT_TRUE(sp_const_three.data() == stl.data());
+        EXPECT_TRUE(sp_dyn.size() == 4);
+        EXPECT_TRUE(sp_three.size() == 3);
+        EXPECT_TRUE(sp_const_dyn.size() == 4);
+        EXPECT_TRUE(sp_const_three.size() == 3);
+    }
+    {
+        gsl::span<int>::iterator it_dyn{};
+
+        {
+            gsl::span<int> sp_dyn(arr);
+            it_dyn = sp_dyn.begin();
+        }
+
+        EXPECT_TRUE(*it_dyn == arr[0]);
+        EXPECT_TRUE(it_dyn[2] == arr[2]);
+
+        gsl::span<int, 3>::iterator it_three{};
+
+        {
+            gsl::span<int, 3> sp_three(stl);
+            it_three = sp_three.begin();
+        }
+
+        EXPECT_TRUE(*it_three == stl[0]);
+        EXPECT_TRUE(it_three[2] == stl[2]);
+    }
+
+    {
+        int sequence[9]{10, 20, 30, 40, 50, 60, 70, 80, 90};
+
+        const gsl::span<int> sp_dyn(sequence);
+        const gsl::span<int, 9> sp_nine(sequence);
+
+        auto first_3 = sp_dyn.first<3>();
+        auto first_4 = sp_nine.first<4>();
+        auto first_5 = sp_dyn.first(5);
+        auto first_6 = sp_nine.first(6);
+        static_assert(noexcept(sp_dyn.first<3>()), "noexcept(sp_dyn.first<3>())");   // strengthened
+        static_assert(noexcept(sp_nine.first<4>()), "noexcept(sp_nine.first<4>())"); // strengthened
+        static_assert(noexcept(sp_dyn.first(5)), "noexcept(sp_dyn.first(5))");       // strengthened
+        static_assert(noexcept(sp_nine.first(6)), "noexcept(sp_nine.first(6))");     // strengthened
+        static_assert(is_same<decltype(first_3), gsl::span<int, 3>>::value,
+                      "is_same<decltype(first_3), gsl::span<int, 3>>::value");
+        static_assert(is_same<decltype(first_4), gsl::span<int, 4>>::value,
+                      "is_same<decltype(first_4), gsl::span<int, 4>>::value");
+        static_assert(is_same<decltype(first_5), gsl::span<int>>::value,
+                      "is_same<decltype(first_5), gsl::span<int>>::value");
+        static_assert(is_same<decltype(first_6), gsl::span<int>>::value,
+                      "is_same<decltype(first_6), gsl::span<int>>::value");
+        EXPECT_TRUE(first_3.data() == std::begin(sequence));
+        EXPECT_TRUE(first_4.data() == std::begin(sequence));
+        EXPECT_TRUE(first_5.data() == std::begin(sequence));
+        EXPECT_TRUE(first_6.data() == std::begin(sequence));
+        EXPECT_TRUE(first_3.size() == 3);
+        EXPECT_TRUE(first_4.size() == 4);
+        EXPECT_TRUE(first_5.size() == 5);
+        EXPECT_TRUE(first_6.size() == 6);
+
+        auto last_3 = sp_dyn.last<3>();
+        auto last_4 = sp_nine.last<4>();
+        auto last_5 = sp_dyn.last(5);
+        auto last_6 = sp_nine.last(6);
+        static_assert(noexcept(sp_dyn.last<3>()), "noexcept(sp_dyn.last<3>())");   // strengthened
+        static_assert(noexcept(sp_nine.last<4>()), "noexcept(sp_nine.last<4>())"); // strengthened
+        static_assert(noexcept(sp_dyn.last(5)), "noexcept(sp_dyn.last(5))");       // strengthened
+        static_assert(noexcept(sp_nine.last(6)), "noexcept(sp_nine.last(6))");     // strengthened
+        static_assert(is_same<decltype(last_3), gsl::span<int, 3>>::value,
+                      "is_same<decltype(last_3), gsl::span<int, 3>>::value");
+        static_assert(is_same<decltype(last_4), gsl::span<int, 4>>::value,
+                      "is_same<decltype(last_4), gsl::span<int, 4>>::value");
+        static_assert(is_same<decltype(last_5), gsl::span<int>>::value,
+                      "is_same<decltype(last_5), gsl::span<int>>::value");
+        static_assert(is_same<decltype(last_6), gsl::span<int>>::value,
+                      "is_same<decltype(last_6), gsl::span<int>>::value");
+        EXPECT_TRUE(last_3.data() == std::begin(sequence) + 6);
+        EXPECT_TRUE(last_4.data() == std::begin(sequence) + 5);
+        EXPECT_TRUE(last_5.data() == std::begin(sequence) + 4);
+        EXPECT_TRUE(last_6.data() == std::begin(sequence) + 3);
+        EXPECT_TRUE(last_3.size() == 3);
+        EXPECT_TRUE(last_4.size() == 4);
+        EXPECT_TRUE(last_5.size() == 5);
+        EXPECT_TRUE(last_6.size() == 6);
+
+        auto offset_3 = sp_dyn.subspan<3>();
+        auto offset_4 = sp_nine.subspan<4>();
+        auto offset_5 = sp_dyn.subspan(5);
+        auto offset_6 = sp_nine.subspan(6);
+        static_assert(noexcept(sp_dyn.subspan<3>()),
+                      "noexcept(sp_dyn.subspan<3>())"); // strengthened
+        static_assert(noexcept(sp_nine.subspan<4>()),
+                      "noexcept(sp_nine.subspan<4>())");                             // strengthened
+        static_assert(noexcept(sp_dyn.subspan(5)), "noexcept(sp_dyn.subspan(5))");   // strengthened
+        static_assert(noexcept(sp_nine.subspan(6)), "noexcept(sp_nine.subspan(6))"); // strengthened
+        static_assert(is_same<decltype(offset_3), gsl::span<int>>::value,
+                      "is_same<decltype(offset_3), gsl::span<int>>::value");
+        static_assert(is_same<decltype(offset_4), gsl::span<int, 5>>::value,
+                      "is_same<decltype(offset_4), gsl::span<int, 5>>::value");
+        static_assert(is_same<decltype(offset_5), gsl::span<int>>::value,
+                      "is_same<decltype(offset_5), gsl::span<int>>::value");
+        static_assert(is_same<decltype(offset_6), gsl::span<int>>::value,
+                      "is_same<decltype(offset_6), gsl::span<int>>::value");
+        EXPECT_TRUE(offset_3.data() == std::begin(sequence) + 3);
+        EXPECT_TRUE(offset_4.data() == std::begin(sequence) + 4);
+        EXPECT_TRUE(offset_5.data() == std::begin(sequence) + 5);
+        EXPECT_TRUE(offset_6.data() == std::begin(sequence) + 6);
+        EXPECT_TRUE(offset_3.size() == 6);
+        EXPECT_TRUE(offset_4.size() == 5);
+        EXPECT_TRUE(offset_5.size() == 4);
+        EXPECT_TRUE(offset_6.size() == 3);
+
+        auto subspan_3 = sp_dyn.subspan<3, 2>();
+        auto subspan_4 = sp_nine.subspan<4, 2>();
+        auto subspan_5 = sp_dyn.subspan(5, 2);
+        auto subspan_6 = sp_nine.subspan(6, 2);
+        static_assert(noexcept(sp_dyn.subspan<3, 2>()),
+                      "noexcept(sp_dyn.subspan<3, 2>())"); // strengthened
+        static_assert(noexcept(sp_nine.subspan<4, 2>()),
+                      "noexcept(sp_nine.subspan<4, 2>())"); // strengthened
+        static_assert(noexcept(sp_dyn.subspan(5, 2)),
+                      "noexcept(sp_dyn.subspan(5, 2))"); // strengthened
+        static_assert(noexcept(sp_nine.subspan(6, 2)),
+                      "noexcept(sp_nine.subspan(6, 2))"); // strengthened
+        static_assert(is_same<decltype(subspan_3), gsl::span<int, 2>>::value,
+                      "is_same<decltype(subspan_3), gsl::span<int, 2>>::value");
+        static_assert(is_same<decltype(subspan_4), gsl::span<int, 2>>::value,
+                      "is_same<decltype(subspan_4), gsl::span<int, 2>>::value");
+        static_assert(is_same<decltype(subspan_5), gsl::span<int>>::value,
+                      "is_same<decltype(subspan_5), gsl::span<int>>::value");
+        static_assert(is_same<decltype(subspan_6), gsl::span<int>>::value,
+                      "is_same<decltype(subspan_6), gsl::span<int>>::value");
+        EXPECT_TRUE(subspan_3.data() == std::begin(sequence) + 3);
+        EXPECT_TRUE(subspan_4.data() == std::begin(sequence) + 4);
+        EXPECT_TRUE(subspan_5.data() == std::begin(sequence) + 5);
+        EXPECT_TRUE(subspan_6.data() == std::begin(sequence) + 6);
+        EXPECT_TRUE(subspan_3.size() == 2);
+        EXPECT_TRUE(subspan_4.size() == 2);
+        EXPECT_TRUE(subspan_5.size() == 2);
+        EXPECT_TRUE(subspan_6.size() == 2);
+
+        static_assert(noexcept(sp_dyn.size()), "noexcept(sp_dyn.size())");
+        static_assert(noexcept(sp_dyn.size_bytes()), "noexcept(sp_dyn.size_bytes())");
+        static_assert(noexcept(sp_dyn.empty()), "noexcept(sp_dyn.empty())");
+        static_assert(noexcept(sp_dyn[0]), "noexcept(sp_dyn[0])");           // strengthened
+        static_assert(noexcept(sp_dyn.front()), "noexcept(sp_dyn.front())"); // strengthened
+        static_assert(noexcept(sp_dyn.back()), "noexcept(sp_dyn.back())");   // strengthened
+        static_assert(noexcept(sp_dyn.data()), "noexcept(sp_dyn.data())");
+        static_assert(noexcept(sp_dyn.begin()), "noexcept(sp_dyn.begin())");
+        static_assert(noexcept(sp_dyn.end()), "noexcept(sp_dyn.end())");
+        static_assert(noexcept(sp_dyn.cbegin()), "noexcept(sp_dyn.cbegin())");
+        static_assert(noexcept(sp_dyn.cend()), "noexcept(sp_dyn.cend())");
+        static_assert(noexcept(sp_dyn.rbegin()), "noexcept(sp_dyn.rbegin())");
+        static_assert(noexcept(sp_dyn.rend()), "noexcept(sp_dyn.rend())");
+        static_assert(noexcept(sp_dyn.crbegin()), "noexcept(sp_dyn.crbegin())");
+        static_assert(noexcept(sp_dyn.crend()), "noexcept(sp_dyn.crend())");
+
+        static_assert(noexcept(sp_nine.size()), "noexcept(sp_nine.size())");
+        static_assert(noexcept(sp_nine.size_bytes()), "noexcept(sp_nine.size_bytes())");
+        static_assert(noexcept(sp_nine.empty()), "noexcept(sp_nine.empty())");
+        static_assert(noexcept(sp_nine[0]), "noexcept(sp_nine[0])");           // strengthened
+        static_assert(noexcept(sp_nine.front()), "noexcept(sp_nine.front())"); // strengthened
+        static_assert(noexcept(sp_nine.back()), "noexcept(sp_nine.back())");   // strengthened
+        static_assert(noexcept(sp_nine.data()), "noexcept(sp_nine.data())");
+        static_assert(noexcept(sp_nine.begin()), "noexcept(sp_nine.begin())");
+        static_assert(noexcept(sp_nine.end()), "noexcept(sp_nine.end())");
+        static_assert(noexcept(sp_nine.cbegin()), "noexcept(sp_nine.cbegin())");
+        static_assert(noexcept(sp_nine.cend()), "noexcept(sp_nine.cend())");
+        static_assert(noexcept(sp_nine.rbegin()), "noexcept(sp_nine.rbegin())");
+        static_assert(noexcept(sp_nine.rend()), "noexcept(sp_nine.rend())");
+        static_assert(noexcept(sp_nine.crbegin()), "noexcept(sp_nine.crbegin())");
+        static_assert(noexcept(sp_nine.crend()), "noexcept(sp_nine.crend())");
+
+        EXPECT_TRUE(sp_dyn.size() == 9);
+        EXPECT_TRUE(sp_nine.size() == 9);
+
+        EXPECT_TRUE(sp_dyn.size_bytes() == 9 * sizeof(int));
+        EXPECT_TRUE(sp_nine.size_bytes() == 9 * sizeof(int));
+
+        EXPECT_TRUE(!sp_dyn.empty());
+        EXPECT_TRUE(!sp_nine.empty());
+
+        EXPECT_TRUE(sp_dyn[0] == 10);
+        EXPECT_TRUE(sp_nine[0] == 10);
+        EXPECT_TRUE(sp_dyn[8] == 90);
+        EXPECT_TRUE(sp_nine[8] == 90);
+
+        EXPECT_TRUE(sp_dyn.front() == 10);
+        EXPECT_TRUE(sp_nine.front() == 10);
+
+        EXPECT_TRUE(sp_dyn.back() == 90);
+        EXPECT_TRUE(sp_nine.back() == 90);
+
+        EXPECT_TRUE(&sp_dyn.front() == std::begin(sequence));
+        EXPECT_TRUE(&sp_nine.front() == std::begin(sequence));
+        EXPECT_TRUE(&sp_dyn[4] == std::begin(sequence) + 4);
+        EXPECT_TRUE(&sp_nine[4] == std::begin(sequence) + 4);
+        EXPECT_TRUE(&sp_dyn.back() == std::begin(sequence) + 8);
+        EXPECT_TRUE(&sp_nine.back() == std::begin(sequence) + 8);
+
+        EXPECT_TRUE(sp_dyn.data() == std::begin(sequence));
+        EXPECT_TRUE(sp_nine.data() == std::begin(sequence));
+
+        EXPECT_TRUE(*sp_dyn.begin() == 10);
+        EXPECT_TRUE(*sp_nine.begin() == 10);
+
+        EXPECT_TRUE(sp_dyn.end()[-2] == 80);
+        EXPECT_TRUE(sp_nine.end()[-2] == 80);
+
+        EXPECT_TRUE(*sp_dyn.cbegin() == 10);
+        EXPECT_TRUE(*sp_nine.cbegin() == 10);
+
+        EXPECT_TRUE(sp_dyn.cend()[-2] == 80);
+        EXPECT_TRUE(sp_nine.cend()[-2] == 80);
+
+        EXPECT_TRUE(*sp_dyn.rbegin() == 90);
+        EXPECT_TRUE(*sp_nine.rbegin() == 90);
+
+        EXPECT_TRUE(sp_dyn.rend()[-2] == 20);
+        EXPECT_TRUE(sp_nine.rend()[-2] == 20);
+
+        EXPECT_TRUE(*sp_dyn.crbegin() == 90);
+        EXPECT_TRUE(*sp_nine.crbegin() == 90);
+
+        EXPECT_TRUE(sp_dyn.crend()[-2] == 20);
+        EXPECT_TRUE(sp_nine.crend()[-2] == 20);
+
+        static_assert(is_same<decltype(sp_dyn.begin()), gsl::span<int>::iterator>::value,
+                      "is_same<decltype(sp_dyn.begin()), gsl::span<int>::iterator>::value");
+        static_assert(is_same<decltype(sp_nine.begin()), gsl::span<int, 9>::iterator>::value,
+                      "is_same<decltype(sp_nine.begin()), gsl::span<int, 9>::iterator>::value");
+        static_assert(is_same<decltype(sp_dyn.end()), gsl::span<int>::iterator>::value,
+                      "is_same<decltype(sp_dyn.end()), gsl::span<int>::iterator>::value");
+        static_assert(is_same<decltype(sp_nine.end()), gsl::span<int, 9>::iterator>::value,
+                      "is_same<decltype(sp_nine.end()), gsl::span<int, 9>::iterator>::value");
+        static_assert(is_same<decltype(sp_dyn.cbegin()), gsl::span<int>::const_iterator>::value,
+                      "is_same<decltype(sp_dyn.cbegin()), gsl::span<int>::const_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.cbegin()), gsl::span<int, 9>::const_iterator>::value,
+            "is_same<decltype(sp_nine.cbegin()), gsl::span<int, 9>::const_iterator>::value");
+        static_assert(is_same<decltype(sp_dyn.cend()), gsl::span<int>::const_iterator>::value,
+                      "is_same<decltype(sp_dyn.cend()), gsl::span<int>::const_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.cend()), gsl::span<int, 9>::const_iterator>::value,
+            "is_same<decltype(sp_nine.cend()), gsl::span<int, 9>::const_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_dyn.rbegin()), gsl::span<int>::reverse_iterator>::value,
+            "is_same<decltype(sp_dyn.rbegin()), gsl::span<int>::reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.rbegin()), gsl::span<int, 9>::reverse_iterator>::value,
+            "is_same<decltype(sp_nine.rbegin()), gsl::span<int, 9>::reverse_iterator>::value");
+        static_assert(is_same<decltype(sp_dyn.rend()), gsl::span<int>::reverse_iterator>::value,
+                      "is_same<decltype(sp_dyn.rend()), gsl::span<int>::reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.rend()), gsl::span<int, 9>::reverse_iterator>::value,
+            "is_same<decltype(sp_nine.rend()), gsl::span<int, 9>::reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_dyn.crbegin()), gsl::span<int>::const_reverse_iterator>::value,
+            "is_same<decltype(sp_dyn.crbegin()), gsl::span<int>::const_reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.crbegin()), gsl::span<int, 9>::const_reverse_iterator>::value,
+            "is_same<decltype(sp_nine.crbegin()), gsl::span<int, "
+            "9>::const_reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_dyn.crend()), gsl::span<int>::const_reverse_iterator>::value,
+            "is_same<decltype(sp_dyn.crend()), gsl::span<int>::const_reverse_iterator>::value");
+        static_assert(
+            is_same<decltype(sp_nine.crend()), gsl::span<int, 9>::const_reverse_iterator>::value,
+            "is_same<decltype(sp_nine.crend()), gsl::span<int, 9>::const_reverse_iterator>::value");
+    }
+    {
+        int sequence[9]{10, 20, 30, 40, 50, 60, 70, 80, 90};
+
+        constexpr size_t SizeBytes = sizeof(sequence);
+
+        const gsl::span<int> sp_dyn(sequence);
+        const gsl::span<int, 9> sp_nine(sequence);
+        const gsl::span<const int> sp_const_dyn(sequence);
+        const gsl::span<const int, 9> sp_const_nine(sequence);
+
+        static_assert(noexcept(as_bytes(sp_dyn)), "noexcept(as_bytes(sp_dyn))");
+        static_assert(noexcept(as_bytes(sp_nine)), "noexcept(as_bytes(sp_nine))");
+        static_assert(noexcept(as_bytes(sp_const_dyn)), "noexcept(as_bytes(sp_const_dyn))");
+        static_assert(noexcept(as_bytes(sp_const_nine)), "noexcept(as_bytes(sp_const_nine))");
+        static_assert(noexcept(as_writable_bytes(sp_dyn)), "noexcept(as_writable_bytes(sp_dyn))");
+        static_assert(noexcept(as_writable_bytes(sp_nine)), "noexcept(as_writable_bytes(sp_nine))");
+
+        static_assert(AsWritableBytesCompilesFor<gsl::span<int>>,
+                      "AsWritableBytesCompilesFor<gsl::span<int>>");
+        static_assert(AsWritableBytesCompilesFor<gsl::span<int, 9>>,
+                      "AsWritableBytesCompilesFor<gsl::span<int, 9>>");
+        static_assert(!AsWritableBytesCompilesFor<gsl::span<const int>>,
+                      "!AsWritableBytesCompilesFor<gsl::span<const int>>");
+        static_assert(!AsWritableBytesCompilesFor<gsl::span<const int, 9>>,
+                      "!AsWritableBytesCompilesFor<gsl::span<const int, 9>>");
+
+        auto sp_1 = as_bytes(sp_dyn);
+        auto sp_2 = as_bytes(sp_nine);
+        auto sp_3 = as_bytes(sp_const_dyn);
+        auto sp_4 = as_bytes(sp_const_nine);
+        auto sp_5 = as_writable_bytes(sp_dyn);
+        auto sp_6 = as_writable_bytes(sp_nine);
+
+        static_assert(is_same<decltype(sp_1), gsl::span<const byte>>::value,
+                      "is_same<decltype(sp_1), gsl::span<const byte>>::value");
+        static_assert(is_same<decltype(sp_2), gsl::span<const byte, SizeBytes>>::value,
+                      "is_same<decltype(sp_2), gsl::span<const byte, SizeBytes>>::value");
+        static_assert(is_same<decltype(sp_3), gsl::span<const byte>>::value,
+                      "is_same<decltype(sp_3), gsl::span<const byte>>::value");
+        static_assert(is_same<decltype(sp_4), gsl::span<const byte, SizeBytes>>::value,
+                      "is_same<decltype(sp_4), gsl::span<const byte, SizeBytes>>::value");
+        static_assert(is_same<decltype(sp_5), gsl::span<byte>>::value,
+                      "is_same<decltype(sp_5), gsl::span<byte>>::value");
+        static_assert(is_same<decltype(sp_6), gsl::span<byte, SizeBytes>>::value,
+                      "is_same<decltype(sp_6), gsl::span<byte, SizeBytes>>::value");
+
+        EXPECT_TRUE(sp_1.data() == reinterpret_cast<const byte*>(begin(sequence)));
+        EXPECT_TRUE(sp_2.data() == reinterpret_cast<const byte*>(begin(sequence)));
+        EXPECT_TRUE(sp_3.data() == reinterpret_cast<const byte*>(begin(sequence)));
+        EXPECT_TRUE(sp_4.data() == reinterpret_cast<const byte*>(begin(sequence)));
+        EXPECT_TRUE(sp_5.data() == reinterpret_cast<byte*>(begin(sequence)));
+        EXPECT_TRUE(sp_6.data() == reinterpret_cast<byte*>(begin(sequence)));
+
+        EXPECT_TRUE(sp_1.size() == SizeBytes);
+        EXPECT_TRUE(sp_2.size() == SizeBytes);
+        EXPECT_TRUE(sp_3.size() == SizeBytes);
+        EXPECT_TRUE(sp_4.size() == SizeBytes);
+        EXPECT_TRUE(sp_5.size() == SizeBytes);
+        EXPECT_TRUE(sp_6.size() == SizeBytes);
+    }
+}
+
+// assertions for span's definition
+static_assert(std::is_same<decltype(gsl::dynamic_extent), const std::size_t>::value,
+              "gsl::dynamic_extent must be respresented as std::size_t");
+static_assert(gsl::dynamic_extent == static_cast<std::size_t>(-1),
+              "gsl::dynamic_extent must be defined as the max value of std::size_t");
+
+static_assert(std::is_same<decltype(gsl::span<int>::extent), const std::size_t>::value,
+              "Ensure that the type of  gsl::span::extent is std::size_t");
+static_assert(gsl::span<int>::extent == gsl::dynamic_extent,
+              "gsl::span<int>::extent should be equivalent to gsl::dynamic_extent");
+
+static_assert(std::is_same<decltype(gsl::span<int, 3>::extent), const std::size_t>::value,
+              "Ensure that the type of gsl::span::extent is std::size_t");
+static_assert(gsl::span<int, 3>::extent == 3, "Ensure that span<int, 3>::extent is equal to 3");
+
+static_assert(std::is_same<gsl::span<int>::element_type, int>::value,
+              "span<int>::element_type should be int");
+static_assert(std::is_same<gsl::span<int>::value_type, int>::value,
+              "span<int>::value_type should be int");
+static_assert(std::is_same<gsl::span<int>::size_type, std::size_t>::value,
+              "span<int>::size_type should be std::size_t");
+static_assert(std::is_same<gsl::span<int>::difference_type, ptrdiff_t>::value,
+              "span<int>::difference_type should be std::ptrdiff_t");
+static_assert(std::is_same<gsl::span<int>::pointer, int*>::value,
+              "span<int>::pointer should be int*");
+static_assert(std::is_same<gsl::span<int>::const_pointer, const int*>::value,
+              "span<int>::const_pointer should be const int*");
+static_assert(std::is_same<gsl::span<int>::reference, int&>::value,
+              "span<int>::reference should be int&");
+static_assert(std::is_same<gsl::span<int>::const_reference, const int&>::value,
+              "span<int>::const_reference should be const int&");
+
+static_assert(std::is_same<gsl::span<int, 3>::element_type, int>::value,
+              "span<int, 3>::element_type should be int");
+static_assert(std::is_same<gsl::span<int, 3>::value_type, int>::value,
+              "span<int, 3>::value_type should be int");
+static_assert(std::is_same<gsl::span<int, 3>::size_type, std::size_t>::value,
+              "span<int, 3>::size_type should be std::size_t");
+static_assert(std::is_same<gsl::span<int, 3>::difference_type, ptrdiff_t>::value,
+              "span<int, 3>::difference_type should be std::ptrdiff_t");
+static_assert(std::is_same<gsl::span<int, 3>::pointer, int*>::value,
+              "span<int, 3>::pointer should be int*");
+static_assert(std::is_same<gsl::span<int, 3>::const_pointer, const int*>::value,
+              "span<int, 3>::const_pointer should be const int*");
+static_assert(std::is_same<gsl::span<int, 3>::reference, int&>::value,
+              "span<int, 3>::reference should be int&");
+static_assert(std::is_same<gsl::span<int, 3>::const_reference, const int&>::value,
+              "span<int, 3>::const_reference should be const int&");
+
+static_assert(std::is_same<gsl::span<const int>::element_type, const int>::value,
+              "span<const int>::element_type should be const int");
+static_assert(std::is_same<gsl::span<const int>::value_type, int>::value,
+              "span<const int>::value_type should be int");
+static_assert(std::is_same<gsl::span<const int>::size_type, std::size_t>::value,
+              "span<const int>::size_type should be size_t");
+static_assert(std::is_same<gsl::span<const int>::difference_type, ptrdiff_t>::value,
+              "span<const int>::difference_type should be ptrdiff_t");
+static_assert(std::is_same<gsl::span<const int>::pointer, const int*>::value,
+              "span<const int>::pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int>::const_pointer, const int*>::value,
+              "span<const int>::const_pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int>::reference, const int&>::value,
+              "span<const int>::reference should be const int&");
+static_assert(std::is_same<gsl::span<const int>::const_reference, const int&>::value,
+              "span<const int>::const_reference should be const int&");
+
+static_assert(std::is_same<gsl::span<const int, 3>::element_type, const int>::value,
+              "span<const int, 3>::element_type should be const int");
+static_assert(std::is_same<gsl::span<const int, 3>::value_type, int>::value,
+              "span<const int, 3>::value_type should be int");
+static_assert(std::is_same<gsl::span<const int, 3>::size_type, std::size_t>::value,
+              "span<const int, 3>::size_type should be size_t");
+static_assert(std::is_same<gsl::span<const int, 3>::difference_type, ptrdiff_t>::value,
+              "span<const int, 3>::difference_type should be ptrdiff_t");
+static_assert(std::is_same<gsl::span<const int, 3>::pointer, const int*>::value,
+              "span<const int, 3>::pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int, 3>::const_pointer, const int*>::value,
+              "span<const int, 3>::const_pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int, 3>::reference, const int&>::value,
+              "span<const int, 3>::reference should be const int&");
+static_assert(std::is_same<gsl::span<const int, 3>::const_reference, const int&>::value,
+              "span<const int, 3>::const_reference should be const int&");
+
+// assertions for span_iterator
+static_assert(std::is_same<std::iterator_traits<gsl::span<int>::iterator>::pointer, int*>::value,
+              "span<int>::iterator's pointer should be int*");
+static_assert(
+    std::is_same<std::iterator_traits<gsl::span<int>::const_iterator>::pointer, const int*>::value,
+    "span<int>::const_iterator's pointer should be const int*");
+static_assert(
+    std::is_same<gsl::span<int>::reverse_iterator,
+                 std::reverse_iterator<gsl::span<int>::iterator>>::value,
+    "span<int>::reverse_iterator should equal std::reverse_iterator<span<int>::iterator>");
+static_assert(std::is_same<gsl::span<int>::const_reverse_iterator,
+                           std::reverse_iterator<gsl::span<int>::const_iterator>>::value,
+              "span<int>::const_reverse_iterator should equal "
+              "std::reverse_iterator<span<int>::const_iterator>");
+
+static_assert(std::is_same<std::iterator_traits<gsl::span<int, 3>::iterator>::pointer, int*>::value,
+              "span<int, 3>::iterator's pointer should be int*");
+static_assert(std::is_same<std::iterator_traits<gsl::span<int, 3>::const_iterator>::pointer,
+                           const int*>::value,
+              "span<int, 3>::const_iterator's pointer should be const int*");
+static_assert(
+    std::is_same<gsl::span<int, 3>::reverse_iterator,
+                 std::reverse_iterator<gsl::span<int, 3>::iterator>>::value,
+    "span<int, 3>::reverse_iterator should equal std::reverse_iterator<span<int, 3>::iterator>");
+static_assert(std::is_same<gsl::span<int, 3>::const_reverse_iterator,
+                           std::reverse_iterator<gsl::span<int, 3>::const_iterator>>::value,
+              "span<int, 3>::const_reverse_iterator should equal std::reverse_iterator<span<int, "
+              "3>::const_iterator>");
+
+static_assert(
+    std::is_same<std::iterator_traits<gsl::span<const int>::iterator>::pointer, const int*>::value,
+    "span<const int>::iterator's pointer should be int*");
+static_assert(std::is_same<std::iterator_traits<gsl::span<const int>::const_iterator>::pointer,
+                           const int*>::value,
+              "span<const int>::const_iterator's pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int>::reverse_iterator,
+                           std::reverse_iterator<gsl::span<const int>::iterator>>::value,
+              "span<const int>::reverse_iterator should equal std::reverse_iterator<span<const "
+              "int>::iterator>");
+static_assert(std::is_same<gsl::span<const int>::const_reverse_iterator,
+                           std::reverse_iterator<gsl::span<const int>::const_iterator>>::value,
+              "span<const int>::const_reverse_iterator should equal "
+              "std::reverse_iterator<span<const int>::const_iterator>");
+
+static_assert(std::is_same<std::iterator_traits<gsl::span<const int, 3>::iterator>::pointer,
+                           const int*>::value,
+              "span<const int, 3>::iterator's pointer should be int*");
+static_assert(std::is_same<std::iterator_traits<gsl::span<const int, 3>::const_iterator>::pointer,
+                           const int*>::value,
+              "span<const int, 3>::const_iterator's pointer should be const int*");
+static_assert(std::is_same<gsl::span<const int, 3>::reverse_iterator,
+                           std::reverse_iterator<gsl::span<const int, 3>::iterator>>::value,
+              "span<const int, 3>::reverse_iterator should equal std::reverse_iterator<span<const "
+              "int, 3>::iterator>");
+static_assert(std::is_same<gsl::span<const int, 3>::const_reverse_iterator,
+                           std::reverse_iterator<gsl::span<const int, 3>::const_iterator>>::value,
+              "span<const int, 3>::const_reverse_iterator should equal "
+              "std::reverse_iterator<span<const int, 3>::const_iterator>");
+
+// copyability assertions
+static_assert(std::is_trivially_copyable<gsl::span<int>>::value,
+              "span<int> should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<int>::iterator>::value,
+              "span<int>::iterator should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<int>::const_iterator>::value,
+              "span<int>::const_iterator should be trivially copyable");
+
+static_assert(std::is_trivially_copyable<gsl::span<int, 3>>::value,
+              "span<int, 3> should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<int, 3>::iterator>::value,
+              "span<int, 3>::iterator should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<int, 3>::const_iterator>::value,
+              "span<int, 3>::const_iterator should be trivially copyable");
+
+static_assert(std::is_trivially_copyable<gsl::span<const int>>::value,
+              "span<const int> should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<const int>::iterator>::value,
+              "span<const int>::iterator should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<const int>::const_iterator>::value,
+              "span<const int>::const_iterator should be trivially copyable");
+
+static_assert(std::is_trivially_copyable<gsl::span<const int, 3>>::value,
+              "span<const int, 3> should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<const int, 3>::iterator>::value,
+              "span<const int, 3>::iterator should be trivially copyable");
+static_assert(std::is_trivially_copyable<gsl::span<const int, 3>::const_iterator>::value,
+              "span<const int, 3>::const_iterator should be trivially copyable");
+
+// nothrow constructible assertions
+static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, std::size_t>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, int*, std::size_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, std::uint16_t>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, int*, std::uint16_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, int*>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, int*, int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, int (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, int(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 500>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 500>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<int>, std::array<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int>, std::array<int, 3>&>");
+
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::size_t>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::size_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::uint16_t>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::uint16_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, int*>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, int(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, const gsl::span<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, const gsl::span<int, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, std::array<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<int, 3>, std::array<int, 3>&>");
+
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, std::size_t>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, int*, std::size_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, int*>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, int*, int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, const int*>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, int*, const int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, int (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, int(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, int*>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const int*, int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, const int*>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const int*, const int*>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, std::size_t>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const int*, std::size_t>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const int(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 500>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 500>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 500>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 500>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, std::array<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, std::array<int, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<const int>, const std::array<int, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const int>, const std::array<int, 3>&>");
+
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<int, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<int, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<const int, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<const int, 3>&>");
+
+static_assert(std::is_nothrow_constructible<gsl::span<Base>, Base (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<Base>, Base(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base>&>::value,
+              "std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<Base>, std::array<Base, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<Base>, std::array<Base, 3>&>");
+
+static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, Base (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<Base, 3>, Base(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, const gsl::span<Base, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<Base, 3>, const gsl::span<Base, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, std::array<Base, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<Base, 3>, std::array<Base, 3>&>");
+
+static_assert(std::is_nothrow_constructible<gsl::span<const Base>, Base (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<const Base>, Base(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<const Base>, const Base (&)[3]>::value,
+              "std::is_nothrow_constructible<gsl::span<const Base>, const Base(&)[3]>");
+static_assert(std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base, 3>&>");
+static_assert(std::is_nothrow_constructible<gsl::span<const Base>, std::array<Base, 3>&>::value,
+              "std::is_nothrow_constructible<gsl::span<const Base>, std::array<Base, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base>, const std::array<Base, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base>, const std::array<Base, 3>&>");
+
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<Base, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<Base, 3>&>");
+static_assert(
+    std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<const Base, 3>&>::value,
+    "std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<const Base, 3>&>");
+
+// non-constructible assertions
+static_assert(!std::is_constructible<gsl::span<int>, const int*, int*>::value,
+              "!std::is_constructible<gsl::span<int>, const int*, int*>");
+static_assert(!std::is_constructible<gsl::span<int>, const int*, const int*>::value,
+              "!std::is_constructible<gsl::span<int>, const int*, const int*>");
+static_assert(!std::is_constructible<gsl::span<int>, const int*, double*>::value,
+              "!std::is_constructible<gsl::span<int>, const int*, double*>");
+static_assert(!std::is_constructible<gsl::span<int>, const int*, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int>, const int*, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int>, const int (&)[3]>::value,
+              "!std::is_constructible<gsl::span<int>, const int(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<int>, double*, int*>::value,
+              "!std::is_constructible<gsl::span<int>, double*, int*>");
+static_assert(!std::is_constructible<gsl::span<int>, double*, const int*>::value,
+              "!std::is_constructible<gsl::span<int>, double*, const int*>");
+static_assert(!std::is_constructible<gsl::span<int>, double*, double*>::value,
+              "!std::is_constructible<gsl::span<int>, double*, double*>");
+static_assert(!std::is_constructible<gsl::span<int>, double*, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int>, double*, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int>, double (&)[3]>::value,
+              "!std::is_constructible<gsl::span<int>, double(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<int>, int*, double*>::value,
+              "!std::is_constructible<gsl::span<int>, int*, double*>");
+static_assert(!std::is_constructible<gsl::span<int>, std::size_t, int*>::value,
+              "!std::is_constructible<gsl::span<int>, std::size_t, int*>");
+static_assert(!std::is_constructible<gsl::span<int>, std::size_t, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int>, std::size_t, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int>&>::value,
+              "!std::is_constructible<gsl::span<int>, const gsl::span<const int>&>");
+static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int, 3>&>::value,
+              "!std::is_constructible<gsl::span<int>, const gsl::span<const int, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int, 500>&>::value,
+              "!std::is_constructible<gsl::span<int>, const gsl::span<const int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<int>, const gsl::span<double, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int>, std::array<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<int>, std::array<double, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int>, const std::array<int, 3>&>::value,
+              "!std::is_constructible<gsl::span<int>, const std::array<int, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<int, 3>, int*, double*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, int*, double*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, int (&)[500]>::value,
+              "!std::is_constructible<gsl::span<int, 3>, int(&)[500]>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, int*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const int*, int*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, const int*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const int*, const int*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const int*, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, double*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const int*, double*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const int (&)[3]>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const int(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, double*, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int, 3>, double*, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, double*, int*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, double*, int*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, double*, const int*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, double*, const int*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, double*, double*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, double*, double*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, double (&)[3]>::value,
+              "!std::is_constructible<gsl::span<int, 3>, double(&)[3]>");
+
+static_assert(!std::is_constructible<gsl::span<int, 3>, std::size_t, int*>::value,
+              "!std::is_constructible<gsl::span<int, 3>, std::size_t, int*>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, std::size_t, std::size_t>::value,
+              "!std::is_constructible<gsl::span<int, 3>, std::size_t, std::size_t>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, std::array<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, std::array<double, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 3>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 3>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 500>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<double, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<const int>, double (&)[3]>::value,
+              "!std::is_constructible<gsl::span<const int>, double(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<const int>, std::array<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<const int>, std::array<double, 3>&>");
+static_assert(!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>::value,
+              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>");
+static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>::value,
+              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>::value,
+              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>");
+static_assert(
+    !std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>::value,
+    "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>");
+static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<double, 3>&>::value,
+              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<double, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<Base>, Derived (&)[3]>::value,
+              "!std::is_constructible<gsl::span<Base>, Derived(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<Base>, std::array<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<Base>, std::array<Derived, 3>&>");
+static_assert(!std::is_constructible<gsl::span<Base>, const gsl::span<Derived>&>::value,
+              "!std::is_constructible<gsl::span<Base>, const gsl::span<Derived>&>");
+static_assert(!std::is_constructible<gsl::span<Base>, const gsl::span<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<Base>, const gsl::span<Derived, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<Base, 3>, const gsl::span<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<Base, 3>, const gsl::span<Derived, 3>&>");
+static_assert(!std::is_constructible<gsl::span<Base, 3>, Derived (&)[3]>::value,
+              "!std::is_constructible<gsl::span<Base, 3>, Derived(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<Base, 3>, std::array<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<Base, 3>, std::array<Derived, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<const Base>, Derived (&)[3]>::value,
+              "!std::is_constructible<gsl::span<const Base>, Derived(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<const Base>, const Derived (&)[3]>::value,
+              "!std::is_constructible<gsl::span<const Base>, const Derived(&)[3]>");
+static_assert(!std::is_constructible<gsl::span<const Base>, std::array<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Base>, std::array<Derived, 3>&>");
+static_assert(!std::is_constructible<gsl::span<const Base>, const std::array<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Base>, const std::array<Derived, 3>&>");
+static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived>&>::value,
+              "!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived>&>");
+static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived, 3>&>");
+static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived>&>::value,
+              "!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived>&>");
+static_assert(
+    !std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived, 3>&>::value,
+    "!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<Derived, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<Derived, 3>&>");
+static_assert(
+    !std::is_constructible<gsl::span<const Base, 3>, const gsl::span<const Derived, 3>&>::value,
+    "!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<const Derived, 3>&>");
+
+static_assert(!std::is_constructible<gsl::span<const Derived>, std::array<Base, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Derived>, std::array<Base, 3>&>");
+static_assert(!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>::value,
+              "!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>");
+
+// no throw copy constructor
+static_assert(std::is_nothrow_copy_constructible<gsl::span<int>>::value,
+              "std::is_nothrow_copy_constructible<gsl::span<int>>");
+static_assert(std::is_nothrow_copy_constructible<gsl::span<int, 3>>::value,
+              "std::is_nothrow_copy_constructible<gsl::span<int, 3>>");
+static_assert(std::is_nothrow_copy_constructible<gsl::span<const int>>::value,
+              "std::is_nothrow_copy_constructible<gsl::span<const int>>");
+static_assert(std::is_nothrow_copy_constructible<gsl::span<const int, 3>>::value,
+              "std::is_nothrow_copy_constructible<gsl::span<const int, 3>>");
+
+// no throw copy assignment
+static_assert(std::is_nothrow_copy_assignable<gsl::span<int>>::value,
+              "std::is_nothrow_copy_assignable<gsl::span<int>>");
+static_assert(std::is_nothrow_copy_assignable<gsl::span<int, 3>>::value,
+              "std::is_nothrow_copy_assignable<gsl::span<int, 3>>");
+static_assert(std::is_nothrow_copy_assignable<gsl::span<const int>>::value,
+              "std::is_nothrow_copy_assignable<gsl::span<const int>>");
+static_assert(std::is_nothrow_copy_assignable<gsl::span<const int, 3>>::value,
+              "std::is_nothrow_copy_assignable<gsl::span<const int, 3>>");
+
+// no throw destruction
+static_assert(std::is_nothrow_destructible<gsl::span<int>>::value,
+              "std::is_nothrow_destructible<gsl::span<int>>");
+static_assert(std::is_nothrow_destructible<gsl::span<int, 3>>::value,
+              "std::is_nothrow_destructible<gsl::span<int, 3>>");
+static_assert(std::is_nothrow_destructible<gsl::span<const int>>::value,
+              "std::is_nothrow_destructible<gsl::span<const int>>");
+
+// conversions
+static_assert(std::is_convertible<int (&)[3], gsl::span<int>>::value,
+              "std::is_convertible<int(&)[3], gsl::span<int>>");
+static_assert(std::is_convertible<int (&)[3], gsl::span<int, 3>>::value,
+              "std::is_convertible<int(&)[3], gsl::span<int, 3>>");
+static_assert(std::is_convertible<int (&)[3], gsl::span<const int>>::value,
+              "std::is_convertible<int(&)[3], gsl::span<const int>>");
+
+static_assert(std::is_convertible<const int (&)[3], gsl::span<const int>>::value,
+              "std::is_convertible<const int(&)[3], gsl::span<const int>>");
+
+static_assert(std::is_convertible<const gsl::span<int>&, gsl::span<int>>::value,
+              "std::is_convertible<const gsl::span<int>&, gsl::span<int>>");
+static_assert(std::is_convertible<const gsl::span<int>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<int>&, gsl::span<const int>>");
+
+static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<int>>::value,
+              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<int>>");
+static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<int, 3>>::value,
+              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<int, 3>>");
+static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int>>");
+static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int, 3>>::value,
+              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int, 3>>");
+static_assert(std::is_convertible<const gsl::span<int, 500>&, gsl::span<int>>::value,
+              "std::is_convertible<const gsl::span<int, 500>&, gsl::span<int>>");
+static_assert(std::is_convertible<const gsl::span<int, 500>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<int, 500>&, gsl::span<const int>>");
+
+static_assert(std::is_convertible<const gsl::span<const int>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<const int>&, gsl::span<const int>>");
+
+static_assert(std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int>>");
+static_assert(std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int, 3>>::value,
+              "std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int, 3>>");
+static_assert(std::is_convertible<const gsl::span<const int, 500>&, gsl::span<const int>>::value,
+              "std::is_convertible<const gsl::span<const int, 500>&, gsl::span<const int>>");
+
+static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<int>>::value,
+              "std::is_convertible<std::array<int, 3>&, gsl::span<int>>");
+static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<int, 3>>::value,
+              "std::is_convertible<std::array<int, 3>&, gsl::span<int, 3>>");
+static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<const int>>::value,
+              "std::is_convertible<std::array<int, 3>&, gsl::span<const int>>");
+
+static_assert(std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>::value,
+              "std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>");
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index ab437a5..2c4a19c 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -29,6 +29,7 @@
 #include <string>      // for string
 #include <type_traits> // for integral_constant<>::value, is_default_co...
 #include <vector>      // for vector
+#include <utility>
 
 using namespace std;
 using namespace gsl;
@@ -1021,11 +1022,11 @@ TEST(span_test, from_array_constructor)
      EXPECT_TRUE((std::is_same<decltype(s.crbegin()), decltype(crbegin(s))>::value));
      EXPECT_TRUE((std::is_same<decltype(s.crend()), decltype(crend(s))>::value));
 
-     EXPECT_TRUE(s.begin() == begin(s));
-     EXPECT_TRUE(s.end() == end(s));
+     EXPECT_TRUE(s.begin() == std::begin(s));
+     EXPECT_TRUE(s.end() == std::end(s));
 
-     EXPECT_TRUE(s.cbegin() == cbegin(s));
-     EXPECT_TRUE(s.cend() == cend(s));
+     EXPECT_TRUE(s.cbegin() == std::cbegin(s));
+     EXPECT_TRUE(s.cend() == std::cend(s));
 
      EXPECT_TRUE(s.rbegin() == rbegin(s));
      EXPECT_TRUE(s.rend() == rend(s));
diff --git a/tests/utils_tests.cpp b/tests/utils_tests.cpp
index 1fb0fd2..f7f7ce3 100644
--- a/tests/utils_tests.cpp
+++ b/tests/utils_tests.cpp
@@ -23,7 +23,7 @@
 #include <limits>      // for numeric_limits
 #include <stdint.h>    // for uint32_t, int32_t
 #include <type_traits> // for is_same
-#include <cstddef>     // for std::size_t
+#include <cstddef>     // for std::ptrdiff_t
 
 using namespace gsl;