From 7505111329ad32b76b479a5a29961dfb6ea59f55 Mon Sep 17 00:00:00 2001
From: Jason Horsburgh <jayhorsburgh@googlemail.com>
Date: Sat, 21 Nov 2015 19:13:21 +0000
Subject: [PATCH 01/42] Add CMake install target for header files

---
 CMakeLists.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f8145d6..7397fe2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,10 +2,21 @@ cmake_minimum_required(VERSION 2.8.7)
 
 project(GSL CXX)
 
+set(GSL_HEADERS
+    "include/gsl.h"
+    "include/gsl_assert.h"
+    "include/span.h"
+    "include/string_span.h"
+)
+
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
 )
 
+install(FILES ${GSL_HEADERS}
+    DESTINATION include/gsl
+)
+
 enable_testing()
 
 add_subdirectory(tests)

From 49e80625c682fe88baf9e306a784f8be7350e416 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 24 Feb 2016 10:29:29 -0800
Subject: [PATCH 02/42] Renamed existing span to multi_span.

---
 include/span.h               | 194 ++++++++---------
 include/string_span.h        |  32 +--
 tests/bounds_tests.cpp       |   2 +-
 tests/span_tests.cpp         | 390 +++++++++++++++++------------------
 tests/strided_span_tests.cpp |  68 +++---
 tests/string_span_tests.cpp  |  26 +--
 6 files changed, 356 insertions(+), 356 deletions(-)

diff --git a/include/span.h b/include/span.h
index 31c26ad..659e116 100644
--- a/include/span.h
+++ b/include/span.h
@@ -1072,7 +1072,7 @@ struct dim<dynamic_range>
 
 template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
           std::ptrdiff_t... RestDimensions>
-class span;
+class multi_span;
 
 template <typename ValueType, size_t Rank>
 class strided_span;
@@ -1096,7 +1096,7 @@ namespace details
     template <typename T, std::ptrdiff_t... Ranks>
     struct SpanArrayTraits
     {
-        using type = span<T, Ranks...>;
+        using type = multi_span<T, Ranks...>;
         using value_type = T;
         using bounds_type = static_bounds<Ranks...>;
         using pointer = T*;
@@ -1161,7 +1161,7 @@ namespace details
     };
 
     template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct is_span_oracle<span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
+    struct is_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
     {
     };
 
@@ -1177,12 +1177,12 @@ namespace details
 }
 
 template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-class span
+class multi_span
 {
     // TODO do we still need this?
     template <typename ValueType2, std::ptrdiff_t FirstDimension2,
               std::ptrdiff_t... RestDimensions2>
-    friend class span;
+    friend class multi_span;
 
 public:
     using bounds_type = static_bounds<FirstDimension, RestDimensions...>;
@@ -1193,13 +1193,13 @@ public:
     using const_value_type = std::add_const_t<value_type>;
     using pointer = std::add_pointer_t<value_type>;
     using reference = std::add_lvalue_reference_t<value_type>;
-    using iterator = contiguous_span_iterator<span>;
-    using const_span = span<const_value_type, FirstDimension, RestDimensions...>;
+    using iterator = contiguous_span_iterator<multi_span>;
+    using const_span = multi_span<const_value_type, FirstDimension, RestDimensions...>;
     using const_iterator = contiguous_span_iterator<const_span>;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using sliced_type =
-        std::conditional_t<Rank == 1, value_type, span<value_type, RestDimensions...>>;
+        std::conditional_t<Rank == 1, value_type, multi_span<value_type, RestDimensions...>>;
 
 private:
     pointer data_;
@@ -1210,36 +1210,36 @@ private:
 
 public:
     // default constructor - same as constructing from nullptr_t
-    constexpr span() noexcept : span(nullptr, bounds_type{})
+    constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{})
     {
         static_assert(bounds_type::dynamic_rank != 0 ||
                           (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "Default construction of span<T> only possible "
+                      "Default construction of multi_span<T> only possible "
                       "for dynamic or fixed, zero-length spans.");
     }
 
-    // construct from nullptr - get an empty span
-    constexpr span(std::nullptr_t) noexcept : span(nullptr, bounds_type{})
+    // construct from nullptr - get an empty multi_span
+    constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{})
     {
         static_assert(bounds_type::dynamic_rank != 0 ||
                           (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "nullptr_t construction of span<T> only possible "
+                      "nullptr_t construction of multi_span<T> only possible "
                       "for dynamic or fixed, zero-length spans.");
     }
 
     // construct from nullptr with size of 0 (helps with template function calls)
     template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>>
-    constexpr span(std::nullptr_t, IntType size) noexcept : span(nullptr, bounds_type{})
+    constexpr multi_span(std::nullptr_t, IntType size) noexcept : multi_span(nullptr, bounds_type{})
     {
         static_assert(bounds_type::dynamic_rank != 0 ||
                           (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "nullptr_t construction of span<T> only possible "
+                      "nullptr_t construction of multi_span<T> only possible "
                       "for dynamic or fixed, zero-length spans.");
         Expects(size == 0);
     }
 
     // construct from a single element
-    constexpr span(reference data) noexcept : span(&data, bounds_type{1})
+    constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1})
     {
         static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 ||
                           bounds_type::static_size == 1,
@@ -1248,13 +1248,13 @@ public:
     }
 
     // prevent constructing from temporaries for single-elements
-    constexpr span(value_type&&) = delete;
+    constexpr multi_span(value_type&&) = delete;
 
     // construct from pointer + length
-    constexpr span(pointer ptr, size_type size) noexcept : span(ptr, bounds_type{size}) {}
+    constexpr multi_span(pointer ptr, size_type size) noexcept : multi_span(ptr, bounds_type{size}) {}
 
     // construct from pointer + length - multidimensional
-    constexpr span(pointer data, bounds_type bounds) noexcept : data_(data),
+    constexpr multi_span(pointer data, bounds_type bounds) noexcept : data_(data),
                                                                 bounds_(std::move(bounds))
     {
         Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
@@ -1264,60 +1264,60 @@ public:
     template <typename Ptr,
               typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value &&
                                           details::LessThan<bounds_type::dynamic_rank, 2>::value>>
-    constexpr span(pointer begin, Ptr end)
-        : span(begin, details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
+    constexpr multi_span(pointer begin, Ptr end)
+        : multi_span(begin, details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
     {
         Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end));
     }
 
     // construct from n-dimensions static array
     template <typename T, size_t N, typename Helper = details::SpanArrayTraits<T, N>>
-    constexpr span(T (&arr)[N])
-        : span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
+    constexpr multi_span(T (&arr)[N])
+        : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
     {
         static_assert(
             std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value,
-            "Cannot convert from source type to target span type.");
+            "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value,
-                      "Cannot construct a span from an array with fewer elements.");
+                      "Cannot construct a multi_span from an array with fewer elements.");
     }
 
     // construct from n-dimensions dynamic array (e.g. new int[m][4])
     // (precedence will be lower than the 1-dimension pointer)
     template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>>
-    constexpr span(T* const& data, size_type size)
-        : span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size})
+    constexpr multi_span(T* const& data, size_type size)
+        : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size})
     {
         static_assert(
             std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value,
-            "Cannot convert from source type to target span type.");
+            "Cannot convert from source type to target multi_span type.");
     }
 
     // construct from std::array
     template <typename T, size_t N>
-    constexpr span(std::array<T, N>& arr) : span(arr.data(), bounds_type{static_bounds<N>{}})
+    constexpr multi_span(std::array<T, N>& arr) : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
     {
         static_assert(
             std::is_convertible<T(*) [], typename std::remove_const_t<value_type>(*) []>::value,
-            "Cannot convert from source type to target span type.");
+            "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
-                      "You cannot construct a span from a std::array of smaller size.");
+                      "You cannot construct a multi_span from a std::array of smaller size.");
     }
 
     // construct from const std::array
     template <typename T, size_t N>
-    constexpr span(const std::array<std::remove_const_t<value_type>, N>& arr)
-        : span(arr.data(), static_bounds<N>())
+    constexpr multi_span(const std::array<std::remove_const_t<value_type>, N>& arr)
+        : multi_span(arr.data(), static_bounds<N>())
     {
         static_assert(std::is_convertible<T(*) [], std::remove_const_t<value_type>>::value,
-                      "Cannot convert from source type to target span type.");
+                      "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
-                      "You cannot construct a span from a std::array of smaller size.");
+                      "You cannot construct a multi_span from a std::array of smaller size.");
     }
 
     // prevent constructing from temporary std::array
     template <typename T, size_t N>
-    constexpr span(std::array<T, N>&& arr) = delete;
+    constexpr multi_span(std::array<T, N>&& arr) = delete;
 
     // construct from containers
     // future: could use contiguous_iterator_traits to identify only contiguous containers
@@ -1329,8 +1329,8 @@ public:
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
                                DataType>::value>>
-    constexpr span(Cont& cont)
-        : span(static_cast<pointer>(cont.data()),
+    constexpr multi_span(Cont& cont)
+        : multi_span(static_cast<pointer>(cont.data()),
                details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
     {
     }
@@ -1343,33 +1343,33 @@ public:
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
                                DataType>::value>>
-    explicit constexpr span(Cont&& cont) = delete;
+    explicit constexpr multi_span(Cont&& cont) = delete;
 
-    // construct from a convertible span
+    // construct from a convertible multi_span
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename OtherBounds = static_bounds<OtherDimensions...>,
               typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value &&
                                           std::is_convertible<OtherBounds, bounds_type>::value>>
-    constexpr span(span<OtherValueType, OtherDimensions...> other) noexcept : data_(other.data_),
+    constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept : data_(other.data_),
                                                                               bounds_(other.bounds_)
     {
     }
 
 // trivial copy and move
 #ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
-    constexpr span(span&&) = default;
+    constexpr multi_span(multi_span&&) = default;
 #endif
-    constexpr span(const span&) = default;
+    constexpr multi_span(const multi_span&) = default;
 
 // trivial assignment
 #ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
-    constexpr span& operator=(span&&) = default;
+    constexpr multi_span& operator=(multi_span&&) = default;
 #endif
-    constexpr span& operator=(const span&) = default;
+    constexpr multi_span& operator=(const multi_span&) = default;
 
-    // first() - extract the first Count elements into a new span
+    // first() - extract the first Count elements into a new multi_span
     template <std::ptrdiff_t Count>
-    constexpr span<ValueType, Count> first() const noexcept
+    constexpr multi_span<ValueType, Count> first() const noexcept
     {
         static_assert(Count >= 0, "Count must be >= 0.");
         static_assert(bounds_type::static_size == dynamic_range ||
@@ -1380,16 +1380,16 @@ public:
         return {this->data(), Count};
     }
 
-    // first() - extract the first count elements into a new span
-    constexpr span<ValueType, dynamic_range> first(size_type count) const noexcept
+    // first() - extract the first count elements into a new multi_span
+    constexpr multi_span<ValueType, dynamic_range> first(size_type count) const noexcept
     {
         Expects(count >= 0 && count <= this->size());
         return {this->data(), count};
     }
 
-    // last() - extract the last Count elements into a new span
+    // last() - extract the last Count elements into a new multi_span
     template <std::ptrdiff_t Count>
-    constexpr span<ValueType, Count> last() const noexcept
+    constexpr multi_span<ValueType, Count> last() const noexcept
     {
         static_assert(Count >= 0, "Count must be >= 0.");
         static_assert(bounds_type::static_size == dynamic_range ||
@@ -1400,8 +1400,8 @@ public:
         return {this->data() + this->size() - Count, Count};
     }
 
-    // last() - extract the last count elements into a new span
-    constexpr span<ValueType, dynamic_range> last(size_type count) const noexcept
+    // last() - extract the last count elements into a new multi_span
+    constexpr multi_span<ValueType, dynamic_range> last(size_type count) const noexcept
     {
         Expects(count >= 0 && count <= this->size());
         return {this->data() + this->size() - count, count};
@@ -1409,14 +1409,14 @@ public:
 
     // subspan() - create a subview of Count elements starting at Offset
     template <std::ptrdiff_t Offset, std::ptrdiff_t Count>
-    constexpr span<ValueType, Count> subspan() const noexcept
+    constexpr multi_span<ValueType, Count> subspan() const noexcept
     {
         static_assert(Count >= 0, "Count must be >= 0.");
         static_assert(Offset >= 0, "Offset must be >= 0.");
         static_assert(bounds_type::static_size == dynamic_range ||
                           ((Offset <= bounds_type::static_size) &&
                            Count <= bounds_type::static_size - Offset),
-                      "You must describe a sub-range within bounds of the span.");
+                      "You must describe a sub-range within bounds of the multi_span.");
 
         Expects(bounds_type::static_size != dynamic_range ||
                 (Offset <= this->size() && Count <= this->size() - Offset));
@@ -1425,7 +1425,7 @@ public:
 
     // subspan() - create a subview of count elements starting at offset
     // supplying dynamic_range for count will consume all available elements from offset
-    constexpr span<ValueType, dynamic_range> subspan(size_type offset,
+    constexpr multi_span<ValueType, dynamic_range> subspan(size_type offset,
                                                      size_type count = dynamic_range) const noexcept
     {
         Expects((offset >= 0 && offset <= this->size()) &&
@@ -1433,7 +1433,7 @@ public:
         return {this->data() + offset, count == dynamic_range ? this->length() - offset : count};
     }
 
-    // section - creates a non-contiguous, strided span from a contiguous one
+    // section - creates a non-contiguous, strided multi_span from a contiguous one
     constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const
         noexcept
     {
@@ -1442,16 +1442,16 @@ public:
                 strided_bounds<Rank>{extents, details::make_stride(bounds())}};
     }
 
-    // length of the span in elements
+    // length of the multi_span in elements
     constexpr size_type size() const noexcept { return bounds_.size(); }
 
-    // length of the span in elements
+    // length of the multi_span in elements
     constexpr size_type length() const noexcept { return this->size(); }
 
-    // length of the span in bytes
+    // length of the multi_span in bytes
     constexpr size_type size_bytes() const noexcept { return sizeof(value_type) * this->size(); }
 
-    // length of the span in bytes
+    // length of the multi_span in bytes
     constexpr size_type length_bytes() const noexcept { return this->size_bytes(); }
 
     constexpr bool empty() const noexcept { return this->size() == 0; }
@@ -1537,7 +1537,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator==(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return bounds_.size() == other.bounds_.size() &&
                (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
@@ -1546,7 +1546,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator!=(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return !(*this == other);
     }
@@ -1554,7 +1554,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator<(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
     }
@@ -1562,7 +1562,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator<=(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return !(other < *this);
     }
@@ -1570,7 +1570,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator>(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return (other < *this);
     }
@@ -1578,7 +1578,7 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator>=(const span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
     {
         return !(*this < other);
     }
@@ -1588,57 +1588,57 @@ public:
 // Free functions for manipulating spans
 //
 
-// reshape a span into a different dimensionality
+// reshape a multi_span into a different dimensionality
 // DimCount and Enabled here are workarounds for a bug in MSVC 2015
 template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2),
           bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
-constexpr span<typename SpanType::value_type, Dimensions2::value...> as_span(SpanType s,
+constexpr multi_span<typename SpanType::value_type, Dimensions2::value...> as_span(SpanType s,
                                                                              Dimensions2... dims)
 {
     static_assert(details::is_span<SpanType>::value,
                   "Variadic as_span() is for reshaping existing spans.");
     using BoundsType =
-        typename span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
+        typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
     auto tobounds = details::static_as_span_helper<BoundsType>(dims..., details::Sep{});
     details::verifyBoundsReshape(s.bounds(), tobounds);
     return {s.data(), tobounds};
 }
 
-// convert a span<T> to a span<const byte>
+// convert a multi_span<T> to a multi_span<const byte>
 template <typename U, std::ptrdiff_t... Dimensions>
-span<const byte, dynamic_range> as_bytes(span<U, Dimensions...> s) noexcept
+multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) noexcept
 {
     static_assert(std::is_trivial<std::decay_t<U>>::value,
-                  "The value_type of span must be a trivial type.");
+                  "The value_type of multi_span must be a trivial type.");
     return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }
 
-// convert a span<T> to a span<byte> (a writeable byte span)
+// convert a multi_span<T> to a multi_span<byte> (a writeable byte multi_span)
 // this is not currently a portable function that can be relied upon to work
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-span<byte> as_writeable_bytes(span<U, Dimensions...> s) noexcept
+multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept
 {
     static_assert(std::is_trivial<std::decay_t<U>>::value,
-                  "The value_type of span must be a trivial type.");
+                  "The value_type of multi_span must be a trivial type.");
     return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
 }
 
-// convert a span<const byte> to a span<const T>
+// convert a multi_span<const byte> to a multi_span<const T>
 // this is not currently a portable function that can be relied upon to work
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(span<const byte, Dimensions...> s) noexcept
-    -> span<const U, static_cast<std::ptrdiff_t>(
-                         span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
+constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept
+    -> multi_span<const U, static_cast<std::ptrdiff_t>(
+                         multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
                              ? (static_cast<size_t>(
-                                    span<const byte, Dimensions...>::bounds_type::static_size) /
+                                    multi_span<const byte, Dimensions...>::bounds_type::static_size) /
                                 sizeof(U))
                              : dynamic_range)>
 {
-    using ConstByteSpan = span<const byte, Dimensions...>;
+    using ConstByteSpan = multi_span<const byte, Dimensions...>;
     static_assert(
         std::is_trivial<std::decay_t<U>>::value &&
             (ConstByteSpan::bounds_type::static_size == dynamic_range ||
@@ -1650,19 +1650,19 @@ constexpr auto as_span(span<const byte, Dimensions...> s) noexcept
             s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))};
 }
 
-// convert a span<byte> to a span<T>
+// convert a multi_span<byte> to a multi_span<T>
 // this is not currently a portable function that can be relied upon to work
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(span<byte, Dimensions...> s) noexcept -> span<
+constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept -> multi_span<
     U, narrow_cast<std::ptrdiff_t>(
-           span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
-               ? static_cast<std::size_t>(span<byte, Dimensions...>::bounds_type::static_size) /
+           multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
+               ? static_cast<std::size_t>(multi_span<byte, Dimensions...>::bounds_type::static_size) /
                      sizeof(U)
                : dynamic_range)>
 {
-    using ByteSpan = span<byte, Dimensions...>;
+    using ByteSpan = multi_span<byte, Dimensions...>;
     static_assert(
         std::is_trivial<std::decay_t<U>>::value &&
             (ByteSpan::bounds_type::static_size == dynamic_range ||
@@ -1676,7 +1676,7 @@ constexpr auto as_span(span<byte, Dimensions...> s) noexcept -> span<
 
 template <typename T, std::ptrdiff_t... Dimensions>
 constexpr auto as_span(T* const& ptr, dim<Dimensions>... args)
-    -> span<std::remove_all_extents_t<T>, Dimensions...>
+    -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
 {
     return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
             details::static_as_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})};
@@ -1696,22 +1696,22 @@ constexpr auto as_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::
 }
 
 template <typename T, size_t N>
-constexpr span<const T, N> as_span(const std::array<T, N>& arr)
+constexpr multi_span<const T, N> as_span(const std::array<T, N>& arr)
 {
     return {arr};
 }
 
 template <typename T, size_t N>
-constexpr span<const T, N> as_span(const std::array<T, N>&&) = delete;
+constexpr multi_span<const T, N> as_span(const std::array<T, N>&&) = delete;
 
 template <typename T, size_t N>
-constexpr span<T, N> as_span(std::array<T, N>& arr)
+constexpr multi_span<T, N> as_span(std::array<T, N>& arr)
 {
     return {arr};
 }
 
 template <typename T>
-constexpr span<T, dynamic_range> as_span(T* begin, T* end)
+constexpr multi_span<T, dynamic_range> as_span(T* begin, T* end)
 {
     return {begin, end};
 }
@@ -1719,7 +1719,7 @@ constexpr span<T, dynamic_range> as_span(T* begin, T* end)
 template <typename Cont>
 constexpr auto as_span(Cont& arr) -> std::enable_if_t<
     !details::is_span<std::decay_t<Cont>>::value,
-    span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
+    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
 {
     Expects(arr.size() < PTRDIFF_MAX);
     return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())};
@@ -1728,12 +1728,12 @@ constexpr auto as_span(Cont& arr) -> std::enable_if_t<
 template <typename Cont>
 constexpr auto as_span(Cont&& arr) -> std::enable_if_t<
     !details::is_span<std::decay_t<Cont>>::value,
-    span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
+    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
 
 // from basic_string which doesn't have nonconst .data() member like other contiguous containers
 template <typename CharT, typename Traits, typename Allocator>
 constexpr auto as_span(std::basic_string<CharT, Traits, Allocator>& str)
-    -> span<CharT, dynamic_range>
+    -> multi_span<CharT, dynamic_range>
 {
     Expects(str.size() < PTRDIFF_MAX);
     return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())};
@@ -1792,7 +1792,7 @@ public:
               bool Enabled1 = (sizeof...(Dimensions) == Rank),
               bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value,
               typename Dummy = std::enable_if_t<Enabled1 && Enabled2>>
-    constexpr strided_span(span<OtherValueType, Dimensions...> av, bounds_type bounds)
+    constexpr strided_span(multi_span<OtherValueType, Dimensions...> av, bounds_type bounds)
         : strided_span(av.data(), av.bounds().total_size(), std::move(bounds))
     {
     }
@@ -1988,7 +1988,7 @@ public:
 
 private:
     template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    friend class span;
+    friend class multi_span;
 
     pointer data_;
     const Span* m_validator;
diff --git a/include/string_span.h b/include/string_span.h
index 46bf2d4..f585d3f 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -96,7 +96,7 @@ using wzstring = basic_zstring<wchar_t, Extent>;
 // Will fail-fast if sentinel cannot be found before max elements are examined.
 //
 template<typename T, const T Sentinel>
-span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
+multi_span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     auto cur = seq;
     while ((cur - seq) < max && *cur != Sentinel) ++cur;
@@ -111,34 +111,34 @@ span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
 // the limit of size_type.
 //
 template<typename T>
-inline span<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
+inline multi_span<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     return ensure_sentinel<T, 0>(sz, max);
 }
 
 // TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation
-inline span<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max)
+inline multi_span<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline span<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max)
+inline multi_span<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline span<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
+inline multi_span<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
+inline multi_span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
@@ -146,10 +146,10 @@ inline span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std
 }
 
 template<typename T, size_t N>
-span<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
+multi_span<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
 
 template<class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont)
+multi_span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont)
 {
     return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length()));
 }
@@ -228,7 +228,7 @@ public:
     using reference = std::add_lvalue_reference_t<value_type>;
     using const_reference = std::add_lvalue_reference_t<const_value_type>;
     using bounds_type = static_bounds<Extent>;
-    using impl_type = span<value_type, Extent>;
+    using impl_type = multi_span<value_type, Extent>;
 
     using size_type = ptrdiff_t;
     using iterator = typename impl_type::iterator;
@@ -323,17 +323,17 @@ public:
         std::is_convertible<OtherValueType*, value_type*>::value
         && std::is_convertible<static_bounds<OtherExtent>, bounds_type>::value>
     >
-    constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept
+    constexpr basic_string_span(multi_span<OtherValueType, OtherExtent> other) noexcept
         : span_(other)
     {}
 #else
     // from span
-    constexpr basic_string_span(span<value_type, Extent> other) noexcept
+    constexpr basic_string_span(multi_span<value_type, Extent> other) noexcept
         : span_(other)
     {}
         
     template <typename Dummy = std::enable_if_t<!std::is_same<std::remove_const_t<value_type>, value_type>::value>>
-    constexpr basic_string_span(span<std::remove_const_t<value_type>, Extent> other) noexcept
+    constexpr basic_string_span(multi_span<std::remove_const_t<value_type>, Extent> other) noexcept
         : span_(other)
     {}
 #endif
@@ -540,14 +540,14 @@ public:
     using zstring_type = basic_zstring<value_type, Extent>;
     using const_zstring_type = basic_zstring<const_value_type, Extent>;
 
-    using impl_type = span<value_type, Extent>;
+    using impl_type = multi_span<value_type, Extent>;
     using string_span_type = basic_string_span<value_type, Extent>;
 
-    constexpr basic_zstring_span(impl_type span) noexcept
-        : span_(span)
+    constexpr basic_zstring_span(impl_type multi_span) noexcept
+        : span_(multi_span)
     {
         // expects a zero-terminated span
-        Expects(span[span.size() - 1] == '\0');
+        Expects(multi_span[multi_span.size() - 1] == '\0');
     }
 
     // copy
diff --git a/tests/bounds_tests.cpp b/tests/bounds_tests.cpp
index 0665260..ab8c5bd 100644
--- a/tests/bounds_tests.cpp
+++ b/tests/bounds_tests.cpp
@@ -58,7 +58,7 @@ SUITE(bounds_test)
 		auto itr = bounds.begin();
 		(void)itr;	
 #ifdef CONFIRM_COMPILATION_ERRORS
-		span<int, 4, dynamic_range, 2> av(nullptr, bounds);
+		multi_span<int, 4, dynamic_range, 2> av(nullptr, bounds);
 	
 		auto itr2 = av.cbegin();
 	
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 8b39639..0d1170d 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -43,33 +43,33 @@ SUITE(span_tests)
     TEST(default_constructor)
     {
         {
-            span<int> s;
+            multi_span<int> s;
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs;
+            multi_span<const int> cs;
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            span<int, 0> s;
+            multi_span<int, 0> s;
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int, 0> cs;
+            multi_span<const int, 0> cs;
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 1> s;
+            multi_span<int, 1> s;
             CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
 #endif
         }
 
         {
-            span<int> s{};
+            multi_span<int> s{};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs{};
+            multi_span<const int> cs{};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
     }
@@ -77,41 +77,41 @@ SUITE(span_tests)
     TEST(from_nullptr_constructor)
     {
         {
-            span<int> s = nullptr;
+            multi_span<int> s = nullptr;
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs = nullptr;
+            multi_span<const int> cs = nullptr;
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            span<int, 0> s = nullptr;
+            multi_span<int, 0> s = nullptr;
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int, 0> cs = nullptr;
+            multi_span<const int, 0> cs = nullptr;
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 1> s = nullptr;
+            multi_span<int, 1> s = nullptr;
             CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
 #endif
         }
 
         {
-            span<int> s{nullptr};
+            multi_span<int> s{nullptr};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs{nullptr};
+            multi_span<const int> cs{nullptr};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            span<int*> s{nullptr};
+            multi_span<int*> s{nullptr};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int*> cs{nullptr};
+            multi_span<const int*> cs{nullptr};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
     }
@@ -119,49 +119,49 @@ SUITE(span_tests)
     TEST(from_nullptr_length_constructor)
     {
         {
-            span<int> s{nullptr, 0};
+            multi_span<int> s{nullptr, 0};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs{nullptr, 0};
+            multi_span<const int> cs{nullptr, 0};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            span<int, 0> s{nullptr, 0};
+            multi_span<int, 0> s{nullptr, 0};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int, 0> cs{nullptr, 0};
+            multi_span<const int, 0> cs{nullptr, 0};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 1> s{nullptr, 0};
+            multi_span<int, 1> s{nullptr, 0};
             CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
 #endif
         }
 
         {
-            auto workaround_macro = []() { span<int> s{nullptr, 1}; };
+            auto workaround_macro = []() { multi_span<int> s{nullptr, 1}; };
             CHECK_THROW(workaround_macro(), fail_fast);
 
-            auto const_workaround_macro = []() { span<const int> cs{nullptr, 1}; };
+            auto const_workaround_macro = []() { multi_span<const int> cs{nullptr, 1}; };
             CHECK_THROW(const_workaround_macro(), fail_fast);
         }
 
         {
-            auto workaround_macro = []() { span<int, 0> s{nullptr, 1}; };
+            auto workaround_macro = []() { multi_span<int, 0> s{nullptr, 1}; };
             CHECK_THROW(workaround_macro(), fail_fast);
 
-            auto const_workaround_macro = []() { span<const int, 0> s{nullptr, 1}; };
+            auto const_workaround_macro = []() { multi_span<const int, 0> s{nullptr, 1}; };
             CHECK_THROW(const_workaround_macro(), fail_fast);
         }
 
         {
-            span<int*> s{nullptr, 0};
+            multi_span<int*> s{nullptr, 0};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int*> cs{nullptr, 0};
+            multi_span<const int*> cs{nullptr, 0};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
     }
@@ -171,11 +171,11 @@ SUITE(span_tests)
         int i = 5;
 
         {
-            span<int> s = i;
+            multi_span<int> s = i;
             CHECK(s.length() == 1 && s.data() == &i);
             CHECK(s[0] == 5);
 
-            span<const int> cs = i;
+            multi_span<const int> cs = i;
             CHECK(cs.length() == 1 && cs.data() == &i);
             CHECK(cs[0] == 5);
         }
@@ -183,26 +183,26 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             const j = 1;
-            span<int, 0> s = j;
+            multi_span<int, 0> s = j;
 #endif
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 0> s = i;
+            multi_span<int, 0> s = i;
             CHECK(s.length() == 0 && s.data() == &i);
 #endif
         }
 
         {
-            span<int, 1> s = i;
+            multi_span<int, 1> s = i;
             CHECK(s.length() == 1 && s.data() == &i);
             CHECK(s[0] == 5);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 2> s = i;
+            multi_span<int, 2> s = i;
             CHECK(s.length() == 2 && s.data() == &i);
 #endif
         }
@@ -210,7 +210,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_a_temp = []() -> int { return 4; };
-            auto use_a_span = [](span<int> s) { (void) s; };
+            auto use_a_span = [](multi_span<int> s) { (void) s; };
             use_a_span(get_a_temp());
 #endif
         }
@@ -221,26 +221,26 @@ SUITE(span_tests)
         int arr[4] = {1, 2, 3, 4};
 
         {
-            span<int> s{&arr[0], 2};
+            multi_span<int> s{&arr[0], 2};
             CHECK(s.length() == 2 && s.data() == &arr[0]);
             CHECK(s[0] == 1 && s[1] == 2);
         }
 
         {
-            span<int, 2> s{&arr[0], 2};
+            multi_span<int, 2> s{&arr[0], 2};
             CHECK(s.length() == 2 && s.data() == &arr[0]);
             CHECK(s[0] == 1 && s[1] == 2);
         }
 
         {
             int* p = nullptr;
-            span<int> s{p, 0};
+            multi_span<int> s{p, 0};
             CHECK(s.length() == 0 && s.data() == nullptr);
         }
 
         {
             int* p = nullptr;
-            auto workaround_macro = [=]() { span<int> s{p, 2}; };
+            auto workaround_macro = [=]() { multi_span<int> s{p, 2}; };
             CHECK_THROW(workaround_macro(), fail_fast);
         }
     }
@@ -250,47 +250,47 @@ SUITE(span_tests)
         int arr[4] = {1, 2, 3, 4};
 
         {
-            span<int> s{&arr[0], &arr[2]};
+            multi_span<int> s{&arr[0], &arr[2]};
             CHECK(s.length() == 2 && s.data() == &arr[0]);
             CHECK(s[0] == 1 && s[1] == 2);
         }
 
         {
-            span<int, 2> s{&arr[0], &arr[2]};
+            multi_span<int, 2> s{&arr[0], &arr[2]};
             CHECK(s.length() == 2 && s.data() == &arr[0]);
             CHECK(s[0] == 1 && s[1] == 2);
         }
 
         {
-            span<int> s{&arr[0], &arr[0]};
+            multi_span<int> s{&arr[0], &arr[0]};
             CHECK(s.length() == 0 && s.data() == &arr[0]);
         }
 
         {
-            span<int, 0> s{&arr[0], &arr[0]};
+            multi_span<int, 0> s{&arr[0], &arr[0]};
             CHECK(s.length() == 0 && s.data() == &arr[0]);
         }
 
         {
-            auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
+            auto workaround_macro = [&]() { multi_span<int> s{&arr[1], &arr[0]}; };
             CHECK_THROW(workaround_macro(), fail_fast);
         }
 
         {
             int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+            auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; };
             CHECK_THROW(workaround_macro(), fail_fast);
         }
 
         {
             int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{p, p}; };
+            auto workaround_macro = [&]() { multi_span<int> s{p, p}; };
             CHECK_THROW(workaround_macro(), fail_fast);
         }
 
         {
             int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+            auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; };
             CHECK_THROW(workaround_macro(), fail_fast);
         }
     }
@@ -300,64 +300,64 @@ SUITE(span_tests)
         int arr[5] = {1, 2, 3, 4, 5};
 
         {
-            span<int> s{arr};
+            multi_span<int> s{arr};
             CHECK(s.length() == 5 && s.data() == &arr[0]);
         }
 
         {
-            span<int, 5> s{arr};
+            multi_span<int, 5> s{arr};
             CHECK(s.length() == 5 && s.data() == &arr[0]);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 6> s{arr};
+            multi_span<int, 6> s{arr};
 #endif
         }
 
         {
-            span<int, 0> s{arr};
+            multi_span<int, 0> s{arr};
             CHECK(s.length() == 0 && s.data() == &arr[0]);
         }
 
         int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
 
         {
-            span<int> s{arr2d};
+            multi_span<int> s{arr2d};
             CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
             CHECK(s[0] == 1 && s[5] == 6);
         }
 
         {
-            span<int, 0> s{arr2d};
+            multi_span<int, 0> s{arr2d};
             CHECK(s.length() == 0 && s.data() == &arr2d[0][0]);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 5> s{arr2d};
+            multi_span<int, 5> s{arr2d};
 #endif
         }
 
         {
-            span<int, 6> s{arr2d};
+            multi_span<int, 6> s{arr2d};
             CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
             CHECK(s[0] == 1 && s[5] == 6);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 7> s{arr2d};
+            multi_span<int, 7> s{arr2d};
 #endif
         }
 
         {
-            span<int[3]> s{arr2d[0]};
+            multi_span<int[3]> s{arr2d[0]};
             CHECK(s.length() == 1 && s.data() == &arr2d[0]);
         }
 
         {
-            span<int, 2, 3> s{arr2d};
+            multi_span<int, 2, 3> s{arr2d};
             CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
             auto workaround_macro = [&]() { return s[{1, 2}] == 6; };
             CHECK(workaround_macro());
@@ -365,48 +365,48 @@ SUITE(span_tests)
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 3, 3> s{arr2d};
+            multi_span<int, 3, 3> s{arr2d};
 #endif
         }
 
         int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
         {
-            span<int> s{arr3d};
+            multi_span<int> s{arr3d};
             CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
             CHECK(s[0] == 1 && s[11] == 12);
         }
 
         {
-            span<int, 0> s{arr3d};
+            multi_span<int, 0> s{arr3d};
             CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 11> s{arr3d};
+            multi_span<int, 11> s{arr3d};
 #endif
         }
 
         {
-            span<int, 12> s{arr3d};
+            multi_span<int, 12> s{arr3d};
             CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
             CHECK(s[0] == 1 && s[5] == 6);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 13> s{arr3d};
+            multi_span<int, 13> s{arr3d};
 #endif
         }
 
         {
-            span<int[3][2]> s{arr3d[0]};
+            multi_span<int[3][2]> s{arr3d[0]};
             CHECK(s.length() == 1 && s.data() == &arr3d[0]);
         }
 
         {
-            span<int, 3, 2, 2> s{arr3d};
+            multi_span<int, 3, 2, 2> s{arr3d};
             CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
             auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; };
             CHECK(workaround_macro());
@@ -414,7 +414,7 @@ SUITE(span_tests)
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 3, 3, 3> s{arr3d};
+            multi_span<int, 3, 3, 3> s{arr3d};
 #endif
         }
     }
@@ -424,23 +424,23 @@ SUITE(span_tests)
         double(*arr)[3][4] = new double[100][3][4];
 
         {
-            span<double, dynamic_range, 3, 4> s(arr, 10);
+            multi_span<double, dynamic_range, 3, 4> s(arr, 10);
             CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
             CHECK_THROW(s[10][3][4], fail_fast);
         }
 
         {
-            span<double, dynamic_range, 4, 3> s(arr, 10);
+            multi_span<double, dynamic_range, 4, 3> s(arr, 10);
             CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
         }
 
         {
-            span<double> s(arr, 10);
+            multi_span<double> s(arr, 10);
             CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
         }
 
         {
-            span<double, dynamic_range, 3, 4> s(arr, 0);
+            multi_span<double, dynamic_range, 3, 4> s(arr, 0);
             CHECK(s.length() == 0 && s.data() == &arr[0][0][0]);
         }
 
@@ -452,54 +452,54 @@ SUITE(span_tests)
         std::array<int, 4> arr = {1, 2, 3, 4};
 
         {
-            span<int> s{arr};
+            multi_span<int> s{arr};
             CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
 
-            span<const int> cs{arr};
+            multi_span<const int> cs{arr};
             CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
         }
 
         {
-            span<int, 4> s{arr};
+            multi_span<int, 4> s{arr};
             CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
 
-            span<const int, 4> cs{arr};
+            multi_span<const int, 4> cs{arr};
             CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
         }
 
         {
-            span<int, 2> s{arr};
+            multi_span<int, 2> s{arr};
             CHECK(s.size() == 2 && s.data() == arr.data());
 
-            span<const int, 2> cs{arr};
+            multi_span<const int, 2> cs{arr};
             CHECK(cs.size() == 2 && cs.data() == arr.data());
         }
 
         {
-            span<int, 0> s{arr};
+            multi_span<int, 0> s{arr};
             CHECK(s.size() == 0 && s.data() == arr.data());
 
-            span<const int, 0> cs{arr};
+            multi_span<const int, 0> cs{arr};
             CHECK(cs.size() == 0 && cs.data() == arr.data());
         }
 
         // TODO This is currently an unsupported scenario. We will come back to it as we revise
         // the multidimensional interface and what transformations between dimensionality look like
         //{
-        //    span<int, 2, 2> s{arr};
+        //    multi_span<int, 2, 2> s{arr};
         //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
         //}
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 5> s{arr};
+            multi_span<int, 5> s{arr};
 #endif
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; };
-            auto take_a_span = [](span<int> s) { (void) s; };
+            auto take_a_span = [](multi_span<int> s) { (void) s; };
             // try to take a temporary std::array
             take_a_span(get_an_array());
 #endif
@@ -511,42 +511,42 @@ SUITE(span_tests)
         const std::array<int, 4> arr = {1, 2, 3, 4};
 
         {
-            span<const int> s{arr};
+            multi_span<const int> s{arr};
             CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
         }
 
         {
-            span<const int, 4> s{arr};
+            multi_span<const int, 4> s{arr};
             CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
         }
 
         {
-            span<const int, 2> s{arr};
+            multi_span<const int, 2> s{arr};
             CHECK(s.size() == 2 && s.data() == arr.data());
         }
 
         {
-            span<const int, 0> s{arr};
+            multi_span<const int, 0> s{arr};
             CHECK(s.size() == 0 && s.data() == arr.data());
         }
 
         // TODO This is currently an unsupported scenario. We will come back to it as we revise
         // the multidimensional interface and what transformations between dimensionality look like
         //{
-        //    span<int, 2, 2> s{arr};
+        //    multi_span<int, 2, 2> s{arr};
         //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
         //}
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<const int, 5> s{arr};
+            multi_span<const int, 5> s{arr};
 #endif
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
-            auto take_a_span = [](span<const int> s) { (void) s; };
+            auto take_a_span = [](multi_span<const int> s) { (void) s; };
             // try to take a temporary std::array
             take_a_span(get_an_array());
 #endif
@@ -559,10 +559,10 @@ SUITE(span_tests)
         const std::vector<int> cv = v;
 
         {
-            span<int> s{v};
+            multi_span<int> s{v};
             CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data());
 
-            span<const int> cs{v};
+            multi_span<const int> cs{v};
             CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data());
         }
 
@@ -571,18 +571,18 @@ SUITE(span_tests)
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<char> s{str};
+            multi_span<char> s{str};
             CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data());
 #endif
-            span<const char> cs{str};
+            multi_span<const char> cs{str};
             CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data());
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            span<char> s{cstr};
+            multi_span<char> s{cstr};
 #endif
-            span<const char> cs{cstr};
+            multi_span<const char> cs{cstr};
             CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) &&
                   cs.data() == cstr.data());
         }
@@ -590,7 +590,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_vector = []() -> std::vector<int> { return {}; };
-            auto use_span = [](span<int> s) { (void) s; };
+            auto use_span = [](multi_span<int> s) { (void) s; };
             use_span(get_temp_vector());
 #endif
         }
@@ -598,7 +598,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_string = []() -> std::string { return {}; };
-            auto use_span = [](span<char> s) { (void) s; };
+            auto use_span = [](multi_span<char> s) { (void) s; };
             use_span(get_temp_string());
 #endif
         }
@@ -606,7 +606,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_vector = []() -> const std::vector<int> { return {}; };
-            auto use_span = [](span<const char> s) { (void) s; };
+            auto use_span = [](multi_span<const char> s) { (void) s; };
             use_span(get_temp_vector());
 #endif
         }
@@ -614,7 +614,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_string = []() -> const std::string { return {}; };
-            auto use_span = [](span<const char> s) { (void) s; };
+            auto use_span = [](multi_span<const char> s) { (void) s; };
             use_span(get_temp_string());
 #endif
         }
@@ -622,7 +622,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             std::map<int, int> m;
-            span<int> s{m};
+            multi_span<int> s{m};
 #endif
         }
     }
@@ -630,9 +630,9 @@ SUITE(span_tests)
     TEST(from_convertible_span_constructor)
     {
 #ifdef CONFIRM_COMPILATION_ERRORS
-        span<int, 7, 4, 2> av1(nullptr, b1);
+        multi_span<int, 7, 4, 2> av1(nullptr, b1);
 
-        auto f = [&]() { span<int, 7, 4, 2> av1(nullptr); };
+        auto f = [&]() { multi_span<int, 7, 4, 2> av1(nullptr); };
         CHECK_THROW(f(), fail_fast);
 #endif
 
@@ -641,34 +641,34 @@ SUITE(span_tests)
         b12 = b11;
         b11 = b12;
 
-        span<int, dynamic_range> av1 = nullptr;
-        span<int, 7, dynamic_range, 2> av2(av1);
-        span<int, 7, 4, 2> av2(av1);
+        multi_span<int, dynamic_range> av1 = nullptr;
+        multi_span<int, 7, dynamic_range, 2> av2(av1);
+        multi_span<int, 7, 4, 2> av2(av1);
 #endif
 
-        span<DerivedClass> avd;
+        multi_span<DerivedClass> avd;
 #ifdef CONFIRM_COMPILATION_ERRORS
-        span<BaseClass> avb = avd;
+        multi_span<BaseClass> avb = avd;
 #endif
-        span<const DerivedClass> avcd = avd;
+        multi_span<const DerivedClass> avcd = avd;
         (void) avcd;
     }
 
     TEST(copy_move_and_assignment)
     {
-        span<int> s1;
+        multi_span<int> s1;
         CHECK(s1.empty());
 
         int arr[] = {3, 4, 5};
 
-        span<const int> s2 = arr;
+        multi_span<const int> s2 = arr;
         CHECK(s2.length() == 3 && s2.data() == &arr[0]);
 
         s2 = s1;
         CHECK(s2.empty());
 
-        auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
-        auto use_span = [&](span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); };
+        auto get_temp_span = [&]() -> multi_span<int> { return {&arr[1], 2}; };
+        auto use_span = [&](multi_span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); };
         use_span(get_temp_span());
 
         s1 = get_temp_span();
@@ -708,28 +708,28 @@ SUITE(span_tests)
         int arr[5] = {1, 2, 3, 4, 5};
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.first<2>().bounds() == static_bounds<2>()));
             CHECK(av.first<2>().length() == 2);
             CHECK(av.first(2).length() == 2);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.first<0>().bounds() == static_bounds<0>()));
             CHECK(av.first<0>().length() == 0);
             CHECK(av.first(0).length() == 0);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.first<5>().bounds() == static_bounds<5>()));
             CHECK(av.first<5>().length() == 5);
             CHECK(av.first(5).length() == 5);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
             CHECK(av.first<6>().bounds() == static_bounds<6>());
             CHECK(av.first<6>().length() == 6);
@@ -739,7 +739,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av;
+            multi_span<int, dynamic_range> av;
             CHECK((av.first<0>().bounds() == static_bounds<0>()));
             CHECK(av.first<0>().length() == 0);
             CHECK(av.first(0).length() == 0);
@@ -751,28 +751,28 @@ SUITE(span_tests)
         int arr[5] = {1, 2, 3, 4, 5};
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.last<2>().bounds() == static_bounds<2>()));
             CHECK(av.last<2>().length() == 2);
             CHECK(av.last(2).length() == 2);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.last<0>().bounds() == static_bounds<0>()));
             CHECK(av.last<0>().length() == 0);
             CHECK(av.last(0).length() == 0);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.last<5>().bounds() == static_bounds<5>()));
             CHECK(av.last<5>().length() == 5);
             CHECK(av.last(5).length() == 5);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
             CHECK((av.last<6>().bounds() == static_bounds<6>()));
             CHECK(av.last<6>().length() == 6);
@@ -781,7 +781,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av;
+            multi_span<int, dynamic_range> av;
             CHECK((av.last<0>().bounds() == static_bounds<0>()));
             CHECK(av.last<0>().length() == 0);
             CHECK(av.last(0).length() == 0);
@@ -793,7 +793,7 @@ SUITE(span_tests)
         int arr[5] = {1, 2, 3, 4, 5};
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>()));
             CHECK((av.subspan<2, 2>().length() == 2));
             CHECK(av.subspan(2, 2).length() == 2);
@@ -801,14 +801,14 @@ SUITE(span_tests)
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
             CHECK((av.subspan<0, 0>().length() == 0));
             CHECK(av.subspan(0, 0).length() == 0);
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>()));
             CHECK((av.subspan<0, 5>().length() == 5));
             CHECK(av.subspan(0, 5).length() == 5);
@@ -817,7 +817,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>()));
             CHECK((av.subspan<5, 0>().length() == 0));
             CHECK(av.subspan(5, 0).length() == 0);
@@ -825,7 +825,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av;
+            multi_span<int, dynamic_range> av;
             CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
             CHECK((av.subspan<0, 0>().length() == 0));
             CHECK(av.subspan(0, 0).length() == 0);
@@ -833,13 +833,13 @@ SUITE(span_tests)
         }
 
         {
-            span<int> av;
+            multi_span<int> av;
             CHECK(av.subspan(0).length() == 0);
             CHECK_THROW(av.subspan(1).length(), fail_fast);
         }
 
         {
-            span<int> av = arr;
+            multi_span<int> av = arr;
             CHECK(av.subspan(0).length() == 5);
             CHECK(av.subspan(1).length() == 4);
             CHECK(av.subspan(4).length() == 1);
@@ -850,7 +850,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, 5> av = arr;
+            multi_span<int, 5> av = arr;
             CHECK(av.subspan(0).length() == 5);
             CHECK(av.subspan(1).length() == 4);
             CHECK(av.subspan(4).length() == 1);
@@ -866,18 +866,18 @@ SUITE(span_tests)
         int arr[2] = {1, 2};
 
         {
-            span<int> s;
+            multi_span<int> s;
             CHECK(s.rank() == 1);
         }
 
         {
-            span<int, 2> s = arr;
+            multi_span<int, 2> s = arr;
             CHECK(s.rank() == 1);
         }
 
         int arr2d[1][1] = {};
         {
-            span<int, 1, 1> s = arr2d;
+            multi_span<int, 1, 1> s = arr2d;
             CHECK(s.rank() == 2);
         }
     }
@@ -885,7 +885,7 @@ SUITE(span_tests)
     TEST(extent)
     {
         {
-            span<int> s;
+            multi_span<int> s;
             CHECK(s.extent() == 0);
             CHECK(s.extent(0) == 0);
             CHECK_THROW(s.extent(1), fail_fast);
@@ -895,7 +895,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, 0> s;
+            multi_span<int, 0> s;
             CHECK(s.extent() == 0);
             CHECK(s.extent(0) == 0);
             CHECK_THROW(s.extent(1), fail_fast);
@@ -904,7 +904,7 @@ SUITE(span_tests)
         {
             int arr2d[1][2] = {};
 
-            span<int, 1, 2> s = arr2d;
+            multi_span<int, 1, 2> s = arr2d;
             CHECK(s.extent() == 1);
             CHECK(s.extent<0>() == 1);
             CHECK(s.extent<1>() == 2);
@@ -916,7 +916,7 @@ SUITE(span_tests)
         {
             int arr2d[1][2] = {};
 
-            span<int, 0, 2> s = arr2d;
+            multi_span<int, 0, 2> s = arr2d;
             CHECK(s.extent() == 0);
             CHECK(s.extent<0>() == 0);
             CHECK(s.extent<1>() == 2);
@@ -931,7 +931,7 @@ SUITE(span_tests)
         int arr[4] = {1, 2, 3, 4};
 
         {
-            span<int> s = arr;
+            multi_span<int> s = arr;
             CHECK(s(0) == 1);
             CHECK_THROW(s(5), fail_fast);
         }
@@ -939,7 +939,7 @@ SUITE(span_tests)
         int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
 
         {
-            span<int, 2, 3> s = arr2d;
+            multi_span<int, 2, 3> s = arr2d;
             CHECK(s(0, 0) == 1);
             CHECK(s(1, 2) == 6);
         }
@@ -950,11 +950,11 @@ SUITE(span_tests)
         {
             int arr[10][2];
             auto s1 = as_span(arr);
-            span<const int, dynamic_range, 2> s2 = s1;
+            multi_span<const int, dynamic_range, 2> s2 = s1;
 
             CHECK(s1 == s2);
 
-            span<int, 20> s3 = as_span(s1, dim<>(20));
+            multi_span<int, 20> s3 = as_span(s1, dim<>(20));
             CHECK(s3 == s2 && s3 == s1);
         }
 
@@ -978,8 +978,8 @@ SUITE(span_tests)
         {
             int arr[] = {2, 1}; // bigger
 
-            span<int> s1 = nullptr;
-            span<int> s2 = arr;
+            multi_span<int> s1 = nullptr;
+            multi_span<int> s2 = arr;
 
             CHECK(s1 != s2);
             CHECK(s2 != s1);
@@ -998,8 +998,8 @@ SUITE(span_tests)
         {
             int arr1[] = {1, 2};
             int arr2[] = {1, 2};
-            span<int> s1 = arr1;
-            span<int> s2 = arr2;
+            multi_span<int> s1 = arr1;
+            multi_span<int> s2 = arr2;
 
             CHECK(s1 == s2);
             CHECK(!(s1 != s2));
@@ -1018,8 +1018,8 @@ SUITE(span_tests)
         {
             int arr[] = {1, 2, 3};
 
-            span<int> s1 = {&arr[0], 2}; // shorter
-            span<int> s2 = arr; // longer
+            multi_span<int> s1 = {&arr[0], 2}; // shorter
+            multi_span<int> s2 = arr; // longer
 
             CHECK(s1 != s2);
             CHECK(s2 != s1);
@@ -1039,8 +1039,8 @@ SUITE(span_tests)
             int arr1[] = {1, 2}; // smaller
             int arr2[] = {2, 1}; // bigger
 
-            span<int> s1 = arr1;
-            span<int> s2 = arr2;
+            multi_span<int> s1 = arr1;
+            multi_span<int> s2 = arr2;
 
             CHECK(s1 != s2);
             CHECK(s2 != s1);
@@ -1086,21 +1086,21 @@ SUITE(span_tests)
         CHECK_THROW((av[{10, 2}]), fail_fast);
     }
 
-    void overloaded_func(span<const int, dynamic_range, 3, 5> exp, int expected_value)
+    void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int expected_value)
     {
         for (auto val : exp) {
             CHECK(val == expected_value);
         }
     }
 
-    void overloaded_func(span<const char, dynamic_range, 3, 5> exp, char expected_value)
+    void overloaded_func(multi_span<const char, dynamic_range, 3, 5> exp, char expected_value)
     {
         for (auto val : exp) {
             CHECK(val == expected_value);
         }
     }
 
-    void fixed_func(span<int, 3, 3, 5> exp, int expected_value)
+    void fixed_func(multi_span<int, 3, 3, 5> exp, int expected_value)
     {
         for (auto val : exp) {
             CHECK(val == expected_value);
@@ -1185,10 +1185,10 @@ SUITE(span_tests)
 
         {
             string str;
-            span<char> strspan = as_span(str);
+            multi_span<char> strspan = as_span(str);
             (void) strspan;
             const string cstr;
-            span<const char> cstrspan = as_span(cstr);
+            multi_span<const char> cstrspan = as_span(cstr);
             (void) cstrspan;
         }
 
@@ -1218,7 +1218,7 @@ SUITE(span_tests)
     TEST(empty_spans)
     {
         {
-            span<int, 0> empty_av(nullptr);
+            multi_span<int, 0> empty_av(nullptr);
 
             CHECK(empty_av.bounds().index_bounds() == index<1>{0});
             CHECK_THROW(empty_av[0], fail_fast);
@@ -1231,7 +1231,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int> empty_av = {};
+            multi_span<int> empty_av = {};
             CHECK(empty_av.bounds().index_bounds() == index<1>{0});
             CHECK_THROW(empty_av[0], fail_fast);
             CHECK_THROW(empty_av.begin()[0], fail_fast);
@@ -1251,7 +1251,7 @@ SUITE(span_tests)
             arr[2 * i + 1] = i;
         }
 
-        span<int, dynamic_range> av(arr, 8);
+        multi_span<int, dynamic_range> av(arr, 8);
 
         ptrdiff_t a[1] = {0};
         index<1> i = a;
@@ -1395,7 +1395,7 @@ SUITE(span_tests)
         }
     }
 
-    void iterate_second_column(span<int, dynamic_range, dynamic_range> av)
+    void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
     {
         auto length = av.size() / 2;
 
@@ -1456,22 +1456,22 @@ SUITE(span_tests)
 
         // static bounds
         {
-            span<int, 4, 2> av = arr;
+            multi_span<int, 4, 2> av = arr;
             iterate_second_column(av);
         }
         // first bound is dynamic
         {
-            span<int, dynamic_range, 2> av = arr;
+            multi_span<int, dynamic_range, 2> av = arr;
             iterate_second_column(av);
         }
         // second bound is dynamic
         {
-            span<int, 4, dynamic_range> av = arr;
+            multi_span<int, 4, dynamic_range> av = arr;
             iterate_second_column(av);
         }
         // both bounds are dynamic
         {
-            span<int, dynamic_range, dynamic_range> av = arr;
+            multi_span<int, dynamic_range, dynamic_range> av = arr;
             iterate_second_column(av);
         }
     }
@@ -1490,17 +1490,17 @@ SUITE(span_tests)
 
         // first bound is dynamic
         {
-            span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
         // second bound is dynamic
         {
-            span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
         // both bounds are dynamic
         {
-            span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
 
@@ -1510,7 +1510,7 @@ SUITE(span_tests)
     TEST(span_structure_size)
     {
         double(*arr)[3][4] = new double[100][3][4];
-        span<double, dynamic_range, 3, 4> av1(arr, 10);
+        multi_span<double, dynamic_range, 3, 4> av1(arr, 10);
 
         struct EffectiveStructure
         {
@@ -1521,7 +1521,7 @@ SUITE(span_tests)
 
         CHECK_THROW(av1[10][3][4], fail_fast);
 
-        span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>());
+        multi_span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>());
         (void) av2;
     }
 
@@ -1529,46 +1529,46 @@ SUITE(span_tests)
     {
         int arr[] = {1, 2, 3, 4};
 
-        // converting to an span from an equal size array is ok
-        span<int, 4> av4 = arr;
+        // converting to an multi_span from an equal size array is ok
+        multi_span<int, 4> av4 = arr;
         CHECK(av4.length() == 4);
 
         // converting to dynamic_range a_v is always ok
         {
-            span<int, dynamic_range> av = av4;
+            multi_span<int, dynamic_range> av = av4;
             (void) av;
         }
         {
-            span<int, dynamic_range> av = arr;
+            multi_span<int, dynamic_range> av = arr;
             (void) av;
         }
 
-// initialization or assignment to static span that REDUCES size is NOT ok
+// initialization or assignment to static multi_span that REDUCES size is NOT ok
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<int, 2> av2 = arr;
+            multi_span<int, 2> av2 = arr;
         }
         {
-            span<int, 2> av2 = av4;
+            multi_span<int, 2> av2 = av4;
         }
 #endif
 
         {
-            span<int, dynamic_range> av = arr;
-            span<int, 2> av2 = av;
+            multi_span<int, dynamic_range> av = arr;
+            multi_span<int, 2> av2 = av;
             (void) av2;
         }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<int, dynamic_range> av = arr;
-            span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>());
+            multi_span<int, dynamic_range> av = arr;
+            multi_span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>());
         }
 #endif
 
         {
-            span<int, dynamic_range> av = arr;
-            span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2));
+            multi_span<int, dynamic_range> av = arr;
+            multi_span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2));
             auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
             CHECK(workaround_macro());
         }
@@ -1577,45 +1577,45 @@ SUITE(span_tests)
 
         // you can convert statically
         {
-            span<int, 2> av2 = {arr, 2};
+            multi_span<int, 2> av2 = {arr, 2};
             (void) av2;
         }
         {
-            span<int, 1> av2 = av4.first<1>();
+            multi_span<int, 1> av2 = av4.first<1>();
             (void) av2;
         }
 
         // ...or dynamically
         {
-            // NB: implicit conversion to span<int,2> from span<int,dynamic_range>
-            span<int, 1> av2 = av4.first(1);
+            // NB: implicit conversion to multi_span<int,2> from multi_span<int,dynamic_range>
+            multi_span<int, 1> av2 = av4.first(1);
             (void) av2;
         }
 
-        // initialization or assignment to static span that requires size INCREASE is not ok.
+        // initialization or assignment to static multi_span that requires size INCREASE is not ok.
         int arr2[2] = {1, 2};
 
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<int, 4> av4 = arr2;
+            multi_span<int, 4> av4 = arr2;
         }
         {
-            span<int, 2> av2 = arr2;
-            span<int, 4> av4 = av2;
+            multi_span<int, 2> av2 = arr2;
+            multi_span<int, 4> av4 = av2;
         }
 #endif
         {
             auto f = [&]() {
-                span<int, 4> av9 = {arr2, 2};
+                multi_span<int, 4> av9 = {arr2, 2};
                 (void) av9;
             };
             CHECK_THROW(f(), fail_fast);
         }
 
         // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one
-        span<int, dynamic_range> av = arr2;
+        multi_span<int, dynamic_range> av = arr2;
         auto f = [&]() {
-            span<int, 4> av2 = av;
+            multi_span<int, 4> av2 = av;
             (void) av2;
         };
         CHECK_THROW(f(), fail_fast);
@@ -1628,13 +1628,13 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             // you should not be able to get writeable bytes for const objects
-            span<const int, dynamic_range> av = a;
+            multi_span<const int, dynamic_range> av = a;
             auto wav = av.as_writeable_bytes();
 #endif
         }
 
         {
-            span<int, dynamic_range> av;
+            multi_span<int, dynamic_range> av;
             auto wav = as_writeable_bytes(av);
             CHECK(wav.length() == av.length());
             CHECK(wav.length() == 0);
@@ -1642,7 +1642,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av = a;
+            multi_span<int, dynamic_range> av = a;
             auto wav = as_writeable_bytes(av);
             CHECK(wav.data() == (byte*) &a[0]);
             CHECK(wav.length() == sizeof(a));
@@ -1654,7 +1654,7 @@ SUITE(span_tests)
         int a[] = {1, 2, 3, 4};
 
         {
-            span<int, dynamic_range> av = a;
+            multi_span<int, dynamic_range> av = a;
             auto wav = as_writeable_bytes(av);
             for (auto& b : wav) {
                 b = byte(0);
@@ -1665,7 +1665,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av = a;
+            multi_span<int, dynamic_range> av = a;
             for (auto& n : av) {
                 n = 1;
             }
diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp
index 0fbf1d7..8b96ddf 100644
--- a/tests/strided_span_tests.cpp
+++ b/tests/strided_span_tests.cpp
@@ -49,7 +49,7 @@ SUITE(strided_span_tests)
 	{
 		std::vector<int> data(5 * 10);
 		std::iota(begin(data), end(data), 0);
-        const span<int, 5, 10> av = as_span(span<int>{data}, dim<5>(), dim<10>());
+        const multi_span<int, 5, 10> av = as_span(multi_span<int>{data}, dim<5>(), dim<10>());
 
 		strided_span<int, 2> av_section_1 = av.section({ 1, 2 }, { 3, 4 });
 		CHECK((av_section_1[{0, 0}] == 12));
@@ -87,13 +87,13 @@ SUITE(strided_span_tests)
 			CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7));
 		}
 
-		// Check span constructor
+		// Check multi_span constructor
 		{
 			int arr[] = { 1, 2 };
 
 			// From non-cv-qualified source
 			{
-				const span<int> src = arr;
+				const multi_span<int> src = arr;
 
 				strided_span<int, 1> sav{ src, {2, 1} };
 				CHECK(sav.bounds().index_bounds() == index<1>{ 2 });
@@ -102,9 +102,9 @@ SUITE(strided_span_tests)
 
 #if _MSC_VER > 1800
 				//strided_span<const int, 1> sav_c{ {src}, {2, 1} };
-				strided_span<const int, 1> sav_c{ span<const int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} };
 #else
-				strided_span<const int, 1> sav_c{ span<const int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} };
 #endif
 				CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 });
 				CHECK(sav_c.bounds().strides() == index<1>{ 1 });
@@ -113,7 +113,7 @@ SUITE(strided_span_tests)
 #if _MSC_VER > 1800
 				strided_span<volatile int, 1> sav_v{ src, {2, 1} };
 #else
-				strided_span<volatile int, 1> sav_v{ span<volatile int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<volatile int, 1> sav_v{ multi_span<volatile int>{src}, strided_bounds<1>{2, 1} };
 #endif
 				CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 });
 				CHECK(sav_v.bounds().strides() == index<1>{ 1 });
@@ -122,7 +122,7 @@ SUITE(strided_span_tests)
 #if _MSC_VER > 1800
 				strided_span<const volatile int, 1> sav_cv{ src, {2, 1} };
 #else
-				strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} };
 #endif
 				CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 });
 				CHECK(sav_cv.bounds().strides() == index<1>{ 1 });
@@ -131,7 +131,7 @@ SUITE(strided_span_tests)
 
 			// From const-qualified source
 			{
-				const span<const int> src{ arr };
+				const multi_span<const int> src{ arr };
 
 				strided_span<const int, 1> sav_c{ src, {2, 1} };
 				CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 });
@@ -141,7 +141,7 @@ SUITE(strided_span_tests)
 #if _MSC_VER > 1800
 				strided_span<const volatile int, 1> sav_cv{ src, {2, 1} };
 #else
-				strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} };
 #endif
 				
 				CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 });
@@ -151,7 +151,7 @@ SUITE(strided_span_tests)
 
 			// From volatile-qualified source
 			{
-				const span<volatile int> src{ arr };
+				const multi_span<volatile int> src{ arr };
 
 				strided_span<volatile int, 1> sav_v{ src, {2, 1} };
 				CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 });
@@ -161,7 +161,7 @@ SUITE(strided_span_tests)
 #if _MSC_VER > 1800
 				strided_span<const volatile int, 1> sav_cv{ src, {2, 1} };
 #else
-				strided_span<const volatile int, 1> sav_cv{ span<const volatile int>{src}, strided_bounds<1>{2, 1} };
+				strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} };
 #endif
 				CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 });
 				CHECK(sav_cv.bounds().strides() == index<1>{ 1 });
@@ -170,7 +170,7 @@ SUITE(strided_span_tests)
 
 			// From cv-qualified source
 			{
-				const span<const volatile int> src{ arr };
+				const multi_span<const volatile int> src{ arr };
 
 				strided_span<const volatile int, 1> sav_cv{ src, {2, 1} };
 				CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 });
@@ -183,11 +183,11 @@ SUITE(strided_span_tests)
 		{
 			int arr[2] = { 4, 5 };
 
-			const span<int, 2> av(arr, 2);
-			span<const int, 2> av2{ av };
+			const multi_span<int, 2> av(arr, 2);
+			multi_span<const int, 2> av2{ av };
 			CHECK(av2[1] == 5);
 
-			static_assert(std::is_convertible<const span<int, 2>, span<const int, 2>>::value, "ctor is not implicit!");
+			static_assert(std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value, "ctor is not implicit!");
 		
 			const strided_span<int, 1> src{ arr, {2, 1} };
 			strided_span<const int, 1> sav{ src };
@@ -258,13 +258,13 @@ SUITE(strided_span_tests)
 	{
 		std::vector<int> data(5 * 10);
 		std::iota(begin(data), end(data), 0);
-        const span<int, 5, 10> src = as_span(span<int>{data}, dim<5>(), dim<10>());
+        const multi_span<int, 5, 10> src = as_span(multi_span<int>{data}, dim<5>(), dim<10>());
 
 		const strided_span<int, 2> sav{ src, {{5, 10}, {10, 1}} };
 #ifdef CONFIRM_COMPILATION_ERRORS
 		const strided_span<const int, 2> csav{ {src},{ { 5, 10 },{ 10, 1 } } };
 #endif
-		const strided_span<const int, 2> csav{ span<const int, 5, 10>{ src }, { { 5, 10 },{ 10, 1 } } };
+		const strided_span<const int, 2> csav{ multi_span<const int, 5, 10>{ src }, { { 5, 10 },{ 10, 1 } } };
 
 		strided_span<int, 1> sav_sl = sav[2];
 		CHECK(sav_sl[0] == 20);
@@ -317,7 +317,7 @@ SUITE(strided_span_tests)
 	TEST(strided_span_bounds)
 	{
 		int arr[] = { 0, 1, 2, 3 };
-		span<int> av(arr);
+		multi_span<int> av(arr);
 
 		{
 			// incorrect sections
@@ -432,7 +432,7 @@ SUITE(strided_span_tests)
 	TEST(strided_span_type_conversion)
 	{
 		int arr[] = { 0, 1, 2, 3 };
-		span<int> av(arr);
+		multi_span<int> av(arr);
 
 		{
 			strided_span<int, 1> sav{ av.data(), av.size(), { av.size() / 2, 2 } };
@@ -447,7 +447,7 @@ SUITE(strided_span_tests)
 #endif
 		}
 
-		span<const byte, dynamic_range> bytes = as_bytes(av);
+		multi_span<const byte, dynamic_range> bytes = as_bytes(av);
 
 		// retype strided array with regular strides - from raw data
 		{
@@ -460,10 +460,10 @@ SUITE(strided_span_tests)
 			CHECK_THROW(sav3[0][1], fail_fast);
 		}
 
-		// retype strided array with regular strides - from span
+		// retype strided array with regular strides - from multi_span
 		{
 			strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } };
-			span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
 			CHECK(sav3[0][0] == 0);
@@ -475,7 +475,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension of the array is too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } };
-			span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -483,7 +483,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides are too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } };
-			span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -491,7 +491,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } };
-			span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -499,7 +499,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } };
-			span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -511,7 +511,7 @@ SUITE(strided_span_tests)
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
 
-		// retype strided array with irregular strides - from span
+		// retype strided array with irregular strides - from multi_span
 		{
 			strided_bounds<1> bounds{ bytes.size() / 2, 2 };
 			strided_span<const byte, 1> sav2{ bytes, bounds };
@@ -522,7 +522,7 @@ SUITE(strided_span_tests)
 	TEST(empty_strided_spans)
 	{
 		{
-			span<int, 0> empty_av(nullptr);
+			multi_span<int, 0> empty_av(nullptr);
 			strided_span<int, 1> empty_sav{ empty_av, { 0, 1 } };
 
 			CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 });
@@ -553,7 +553,7 @@ SUITE(strided_span_tests)
 		}
 	}
 
-    void iterate_every_other_element(span<int, dynamic_range> av)
+    void iterate_every_other_element(multi_span<int, dynamic_range> av)
     {
         // pick every other element
 
@@ -586,13 +586,13 @@ SUITE(strided_span_tests)
 
         // static bounds
         {
-            span<int, 8> av(arr, 8);
+            multi_span<int, 8> av(arr, 8);
             iterate_every_other_element(av);
         }
 
         // dynamic bounds
         {
-            span<int, dynamic_range> av(arr, 8);
+            multi_span<int, dynamic_range> av(arr, 8);
             iterate_every_other_element(av);
         }
     }
@@ -612,7 +612,7 @@ SUITE(strided_span_tests)
         delete[] arr;
     }
 
-    void iterate_second_slice(span<int, dynamic_range, dynamic_range, dynamic_range> av)
+    void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av)
     {
         int expected[6] = {2,3,10,11,18,19};
         auto section = av.section({0,1,0}, {3,1,2});
@@ -653,7 +653,7 @@ SUITE(strided_span_tests)
         }
 
         {
-            span<int, 3, 4, 2> av = arr;
+            multi_span<int, 3, 4, 2> av = arr;
             iterate_second_slice(av);
         }
     }
@@ -693,7 +693,7 @@ SUITE(strided_span_tests)
 
     TEST(strided_span_conversion)
     {
-        // get an span of 'c' values from the list of X's
+        // get an multi_span of 'c' values from the list of X's
 
         struct X { int a; int b; int c; };
 
diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp
index 28d7353..cd301a0 100644
--- a/tests/string_span_tests.cpp
+++ b/tests/string_span_tests.cpp
@@ -142,7 +142,7 @@ SUITE(string_span_tests)
             const char* ptr = "Hello";
             const std::string str = "Hello";
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::span<const char> sp = ensure_z("Hello");
+            gsl::multi_span<const char> sp = ensure_z("Hello");
 
             // comparison to  literal
             CHECK(span == cstring_span<>("Hello"));
@@ -182,7 +182,7 @@ SUITE(string_span_tests)
             char* ptr = ar;
             std::string str = "Hello";
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::span<char> sp = ensure_z(ar1);
+            gsl::multi_span<char> sp = ensure_z(ar1);
 
             // comparison to static array with no null termination
             CHECK(span == string_span<>(ar));
@@ -216,7 +216,7 @@ SUITE(string_span_tests)
             const char ar2[10] = "Hello";
             const std::string str = "Hello";
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::span<const char> sp = ensure_z("Hello");
+            gsl::multi_span<const char> sp = ensure_z("Hello");
 
             cstring_span<> span = "Hello";
 
@@ -253,7 +253,7 @@ SUITE(string_span_tests)
             char* _ptr = _ar;
             std::string _str = "Hello";
             std::vector<char> _vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::span<char> _sp{ _ar, 5 };
+            gsl::multi_span<char> _sp{ _ar, 5 };
 
             CHECK(span == _ar);
             CHECK(span == _ar1);
@@ -447,7 +447,7 @@ SUITE(string_span_tests)
 
         // from span of a final extent
         {
-            span<const char, 6> sp = "Hello";
+            multi_span<const char, 6> sp = "Hello";
             cstring_span<> span = sp;
             CHECK(span.length() == 6);
         }
@@ -455,7 +455,7 @@ SUITE(string_span_tests)
         // from const span of a final extent to non-const string_span
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<const char, 6> sp = "Hello";
+            multi_span<const char, 6> sp = "Hello";
             string_span<> span = sp;
             CHECK(span.length() == 6);
         }
@@ -568,7 +568,7 @@ SUITE(string_span_tests)
         // from const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const span<const char> inner = vec;
+            const multi_span<const char> inner = vec;
             cstring_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -576,7 +576,7 @@ SUITE(string_span_tests)
         // from non-const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            span<char> inner = vec;
+            multi_span<char> inner = vec;
             cstring_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -675,7 +675,7 @@ SUITE(string_span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const span<const char> inner = vec;
+            const multi_span<const char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
 #endif
@@ -684,7 +684,7 @@ SUITE(string_span_tests)
         // from non-const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            span<char> inner = vec;
+            multi_span<char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -693,7 +693,7 @@ SUITE(string_span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const span<char> inner = vec;
+            const multi_span<char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
 #endif
@@ -769,12 +769,12 @@ SUITE(string_span_tests)
 
         // move span
         {
-            span<const char> span = ensure_z("Hello");
+            multi_span<const char> span = ensure_z("Hello");
             cstring_span<> span1 = std::move(span);
             CHECK(span1.length() == 5);
         }
         {
-            span<const char> span = ensure_z("Hello");
+            multi_span<const char> span = ensure_z("Hello");
             cstring_span<> span2 = move_wrapper(std::move(span));
             CHECK(span2.length() == 5);
         }

From d2f12a8fa3df7d0debaa683c4c4cabcaeea383a1 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 24 Feb 2016 11:03:33 -0800
Subject: [PATCH 03/42] File renames to reflect new multi_span name.

---
 include/gsl.h                                  | 3 ++-
 include/{span.h => multi_span.h}               | 0
 include/string_span.h                          | 2 +-
 tests/CMakeLists.txt                           | 4 ++--
 tests/bounds_tests.cpp                         | 2 +-
 tests/{span_tests.cpp => multi_span_tests.cpp} | 4 ++--
 tests/strided_span_tests.cpp                   | 2 +-
 7 files changed, 9 insertions(+), 8 deletions(-)
 rename include/{span.h => multi_span.h} (100%)
 rename tests/{span_tests.cpp => multi_span_tests.cpp} (99%)

diff --git a/include/gsl.h b/include/gsl.h
index ad064ba..03f8545 100644
--- a/include/gsl.h
+++ b/include/gsl.h
@@ -21,7 +21,8 @@
 
 #include "gsl_assert.h"  // Ensures/Expects
 #include "gsl_util.h"    // finally()/narrow()/narrow_cast()...
-#include "span.h"           // span, strided_span...
+//#include "span.h"           // span
+#include "multi_span.h"           // multi_span, strided_span...
 #include "string_span.h"    // zstring, string_span, zstring_builder...
 #include <memory>
 
diff --git a/include/span.h b/include/multi_span.h
similarity index 100%
rename from include/span.h
rename to include/multi_span.h
diff --git a/include/string_span.h b/include/string_span.h
index f585d3f..c58cef9 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -21,7 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
-#include "span.h"
+#include "multi_span.h"
 #include <cstring>
 #include <string>
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7990ec3..87999dc 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -33,7 +33,7 @@ if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/unittest-cpp)
 endif()
 
 function(add_gsl_test name)
-    add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/span.h ../include/string_span.h)
+    add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/multi_span.h ../include/string_span.h)
     target_link_libraries(${name} UnitTest++)
     install(TARGETS ${name}
         RUNTIME DESTINATION bin
@@ -44,7 +44,7 @@ function(add_gsl_test name)
     )
 endfunction()
 
-add_gsl_test(span_tests)
+add_gsl_test(multi_span_tests)
 add_gsl_test(strided_span_tests)
 add_gsl_test(string_span_tests)
 add_gsl_test(at_tests)
diff --git a/tests/bounds_tests.cpp b/tests/bounds_tests.cpp
index ab8c5bd..736a85c 100644
--- a/tests/bounds_tests.cpp
+++ b/tests/bounds_tests.cpp
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <UnitTest++/UnitTest++.h> 
-#include <span.h>
+#include <multi_span.h>
 #include <vector>
 
 using namespace std;
diff --git a/tests/span_tests.cpp b/tests/multi_span_tests.cpp
similarity index 99%
rename from tests/span_tests.cpp
rename to tests/multi_span_tests.cpp
index 0d1170d..207428d 100644
--- a/tests/span_tests.cpp
+++ b/tests/multi_span_tests.cpp
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <UnitTest++/UnitTest++.h>
-#include <span.h>
+#include <multi_span.h>
 
 #include <iostream>
 #include <list>
@@ -37,7 +37,7 @@ struct DerivedClass : BaseClass
 };
 }
 
-SUITE(span_tests)
+SUITE(multi_span_tests)
 {
 
     TEST(default_constructor)
diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp
index 8b96ddf..9fcdfeb 100644
--- a/tests/strided_span_tests.cpp
+++ b/tests/strided_span_tests.cpp
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <UnitTest++/UnitTest++.h> 
-#include <span.h>
+#include <multi_span.h>
 
 #include <string>
 #include <vector>

From cec26a23b93491f564a7c38e66fee73a8cc1e86c Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 24 Feb 2016 11:26:28 -0800
Subject: [PATCH 04/42] Added new span-related files.

---
 include/gsl.h        |    2 +-
 include/multi_span.h |    6 +-
 include/span.h       |  115 +++
 tests/CMakeLists.txt |    3 +-
 tests/span_tests.cpp | 1680 ++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 1801 insertions(+), 5 deletions(-)
 create mode 100644 include/span.h
 create mode 100644 tests/span_tests.cpp

diff --git a/include/gsl.h b/include/gsl.h
index 03f8545..4eb555b 100644
--- a/include/gsl.h
+++ b/include/gsl.h
@@ -21,7 +21,7 @@
 
 #include "gsl_assert.h"  // Ensures/Expects
 #include "gsl_util.h"    // finally()/narrow()/narrow_cast()...
-//#include "span.h"           // span
+#include "span.h"           // span
 #include "multi_span.h"           // multi_span, strided_span...
 #include "string_span.h"    // zstring, string_span, zstring_builder...
 #include <memory>
diff --git a/include/multi_span.h b/include/multi_span.h
index 659e116..b070f29 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#ifndef GSL_SPAN_H
-#define GSL_SPAN_H
+#ifndef GSL_MULTI_SPAN_H
+#define GSL_MULTI_SPAN_H
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
@@ -2221,4 +2221,4 @@ general_span_iterator<Span> operator+(typename general_span_iterator<Span>::diff
 
 #endif // GSL_THROW_ON_CONTRACT_VIOLATION
 
-#endif // GSL_SPAN_H
+#endif // GSL_MULTI_SPAN_H
diff --git a/include/span.h b/include/span.h
new file mode 100644
index 0000000..7df4964
--- /dev/null
+++ b/include/span.h
@@ -0,0 +1,115 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#ifndef GSL_SPAN_H
+#define GSL_SPAN_H
+
+#include "gsl_assert.h"
+#include "gsl_util.h"
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <new>
+#include <numeric>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+#ifdef _MSC_VER
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+
+// No MSVC does constexpr fully yet
+#pragma push_macro("constexpr")
+#define constexpr
+
+// VS 2013 workarounds
+#if _MSC_VER <= 1800
+
+#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG
+#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
+
+// noexcept is not understood 
+#ifndef GSL_THROW_ON_CONTRACT_VIOLATION
+#pragma push_macro("noexcept")
+#define noexcept /* nothing */
+#endif
+
+// turn off some misguided warnings
+#pragma warning(push)
+#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior
+#pragma warning(disable : 4512) // warns that assignment op could not be generated
+
+#endif // _MSC_VER <= 1800
+
+#endif // _MSC_VER
+
+#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
+
+#ifdef _MSC_VER
+#pragma push_macro("noexcept")
+#endif
+
+#define noexcept /* nothing */
+
+#endif // GSL_THROW_ON_CONTRACT_VIOLATION
+
+namespace gsl
+{
+
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+
+#undef constexpr
+#pragma pop_macro("constexpr")
+
+#if _MSC_VER <= 1800
+#pragma warning(pop)
+
+#ifndef GSL_THROW_ON_CONTRACT_VIOLATION
+#undef noexcept
+#pragma pop_macro("noexcept")
+#endif // GSL_THROW_ON_CONTRACT_VIOLATION
+
+#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG
+
+#endif // _MSC_VER <= 1800
+
+#endif // _MSC_VER
+
+#if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
+
+#undef noexcept
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#pragma pop_macro("noexcept")
+#endif
+
+#endif // GSL_THROW_ON_CONTRACT_VIOLATION
+
+#endif // GSL_SPAN_H
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 87999dc..9723309 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -33,7 +33,7 @@ if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/unittest-cpp)
 endif()
 
 function(add_gsl_test name)
-    add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/multi_span.h ../include/string_span.h)
+    add_executable(${name} ${name}.cpp ../include/gsl.h ../include/gsl_assert.h ../include/gsl_util.h ../include/multi_span.h ../include/span.h ../include/string_span.h)
     target_link_libraries(${name} UnitTest++)
     install(TARGETS ${name}
         RUNTIME DESTINATION bin
@@ -44,6 +44,7 @@ function(add_gsl_test name)
     )
 endfunction()
 
+add_gsl_test(span_tests)
 add_gsl_test(multi_span_tests)
 add_gsl_test(strided_span_tests)
 add_gsl_test(string_span_tests)
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
new file mode 100644
index 0000000..83eec0e
--- /dev/null
+++ b/tests/span_tests.cpp
@@ -0,0 +1,1680 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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 <UnitTest++/UnitTest++.h>
+#include <span.h>
+
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace gsl;
+
+namespace
+{
+struct BaseClass
+{
+};
+struct DerivedClass : BaseClass
+{
+};
+}
+
+SUITE(span_tests)
+{
+#if 0
+    TEST(default_constructor)
+    {
+        {
+            span<int> s;
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int> cs;
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+            span<int, 0> s;
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int, 0> cs;
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 1> s;
+            CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
+#endif
+        }
+
+        {
+            span<int> s{};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int> cs{};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+    }
+
+    TEST(from_nullptr_constructor)
+    {
+        {
+            span<int> s = nullptr;
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int> cs = nullptr;
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+            span<int, 0> s = nullptr;
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int, 0> cs = nullptr;
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 1> s = nullptr;
+            CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
+#endif
+        }
+
+        {
+            span<int> s{nullptr};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int> cs{nullptr};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+            span<int*> s{nullptr};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int*> cs{nullptr};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+    }
+
+    TEST(from_nullptr_length_constructor)
+    {
+        {
+            span<int> s{nullptr, 0};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int> cs{nullptr, 0};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+            span<int, 0> s{nullptr, 0};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int, 0> cs{nullptr, 0};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 1> s{nullptr, 0};
+            CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
+#endif
+        }
+
+        {
+            auto workaround_macro = []() { span<int> s{nullptr, 1}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+
+            auto const_workaround_macro = []() { span<const int> cs{nullptr, 1}; };
+            CHECK_THROW(const_workaround_macro(), fail_fast);
+        }
+
+        {
+            auto workaround_macro = []() { span<int, 0> s{nullptr, 1}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+
+            auto const_workaround_macro = []() { span<const int, 0> s{nullptr, 1}; };
+            CHECK_THROW(const_workaround_macro(), fail_fast);
+        }
+
+        {
+            span<int*> s{nullptr, 0};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+
+            span<const int*> cs{nullptr, 0};
+            CHECK(cs.length() == 0 && cs.data() == nullptr);
+        }
+    }
+
+    TEST(from_element_constructor)
+    {
+        int i = 5;
+
+        {
+            span<int> s = i;
+            CHECK(s.length() == 1 && s.data() == &i);
+            CHECK(s[0] == 5);
+
+            span<const int> cs = i;
+            CHECK(cs.length() == 1 && cs.data() == &i);
+            CHECK(cs[0] == 5);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            const j = 1;
+            span<int, 0> s = j;
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 0> s = i;
+            CHECK(s.length() == 0 && s.data() == &i);
+#endif
+        }
+
+        {
+            span<int, 1> s = i;
+            CHECK(s.length() == 1 && s.data() == &i);
+            CHECK(s[0] == 5);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 2> s = i;
+            CHECK(s.length() == 2 && s.data() == &i);
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_a_temp = []() -> int { return 4; };
+            auto use_a_span = [](span<int> s) { (void) s; };
+            use_a_span(get_a_temp());
+#endif
+        }
+    }
+
+    TEST(from_pointer_length_constructor)
+    {
+        int arr[4] = {1, 2, 3, 4};
+
+        {
+            span<int> s{&arr[0], 2};
+            CHECK(s.length() == 2 && s.data() == &arr[0]);
+            CHECK(s[0] == 1 && s[1] == 2);
+        }
+
+        {
+            span<int, 2> s{&arr[0], 2};
+            CHECK(s.length() == 2 && s.data() == &arr[0]);
+            CHECK(s[0] == 1 && s[1] == 2);
+        }
+
+        {
+            int* p = nullptr;
+            span<int> s{p, 0};
+            CHECK(s.length() == 0 && s.data() == nullptr);
+        }
+
+        {
+            int* p = nullptr;
+            auto workaround_macro = [=]() { span<int> s{p, 2}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+        }
+    }
+
+    TEST(from_pointer_pointer_constructor)
+    {
+        int arr[4] = {1, 2, 3, 4};
+
+        {
+            span<int> s{&arr[0], &arr[2]};
+            CHECK(s.length() == 2 && s.data() == &arr[0]);
+            CHECK(s[0] == 1 && s[1] == 2);
+        }
+
+        {
+            span<int, 2> s{&arr[0], &arr[2]};
+            CHECK(s.length() == 2 && s.data() == &arr[0]);
+            CHECK(s[0] == 1 && s[1] == 2);
+        }
+
+        {
+            span<int> s{&arr[0], &arr[0]};
+            CHECK(s.length() == 0 && s.data() == &arr[0]);
+        }
+
+        {
+            span<int, 0> s{&arr[0], &arr[0]};
+            CHECK(s.length() == 0 && s.data() == &arr[0]);
+        }
+
+        {
+            auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+        }
+
+        {
+            int* p = nullptr;
+            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+        }
+
+        {
+            int* p = nullptr;
+            auto workaround_macro = [&]() { span<int> s{p, p}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+        }
+
+        {
+            int* p = nullptr;
+            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+            CHECK_THROW(workaround_macro(), fail_fast);
+        }
+    }
+
+    TEST(from_array_constructor)
+    {
+        int arr[5] = {1, 2, 3, 4, 5};
+
+        {
+            span<int> s{arr};
+            CHECK(s.length() == 5 && s.data() == &arr[0]);
+        }
+
+        {
+            span<int, 5> s{arr};
+            CHECK(s.length() == 5 && s.data() == &arr[0]);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 6> s{arr};
+#endif
+        }
+
+        {
+            span<int, 0> s{arr};
+            CHECK(s.length() == 0 && s.data() == &arr[0]);
+        }
+
+        int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
+
+        {
+            span<int> s{arr2d};
+            CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
+            CHECK(s[0] == 1 && s[5] == 6);
+        }
+
+        {
+            span<int, 0> s{arr2d};
+            CHECK(s.length() == 0 && s.data() == &arr2d[0][0]);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 5> s{arr2d};
+#endif
+        }
+
+        {
+            span<int, 6> s{arr2d};
+            CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
+            CHECK(s[0] == 1 && s[5] == 6);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 7> s{arr2d};
+#endif
+        }
+
+        {
+            span<int[3]> s{arr2d[0]};
+            CHECK(s.length() == 1 && s.data() == &arr2d[0]);
+        }
+
+        {
+            span<int, 2, 3> s{arr2d};
+            CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
+            auto workaround_macro = [&]() { return s[{1, 2}] == 6; };
+            CHECK(workaround_macro());
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 3, 3> s{arr2d};
+#endif
+        }
+
+        int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+        {
+            span<int> s{arr3d};
+            CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
+            CHECK(s[0] == 1 && s[11] == 12);
+        }
+
+        {
+            span<int, 0> s{arr3d};
+            CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 11> s{arr3d};
+#endif
+        }
+
+        {
+            span<int, 12> s{arr3d};
+            CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
+            CHECK(s[0] == 1 && s[5] == 6);
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 13> s{arr3d};
+#endif
+        }
+
+        {
+            span<int[3][2]> s{arr3d[0]};
+            CHECK(s.length() == 1 && s.data() == &arr3d[0]);
+        }
+
+        {
+            span<int, 3, 2, 2> s{arr3d};
+            CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
+            auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; };
+            CHECK(workaround_macro());
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 3, 3, 3> s{arr3d};
+#endif
+        }
+    }
+
+    TEST(from_dynamic_array_constructor)
+    {
+        double(*arr)[3][4] = new double[100][3][4];
+
+        {
+            span<double, dynamic_range, 3, 4> s(arr, 10);
+            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
+            CHECK_THROW(s[10][3][4], fail_fast);
+        }
+
+        {
+            span<double, dynamic_range, 4, 3> s(arr, 10);
+            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
+        }
+
+        {
+            span<double> s(arr, 10);
+            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
+        }
+
+        {
+            span<double, dynamic_range, 3, 4> s(arr, 0);
+            CHECK(s.length() == 0 && s.data() == &arr[0][0][0]);
+        }
+
+        delete[] arr;
+    }
+
+    TEST(from_std_array_constructor)
+    {
+        std::array<int, 4> arr = {1, 2, 3, 4};
+
+        {
+            span<int> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+
+            span<const int> cs{arr};
+            CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
+        }
+
+        {
+            span<int, 4> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+
+            span<const int, 4> cs{arr};
+            CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
+        }
+
+        {
+            span<int, 2> s{arr};
+            CHECK(s.size() == 2 && s.data() == arr.data());
+
+            span<const int, 2> cs{arr};
+            CHECK(cs.size() == 2 && cs.data() == arr.data());
+        }
+
+        {
+            span<int, 0> s{arr};
+            CHECK(s.size() == 0 && s.data() == arr.data());
+
+            span<const int, 0> cs{arr};
+            CHECK(cs.size() == 0 && cs.data() == arr.data());
+        }
+
+        // TODO This is currently an unsupported scenario. We will come back to it as we revise
+        // the multidimensional interface and what transformations between dimensionality look like
+        //{
+        //    span<int, 2, 2> s{arr};
+        //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        //}
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<int, 5> s{arr};
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; };
+            auto take_a_span = [](span<int> s) { (void) s; };
+            // try to take a temporary std::array
+            take_a_span(get_an_array());
+#endif
+        }
+    }
+
+    TEST(from_const_std_array_constructor)
+    {
+        const std::array<int, 4> arr = {1, 2, 3, 4};
+
+        {
+            span<const int> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 4> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 2> s{arr};
+            CHECK(s.size() == 2 && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 0> s{arr};
+            CHECK(s.size() == 0 && s.data() == arr.data());
+        }
+
+        // TODO This is currently an unsupported scenario. We will come back to it as we revise
+        // the multidimensional interface and what transformations between dimensionality look like
+        //{
+        //    span<int, 2, 2> s{arr};
+        //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        //}
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<const int, 5> s{arr};
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
+            auto take_a_span = [](span<const int> s) { (void) s; };
+            // try to take a temporary std::array
+            take_a_span(get_an_array());
+#endif
+        }
+    }
+
+    TEST(from_container_constructor)
+    {
+        std::vector<int> v = {1, 2, 3};
+        const std::vector<int> cv = v;
+
+        {
+            span<int> s{v};
+            CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data());
+
+            span<const int> cs{v};
+            CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data());
+        }
+
+        std::string str = "hello";
+        const std::string cstr = "hello";
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<char> s{str};
+            CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data());
+#endif
+            span<const char> cs{str};
+            CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data());
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            span<char> s{cstr};
+#endif
+            span<const char> cs{cstr};
+            CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) &&
+                  cs.data() == cstr.data());
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_temp_vector = []() -> std::vector<int> { return {}; };
+            auto use_span = [](span<int> s) { (void) s; };
+            use_span(get_temp_vector());
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_temp_string = []() -> std::string { return {}; };
+            auto use_span = [](span<char> s) { (void) s; };
+            use_span(get_temp_string());
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_temp_vector = []() -> const std::vector<int> { return {}; };
+            auto use_span = [](span<const char> s) { (void) s; };
+            use_span(get_temp_vector());
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto get_temp_string = []() -> const std::string { return {}; };
+            auto use_span = [](span<const char> s) { (void) s; };
+            use_span(get_temp_string());
+#endif
+        }
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            std::map<int, int> m;
+            span<int> s{m};
+#endif
+        }
+    }
+
+    TEST(from_convertible_span_constructor)
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        span<int, 7, 4, 2> av1(nullptr, b1);
+
+        auto f = [&]() { span<int, 7, 4, 2> av1(nullptr); };
+        CHECK_THROW(f(), fail_fast);
+#endif
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        static_bounds<size_t, 7, dynamic_range, 2> b12(b11);
+        b12 = b11;
+        b11 = b12;
+
+        span<int, dynamic_range> av1 = nullptr;
+        span<int, 7, dynamic_range, 2> av2(av1);
+        span<int, 7, 4, 2> av2(av1);
+#endif
+
+        span<DerivedClass> avd;
+#ifdef CONFIRM_COMPILATION_ERRORS
+        span<BaseClass> avb = avd;
+#endif
+        span<const DerivedClass> avcd = avd;
+        (void) avcd;
+    }
+
+    TEST(copy_move_and_assignment)
+    {
+        span<int> s1;
+        CHECK(s1.empty());
+
+        int arr[] = {3, 4, 5};
+
+        span<const int> s2 = arr;
+        CHECK(s2.length() == 3 && s2.data() == &arr[0]);
+
+        s2 = s1;
+        CHECK(s2.empty());
+
+        auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
+        auto use_span = [&](span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); };
+        use_span(get_temp_span());
+
+        s1 = get_temp_span();
+        CHECK(s1.length() == 2 && s1.data() == &arr[1]);
+    }
+
+    template <class Bounds>
+    void fn(const Bounds&)
+    {
+        static_assert(Bounds::static_size == 60, "static bounds is wrong size");
+    }
+    TEST(as_span_reshape)
+    {
+        int a[3][4][5];
+        auto av = as_span(a);
+        fn(av.bounds());
+        auto av2 = as_span(av, dim<60>());
+        auto av3 = as_span(av2, dim<3>(), dim<4>(), dim<5>());
+        auto av4 = as_span(av3, dim<4>(), dim<>(3), dim<5>());
+        auto av5 = as_span(av4, dim<3>(), dim<4>(), dim<5>());
+        auto av6 = as_span(av5, dim<12>(), dim<>(5));
+
+        fill(av6.begin(), av6.end(), 1);
+
+        auto av7 = as_bytes(av6);
+
+        auto av8 = as_span<int>(av7);
+
+        CHECK(av8.size() == av6.size());
+        for (auto i = 0; i < av8.size(); i++) {
+            CHECK(av8[i] == 1);
+        }
+    }
+
+    TEST(first)
+    {
+        int arr[5] = {1, 2, 3, 4, 5};
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.first<2>().bounds() == static_bounds<2>()));
+            CHECK(av.first<2>().length() == 2);
+            CHECK(av.first(2).length() == 2);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.first<0>().bounds() == static_bounds<0>()));
+            CHECK(av.first<0>().length() == 0);
+            CHECK(av.first(0).length() == 0);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.first<5>().bounds() == static_bounds<5>()));
+            CHECK(av.first<5>().length() == 5);
+            CHECK(av.first(5).length() == 5);
+        }
+
+        {
+            span<int, 5> av = arr;
+#ifdef CONFIRM_COMPILATION_ERRORS
+            CHECK(av.first<6>().bounds() == static_bounds<6>());
+            CHECK(av.first<6>().length() == 6);
+            CHECK(av.first<-1>().length() == -1);
+#endif
+            CHECK_THROW(av.first(6).length(), fail_fast);
+        }
+
+        {
+            span<int, dynamic_range> av;
+            CHECK((av.first<0>().bounds() == static_bounds<0>()));
+            CHECK(av.first<0>().length() == 0);
+            CHECK(av.first(0).length() == 0);
+        }
+    }
+
+    TEST(last)
+    {
+        int arr[5] = {1, 2, 3, 4, 5};
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.last<2>().bounds() == static_bounds<2>()));
+            CHECK(av.last<2>().length() == 2);
+            CHECK(av.last(2).length() == 2);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.last<0>().bounds() == static_bounds<0>()));
+            CHECK(av.last<0>().length() == 0);
+            CHECK(av.last(0).length() == 0);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.last<5>().bounds() == static_bounds<5>()));
+            CHECK(av.last<5>().length() == 5);
+            CHECK(av.last(5).length() == 5);
+        }
+
+        {
+            span<int, 5> av = arr;
+#ifdef CONFIRM_COMPILATION_ERRORS
+            CHECK((av.last<6>().bounds() == static_bounds<6>()));
+            CHECK(av.last<6>().length() == 6);
+#endif
+            CHECK_THROW(av.last(6).length(), fail_fast);
+        }
+
+        {
+            span<int, dynamic_range> av;
+            CHECK((av.last<0>().bounds() == static_bounds<0>()));
+            CHECK(av.last<0>().length() == 0);
+            CHECK(av.last(0).length() == 0);
+        }
+    }
+
+    TEST(subspan)
+    {
+        int arr[5] = {1, 2, 3, 4, 5};
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>()));
+            CHECK((av.subspan<2, 2>().length() == 2));
+            CHECK(av.subspan(2, 2).length() == 2);
+            CHECK(av.subspan(2, 3).length() == 3);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
+            CHECK((av.subspan<0, 0>().length() == 0));
+            CHECK(av.subspan(0, 0).length() == 0);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>()));
+            CHECK((av.subspan<0, 5>().length() == 5));
+            CHECK(av.subspan(0, 5).length() == 5);
+            CHECK_THROW(av.subspan(0, 6).length(), fail_fast);
+            CHECK_THROW(av.subspan(1, 5).length(), fail_fast);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>()));
+            CHECK((av.subspan<5, 0>().length() == 0));
+            CHECK(av.subspan(5, 0).length() == 0);
+            CHECK_THROW(av.subspan(6, 0).length(), fail_fast);
+        }
+
+        {
+            span<int, dynamic_range> av;
+            CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
+            CHECK((av.subspan<0, 0>().length() == 0));
+            CHECK(av.subspan(0, 0).length() == 0);
+            CHECK_THROW((av.subspan<1, 0>().length()), fail_fast);
+        }
+
+        {
+            span<int> av;
+            CHECK(av.subspan(0).length() == 0);
+            CHECK_THROW(av.subspan(1).length(), fail_fast);
+        }
+
+        {
+            span<int> av = arr;
+            CHECK(av.subspan(0).length() == 5);
+            CHECK(av.subspan(1).length() == 4);
+            CHECK(av.subspan(4).length() == 1);
+            CHECK(av.subspan(5).length() == 0);
+            CHECK_THROW(av.subspan(6).length(), fail_fast);
+            auto av2 = av.subspan(1);
+            for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
+        }
+
+        {
+            span<int, 5> av = arr;
+            CHECK(av.subspan(0).length() == 5);
+            CHECK(av.subspan(1).length() == 4);
+            CHECK(av.subspan(4).length() == 1);
+            CHECK(av.subspan(5).length() == 0);
+            CHECK_THROW(av.subspan(6).length(), fail_fast);
+            auto av2 = av.subspan(1);
+            for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
+        }
+    }
+
+    TEST(rank)
+    {
+        int arr[2] = {1, 2};
+
+        {
+            span<int> s;
+            CHECK(s.rank() == 1);
+        }
+
+        {
+            span<int, 2> s = arr;
+            CHECK(s.rank() == 1);
+        }
+
+        int arr2d[1][1] = {};
+        {
+            span<int, 1, 1> s = arr2d;
+            CHECK(s.rank() == 2);
+        }
+    }
+
+    TEST(extent)
+    {
+        {
+            span<int> s;
+            CHECK(s.extent() == 0);
+            CHECK(s.extent(0) == 0);
+            CHECK_THROW(s.extent(1), fail_fast);
+#ifdef CONFIRM_COMPILATION_ERRORS
+            CHECK(s.extent<1>() == 0);
+#endif
+        }
+
+        {
+            span<int, 0> s;
+            CHECK(s.extent() == 0);
+            CHECK(s.extent(0) == 0);
+            CHECK_THROW(s.extent(1), fail_fast);
+        }
+
+        {
+            int arr2d[1][2] = {};
+
+            span<int, 1, 2> s = arr2d;
+            CHECK(s.extent() == 1);
+            CHECK(s.extent<0>() == 1);
+            CHECK(s.extent<1>() == 2);
+            CHECK(s.extent(0) == 1);
+            CHECK(s.extent(1) == 2);
+            CHECK_THROW(s.extent(3), fail_fast);
+        }
+
+        {
+            int arr2d[1][2] = {};
+
+            span<int, 0, 2> s = arr2d;
+            CHECK(s.extent() == 0);
+            CHECK(s.extent<0>() == 0);
+            CHECK(s.extent<1>() == 2);
+            CHECK(s.extent(0) == 0);
+            CHECK(s.extent(1) == 2);
+            CHECK_THROW(s.extent(3), fail_fast);
+        }
+    }
+
+    TEST(operator_function_call)
+    {
+        int arr[4] = {1, 2, 3, 4};
+
+        {
+            span<int> s = arr;
+            CHECK(s(0) == 1);
+            CHECK_THROW(s(5), fail_fast);
+        }
+
+        int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
+
+        {
+            span<int, 2, 3> s = arr2d;
+            CHECK(s(0, 0) == 1);
+            CHECK(s(1, 2) == 6);
+        }
+    }
+
+    TEST(comparison_operators)
+    {
+        {
+            int arr[10][2];
+            auto s1 = as_span(arr);
+            span<const int, dynamic_range, 2> s2 = s1;
+
+            CHECK(s1 == s2);
+
+            span<int, 20> s3 = as_span(s1, dim<>(20));
+            CHECK(s3 == s2 && s3 == s1);
+        }
+
+        {
+            auto s1 = nullptr;
+            auto s2 = nullptr;
+            CHECK(s1 == s2);
+            CHECK(!(s1 != s2));
+            CHECK(!(s1 < s2));
+            CHECK(s1 <= s2);
+            CHECK(!(s1 > s2));
+            CHECK(s1 >= s2);
+            CHECK(s2 == s1);
+            CHECK(!(s2 != s1));
+            CHECK(!(s2 < s1));
+            CHECK(s2 <= s1);
+            CHECK(!(s2 > s1));
+            CHECK(s2 >= s1);
+        }
+
+        {
+            int arr[] = {2, 1}; // bigger
+
+            span<int> s1 = nullptr;
+            span<int> s2 = arr;
+
+            CHECK(s1 != s2);
+            CHECK(s2 != s1);
+            CHECK(!(s1 == s2));
+            CHECK(!(s2 == s1));
+            CHECK(s1 < s2);
+            CHECK(!(s2 < s1));
+            CHECK(s1 <= s2);
+            CHECK(!(s2 <= s1));
+            CHECK(s2 > s1);
+            CHECK(!(s1 > s2));
+            CHECK(s2 >= s1);
+            CHECK(!(s1 >= s2));
+        }
+
+        {
+            int arr1[] = {1, 2};
+            int arr2[] = {1, 2};
+            span<int> s1 = arr1;
+            span<int> s2 = arr2;
+
+            CHECK(s1 == s2);
+            CHECK(!(s1 != s2));
+            CHECK(!(s1 < s2));
+            CHECK(s1 <= s2);
+            CHECK(!(s1 > s2));
+            CHECK(s1 >= s2);
+            CHECK(s2 == s1);
+            CHECK(!(s2 != s1));
+            CHECK(!(s2 < s1));
+            CHECK(s2 <= s1);
+            CHECK(!(s2 > s1));
+            CHECK(s2 >= s1);
+        }
+
+        {
+            int arr[] = {1, 2, 3};
+
+            span<int> s1 = {&arr[0], 2}; // shorter
+            span<int> s2 = arr; // longer
+
+            CHECK(s1 != s2);
+            CHECK(s2 != s1);
+            CHECK(!(s1 == s2));
+            CHECK(!(s2 == s1));
+            CHECK(s1 < s2);
+            CHECK(!(s2 < s1));
+            CHECK(s1 <= s2);
+            CHECK(!(s2 <= s1));
+            CHECK(s2 > s1);
+            CHECK(!(s1 > s2));
+            CHECK(s2 >= s1);
+            CHECK(!(s1 >= s2));
+        }
+
+        {
+            int arr1[] = {1, 2}; // smaller
+            int arr2[] = {2, 1}; // bigger
+
+            span<int> s1 = arr1;
+            span<int> s2 = arr2;
+
+            CHECK(s1 != s2);
+            CHECK(s2 != s1);
+            CHECK(!(s1 == s2));
+            CHECK(!(s2 == s1));
+            CHECK(s1 < s2);
+            CHECK(!(s2 < s1));
+            CHECK(s1 <= s2);
+            CHECK(!(s2 <= s1));
+            CHECK(s2 > s1);
+            CHECK(!(s1 > s2));
+            CHECK(s2 >= s1);
+            CHECK(!(s1 >= s2));
+        }
+    }
+
+    TEST(basics)
+    {
+        auto ptr = as_span(new int[10], 10);
+        fill(ptr.begin(), ptr.end(), 99);
+        for (int num : ptr) {
+            CHECK(num == 99);
+        }
+
+        delete[] ptr.data();
+    }
+
+    TEST(bounds_checks)
+    {
+        int arr[10][2];
+        auto av = as_span(arr);
+
+        fill(begin(av), end(av), 0);
+
+        av[2][0] = 1;
+        av[1][1] = 3;
+
+        // out of bounds
+        CHECK_THROW(av[1][3] = 3, fail_fast);
+        CHECK_THROW((av[{1, 3}] = 3), fail_fast);
+
+        CHECK_THROW(av[10][2], fail_fast);
+        CHECK_THROW((av[{10, 2}]), fail_fast);
+    }
+
+    void overloaded_func(span<const int, dynamic_range, 3, 5> exp, int expected_value)
+    {
+        for (auto val : exp) {
+            CHECK(val == expected_value);
+        }
+    }
+
+    void overloaded_func(span<const char, dynamic_range, 3, 5> exp, char expected_value)
+    {
+        for (auto val : exp) {
+            CHECK(val == expected_value);
+        }
+    }
+
+    void fixed_func(span<int, 3, 3, 5> exp, int expected_value)
+    {
+        for (auto val : exp) {
+            CHECK(val == expected_value);
+        }
+    }
+
+    TEST(span_parameter_test)
+    {
+        auto data = new int[4][3][5];
+
+        auto av = as_span(data, 4);
+
+        CHECK(av.size() == 60);
+
+        fill(av.begin(), av.end(), 34);
+
+        int count = 0;
+        for_each(av.rbegin(), av.rend(), [&](int val) { count += val; });
+        CHECK(count == 34 * 60);
+        overloaded_func(av, 34);
+
+        overloaded_func(as_span(av, dim<>(4), dim<>(3), dim<>(5)), 34);
+
+        // fixed_func(av, 34);
+        delete[] data;
+    }
+
+    TEST(md_access)
+    {
+        auto width = 5, height = 20;
+
+        auto imgSize = width * height;
+        auto image_ptr = new int[imgSize][3];
+
+        // size check will be done
+        auto image_view =
+            as_span(as_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>());
+
+        iota(image_view.begin(), image_view.end(), 1);
+
+        int expected = 0;
+        for (auto i = 0; i < height; i++) {
+            for (auto j = 0; j < width; j++) {
+                CHECK(expected + 1 == image_view[i][j][0]);
+                CHECK(expected + 2 == image_view[i][j][1]);
+                CHECK(expected + 3 == image_view[i][j][2]);
+
+                auto val = image_view[{i, j, 0}];
+                CHECK(expected + 1 == val);
+                val = image_view[{i, j, 1}];
+                CHECK(expected + 2 == val);
+                val = image_view[{i, j, 2}];
+                CHECK(expected + 3 == val);
+
+                expected += 3;
+            }
+        }
+    }
+
+    TEST(as_span)
+    {
+        {
+            int* arr = new int[150];
+
+            auto av = as_span(arr, dim<10>(), dim<>(3), dim<5>());
+
+            fill(av.begin(), av.end(), 24);
+            overloaded_func(av, 24);
+
+            delete[] arr;
+
+            array<int, 15> stdarr{0};
+            auto av2 = as_span(stdarr);
+            overloaded_func(as_span(av2, dim<>(1), dim<3>(), dim<5>()), 0);
+
+            string str = "ttttttttttttttt"; // size = 15
+            auto t = str.data();
+            (void) t;
+            auto av3 = as_span(str);
+            overloaded_func(as_span(av3, dim<>(1), dim<3>(), dim<5>()), 't');
+        }
+
+        {
+            string str;
+            span<char> strspan = as_span(str);
+            (void) strspan;
+            const string cstr;
+            span<const char> cstrspan = as_span(cstr);
+            (void) cstrspan;
+        }
+
+        {
+            int a[3][4][5];
+            auto av = as_span(a);
+            const int(*b)[4][5];
+            b = a;
+            auto bv = as_span(b, 3);
+
+            CHECK(av == bv);
+
+            const std::array<double, 3> arr = {0.0, 0.0, 0.0};
+            auto cv = as_span(arr);
+            (void) cv;
+
+            vector<float> vec(3);
+            auto dv = as_span(vec);
+            (void) dv;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+            auto dv2 = as_span(std::move(vec));
+#endif
+        }
+    }
+
+    TEST(empty_spans)
+    {
+        {
+            span<int, 0> empty_av(nullptr);
+
+            CHECK(empty_av.bounds().index_bounds() == index<1>{0});
+            CHECK_THROW(empty_av[0], fail_fast);
+            CHECK_THROW(empty_av.begin()[0], fail_fast);
+            CHECK_THROW(empty_av.cbegin()[0], fail_fast);
+            for (auto& v : empty_av) {
+                (void) v;
+                CHECK(false);
+            }
+        }
+
+        {
+            span<int> empty_av = {};
+            CHECK(empty_av.bounds().index_bounds() == index<1>{0});
+            CHECK_THROW(empty_av[0], fail_fast);
+            CHECK_THROW(empty_av.begin()[0], fail_fast);
+            CHECK_THROW(empty_av.cbegin()[0], fail_fast);
+            for (auto& v : empty_av) {
+                (void) v;
+                CHECK(false);
+            }
+        }
+    }
+
+    TEST(index_constructor)
+    {
+        auto arr = new int[8];
+        for (int i = 0; i < 4; ++i) {
+            arr[2 * i] = 4 + i;
+            arr[2 * i + 1] = i;
+        }
+
+        span<int, dynamic_range> av(arr, 8);
+
+        ptrdiff_t a[1] = {0};
+        index<1> i = a;
+
+        CHECK(av[i] == 4);
+
+        auto av2 = as_span(av, dim<4>(), dim<>(2));
+        ptrdiff_t a2[2] = {0, 1};
+        index<2> i2 = a2;
+
+        CHECK(av2[i2] == 0);
+        CHECK(av2[0][i] == 4);
+
+        delete[] arr;
+    }
+
+    TEST(index_constructors)
+    {
+        {
+            // components of the same type
+            index<3> i1(0, 1, 2);
+            CHECK(i1[0] == 0);
+
+            // components of different types
+            size_t c0 = 0;
+            size_t c1 = 1;
+            index<3> i2(c0, c1, 2);
+            CHECK(i2[0] == 0);
+
+            // from array
+            index<3> i3 = {0, 1, 2};
+            CHECK(i3[0] == 0);
+
+            // from other index of the same size type
+            index<3> i4 = i3;
+            CHECK(i4[0] == 0);
+
+            // default
+            index<3> i7;
+            CHECK(i7[0] == 0);
+
+            // default
+            index<3> i9 = {};
+            CHECK(i9[0] == 0);
+        }
+
+        {
+            // components of the same type
+            index<1> i1(0);
+            CHECK(i1[0] == 0);
+
+            // components of different types
+            size_t c0 = 0;
+            index<1> i2(c0);
+            CHECK(i2[0] == 0);
+
+            // from array
+            index<1> i3 = {0};
+            CHECK(i3[0] == 0);
+
+            // from int
+            index<1> i4 = 0;
+            CHECK(i4[0] == 0);
+
+            // from other index of the same size type
+            index<1> i5 = i3;
+            CHECK(i5[0] == 0);
+
+            // default
+            index<1> i8;
+            CHECK(i8[0] == 0);
+
+            // default
+            index<1> i9 = {};
+            CHECK(i9[0] == 0);
+        }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        {
+            index<3> i1(0, 1);
+            index<3> i2(0, 1, 2, 3);
+            index<3> i3 = {0};
+            index<3> i4 = {0, 1, 2, 3};
+            index<1> i5 = {0, 1};
+        }
+#endif
+    }
+
+    TEST(index_operations)
+    {
+        ptrdiff_t a[3] = {0, 1, 2};
+        ptrdiff_t b[3] = {3, 4, 5};
+        index<3> i = a;
+        index<3> j = b;
+
+        CHECK(i[0] == 0);
+        CHECK(i[1] == 1);
+        CHECK(i[2] == 2);
+
+        {
+            index<3> k = i + j;
+
+            CHECK(i[0] == 0);
+            CHECK(i[1] == 1);
+            CHECK(i[2] == 2);
+            CHECK(k[0] == 3);
+            CHECK(k[1] == 5);
+            CHECK(k[2] == 7);
+        }
+
+        {
+            index<3> k = i * 3;
+
+            CHECK(i[0] == 0);
+            CHECK(i[1] == 1);
+            CHECK(i[2] == 2);
+            CHECK(k[0] == 0);
+            CHECK(k[1] == 3);
+            CHECK(k[2] == 6);
+        }
+
+        {
+            index<3> k = 3 * i;
+
+            CHECK(i[0] == 0);
+            CHECK(i[1] == 1);
+            CHECK(i[2] == 2);
+            CHECK(k[0] == 0);
+            CHECK(k[1] == 3);
+            CHECK(k[2] == 6);
+        }
+
+        {
+            index<2> k = details::shift_left(i);
+
+            CHECK(i[0] == 0);
+            CHECK(i[1] == 1);
+            CHECK(i[2] == 2);
+            CHECK(k[0] == 1);
+            CHECK(k[1] == 2);
+        }
+    }
+
+    void iterate_second_column(span<int, dynamic_range, dynamic_range> av)
+    {
+        auto length = av.size() / 2;
+
+        // view to the second column
+        auto section = av.section({0, 1}, {length, 1});
+
+        CHECK(section.size() == length);
+        for (auto i = 0; i < section.size(); ++i) {
+            CHECK(section[i][0] == av[i][1]);
+        }
+
+        for (auto i = 0; i < section.size(); ++i) {
+            auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro
+            CHECK(section[idx] == av[i][1]);
+        }
+
+        CHECK(section.bounds().index_bounds()[0] == length);
+        CHECK(section.bounds().index_bounds()[1] == 1);
+        for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) {
+            for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) {
+                auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro
+                CHECK(section[idx] == av[i][1]);
+            }
+        }
+
+        size_t check_sum = 0;
+        for (auto i = 0; i < length; ++i) {
+            check_sum += av[i][1];
+        }
+
+        {
+            auto idx = 0;
+            size_t sum = 0;
+            for (auto num : section) {
+                CHECK(num == av[idx][1]);
+                sum += num;
+                idx++;
+            }
+
+            CHECK(sum == check_sum);
+        }
+        {
+            size_t idx = length - 1;
+            size_t sum = 0;
+            for (auto iter = section.rbegin(); iter != section.rend(); ++iter) {
+                CHECK(*iter == av[idx][1]);
+                sum += *iter;
+                idx--;
+            }
+
+            CHECK(sum == check_sum);
+        }
+    }
+
+    TEST(span_section_iteration)
+    {
+        int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}};
+
+        // static bounds
+        {
+            span<int, 4, 2> av = arr;
+            iterate_second_column(av);
+        }
+        // first bound is dynamic
+        {
+            span<int, dynamic_range, 2> av = arr;
+            iterate_second_column(av);
+        }
+        // second bound is dynamic
+        {
+            span<int, 4, dynamic_range> av = arr;
+            iterate_second_column(av);
+        }
+        // both bounds are dynamic
+        {
+            span<int, dynamic_range, dynamic_range> av = arr;
+            iterate_second_column(av);
+        }
+    }
+
+    TEST(dynamic_span_section_iteration)
+    {
+        auto height = 4, width = 2;
+        auto size = height * width;
+
+        auto arr = new int[size];
+        for (auto i = 0; i < size; ++i) {
+            arr[i] = i;
+        }
+
+        auto av = as_span(arr, size);
+
+        // first bound is dynamic
+        {
+            span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width));
+            iterate_second_column(av2);
+        }
+        // second bound is dynamic
+        {
+            span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            iterate_second_column(av2);
+        }
+        // both bounds are dynamic
+        {
+            span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            iterate_second_column(av2);
+        }
+
+        delete[] arr;
+    }
+
+    TEST(span_structure_size)
+    {
+        double(*arr)[3][4] = new double[100][3][4];
+        span<double, dynamic_range, 3, 4> av1(arr, 10);
+
+        struct EffectiveStructure
+        {
+            double* v1;
+            ptrdiff_t v2;
+        };
+        CHECK(sizeof(av1) == sizeof(EffectiveStructure));
+
+        CHECK_THROW(av1[10][3][4], fail_fast);
+
+        span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>());
+        (void) av2;
+    }
+
+    TEST(fixed_size_conversions)
+    {
+        int arr[] = {1, 2, 3, 4};
+
+        // converting to an span from an equal size array is ok
+        span<int, 4> av4 = arr;
+        CHECK(av4.length() == 4);
+
+        // converting to dynamic_range a_v is always ok
+        {
+            span<int, dynamic_range> av = av4;
+            (void) av;
+        }
+        {
+            span<int, dynamic_range> av = arr;
+            (void) av;
+        }
+
+// initialization or assignment to static span that REDUCES size is NOT ok
+#ifdef CONFIRM_COMPILATION_ERRORS
+        {
+            span<int, 2> av2 = arr;
+        }
+        {
+            span<int, 2> av2 = av4;
+        }
+#endif
+
+        {
+            span<int, dynamic_range> av = arr;
+            span<int, 2> av2 = av;
+            (void) av2;
+        }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        {
+            span<int, dynamic_range> av = arr;
+            span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>());
+        }
+#endif
+
+        {
+            span<int, dynamic_range> av = arr;
+            span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2));
+            auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
+            CHECK(workaround_macro());
+        }
+
+        // but doing so explicitly is ok
+
+        // you can convert statically
+        {
+            span<int, 2> av2 = {arr, 2};
+            (void) av2;
+        }
+        {
+            span<int, 1> av2 = av4.first<1>();
+            (void) av2;
+        }
+
+        // ...or dynamically
+        {
+            // NB: implicit conversion to span<int,2> from span<int,dynamic_range>
+            span<int, 1> av2 = av4.first(1);
+            (void) av2;
+        }
+
+        // initialization or assignment to static span that requires size INCREASE is not ok.
+        int arr2[2] = {1, 2};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        {
+            span<int, 4> av4 = arr2;
+        }
+        {
+            span<int, 2> av2 = arr2;
+            span<int, 4> av4 = av2;
+        }
+#endif
+        {
+            auto f = [&]() {
+                span<int, 4> av9 = {arr2, 2};
+                (void) av9;
+            };
+            CHECK_THROW(f(), fail_fast);
+        }
+
+        // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one
+        span<int, dynamic_range> av = arr2;
+        auto f = [&]() {
+            span<int, 4> av2 = av;
+            (void) av2;
+        };
+        CHECK_THROW(f(), fail_fast);
+    }
+
+    TEST(as_writeable_bytes)
+    {
+        int a[] = {1, 2, 3, 4};
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            // you should not be able to get writeable bytes for const objects
+            span<const int, dynamic_range> av = a;
+            auto wav = av.as_writeable_bytes();
+#endif
+        }
+
+        {
+            span<int, dynamic_range> av;
+            auto wav = as_writeable_bytes(av);
+            CHECK(wav.length() == av.length());
+            CHECK(wav.length() == 0);
+            CHECK(wav.size_bytes() == 0);
+        }
+
+        {
+            span<int, dynamic_range> av = a;
+            auto wav = as_writeable_bytes(av);
+            CHECK(wav.data() == (byte*) &a[0]);
+            CHECK(wav.length() == sizeof(a));
+        }
+    }
+
+    TEST(iterator)
+    {
+        int a[] = {1, 2, 3, 4};
+
+        {
+            span<int, dynamic_range> av = a;
+            auto wav = as_writeable_bytes(av);
+            for (auto& b : wav) {
+                b = byte(0);
+            }
+            for (size_t i = 0; i < 4; ++i) {
+                CHECK(a[i] == 0);
+            }
+        }
+
+        {
+            span<int, dynamic_range> av = a;
+            for (auto& n : av) {
+                n = 1;
+            }
+            for (size_t i = 0; i < 4; ++i) {
+                CHECK(a[i] == 1);
+            }
+        }
+    }
+#endif    
+}
+
+int main(int, const char* []) { return UnitTest::RunAllTests(); }

From d3929c59a07a0bd1137601cf2866ffd6dd68d795 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 24 Feb 2016 16:11:33 -0800
Subject: [PATCH 05/42] Began reimplementation of span. Basic constructors.

---
 include/gsl_util.h   |   1 +
 include/span.h       | 132 ++++++++++++++++++++++++++++++++++++++++---
 tests/span_tests.cpp |   2 +-
 3 files changed, 126 insertions(+), 9 deletions(-)

diff --git a/include/gsl_util.h b/include/gsl_util.h
index 316f2a1..508672c 100644
--- a/include/gsl_util.h
+++ b/include/gsl_util.h
@@ -106,6 +106,7 @@ inline T narrow(U u)
     T t = narrow_cast<T>(u);
     if (static_cast<U>(t) != u)
         throw narrowing_error();
+#pragma warning(suppress:4127) // suppress warning from MSVC compiler about constant in if-test
     if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
         throw narrowing_error();
     return t;
diff --git a/include/span.h b/include/span.h
index 7df4964..b8c1196 100644
--- a/include/span.h
+++ b/include/span.h
@@ -21,16 +21,9 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
-#include <algorithm>
 #include <array>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <iterator>
 #include <limits>
-#include <new>
-#include <numeric>
+#include <iterator>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -79,6 +72,129 @@
 namespace gsl
 {
 
+// [views.constants], constants  
+constexpr const std::ptrdiff_t dynamic_extent = -1;
+
+
+// [span], class template span 
+template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
+class span {
+public:
+    // constants and types 
+    using element_type = ElementType;
+    using index_type = std::ptrdiff_t;
+    using pointer = element_type*;
+    using reference = element_type&;
+#if 0  // TODO
+    using iterator = /*implementation-defined */;
+    using const_iterator = /* implementation-defined */;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+#endif 
+    constexpr static const index_type extent = Extent;
+
+    // [span.cons], span constructors, copy, assignment, and destructor 
+    constexpr span() noexcept : data_(nullptr), size_(0)
+    { static_assert(extent == dynamic_extent || extent == 0, "Cannot default initialize a fixed-length span."); }
+    constexpr span(nullptr_t) noexcept : span() {}
+    constexpr span(pointer ptr, index_type count) : data_(ptr), size_(count)
+    { Expects((!ptr && count == 0) || (ptr && count >= 0)); }
+#if 0 // TODO
+    constexpr span(pointer firstElem, pointer lastElem);
+    template <size_t N>
+    constexpr span(element_type(&arr)[N]);
+    template <size_t N>
+    constexpr span(array<remove_const_t<element_type>, N>& arr);
+    template <size_t N>
+    constexpr span(const array<remove_const_t<element_type>, N>& arr);
+    template <class Container>
+    constexpr span(Container& cont);
+    template <class Container>
+    span(const Container&&) = delete;
+    constexpr span(const span& other) noexcept = default;
+    constexpr span(span&& other) noexcept = default;
+    template <class OtherElementType, ptrdiff_t OtherExtent>
+    constexpr span(const span<OtherElementType, OtherExtent>& other);
+    template <class OtherElementType, ptrdiff_t OtherExtent>
+    constexpr span(span<OtherElementType, OtherExtent>&& other);
+    ~span() noexcept = default;
+    constexpr span& operator=(const span& other) noexcept = default;
+    constexpr span& operator=(span&& other) noexcept = default;
+
+    // [span.sub], span subviews  
+    template <ptrdiff_t Count>
+    constexpr span<element_type, Count> first() const;
+    template <ptrdiff_t Count>
+    constexpr span<element_type, Count> last() const;
+    template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
+    constexpr span<element_type, Count> subspan() const;
+    constexpr span<element_type, dynamic_extent> first(index_type count) const;
+    constexpr span<element_type, dynamic_extent> last(index_type count) const;
+    constexpr span<element_type, dynamic_extent> subspan(index_type offset, index_type count = dynamic_extent) const;
+#endif
+    // [span.obs], span observers 
+    constexpr index_type length() const noexcept { return size(); }
+    constexpr index_type size() const noexcept { return size_;  }
+    constexpr index_type length_bytes() const noexcept { return size_bytes(); }
+    constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); }
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+#if 0 // TODO
+    // [span.elem], span element access 
+    constexpr reference operator[](index_type idx) const;
+    constexpr reference operator()(index_type idx) const;
+#endif 
+    constexpr pointer data() const noexcept { return data_; }
+#if 0 // TODO
+    // [span.iter], span iterator support 
+    iterator begin() const noexcept;
+    iterator end() const noexcept;
+ 
+    const_iterator cbegin() const noexcept;
+    const_iterator cend() const noexcept;
+
+    reverse_iterator rbegin() const noexcept;
+    reverse_iterator rend() const noexcept;
+
+    const_reverse_iterator crbegin() const noexcept;
+    const_reverse_iterator crend() const noexcept;
+#endif
+private:
+    pointer data_;
+    index_type size_;
+};
+
+
+#if 0 // TODO
+// [span.comparison], span comparison operators 
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+#endif
+
+
+#if 0 // TODO
+// [span.objectrep], views of object representation 
+template <class ElementType, ptrdiff_t Extent>
+constexpr span<const char, ((Extent == dynamic_extent) ? dynamic_extent : (sizeof(ElementType) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;
+
+template <class ElementType, ptrdiff_t Extent>
+constexpr span<char, ((Extent == dynamic_extent) ? dynamic_extent : (sizeof(ElementType) * Extent))> as_writeable_bytes(span<ElementType, Extent>) noexcept;
+#endif
 
 } // namespace gsl
 
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 83eec0e..233ab00 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -39,7 +39,6 @@ struct DerivedClass : BaseClass
 
 SUITE(span_tests)
 {
-#if 0
     TEST(default_constructor)
     {
         {
@@ -116,6 +115,7 @@ SUITE(span_tests)
         }
     }
 
+#if 0
     TEST(from_nullptr_length_constructor)
     {
         {

From cc22f2bf4263042d5294c7b97a443d9191c2eb1f Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Thu, 25 Feb 2016 11:42:26 -0800
Subject: [PATCH 06/42] first/last constructor working.

---
 include/span.h       | 27 ++++++++----
 tests/span_tests.cpp | 98 ++++++++++++--------------------------------
 2 files changed, 45 insertions(+), 80 deletions(-)

diff --git a/include/span.h b/include/span.h
index b8c1196..38cf9f5 100644
--- a/include/span.h
+++ b/include/span.h
@@ -96,13 +96,20 @@ public:
     // [span.cons], span constructors, copy, assignment, and destructor 
     constexpr span() noexcept : data_(nullptr), size_(0)
     { static_assert(extent == dynamic_extent || extent == 0, "Cannot default initialize a fixed-length span."); }
-    constexpr span(nullptr_t) noexcept : span() {}
+
+    constexpr span(nullptr_t) noexcept : span()
+    {}
+
     constexpr span(pointer ptr, index_type count) : data_(ptr), size_(count)
-    { Expects((!ptr && count == 0) || (ptr && count >= 0)); }
-#if 0 // TODO
-    constexpr span(pointer firstElem, pointer lastElem);
+    { Expects(((!ptr && count == 0) || (ptr && count >= 0)) && (extent == dynamic_extent || extent == count)); }
+
+    constexpr span(pointer firstElem, pointer lastElem) : data_(firstElem), size_(std::distance(firstElem, lastElem))
+    { Expects(size_ >= 0 && (extent == dynamic_extent || extent == size_)); }
+    
     template <size_t N>
-    constexpr span(element_type(&arr)[N]);
+    constexpr span(element_type(&arr)[N]) {}
+
+#if 0 // TODO
     template <size_t N>
     constexpr span(array<remove_const_t<element_type>, N>& arr);
     template <size_t N>
@@ -139,11 +146,13 @@ public:
     constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); }
     constexpr bool empty() const noexcept { return size() == 0; }
 
-#if 0 // TODO
     // [span.elem], span element access 
-    constexpr reference operator[](index_type idx) const;
-    constexpr reference operator()(index_type idx) const;
-#endif 
+    constexpr reference operator[](index_type idx) const
+    {
+        Expects(idx >= 0 && idx < size_);
+        return data_[idx];
+    }
+    constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
     constexpr pointer data() const noexcept { return data_; }
 #if 0 // TODO
     // [span.iter], span iterator support 
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 233ab00..11004ae 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -115,7 +115,6 @@ SUITE(span_tests)
         }
     }
 
-#if 0
     TEST(from_nullptr_length_constructor)
     {
         {
@@ -135,10 +134,8 @@ SUITE(span_tests)
         }
 
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 1> s{nullptr, 0};
-            CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
-#endif
+            auto workaround_macro = []() { span<int, 1> s{ nullptr, 0 }; };
+            CHECK_THROW(workaround_macro(), fail_fast); 
         }
 
         {
@@ -166,56 +163,6 @@ SUITE(span_tests)
         }
     }
 
-    TEST(from_element_constructor)
-    {
-        int i = 5;
-
-        {
-            span<int> s = i;
-            CHECK(s.length() == 1 && s.data() == &i);
-            CHECK(s[0] == 5);
-
-            span<const int> cs = i;
-            CHECK(cs.length() == 1 && cs.data() == &i);
-            CHECK(cs[0] == 5);
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            const j = 1;
-            span<int, 0> s = j;
-#endif
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 0> s = i;
-            CHECK(s.length() == 0 && s.data() == &i);
-#endif
-        }
-
-        {
-            span<int, 1> s = i;
-            CHECK(s.length() == 1 && s.data() == &i);
-            CHECK(s[0] == 5);
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 2> s = i;
-            CHECK(s.length() == 2 && s.data() == &i);
-#endif
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            auto get_a_temp = []() -> int { return 4; };
-            auto use_a_span = [](span<int> s) { (void) s; };
-            use_a_span(get_a_temp());
-#endif
-        }
-    }
-
     TEST(from_pointer_length_constructor)
     {
         int arr[4] = {1, 2, 3, 4};
@@ -271,30 +218,39 @@ SUITE(span_tests)
             CHECK(s.length() == 0 && s.data() == &arr[0]);
         }
 
+        // this will fail the std::distance() precondition, which asserts on MSVC debug builds
+        //{
+        //    auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
+        //    CHECK_THROW(workaround_macro(), fail_fast);
+        //}
+
+        // this will fail the std::distance() precondition, which asserts on MSVC debug builds
+        //{
+        //    int* p = nullptr;
+        //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+        //    CHECK_THROW(workaround_macro(), fail_fast);
+        //}
+
         {
-            auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
-            CHECK_THROW(workaround_macro(), fail_fast);
+            int* p = nullptr;
+            span<int> s{ p, p };
+            CHECK(s.length() == 0 && s.data() == nullptr);
         }
 
         {
             int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
-            CHECK_THROW(workaround_macro(), fail_fast);
+            span<int, 0> s{ p, p };
+            CHECK(s.length() == 0 && s.data() == nullptr);
         }
 
-        {
-            int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{p, p}; };
-            CHECK_THROW(workaround_macro(), fail_fast);
-        }
-
-        {
-            int* p = nullptr;
-            auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
-            CHECK_THROW(workaround_macro(), fail_fast);
-        }
+        // this will fail the std::distance() precondition, which asserts on MSVC debug builds
+        //{
+        //    int* p = nullptr;
+        //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+        //    CHECK_THROW(workaround_macro(), fail_fast);
+        //}
     }
-
+#if 0
     TEST(from_array_constructor)
     {
         int arr[5] = {1, 2, 3, 4, 5};

From 502cd6650aed90cfe221857dfc3547fafc54d6f8 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 28 Feb 2016 00:50:53 -0800
Subject: [PATCH 07/42] Checking in to continue working elsewhere.

---
 include/span.h       | 90 +++++++++++++++++++++++++++++++++++++-------
 tests/span_tests.cpp | 83 ++++++++++++----------------------------
 2 files changed, 101 insertions(+), 72 deletions(-)

diff --git a/include/span.h b/include/span.h
index 38cf9f5..4983295 100644
--- a/include/span.h
+++ b/include/span.h
@@ -94,20 +94,22 @@ public:
     constexpr static const index_type extent = Extent;
 
     // [span.cons], span constructors, copy, assignment, and destructor 
-    constexpr span() noexcept : data_(nullptr), size_(0)
-    { static_assert(extent == dynamic_extent || extent == 0, "Cannot default initialize a fixed-length span."); }
+    constexpr span() noexcept : storage_(nullptr, extent_type<0>())
+    {}
 
     constexpr span(nullptr_t) noexcept : span()
     {}
 
-    constexpr span(pointer ptr, index_type count) : data_(ptr), size_(count)
-    { Expects(((!ptr && count == 0) || (ptr && count >= 0)) && (extent == dynamic_extent || extent == count)); }
+    constexpr span(pointer ptr, index_type count) : storage_(ptr, count)
+    { Expects(((!ptr && count == 0) || (ptr && count >= 0))); }
 
-    constexpr span(pointer firstElem, pointer lastElem) : data_(firstElem), size_(std::distance(firstElem, lastElem))
-    { Expects(size_ >= 0 && (extent == dynamic_extent || extent == size_)); }
+    constexpr span(pointer firstElem, pointer lastElem)
+        : storage_(firstElem, std::distance(firstElem, lastElem))
+    {}
     
     template <size_t N>
-    constexpr span(element_type(&arr)[N]) {}
+    constexpr span(element_type(&arr)[N]) : storage_(&arr[0], extent_type<N>())
+    {}
 
 #if 0 // TODO
     template <size_t N>
@@ -141,7 +143,7 @@ public:
 #endif
     // [span.obs], span observers 
     constexpr index_type length() const noexcept { return size(); }
-    constexpr index_type size() const noexcept { return size_;  }
+    constexpr index_type size() const noexcept { return storage_.size();  }
     constexpr index_type length_bytes() const noexcept { return size_bytes(); }
     constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); }
     constexpr bool empty() const noexcept { return size() == 0; }
@@ -149,11 +151,11 @@ public:
     // [span.elem], span element access 
     constexpr reference operator[](index_type idx) const
     {
-        Expects(idx >= 0 && idx < size_);
-        return data_[idx];
+        Expects(idx >= 0 && idx < storage_.size());
+        return storage_.data()[idx];
     }
     constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
-    constexpr pointer data() const noexcept { return data_; }
+    constexpr pointer data() const noexcept { return storage_.data(); }
 #if 0 // TODO
     // [span.iter], span iterator support 
     iterator begin() const noexcept;
@@ -169,8 +171,70 @@ public:
     const_reverse_iterator crend() const noexcept;
 #endif
 private:
-    pointer data_;
-    index_type size_;
+    template <index_type Extent>
+    class extent_type;
+    
+    template <index_type Extent>
+    class extent_type
+    {
+    public:
+        static_assert(Extent >= 0, "A fixed-size span must be >= 0 in size.");
+
+        constexpr extent_type() noexcept {}
+
+        template <index_type Other>
+        constexpr extent_type(extent_type<Other>) noexcept
+        {
+            static_assert(Other == Extent,
+                "Mismatch between fixed-size extent and size of initializing data.");
+        }
+
+        constexpr extent_type(index_type size)
+        { Expects(size == Extent); }
+
+        constexpr inline index_type size() const noexcept { return Extent; }
+    };
+
+    template <>
+    class extent_type<dynamic_extent>
+    {
+    public:
+        template <index_type Other>
+        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
+        {}
+
+        explicit constexpr extent_type(index_type size) : size_(size)
+        { Expects(size >= 0); } 
+
+        constexpr inline index_type size() const noexcept
+        { return size_; }
+
+    private:
+        index_type size_;
+    };
+
+    // this implementation detail class lets us take advantage of the 
+    // empty base class optimization to pay for only storage of a single
+    // pointer in the case of fixed-size spans
+    template <class ExtentType>
+    class storage_type : public ExtentType
+    {
+    public:
+        template <class OtherExtentType>
+        storage_type(pointer data, OtherExtentType ext)
+            : ExtentType(ext), data_(data) {}
+
+        //storage_type(pointer data, ExtentType ext)
+        //    : ExtentType(ext), data_(data) {}
+        
+        constexpr inline pointer data() const noexcept
+        { return data_; }
+
+    private:
+        pointer data_;
+    };
+
+    storage_type<extent_type<Extent>> storage_;
 };
 
 
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 11004ae..e4bdef4 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -73,6 +73,19 @@ SUITE(span_tests)
         }
     }
 
+    TEST(size_optimization)
+    {
+        {
+            span<int> s;
+            CHECK(sizeof(s) == sizeof(int*) + sizeof(ptrdiff_t));
+        }
+
+        {
+            span<int, 0> s;
+            CHECK(sizeof(s) == sizeof(int*));
+        }
+    }
+
     TEST(from_nullptr_constructor)
     {
         {
@@ -250,7 +263,7 @@ SUITE(span_tests)
         //    CHECK_THROW(workaround_macro(), fail_fast);
         //}
     }
-#if 0
+
     TEST(from_array_constructor)
     {
         int arr[5] = {1, 2, 3, 4, 5};
@@ -265,10 +278,11 @@ SUITE(span_tests)
             CHECK(s.length() == 5 && s.data() == &arr[0]);
         }
 
-        {
+        int arr2d[2][3] = { 1, 2, 3, 4, 5, 6 };
+
 #ifdef CONFIRM_COMPILATION_ERRORS
+        {
             span<int, 6> s{arr};
-#endif
         }
 
         {
@@ -276,8 +290,6 @@ SUITE(span_tests)
             CHECK(s.length() == 0 && s.data() == &arr[0]);
         }
 
-        int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
-
         {
             span<int> s{arr2d};
             CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
@@ -290,43 +302,17 @@ SUITE(span_tests)
         }
 
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 5> s{arr2d};
+            span<int, 6> s{ arr2d };
+        }
 #endif
-        }
-
         {
-            span<int, 6> s{arr2d};
-            CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
-            CHECK(s[0] == 1 && s[5] == 6);
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 7> s{arr2d};
-#endif
-        }
-
-        {
-            span<int[3]> s{arr2d[0]};
+            span<int[3]> s{ arr2d[0] };
             CHECK(s.length() == 1 && s.data() == &arr2d[0]);
         }
 
-        {
-            span<int, 2, 3> s{arr2d};
-            CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
-            auto workaround_macro = [&]() { return s[{1, 2}] == 6; };
-            CHECK(workaround_macro());
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 3, 3> s{arr2d};
-#endif
-        }
-
         int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
+#ifdef CONFIRM_COMPILATION_ERRORS
         {
             span<int> s{arr3d};
             CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
@@ -339,9 +325,7 @@ SUITE(span_tests)
         }
 
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
             span<int, 11> s{arr3d};
-#endif
         }
 
         {
@@ -349,32 +333,13 @@ SUITE(span_tests)
             CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
             CHECK(s[0] == 1 && s[5] == 6);
         }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 13> s{arr3d};
 #endif
-        }
-
         {
-            span<int[3][2]> s{arr3d[0]};
-            CHECK(s.length() == 1 && s.data() == &arr3d[0]);
-        }
-
-        {
-            span<int, 3, 2, 2> s{arr3d};
-            CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
-            auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; };
-            CHECK(workaround_macro());
-        }
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            span<int, 3, 3, 3> s{arr3d};
-#endif
+            //span<int[3][2]> s{arr3d[0]};
+            //CHECK(s.length() == 1 && s.data() == &arr3d[0]);
         }
     }
-
+#if 0
     TEST(from_dynamic_array_constructor)
     {
         double(*arr)[3][4] = new double[100][3][4];

From f61a9bba48fa410e2df4519793f7480be4b85934 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 29 Feb 2016 13:16:48 -0800
Subject: [PATCH 08/42] Added array constructors.

---
 include/span.h       | 17 +++++++++----
 tests/span_tests.cpp | 57 +++++++++-----------------------------------
 2 files changed, 23 insertions(+), 51 deletions(-)

diff --git a/include/span.h b/include/span.h
index 4983295..2d95899 100644
--- a/include/span.h
+++ b/include/span.h
@@ -108,14 +108,21 @@ public:
     {}
     
     template <size_t N>
-    constexpr span(element_type(&arr)[N]) : storage_(&arr[0], extent_type<N>())
+    constexpr span(element_type(&arr)[N])
+        : storage_(&arr[0], extent_type<N>())
+    {}
+
+    template <size_t N>
+    constexpr span(std::array<std::remove_const_t<element_type>, N>& arr)
+        : storage_(&arr[0], extent_type<N>())
+    {}
+
+    template <size_t N>
+    constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr)
+        : storage_(&arr[0], extent_type<N>())
     {}
 
 #if 0 // TODO
-    template <size_t N>
-    constexpr span(array<remove_const_t<element_type>, N>& arr);
-    template <size_t N>
-    constexpr span(const array<remove_const_t<element_type>, N>& arr);
     template <class Container>
     constexpr span(Container& cont);
     template <class Container>
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index e4bdef4..e13694c 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -306,7 +306,7 @@ SUITE(span_tests)
         }
 #endif
         {
-            span<int[3]> s{ arr2d[0] };
+            span<int[3]> s{ &(arr2d[0]), 1 };
             CHECK(s.length() == 1 && s.data() == &arr2d[0]);
         }
 
@@ -335,34 +335,18 @@ SUITE(span_tests)
         }
 #endif
         {
-            //span<int[3][2]> s{arr3d[0]};
-            //CHECK(s.length() == 1 && s.data() == &arr3d[0]);
+            span<int[3][2]> s{&arr3d[0], 1};
+            CHECK(s.length() == 1 && s.data() == &arr3d[0]);
         }
     }
-#if 0
+
     TEST(from_dynamic_array_constructor)
     {
         double(*arr)[3][4] = new double[100][3][4];
 
         {
-            span<double, dynamic_range, 3, 4> s(arr, 10);
-            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
-            CHECK_THROW(s[10][3][4], fail_fast);
-        }
-
-        {
-            span<double, dynamic_range, 4, 3> s(arr, 10);
-            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
-        }
-
-        {
-            span<double> s(arr, 10);
-            CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
-        }
-
-        {
-            span<double, dynamic_range, 3, 4> s(arr, 0);
-            CHECK(s.length() == 0 && s.data() == &arr[0][0][0]);
+            span<double> s(&arr[0][0][0], 10);
+            CHECK(s.length() == 10 && s.data() == &arr[0][0][0]);
         }
 
         delete[] arr;
@@ -388,6 +372,7 @@ SUITE(span_tests)
             CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
         }
 
+#ifdef CONFIRM_COMPILATION_ERRORS
         {
             span<int, 2> s{arr};
             CHECK(s.size() == 2 && s.data() == arr.data());
@@ -404,27 +389,17 @@ SUITE(span_tests)
             CHECK(cs.size() == 0 && cs.data() == arr.data());
         }
 
-        // TODO This is currently an unsupported scenario. We will come back to it as we revise
-        // the multidimensional interface and what transformations between dimensionality look like
-        //{
-        //    span<int, 2, 2> s{arr};
-        //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
-        //}
-
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
             span<int, 5> s{arr};
-#endif
         }
 
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
             auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; };
             auto take_a_span = [](span<int> s) { (void) s; };
             // try to take a temporary std::array
             take_a_span(get_an_array());
-#endif
         }
+#endif
     }
 
     TEST(from_const_std_array_constructor)
@@ -440,7 +415,7 @@ SUITE(span_tests)
             span<const int, 4> s{arr};
             CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
         }
-
+#ifdef CONFIRM_COMPILATION_ERRORS
         {
             span<const int, 2> s{arr};
             CHECK(s.size() == 2 && s.data() == arr.data());
@@ -451,29 +426,19 @@ SUITE(span_tests)
             CHECK(s.size() == 0 && s.data() == arr.data());
         }
 
-        // TODO This is currently an unsupported scenario. We will come back to it as we revise
-        // the multidimensional interface and what transformations between dimensionality look like
-        //{
-        //    span<int, 2, 2> s{arr};
-        //    CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
-        //}
-
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
             span<const int, 5> s{arr};
-#endif
         }
 
         {
-#ifdef CONFIRM_COMPILATION_ERRORS
             auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
             auto take_a_span = [](span<const int> s) { (void) s; };
             // try to take a temporary std::array
             take_a_span(get_an_array());
-#endif
         }
+#endif
     }
-
+#if 0
     TEST(from_container_constructor)
     {
         std::vector<int> v = {1, 2, 3};

From c40094a532f932bc0ed7af2279161dc4bc72b85d Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 1 Mar 2016 12:11:41 -0800
Subject: [PATCH 09/42] Added from-container constructors.

---
 include/multi_span.h        | 18 ++++++-------
 include/span.h              | 50 +++++++++++++++++++++++++++++++------
 include/string_span.h       | 28 ++++++++++-----------
 tests/span_tests.cpp        |  4 +--
 tests/string_span_tests.cpp |  2 +-
 5 files changed, 68 insertions(+), 34 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index b070f29..5eb9109 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -1156,22 +1156,22 @@ namespace details
     };
 
     template <typename T>
-    struct is_span_oracle : std::false_type
+    struct is_multi_span_oracle : std::false_type
     {
     };
 
     template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct is_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
+    struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
     {
     };
 
     template <typename ValueType, std::ptrdiff_t Rank>
-    struct is_span_oracle<strided_span<ValueType, Rank>> : std::true_type
+    struct is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type
     {
     };
 
     template <typename T>
-    struct is_span : is_span_oracle<std::remove_cv_t<T>>
+    struct is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>>
     {
     };
 }
@@ -1324,7 +1324,7 @@ public:
     // type-requirements: container must have .size(), operator[] which are value_type compatible
     template <typename Cont, typename DataType = typename Cont::value_type,
               typename = std::enable_if_t<
-                  !details::is_span<Cont>::value &&
+                  !details::is_multi_span<Cont>::value &&
                   std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
@@ -1338,7 +1338,7 @@ public:
     // prevent constructing from temporary containers
     template <typename Cont, typename DataType = typename Cont::value_type,
               typename = std::enable_if_t<
-                  !details::is_span<Cont>::value &&
+                  !details::is_multi_span<Cont>::value &&
                   std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
@@ -1595,7 +1595,7 @@ template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof..
 constexpr multi_span<typename SpanType::value_type, Dimensions2::value...> as_span(SpanType s,
                                                                              Dimensions2... dims)
 {
-    static_assert(details::is_span<SpanType>::value,
+    static_assert(details::is_multi_span<SpanType>::value,
                   "Variadic as_span() is for reshaping existing spans.");
     using BoundsType =
         typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
@@ -1718,7 +1718,7 @@ constexpr multi_span<T, dynamic_range> as_span(T* begin, T* end)
 
 template <typename Cont>
 constexpr auto as_span(Cont& arr) -> std::enable_if_t<
-    !details::is_span<std::decay_t<Cont>>::value,
+    !details::is_multi_span<std::decay_t<Cont>>::value,
     multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
 {
     Expects(arr.size() < PTRDIFF_MAX);
@@ -1727,7 +1727,7 @@ constexpr auto as_span(Cont& arr) -> std::enable_if_t<
 
 template <typename Cont>
 constexpr auto as_span(Cont&& arr) -> std::enable_if_t<
-    !details::is_span<std::decay_t<Cont>>::value,
+    !details::is_multi_span<std::decay_t<Cont>>::value,
     multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
 
 // from basic_string which doesn't have nonconst .data() member like other contiguous containers
diff --git a/include/span.h b/include/span.h
index 2d95899..eab2659 100644
--- a/include/span.h
+++ b/include/span.h
@@ -72,12 +72,35 @@
 namespace gsl
 {
 
+template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
+class span;
+
+
+namespace details
+{
+template <class T>
+struct is_span_oracle : std::false_type
+{
+};
+
+template <class ElementType, std::ptrdiff_t Extent>
+struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
+{
+};
+
+template <class T>
+struct is_span : is_span_oracle<std::remove_cv_t<T>>
+{
+};
+} // namespace details
+
+
 // [views.constants], constants  
 constexpr const std::ptrdiff_t dynamic_extent = -1;
 
 
 // [span], class template span 
-template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
+template <class ElementType, std::ptrdiff_t Extent>
 class span {
 public:
     // constants and types 
@@ -122,11 +145,25 @@ public:
         : storage_(&arr[0], extent_type<N>())
     {}
 
-#if 0 // TODO
-    template <class Container>
-    constexpr span(Container& cont);
-    template <class Container>
+    // NB: the SFINAE here uses .data() as a 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 &&
+        std::is_convertible<Container::pointer, pointer>::value &&
+        std::is_convertible<Container::pointer, decltype(std::declval<Container>().data())>::value>
+    >
+    constexpr span(Container& cont) : span(cont.data(), cont.size()) {}
+
+    // 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 &&
+        std::is_convertible<Container::pointer, pointer>::value &&
+        std::is_convertible<Container::pointer, decltype(std::declval<Container>().data())>::value>
+    >
     span(const Container&&) = delete;
+    
+#if 0 // TODO
     constexpr span(const span& other) noexcept = default;
     constexpr span(span&& other) noexcept = default;
     template <class OtherElementType, ptrdiff_t OtherExtent>
@@ -231,9 +268,6 @@ private:
         storage_type(pointer data, OtherExtentType ext)
             : ExtentType(ext), data_(data) {}
 
-        //storage_type(pointer data, ExtentType ext)
-        //    : ExtentType(ext), data_(data) {}
-        
         constexpr inline pointer data() const noexcept
         { return data_; }
 
diff --git a/include/string_span.h b/include/string_span.h
index c58cef9..69c3a81 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -297,7 +297,7 @@ public:
 
     // from containers. Containers must have .size() and .data() function signatures
     template <typename Cont, typename DataType = typename Cont::value_type,
-        typename Dummy = std::enable_if_t<!details::is_span<Cont>::value
+        typename Dummy = std::enable_if_t<!details::is_multi_span<Cont>::value
         && !details::is_basic_string_span<Cont>::value
         && !(!std::is_const<value_type>::value && std::is_const<Cont>::value) // no converting const containers to non-const span
         && std::is_convertible<DataType*, value_type*>::value
@@ -309,7 +309,7 @@ public:
 
     // disallow creation from temporary containers and strings
     template <typename Cont, typename DataType = typename Cont::value_type,
-        typename Dummy = std::enable_if_t<!details::is_span<Cont>::value
+        typename Dummy = std::enable_if_t<!details::is_multi_span<Cont>::value
         && !details::is_basic_string_span<Cont>::value
         && std::is_convertible<DataType*, value_type*>::value
         && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value>
@@ -640,7 +640,7 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -654,7 +654,7 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -694,7 +694,7 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -707,7 +707,7 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -748,7 +748,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -762,7 +762,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -802,7 +802,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -815,7 +815,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -854,7 +854,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -867,7 +867,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -906,7 +906,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -919,7 +919,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
+    !gsl::details::is_multi_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index e13694c..e68493c 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -438,7 +438,7 @@ SUITE(span_tests)
         }
 #endif
     }
-#if 0
+
     TEST(from_container_constructor)
     {
         std::vector<int> v = {1, 2, 3};
@@ -512,7 +512,7 @@ SUITE(span_tests)
 #endif
         }
     }
-
+#if 0
     TEST(from_convertible_span_constructor)
     {
 #ifdef CONFIRM_COMPILATION_ERRORS
diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp
index cd301a0..6876253 100644
--- a/tests/string_span_tests.cpp
+++ b/tests/string_span_tests.cpp
@@ -46,7 +46,7 @@ SUITE(string_span_tests)
     TEST(TestConstructFromStdVector)
     {
         std::vector<char> vec(5, 'h');
-        string_span<> v = vec;
+        string_span<> v {vec};
         CHECK(v.length() == static_cast<string_span<>::size_type>(vec.size()));
     }
 

From 717a2e35f13e723c491aa1d90364a7831cdbb526 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 16 Mar 2016 19:39:55 -0700
Subject: [PATCH 10/42] Added conversion ctors.

---
 include/span.h       | 73 +++++++++++++++++++++++++++++++++++++++++---
 tests/span_tests.cpp | 50 ++++++++++++++++++------------
 2 files changed, 98 insertions(+), 25 deletions(-)

diff --git a/include/span.h b/include/span.h
index eab2659..3c5b53d 100644
--- a/include/span.h
+++ b/include/span.h
@@ -92,6 +92,53 @@ template <class T>
 struct is_span : is_span_oracle<std::remove_cv_t<T>>
 {
 };
+
+template <class From, class To>
+struct is_allowed_pointer_conversion
+    : std::integral_constant<bool,
+        std::is_pointer<From>::value &&
+        std::is_pointer<To>::value &&
+        std::is_convertible<From, To>::value
+    >
+{
+};
+
+template <class From, class To>
+struct is_allowed_integral_conversion
+    : std::integral_constant<bool,
+        std::is_integral<From>::value &&
+        std::is_integral<To>::value &&
+        sizeof(From) == sizeof(To) && 
+        alignof(From) == alignof(To) &&
+        std::is_convertible<From, To>::value
+    >
+{
+};
+
+template <class From, class To>
+struct is_allowed_element_type_conversion
+    : std::integral_constant<bool,        
+        std::is_same<From, std::remove_cv_t<To>>::value ||
+        is_allowed_pointer_conversion<From, To>::value ||
+        is_allowed_integral_conversion<From, To>::value
+    >
+{
+};
+
+template <class From>
+struct is_allowed_element_type_conversion<From, char>
+    : std::integral_constant<bool, !std::is_const<From>::value>
+{
+};
+
+template <class From>
+struct is_allowed_element_type_conversion<From, const char>
+    : std::integral_constant<bool, true>
+{
+};
+
+
+
 } // namespace details
 
 
@@ -163,13 +210,29 @@ public:
     >
     span(const Container&&) = delete;
     
-#if 0 // TODO
     constexpr span(const span& other) noexcept = default;
     constexpr span(span&& other) noexcept = default;
-    template <class OtherElementType, ptrdiff_t OtherExtent>
-    constexpr span(const span<OtherElementType, OtherExtent>& other);
-    template <class OtherElementType, ptrdiff_t OtherExtent>
-    constexpr span(span<OtherElementType, OtherExtent>&& other);
+
+    template <class OtherElementType, std::ptrdiff_t OtherExtent,
+        class = std::enable_if_t<!std::is_same<element_type, OtherElementType>::value &&
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
+        >
+    >
+    constexpr span(const span<OtherElementType, OtherExtent>& other)
+        : storage_(reinterpret_cast<pointer>(other.data()), other.length())
+    {}
+
+    template <class OtherElementType, std::ptrdiff_t OtherExtent,
+        class = std::enable_if_t<!std::is_same<element_type, OtherElementType>::value &&
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
+        >
+    >
+    constexpr span(span<OtherElementType, OtherExtent>&& other)
+        : storage_(reinterpret_cast<pointer>(other.data()), other.length())
+    {
+    }
+
+#if 0 // TODO
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     constexpr span& operator=(span&& other) noexcept = default;
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index e68493c..0b65507 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -512,34 +512,44 @@ SUITE(span_tests)
 #endif
         }
     }
-#if 0
+
     TEST(from_convertible_span_constructor)
     {
+        {
+            span<DerivedClass> avd;
+            span<const DerivedClass> avcd = avd;
+            (void)avcd;
+        }
+
+        {
 #ifdef CONFIRM_COMPILATION_ERRORS
-        span<int, 7, 4, 2> av1(nullptr, b1);
-
-        auto f = [&]() { span<int, 7, 4, 2> av1(nullptr); };
-        CHECK_THROW(f(), fail_fast);
+            span<DerivedClass> avd;
+            span<BaseClass> avb = avd;
+            (void) avb;
 #endif
+        }
 
+        {
+            span<int> s;
+            span<unsigned int> s2 = s;
+            (void)s2;
+        }
+
+        {
+            span<int> s;
+            span<const unsigned int> s2 = s;
+            (void)s2;
+        }
+
+        {
 #ifdef CONFIRM_COMPILATION_ERRORS
-        static_bounds<size_t, 7, dynamic_range, 2> b12(b11);
-        b12 = b11;
-        b11 = b12;
-
-        span<int, dynamic_range> av1 = nullptr;
-        span<int, 7, dynamic_range, 2> av2(av1);
-        span<int, 7, 4, 2> av2(av1);
+            span<int> s;
+            span<short> s2 = s;
+            (void)s2;
 #endif
-
-        span<DerivedClass> avd;
-#ifdef CONFIRM_COMPILATION_ERRORS
-        span<BaseClass> avb = avd;
-#endif
-        span<const DerivedClass> avcd = avd;
-        (void) avcd;
+        }
     }
-
+#if 0
     TEST(copy_move_and_assignment)
     {
         span<int> s1;

From 3d4c34966a093e71f5f6c47ec68d06f2700fd7e2 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Thu, 17 Mar 2016 17:20:33 -0700
Subject: [PATCH 11/42] Fixed ctors for Container and std::array to accept
 temporaries.

---
 include/multi_span.h |  2 +-
 include/span.h       | 13 +++++-----
 tests/span_tests.cpp | 57 +++++++++++++++++++-------------------------
 3 files changed, 31 insertions(+), 41 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index 5eb9109..523f324 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -2159,8 +2159,8 @@ public:
     value_type operator[](difference_type n) const noexcept
     {
         return (*m_container)[m_itr[n]];
-        ;
     }
+
     bool operator==(const general_span_iterator& rhs) const noexcept
     {
         Expects(m_container == rhs.m_container);
diff --git a/include/span.h b/include/span.h
index 3c5b53d..7e8c119 100644
--- a/include/span.h
+++ b/include/span.h
@@ -187,7 +187,7 @@ public:
         : storage_(&arr[0], extent_type<N>())
     {}
 
-    template <size_t N>
+    template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
     constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr)
         : storage_(&arr[0], extent_type<N>())
     {}
@@ -201,15 +201,14 @@ public:
     >
     constexpr span(Container& cont) : span(cont.data(), cont.size()) {}
 
-    // 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 &&
+    class = std::enable_if_t<std::is_const<element_type>::value &&
+        !details::is_span<Container>::value &&
         std::is_convertible<Container::pointer, pointer>::value &&
         std::is_convertible<Container::pointer, decltype(std::declval<Container>().data())>::value>
     >
-    span(const Container&&) = delete;
-    
+    constexpr span(const Container& cont) : span(cont.data(), cont.size()) {}
+
     constexpr span(const span& other) noexcept = default;
     constexpr span(span&& other) noexcept = default;
 
@@ -232,10 +231,10 @@ public:
     {
     }
 
-#if 0 // TODO
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     constexpr span& operator=(span&& other) noexcept = default;
+#if 0 // TODO
 
     // [span.sub], span subviews  
     template <ptrdiff_t Count>
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 0b65507..8534b3e 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -394,12 +394,18 @@ SUITE(span_tests)
         }
 
         {
-            auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; };
-            auto take_a_span = [](span<int> s) { (void) s; };
+            auto get_an_array = []()->std::array<int, 4> { return{1, 2, 3, 4}; };
+            auto take_a_span = [](span<int> s) { (void)s; };
             // try to take a temporary std::array
             take_a_span(get_an_array());
         }
 #endif
+        {
+            auto get_an_array = []() -> std::array<int, 4> { return { 1, 2, 3, 4 }; };
+            auto take_a_span = [](span<const int> s) { (void)s; };
+            // try to take a temporary std::array
+            take_a_span(get_an_array());
+        }
     }
 
     TEST(from_const_std_array_constructor)
@@ -481,14 +487,26 @@ SUITE(span_tests)
 #endif
         }
 
+        {
+            auto get_temp_vector = []() -> std::vector<int> { return{}; };
+            auto use_span = [](span<const int> s) { (void)s; };
+            use_span(get_temp_vector());
+        }
+
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
-            auto get_temp_string = []() -> std::string { return {}; };
-            auto use_span = [](span<char> s) { (void) s; };
+            auto get_temp_string = []() -> std::string { return{}; };
+            auto use_span = [](span<char> s) { (void)s; };
             use_span(get_temp_string());
 #endif
         }
 
+        {
+            auto get_temp_string = []() -> std::string { return {}; };
+            auto use_span = [](span<const char> s) { (void) s; };
+            use_span(get_temp_string());
+        }
+
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_vector = []() -> const std::vector<int> { return {}; };
@@ -549,7 +567,7 @@ SUITE(span_tests)
 #endif
         }
     }
-#if 0
+
     TEST(copy_move_and_assignment)
     {
         span<int> s1;
@@ -570,34 +588,7 @@ SUITE(span_tests)
         s1 = get_temp_span();
         CHECK(s1.length() == 2 && s1.data() == &arr[1]);
     }
-
-    template <class Bounds>
-    void fn(const Bounds&)
-    {
-        static_assert(Bounds::static_size == 60, "static bounds is wrong size");
-    }
-    TEST(as_span_reshape)
-    {
-        int a[3][4][5];
-        auto av = as_span(a);
-        fn(av.bounds());
-        auto av2 = as_span(av, dim<60>());
-        auto av3 = as_span(av2, dim<3>(), dim<4>(), dim<5>());
-        auto av4 = as_span(av3, dim<4>(), dim<>(3), dim<5>());
-        auto av5 = as_span(av4, dim<3>(), dim<4>(), dim<5>());
-        auto av6 = as_span(av5, dim<12>(), dim<>(5));
-
-        fill(av6.begin(), av6.end(), 1);
-
-        auto av7 = as_bytes(av6);
-
-        auto av8 = as_span<int>(av7);
-
-        CHECK(av8.size() == av6.size());
-        for (auto i = 0; i < av8.size(); i++) {
-            CHECK(av8[i] == 1);
-        }
-    }
+#if 0
 
     TEST(first)
     {

From c8a412f0280d0fd79e5f1e150dafcf30b2751cbe Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Fri, 18 Mar 2016 16:49:29 -0700
Subject: [PATCH 12/42] Implemented first, last, subspan.

---
 include/span.h       | 47 ++++++++++++++++++----
 tests/span_tests.cpp | 92 +++-----------------------------------------
 2 files changed, 45 insertions(+), 94 deletions(-)

diff --git a/include/span.h b/include/span.h
index 7e8c119..032779c 100644
--- a/include/span.h
+++ b/include/span.h
@@ -234,19 +234,50 @@ public:
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     constexpr span& operator=(span&& other) noexcept = default;
-#if 0 // TODO
 
     // [span.sub], span subviews  
     template <ptrdiff_t Count>
-    constexpr span<element_type, Count> first() const;
+    constexpr span<element_type, Count> first() const
+    {
+        Expects(Count >= 0 && Count <= size());
+        return { data(), Count };
+    }
+
     template <ptrdiff_t Count>
-    constexpr span<element_type, Count> last() const;
+    constexpr span<element_type, Count> last() const
+    {
+        Expects(Count >= 0 && Count <= size());
+        return{ Count == 0 ? data() : data() + (size() - Count), Count };
+    }
+
     template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
-    constexpr span<element_type, Count> subspan() const;
-    constexpr span<element_type, dynamic_extent> first(index_type count) const;
-    constexpr span<element_type, dynamic_extent> last(index_type count) const;
-    constexpr span<element_type, dynamic_extent> subspan(index_type offset, index_type count = dynamic_extent) const;
-#endif
+    constexpr span<element_type, Count> subspan() const
+    {
+        Expects((Offset == 0 || Offset > 0 && Offset <= size()) &&
+            (Count == dynamic_extent || Count >= 0 && Offset + Count <= size()));
+        return { data() + Offset, Count == dynamic_extent ? size() - Offset : Count };
+    }
+
+    constexpr span<element_type, dynamic_extent> first(index_type count) const
+    {
+        Expects(count >= 0 && count <= size());
+        return { data(), count };
+    }
+
+    constexpr span<element_type, dynamic_extent> last(index_type count) const
+    {
+        Expects(count >= 0 && count <= size());
+        return { count == 0 ? data() : data() + (size() - count), count };
+    }
+
+    constexpr span<element_type, dynamic_extent> subspan(index_type offset,
+        index_type count = dynamic_extent) const
+    {
+        Expects((offset == 0 || offset > 0 && offset <= size()) &&
+            (count == dynamic_extent || count >= 0 && offset + count <= size()));
+        return { data() + offset, count == dynamic_extent ? size() - offset : count };
+    }
+
     // [span.obs], span observers 
     constexpr index_type length() const noexcept { return size(); }
     constexpr index_type size() const noexcept { return storage_.size();  }
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 8534b3e..01784f6 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -588,7 +588,6 @@ SUITE(span_tests)
         s1 = get_temp_span();
         CHECK(s1.length() == 2 && s1.data() == &arr[1]);
     }
-#if 0
 
     TEST(first)
     {
@@ -596,21 +595,18 @@ SUITE(span_tests)
 
         {
             span<int, 5> av = arr;
-            CHECK((av.first<2>().bounds() == static_bounds<2>()));
             CHECK(av.first<2>().length() == 2);
             CHECK(av.first(2).length() == 2);
         }
 
         {
             span<int, 5> av = arr;
-            CHECK((av.first<0>().bounds() == static_bounds<0>()));
             CHECK(av.first<0>().length() == 0);
             CHECK(av.first(0).length() == 0);
         }
 
         {
             span<int, 5> av = arr;
-            CHECK((av.first<5>().bounds() == static_bounds<5>()));
             CHECK(av.first<5>().length() == 5);
             CHECK(av.first(5).length() == 5);
         }
@@ -618,7 +614,6 @@ SUITE(span_tests)
         {
             span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
-            CHECK(av.first<6>().bounds() == static_bounds<6>());
             CHECK(av.first<6>().length() == 6);
             CHECK(av.first<-1>().length() == -1);
 #endif
@@ -626,8 +621,7 @@ SUITE(span_tests)
         }
 
         {
-            span<int, dynamic_range> av;
-            CHECK((av.first<0>().bounds() == static_bounds<0>()));
+            span<int> av;
             CHECK(av.first<0>().length() == 0);
             CHECK(av.first(0).length() == 0);
         }
@@ -639,21 +633,18 @@ SUITE(span_tests)
 
         {
             span<int, 5> av = arr;
-            CHECK((av.last<2>().bounds() == static_bounds<2>()));
             CHECK(av.last<2>().length() == 2);
             CHECK(av.last(2).length() == 2);
         }
 
         {
             span<int, 5> av = arr;
-            CHECK((av.last<0>().bounds() == static_bounds<0>()));
             CHECK(av.last<0>().length() == 0);
             CHECK(av.last(0).length() == 0);
         }
 
         {
             span<int, 5> av = arr;
-            CHECK((av.last<5>().bounds() == static_bounds<5>()));
             CHECK(av.last<5>().length() == 5);
             CHECK(av.last(5).length() == 5);
         }
@@ -661,15 +652,13 @@ SUITE(span_tests)
         {
             span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
-            CHECK((av.last<6>().bounds() == static_bounds<6>()));
             CHECK(av.last<6>().length() == 6);
 #endif
             CHECK_THROW(av.last(6).length(), fail_fast);
         }
 
         {
-            span<int, dynamic_range> av;
-            CHECK((av.last<0>().bounds() == static_bounds<0>()));
+            span<int> av;
             CHECK(av.last<0>().length() == 0);
             CHECK(av.last(0).length() == 0);
         }
@@ -681,7 +670,6 @@ SUITE(span_tests)
 
         {
             span<int, 5> av = arr;
-            CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>()));
             CHECK((av.subspan<2, 2>().length() == 2));
             CHECK(av.subspan(2, 2).length() == 2);
             CHECK(av.subspan(2, 3).length() == 3);
@@ -689,14 +677,12 @@ SUITE(span_tests)
 
         {
             span<int, 5> av = arr;
-            CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
             CHECK((av.subspan<0, 0>().length() == 0));
             CHECK(av.subspan(0, 0).length() == 0);
         }
 
         {
             span<int, 5> av = arr;
-            CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>()));
             CHECK((av.subspan<0, 5>().length() == 5));
             CHECK(av.subspan(0, 5).length() == 5);
             CHECK_THROW(av.subspan(0, 6).length(), fail_fast);
@@ -705,15 +691,14 @@ SUITE(span_tests)
 
         {
             span<int, 5> av = arr;
-            CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>()));
-            CHECK((av.subspan<5, 0>().length() == 0));
+            CHECK((av.subspan<4, 0>().length() == 0));
+            CHECK(av.subspan(4, 0).length() == 0);
             CHECK(av.subspan(5, 0).length() == 0);
             CHECK_THROW(av.subspan(6, 0).length(), fail_fast);
         }
 
         {
-            span<int, dynamic_range> av;
-            CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
+            span<int> av;
             CHECK((av.subspan<0, 0>().length() == 0));
             CHECK(av.subspan(0, 0).length() == 0);
             CHECK_THROW((av.subspan<1, 0>().length()), fail_fast);
@@ -747,72 +732,7 @@ SUITE(span_tests)
             for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
         }
     }
-
-    TEST(rank)
-    {
-        int arr[2] = {1, 2};
-
-        {
-            span<int> s;
-            CHECK(s.rank() == 1);
-        }
-
-        {
-            span<int, 2> s = arr;
-            CHECK(s.rank() == 1);
-        }
-
-        int arr2d[1][1] = {};
-        {
-            span<int, 1, 1> s = arr2d;
-            CHECK(s.rank() == 2);
-        }
-    }
-
-    TEST(extent)
-    {
-        {
-            span<int> s;
-            CHECK(s.extent() == 0);
-            CHECK(s.extent(0) == 0);
-            CHECK_THROW(s.extent(1), fail_fast);
-#ifdef CONFIRM_COMPILATION_ERRORS
-            CHECK(s.extent<1>() == 0);
-#endif
-        }
-
-        {
-            span<int, 0> s;
-            CHECK(s.extent() == 0);
-            CHECK(s.extent(0) == 0);
-            CHECK_THROW(s.extent(1), fail_fast);
-        }
-
-        {
-            int arr2d[1][2] = {};
-
-            span<int, 1, 2> s = arr2d;
-            CHECK(s.extent() == 1);
-            CHECK(s.extent<0>() == 1);
-            CHECK(s.extent<1>() == 2);
-            CHECK(s.extent(0) == 1);
-            CHECK(s.extent(1) == 2);
-            CHECK_THROW(s.extent(3), fail_fast);
-        }
-
-        {
-            int arr2d[1][2] = {};
-
-            span<int, 0, 2> s = arr2d;
-            CHECK(s.extent() == 0);
-            CHECK(s.extent<0>() == 0);
-            CHECK(s.extent<1>() == 2);
-            CHECK(s.extent(0) == 0);
-            CHECK(s.extent(1) == 2);
-            CHECK_THROW(s.extent(3), fail_fast);
-        }
-    }
-
+#if 0
     TEST(operator_function_call)
     {
         int arr[4] = {1, 2, 3, 4};

From 85939048b457e4808f2f9b8c29d257d53f24fe61 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Fri, 18 Mar 2016 16:53:16 -0700
Subject: [PATCH 13/42] Test for operator function call.

---
 tests/span_tests.cpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 01784f6..9afd943 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -732,7 +732,7 @@ SUITE(span_tests)
             for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
         }
     }
-#if 0
+
     TEST(operator_function_call)
     {
         int arr[4] = {1, 2, 3, 4};
@@ -743,15 +743,15 @@ SUITE(span_tests)
             CHECK_THROW(s(5), fail_fast);
         }
 
-        int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
-
         {
-            span<int, 2, 3> s = arr2d;
-            CHECK(s(0, 0) == 1);
-            CHECK(s(1, 2) == 6);
+            int arr2d[2] = {1, 6};
+            span<int, 2> s = arr2d;
+            CHECK(s(0) == 1);
+            CHECK(s(1) == 6);
+            CHECK_THROW(s(2) ,fail_fast);
         }
     }
-
+#if 0
     TEST(comparison_operators)
     {
         {
@@ -864,6 +864,8 @@ SUITE(span_tests)
         }
     }
 
+#if 0
+
     TEST(basics)
     {
         auto ptr = as_span(new int[10], 10);

From d9d6ff01215fe55d8e0768b2c387b564c808dfa2 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 29 May 2016 13:52:28 -0700
Subject: [PATCH 14/42] Added iterators.

---
 include/span.h       | 147 ++++++++++--
 tests/span_tests.cpp | 545 ++++---------------------------------------
 2 files changed, 179 insertions(+), 513 deletions(-)

diff --git a/include/span.h b/include/span.h
index 032779c..f0edafa 100644
--- a/include/span.h
+++ b/include/span.h
@@ -137,6 +137,126 @@ struct is_allowed_element_type_conversion<From, const char>
 {
 };
 
+template <class Span>
+class span_iterator
+    : public std::iterator<std::random_access_iterator_tag, typename Span::element_type>
+{
+    using Base = std::iterator<std::random_access_iterator_tag, typename Span::element_type>;
+
+public:
+    using typename Base::reference;
+    using typename Base::pointer;
+    using typename Base::difference_type;
+
+    span_iterator() : span_iterator(nullptr, 0) {}
+    span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
+    {
+        Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
+    }
+
+    reference operator*() const { Expects(span_); return (*span_)[index_]; }
+    pointer operator->() const { Expects(span_); return &((*span_)[index_]); }
+
+    span_iterator& operator++() noexcept
+    {
+        Expects(span_ && index_ >= 0 && index_ < span_->length());
+        ++index_;
+        return *this;
+    }
+
+    span_iterator operator++(int) noexcept
+    {
+        auto ret = *this;
+        ++(*this);
+        return ret;
+    }
+
+    span_iterator& operator--() noexcept
+    {
+        Expects(span_ && index > 0 && index_ <= span_->length());
+        --index_;
+        return *this;
+    }
+
+    span_iterator operator--(int) noexcept
+    {
+        auto ret = *this;
+        --(*this);
+        return ret;
+    }
+
+    span_iterator operator+(difference_type n) const noexcept
+    {
+        auto ret{*this};
+        return ret += n;
+    }
+    
+    span_iterator& operator+=(difference_type n) noexcept
+    {
+        index_ += n;
+        Expects(span_ && index_ >= 0 && index_ <= span_->length());
+        return *this;
+    }
+
+    span_iterator operator-(difference_type n) const noexcept
+    {
+        auto ret{*this};
+        return ret -= n;
+    }
+
+    span_iterator& operator-=(difference_type n) noexcept
+    {
+        return *this += -n;
+    }
+
+    difference_type operator-(const span_iterator& rhs) const noexcept
+    {
+        Expects(span_ == rhs.span_);
+        return index_ - rhs.index_;
+    }
+
+    reference operator[](difference_type n) const noexcept
+    { return *(*this + n); }
+
+    bool operator==(const span_iterator& rhs) const noexcept
+    { return span_ == rhs.span_ && index_ == rhs.index_; }
+
+    bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
+
+    bool operator<(const span_iterator& rhs) const noexcept
+    {
+        Expects(span_ == rhs.span_);
+        return index_ < rhs.index_;
+    }
+
+    bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
+    
+    bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
+    
+    bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
+
+    void swap(span_iterator& rhs) noexcept
+    {
+        std::swap(index_, rhs.index_);
+        std::swap(m_span, rhs.m_span);
+    }
+
+private:
+    const Span* span_;
+    ptrdiff_t index_;
+};
+
+template <typename Span>
+span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
+    const span_iterator<Span>& rhs) noexcept
+{ return rhs + n; }
+
+template <typename Span>
+span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
+    const span_iterator<Span>& rhs) noexcept
+{
+    return rhs - n;
+}
 
 
 } // namespace details
@@ -155,12 +275,10 @@ public:
     using index_type = std::ptrdiff_t;
     using pointer = element_type*;
     using reference = element_type&;
-#if 0  // TODO
-    using iterator = /*implementation-defined */;
-    using const_iterator = /* implementation-defined */;
+
+    using iterator = details::span_iterator<span<ElementType, Extent>>;
     using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-#endif 
+
     constexpr static const index_type extent = Extent;
 
     // [span.cons], span constructors, copy, assignment, and destructor 
@@ -228,8 +346,7 @@ public:
     >
     constexpr span(span<OtherElementType, OtherExtent>&& other)
         : storage_(reinterpret_cast<pointer>(other.data()), other.length())
-    {
-    }
+    {}
 
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
@@ -293,20 +410,14 @@ public:
     }
     constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
     constexpr pointer data() const noexcept { return storage_.data(); }
-#if 0 // TODO
+
     // [span.iter], span iterator support 
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
+    iterator begin() const noexcept { return {this, 0}; }
+    iterator end() const noexcept { return {this, length()}; }
  
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
+    reverse_iterator rbegin() const noexcept { return {this, length()}; }
+    reverse_iterator rend() const noexcept { return {this, 0}; }
 
-    reverse_iterator rbegin() const noexcept;
-    reverse_iterator rend() const noexcept;
-
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
-#endif
 private:
     template <index_type Extent>
     class extent_type;
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 9afd943..74182de 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -751,6 +751,56 @@ SUITE(span_tests)
             CHECK_THROW(s(2) ,fail_fast);
         }
     }
+
+    TEST(iterator)
+    {
+        span<int>::iterator it1;
+        span<int>::iterator it2;
+        CHECK(it1 == it2);
+    }
+
+    TEST(begin_end)
+    {
+        {
+            int a[] = { 1, 2, 3, 4 };
+            span<int> s = a;
+
+            span<int>::iterator it = s.begin();
+            auto first = it;
+            CHECK(it == first);
+            CHECK(*it == 1);
+
+            span<int>::iterator beyond = s.end();
+            CHECK(it != beyond);
+            CHECK_THROW(*beyond, fail_fast);
+
+            CHECK(beyond - first == 4);
+            CHECK(first - first == 0);
+            CHECK(beyond - beyond == 0);
+            
+            ++it;
+            CHECK(it - first == 1);
+            CHECK(*it == 2);
+            *it = 22;
+            CHECK(*it == 22);
+            CHECK(beyond - it == 3);
+
+            it = first;
+            CHECK(it == first);
+            while (it != s.end())
+            {
+                *it = 5;
+                ++it;
+            }
+
+            CHECK(it == beyond);
+            CHECK(it - beyond == 0);
+
+            for (auto& n : s)
+                CHECK(n == 5);
+        }
+    }
+
 #if 0
     TEST(comparison_operators)
     {
@@ -864,476 +914,6 @@ SUITE(span_tests)
         }
     }
 
-#if 0
-
-    TEST(basics)
-    {
-        auto ptr = as_span(new int[10], 10);
-        fill(ptr.begin(), ptr.end(), 99);
-        for (int num : ptr) {
-            CHECK(num == 99);
-        }
-
-        delete[] ptr.data();
-    }
-
-    TEST(bounds_checks)
-    {
-        int arr[10][2];
-        auto av = as_span(arr);
-
-        fill(begin(av), end(av), 0);
-
-        av[2][0] = 1;
-        av[1][1] = 3;
-
-        // out of bounds
-        CHECK_THROW(av[1][3] = 3, fail_fast);
-        CHECK_THROW((av[{1, 3}] = 3), fail_fast);
-
-        CHECK_THROW(av[10][2], fail_fast);
-        CHECK_THROW((av[{10, 2}]), fail_fast);
-    }
-
-    void overloaded_func(span<const int, dynamic_range, 3, 5> exp, int expected_value)
-    {
-        for (auto val : exp) {
-            CHECK(val == expected_value);
-        }
-    }
-
-    void overloaded_func(span<const char, dynamic_range, 3, 5> exp, char expected_value)
-    {
-        for (auto val : exp) {
-            CHECK(val == expected_value);
-        }
-    }
-
-    void fixed_func(span<int, 3, 3, 5> exp, int expected_value)
-    {
-        for (auto val : exp) {
-            CHECK(val == expected_value);
-        }
-    }
-
-    TEST(span_parameter_test)
-    {
-        auto data = new int[4][3][5];
-
-        auto av = as_span(data, 4);
-
-        CHECK(av.size() == 60);
-
-        fill(av.begin(), av.end(), 34);
-
-        int count = 0;
-        for_each(av.rbegin(), av.rend(), [&](int val) { count += val; });
-        CHECK(count == 34 * 60);
-        overloaded_func(av, 34);
-
-        overloaded_func(as_span(av, dim<>(4), dim<>(3), dim<>(5)), 34);
-
-        // fixed_func(av, 34);
-        delete[] data;
-    }
-
-    TEST(md_access)
-    {
-        auto width = 5, height = 20;
-
-        auto imgSize = width * height;
-        auto image_ptr = new int[imgSize][3];
-
-        // size check will be done
-        auto image_view =
-            as_span(as_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>());
-
-        iota(image_view.begin(), image_view.end(), 1);
-
-        int expected = 0;
-        for (auto i = 0; i < height; i++) {
-            for (auto j = 0; j < width; j++) {
-                CHECK(expected + 1 == image_view[i][j][0]);
-                CHECK(expected + 2 == image_view[i][j][1]);
-                CHECK(expected + 3 == image_view[i][j][2]);
-
-                auto val = image_view[{i, j, 0}];
-                CHECK(expected + 1 == val);
-                val = image_view[{i, j, 1}];
-                CHECK(expected + 2 == val);
-                val = image_view[{i, j, 2}];
-                CHECK(expected + 3 == val);
-
-                expected += 3;
-            }
-        }
-    }
-
-    TEST(as_span)
-    {
-        {
-            int* arr = new int[150];
-
-            auto av = as_span(arr, dim<10>(), dim<>(3), dim<5>());
-
-            fill(av.begin(), av.end(), 24);
-            overloaded_func(av, 24);
-
-            delete[] arr;
-
-            array<int, 15> stdarr{0};
-            auto av2 = as_span(stdarr);
-            overloaded_func(as_span(av2, dim<>(1), dim<3>(), dim<5>()), 0);
-
-            string str = "ttttttttttttttt"; // size = 15
-            auto t = str.data();
-            (void) t;
-            auto av3 = as_span(str);
-            overloaded_func(as_span(av3, dim<>(1), dim<3>(), dim<5>()), 't');
-        }
-
-        {
-            string str;
-            span<char> strspan = as_span(str);
-            (void) strspan;
-            const string cstr;
-            span<const char> cstrspan = as_span(cstr);
-            (void) cstrspan;
-        }
-
-        {
-            int a[3][4][5];
-            auto av = as_span(a);
-            const int(*b)[4][5];
-            b = a;
-            auto bv = as_span(b, 3);
-
-            CHECK(av == bv);
-
-            const std::array<double, 3> arr = {0.0, 0.0, 0.0};
-            auto cv = as_span(arr);
-            (void) cv;
-
-            vector<float> vec(3);
-            auto dv = as_span(vec);
-            (void) dv;
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-            auto dv2 = as_span(std::move(vec));
-#endif
-        }
-    }
-
-    TEST(empty_spans)
-    {
-        {
-            span<int, 0> empty_av(nullptr);
-
-            CHECK(empty_av.bounds().index_bounds() == index<1>{0});
-            CHECK_THROW(empty_av[0], fail_fast);
-            CHECK_THROW(empty_av.begin()[0], fail_fast);
-            CHECK_THROW(empty_av.cbegin()[0], fail_fast);
-            for (auto& v : empty_av) {
-                (void) v;
-                CHECK(false);
-            }
-        }
-
-        {
-            span<int> empty_av = {};
-            CHECK(empty_av.bounds().index_bounds() == index<1>{0});
-            CHECK_THROW(empty_av[0], fail_fast);
-            CHECK_THROW(empty_av.begin()[0], fail_fast);
-            CHECK_THROW(empty_av.cbegin()[0], fail_fast);
-            for (auto& v : empty_av) {
-                (void) v;
-                CHECK(false);
-            }
-        }
-    }
-
-    TEST(index_constructor)
-    {
-        auto arr = new int[8];
-        for (int i = 0; i < 4; ++i) {
-            arr[2 * i] = 4 + i;
-            arr[2 * i + 1] = i;
-        }
-
-        span<int, dynamic_range> av(arr, 8);
-
-        ptrdiff_t a[1] = {0};
-        index<1> i = a;
-
-        CHECK(av[i] == 4);
-
-        auto av2 = as_span(av, dim<4>(), dim<>(2));
-        ptrdiff_t a2[2] = {0, 1};
-        index<2> i2 = a2;
-
-        CHECK(av2[i2] == 0);
-        CHECK(av2[0][i] == 4);
-
-        delete[] arr;
-    }
-
-    TEST(index_constructors)
-    {
-        {
-            // components of the same type
-            index<3> i1(0, 1, 2);
-            CHECK(i1[0] == 0);
-
-            // components of different types
-            size_t c0 = 0;
-            size_t c1 = 1;
-            index<3> i2(c0, c1, 2);
-            CHECK(i2[0] == 0);
-
-            // from array
-            index<3> i3 = {0, 1, 2};
-            CHECK(i3[0] == 0);
-
-            // from other index of the same size type
-            index<3> i4 = i3;
-            CHECK(i4[0] == 0);
-
-            // default
-            index<3> i7;
-            CHECK(i7[0] == 0);
-
-            // default
-            index<3> i9 = {};
-            CHECK(i9[0] == 0);
-        }
-
-        {
-            // components of the same type
-            index<1> i1(0);
-            CHECK(i1[0] == 0);
-
-            // components of different types
-            size_t c0 = 0;
-            index<1> i2(c0);
-            CHECK(i2[0] == 0);
-
-            // from array
-            index<1> i3 = {0};
-            CHECK(i3[0] == 0);
-
-            // from int
-            index<1> i4 = 0;
-            CHECK(i4[0] == 0);
-
-            // from other index of the same size type
-            index<1> i5 = i3;
-            CHECK(i5[0] == 0);
-
-            // default
-            index<1> i8;
-            CHECK(i8[0] == 0);
-
-            // default
-            index<1> i9 = {};
-            CHECK(i9[0] == 0);
-        }
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-        {
-            index<3> i1(0, 1);
-            index<3> i2(0, 1, 2, 3);
-            index<3> i3 = {0};
-            index<3> i4 = {0, 1, 2, 3};
-            index<1> i5 = {0, 1};
-        }
-#endif
-    }
-
-    TEST(index_operations)
-    {
-        ptrdiff_t a[3] = {0, 1, 2};
-        ptrdiff_t b[3] = {3, 4, 5};
-        index<3> i = a;
-        index<3> j = b;
-
-        CHECK(i[0] == 0);
-        CHECK(i[1] == 1);
-        CHECK(i[2] == 2);
-
-        {
-            index<3> k = i + j;
-
-            CHECK(i[0] == 0);
-            CHECK(i[1] == 1);
-            CHECK(i[2] == 2);
-            CHECK(k[0] == 3);
-            CHECK(k[1] == 5);
-            CHECK(k[2] == 7);
-        }
-
-        {
-            index<3> k = i * 3;
-
-            CHECK(i[0] == 0);
-            CHECK(i[1] == 1);
-            CHECK(i[2] == 2);
-            CHECK(k[0] == 0);
-            CHECK(k[1] == 3);
-            CHECK(k[2] == 6);
-        }
-
-        {
-            index<3> k = 3 * i;
-
-            CHECK(i[0] == 0);
-            CHECK(i[1] == 1);
-            CHECK(i[2] == 2);
-            CHECK(k[0] == 0);
-            CHECK(k[1] == 3);
-            CHECK(k[2] == 6);
-        }
-
-        {
-            index<2> k = details::shift_left(i);
-
-            CHECK(i[0] == 0);
-            CHECK(i[1] == 1);
-            CHECK(i[2] == 2);
-            CHECK(k[0] == 1);
-            CHECK(k[1] == 2);
-        }
-    }
-
-    void iterate_second_column(span<int, dynamic_range, dynamic_range> av)
-    {
-        auto length = av.size() / 2;
-
-        // view to the second column
-        auto section = av.section({0, 1}, {length, 1});
-
-        CHECK(section.size() == length);
-        for (auto i = 0; i < section.size(); ++i) {
-            CHECK(section[i][0] == av[i][1]);
-        }
-
-        for (auto i = 0; i < section.size(); ++i) {
-            auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro
-            CHECK(section[idx] == av[i][1]);
-        }
-
-        CHECK(section.bounds().index_bounds()[0] == length);
-        CHECK(section.bounds().index_bounds()[1] == 1);
-        for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) {
-            for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) {
-                auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro
-                CHECK(section[idx] == av[i][1]);
-            }
-        }
-
-        size_t check_sum = 0;
-        for (auto i = 0; i < length; ++i) {
-            check_sum += av[i][1];
-        }
-
-        {
-            auto idx = 0;
-            size_t sum = 0;
-            for (auto num : section) {
-                CHECK(num == av[idx][1]);
-                sum += num;
-                idx++;
-            }
-
-            CHECK(sum == check_sum);
-        }
-        {
-            size_t idx = length - 1;
-            size_t sum = 0;
-            for (auto iter = section.rbegin(); iter != section.rend(); ++iter) {
-                CHECK(*iter == av[idx][1]);
-                sum += *iter;
-                idx--;
-            }
-
-            CHECK(sum == check_sum);
-        }
-    }
-
-    TEST(span_section_iteration)
-    {
-        int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}};
-
-        // static bounds
-        {
-            span<int, 4, 2> av = arr;
-            iterate_second_column(av);
-        }
-        // first bound is dynamic
-        {
-            span<int, dynamic_range, 2> av = arr;
-            iterate_second_column(av);
-        }
-        // second bound is dynamic
-        {
-            span<int, 4, dynamic_range> av = arr;
-            iterate_second_column(av);
-        }
-        // both bounds are dynamic
-        {
-            span<int, dynamic_range, dynamic_range> av = arr;
-            iterate_second_column(av);
-        }
-    }
-
-    TEST(dynamic_span_section_iteration)
-    {
-        auto height = 4, width = 2;
-        auto size = height * width;
-
-        auto arr = new int[size];
-        for (auto i = 0; i < size; ++i) {
-            arr[i] = i;
-        }
-
-        auto av = as_span(arr, size);
-
-        // first bound is dynamic
-        {
-            span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width));
-            iterate_second_column(av2);
-        }
-        // second bound is dynamic
-        {
-            span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
-            iterate_second_column(av2);
-        }
-        // both bounds are dynamic
-        {
-            span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
-            iterate_second_column(av2);
-        }
-
-        delete[] arr;
-    }
-
-    TEST(span_structure_size)
-    {
-        double(*arr)[3][4] = new double[100][3][4];
-        span<double, dynamic_range, 3, 4> av1(arr, 10);
-
-        struct EffectiveStructure
-        {
-            double* v1;
-            ptrdiff_t v2;
-        };
-        CHECK(sizeof(av1) == sizeof(EffectiveStructure));
-
-        CHECK_THROW(av1[10][3][4], fail_fast);
-
-        span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>());
-        (void) av2;
-    }
-
     TEST(fixed_size_conversions)
     {
         int arr[] = {1, 2, 3, 4};
@@ -1458,31 +1038,6 @@ SUITE(span_tests)
         }
     }
 
-    TEST(iterator)
-    {
-        int a[] = {1, 2, 3, 4};
-
-        {
-            span<int, dynamic_range> av = a;
-            auto wav = as_writeable_bytes(av);
-            for (auto& b : wav) {
-                b = byte(0);
-            }
-            for (size_t i = 0; i < 4; ++i) {
-                CHECK(a[i] == 0);
-            }
-        }
-
-        {
-            span<int, dynamic_range> av = a;
-            for (auto& n : av) {
-                n = 1;
-            }
-            for (size_t i = 0; i < 4; ++i) {
-                CHECK(a[i] == 1);
-            }
-        }
-    }
 #endif    
 }
 

From 25ff7eca1fc66ff2f0dc71d8aafe1939f57490a6 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 29 May 2016 13:54:19 -0700
Subject: [PATCH 15/42] Removed some redundant parens.

---
 include/span.h | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/include/span.h b/include/span.h
index f0edafa..187f948 100644
--- a/include/span.h
+++ b/include/span.h
@@ -254,9 +254,7 @@ span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
 template <typename Span>
 span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
-{
-    return rhs - n;
-}
+{ return rhs - n; }
 
 
 } // namespace details
@@ -289,7 +287,7 @@ public:
     {}
 
     constexpr span(pointer ptr, index_type count) : storage_(ptr, count)
-    { Expects(((!ptr && count == 0) || (ptr && count >= 0))); }
+    { Expects((!ptr && count == 0) || (ptr && count >= 0)); }
 
     constexpr span(pointer firstElem, pointer lastElem)
         : storage_(firstElem, std::distance(firstElem, lastElem))

From d63c9803da102dcf87979319d6cf366ef38d5bb0 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 29 May 2016 14:05:09 -0700
Subject: [PATCH 16/42] Added comparison operators.

---
 include/span.h       | 20 ++++++++++++--------
 tests/span_tests.cpp | 28 ++++++++++++++++++----------
 2 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/include/span.h b/include/span.h
index 187f948..2760121 100644
--- a/include/span.h
+++ b/include/span.h
@@ -481,26 +481,30 @@ private:
 };
 
 
-#if 0 // TODO
 // [span.comparison], span comparison operators 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return std::equal(l.begin(), l.end(), r.begin(), r.end()); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return !(l == r); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return !(l > r); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
+constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return r < l; }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) const noexcept;
-#endif
+constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+{ return !(l < r); }
 
 
 #if 0 // TODO
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 74182de..694d9a2 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -801,23 +801,30 @@ SUITE(span_tests)
         }
     }
 
-#if 0
     TEST(comparison_operators)
     {
         {
-            int arr[10][2];
-            auto s1 = as_span(arr);
-            span<const int, dynamic_range, 2> s2 = s1;
-
+            span<int> s1 = nullptr;
+            span<int> s2 = nullptr;
             CHECK(s1 == s2);
-
-            span<int, 20> s3 = as_span(s1, dim<>(20));
-            CHECK(s3 == s2 && s3 == s1);
+            CHECK(!(s1 != s2));
+            CHECK(!(s1 < s2));
+            CHECK(s1 <= s2);
+            CHECK(!(s1 > s2));
+            CHECK(s1 >= s2);
+            CHECK(s2 == s1);
+            CHECK(!(s2 != s1));
+            CHECK(!(s2 < s1));
+            CHECK(s2 <= s1);
+            CHECK(!(s2 > s1));
+            CHECK(s2 >= s1);
         }
 
         {
-            auto s1 = nullptr;
-            auto s2 = nullptr;
+            int arr[] = {2, 1};
+            span<int> s1 = arr;
+            span<int> s2 = arr;
+
             CHECK(s1 == s2);
             CHECK(!(s1 != s2));
             CHECK(!(s1 < s2));
@@ -914,6 +921,7 @@ SUITE(span_tests)
         }
     }
 
+#if 0
     TEST(fixed_size_conversions)
     {
         int arr[] = {1, 2, 3, 4};

From ba8ebef509653127e74063097c1f7703b8a27185 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 29 May 2016 17:06:29 -0700
Subject: [PATCH 17/42] Added span to object rep conversions.

---
 include/byte.h       | 33 ++++++++++++++++
 include/multi_span.h |  4 +-
 include/span.h       | 34 +++++++++++++----
 tests/span_tests.cpp | 91 ++++++++++++++++++++++++++++++--------------
 4 files changed, 124 insertions(+), 38 deletions(-)
 create mode 100644 include/byte.h

diff --git a/include/byte.h b/include/byte.h
new file mode 100644
index 0000000..c6449aa
--- /dev/null
+++ b/include/byte.h
@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////// 
+// 
+// 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. 
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#ifndef GSL_BYTE_H
+#define GSL_BYTE_H
+
+namespace gsl
+{
+    // This is a simple definition for now that allows
+    // use of byte within span<> to be standards-compliant
+    //
+    // Ultimately a small language change would allow a more
+    // robust definition (see WG21 proposal P0257 for details).
+    using byte = unsigned char;
+    
+} // namespace gsl
+
+#endif // GSL_BYTE_H
\ No newline at end of file
diff --git a/include/multi_span.h b/include/multi_span.h
index 523f324..3d00c6e 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -21,6 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
+#include "byte.h"
 #include <algorithm>
 #include <array>
 #include <cassert>
@@ -1053,9 +1054,6 @@ template <typename Span>
 class contiguous_span_iterator;
 template <typename Span>
 class general_span_iterator;
-enum class byte : std::uint8_t
-{
-};
 
 template <std::ptrdiff_t DimSize = dynamic_range>
 struct dim
diff --git a/include/span.h b/include/span.h
index 2760121..7152c2d 100644
--- a/include/span.h
+++ b/include/span.h
@@ -21,6 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
+#include "byte.h"
 #include <array>
 #include <limits>
 #include <iterator>
@@ -126,13 +127,13 @@ struct is_allowed_element_type_conversion
 };
 
 template <class From>
-struct is_allowed_element_type_conversion<From, char>
+struct is_allowed_element_type_conversion<From, byte>
     : std::integral_constant<bool, !std::is_const<From>::value>
 {
 };
 
 template <class From>
-struct is_allowed_element_type_conversion<From, const char>
+struct is_allowed_element_type_conversion<From, const byte>
     : std::integral_constant<bool, true>
 {
 };
@@ -507,14 +508,33 @@ constexpr bool operator>=(const span<ElementType, Extent>& l, const span<Element
 { return !(l < r); }
 
 
-#if 0 // TODO
+namespace details
+{
+    // if we only supported compilers with good constexpr support then
+    // this pair of classes could collapse down to a constexpr function
+
+    // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as constexpr
+    // and so will fail compilation of the template
+    template <class ElementType, ptrdiff_t Extent>
+    struct calculate_byte_size :
+        std::integral_constant<std::ptrdiff_t, static_cast<ptrdiff_t>(sizeof(ElementType) * static_cast<size_t>(Extent))>
+    {};
+
+    template <class ElementType>
+    struct calculate_byte_size<ElementType, dynamic_extent> :
+        std::integral_constant<std::ptrdiff_t, dynamic_extent>
+    {};
+}
+
+
 // [span.objectrep], views of object representation 
 template <class ElementType, ptrdiff_t Extent>
-constexpr span<const char, ((Extent == dynamic_extent) ? dynamic_extent : (sizeof(ElementType) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;
+constexpr span<const byte, details::calculate_byte_size<ElementType, Extent>::value> as_bytes(span<ElementType, Extent> s) noexcept
+{ return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; }
 
-template <class ElementType, ptrdiff_t Extent>
-constexpr span<char, ((Extent == dynamic_extent) ? dynamic_extent : (sizeof(ElementType) * Extent))> as_writeable_bytes(span<ElementType, Extent>) noexcept;
-#endif
+template <class ElementType, ptrdiff_t Extent, class = std::enable_if_t<!std::is_const<ElementType>::value>>
+constexpr span<byte, details::calculate_byte_size<ElementType, Extent>::value> as_writeable_bytes(span<ElementType, Extent> s) noexcept
+{ return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; }
 
 } // namespace gsl
 
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 694d9a2..ddae404 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -921,6 +921,69 @@ SUITE(span_tests)
         }
     }
 
+    TEST(as_bytes)
+    {
+        int a[] = {1, 2, 3, 4};
+
+        {
+            span<const int> s = a;
+            CHECK(s.length() == 4);
+            span<const byte> bs = as_bytes(s);
+            CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+            CHECK(bs.length() == s.length_bytes());
+        }
+
+        {
+            span<int> s;
+            auto bs = as_bytes(s);
+            CHECK(bs.length() == s.length());
+            CHECK(bs.length() == 0);
+            CHECK(bs.size_bytes() == 0);
+            CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+            CHECK(bs.data() == nullptr);
+        }
+
+        {
+            span<int> s = a;
+            auto bs = as_bytes(s);
+            CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+            CHECK(bs.length() == s.length_bytes());
+        }
+    }
+
+    TEST(as_writeable_bytes)
+    {
+        int a[] = {1, 2, 3, 4};
+
+        {
+#ifdef CONFIRM_COMPILATION_ERRORS
+            // you should not be able to get writeable bytes for const objects
+            span<const int> s = a;
+            CHECK(s.length() == 4);
+            span<const byte> bs = as_writeable_bytes(s);
+            CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+            CHECK(bs.length() == s.length_bytes());
+#endif
+        }
+
+        {
+            span<int> s;
+            auto bs = as_writeable_bytes(s);
+            CHECK(bs.length() == s.length());
+            CHECK(bs.length() == 0);
+            CHECK(bs.size_bytes() == 0);
+            CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+            CHECK(bs.data() == nullptr);
+        }
+
+        {
+            span<int> s = a;
+            auto bs = as_writeable_bytes(s);
+            CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+            CHECK(bs.length() == s.length_bytes());
+        }
+    }
+
 #if 0
     TEST(fixed_size_conversions)
     {
@@ -1018,34 +1081,6 @@ SUITE(span_tests)
         CHECK_THROW(f(), fail_fast);
     }
 
-    TEST(as_writeable_bytes)
-    {
-        int a[] = {1, 2, 3, 4};
-
-        {
-#ifdef CONFIRM_COMPILATION_ERRORS
-            // you should not be able to get writeable bytes for const objects
-            span<const int, dynamic_range> av = a;
-            auto wav = av.as_writeable_bytes();
-#endif
-        }
-
-        {
-            span<int, dynamic_range> av;
-            auto wav = as_writeable_bytes(av);
-            CHECK(wav.length() == av.length());
-            CHECK(wav.length() == 0);
-            CHECK(wav.size_bytes() == 0);
-        }
-
-        {
-            span<int, dynamic_range> av = a;
-            auto wav = as_writeable_bytes(av);
-            CHECK(wav.data() == (byte*) &a[0]);
-            CHECK(wav.length() == sizeof(a));
-        }
-    }
-
 #endif    
 }
 

From c94a66f4684e38ad599d5de15a5f6ac319395286 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 12 Jun 2016 18:28:19 -0700
Subject: [PATCH 18/42] Tightened SFINAE for span<U> to span<T> conversions.

---
 include/span.h       |  91 ++++++++++++++++++++++--------------
 tests/span_tests.cpp | 109 +++++++++++++++++++------------------------
 2 files changed, 104 insertions(+), 96 deletions(-)

diff --git a/include/span.h b/include/span.h
index 7152c2d..676fdf2 100644
--- a/include/span.h
+++ b/include/span.h
@@ -77,6 +77,11 @@ template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
 class span;
 
 
+// [views.constants], constants  
+constexpr const std::ptrdiff_t dynamic_extent = -1;
+
+
+// implementation details
 namespace details
 {
 template <class T>
@@ -96,45 +101,55 @@ struct is_span : is_span_oracle<std::remove_cv_t<T>>
 
 template <class From, class To>
 struct is_allowed_pointer_conversion
-    : std::integral_constant<bool,
-        std::is_pointer<From>::value &&
-        std::is_pointer<To>::value &&
-        std::is_convertible<From, To>::value
+    : std::bool_constant<
+    std::is_pointer<From>::value &&
+    std::is_pointer<To>::value &&
+    std::is_convertible<From, To>::value
     >
 {
 };
 
 template <class From, class To>
 struct is_allowed_integral_conversion
-    : std::integral_constant<bool,
-        std::is_integral<From>::value &&
-        std::is_integral<To>::value &&
-        sizeof(From) == sizeof(To) && 
-        alignof(From) == alignof(To) &&
-        std::is_convertible<From, To>::value
+    : std::bool_constant<
+    std::is_integral<From>::value &&
+    std::is_integral<To>::value &&
+    sizeof(From) == sizeof(To) &&
+    alignof(From) == alignof(To) &&
+    std::is_convertible<From, To>::value
+    >
+{
+};
+
+template <std::ptrdiff_t From, std::ptrdiff_t To>
+struct is_allowed_extent_conversion
+    : std::bool_constant<
+    From == To ||
+    From == gsl::dynamic_extent ||
+    To == gsl::dynamic_extent
     >
 {
 };
 
 template <class From, class To>
 struct is_allowed_element_type_conversion
-    : std::integral_constant<bool,        
-        std::is_same<From, std::remove_cv_t<To>>::value ||
-        is_allowed_pointer_conversion<From, To>::value ||
-        is_allowed_integral_conversion<From, To>::value
+    : std::bool_constant<
+    std::is_same<From, std::remove_cv_t<To>>::value ||
+    is_allowed_pointer_conversion<From, To>::value ||
+    is_allowed_integral_conversion<From, To>::value
     >
 {
 };
 
 template <class From>
 struct is_allowed_element_type_conversion<From, byte>
-    : std::integral_constant<bool, !std::is_const<From>::value>
+    : std::bool_constant<!std::is_const<From>::value>
 {
 };
 
 template <class From>
 struct is_allowed_element_type_conversion<From, const byte>
-    : std::integral_constant<bool, true>
+    : std::true_type
 {
 };
 
@@ -191,7 +206,7 @@ public:
         auto ret{*this};
         return ret += n;
     }
-    
+
     span_iterator& operator+=(difference_type n) noexcept
     {
         index_ += n;
@@ -217,10 +232,14 @@ public:
     }
 
     reference operator[](difference_type n) const noexcept
-    { return *(*this + n); }
+    {
+        return *(*this + n);
+    }
 
     bool operator==(const span_iterator& rhs) const noexcept
-    { return span_ == rhs.span_ && index_ == rhs.index_; }
+    {
+        return span_ == rhs.span_ && index_ == rhs.index_;
+    }
 
     bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
 
@@ -231,9 +250,9 @@ public:
     }
 
     bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
-    
+
     bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
-    
+
     bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
 
     void swap(span_iterator& rhs) noexcept
@@ -250,21 +269,20 @@ private:
 template <typename Span>
 span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
-{ return rhs + n; }
+{
+    return rhs + n;
+}
 
 template <typename Span>
 span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
-{ return rhs - n; }
-
+{
+    return rhs - n;
+}
 
 } // namespace details
 
 
-// [views.constants], constants  
-constexpr const std::ptrdiff_t dynamic_extent = -1;
-
-
 // [span], class template span 
 template <class ElementType, std::ptrdiff_t Extent>
 class span {
@@ -330,21 +348,23 @@ public:
     constexpr span(span&& other) noexcept = default;
 
     template <class OtherElementType, std::ptrdiff_t OtherExtent,
-        class = std::enable_if_t<!std::is_same<element_type, OtherElementType>::value &&
+        class = std::enable_if_t<
+            details::is_allowed_extent_conversion<OtherExtent, Extent>::value && 
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
         >
     >
     constexpr span(const span<OtherElementType, OtherExtent>& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), other.length())
+        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
     {}
 
     template <class OtherElementType, std::ptrdiff_t OtherExtent,
-        class = std::enable_if_t<!std::is_same<element_type, OtherElementType>::value &&
+        class = std::enable_if_t<
+            details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
         >
     >
     constexpr span(span<OtherElementType, OtherExtent>&& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), other.length())
+        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
     {}
 
     ~span() noexcept = default;
@@ -418,6 +438,8 @@ public:
     reverse_iterator rend() const noexcept { return {this, 0}; }
 
 private:
+    constexpr static const bool is_span_type = true;
+
     template <index_type Extent>
     class extent_type;
     
@@ -430,10 +452,11 @@ private:
         constexpr extent_type() noexcept {}
 
         template <index_type Other>
-        constexpr extent_type(extent_type<Other>) noexcept
+        constexpr extent_type(extent_type<Other> ext) noexcept
         {
-            static_assert(Other == Extent,
+            static_assert(Other == Extent || Other == dynamic_extent,
                 "Mismatch between fixed-size extent and size of initializing data.");
+            Expects(ext.size() == Extent);
         }
 
         constexpr extent_type(index_type size)
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index ddae404..81784c3 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -395,14 +395,14 @@ SUITE(span_tests)
 
         {
             auto get_an_array = []()->std::array<int, 4> { return{1, 2, 3, 4}; };
-            auto take_a_span = [](span<int> s) { (void)s; };
+            auto take_a_span = [](span<int> s) { static_cast<void>(s); };
             // try to take a temporary std::array
             take_a_span(get_an_array());
         }
 #endif
         {
             auto get_an_array = []() -> std::array<int, 4> { return { 1, 2, 3, 4 }; };
-            auto take_a_span = [](span<const int> s) { (void)s; };
+            auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
             // try to take a temporary std::array
             take_a_span(get_an_array());
         }
@@ -438,7 +438,7 @@ SUITE(span_tests)
 
         {
             auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
-            auto take_a_span = [](span<const int> s) { (void) s; };
+            auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
             // try to take a temporary std::array
             take_a_span(get_an_array());
         }
@@ -482,35 +482,35 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_vector = []() -> std::vector<int> { return {}; };
-            auto use_span = [](span<int> s) { (void) s; };
+            auto use_span = [](span<int> s) { static_cast<void>(s); };
             use_span(get_temp_vector());
 #endif
         }
 
         {
             auto get_temp_vector = []() -> std::vector<int> { return{}; };
-            auto use_span = [](span<const int> s) { (void)s; };
+            auto use_span = [](span<const int> s) { static_cast<void>(s); };
             use_span(get_temp_vector());
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_string = []() -> std::string { return{}; };
-            auto use_span = [](span<char> s) { (void)s; };
+            auto use_span = [](span<char> s) { static_cast<void>(s); };
             use_span(get_temp_string());
 #endif
         }
 
         {
             auto get_temp_string = []() -> std::string { return {}; };
-            auto use_span = [](span<const char> s) { (void) s; };
+            auto use_span = [](span<const char> s) { static_cast<void>(s); };
             use_span(get_temp_string());
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_vector = []() -> const std::vector<int> { return {}; };
-            auto use_span = [](span<const char> s) { (void) s; };
+            auto use_span = [](span<const char> s) { static_cast<void>(s); };
             use_span(get_temp_vector());
 #endif
         }
@@ -518,7 +518,7 @@ SUITE(span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             auto get_temp_string = []() -> const std::string { return {}; };
-            auto use_span = [](span<const char> s) { (void) s; };
+            auto use_span = [](span<const char> s) { static_cast<void>(s); };
             use_span(get_temp_string());
 #endif
         }
@@ -536,34 +536,34 @@ SUITE(span_tests)
         {
             span<DerivedClass> avd;
             span<const DerivedClass> avcd = avd;
-            (void)avcd;
+            static_cast<void>(avcd);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             span<DerivedClass> avd;
             span<BaseClass> avb = avd;
-            (void) avb;
+            static_cast<void>(avb);
 #endif
         }
 
         {
             span<int> s;
             span<unsigned int> s2 = s;
-            (void)s2;
+            static_cast<void>(s2);
         }
 
         {
             span<int> s;
             span<const unsigned int> s2 = s;
-            (void)s2;
+            static_cast<void>(s2);
         }
 
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             span<int> s;
             span<short> s2 = s;
-            (void)s2;
+            static_cast<void>(s2);
 #endif
         }
     }
@@ -984,72 +984,59 @@ SUITE(span_tests)
         }
     }
 
-#if 0
     TEST(fixed_size_conversions)
     {
         int arr[] = {1, 2, 3, 4};
 
         // converting to an span from an equal size array is ok
-        span<int, 4> av4 = arr;
-        CHECK(av4.length() == 4);
+        span<int, 4> s4 = arr;
+        CHECK(s4.length() == 4);
 
-        // converting to dynamic_range a_v is always ok
+        // converting to dynamic_range is always ok
         {
-            span<int, dynamic_range> av = av4;
-            (void) av;
-        }
-        {
-            span<int, dynamic_range> av = arr;
-            (void) av;
+            span<int> s = s4;
+            CHECK(s.length() == s4.length());
+            static_cast<void>(s);
         }
 
 // initialization or assignment to static span that REDUCES size is NOT ok
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<int, 2> av2 = arr;
+            span<int, 2> s = arr;
         }
         {
-            span<int, 2> av2 = av4;
+            span<int, 2> s2 = s4;
+            static_cast<void>(s2);
         }
 #endif
 
+        // even when done dynamically
         {
-            span<int, dynamic_range> av = arr;
-            span<int, 2> av2 = av;
-            (void) av2;
-        }
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-        {
-            span<int, dynamic_range> av = arr;
-            span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>());
-        }
-#endif
-
-        {
-            span<int, dynamic_range> av = arr;
-            span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2));
-            auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
-            CHECK(workaround_macro());
+            span<int> s = arr;
+            auto f = [&]() {
+                span<int, 2> s2 = s;
+                static_cast<void>(s2);
+            };
+            CHECK_THROW(f(), fail_fast);
         }
 
         // but doing so explicitly is ok
 
         // you can convert statically
         {
-            span<int, 2> av2 = {arr, 2};
-            (void) av2;
+            span<int, 2> s2 = {arr, 2};
+            static_cast<void>(s2);
         }
         {
-            span<int, 1> av2 = av4.first<1>();
-            (void) av2;
+            span<int, 1> s1 = s4.first<1>();
+            static_cast<void>(s1);
         }
 
         // ...or dynamically
         {
-            // NB: implicit conversion to span<int,2> from span<int,dynamic_range>
-            span<int, 1> av2 = av4.first(1);
-            (void) av2;
+            // NB: implicit conversion to span<int,1> from span<int>
+            span<int, 1> s1 = s4.first(1);
+            static_cast<void>(s1);
         }
 
         // initialization or assignment to static span that requires size INCREASE is not ok.
@@ -1057,31 +1044,29 @@ SUITE(span_tests)
 
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            span<int, 4> av4 = arr2;
+            span<int, 4> s3 = arr2;
         }
         {
-            span<int, 2> av2 = arr2;
-            span<int, 4> av4 = av2;
+            span<int, 2> s2 = arr2;
+            span<int, 4> s4a = s2;
         }
 #endif
         {
             auto f = [&]() {
-                span<int, 4> av9 = {arr2, 2};
-                (void) av9;
-            };
+                span<int, 4> s4 = {arr2, 2};
+                static_cast<void>(s4);
+            };                     
             CHECK_THROW(f(), fail_fast);
         }
 
-        // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one
-        span<int, dynamic_range> av = arr2;
+        // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one
+        span<int> av = arr2;
         auto f = [&]() {
-            span<int, 4> av2 = av;
-            (void) av2;
+            span<int, 4> s4 = av;
+            static_cast<void>(s4);            
         };
         CHECK_THROW(f(), fail_fast);
     }
-
-#endif    
 }
 
 int main(int, const char* []) { return UnitTest::RunAllTests(); }

From 62f30205e5be7e87f1b566ee8395d9363f2ec984 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 14 Jun 2016 20:14:17 -0700
Subject: [PATCH 19/42] Additional std::array ctor to support const element
 cases.

---
 include/span.h       |  5 +++++
 tests/span_tests.cpp | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/include/span.h b/include/span.h
index 676fdf2..3e0ccc9 100644
--- a/include/span.h
+++ b/include/span.h
@@ -318,6 +318,11 @@ public:
     {}
 
     template <size_t N>
+    constexpr span(std::array<element_type, N>& arr)
+        : storage_(&arr[0], extent_type<N>())
+    {}
+
+    template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
     constexpr span(std::array<std::remove_const_t<element_type>, N>& arr)
         : storage_(&arr[0], extent_type<N>())
     {}
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 81784c3..5c17552 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -400,6 +400,7 @@ SUITE(span_tests)
             take_a_span(get_an_array());
         }
 #endif
+
         {
             auto get_an_array = []() -> std::array<int, 4> { return { 1, 2, 3, 4 }; };
             auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
@@ -445,6 +446,40 @@ SUITE(span_tests)
 #endif
     }
 
+    TEST(from_std_array_const_constructor)
+    {
+        std::array<const int, 4> arr = {1, 2, 3, 4};
+
+        {
+            span<const int> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 4> s{arr};
+            CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
+        }
+#ifdef CONFIRM_COMPILATION_ERRORS
+        {
+            span<const int, 2> s{arr};
+            CHECK(s.size() == 2 && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 0> s{arr};
+            CHECK(s.size() == 0 && s.data() == arr.data());
+        }
+
+        {
+            span<const int, 5> s{arr};
+        }
+
+        {
+            span<int, 4> s{arr};
+        }
+#endif
+    }
+
     TEST(from_container_constructor)
     {
         std::vector<int> v = {1, 2, 3};

From 64598bc0f724ae123dc0ecc734cbd0ccc6de552b Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 14 Jun 2016 20:20:09 -0700
Subject: [PATCH 20/42] Cleaned up last() functions to match spec.

---
 include/span.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/span.h b/include/span.h
index 3e0ccc9..00225ba 100644
--- a/include/span.h
+++ b/include/span.h
@@ -388,7 +388,7 @@ public:
     constexpr span<element_type, Count> last() const
     {
         Expects(Count >= 0 && Count <= size());
-        return{ Count == 0 ? data() : data() + (size() - Count), Count };
+        return{ data() + (size() - Count), Count };
     }
 
     template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
@@ -408,7 +408,7 @@ public:
     constexpr span<element_type, dynamic_extent> last(index_type count) const
     {
         Expects(count >= 0 && count <= size());
-        return { count == 0 ? data() : data() + (size() - count), count };
+        return { data() + (size() - count), count };
     }
 
     constexpr span<element_type, dynamic_extent> subspan(index_type offset,

From 7b00172f0073305cd868cecc2d8ab0e716613b39 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 20 Jun 2016 01:41:49 -0700
Subject: [PATCH 21/42] Final sync with D0122R3 version of specification.

---
 include/span.h | 64 +++++++++++++++++++++++++-------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/include/span.h b/include/span.h
index 00225ba..e52e14a 100644
--- a/include/span.h
+++ b/include/span.h
@@ -164,96 +164,96 @@ public:
     using typename Base::pointer;
     using typename Base::difference_type;
 
-    span_iterator() : span_iterator(nullptr, 0) {}
-    span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
+    constexpr span_iterator() : span_iterator(nullptr, 0) {}
+    constexpr span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
     {
         Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
     }
 
-    reference operator*() const { Expects(span_); return (*span_)[index_]; }
-    pointer operator->() const { Expects(span_); return &((*span_)[index_]); }
+    constexpr reference operator*() const { Expects(span_); return (*span_)[index_]; }
+    constexpr pointer operator->() const { Expects(span_); return &((*span_)[index_]); }
 
-    span_iterator& operator++() noexcept
+    constexpr span_iterator& operator++() noexcept
     {
         Expects(span_ && index_ >= 0 && index_ < span_->length());
         ++index_;
         return *this;
     }
 
-    span_iterator operator++(int) noexcept
+    constexpr span_iterator operator++(int) noexcept
     {
         auto ret = *this;
         ++(*this);
         return ret;
     }
 
-    span_iterator& operator--() noexcept
+    constexpr span_iterator& operator--() noexcept
     {
         Expects(span_ && index > 0 && index_ <= span_->length());
         --index_;
         return *this;
     }
 
-    span_iterator operator--(int) noexcept
+    constexpr span_iterator operator--(int) noexcept
     {
         auto ret = *this;
         --(*this);
         return ret;
     }
 
-    span_iterator operator+(difference_type n) const noexcept
+    constexpr span_iterator operator+(difference_type n) const noexcept
     {
         auto ret{*this};
         return ret += n;
     }
 
-    span_iterator& operator+=(difference_type n) noexcept
+    constexpr span_iterator& operator+=(difference_type n) noexcept
     {
         index_ += n;
         Expects(span_ && index_ >= 0 && index_ <= span_->length());
         return *this;
     }
 
-    span_iterator operator-(difference_type n) const noexcept
+    constexpr span_iterator operator-(difference_type n) const noexcept
     {
         auto ret{*this};
         return ret -= n;
     }
 
-    span_iterator& operator-=(difference_type n) noexcept
+    constexpr span_iterator& operator-=(difference_type n) noexcept
     {
         return *this += -n;
     }
 
-    difference_type operator-(const span_iterator& rhs) const noexcept
+    constexpr difference_type operator-(const span_iterator& rhs) const noexcept
     {
         Expects(span_ == rhs.span_);
         return index_ - rhs.index_;
     }
 
-    reference operator[](difference_type n) const noexcept
+    constexpr reference operator[](difference_type n) const noexcept
     {
         return *(*this + n);
     }
 
-    bool operator==(const span_iterator& rhs) const noexcept
+    constexpr bool operator==(const span_iterator& rhs) const noexcept
     {
         return span_ == rhs.span_ && index_ == rhs.index_;
     }
 
-    bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
+    constexpr bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
 
-    bool operator<(const span_iterator& rhs) const noexcept
+    constexpr bool operator<(const span_iterator& rhs) const noexcept
     {
         Expects(span_ == rhs.span_);
         return index_ < rhs.index_;
     }
 
-    bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
+    constexpr bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
 
-    bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
+    constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
 
-    bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
+    constexpr bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
 
     void swap(span_iterator& rhs) noexcept
     {
@@ -267,14 +267,14 @@ private:
 };
 
 template <typename Span>
-span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
+constexpr span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
 {
     return rhs + n;
 }
 
 template <typename Span>
-span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
+constexpr span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
 {
     return rhs - n;
@@ -313,7 +313,7 @@ public:
     {}
     
     template <size_t N>
-    constexpr span(element_type(&arr)[N])
+    constexpr span(element_type(&arr)[N]) noexcept
         : storage_(&arr[0], extent_type<N>())
     {}
 
@@ -496,7 +496,7 @@ private:
     {
     public:
         template <class OtherExtentType>
-        storage_type(pointer data, OtherExtentType ext)
+        constexpr storage_type(pointer data, OtherExtentType ext)
             : ExtentType(ext), data_(data) {}
 
         constexpr inline pointer data() const noexcept
@@ -512,27 +512,27 @@ private:
 
 // [span.comparison], span comparison operators 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return std::equal(l.begin(), l.end(), r.begin(), r.end()); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return !(l == r); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return !(l > r); }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return r < l; }
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) noexcept
+constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
 { return !(l < r); }
 
 
@@ -557,11 +557,11 @@ namespace details
 
 // [span.objectrep], views of object representation 
 template <class ElementType, ptrdiff_t Extent>
-constexpr span<const byte, details::calculate_byte_size<ElementType, Extent>::value> as_bytes(span<ElementType, Extent> s) noexcept
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value> as_bytes(span<ElementType, Extent> s) noexcept
 { return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; }
 
 template <class ElementType, ptrdiff_t Extent, class = std::enable_if_t<!std::is_const<ElementType>::value>>
-constexpr span<byte, details::calculate_byte_size<ElementType, Extent>::value> as_writeable_bytes(span<ElementType, Extent> s) noexcept
+span<byte, details::calculate_byte_size<ElementType, Extent>::value> as_writeable_bytes(span<ElementType, Extent> s) noexcept 
 { return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; }
 
 } // namespace gsl

From b72d7abfb05aab6e3be88d414811473cb9394465 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Fri, 24 Jun 2016 04:54:09 -0700
Subject: [PATCH 22/42] Added definition of gsl::byte to match proposed
 std::byte.

---
 include/byte.h       | 46 ++++++++++++++++++++--
 tests/CMakeLists.txt |  1 +
 tests/byte_tests.cpp | 92 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 135 insertions(+), 4 deletions(-)
 create mode 100644 tests/byte_tests.cpp

diff --git a/include/byte.h b/include/byte.h
index c6449aa..6e32fef 100644
--- a/include/byte.h
+++ b/include/byte.h
@@ -23,10 +23,48 @@ namespace gsl
 {
     // This is a simple definition for now that allows
     // use of byte within span<> to be standards-compliant
-    //
-    // Ultimately a small language change would allow a more
-    // robust definition (see WG21 proposal P0257 for details).
-    using byte = unsigned char;
+    enum class byte : unsigned char {};
+
+    template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+    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>>
+    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>>
+    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>>
+    constexpr byte operator>> (byte b, IntegerType shift) noexcept
+    { return byte(static_cast<unsigned char>(b) >> shift); }
+
+    constexpr byte& operator|=(byte& l, byte r) noexcept
+    { return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); }
+
+    constexpr byte operator|(byte l, byte r) noexcept
+    { return byte(static_cast<unsigned char>(l) + static_cast<unsigned char>(r)); }
+
+    constexpr byte& operator&=(byte& l, byte r) noexcept
+    { return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); }
+
+    constexpr byte operator&(byte l, byte r) noexcept
+    { return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); }
+
+    constexpr byte& operator^=(byte& l, byte r) noexcept
+    { return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); }
+    
+    constexpr byte operator^(byte l, byte r) noexcept
+    { return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); }
+    
+    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>>
+    constexpr IntegerType to_integer(byte b) noexcept { return {b}; }
+
     
 } // namespace gsl
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 9723309..009b52d 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -54,3 +54,4 @@ add_gsl_test(notnull_tests)
 add_gsl_test(assertion_tests)
 add_gsl_test(utils_tests)
 add_gsl_test(owner_tests)
+add_gsl_test(byte_tests)
\ No newline at end of file
diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp
new file mode 100644
index 0000000..ff91e50
--- /dev/null
+++ b/tests/byte_tests.cpp
@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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 <UnitTest++/UnitTest++.h>
+#include <byte.h>
+
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace gsl;
+
+namespace
+{
+
+SUITE(byte_tests)
+{
+    TEST(construction)
+    {
+        {
+            byte b = static_cast<byte>(4);
+            CHECK(static_cast<unsigned char>(b) == 4);
+        }
+
+        {
+            byte b = byte(12);
+            CHECK(static_cast<unsigned char>(b) == 12);
+        }
+
+        // waiting for C++17 enum class direct initializer support
+        //{
+        //    byte b { 14 };
+        //    CHECK(static_cast<unsigned char>(b) == 14);
+        //}
+    }
+
+    TEST(bitwise_operations)
+    {
+        byte b = byte(0xFF);
+
+        byte a = byte(0x00);
+        CHECK((b | a) == byte(0xFF));
+        CHECK(a == byte(0x00));
+
+        a |= b;
+        CHECK(a == byte(0xFF));
+
+        a = byte(0x01);
+        CHECK((b & a) == byte(0x01));
+
+        a &= b;
+        CHECK(a == byte(0x01));
+
+        CHECK((b ^ a) == byte(0xFE));
+        
+        CHECK(a == byte(0x01));
+        a ^= b;
+        CHECK(a == byte(0xFE));
+
+        a = byte(0x01);
+        CHECK(~a == byte(0xFE));
+
+        a = byte(0xFF);
+        CHECK((a << 4) == byte(0xF0));
+        CHECK((a >> 4) == byte(0x0F));
+
+        a <<= 4;
+        CHECK(a == byte(0xF0));
+        a >>= 4;
+        CHECK(a == byte(0x0F));
+    }
+}
+}
+
+int main(int, const char* []) { return UnitTest::RunAllTests(); }

From 267472449c2ff450aff9ae068d4a8c93651f310f Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Sun, 26 Jun 2016 17:00:56 +0300
Subject: [PATCH 23/42] Renamed byte header and tidied up string_span
 dependencies.

---
 include/{byte.h => gsl_byte.h} |   0
 include/multi_span.h           |   2 +-
 include/span.h                 | 126 +++++++++++++++++-----
 include/string_span.h          | 187 ++++++++++++++++-----------------
 tests/byte_tests.cpp           |   2 +-
 tests/string_span_tests.cpp    |  28 ++---
 6 files changed, 208 insertions(+), 137 deletions(-)
 rename include/{byte.h => gsl_byte.h} (100%)

diff --git a/include/byte.h b/include/gsl_byte.h
similarity index 100%
rename from include/byte.h
rename to include/gsl_byte.h
diff --git a/include/multi_span.h b/include/multi_span.h
index 3d00c6e..c4a0eac 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -21,7 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
-#include "byte.h"
+#include "gsl_byte.h"
 #include <algorithm>
 #include <array>
 #include <cassert>
diff --git a/include/span.h b/include/span.h
index e52e14a..053b488 100644
--- a/include/span.h
+++ b/include/span.h
@@ -21,7 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
-#include "byte.h"
+#include "gsl_byte.h"
 #include <array>
 #include <limits>
 #include <iterator>
@@ -154,18 +154,21 @@ struct is_allowed_element_type_conversion<From, const byte>
 };
 
 template <class Span>
-class span_iterator
-    : public std::iterator<std::random_access_iterator_tag, typename Span::element_type>
+class const_span_iterator
 {
-    using Base = std::iterator<std::random_access_iterator_tag, typename Span::element_type>;
-
 public:
-    using typename Base::reference;
-    using typename Base::pointer;
-    using typename Base::difference_type;
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = typename Span::element_type;
+    using difference_type = std::ptrdiff_t;
 
-    constexpr span_iterator() : span_iterator(nullptr, 0) {}
-    constexpr span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
+    using const_pointer = std::add_const_t<value_type*>;
+    using pointer = const_pointer;
+
+    using const_reference = std::add_const_t<value_type&>;
+    using reference = const_reference;
+
+    constexpr const_span_iterator() : const_span_iterator(nullptr, 0) {}
+    constexpr const_span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
     {
         Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
     }
@@ -173,59 +176,59 @@ public:
     constexpr reference operator*() const { Expects(span_); return (*span_)[index_]; }
     constexpr pointer operator->() const { Expects(span_); return &((*span_)[index_]); }
 
-    constexpr span_iterator& operator++() noexcept
+    constexpr const_span_iterator& operator++() noexcept
     {
         Expects(span_ && index_ >= 0 && index_ < span_->length());
         ++index_;
         return *this;
     }
 
-    constexpr span_iterator operator++(int) noexcept
+    constexpr const_span_iterator operator++(int) noexcept
     {
         auto ret = *this;
         ++(*this);
         return ret;
     }
 
-    constexpr span_iterator& operator--() noexcept
+    constexpr const_span_iterator& operator--() noexcept
     {
         Expects(span_ && index > 0 && index_ <= span_->length());
         --index_;
         return *this;
     }
 
-    constexpr span_iterator operator--(int) noexcept
+    constexpr const_span_iterator operator--(int) noexcept
     {
         auto ret = *this;
         --(*this);
         return ret;
     }
 
-    constexpr span_iterator operator+(difference_type n) const noexcept
+    constexpr const_span_iterator operator+(difference_type n) const noexcept
     {
         auto ret{*this};
         return ret += n;
     }
 
-    constexpr span_iterator& operator+=(difference_type n) noexcept
+    constexpr const_span_iterator& operator+=(difference_type n) noexcept
     {
         index_ += n;
         Expects(span_ && index_ >= 0 && index_ <= span_->length());
         return *this;
     }
 
-    constexpr span_iterator operator-(difference_type n) const noexcept
+    constexpr const_span_iterator operator-(difference_type n) const noexcept
     {
         auto ret{*this};
         return ret -= n;
     }
 
-    constexpr span_iterator& operator-=(difference_type n) noexcept
+    constexpr const_span_iterator& operator-=(difference_type n) noexcept
     {
         return *this += -n;
     }
 
-    constexpr difference_type operator-(const span_iterator& rhs) const noexcept
+    constexpr difference_type operator-(const const_span_iterator& rhs) const noexcept
     {
         Expects(span_ == rhs.span_);
         return index_ - rhs.index_;
@@ -236,26 +239,26 @@ public:
         return *(*this + n);
     }
 
-    constexpr bool operator==(const span_iterator& rhs) const noexcept
+    constexpr bool operator==(const const_span_iterator& rhs) const noexcept
     {
         return span_ == rhs.span_ && index_ == rhs.index_;
     }
 
-    constexpr bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
+    constexpr bool operator!=(const const_span_iterator& rhs) const noexcept { return !(*this == rhs); }
 
-    constexpr bool operator<(const span_iterator& rhs) const noexcept
+    constexpr bool operator<(const const_span_iterator& rhs) const noexcept
     {
         Expects(span_ == rhs.span_);
         return index_ < rhs.index_;
     }
 
-    constexpr bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
+    constexpr bool operator<=(const const_span_iterator& rhs) const noexcept { return !(rhs < *this); }
 
-    constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
+    constexpr bool operator>(const const_span_iterator& rhs) const noexcept { return rhs < *this; }
 
-    constexpr bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
+    constexpr bool operator>=(const const_span_iterator& rhs) const noexcept { return !(rhs > *this); }
 
-    void swap(span_iterator& rhs) noexcept
+    void swap(const_span_iterator& rhs) noexcept
     {
         std::swap(index_, rhs.index_);
         std::swap(m_span, rhs.m_span);
@@ -266,6 +269,75 @@ private:
     ptrdiff_t index_;
 };
 
+
+template <class Span>
+class span_iterator : public const_span_iterator<Span>
+{
+    using base_type = const_span_iterator<Span>;
+
+public:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = typename Span::element_type;
+    using difference_type = std::ptrdiff_t;
+
+    using pointer = value_type*;
+    using reference = value_type&;
+
+    constexpr span_iterator() : base_type() {}
+    constexpr span_iterator(const Span* span, typename Span::index_type index) : base_type(span, index) {}
+
+    constexpr reference operator*() const { return reinterpret_cast<reference>(base_type::operator*()); }
+    constexpr pointer operator->() const { return reinterpret_cast<pointer>(base_type::operator->()); }
+
+    constexpr span_iterator& operator++() noexcept { base_type::operator++(); return *this; }
+
+    constexpr span_iterator operator++(int) noexcept { return base_type::operator++(1); }
+
+    constexpr span_iterator& operator--() noexcept { base_type::operator--(); return *this; }
+
+    constexpr span_iterator operator--(int) noexcept { return base_type::operator--(1); }
+
+    constexpr span_iterator operator+(difference_type n) const noexcept { return base_type::operator+(n); }
+
+    constexpr span_iterator& operator+=(difference_type n) noexcept { return base_type::operator+=(n); }
+
+    constexpr span_iterator operator-(difference_type n) const noexcept { return base_type::operator-(n); }
+
+    constexpr span_iterator& operator-=(difference_type n) noexcept { return base_type::operator-=(n); }
+
+    constexpr difference_type operator-(const span_iterator& rhs) const noexcept { return base_type::operator-(rhs); }
+
+    constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); }
+
+    constexpr bool operator==(const span_iterator& rhs) const noexcept { return base_type::operator==(rhs); }
+
+    constexpr bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
+
+    constexpr bool operator<(const span_iterator& rhs) const noexcept { return base_type::operator<(rhs); }
+
+    constexpr bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
+
+    constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
+
+    constexpr bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
+
+    void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
+};
+
+template <typename Span>
+constexpr const_span_iterator<Span> operator+(typename const_span_iterator<Span>::difference_type n,
+    const const_span_iterator<Span>& rhs) noexcept
+{
+    return rhs + n;
+}
+
+template <typename Span>
+constexpr const_span_iterator<Span> operator-(typename const_span_iterator<Span>::difference_type n,
+    const const_span_iterator<Span>& rhs) noexcept
+{
+    return rhs - n;
+}
+
 template <typename Span>
 constexpr span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
     const span_iterator<Span>& rhs) noexcept
@@ -294,7 +366,9 @@ public:
     using reference = element_type&;
 
     using iterator = details::span_iterator<span<ElementType, Extent>>;
+    using const_iterator = details::span_iterator<span>;
     using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
     constexpr static const index_type extent = Extent;
 
diff --git a/include/string_span.h b/include/string_span.h
index 69c3a81..8aba362 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -21,7 +21,7 @@
 
 #include "gsl_assert.h"
 #include "gsl_util.h"
-#include "multi_span.h"
+#include "span.h"
 #include <cstring>
 #include <string>
 
@@ -72,19 +72,19 @@ namespace gsl
 // (sometimes needlessly) break existing programs when introduced.
 //
 
-template<typename CharT, std::ptrdiff_t Extent = dynamic_range>
+template<typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 using basic_zstring = CharT*;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using czstring = basic_zstring<const char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using cwzstring = basic_zstring<const wchar_t, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using zstring = basic_zstring<char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using wzstring = basic_zstring<wchar_t, Extent>;
 
 //
@@ -96,7 +96,7 @@ using wzstring = basic_zstring<wchar_t, Extent>;
 // Will fail-fast if sentinel cannot be found before max elements are examined.
 //
 template<typename T, const T Sentinel>
-multi_span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
+span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     auto cur = seq;
     while ((cur - seq) < max && *cur != Sentinel) ++cur;
@@ -111,34 +111,34 @@ multi_span<T, dynamic_range> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIF
 // the limit of size_type.
 //
 template<typename T>
-inline multi_span<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
+inline span<T, dynamic_extent> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     return ensure_sentinel<T, 0>(sz, max);
 }
 
 // TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation
-inline multi_span<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max)
+inline span<char, dynamic_extent> ensure_z(char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline multi_span<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max)
+inline span<const char, dynamic_extent> ensure_z(const char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline multi_span<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
+inline span<wchar_t, dynamic_extent> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
     return{ sz, static_cast<std::ptrdiff_t>(len) };
 }
 
-inline multi_span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
+inline span<const wchar_t, dynamic_extent> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
@@ -146,10 +146,10 @@ inline multi_span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& s
 }
 
 template<typename T, size_t N>
-multi_span<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
+span<T, dynamic_extent> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
 
 template<class Cont>
-multi_span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont)
+span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent> ensure_z(Cont& cont)
 {
     return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length()));
 }
@@ -216,9 +216,7 @@ namespace details
 //
 // string_span and relatives
 //
-// Note that Extent is always single-dimension only
-//
-template <typename CharT, std::ptrdiff_t Extent = dynamic_range>
+template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 class basic_string_span
 {
 public:
@@ -227,8 +225,7 @@ public:
     using pointer = std::add_pointer_t<value_type>;
     using reference = std::add_lvalue_reference_t<value_type>;
     using const_reference = std::add_lvalue_reference_t<const_value_type>;
-    using bounds_type = static_bounds<Extent>;
-    using impl_type = multi_span<value_type, Extent>;
+    using impl_type = span<value_type, Extent>;
 
     using size_type = ptrdiff_t;
     using iterator = typename impl_type::iterator;
@@ -296,52 +293,52 @@ public:
     {}
 
     // from containers. Containers must have .size() and .data() function signatures
-    template <typename Cont, typename DataType = typename Cont::value_type,
-        typename Dummy = std::enable_if_t<!details::is_multi_span<Cont>::value
-        && !details::is_basic_string_span<Cont>::value
-        && !(!std::is_const<value_type>::value && std::is_const<Cont>::value) // no converting const containers to non-const span
-        && std::is_convertible<DataType*, value_type*>::value
-        && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value>
+    template <typename Cont,
+        typename = std::enable_if_t<
+        !details::is_basic_string_span<Cont>::value
+        && !details::is_span<Cont>::value
+        && std::is_convertible<Cont::pointer, pointer>::value
+        && std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>
     >
-    constexpr basic_string_span(Cont& cont)
-        : span_(cont.data(), cont.size())
-    {}
+    constexpr basic_string_span(Cont& cont) : span_(cont.data(), cont.size()) {}
 
     // disallow creation from temporary containers and strings
-    template <typename Cont, typename DataType = typename Cont::value_type,
-        typename Dummy = std::enable_if_t<!details::is_multi_span<Cont>::value
-        && !details::is_basic_string_span<Cont>::value
-        && std::is_convertible<DataType*, value_type*>::value
-        && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value>
-    >
-    basic_string_span(Cont&& cont) = delete;
+    template <typename Cont,
+        typename = std::enable_if_t<
+        !details::is_basic_string_span<Cont>::value
+        && !details::is_span<Cont>::value
+        && std::is_convertible<Cont::pointer, pointer>::value
+        && std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>
+        >
+    constexpr basic_string_span(const Cont& cont) : span_(cont.data(), cont.size()) {}
 
 #ifndef GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE
     // from span
     template <typename OtherValueType, std::ptrdiff_t OtherExtent,
         typename Dummy = std::enable_if_t<
-        std::is_convertible<OtherValueType*, value_type*>::value
-        && std::is_convertible<static_bounds<OtherExtent>, bounds_type>::value>
+        std::is_convertible<span<OtherValueType, OtherExtent>, impl_type>::value
+        >
     >
-    constexpr basic_string_span(multi_span<OtherValueType, OtherExtent> other) noexcept
+    constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept
         : span_(other)
     {}
 #else
     // from span
-    constexpr basic_string_span(multi_span<value_type, Extent> other) noexcept
+    constexpr basic_string_span(span<value_type, Extent> other) noexcept
         : span_(other)
     {}
         
-    template <typename Dummy = std::enable_if_t<!std::is_same<std::remove_const_t<value_type>, value_type>::value>>
-    constexpr basic_string_span(multi_span<std::remove_const_t<value_type>, Extent> other) noexcept
+    template <typename = std::enable_if_t<!std::is_same<std::remove_const_t<value_type>, value_type>::value>>
+    constexpr basic_string_span(span<std::remove_const_t<value_type>, Extent> other) noexcept
         : span_(other)
     {}
 #endif
 
     // from string_span
     template <typename OtherValueType, std::ptrdiff_t OtherExtent,
-        typename OtherBounds = static_bounds<OtherExtent>,
-        typename Dummy = std::enable_if_t<std::is_convertible<OtherValueType*, value_type*>::value && std::is_convertible<OtherBounds, bounds_type>::value>
+        typename = std::enable_if_t<
+            std::is_convertible<basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value
+        >
     >
     constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) noexcept
         : span_(other.data(), other.length())
@@ -359,7 +356,7 @@ public:
         return{ span_.template first<Count>() };
     }
 
-    constexpr basic_string_span<value_type, dynamic_range> first(size_type count) const noexcept
+    constexpr basic_string_span<value_type, dynamic_extent> first(size_type count) const noexcept
     {
         return{ span_.first(count) };
     }
@@ -371,7 +368,7 @@ public:
         return{ span_.template last<Count>() };
     }
 
-    constexpr basic_string_span<value_type, dynamic_range> last(size_type count) const noexcept
+    constexpr basic_string_span<value_type, dynamic_extent> last(size_type count) const noexcept
     {
         return{ span_.last(count) };
     }
@@ -383,7 +380,7 @@ public:
         return{ span_.template subspan<Offset, Count>() };
     }
 
-    constexpr basic_string_span<value_type, dynamic_range> subspan(size_type offset, size_type count = dynamic_range) const noexcept
+    constexpr basic_string_span<value_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const noexcept
     {
         return{ span_.subspan(offset, count) };
     }
@@ -478,16 +475,16 @@ private:
     impl_type span_;
 };
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using string_span = basic_string_span<char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using cstring_span = basic_string_span<const char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using wstring_span = basic_string_span<wchar_t, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_range>
+template<std::ptrdiff_t Extent = dynamic_extent>
 using cwstring_span = basic_string_span<const wchar_t, Extent>;
 
 //
@@ -527,7 +524,7 @@ inline std::wstring to_string(wstring_span<> view)
 
 // zero-terminated string span, used to convert
 // zero-terminated spans to legacy strings
-template<typename CharT, std::ptrdiff_t Extent = dynamic_range>
+template<typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 class basic_zstring_span
 {
 public:
@@ -540,14 +537,14 @@ public:
     using zstring_type = basic_zstring<value_type, Extent>;
     using const_zstring_type = basic_zstring<const_value_type, Extent>;
 
-    using impl_type = multi_span<value_type, Extent>;
+    using impl_type = span<value_type, Extent>;
     using string_span_type = basic_string_span<value_type, Extent>;
 
-    constexpr basic_zstring_span(impl_type multi_span) noexcept
-        : span_(multi_span)
+    constexpr basic_zstring_span(impl_type s) noexcept
+        : span_(s)
     {
         // expects a zero-terminated span
-        Expects(multi_span[multi_span.size() - 1] == '\0');
+        Expects(s[s.size() - 1] == '\0');
     }
 
     // copy
@@ -588,22 +585,22 @@ private:
     impl_type span_;
 };
 
-template <std::ptrdiff_t Max = dynamic_range>
+template <std::ptrdiff_t Max = dynamic_extent>
 using zstring_span = basic_zstring_span<char, Max>;
 
-template <std::ptrdiff_t Max = dynamic_range>
+template <std::ptrdiff_t Max = dynamic_extent>
 using wzstring_span = basic_zstring_span<wchar_t, Max>;
 
-template <std::ptrdiff_t Max = dynamic_range>
+template <std::ptrdiff_t Max = dynamic_extent>
 using czstring_span = basic_zstring_span<const char, Max>;
 
-template <std::ptrdiff_t Max = dynamic_range>
+template <std::ptrdiff_t Max = dynamic_extent>
 using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
 
 } // namespace GSL
 
 // operator ==
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -617,7 +614,7 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 #endif
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -637,10 +634,10 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -651,10 +648,10 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -667,7 +664,7 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 #endif
 
 // operator !=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -676,7 +673,7 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(one == other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -691,10 +688,10 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -704,10 +701,10 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(one == other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -719,7 +716,7 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 #endif
 
 // operator<
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -729,7 +726,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
     return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -745,10 +742,10 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -759,10 +756,10 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
     return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -775,7 +772,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 #endif
 
 // operator <=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -784,7 +781,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(other < one);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -799,10 +796,10 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -812,10 +809,10 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(other < one);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -827,7 +824,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 #endif
 
 // operator>
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -836,7 +833,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
     return other < one;
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -851,10 +848,10 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -864,10 +861,10 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexce
     return other < one;
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -879,7 +876,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 #endif
 
 // operator >=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
 >
@@ -888,7 +885,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(one < other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
     std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
     && !gsl::details::is_basic_string_span<T>::value>
@@ -903,10 +900,10 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
@@ -916,10 +913,10 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
     return !(one < other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_range, typename T,
+template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_multi_span<T>::value
+    !gsl::details::is_span<T>::value
     && !gsl::details::is_basic_string_span<T>::value
     && std::is_convertible<DataType*, CharT*>::value
     && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp
index ff91e50..19456fd 100644
--- a/tests/byte_tests.cpp
+++ b/tests/byte_tests.cpp
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <UnitTest++/UnitTest++.h>
-#include <byte.h>
+#include <gsl_byte.h>
 
 #include <iostream>
 #include <list>
diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp
index 6876253..f380be3 100644
--- a/tests/string_span_tests.cpp
+++ b/tests/string_span_tests.cpp
@@ -142,7 +142,7 @@ SUITE(string_span_tests)
             const char* ptr = "Hello";
             const std::string str = "Hello";
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::multi_span<const char> sp = ensure_z("Hello");
+            gsl::span<const char> sp = ensure_z("Hello");
 
             // comparison to  literal
             CHECK(span == cstring_span<>("Hello"));
@@ -182,7 +182,7 @@ SUITE(string_span_tests)
             char* ptr = ar;
             std::string str = "Hello";
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::multi_span<char> sp = ensure_z(ar1);
+            gsl::span<char> sp = ensure_z(ar1);
 
             // comparison to static array with no null termination
             CHECK(span == string_span<>(ar));
@@ -216,7 +216,7 @@ SUITE(string_span_tests)
             const char ar2[10] = "Hello";
             const std::string str = "Hello";
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::multi_span<const char> sp = ensure_z("Hello");
+            gsl::span<const char> sp = ensure_z("Hello");
 
             cstring_span<> span = "Hello";
 
@@ -253,7 +253,7 @@ SUITE(string_span_tests)
             char* _ptr = _ar;
             std::string _str = "Hello";
             std::vector<char> _vec = { 'H', 'e', 'l', 'l', 'o' };
-            gsl::multi_span<char> _sp{ _ar, 5 };
+            gsl::span<char> _sp{ _ar, 5 };
 
             CHECK(span == _ar);
             CHECK(span == _ar1);
@@ -447,7 +447,7 @@ SUITE(string_span_tests)
 
         // from span of a final extent
         {
-            multi_span<const char, 6> sp = "Hello";
+            span<const char, 6> sp = "Hello";
             cstring_span<> span = sp;
             CHECK(span.length() == 6);
         }
@@ -455,7 +455,7 @@ SUITE(string_span_tests)
         // from const span of a final extent to non-const string_span
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
-            multi_span<const char, 6> sp = "Hello";
+            span<const char, 6> sp = "Hello";
             string_span<> span = sp;
             CHECK(span.length() == 6);
         }
@@ -568,7 +568,7 @@ SUITE(string_span_tests)
         // from const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const multi_span<const char> inner = vec;
+            const span<const char> inner = vec;
             cstring_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -576,7 +576,7 @@ SUITE(string_span_tests)
         // from non-const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            multi_span<char> inner = vec;
+            span<char> inner = vec;
             cstring_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -675,7 +675,7 @@ SUITE(string_span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const multi_span<const char> inner = vec;
+            const span<const char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
 #endif
@@ -684,7 +684,7 @@ SUITE(string_span_tests)
         // from non-const span
         {
             std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            multi_span<char> inner = vec;
+            span<char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
         }
@@ -693,7 +693,7 @@ SUITE(string_span_tests)
         {
 #ifdef CONFIRM_COMPILATION_ERRORS
             const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' };
-            const multi_span<char> inner = vec;
+            const span<char> inner = vec;
             string_span<> span = inner;
             CHECK(span.length() == 5);
 #endif
@@ -746,7 +746,7 @@ SUITE(string_span_tests)
     T create() { return T{}; }
 
     template <class T>
-    void use(basic_string_span<T, gsl::dynamic_range> s) {}
+    void use(basic_string_span<T, gsl::dynamic_extent> s) {}
 
     TEST(MoveConstructors)
     {
@@ -769,12 +769,12 @@ SUITE(string_span_tests)
 
         // move span
         {
-            multi_span<const char> span = ensure_z("Hello");
+            span<const char> span = ensure_z("Hello");
             cstring_span<> span1 = std::move(span);
             CHECK(span1.length() == 5);
         }
         {
-            multi_span<const char> span = ensure_z("Hello");
+            span<const char> span = ensure_z("Hello");
             cstring_span<> span2 = move_wrapper(std::move(span));
             CHECK(span2.length() == 5);
         }

From 8855c59579bb0de5212210662ed8aebff3582d41 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Fri, 15 Jul 2016 17:31:40 -0700
Subject: [PATCH 24/42] Added basic compile support for MSVC 2013 to byte.

---
 include/gsl_byte.h   | 32 ++++++++++++++++++++++++++++++++
 tests/byte_tests.cpp |  1 +
 tests/span_tests.cpp |  9 +++++++++
 3 files changed, 42 insertions(+)

diff --git a/include/gsl_byte.h b/include/gsl_byte.h
index 6e32fef..e2c79c9 100644
--- a/include/gsl_byte.h
+++ b/include/gsl_byte.h
@@ -19,6 +19,23 @@
 #ifndef GSL_BYTE_H
 #define GSL_BYTE_H
 
+#ifdef _MSC_VER
+
+// MSVC 2013 workarounds
+#if _MSC_VER <= 1800
+
+// constexpr is not understood
+#pragma push_macro("constexpr")
+#define constexpr 
+
+// noexcept is not understood 
+#pragma push_macro("noexcept")
+#define noexcept  
+
+#endif // _MSC_VER <= 1800
+
+#endif // _MSC_VER
+
 namespace gsl
 {
     // This is a simple definition for now that allows
@@ -68,4 +85,19 @@ namespace gsl
     
 } // namespace gsl
 
+
+#ifdef _MSC_VER
+
+#if _MSC_VER <= 1800
+
+#undef constexpr
+#pragma pop_macro("constexpr")
+
+#undef noexcept
+#pragma pop_macro("noexcept")
+
+#endif // _MSC_VER <= 1800
+
+#endif // _MSC_VER
+
 #endif // GSL_BYTE_H
\ No newline at end of file
diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp
index 19456fd..5d4e7f6 100644
--- a/tests/byte_tests.cpp
+++ b/tests/byte_tests.cpp
@@ -87,6 +87,7 @@ SUITE(byte_tests)
         CHECK(a == byte(0x0F));
     }
 }
+
 }
 
 int main(int, const char* []) { return UnitTest::RunAllTests(); }
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 5c17552..ae3c32e 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -794,6 +794,15 @@ SUITE(span_tests)
         CHECK(it1 == it2);
     }
 
+    TEST(const_iterator)
+    {
+        span<int>::const_iterator it1;
+        span<int>::const_iterator it2;
+        CHECK(it1 == it2);
+
+        
+    }
+
     TEST(begin_end)
     {
         {

From 30a038ca6a159c259da342e6dec24527d06fef76 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 18 Jul 2016 11:38:01 -0700
Subject: [PATCH 25/42] Added tests for span iterators, fixed implementation.

---
 include/gsl.h        |   6 +-
 include/span.h       |  16 ++++--
 tests/span_tests.cpp | 132 +++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 141 insertions(+), 13 deletions(-)

diff --git a/include/gsl.h b/include/gsl.h
index 4eb555b..f4c9178 100644
--- a/include/gsl.h
+++ b/include/gsl.h
@@ -19,10 +19,10 @@
 #ifndef GSL_GSL_H
 #define GSL_GSL_H
 
-#include "gsl_assert.h"  // Ensures/Expects
-#include "gsl_util.h"    // finally()/narrow()/narrow_cast()...
+#include "gsl_assert.h"     // Ensures/Expects
+#include "gsl_util.h"       // finally()/narrow()/narrow_cast()...
 #include "span.h"           // span
-#include "multi_span.h"           // multi_span, strided_span...
+#include "multi_span.h"     // multi_span, strided_span...
 #include "string_span.h"    // zstring, string_span, zstring_builder...
 #include <memory>
 
diff --git a/include/span.h b/include/span.h
index 053b488..3f3b8fe 100644
--- a/include/span.h
+++ b/include/span.h
@@ -192,7 +192,7 @@ public:
 
     constexpr const_span_iterator& operator--() noexcept
     {
-        Expects(span_ && index > 0 && index_ <= span_->length());
+        Expects(span_ && index_ > 0 && index_ <= span_->length());
         --index_;
         return *this;
     }
@@ -366,7 +366,7 @@ public:
     using reference = element_type&;
 
     using iterator = details::span_iterator<span<ElementType, Extent>>;
-    using const_iterator = details::span_iterator<span>;
+    using const_iterator = details::const_span_iterator<span>;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
@@ -512,13 +512,17 @@ public:
     // [span.iter], span iterator support 
     iterator begin() const noexcept { return {this, 0}; }
     iterator end() const noexcept { return {this, length()}; }
+
+    const_iterator cbegin() const noexcept { return {this, 0}; }
+    const_iterator cend() const noexcept { return {this, length()}; }
  
-    reverse_iterator rbegin() const noexcept { return {this, length()}; }
-    reverse_iterator rend() const noexcept { return {this, 0}; }
+    reverse_iterator rbegin() const noexcept { return reverse_iterator{{this, length()}}; }
+    reverse_iterator rend() const noexcept { return reverse_iterator{{this, 0}}; }
+
+    const_reverse_iterator crbegin() const noexcept { return reverse_iterator{{this, length()}}; }
+    const_reverse_iterator crend() const noexcept { return reverse_iterator{{this, 0}}; }
 
 private:
-    constexpr static const bool is_span_type = true;
-
     template <index_type Extent>
     class extent_type;
     
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index ae3c32e..7652ff9 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -799,8 +799,6 @@ SUITE(span_tests)
         span<int>::const_iterator it1;
         span<int>::const_iterator it2;
         CHECK(it1 == it2);
-
-        
     }
 
     TEST(begin_end)
@@ -809,12 +807,12 @@ SUITE(span_tests)
             int a[] = { 1, 2, 3, 4 };
             span<int> s = a;
 
-            span<int>::iterator it = s.begin();
+            auto it = s.begin();
             auto first = it;
             CHECK(it == first);
             CHECK(*it == 1);
 
-            span<int>::iterator beyond = s.end();
+            auto beyond = s.end();
             CHECK(it != beyond);
             CHECK_THROW(*beyond, fail_fast);
 
@@ -845,6 +843,132 @@ SUITE(span_tests)
         }
     }
 
+    TEST(cbegin_cend)
+    {
+        {
+            int a[] = {1, 2, 3, 4};
+            span<int> s = a;
+
+            auto it = s.cbegin();
+            auto first = it;
+            CHECK(it == first);
+            CHECK(*it == 1);
+
+            auto beyond = s.cend();
+            CHECK(it != beyond);
+            CHECK_THROW(*beyond, fail_fast);
+
+            CHECK(beyond - first == 4);
+            CHECK(first - first == 0);
+            CHECK(beyond - beyond == 0);
+
+            ++it;
+            CHECK(it - first == 1);
+            CHECK(*it == 2);
+            *it = 22;
+            CHECK(*it == 22);
+            CHECK(beyond - it == 3);
+
+            it = first;
+            CHECK(it == first);
+            while (it != s.cend())
+            {
+                *it = 5;
+                ++it;
+            }
+
+            CHECK(it == beyond);
+            CHECK(it - beyond == 0);
+
+            for (auto& n : s)
+                CHECK(n == 5);
+        }
+    }
+
+    TEST(rbegin_rend)
+    {
+        {
+            int a[] = {1, 2, 3, 4};
+            span<int> s = a;
+
+            auto it = s.rbegin();
+            auto first = it;
+            CHECK(it == first);
+            CHECK(*it == 4);
+
+            auto beyond = s.rend();
+            CHECK(it != beyond);
+            CHECK_THROW(*beyond, fail_fast);
+
+            CHECK(beyond - first == 4);
+            CHECK(first - first == 0);
+            CHECK(beyond - beyond == 0);
+
+            ++it;
+            CHECK(it - first == 1);
+            CHECK(*it == 3);
+            *it = 22;
+            CHECK(*it == 22);
+            CHECK(beyond - it == 3);
+
+            it = first;
+            CHECK(it == first);
+            while (it != s.rend())
+            {
+                *it = 5;
+                ++it;
+            }
+
+            CHECK(it == beyond);
+            CHECK(it - beyond == 0);
+
+            for (auto& n : s)
+                CHECK(n == 5);
+        }
+    }
+
+    TEST(crbegin_crend)
+    {
+        {
+            int a[] = {1, 2, 3, 4};
+            span<int> s = a;
+
+            auto it = s.crbegin();
+            auto first = it;
+            CHECK(it == first);
+            CHECK(*it == 4);
+
+            auto beyond = s.crend();
+            CHECK(it != beyond);
+            CHECK_THROW(*beyond, fail_fast);
+
+            CHECK(beyond - first == 4);
+            CHECK(first - first == 0);
+            CHECK(beyond - beyond == 0);
+
+            ++it;
+            CHECK(it - first == 1);
+            CHECK(*it == 3);
+            *it = 22;
+            CHECK(*it == 22);
+            CHECK(beyond - it == 3);
+
+            it = first;
+            CHECK(it == first);
+            while (it != s.crend())
+            {
+                *it = 5;
+                ++it;
+            }
+
+            CHECK(it == beyond);
+            CHECK(it - beyond == 0);
+
+            for (auto& n : s)
+                CHECK(n == 5);
+        }
+    }
+
     TEST(comparison_operators)
     {
         {

From 520c72d777f485775439f4b98b3b7e86c07501e2 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 18 Jul 2016 12:00:33 -0700
Subject: [PATCH 26/42] Tidied up assertion.

---
 include/span.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/span.h b/include/span.h
index 3f3b8fe..6fe3bff 100644
--- a/include/span.h
+++ b/include/span.h
@@ -212,8 +212,8 @@ public:
 
     constexpr const_span_iterator& operator+=(difference_type n) noexcept
     {
+        Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length());
         index_ += n;
-        Expects(span_ && index_ >= 0 && index_ <= span_->length());
         return *this;
     }
 

From 0c1b6717c12477cbf9f744e3b011ae1711256e69 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 20 Jul 2016 08:52:09 -0700
Subject: [PATCH 27/42] Weakened cast in span::iterator.

---
 include/span.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/span.h b/include/span.h
index 6fe3bff..fbed6f7 100644
--- a/include/span.h
+++ b/include/span.h
@@ -286,8 +286,8 @@ public:
     constexpr span_iterator() : base_type() {}
     constexpr span_iterator(const Span* span, typename Span::index_type index) : base_type(span, index) {}
 
-    constexpr reference operator*() const { return reinterpret_cast<reference>(base_type::operator*()); }
-    constexpr pointer operator->() const { return reinterpret_cast<pointer>(base_type::operator->()); }
+    constexpr reference operator*() const { return const_cast<reference>(base_type::operator*()); }
+    constexpr pointer operator->() const { return const_cast<pointer>(base_type::operator->()); }
 
     constexpr span_iterator& operator++() noexcept { base_type::operator++(); return *this; }
 

From 5e7771f879b6496dc10f17f94aace3faf70c6f71 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 20 Jul 2016 09:00:10 -0700
Subject: [PATCH 28/42] Slight tidy-up to precondition checking in span.

---
 include/span.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/span.h b/include/span.h
index fbed6f7..13e57ae 100644
--- a/include/span.h
+++ b/include/span.h
@@ -380,7 +380,7 @@ public:
     {}
 
     constexpr span(pointer ptr, index_type count) : storage_(ptr, count)
-    { Expects((!ptr && count == 0) || (ptr && count >= 0)); }
+    {}
 
     constexpr span(pointer firstElem, pointer lastElem)
         : storage_(firstElem, std::distance(firstElem, lastElem))
@@ -575,7 +575,8 @@ private:
     public:
         template <class OtherExtentType>
         constexpr storage_type(pointer data, OtherExtentType ext)
-            : ExtentType(ext), data_(data) {}
+            : ExtentType(ext), data_(data)
+        { Expects((!data && size() == 0) || (data && size() >= 0)); }
 
         constexpr inline pointer data() const noexcept
         { return data_; }

From f2ab3a5c546385df138063235ad61e1ec1ee7845 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 20 Jul 2016 09:24:49 -0700
Subject: [PATCH 29/42] Tidying up noexcepts.

---
 include/span.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/span.h b/include/span.h
index 13e57ae..96164b6 100644
--- a/include/span.h
+++ b/include/span.h
@@ -392,17 +392,17 @@ public:
     {}
 
     template <size_t N>
-    constexpr span(std::array<element_type, N>& arr)
+    constexpr span(std::array<element_type, N>& arr) noexcept
         : storage_(&arr[0], extent_type<N>())
     {}
 
     template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
-    constexpr span(std::array<std::remove_const_t<element_type>, N>& arr)
+    constexpr span(std::array<std::remove_const_t<element_type>, N>& arr) noexcept
         : storage_(&arr[0], extent_type<N>())
     {}
 
     template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
-    constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr)
+    constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept
         : storage_(&arr[0], extent_type<N>())
     {}
 
@@ -504,7 +504,7 @@ public:
     constexpr reference operator[](index_type idx) const
     {
         Expects(idx >= 0 && idx < storage_.size());
-        return storage_.data()[idx];
+        return data()[idx];
     }
     constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
     constexpr pointer data() const noexcept { return storage_.data(); }

From ca4cdd80deabb7145969dcbca67e44ea00b2bd27 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 20 Jul 2016 12:47:21 -0700
Subject: [PATCH 30/42] 64-bit clean fixes.

---
 tests/span_tests.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 7652ff9..77b799a 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -131,23 +131,23 @@ SUITE(span_tests)
     TEST(from_nullptr_length_constructor)
     {
         {
-            span<int> s{nullptr, 0};
+            span<int> s{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int> cs{nullptr, 0};
+            span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            span<int, 0> s{nullptr, 0};
+            span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int, 0> cs{nullptr, 0};
+            span<const int, 0> cs{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
 
         {
-            auto workaround_macro = []() { span<int, 1> s{ nullptr, 0 }; };
+            auto workaround_macro = []() { span<int, 1> s{ nullptr, static_cast<span<int>::index_type>(0) }; };
             CHECK_THROW(workaround_macro(), fail_fast); 
         }
 
@@ -168,10 +168,10 @@ SUITE(span_tests)
         }
 
         {
-            span<int*> s{nullptr, 0};
+            span<int*> s{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(s.length() == 0 && s.data() == nullptr);
 
-            span<const int*> cs{nullptr, 0};
+            span<const int*> cs{nullptr, static_cast<span<int>::index_type>(0)};
             CHECK(cs.length() == 0 && cs.data() == nullptr);
         }
     }
@@ -194,7 +194,7 @@ SUITE(span_tests)
 
         {
             int* p = nullptr;
-            span<int> s{p, 0};
+            span<int> s{p, static_cast<span<int>::index_type>(0)};
             CHECK(s.length() == 0 && s.data() == nullptr);
         }
 

From b03b04bfcd436789724cb7dce8a40a9ae560c0a8 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 20 Jul 2016 13:17:47 -0700
Subject: [PATCH 31/42] Applied clang-format to the source.

---
 .clang-format         |   2 +-
 include/gsl.h         | 107 +++---
 include/gsl_assert.h  |  68 ++--
 include/gsl_byte.h    | 126 ++++---
 include/gsl_util.h    |  87 +++--
 include/multi_span.h  | 123 +++----
 include/span.h        | 814 +++++++++++++++++++++++-------------------
 include/string_span.h | 530 +++++++++++++--------------
 8 files changed, 964 insertions(+), 893 deletions(-)

diff --git a/.clang-format b/.clang-format
index b80d2c6..78696f5 100644
--- a/.clang-format
+++ b/.clang-format
@@ -16,6 +16,6 @@ AllowShortLoopsOnASingleLine: true
 
 PointerAlignment: Left
 AlignConsecutiveAssignments: false
-AlignTrailingComments: false
+AlignTrailingComments: true
 
 SpaceAfterCStyleCast: true
diff --git a/include/gsl.h b/include/gsl.h
index f4c9178..8e00a44 100644
--- a/include/gsl.h
+++ b/include/gsl.h
@@ -1,17 +1,17 @@
-/////////////////////////////////////////////////////////////////////////////// 
-// 
-// 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. 
-// 
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #pragma once
@@ -19,39 +19,38 @@
 #ifndef GSL_GSL_H
 #define GSL_GSL_H
 
-#include "gsl_assert.h"     // Ensures/Expects
-#include "gsl_util.h"       // finally()/narrow()/narrow_cast()...
-#include "span.h"           // span
-#include "multi_span.h"     // multi_span, strided_span...
-#include "string_span.h"    // zstring, string_span, zstring_builder...
+#include "gsl_assert.h"  // Ensures/Expects
+#include "gsl_util.h"    // finally()/narrow()/narrow_cast()...
+#include "multi_span.h"  // multi_span, strided_span...
+#include "span.h"        // span
+#include "string_span.h" // zstring, string_span, zstring_builder...
 #include <memory>
 
 #ifdef _MSC_VER
 
 // No MSVC does constexpr fully yet
 #pragma push_macro("constexpr")
-#define constexpr 
+#define constexpr
 
 // MSVC 2013 workarounds
 #if _MSC_VER <= 1800
-// noexcept is not understood 
+// noexcept is not understood
 #pragma push_macro("noexcept")
-#define noexcept  
+#define noexcept
 
 // turn off some misguided warnings
 #pragma warning(push)
-#pragma warning(disable: 4351) // warns about newly introduced aggregate initializer behavior
+#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior
 
 #endif // _MSC_VER <= 1800
 
 #endif // _MSC_VER
 
-
 namespace gsl
 {
 
 //
-// GSL.owner: ownership pointers 
+// GSL.owner: ownership pointers
 //
 using std::unique_ptr;
 using std::shared_ptr;
@@ -59,67 +58,74 @@ using std::shared_ptr;
 template <class T>
 using owner = T;
 
-
 //
 // not_null
 //
 // Restricts a pointer or smart pointer to only hold non-null values.
-// 
+//
 // Has zero size overhead over T.
 //
-// If T is a pointer (i.e. T == U*) then 
-// - allow construction from U* or U& 
+// If T is a pointer (i.e. T == U*) then
+// - allow construction from U* or U&
 // - disallow construction from nullptr_t
 // - disallow default construction
 // - ensure construction from U* fails with nullptr
 // - allow implicit conversion to U*
 //
-template<class T>
+template <class T>
 class not_null
 {
     static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");
+
 public:
     not_null(T t) : ptr_(t) { ensure_invariant(); }
-    not_null& operator=(const T& t) { ptr_ = t; ensure_invariant(); return *this; }
+    not_null& operator=(const T& t)
+    {
+        ptr_ = t;
+        ensure_invariant();
+        return *this;
+    }
 
-    not_null(const not_null &other) = default;
-    not_null& operator=(const not_null &other) = default;
+    not_null(const not_null& other) = default;
+    not_null& operator=(const not_null& other) = default;
 
     template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>>
-    not_null(const not_null<U> &other)
+    not_null(const not_null<U>& other)
     {
         *this = other;
     }
 
     template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>>
-    not_null& operator=(const not_null<U> &other)
+    not_null& operator=(const not_null<U>& other)
     {
         ptr_ = other.get();
         return *this;
     }
 
-    // prevents compilation when someone attempts to assign a nullptr 
+    // prevents compilation when someone attempts to assign a nullptr
     not_null(std::nullptr_t) = delete;
     not_null(int) = delete;
     not_null<T>& operator=(std::nullptr_t) = delete;
-	not_null<T>& operator=(int) = delete;
-    
-    T get() const {
+    not_null<T>& operator=(int) = delete;
+
+    T get() const
+    {
 #ifdef _MSC_VER
         __assume(ptr_ != nullptr);
 #endif
         return ptr_;
     } // the assume() should help the optimizer
 
-    operator T() const {  return get(); }
+    operator T() const { return get(); }
     T operator->() const { return get(); }
 
-	bool operator==(const T& rhs) const { return ptr_ == rhs; }
-	bool operator!=(const T& rhs) const { return !(*this == rhs); }
+    bool operator==(const T& rhs) const { return ptr_ == rhs; }
+    bool operator!=(const T& rhs) const { return !(*this == rhs); }
 private:
     T ptr_;
 
-    // we assume that the compiler can hoist/prove away most of the checks inlined from this function
+    // we assume that the compiler can hoist/prove away most of the checks inlined from this
+    // function
     // if not, we could make them optional via conditional compilation
     void ensure_invariant() const { Expects(ptr_ != nullptr); }
 
@@ -139,14 +145,11 @@ private:
 
 namespace std
 {
-    template<class T>
-    struct hash<gsl::not_null<T>>
-    {
-        size_t operator()(const gsl::not_null<T> & value) const
-        {
-            return hash<T>{}(value);
-        }
-    };
+template <class T>
+struct hash<gsl::not_null<T>>
+{
+    size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); }
+};
 
 } // namespace std
 
@@ -159,7 +162,7 @@ namespace std
 
 #undef noexcept
 #pragma pop_macro("noexcept")
- 
+
 #pragma warning(pop)
 
 #endif // _MSC_VER <= 1800
diff --git a/include/gsl_assert.h b/include/gsl_assert.h
index 51e8ab6..10de31a 100644
--- a/include/gsl_assert.h
+++ b/include/gsl_assert.h
@@ -1,17 +1,17 @@
-/////////////////////////////////////////////////////////////////////////////// 
-// 
-// 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. 
-// 
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #pragma once
@@ -28,50 +28,50 @@
 //
 // 1. GSL_TERMINATE_ON_CONTRACT_VIOLATION: std::terminate will be called (default)
 // 2. GSL_THROW_ON_CONTRACT_VIOLATION: a gsl::fail_fast exception will be thrown
-// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens  
+// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens
 //
-#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) ^ defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ^ defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION))
-#define GSL_TERMINATE_ON_CONTRACT_VIOLATION 
+#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) ^ defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ^    \
+      defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION))
+#define GSL_TERMINATE_ON_CONTRACT_VIOLATION
 #endif
 
-
 #define GSL_STRINGIFY_DETAIL(x) #x
 #define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
 
-
 //
 // GSL.assert: assertions
 //
 
 namespace gsl
 {
-struct fail_fast : public std::runtime_error 
+struct fail_fast : public std::runtime_error
 {
-	explicit fail_fast(char const* const message) : std::runtime_error(message) {}   
+    explicit fail_fast(char const* const message) : std::runtime_error(message) {}
 };
 }
 
 #if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
 
-#define Expects(cond)  if (!(cond)) \
-    throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__));
-#define Ensures(cond)  if (!(cond)) \
-    throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__));
-
+#define Expects(cond)                                                                              \
+    if (!(cond))                                                                                   \
+        throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__));
+#define Ensures(cond)                                                                              \
+    if (!(cond))                                                                                   \
+        throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__                             \
+                             ": " GSL_STRINGIFY(__LINE__));
 
 #elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
 
-
-#define Expects(cond)           if (!(cond)) std::terminate(); 
-#define Ensures(cond)           if (!(cond)) std::terminate();
-
+#define Expects(cond)                                                                              \
+    if (!(cond)) std::terminate();
+#define Ensures(cond)                                                                              \
+    if (!(cond)) std::terminate();
 
 #elif defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)
 
-#define Expects(cond)           
-#define Ensures(cond)           
-
-#endif 
+#define Expects(cond)
+#define Ensures(cond)
 
+#endif
 
 #endif // GSL_CONTRACTS_H
diff --git a/include/gsl_byte.h b/include/gsl_byte.h
index e2c79c9..5a9c327 100644
--- a/include/gsl_byte.h
+++ b/include/gsl_byte.h
@@ -1,17 +1,17 @@
-/////////////////////////////////////////////////////////////////////////////// 
-// 
-// 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. 
-// 
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #pragma once
@@ -26,11 +26,11 @@
 
 // constexpr is not understood
 #pragma push_macro("constexpr")
-#define constexpr 
+#define constexpr
 
-// noexcept is not understood 
+// noexcept is not understood
 #pragma push_macro("noexcept")
-#define noexcept  
+#define noexcept
 
 #endif // _MSC_VER <= 1800
 
@@ -38,54 +38,76 @@
 
 namespace gsl
 {
-    // This is a simple definition for now that allows
-    // use of byte within span<> to be standards-compliant
-    enum class byte : unsigned char {};
+// This is a simple definition for now that allows
+// use of byte within span<> to be standards-compliant
+enum class byte : unsigned char
+{
+};
 
-    template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-    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>>
+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>>
-    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>>
+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>>
-    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>>
+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>>
-    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>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) >> shift);
+}
 
-    constexpr byte& operator|=(byte& l, byte r) noexcept
-    { return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); }
+constexpr byte& operator|=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
 
-    constexpr byte operator|(byte l, byte r) noexcept
-    { return byte(static_cast<unsigned char>(l) + static_cast<unsigned char>(r)); }
+constexpr byte operator|(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) + static_cast<unsigned char>(r));
+}
 
-    constexpr byte& operator&=(byte& l, byte r) noexcept
-    { return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); }
+constexpr byte& operator&=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
 
-    constexpr byte operator&(byte l, byte r) noexcept
-    { return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); }
+constexpr byte operator&(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
 
-    constexpr byte& operator^=(byte& l, byte r) noexcept
-    { return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); }
-    
-    constexpr byte operator^(byte l, byte r) noexcept
-    { return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); }
-    
-    constexpr byte operator~(byte b) noexcept
-    { return byte(~static_cast<unsigned char>(b)); }
+constexpr byte& operator^=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
 
-    template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-    constexpr IntegerType to_integer(byte b) noexcept { return {b}; }
+constexpr byte operator^(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+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>>
+constexpr IntegerType to_integer(byte b) noexcept
+{
+    return {b};
+}
 
-    
 } // namespace gsl
 
-
 #ifdef _MSC_VER
 
 #if _MSC_VER <= 1800
diff --git a/include/gsl_util.h b/include/gsl_util.h
index d82937f..a3d5fbe 100644
--- a/include/gsl_util.h
+++ b/include/gsl_util.h
@@ -19,11 +19,11 @@
 #ifndef GSL_UTIL_H
 #define GSL_UTIL_H
 
-#include "gsl_assert.h"  // Ensures/Expects
+#include "gsl_assert.h" // Ensures/Expects
 #include <array>
-#include <utility>
-#include <type_traits>
 #include <exception>
+#include <type_traits>
+#include <utility>
 
 #ifdef _MSC_VER
 
@@ -32,7 +32,7 @@
 #define constexpr
 
 #pragma warning(push)
-#pragma warning(disable: 4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 
 // MSVC 2013 workarounds
 #if _MSC_VER <= 1800
@@ -42,13 +42,12 @@
 
 // turn off some misguided warnings
 #pragma warning(push)
-#pragma warning(disable: 4351) // warns about newly introduced aggregate initializer behavior
+#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior
 
 #endif // _MSC_VER <= 1800
 
 #endif // _MSC_VER
 
-
 namespace gsl
 {
 //
@@ -60,18 +59,20 @@ template <class F>
 class final_act
 {
 public:
-    explicit final_act(F f) noexcept
-    : f_(std::move(f)), invoke_(true)
-    {}
+    explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {}
 
-    final_act(final_act&& other) noexcept
-    : f_(std::move(other.f_)), invoke_(other.invoke_)
-    { other.invoke_ = false; }
+    final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
+    {
+        other.invoke_ = false;
+    }
 
     final_act(const final_act&) = delete;
     final_act& operator=(const final_act&) = delete;
 
-    ~final_act() noexcept { if (invoke_) f_(); }
+    ~final_act() noexcept
+    {
+        if (invoke_) f_();
+    }
 
 private:
     F f_;
@@ -80,35 +81,44 @@ private:
 
 // finally() - convenience function to generate a final_act
 template <class F>
-inline final_act<F> finally(const F &f)
-noexcept { return final_act<F>(f); }
+inline final_act<F> finally(const F& f) noexcept
+{
+    return final_act<F>(f);
+}
 
 template <class F>
-inline final_act<F> finally(F &&f) noexcept
-{ return final_act<F>(std::forward<F>(f)); }
+inline final_act<F> finally(F&& f) noexcept
+{
+    return final_act<F>(std::forward<F>(f));
+}
 
 // narrow_cast(): a searchable way to do narrowing casts of values
-template<class T, class U>
+template <class T, class U>
 inline constexpr T narrow_cast(U u) noexcept
-{ return static_cast<T>(u); }
+{
+    return static_cast<T>(u);
+}
 
-struct narrowing_error : public std::exception {};
+struct narrowing_error : public std::exception
+{
+};
 
 namespace details
 {
-    template<class T, class U>
-    struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
-    {};
+    template <class T, class U>
+    struct is_same_signedness
+        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
+    {
+    };
 }
 
 // narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-template<class T, class U>
+template <class T, class U>
 inline T narrow(U u)
 {
     T t = narrow_cast<T>(u);
-    if (static_cast<U>(t) != u)
-        throw narrowing_error();
-#pragma warning(suppress:4127) // suppress warning from MSVC compiler about constant in if-test
+    if (static_cast<U>(t) != u) throw narrowing_error();
+#pragma warning(suppress : 4127) // suppress warning from MSVC compiler about constant in if-test
     if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
         throw narrowing_error();
     return t;
@@ -118,24 +128,35 @@ inline T narrow(U u)
 // at() - Bounds-checked way of accessing static arrays, std::array, std::vector
 //
 template <class T, size_t N>
-constexpr T& at(T(&arr)[N], size_t index)
-{ Expects(index < N); return arr[index]; }
+constexpr T& at(T (&arr)[N], size_t index)
+{
+    Expects(index < N);
+    return arr[index];
+}
 
 template <class T, size_t N>
 constexpr T& at(std::array<T, N>& arr, size_t index)
-{ Expects(index < N); return arr[index]; }
+{
+    Expects(index < N);
+    return arr[index];
+}
 
 template <class Cont>
 constexpr typename Cont::value_type& at(Cont& cont, size_t index)
-{ Expects(index < cont.size()); return cont[index]; }
+{
+    Expects(index < cont.size());
+    return cont[index];
+}
 
 template <class T>
 constexpr const T& at(std::initializer_list<T> cont, size_t index)
-{ Expects(index < cont.size()); return *(cont.begin() + index); }
+{
+    Expects(index < cont.size());
+    return *(cont.begin() + index);
+}
 
 } // namespace gsl
 
-
 #ifdef _MSC_VER
 
 #pragma warning(pop)
diff --git a/include/multi_span.h b/include/multi_span.h
index c4a0eac..a63f8ce 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -20,8 +20,8 @@
 #define GSL_MULTI_SPAN_H
 
 #include "gsl_assert.h"
-#include "gsl_util.h"
 #include "gsl_byte.h"
+#include "gsl_util.h"
 #include <algorithm>
 #include <array>
 #include <cassert>
@@ -52,7 +52,7 @@
 #define GSL_MSVC_HAS_VARIADIC_CTOR_BUG
 #define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
 
-// noexcept is not understood 
+// noexcept is not understood
 #ifndef GSL_THROW_ON_CONTRACT_VIOLATION
 #pragma push_macro("noexcept")
 #define noexcept /* nothing */
@@ -217,10 +217,7 @@ public:
         return ret;
     }
 
-    friend constexpr index operator*(value_type v, const index& rhs) noexcept
-    {
-        return rhs * v;
-    }
+    friend constexpr index operator*(value_type v, const index& rhs) noexcept { return rhs * v; }
 
     constexpr index& operator*=(value_type v) noexcept
     {
@@ -743,8 +740,7 @@ public:
     }
 
     constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept
-        : m_extents(extents),
-          m_strides(strides)
+        : m_extents(extents), m_strides(strides)
     {
     }
 
@@ -841,8 +837,7 @@ public:
     using index_size_type = typename IndexType::value_type;
     template <typename Bounds>
     explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept
-        : boundary_(bnd.index_bounds()),
-          curr_(std::move(curr))
+        : boundary_(bnd.index_bounds()), curr_(std::move(curr))
     {
         static_assert(is_bounds<Bounds>::value, "Bounds type must be provided");
     }
@@ -930,7 +925,7 @@ public:
         return ret -= n;
     }
 
-    constexpr bounds_iterator& operator-=(difference_type n) noexcept { return * this += -n; }
+    constexpr bounds_iterator& operator-=(difference_type n) noexcept { return *this += -n; }
 
     constexpr difference_type operator-(const bounds_iterator& rhs) const noexcept
     {
@@ -1137,7 +1132,7 @@ namespace details
     template <typename T, typename Arg, typename... Args>
     std::enable_if_t<
         !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
-        static_as_span_helper(Arg, Args... args)
+    static_as_span_helper(Arg, Args... args)
     {
         return static_as_span_helper<T>(args...);
     }
@@ -1159,7 +1154,8 @@ namespace details
     };
 
     template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
+    struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
+        : std::true_type
     {
     };
 
@@ -1249,11 +1245,13 @@ public:
     constexpr multi_span(value_type&&) = delete;
 
     // construct from pointer + length
-    constexpr multi_span(pointer ptr, size_type size) noexcept : multi_span(ptr, bounds_type{size}) {}
+    constexpr multi_span(pointer ptr, size_type size) noexcept : multi_span(ptr, bounds_type{size})
+    {
+    }
 
     // construct from pointer + length - multidimensional
-    constexpr multi_span(pointer data, bounds_type bounds) noexcept : data_(data),
-                                                                bounds_(std::move(bounds))
+    constexpr multi_span(pointer data, bounds_type bounds) noexcept
+        : data_(data), bounds_(std::move(bounds))
     {
         Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
     }
@@ -1263,7 +1261,8 @@ public:
               typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value &&
                                           details::LessThan<bounds_type::dynamic_rank, 2>::value>>
     constexpr multi_span(pointer begin, Ptr end)
-        : multi_span(begin, details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
+        : multi_span(begin,
+                     details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
     {
         Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end));
     }
@@ -1273,9 +1272,8 @@ public:
     constexpr multi_span(T (&arr)[N])
         : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
     {
-        static_assert(
-            std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value,
-            "Cannot convert from source type to target multi_span type.");
+        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
+                      "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value,
                       "Cannot construct a multi_span from an array with fewer elements.");
     }
@@ -1286,17 +1284,17 @@ public:
     constexpr multi_span(T* const& data, size_type size)
         : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size})
     {
-        static_assert(
-            std::is_convertible<typename Helper::value_type(*) [], value_type(*) []>::value,
-            "Cannot convert from source type to target multi_span type.");
+        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
+                      "Cannot convert from source type to target multi_span type.");
     }
 
     // construct from std::array
     template <typename T, size_t N>
-    constexpr multi_span(std::array<T, N>& arr) : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
+    constexpr multi_span(std::array<T, N>& arr)
+        : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
     {
         static_assert(
-            std::is_convertible<T(*) [], typename std::remove_const_t<value_type>(*) []>::value,
+            std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value,
             "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
                       "You cannot construct a multi_span from a std::array of smaller size.");
@@ -1307,7 +1305,7 @@ public:
     constexpr multi_span(const std::array<std::remove_const_t<value_type>, N>& arr)
         : multi_span(arr.data(), static_bounds<N>())
     {
-        static_assert(std::is_convertible<T(*) [], std::remove_const_t<value_type>>::value,
+        static_assert(std::is_convertible<T(*)[], std::remove_const_t<value_type>>::value,
                       "Cannot convert from source type to target multi_span type.");
         static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
                       "You cannot construct a multi_span from a std::array of smaller size.");
@@ -1329,7 +1327,7 @@ public:
                                DataType>::value>>
     constexpr multi_span(Cont& cont)
         : multi_span(static_cast<pointer>(cont.data()),
-               details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
+                     details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
     {
     }
 
@@ -1348,8 +1346,8 @@ public:
               typename OtherBounds = static_bounds<OtherDimensions...>,
               typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value &&
                                           std::is_convertible<OtherBounds, bounds_type>::value>>
-    constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept : data_(other.data_),
-                                                                              bounds_(other.bounds_)
+    constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept
+        : data_(other.data_), bounds_(other.bounds_)
     {
     }
 
@@ -1424,7 +1422,8 @@ public:
     // subspan() - create a subview of count elements starting at offset
     // supplying dynamic_range for count will consume all available elements from offset
     constexpr multi_span<ValueType, dynamic_range> subspan(size_type offset,
-                                                     size_type count = dynamic_range) const noexcept
+                                                           size_type count = dynamic_range) const
+        noexcept
     {
         Expects((offset >= 0 && offset <= this->size()) &&
                 (count == dynamic_range || (count <= this->size() - offset)));
@@ -1535,7 +1534,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return bounds_.size() == other.bounds_.size() &&
                (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
@@ -1544,7 +1544,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return !(*this == other);
     }
@@ -1552,7 +1553,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
     }
@@ -1560,7 +1562,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return !(other < *this);
     }
@@ -1568,7 +1571,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return (other < *this);
     }
@@ -1576,7 +1580,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename Dummy = std::enable_if_t<std::is_same<
                   std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const noexcept
+    constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const
+        noexcept
     {
         return !(*this < other);
     }
@@ -1590,8 +1595,8 @@ public:
 // DimCount and Enabled here are workarounds for a bug in MSVC 2015
 template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2),
           bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
-constexpr multi_span<typename SpanType::value_type, Dimensions2::value...> as_span(SpanType s,
-                                                                             Dimensions2... dims)
+constexpr multi_span<typename SpanType::value_type, Dimensions2::value...>
+as_span(SpanType s, Dimensions2... dims)
 {
     static_assert(details::is_multi_span<SpanType>::value,
                   "Variadic as_span() is for reshaping existing spans.");
@@ -1628,13 +1633,13 @@ multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept
-    -> multi_span<const U, static_cast<std::ptrdiff_t>(
-                         multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
-                             ? (static_cast<size_t>(
-                                    multi_span<const byte, Dimensions...>::bounds_type::static_size) /
-                                sizeof(U))
-                             : dynamic_range)>
+constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span<
+    const U, static_cast<std::ptrdiff_t>(
+                 multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
+                     ? (static_cast<size_t>(
+                            multi_span<const byte, Dimensions...>::bounds_type::static_size) /
+                        sizeof(U))
+                     : dynamic_range)>
 {
     using ConstByteSpan = multi_span<const byte, Dimensions...>;
     static_assert(
@@ -1653,12 +1658,13 @@ constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept -> multi_span<
-    U, narrow_cast<std::ptrdiff_t>(
-           multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
-               ? static_cast<std::size_t>(multi_span<byte, Dimensions...>::bounds_type::static_size) /
-                     sizeof(U)
-               : dynamic_range)>
+constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept
+    -> multi_span<U, narrow_cast<std::ptrdiff_t>(
+                         multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
+                             ? static_cast<std::size_t>(
+                                   multi_span<byte, Dimensions...>::bounds_type::static_size) /
+                                   sizeof(U)
+                             : dynamic_range)>
 {
     using ByteSpan = multi_span<byte, Dimensions...>;
     static_assert(
@@ -1816,9 +1822,9 @@ public:
         auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type));
 
         size_type size = this->bounds().total_size() / d;
-        return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())), size,
-                bounds_type{resize_extent(this->bounds().index_bounds(), d),
-                            resize_stride(this->bounds().strides(), d)}};
+        return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())),
+                size, bounds_type{resize_extent(this->bounds().index_bounds(), d),
+                                  resize_stride(this->bounds().strides(), d)}};
     }
 
     constexpr strided_span section(index_type origin, index_type extents) const
@@ -2049,7 +2055,7 @@ public:
         contiguous_span_iterator ret{*this};
         return ret -= n;
     }
-    contiguous_span_iterator& operator-=(difference_type n) noexcept { return * this += -n; }
+    contiguous_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; }
     difference_type operator-(const contiguous_span_iterator& rhs) const noexcept
     {
         Expects(m_validator == rhs.m_validator);
@@ -2148,16 +2154,13 @@ public:
         general_span_iterator ret{*this};
         return ret -= n;
     }
-    general_span_iterator& operator-=(difference_type n) noexcept { return * this += -n; }
+    general_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; }
     difference_type operator-(const general_span_iterator& rhs) const noexcept
     {
         Expects(m_container == rhs.m_container);
         return m_itr - rhs.m_itr;
     }
-    value_type operator[](difference_type n) const noexcept
-    {
-        return (*m_container)[m_itr[n]];
-    }
+    value_type operator[](difference_type n) const noexcept { return (*m_container)[m_itr[n]]; }
 
     bool operator==(const general_span_iterator& rhs) const noexcept
     {
diff --git a/include/span.h b/include/span.h
index 0bffb4b..f40a7ab 100644
--- a/include/span.h
+++ b/include/span.h
@@ -20,11 +20,11 @@
 #define GSL_SPAN_H
 
 #include "gsl_assert.h"
-#include "gsl_util.h"
 #include "gsl_byte.h"
+#include "gsl_util.h"
 #include <array>
-#include <limits>
 #include <iterator>
+#include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -39,7 +39,7 @@
 // blanket turn off warnings from CppCoreCheck for now
 // so people aren't annoyed by them when running the tool.
 // more targeted suppressions will be added in a future update to the GSL
-#pragma warning(disable: 26481 26482 26483 26485 26490 26491 26492 26493 26495)
+#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
 
 // No MSVC does constexpr fully yet
 #pragma push_macro("constexpr")
@@ -51,7 +51,7 @@
 #define GSL_MSVC_HAS_VARIADIC_CTOR_BUG
 #define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
 
-// noexcept is not understood 
+// noexcept is not understood
 #ifndef GSL_THROW_ON_CONTRACT_VIOLATION
 #pragma push_macro("noexcept")
 #define noexcept /* nothing */
@@ -82,290 +82,340 @@ namespace gsl
 template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
 class span;
 
-
-// [views.constants], constants  
+// [views.constants], constants
 constexpr const std::ptrdiff_t dynamic_extent = -1;
 
-
 // implementation details
 namespace details
 {
-template <class T>
-struct is_span_oracle : std::false_type
-{
-};
-
-template <class ElementType, std::ptrdiff_t Extent>
-struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
-{
-};
-
-template <class T>
-struct is_span : is_span_oracle<std::remove_cv_t<T>>
-{
-};
-
-template <class From, class To>
-struct is_allowed_pointer_conversion
-    : std::bool_constant<
-    std::is_pointer<From>::value &&
-    std::is_pointer<To>::value &&
-    std::is_convertible<From, To>::value
-    >
-{
-};
-
-template <class From, class To>
-struct is_allowed_integral_conversion
-    : std::bool_constant<
-    std::is_integral<From>::value &&
-    std::is_integral<To>::value &&
-    sizeof(From) == sizeof(To) &&
-    alignof(From) == alignof(To) &&
-    std::is_convertible<From, To>::value
-    >
-{
-};
-
-template <std::ptrdiff_t From, std::ptrdiff_t To>
-struct is_allowed_extent_conversion
-    : std::bool_constant<
-    From == To ||
-    From == gsl::dynamic_extent ||
-    To == gsl::dynamic_extent
-    >
-{
-};
-
-template <class From, class To>
-struct is_allowed_element_type_conversion
-    : std::bool_constant<
-    std::is_same<From, std::remove_cv_t<To>>::value ||
-    is_allowed_pointer_conversion<From, To>::value ||
-    is_allowed_integral_conversion<From, To>::value
-    >
-{
-};
-
-template <class From>
-struct is_allowed_element_type_conversion<From, byte>
-    : std::bool_constant<!std::is_const<From>::value>
-{
-};
-
-template <class From>
-struct is_allowed_element_type_conversion<From, const byte>
-    : std::true_type
-{
-};
-
-template <class Span>
-class const_span_iterator
-{
-public:
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = typename Span::element_type;
-    using difference_type = std::ptrdiff_t;
-
-    using const_pointer = std::add_const_t<value_type*>;
-    using pointer = const_pointer;
-
-    using const_reference = std::add_const_t<value_type&>;
-    using reference = const_reference;
-
-    constexpr const_span_iterator() : const_span_iterator(nullptr, 0) {}
-    constexpr const_span_iterator(const Span* span, typename Span::index_type index) : span_(span), index_(index)
+    template <class T>
+    struct is_span_oracle : std::false_type
     {
-        Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
+    };
+
+    template <class ElementType, std::ptrdiff_t Extent>
+    struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_span : is_span_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <class From, class To>
+    struct is_allowed_pointer_conversion
+        : std::bool_constant<std::is_pointer<From>::value && std::is_pointer<To>::value &&
+                             std::is_convertible<From, To>::value>
+    {
+    };
+
+    template <class From, class To>
+    struct is_allowed_integral_conversion
+        : std::bool_constant<std::is_integral<From>::value && std::is_integral<To>::value &&
+                             sizeof(From) == sizeof(To) && alignof(From) == alignof(To) &&
+                             std::is_convertible<From, To>::value>
+    {
+    };
+
+    template <std::ptrdiff_t From, std::ptrdiff_t To>
+    struct is_allowed_extent_conversion
+        : std::bool_constant<From == To || From == gsl::dynamic_extent || To == gsl::dynamic_extent>
+    {
+    };
+
+    template <class From, class To>
+    struct is_allowed_element_type_conversion
+        : std::bool_constant<std::is_same<From, std::remove_cv_t<To>>::value ||
+                             is_allowed_pointer_conversion<From, To>::value ||
+                             is_allowed_integral_conversion<From, To>::value>
+    {
+    };
+
+    template <class From>
+    struct is_allowed_element_type_conversion<From, byte>
+        : std::bool_constant<!std::is_const<From>::value>
+    {
+    };
+
+    template <class From>
+    struct is_allowed_element_type_conversion<From, const byte> : std::true_type
+    {
+    };
+
+    template <class Span>
+    class const_span_iterator
+    {
+    public:
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = typename Span::element_type;
+        using difference_type = std::ptrdiff_t;
+
+        using const_pointer = std::add_const_t<value_type*>;
+        using pointer = const_pointer;
+
+        using const_reference = std::add_const_t<value_type&>;
+        using reference = const_reference;
+
+        constexpr const_span_iterator() : const_span_iterator(nullptr, 0) {}
+        constexpr const_span_iterator(const Span* span, typename Span::index_type index)
+            : span_(span), index_(index)
+        {
+            Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
+        }
+
+        constexpr reference operator*() const
+        {
+            Expects(span_);
+            return (*span_)[index_];
+        }
+        constexpr pointer operator->() const
+        {
+            Expects(span_);
+            return &((*span_)[index_]);
+        }
+
+        constexpr const_span_iterator& operator++() noexcept
+        {
+            Expects(span_ && index_ >= 0 && index_ < span_->length());
+            ++index_;
+            return *this;
+        }
+
+        constexpr const_span_iterator operator++(int) noexcept
+        {
+            auto ret = *this;
+            ++(*this);
+            return ret;
+        }
+
+        constexpr const_span_iterator& operator--() noexcept
+        {
+            Expects(span_ && index_ > 0 && index_ <= span_->length());
+            --index_;
+            return *this;
+        }
+
+        constexpr const_span_iterator operator--(int) noexcept
+        {
+            auto ret = *this;
+            --(*this);
+            return ret;
+        }
+
+        constexpr const_span_iterator operator+(difference_type n) const noexcept
+        {
+            auto ret{*this};
+            return ret += n;
+        }
+
+        constexpr const_span_iterator& operator+=(difference_type n) noexcept
+        {
+            Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length());
+            index_ += n;
+            return *this;
+        }
+
+        constexpr const_span_iterator operator-(difference_type n) const noexcept
+        {
+            auto ret{*this};
+            return ret -= n;
+        }
+
+        constexpr const_span_iterator& operator-=(difference_type n) noexcept
+        {
+            return *this += -n;
+        }
+
+        constexpr difference_type operator-(const const_span_iterator& rhs) const noexcept
+        {
+            Expects(span_ == rhs.span_);
+            return index_ - rhs.index_;
+        }
+
+        constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); }
+
+        constexpr bool operator==(const const_span_iterator& rhs) const noexcept
+        {
+            return span_ == rhs.span_ && index_ == rhs.index_;
+        }
+
+        constexpr bool operator!=(const const_span_iterator& rhs) const noexcept
+        {
+            return !(*this == rhs);
+        }
+
+        constexpr bool operator<(const const_span_iterator& rhs) const noexcept
+        {
+            Expects(span_ == rhs.span_);
+            return index_ < rhs.index_;
+        }
+
+        constexpr bool operator<=(const const_span_iterator& rhs) const noexcept
+        {
+            return !(rhs < *this);
+        }
+
+        constexpr bool operator>(const const_span_iterator& rhs) const noexcept
+        {
+            return rhs < *this;
+        }
+
+        constexpr bool operator>=(const const_span_iterator& rhs) const noexcept
+        {
+            return !(rhs > *this);
+        }
+
+        void swap(const_span_iterator& rhs) noexcept
+        {
+            std::swap(index_, rhs.index_);
+            std::swap(m_span, rhs.m_span);
+        }
+
+    private:
+        const Span* span_;
+        ptrdiff_t index_;
+    };
+
+    template <class Span>
+    class span_iterator : public const_span_iterator<Span>
+    {
+        using base_type = const_span_iterator<Span>;
+
+    public:
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = typename Span::element_type;
+        using difference_type = std::ptrdiff_t;
+
+        using pointer = value_type*;
+        using reference = value_type&;
+
+        constexpr span_iterator() : base_type() {}
+        constexpr span_iterator(const Span* span, typename Span::index_type index)
+            : base_type(span, index)
+        {
+        }
+
+        constexpr reference operator*() const
+        {
+            return const_cast<reference>(base_type::operator*());
+        }
+        constexpr pointer operator->() const
+        {
+            return const_cast<pointer>(base_type::operator->());
+        }
+
+        constexpr span_iterator& operator++() noexcept
+        {
+            base_type::operator++();
+            return *this;
+        }
+
+        constexpr span_iterator operator++(int) noexcept { return base_type::operator++(1); }
+
+        constexpr span_iterator& operator--() noexcept
+        {
+            base_type::operator--();
+            return *this;
+        }
+
+        constexpr span_iterator operator--(int) noexcept { return base_type::operator--(1); }
+
+        constexpr span_iterator operator+(difference_type n) const noexcept
+        {
+            return base_type::operator+(n);
+        }
+
+        constexpr span_iterator& operator+=(difference_type n) noexcept
+        {
+            return base_type::operator+=(n);
+        }
+
+        constexpr span_iterator operator-(difference_type n) const noexcept
+        {
+            return base_type::operator-(n);
+        }
+
+        constexpr span_iterator& operator-=(difference_type n) noexcept
+        {
+            return base_type::operator-=(n);
+        }
+
+        constexpr difference_type operator-(const span_iterator& rhs) const noexcept
+        {
+            return base_type::operator-(rhs);
+        }
+
+        constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); }
+
+        constexpr bool operator==(const span_iterator& rhs) const noexcept
+        {
+            return base_type::operator==(rhs);
+        }
+
+        constexpr bool operator!=(const span_iterator& rhs) const noexcept
+        {
+            return !(*this == rhs);
+        }
+
+        constexpr bool operator<(const span_iterator& rhs) const noexcept
+        {
+            return base_type::operator<(rhs);
+        }
+
+        constexpr bool operator<=(const span_iterator& rhs) const noexcept
+        {
+            return !(rhs < *this);
+        }
+
+        constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
+
+        constexpr bool operator>=(const span_iterator& rhs) const noexcept
+        {
+            return !(rhs > *this);
+        }
+
+        void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
+    };
+
+    template <typename Span>
+    constexpr const_span_iterator<Span>
+    operator+(typename const_span_iterator<Span>::difference_type n,
+              const const_span_iterator<Span>& rhs) noexcept
+    {
+        return rhs + n;
     }
 
-    constexpr reference operator*() const { Expects(span_); return (*span_)[index_]; }
-    constexpr pointer operator->() const { Expects(span_); return &((*span_)[index_]); }
-
-    constexpr const_span_iterator& operator++() noexcept
+    template <typename Span>
+    constexpr const_span_iterator<Span>
+    operator-(typename const_span_iterator<Span>::difference_type n,
+              const const_span_iterator<Span>& rhs) noexcept
     {
-        Expects(span_ && index_ >= 0 && index_ < span_->length());
-        ++index_;
-        return *this;
+        return rhs - n;
     }
 
-    constexpr const_span_iterator operator++(int) noexcept
+    template <typename Span>
+    constexpr span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
+                                            const span_iterator<Span>& rhs) noexcept
     {
-        auto ret = *this;
-        ++(*this);
-        return ret;
+        return rhs + n;
     }
 
-    constexpr const_span_iterator& operator--() noexcept
+    template <typename Span>
+    constexpr span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
+                                            const span_iterator<Span>& rhs) noexcept
     {
-        Expects(span_ && index_ > 0 && index_ <= span_->length());
-        --index_;
-        return *this;
+        return rhs - n;
     }
 
-    constexpr const_span_iterator operator--(int) noexcept
-    {
-        auto ret = *this;
-        --(*this);
-        return ret;
-    }
-
-    constexpr const_span_iterator operator+(difference_type n) const noexcept
-    {
-        auto ret{*this};
-        return ret += n;
-    }
-
-    constexpr const_span_iterator& operator+=(difference_type n) noexcept
-    {
-        Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length());
-        index_ += n;
-        return *this;
-    }
-
-    constexpr const_span_iterator operator-(difference_type n) const noexcept
-    {
-        auto ret{*this};
-        return ret -= n;
-    }
-
-    constexpr const_span_iterator& operator-=(difference_type n) noexcept
-    {
-        return *this += -n;
-    }
-
-    constexpr difference_type operator-(const const_span_iterator& rhs) const noexcept
-    {
-        Expects(span_ == rhs.span_);
-        return index_ - rhs.index_;
-    }
-
-    constexpr reference operator[](difference_type n) const noexcept
-    {
-        return *(*this + n);
-    }
-
-    constexpr bool operator==(const const_span_iterator& rhs) const noexcept
-    {
-        return span_ == rhs.span_ && index_ == rhs.index_;
-    }
-
-    constexpr bool operator!=(const const_span_iterator& rhs) const noexcept { return !(*this == rhs); }
-
-    constexpr bool operator<(const const_span_iterator& rhs) const noexcept
-    {
-        Expects(span_ == rhs.span_);
-        return index_ < rhs.index_;
-    }
-
-    constexpr bool operator<=(const const_span_iterator& rhs) const noexcept { return !(rhs < *this); }
-
-    constexpr bool operator>(const const_span_iterator& rhs) const noexcept { return rhs < *this; }
-
-    constexpr bool operator>=(const const_span_iterator& rhs) const noexcept { return !(rhs > *this); }
-
-    void swap(const_span_iterator& rhs) noexcept
-    {
-        std::swap(index_, rhs.index_);
-        std::swap(m_span, rhs.m_span);
-    }
-
-private:
-    const Span* span_;
-    ptrdiff_t index_;
-};
-
-
-template <class Span>
-class span_iterator : public const_span_iterator<Span>
-{
-    using base_type = const_span_iterator<Span>;
-
-public:
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = typename Span::element_type;
-    using difference_type = std::ptrdiff_t;
-
-    using pointer = value_type*;
-    using reference = value_type&;
-
-    constexpr span_iterator() : base_type() {}
-    constexpr span_iterator(const Span* span, typename Span::index_type index) : base_type(span, index) {}
-
-    constexpr reference operator*() const { return const_cast<reference>(base_type::operator*()); }
-    constexpr pointer operator->() const { return const_cast<pointer>(base_type::operator->()); }
-
-    constexpr span_iterator& operator++() noexcept { base_type::operator++(); return *this; }
-
-    constexpr span_iterator operator++(int) noexcept { return base_type::operator++(1); }
-
-    constexpr span_iterator& operator--() noexcept { base_type::operator--(); return *this; }
-
-    constexpr span_iterator operator--(int) noexcept { return base_type::operator--(1); }
-
-    constexpr span_iterator operator+(difference_type n) const noexcept { return base_type::operator+(n); }
-
-    constexpr span_iterator& operator+=(difference_type n) noexcept { return base_type::operator+=(n); }
-
-    constexpr span_iterator operator-(difference_type n) const noexcept { return base_type::operator-(n); }
-
-    constexpr span_iterator& operator-=(difference_type n) noexcept { return base_type::operator-=(n); }
-
-    constexpr difference_type operator-(const span_iterator& rhs) const noexcept { return base_type::operator-(rhs); }
-
-    constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); }
-
-    constexpr bool operator==(const span_iterator& rhs) const noexcept { return base_type::operator==(rhs); }
-
-    constexpr bool operator!=(const span_iterator& rhs) const noexcept { return !(*this == rhs); }
-
-    constexpr bool operator<(const span_iterator& rhs) const noexcept { return base_type::operator<(rhs); }
-
-    constexpr bool operator<=(const span_iterator& rhs) const noexcept { return !(rhs < *this); }
-
-    constexpr bool operator>(const span_iterator& rhs) const noexcept { return rhs < *this; }
-
-    constexpr bool operator>=(const span_iterator& rhs) const noexcept { return !(rhs > *this); }
-
-    void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
-};
-
-template <typename Span>
-constexpr const_span_iterator<Span> operator+(typename const_span_iterator<Span>::difference_type n,
-    const const_span_iterator<Span>& rhs) noexcept
-{
-    return rhs + n;
-}
-
-template <typename Span>
-constexpr const_span_iterator<Span> operator-(typename const_span_iterator<Span>::difference_type n,
-    const const_span_iterator<Span>& rhs) noexcept
-{
-    return rhs - n;
-}
-
-template <typename Span>
-constexpr span_iterator<Span> operator+(typename span_iterator<Span>::difference_type n,
-    const span_iterator<Span>& rhs) noexcept
-{
-    return rhs + n;
-}
-
-template <typename Span>
-constexpr span_iterator<Span> operator-(typename span_iterator<Span>::difference_type n,
-    const span_iterator<Span>& rhs) noexcept
-{
-    return rhs - n;
-}
-
 } // namespace details
 
-
-// [span], class template span 
+// [span], class template span
 template <class ElementType, std::ptrdiff_t Extent>
-class span {
+class span
+{
 public:
-    // constants and types 
+    // constants and types
     using element_type = ElementType;
     using index_type = std::ptrdiff_t;
     using pointer = element_type*;
@@ -378,135 +428,140 @@ public:
 
     constexpr static const index_type extent = Extent;
 
-    // [span.cons], span constructors, copy, assignment, and destructor 
-    constexpr span() noexcept : storage_(nullptr, extent_type<0>())
-    {}
+    // [span.cons], span constructors, copy, assignment, and destructor
+    constexpr span() noexcept : storage_(nullptr, extent_type<0>()) {}
 
-    constexpr span(nullptr_t) noexcept : span()
-    {}
+    constexpr span(nullptr_t) noexcept : span() {}
 
-    constexpr span(pointer ptr, index_type count) : storage_(ptr, count)
-    {}
+    constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {}
 
     constexpr span(pointer firstElem, pointer lastElem)
         : storage_(firstElem, std::distance(firstElem, lastElem))
-    {}
-    
-    template <size_t N>
-    constexpr span(element_type(&arr)[N]) noexcept
-        : storage_(&arr[0], extent_type<N>())
-    {}
+    {
+    }
 
     template <size_t N>
-    constexpr span(std::array<element_type, N>& arr) noexcept
-        : storage_(&arr[0], extent_type<N>())
-    {}
+    constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], extent_type<N>())
+    {
+    }
+
+    template <size_t N>
+    constexpr span(std::array<element_type, N>& arr) noexcept : storage_(&arr[0], extent_type<N>())
+    {
+    }
 
     template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
     constexpr span(std::array<std::remove_const_t<element_type>, N>& arr) noexcept
         : storage_(&arr[0], extent_type<N>())
-    {}
+    {
+    }
 
     template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
     constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept
         : storage_(&arr[0], extent_type<N>())
-    {}
+    {
+    }
 
     // NB: the SFINAE here uses .data() as a 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 &&
-        std::is_convertible<Container::pointer, pointer>::value &&
-        std::is_convertible<Container::pointer, decltype(std::declval<Container>().data())>::value>
-    >
-    constexpr span(Container& cont) : span(cont.data(), cont.size()) {}
+              class = std::enable_if_t<
+                  !details::is_span<Container>::value &&
+                  std::is_convertible<Container::pointer, pointer>::value &&
+                  std::is_convertible<Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
+    constexpr span(Container& cont) : span(cont.data(), cont.size())
+    {
+    }
 
     template <class Container,
-    class = std::enable_if_t<std::is_const<element_type>::value &&
-        !details::is_span<Container>::value &&
-        std::is_convertible<Container::pointer, pointer>::value &&
-        std::is_convertible<Container::pointer, decltype(std::declval<Container>().data())>::value>
-    >
-    constexpr span(const Container& cont) : span(cont.data(), cont.size()) {}
+              class = std::enable_if_t<
+                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
+                  std::is_convertible<Container::pointer, pointer>::value &&
+                  std::is_convertible<Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
+    constexpr span(const Container& cont) : span(cont.data(), cont.size())
+    {
+    }
 
     constexpr span(const span& other) noexcept = default;
     constexpr span(span&& other) noexcept = default;
 
-    template <class OtherElementType, std::ptrdiff_t OtherExtent,
-        class = std::enable_if_t<
-            details::is_allowed_extent_conversion<OtherExtent, Extent>::value && 
-            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
-        >
-    >
-    constexpr span(const span<OtherElementType, OtherExtent>& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
-    {}
-
-    template <class OtherElementType, std::ptrdiff_t OtherExtent,
+    template <
+        class OtherElementType, std::ptrdiff_t OtherExtent,
         class = std::enable_if_t<
             details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
-            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value
-        >
-    >
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
+    constexpr span(const span<OtherElementType, OtherExtent>& other)
+        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
+    {
+    }
+
+    template <
+        class OtherElementType, std::ptrdiff_t OtherExtent,
+        class = std::enable_if_t<
+            details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
     constexpr span(span<OtherElementType, OtherExtent>&& other)
         : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
-    {}
+    {
+    }
 
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     constexpr span& operator=(span&& other) noexcept = default;
 
-    // [span.sub], span subviews  
+    // [span.sub], span subviews
     template <ptrdiff_t Count>
     constexpr span<element_type, Count> first() const
     {
         Expects(Count >= 0 && Count <= size());
-        return { data(), Count };
+        return {data(), Count};
     }
 
     template <ptrdiff_t Count>
     constexpr span<element_type, Count> last() const
     {
         Expects(Count >= 0 && Count <= size());
-        return{ data() + (size() - Count), Count };
+        return {data() + (size() - Count), Count};
     }
 
     template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
     constexpr span<element_type, Count> subspan() const
     {
         Expects((Offset == 0 || Offset > 0 && Offset <= size()) &&
-            (Count == dynamic_extent || Count >= 0 && Offset + Count <= size()));
-        return { data() + Offset, Count == dynamic_extent ? size() - Offset : Count };
+                (Count == dynamic_extent || Count >= 0 && Offset + Count <= size()));
+        return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
     }
 
     constexpr span<element_type, dynamic_extent> first(index_type count) const
     {
         Expects(count >= 0 && count <= size());
-        return { data(), count };
+        return {data(), count};
     }
 
     constexpr span<element_type, dynamic_extent> last(index_type count) const
     {
         Expects(count >= 0 && count <= size());
-        return { data() + (size() - count), count };
+        return {data() + (size() - count), count};
     }
 
     constexpr span<element_type, dynamic_extent> subspan(index_type offset,
-        index_type count = dynamic_extent) const
+                                                         index_type count = dynamic_extent) const
     {
         Expects((offset == 0 || offset > 0 && offset <= size()) &&
-            (count == dynamic_extent || count >= 0 && offset + count <= size()));
-        return { data() + offset, count == dynamic_extent ? size() - offset : count };
+                (count == dynamic_extent || count >= 0 && offset + count <= size()));
+        return {data() + offset, count == dynamic_extent ? size() - offset : count};
     }
 
-    // [span.obs], span observers 
+    // [span.obs], span observers
     constexpr index_type length() const noexcept { return size(); }
-    constexpr index_type size() const noexcept { return storage_.size();  }
+    constexpr index_type size() const noexcept { return storage_.size(); }
     constexpr index_type length_bytes() const noexcept { return size_bytes(); }
     constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); }
     constexpr bool empty() const noexcept { return size() == 0; }
 
-    // [span.elem], span element access 
+    // [span.elem], span element access
     constexpr reference operator[](index_type idx) const
     {
         Expects(idx >= 0 && idx < storage_.size());
@@ -515,13 +570,13 @@ public:
     constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
     constexpr pointer data() const noexcept { return storage_.data(); }
 
-    // [span.iter], span iterator support 
+    // [span.iter], span iterator support
     iterator begin() const noexcept { return {this, 0}; }
     iterator end() const noexcept { return {this, length()}; }
 
     const_iterator cbegin() const noexcept { return {this, 0}; }
     const_iterator cend() const noexcept { return {this, length()}; }
- 
+
     reverse_iterator rbegin() const noexcept { return reverse_iterator{{this, length()}}; }
     reverse_iterator rend() const noexcept { return reverse_iterator{{this, 0}}; }
 
@@ -531,7 +586,7 @@ public:
 private:
     template <index_type Extent>
     class extent_type;
-    
+
     template <index_type Extent>
     class extent_type
     {
@@ -544,12 +599,11 @@ private:
         constexpr extent_type(extent_type<Other> ext) noexcept
         {
             static_assert(Other == Extent || Other == dynamic_extent,
-                "Mismatch between fixed-size extent and size of initializing data.");
+                          "Mismatch between fixed-size extent and size of initializing data.");
             Expects(ext.size() == Extent);
         }
 
-        constexpr extent_type(index_type size)
-        { Expects(size == Extent); }
+        constexpr extent_type(index_type size) { Expects(size == Extent); }
 
         constexpr inline index_type size() const noexcept { return Extent; }
     };
@@ -560,19 +614,18 @@ private:
     public:
         template <index_type Other>
         explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
-        {}
+        {
+        }
 
-        explicit constexpr extent_type(index_type size) : size_(size)
-        { Expects(size >= 0); } 
+        explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); }
 
-        constexpr inline index_type size() const noexcept
-        { return size_; }
+        constexpr inline index_type size() const noexcept { return size_; }
 
     private:
         index_type size_;
     };
 
-    // this implementation detail class lets us take advantage of the 
+    // this implementation detail class lets us take advantage of the
     // empty base class optimization to pay for only storage of a single
     // pointer in the case of fixed-size spans
     template <class ExtentType>
@@ -580,12 +633,12 @@ private:
     {
     public:
         template <class OtherExtentType>
-        constexpr storage_type(pointer data, OtherExtentType ext)
-            : ExtentType(ext), data_(data)
-        { Expects((!data && size() == 0) || (data && size() >= 0)); }
+        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
+        {
+            Expects((!data && size() == 0) || (data && size() >= 0));
+        }
 
-        constexpr inline pointer data() const noexcept
-        { return data_; }
+        constexpr inline pointer data() const noexcept { return data_; }
 
     private:
         pointer data_;
@@ -594,60 +647,81 @@ private:
     storage_type<extent_type<Extent>> storage_;
 };
 
-
-// [span.comparison], span comparison operators 
+// [span.comparison], span comparison operators
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return std::equal(l.begin(), l.end(), r.begin(), r.end()); }
+constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return std::equal(l.begin(), l.end(), r.begin(), r.end());
+}
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return !(l == r); }
+constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return !(l == r);
+}
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); }
+constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return !(l > r); }
+constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return !(l > r);
+}
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return r < l; }
+constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return r < l;
+}
 
 template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) 
-{ return !(l < r); }
-
+constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+{
+    return !(l < r);
+}
 
 namespace details
 {
     // if we only supported compilers with good constexpr support then
     // this pair of classes could collapse down to a constexpr function
 
-    // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as constexpr
+    // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as
+    // constexpr
     // and so will fail compilation of the template
     template <class ElementType, ptrdiff_t Extent>
-    struct calculate_byte_size :
-        std::integral_constant<std::ptrdiff_t, static_cast<ptrdiff_t>(sizeof(ElementType) * static_cast<size_t>(Extent))>
-    {};
+    struct calculate_byte_size
+        : std::integral_constant<std::ptrdiff_t,
+                                 static_cast<ptrdiff_t>(sizeof(ElementType) *
+                                                        static_cast<size_t>(Extent))>
+    {
+    };
 
     template <class ElementType>
-    struct calculate_byte_size<ElementType, dynamic_extent> :
-        std::integral_constant<std::ptrdiff_t, dynamic_extent>
-    {};
+    struct calculate_byte_size<ElementType, dynamic_extent>
+        : std::integral_constant<std::ptrdiff_t, dynamic_extent>
+    {
+    };
 }
 
-
-// [span.objectrep], views of object representation 
+// [span.objectrep], views of object representation
 template <class ElementType, ptrdiff_t Extent>
-span<const byte, details::calculate_byte_size<ElementType, Extent>::value> as_bytes(span<ElementType, Extent> s) noexcept
-{ return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; }
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(span<ElementType, Extent> s) noexcept
+{
+    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
+}
 
-template <class ElementType, ptrdiff_t Extent, class = std::enable_if_t<!std::is_const<ElementType>::value>>
-span<byte, details::calculate_byte_size<ElementType, Extent>::value> as_writeable_bytes(span<ElementType, Extent> s) noexcept 
-{ return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; }
+template <class ElementType, ptrdiff_t Extent,
+          class = std::enable_if_t<!std::is_const<ElementType>::value>>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writeable_bytes(span<ElementType, Extent> s) noexcept
+{
+    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
+}
 
 } // namespace gsl
 
diff --git a/include/string_span.h b/include/string_span.h
index ccfe251..bef8288 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -36,8 +36,7 @@
 // blanket turn off warnings from CppCoreCheck for now
 // so people aren't annoyed by them when running the tool.
 // more targeted suppressions will be added in a future update to the GSL
-#pragma warning(disable: 26481 26482 26483 26485 26490 26491 26492 26493 26495)
-
+#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
 
 // VS 2013 workarounds
 #if _MSC_VER <= 1800
@@ -80,19 +79,19 @@ namespace gsl
 // (sometimes needlessly) break existing programs when introduced.
 //
 
-template<typename CharT, std::ptrdiff_t Extent = dynamic_extent>
+template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 using basic_zstring = CharT*;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using czstring = basic_zstring<const char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using cwzstring = basic_zstring<const wchar_t, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using zstring = basic_zstring<char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using wzstring = basic_zstring<wchar_t, Extent>;
 
 //
@@ -103,85 +102,93 @@ using wzstring = basic_zstring<wchar_t, Extent>;
 //
 // Will fail-fast if sentinel cannot be found before max elements are examined.
 //
-template<typename T, const T Sentinel>
+template <typename T, const T Sentinel>
 span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     auto cur = seq;
     while ((cur - seq) < max && *cur != Sentinel) ++cur;
     Ensures(*cur == Sentinel);
-    return{ seq, cur - seq };
+    return {seq, cur - seq};
 }
 
-
 //
 // ensure_z - creates a span for a czstring or cwzstring.
 // Will fail fast if a null-terminator cannot be found before
 // the limit of size_type.
 //
-template<typename T>
-inline span<T, dynamic_extent> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
+template <typename T>
+inline span<T, dynamic_extent> ensure_z(T* const& sz, std::ptrdiff_t max = PTRDIFF_MAX)
 {
     return ensure_sentinel<T, 0>(sz, max);
 }
 
-// TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation
+// TODO (neilmac) there is probably a better template-magic way to get the const and non-const
+// overloads to share an implementation
 inline span<char, dynamic_extent> ensure_z(char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
-    return{ sz, static_cast<std::ptrdiff_t>(len) };
+    return {sz, static_cast<std::ptrdiff_t>(len)};
 }
 
 inline span<const char, dynamic_extent> ensure_z(const char* const& sz, std::ptrdiff_t max)
 {
     auto len = strnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
-    return{ sz, static_cast<std::ptrdiff_t>(len) };
+    return {sz, static_cast<std::ptrdiff_t>(len)};
 }
 
 inline span<wchar_t, dynamic_extent> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
-    return{ sz, static_cast<std::ptrdiff_t>(len) };
+    return {sz, static_cast<std::ptrdiff_t>(len)};
 }
 
 inline span<const wchar_t, dynamic_extent> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
 {
     auto len = wcsnlen(sz, narrow_cast<size_t>(max));
     Ensures(sz[len] == 0);
-    return{ sz, static_cast<std::ptrdiff_t>(len) };
+    return {sz, static_cast<std::ptrdiff_t>(len)};
 }
 
-template<typename T, size_t N>
-span<T, dynamic_extent> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
+template <typename T, size_t N>
+span<T, dynamic_extent> ensure_z(T (&sz)[N])
+{
+    return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N));
+}
 
-template<class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent> ensure_z(Cont& cont)
+template <class Cont>
+span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
+ensure_z(Cont& cont)
 {
     return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length()));
 }
 
-template<typename CharT, std::ptrdiff_t>
+template <typename CharT, std::ptrdiff_t>
 class basic_string_span;
 
 namespace details
 {
     template <typename T>
     struct is_basic_string_span_oracle : std::false_type
-    {};
+    {
+    };
 
     template <typename CharT, std::ptrdiff_t Extent>
     struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type
-    {};
+    {
+    };
 
     template <typename T>
     struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>>
-    {};
+    {
+    };
 
     template <typename T>
     struct length_func
-    {};
+    {
+    };
 
     template <>
     struct length_func<char>
@@ -220,7 +227,6 @@ namespace details
     };
 }
 
-
 //
 // string_span and relatives
 //
@@ -247,19 +253,17 @@ public:
     // copy
     constexpr basic_string_span(const basic_string_span& other) = default;
 
-    // move
+// move
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr basic_string_span(basic_string_span&& other) = default;
 #else
-    constexpr basic_string_span(basic_string_span&& other)
-    	: span_(std::move(other.span_))
-    {}
+    constexpr basic_string_span(basic_string_span&& other) : span_(std::move(other.span_)) {}
 #endif
 
     // assign
     constexpr basic_string_span& operator=(const basic_string_span& other) = default;
 
-    // move assign
+// move assign
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr basic_string_span& operator=(basic_string_span&& other) = default;
 #else
@@ -271,211 +275,160 @@ public:
 #endif
 
     // from nullptr
-    constexpr basic_string_span(std::nullptr_t ptr) noexcept
-        : span_(ptr)
-    {}
+    constexpr basic_string_span(std::nullptr_t ptr) noexcept : span_(ptr) {}
 
     // from nullptr and length
-    constexpr basic_string_span(std::nullptr_t ptr, size_type length) noexcept
-        : span_(ptr, length)
-    {}
+    constexpr basic_string_span(std::nullptr_t ptr, size_type length) noexcept : span_(ptr, length)
+    {
+    }
 
     // From static arrays - if 0-terminated, remove 0 from the view
 
     // from static arrays and string literals
-    template<size_t N>
-    constexpr basic_string_span(value_type(&arr)[N]) noexcept
-        : span_(remove_z(arr))
-    {}
+    template <size_t N>
+    constexpr basic_string_span(value_type (&arr)[N]) noexcept : span_(remove_z(arr))
+    {
+    }
 
     // Those allow 0s within the length, so we do not remove them
 
     // from raw data and length
-    constexpr basic_string_span(pointer ptr, size_type length) noexcept
-        : span_(ptr, length)
-    {}
+    constexpr basic_string_span(pointer ptr, size_type length) noexcept : span_(ptr, length) {}
 
     // from string
     constexpr basic_string_span(std::string& s) noexcept
         : span_(const_cast<pointer>(s.data()), narrow_cast<std::ptrdiff_t>(s.length()))
-    {}
+    {
+    }
 
     // from containers. Containers must have .size() and .data() function signatures
     template <typename Cont,
-        typename = std::enable_if_t<
-        !details::is_basic_string_span<Cont>::value
-        && !details::is_span<Cont>::value
-        && std::is_convertible<Cont::pointer, pointer>::value
-        && std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>
-    >
-    constexpr basic_string_span(Cont& cont) : span_(cont.data(), cont.size()) {}
+              typename = std::enable_if_t<
+                  !details::is_basic_string_span<Cont>::value && !details::is_span<Cont>::value &&
+                  std::is_convertible<Cont::pointer, pointer>::value &&
+                  std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>>
+    constexpr basic_string_span(Cont& cont) : span_(cont.data(), cont.size())
+    {
+    }
 
     // disallow creation from temporary containers and strings
     template <typename Cont,
-        typename = std::enable_if_t<
-        !details::is_basic_string_span<Cont>::value
-        && !details::is_span<Cont>::value
-        && std::is_convertible<Cont::pointer, pointer>::value
-        && std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>
-        >
-    constexpr basic_string_span(const Cont& cont) : span_(cont.data(), cont.size()) {}
+              typename = std::enable_if_t<
+                  !details::is_basic_string_span<Cont>::value && !details::is_span<Cont>::value &&
+                  std::is_convertible<Cont::pointer, pointer>::value &&
+                  std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>>
+    constexpr basic_string_span(const Cont& cont) : span_(cont.data(), cont.size())
+    {
+    }
 
 #ifndef GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE
     // from span
     template <typename OtherValueType, std::ptrdiff_t OtherExtent,
-        typename Dummy = std::enable_if_t<
-        std::is_convertible<span<OtherValueType, OtherExtent>, impl_type>::value
-        >
-    >
-    constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept
-        : span_(other)
-    {}
+              typename Dummy = std::enable_if_t<
+                  std::is_convertible<span<OtherValueType, OtherExtent>, impl_type>::value>>
+    constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept : span_(other)
+    {
+    }
 #else
     // from span
-    constexpr basic_string_span(span<value_type, Extent> other) noexcept
-        : span_(other)
-    {}
-        
-    template <typename = std::enable_if_t<!std::is_same<std::remove_const_t<value_type>, value_type>::value>>
+    constexpr basic_string_span(span<value_type, Extent> other) noexcept : span_(other) {}
+
+    template <typename = std::enable_if_t<
+                  !std::is_same<std::remove_const_t<value_type>, value_type>::value>>
     constexpr basic_string_span(span<std::remove_const_t<value_type>, Extent> other) noexcept
         : span_(other)
-    {}
+    {
+    }
 #endif
 
     // from string_span
     template <typename OtherValueType, std::ptrdiff_t OtherExtent,
-        typename = std::enable_if_t<
-            std::is_convertible<basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value
-        >
-    >
+              typename = std::enable_if_t<std::is_convertible<
+                  basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
     constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) noexcept
         : span_(other.data(), other.length())
-    {}
-
-    constexpr bool empty() const noexcept
     {
-        return length() == 0;
     }
 
+    constexpr bool empty() const noexcept { return length() == 0; }
+
     // first Count elements
-    template<size_type Count>
+    template <size_type Count>
     constexpr basic_string_span<value_type, Count> first() const noexcept
     {
-        return{ span_.template first<Count>() };
+        return {span_.template first<Count>()};
     }
 
     constexpr basic_string_span<value_type, dynamic_extent> first(size_type count) const noexcept
     {
-        return{ span_.first(count) };
+        return {span_.first(count)};
     }
 
     // last Count elements
-    template<size_type Count>
+    template <size_type Count>
     constexpr basic_string_span<value_type, Count> last() const noexcept
     {
-        return{ span_.template last<Count>() };
+        return {span_.template last<Count>()};
     }
 
     constexpr basic_string_span<value_type, dynamic_extent> last(size_type count) const noexcept
     {
-        return{ span_.last(count) };
+        return {span_.last(count)};
     }
 
     // create a subview of Count elements starting from Offset
-    template<size_type Offset, size_type Count>
+    template <size_type Offset, size_type Count>
     constexpr basic_string_span<value_type, Count> subspan() const noexcept
     {
-        return{ span_.template subspan<Offset, Count>() };
+        return {span_.template subspan<Offset, Count>()};
     }
 
-    constexpr basic_string_span<value_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const noexcept
+    constexpr basic_string_span<value_type, dynamic_extent>
+    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
     {
-        return{ span_.subspan(offset, count) };
+        return {span_.subspan(offset, count)};
     }
 
-    constexpr reference operator[](size_type idx) const noexcept
-    {
-        return span_[idx];
-    }
+    constexpr reference operator[](size_type idx) const noexcept { return span_[idx]; }
 
-    constexpr pointer data() const noexcept
-    {
-        return span_.data();
-    }
+    constexpr pointer data() const noexcept { return span_.data(); }
 
     // length of the span in elements
-    constexpr size_type length() const noexcept
-    {
-        return span_.size();
-    }
+    constexpr size_type length() const noexcept { return span_.size(); }
 
     // length of the span in elements
-    constexpr size_type size() const noexcept
-    {
-        return span_.size();
-    }
+    constexpr size_type size() const noexcept { return span_.size(); }
 
     // length of the span in bytes
-    constexpr size_type size_bytes() const noexcept
-    {
-        return span_.size_bytes();
-    }
+    constexpr size_type size_bytes() const noexcept { return span_.size_bytes(); }
 
     // length of the span in bytes
-    constexpr size_type length_bytes() const noexcept
-    {
-        return span_.length_bytes();
-    }
+    constexpr size_type length_bytes() const noexcept { return span_.length_bytes(); }
 
-    constexpr iterator begin() const noexcept
-    {
-        return span_.begin();
-    }
+    constexpr iterator begin() const noexcept { return span_.begin(); }
 
-    constexpr iterator end() const noexcept
-    {
-        return span_.end();
-    }
+    constexpr iterator end() const noexcept { return span_.end(); }
 
-    constexpr const_iterator cbegin() const noexcept
-    {
-        return span_.cbegin();
-    }
+    constexpr const_iterator cbegin() const noexcept { return span_.cbegin(); }
 
-    constexpr const_iterator cend() const noexcept
-    {
-        return span_.cend();
-    }
+    constexpr const_iterator cend() const noexcept { return span_.cend(); }
 
-    constexpr reverse_iterator rbegin() const noexcept
-    {
-        return span_.rbegin();
-    }
+    constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); }
 
-    constexpr reverse_iterator rend() const noexcept
-    {
-        return span_.rend();
-    }
+    constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
 
-    constexpr const_reverse_iterator crbegin() const noexcept
-    {
-        return span_.crbegin();
-    }
+    constexpr const_reverse_iterator crbegin() const noexcept { return span_.crbegin(); }
 
-    constexpr const_reverse_iterator crend() const noexcept
-    {
-        return span_.crend();
-    }
+    constexpr const_reverse_iterator crend() const noexcept { return span_.crend(); }
 
 private:
-
     static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) noexcept
     {
-        return{ sz, details::length_func<value_type>()(sz, max)};
+        return {sz, details::length_func<value_type>()(sz, max)};
     }
 
-    template<size_t N>
-    static impl_type remove_z(value_type(&sz)[N]) noexcept
+    template <size_t N>
+    static impl_type remove_z(value_type (&sz)[N]) noexcept
     {
         return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N));
     }
@@ -483,16 +436,16 @@ private:
     impl_type span_;
 };
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using string_span = basic_string_span<char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using cstring_span = basic_string_span<const char, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using wstring_span = basic_string_span<wchar_t, Extent>;
 
-template<std::ptrdiff_t Extent = dynamic_extent>
+template <std::ptrdiff_t Extent = dynamic_extent>
 using cwstring_span = basic_string_span<const wchar_t, Extent>;
 
 //
@@ -500,39 +453,40 @@ using cwstring_span = basic_string_span<const wchar_t, Extent>;
 //
 #ifndef GSL_MSVC_HAS_TYPE_DEDUCTION_BUG
 
-template<typename CharT, ptrdiff_t Extent>
-std::basic_string<typename std::remove_const<CharT>::type> to_string(basic_string_span<CharT, Extent> view)
+template <typename CharT, ptrdiff_t Extent>
+std::basic_string<typename std::remove_const<CharT>::type>
+to_string(basic_string_span<CharT, Extent> view)
 {
-    return{ view.data(), static_cast<size_t>(view.length()) };
+    return {view.data(), static_cast<size_t>(view.length())};
 }
 
 #else
 
 inline std::string to_string(cstring_span<> view)
 {
-    return{ view.data(), static_cast<size_t>(view.length()) };
+    return {view.data(), static_cast<size_t>(view.length())};
 }
 
 inline std::string to_string(string_span<> view)
 {
-    return{ view.data(), static_cast<size_t>(view.length()) };
+    return {view.data(), static_cast<size_t>(view.length())};
 }
 
 inline std::wstring to_string(cwstring_span<> view)
 {
-    return{ view.data(), static_cast<size_t>(view.length()) };
+    return {view.data(), static_cast<size_t>(view.length())};
 }
 
 inline std::wstring to_string(wstring_span<> view)
 {
-    return{ view.data(), static_cast<size_t>(view.length()) };
+    return {view.data(), static_cast<size_t>(view.length())};
 }
 
 #endif
 
 // zero-terminated string span, used to convert
 // zero-terminated spans to legacy strings
-template<typename CharT, std::ptrdiff_t Extent = dynamic_extent>
+template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 class basic_zstring_span
 {
 public:
@@ -548,8 +502,7 @@ public:
     using impl_type = span<value_type, Extent>;
     using string_span_type = basic_string_span<value_type, Extent>;
 
-    constexpr basic_zstring_span(impl_type s) noexcept
-        : span_(s)
+    constexpr basic_zstring_span(impl_type s) noexcept : span_(s)
     {
         // expects a zero-terminated span
         Expects(s[s.size() - 1] == '\0');
@@ -558,19 +511,17 @@ public:
     // copy
     constexpr basic_zstring_span(const basic_zstring_span& other) = default;
 
-    // move
+// move
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr basic_zstring_span(basic_zstring_span&& other) = default;
 #else
-    constexpr basic_zstring_span(basic_zstring_span&& other)
-        : span_(std::move(other.span_))
-    {}
+    constexpr basic_zstring_span(basic_zstring_span&& other) : span_(std::move(other.span_)) {}
 #endif
 
     // assign
     constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;
 
-    // move assign
+// move assign
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;
 #else
@@ -583,7 +534,10 @@ public:
 
     constexpr bool empty() const noexcept { return span_.size() == 0; }
 
-    constexpr string_span_type as_string_span() const noexcept { return span_.first(span_.size()-1); }
+    constexpr string_span_type as_string_span() const noexcept
+    {
+        return span_.first(span_.size() - 1);
+    }
 
     constexpr string_span_type ensure_z() const noexcept { return gsl::ensure_z(span_); }
 
@@ -609,9 +563,8 @@ using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
 
 // operator ==
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
@@ -622,11 +575,11 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 #endif
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
@@ -637,33 +590,33 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 #endif
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
     return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
@@ -673,50 +626,49 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 
 // operator !=
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(one == other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(one == other);
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(one == other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(one == other);
@@ -725,53 +677,52 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 
 // operator<
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
     return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
     return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
     return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
@@ -781,50 +732,49 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 
 // operator <=
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(other < one);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(other < one);
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(other < one);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(other < one);
@@ -833,50 +783,49 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 
 // operator>
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return other < one;
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return other < one;
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return other < one;
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return other < one;
@@ -885,50 +834,49 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexce
 
 // operator >=
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>
->
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(one < other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename Dummy = std::enable_if_t<
-    std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value
-    && !gsl::details::is_basic_string_span<T>::value>
->
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
 bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(one < other);
 }
 
-#ifndef _MSC_VER 
+#ifndef _MSC_VER
 
 // VS treats temp and const containers as convertible to basic_string_span,
 // so the cases below are already covered by the previous operators
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
 {
     return !(one < other);
 }
 
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
+template <
+    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename Dummy = std::enable_if_t<
-    !gsl::details::is_span<T>::value
-    && !gsl::details::is_basic_string_span<T>::value
-    && std::is_convertible<DataType*, CharT*>::value
-    && std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, DataType>::value>
->
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
 bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
 {
     return !(one < other);

From c366f4415d581b03e2a900cf36c40e830cd05bf9 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 26 Jul 2016 18:34:27 -0700
Subject: [PATCH 32/42] Fixed compilation issues for GCC on Linux.

---
 include/gsl_util.h          |   1 -
 include/span.h              | 207 +++++++++++++++--------------
 include/string_span.h       | 258 +++++++++++++-----------------------
 tests/string_span_tests.cpp |   6 +-
 4 files changed, 207 insertions(+), 265 deletions(-)

diff --git a/include/gsl_util.h b/include/gsl_util.h
index a3d5fbe..92a795b 100644
--- a/include/gsl_util.h
+++ b/include/gsl_util.h
@@ -118,7 +118,6 @@ inline T narrow(U u)
 {
     T t = narrow_cast<T>(u);
     if (static_cast<U>(t) != u) throw narrowing_error();
-#pragma warning(suppress : 4127) // suppress warning from MSVC compiler about constant in if-test
     if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
         throw narrowing_error();
     return t;
diff --git a/include/span.h b/include/span.h
index f40a7ab..27c479d 100644
--- a/include/span.h
+++ b/include/span.h
@@ -79,12 +79,12 @@
 namespace gsl
 {
 
-template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
-class span;
-
 // [views.constants], constants
 constexpr const std::ptrdiff_t dynamic_extent = -1;
 
+template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
+class span;
+
 // implementation details
 namespace details
 {
@@ -99,20 +99,35 @@ namespace details
     };
 
     template <class T>
-    struct is_span : is_span_oracle<std::remove_cv_t<T>>
+    struct is_span : public is_span_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <class T>
+    struct is_std_array_oracle : std::false_type
+    {
+    };
+
+    template <class ElementType, size_t Extent>
+    struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>>
     {
     };
 
     template <class From, class To>
     struct is_allowed_pointer_conversion
-        : std::bool_constant<std::is_pointer<From>::value && std::is_pointer<To>::value &&
+        : public std::integral_constant<bool, std::is_pointer<From>::value && std::is_pointer<To>::value &&
                              std::is_convertible<From, To>::value>
     {
     };
 
     template <class From, class To>
     struct is_allowed_integral_conversion
-        : std::bool_constant<std::is_integral<From>::value && std::is_integral<To>::value &&
+        : public std::integral_constant<bool, std::is_integral<From>::value && std::is_integral<To>::value &&
                              sizeof(From) == sizeof(To) && alignof(From) == alignof(To) &&
                              std::is_convertible<From, To>::value>
     {
@@ -120,13 +135,13 @@ namespace details
 
     template <std::ptrdiff_t From, std::ptrdiff_t To>
     struct is_allowed_extent_conversion
-        : std::bool_constant<From == To || From == gsl::dynamic_extent || To == gsl::dynamic_extent>
+        : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || To == gsl::dynamic_extent>
     {
     };
 
     template <class From, class To>
     struct is_allowed_element_type_conversion
-        : std::bool_constant<std::is_same<From, std::remove_cv_t<To>>::value ||
+        : public std::integral_constant<bool, std::is_same<From, std::remove_cv_t<To>>::value ||
                              is_allowed_pointer_conversion<From, To>::value ||
                              is_allowed_integral_conversion<From, To>::value>
     {
@@ -134,12 +149,12 @@ namespace details
 
     template <class From>
     struct is_allowed_element_type_conversion<From, byte>
-        : std::bool_constant<!std::is_const<From>::value>
+        : public std::integral_constant<bool, !std::is_const<From>::value>
     {
     };
 
     template <class From>
-    struct is_allowed_element_type_conversion<From, const byte> : std::true_type
+    struct is_allowed_element_type_conversion<From, const byte> : public std::true_type
     {
     };
 
@@ -269,12 +284,12 @@ namespace details
         void swap(const_span_iterator& rhs) noexcept
         {
             std::swap(index_, rhs.index_);
-            std::swap(m_span, rhs.m_span);
+            std::swap(span_, rhs.span_);
         }
 
     private:
         const Span* span_;
-        ptrdiff_t index_;
+        std::ptrdiff_t index_;
     };
 
     template <class Span>
@@ -323,12 +338,12 @@ namespace details
 
         constexpr span_iterator operator+(difference_type n) const noexcept
         {
-            return base_type::operator+(n);
+            return {base_type::operator+(n)};
         }
 
         constexpr span_iterator& operator+=(difference_type n) noexcept
         {
-            return base_type::operator+=(n);
+            return {base_type::operator+=(n)};
         }
 
         constexpr span_iterator operator-(difference_type n) const noexcept
@@ -376,6 +391,10 @@ namespace details
         }
 
         void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
+    private:
+        constexpr span_iterator(const base_type& base) : base_type(base)
+        {
+        }
     };
 
     template <typename Span>
@@ -408,6 +427,47 @@ namespace details
         return rhs - n;
     }
 
+    template <std::ptrdiff_t Ext>
+    class extent_type
+    {
+    public:
+	using index_type = std::ptrdiff_t;
+
+        static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size.");
+
+        constexpr extent_type() noexcept {}
+
+        template <index_type Other>
+        constexpr extent_type(extent_type<Other> ext) noexcept
+        {
+            static_assert(Other == Ext || Other == dynamic_extent,
+                          "Mismatch between fixed-size extent and size of initializing data.");
+            Expects(ext.size() == Ext);
+        }
+
+        constexpr extent_type(index_type size) { Expects(size == Ext); }
+
+        constexpr inline index_type size() const noexcept { return Ext; }
+    };
+
+    template <>
+    class extent_type<dynamic_extent>
+    {
+    public:
+	using index_type = std::ptrdiff_t;
+
+        template <index_type Other>
+        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
+        {
+        }
+
+        explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); }
+
+        constexpr inline index_type size() const noexcept { return size_; }
+
+    private:
+        index_type size_;
+    };
 } // namespace details
 
 // [span], class template span
@@ -429,9 +489,9 @@ public:
     constexpr static const index_type extent = Extent;
 
     // [span.cons], span constructors, copy, assignment, and destructor
-    constexpr span() noexcept : storage_(nullptr, extent_type<0>()) {}
+    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>()) {}
 
-    constexpr span(nullptr_t) noexcept : span() {}
+    constexpr span(std::nullptr_t) noexcept : span() {}
 
     constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {}
 
@@ -441,24 +501,19 @@ public:
     }
 
     template <size_t N>
-    constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], extent_type<N>())
+    constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], details::extent_type<N>())
+    {
+    }
+    
+    template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr span(std::array<ArrayElementType, N>& arr) noexcept
+        : storage_(&arr[0], details::extent_type<N>())
     {
     }
 
     template <size_t N>
-    constexpr span(std::array<element_type, N>& arr) noexcept : storage_(&arr[0], extent_type<N>())
-    {
-    }
-
-    template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
-    constexpr span(std::array<std::remove_const_t<element_type>, N>& arr) noexcept
-        : storage_(&arr[0], extent_type<N>())
-    {
-    }
-
-    template <size_t N, class = std::enable_if_t<is_const<element_type>::value>>
     constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept
-        : storage_(&arr[0], extent_type<N>())
+        : storage_(&arr[0], details::extent_type<N>())
     {
     }
 
@@ -467,8 +522,9 @@ public:
     template <class Container,
               class = std::enable_if_t<
                   !details::is_span<Container>::value &&
-                  std::is_convertible<Container::pointer, pointer>::value &&
-                  std::is_convertible<Container::pointer,
+                  !details::is_std_array<Container>::value && 
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
     constexpr span(Container& cont) : span(cont.data(), cont.size())
     {
@@ -477,8 +533,8 @@ public:
     template <class Container,
               class = std::enable_if_t<
                   std::is_const<element_type>::value && !details::is_span<Container>::value &&
-                  std::is_convertible<Container::pointer, pointer>::value &&
-                  std::is_convertible<Container::pointer,
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
     constexpr span(const Container& cont) : span(cont.data(), cont.size())
     {
@@ -493,7 +549,7 @@ public:
             details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
     constexpr span(const span<OtherElementType, OtherExtent>& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
+        : storage_(reinterpret_cast<pointer>(other.data()), details::extent_type<OtherExtent>(other.size()))
     {
     }
 
@@ -503,7 +559,7 @@ public:
             details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
     constexpr span(span<OtherElementType, OtherExtent>&& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), extent_type<OtherExtent>(other.size()))
+        : storage_(reinterpret_cast<pointer>(other.data()), details::extent_type<OtherExtent>(other.size()))
     {
     }
 
@@ -512,25 +568,25 @@ public:
     constexpr span& operator=(span&& other) noexcept = default;
 
     // [span.sub], span subviews
-    template <ptrdiff_t Count>
+    template <std::ptrdiff_t Count>
     constexpr span<element_type, Count> first() const
     {
         Expects(Count >= 0 && Count <= size());
         return {data(), Count};
     }
 
-    template <ptrdiff_t Count>
+    template <std::ptrdiff_t Count>
     constexpr span<element_type, Count> last() const
     {
         Expects(Count >= 0 && Count <= size());
         return {data() + (size() - Count), Count};
     }
 
-    template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
+    template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent>
     constexpr span<element_type, Count> subspan() const
     {
-        Expects((Offset == 0 || Offset > 0 && Offset <= size()) &&
-                (Count == dynamic_extent || Count >= 0 && Offset + Count <= size()));
+        Expects((Offset == 0 || (Offset > 0 && Offset <= size())) &&
+                (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size())));
         return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
     }
 
@@ -549,8 +605,8 @@ public:
     constexpr span<element_type, dynamic_extent> subspan(index_type offset,
                                                          index_type count = dynamic_extent) const
     {
-        Expects((offset == 0 || offset > 0 && offset <= size()) &&
-                (count == dynamic_extent || count >= 0 && offset + count <= size()));
+        Expects((offset == 0 || (offset > 0 && offset <= size())) &&
+                (count == dynamic_extent || (count >= 0 && offset + count <= size())));
         return {data() + offset, count == dynamic_extent ? size() - offset : count};
     }
 
@@ -584,47 +640,6 @@ public:
     const_reverse_iterator crend() const noexcept { return reverse_iterator{{this, 0}}; }
 
 private:
-    template <index_type Extent>
-    class extent_type;
-
-    template <index_type Extent>
-    class extent_type
-    {
-    public:
-        static_assert(Extent >= 0, "A fixed-size span must be >= 0 in size.");
-
-        constexpr extent_type() noexcept {}
-
-        template <index_type Other>
-        constexpr extent_type(extent_type<Other> ext) noexcept
-        {
-            static_assert(Other == Extent || Other == dynamic_extent,
-                          "Mismatch between fixed-size extent and size of initializing data.");
-            Expects(ext.size() == Extent);
-        }
-
-        constexpr extent_type(index_type size) { Expects(size == Extent); }
-
-        constexpr inline index_type size() const noexcept { return Extent; }
-    };
-
-    template <>
-    class extent_type<dynamic_extent>
-    {
-    public:
-        template <index_type Other>
-        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
-        {
-        }
-
-        explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); }
-
-        constexpr inline index_type size() const noexcept { return size_; }
-
-    private:
-        index_type size_;
-    };
-
     // this implementation detail class lets us take advantage of the
     // empty base class optimization to pay for only storage of a single
     // pointer in the case of fixed-size spans
@@ -644,41 +659,41 @@ private:
         pointer data_;
     };
 
-    storage_type<extent_type<Extent>> storage_;
+    storage_type<details::extent_type<Extent>> storage_;
 };
 
 // [span.comparison], span comparison operators
-template <class ElementType, ptrdiff_t Extent>
-constexpr bool operator==(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
+template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent>
+constexpr bool operator==(const span<ElementType, FirstExtent>& l, const span<ElementType, SecondExtent>& r)
 {
     return std::equal(l.begin(), l.end(), r.begin(), r.end());
 }
 
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
 {
     return !(l == r);
 }
 
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
 {
     return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
 }
 
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
 {
     return !(l > r);
 }
 
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
 {
     return r < l;
 }
 
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r)
 {
     return !(l < r);
@@ -692,11 +707,11 @@ namespace details
     // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as
     // constexpr
     // and so will fail compilation of the template
-    template <class ElementType, ptrdiff_t Extent>
+    template <class ElementType, std::ptrdiff_t Extent>
     struct calculate_byte_size
         : std::integral_constant<std::ptrdiff_t,
-                                 static_cast<ptrdiff_t>(sizeof(ElementType) *
-                                                        static_cast<size_t>(Extent))>
+                                 static_cast<std::ptrdiff_t>(sizeof(ElementType) *
+                                                        static_cast<std::size_t>(Extent))>
     {
     };
 
@@ -708,14 +723,14 @@ namespace details
 }
 
 // [span.objectrep], views of object representation
-template <class ElementType, ptrdiff_t Extent>
+template <class ElementType, std::ptrdiff_t Extent>
 span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(span<ElementType, Extent> s) noexcept
 {
     return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }
 
-template <class ElementType, ptrdiff_t Extent,
+template <class ElementType, std::ptrdiff_t Extent,
           class = std::enable_if_t<!std::is_const<ElementType>::value>>
 span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writeable_bytes(span<ElementType, Extent> s) noexcept
diff --git a/include/string_span.h b/include/string_span.h
index bef8288..723f650 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -234,40 +234,39 @@ template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
 class basic_string_span
 {
 public:
-    using value_type = CharT;
-    using const_value_type = std::add_const_t<value_type>;
-    using pointer = std::add_pointer_t<value_type>;
-    using reference = std::add_lvalue_reference_t<value_type>;
-    using const_reference = std::add_lvalue_reference_t<const_value_type>;
-    using impl_type = span<value_type, Extent>;
+    using element_type = CharT;
+    using pointer = std::add_pointer_t<element_type>;
+    using reference = std::add_lvalue_reference_t<element_type>;
+    using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>;
+    using impl_type = span<element_type, Extent>;
 
-    using size_type = ptrdiff_t;
+    using index_type = typename impl_type::index_type;
     using iterator = typename impl_type::iterator;
     using const_iterator = typename impl_type::const_iterator;
     using reverse_iterator = typename impl_type::reverse_iterator;
     using const_reverse_iterator = typename impl_type::const_reverse_iterator;
 
     // default (empty)
-    constexpr basic_string_span() = default;
+    constexpr basic_string_span() noexcept = default;
 
     // copy
-    constexpr basic_string_span(const basic_string_span& other) = default;
+    constexpr basic_string_span(const basic_string_span& other) noexcept = default;
 
 // move
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
-    constexpr basic_string_span(basic_string_span&& other) = default;
+    constexpr basic_string_span(basic_string_span&& other) noexcept = default;
 #else
     constexpr basic_string_span(basic_string_span&& other) : span_(std::move(other.span_)) {}
 #endif
 
     // assign
-    constexpr basic_string_span& operator=(const basic_string_span& other) = default;
+    constexpr basic_string_span& operator=(const basic_string_span& other) noexcept = default;
 
 // move assign
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
-    constexpr basic_string_span& operator=(basic_string_span&& other) = default;
+    constexpr basic_string_span& operator=(basic_string_span&& other) noexcept = default;
 #else
-    constexpr basic_string_span& operator=(basic_string_span&& other)
+    constexpr basic_string_span& operator=(basic_string_span&& other) noexcept
     {
         span_ = std::move(other.span_);
         return *this;
@@ -277,47 +276,55 @@ public:
     // from nullptr
     constexpr basic_string_span(std::nullptr_t ptr) noexcept : span_(ptr) {}
 
-    // from nullptr and length
-    constexpr basic_string_span(std::nullptr_t ptr, size_type length) noexcept : span_(ptr, length)
-    {
-    }
+    constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {}
+    constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}
 
     // From static arrays - if 0-terminated, remove 0 from the view
-
-    // from static arrays and string literals
+    // All other containers allow 0s within the length, so we do not remove them
     template <size_t N>
-    constexpr basic_string_span(value_type (&arr)[N]) noexcept : span_(remove_z(arr))
+    constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
+    {
+    }
+    
+    template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept
+    : span_(arr) {}
+
+    template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept
+    : span_(arr) {}
+
+    // Container signature should work for basic_string after C++17 version exists
+    template <class Traits, class Allocator>
+    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
+    : span_(&str[0], str.length())
     {
     }
 
-    // Those allow 0s within the length, so we do not remove them
-
-    // from raw data and length
-    constexpr basic_string_span(pointer ptr, size_type length) noexcept : span_(ptr, length) {}
-
-    // from string
-    constexpr basic_string_span(std::string& s) noexcept
-        : span_(const_cast<pointer>(s.data()), narrow_cast<std::ptrdiff_t>(s.length()))
+    template <class Traits, class Allocator>
+    constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str)
+    : span_(&str[0], str.length())
     {
     }
 
-    // from containers. Containers must have .size() and .data() function signatures
-    template <typename Cont,
-              typename = std::enable_if_t<
-                  !details::is_basic_string_span<Cont>::value && !details::is_span<Cont>::value &&
-                  std::is_convertible<Cont::pointer, pointer>::value &&
-                  std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>>
-    constexpr basic_string_span(Cont& cont) : span_(cont.data(), cont.size())
+    // from containers. Containers must have a pointer type and data() function signatures
+    template <class Container,
+              class = std::enable_if_t<
+                  !details::is_basic_string_span<Container>::value &&
+                  !details::is_span<Container>::value &&
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer, decltype(std::declval<Container>().data())>::value>>
+    constexpr basic_string_span(Container& cont) : span_(cont)
     {
     }
 
-    // disallow creation from temporary containers and strings
-    template <typename Cont,
-              typename = std::enable_if_t<
-                  !details::is_basic_string_span<Cont>::value && !details::is_span<Cont>::value &&
-                  std::is_convertible<Cont::pointer, pointer>::value &&
-                  std::is_convertible<Cont::pointer, decltype(std::declval<Cont>().data())>::value>>
-    constexpr basic_string_span(const Cont& cont) : span_(cont.data(), cont.size())
+    template <class Container,
+              class = std::enable_if_t<
+                  !details::is_basic_string_span<Container>::value &&
+                  !details::is_span<Container>::value &&
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer, decltype(std::declval<Container>().data())>::value>>
+    constexpr basic_string_span(const Container& cont) : span_(cont)
     {
     }
 
@@ -326,109 +333,97 @@ public:
     template <typename OtherValueType, std::ptrdiff_t OtherExtent,
               typename Dummy = std::enable_if_t<
                   std::is_convertible<span<OtherValueType, OtherExtent>, impl_type>::value>>
-    constexpr basic_string_span(span<OtherValueType, OtherExtent> other) noexcept : span_(other)
+    constexpr basic_string_span(const span<OtherValueType, OtherExtent>& other) : span_(other)
     {
     }
 #else
     // from span
-    constexpr basic_string_span(span<value_type, Extent> other) noexcept : span_(other) {}
+    constexpr basic_string_span(span<element_type, Extent> other) : span_(other) {}
 
     template <typename = std::enable_if_t<
-                  !std::is_same<std::remove_const_t<value_type>, value_type>::value>>
-    constexpr basic_string_span(span<std::remove_const_t<value_type>, Extent> other) noexcept
+                  !std::is_same<std::remove_const_t<element_type>, value_type>::value>>
+    constexpr basic_string_span(const span<std::remove_const_t<element_type>, Extent>& other) 
         : span_(other)
     {
     }
 #endif
 
     // from string_span
-    template <typename OtherValueType, std::ptrdiff_t OtherExtent,
-              typename = std::enable_if_t<std::is_convertible<
-                  basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
-    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) noexcept
+    template <class OtherValueType, std::ptrdiff_t OtherExtent,
+              class = std::enable_if_t<std::is_convertible<
+                  typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
+    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) 
         : span_(other.data(), other.length())
     {
     }
 
-    constexpr bool empty() const noexcept { return length() == 0; }
-
     // first Count elements
-    template <size_type Count>
-    constexpr basic_string_span<value_type, Count> first() const noexcept
+    template <index_type Count>
+    constexpr basic_string_span<element_type, Count> first() const 
     {
         return {span_.template first<Count>()};
     }
 
-    constexpr basic_string_span<value_type, dynamic_extent> first(size_type count) const noexcept
+    constexpr basic_string_span<index_type, dynamic_extent> first(index_type count) const 
     {
         return {span_.first(count)};
     }
 
     // last Count elements
-    template <size_type Count>
-    constexpr basic_string_span<value_type, Count> last() const noexcept
+    template <index_type Count>
+    constexpr basic_string_span<index_type, Count> last() const 
     {
         return {span_.template last<Count>()};
     }
 
-    constexpr basic_string_span<value_type, dynamic_extent> last(size_type count) const noexcept
+    constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const 
     {
         return {span_.last(count)};
     }
 
-    // create a subview of Count elements starting from Offset
-    template <size_type Offset, size_type Count>
-    constexpr basic_string_span<value_type, Count> subspan() const noexcept
+    template <index_type Offset, index_type Count>
+    constexpr basic_string_span<element_type, Count> subspan() const 
     {
         return {span_.template subspan<Offset, Count>()};
     }
 
-    constexpr basic_string_span<value_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
+    constexpr basic_string_span<element_type, dynamic_extent>
+    subspan(index_type offset, index_type count = dynamic_extent) const 
     {
         return {span_.subspan(offset, count)};
     }
 
-    constexpr reference operator[](size_type idx) const noexcept { return span_[idx]; }
+    constexpr reference operator[](index_type idx) const { return span_[idx]; }
+    constexpr reference operator()(index_type idx) const { return span_[idx]; }
 
-    constexpr pointer data() const noexcept { return span_.data(); }
+    constexpr pointer data() const { return span_.data(); }
 
-    // length of the span in elements
-    constexpr size_type length() const noexcept { return span_.size(); }
-
-    // length of the span in elements
-    constexpr size_type size() const noexcept { return span_.size(); }
-
-    // length of the span in bytes
-    constexpr size_type size_bytes() const noexcept { return span_.size_bytes(); }
-
-    // length of the span in bytes
-    constexpr size_type length_bytes() const noexcept { return span_.length_bytes(); }
+    constexpr index_type length() const noexcept { return span_.size(); }
+    constexpr index_type size() const noexcept { return span_.size(); }
+    constexpr index_type size_bytes() const noexcept { return span_.size_bytes(); }
+    constexpr index_type length_bytes() const noexcept { return span_.length_bytes(); }
+    constexpr bool empty() const noexcept { return size() == 0; }
 
     constexpr iterator begin() const noexcept { return span_.begin(); }
-
     constexpr iterator end() const noexcept { return span_.end(); }
-
+    
     constexpr const_iterator cbegin() const noexcept { return span_.cbegin(); }
-
     constexpr const_iterator cend() const noexcept { return span_.cend(); }
-
+    
     constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); }
-
     constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
 
     constexpr const_reverse_iterator crbegin() const noexcept { return span_.crbegin(); }
-
     constexpr const_reverse_iterator crend() const noexcept { return span_.crend(); }
 
 private:
-    static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) noexcept
+    static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) 
     {
-        return {sz, details::length_func<value_type>()(sz, max)};
+        return {sz, details::length_func<element_type>()(sz, max)};
     }
 
     template <size_t N>
-    static impl_type remove_z(value_type (&sz)[N]) noexcept
+    static impl_type remove_z(element_type (&sz)[N]) 
     {
         return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N));
     }
@@ -453,7 +448,7 @@ using cwstring_span = basic_string_span<const wchar_t, Extent>;
 //
 #ifndef GSL_MSVC_HAS_TYPE_DEDUCTION_BUG
 
-template <typename CharT, ptrdiff_t Extent>
+template <typename CharT, std::ptrdiff_t Extent>
 std::basic_string<typename std::remove_const<CharT>::type>
 to_string(basic_string_span<CharT, Extent> view)
 {
@@ -559,15 +554,13 @@ using czstring_span = basic_zstring_span<const char, Max>;
 template <std::ptrdiff_t Max = dynamic_extent>
 using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
 
-} // namespace GSL
-
 // operator ==
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
+template <class CharT, std::ptrdiff_t Extent, class T,
+          class = std::enable_if_t<details::is_basic_string_span<T>::value || std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
+bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other) noexcept
 {
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
+    gsl::basic_string_span<std::add_const_t<CharT>> tmp(other);
 #ifdef GSL_MSVC_NO_CPP14_STD_EQUAL
     return (one.size() == tmp.size()) && std::equal(one.begin(), one.end(), tmp.begin());
 #else
@@ -576,13 +569,13 @@ bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexc
 }
 
 template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename Dummy = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
+    class CharT, std::ptrdiff_t Extent, class T,
+    class = std::enable_if_t<!details::is_basic_string_span<T>::value && 
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value 
+        >>
+bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other) noexcept
 {
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
+    gsl::basic_string_span<std::add_const_t<CharT>> tmp(one);
 #ifdef GSL_MSVC_NO_CPP14_STD_EQUAL
     return (tmp.size() == other.size()) && std::equal(tmp.begin(), tmp.end(), other.begin());
 #else
@@ -590,40 +583,6 @@ bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
 #endif
 }
 
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename Dummy = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator==(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
-{
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
-    return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename Dummy = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator==(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
-{
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
-    return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end());
-}
-#endif
-
 // operator !=
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
@@ -643,38 +602,6 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
     return !(one == other);
 }
 
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename Dummy = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept
-{
-    return !(one == other);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename Dummy = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept
-{
-    return !(one == other);
-}
-#endif
-
 // operator<
 template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
@@ -882,6 +809,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexc
     return !(one < other);
 }
 #endif
+} // namespace GSL
 
 #ifdef _MSC_VER
 
diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp
index f380be3..876886a 100644
--- a/tests/string_span_tests.cpp
+++ b/tests/string_span_tests.cpp
@@ -40,14 +40,14 @@ SUITE(string_span_tests)
     {
         std::string s = "Hello there world";
         cstring_span<> v = s;
-        CHECK(v.length() == static_cast<cstring_span<>::size_type>(s.length()));
+        CHECK(v.length() == static_cast<cstring_span<>::index_type>(s.length()));
     }
 
     TEST(TestConstructFromStdVector)
     {
         std::vector<char> vec(5, 'h');
         string_span<> v {vec};
-        CHECK(v.length() == static_cast<string_span<>::size_type>(vec.size()));
+        CHECK(v.length() == static_cast<string_span<>::index_type>(vec.size()));
     }
 
     TEST(TestStackArrayConstruction)
@@ -109,7 +109,7 @@ SUITE(string_span_tests)
         char stack_string[] = "Hello";
         cstring_span<> v = ensure_z(stack_string);
         auto s2 = gsl::to_string(v);
-        CHECK(static_cast<cstring_span<>::size_type>(s2.length()) == v.length());
+        CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length());
         CHECK(s2.length() == 5);
     }
 

From 4de3d4e3e314016ee910a21d7c040e343c9871fb Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 26 Jul 2016 18:44:13 -0700
Subject: [PATCH 33/42] Fixes for Clang 3.6 compilation.

---
 include/span.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/span.h b/include/span.h
index 27c479d..decc8e2 100644
--- a/include/span.h
+++ b/include/span.h
@@ -220,7 +220,7 @@ namespace details
 
         constexpr const_span_iterator operator+(difference_type n) const noexcept
         {
-            auto ret{*this};
+            auto ret = *this;
             return ret += n;
         }
 
@@ -233,7 +233,7 @@ namespace details
 
         constexpr const_span_iterator operator-(difference_type n) const noexcept
         {
-            auto ret{*this};
+            auto ret = *this;
             return ret -= n;
         }
 
@@ -650,7 +650,7 @@ private:
         template <class OtherExtentType>
         constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
         {
-            Expects((!data && size() == 0) || (data && size() >= 0));
+            Expects((!data && ExtentType::size() == 0) || (data && ExtentType::size() >= 0));
         }
 
         constexpr inline pointer data() const noexcept { return data_; }

From 6fadce975b95952f13ffafdcee88795222b711f3 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 26 Jul 2016 19:19:47 -0700
Subject: [PATCH 34/42] Applied clang-format.

---
 include/multi_span.h  | 15 ++++++----
 include/span.h        | 43 ++++++++++++++-------------
 include/string_span.h | 69 +++++++++++++++++++++++--------------------
 3 files changed, 69 insertions(+), 58 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index a63f8ce..cfe2d5c 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -740,7 +740,8 @@ public:
     }
 
     constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept
-        : m_extents(extents), m_strides(strides)
+        : m_extents(extents),
+          m_strides(strides)
     {
     }
 
@@ -837,7 +838,8 @@ public:
     using index_size_type = typename IndexType::value_type;
     template <typename Bounds>
     explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept
-        : boundary_(bnd.index_bounds()), curr_(std::move(curr))
+        : boundary_(bnd.index_bounds()),
+          curr_(std::move(curr))
     {
         static_assert(is_bounds<Bounds>::value, "Bounds type must be provided");
     }
@@ -1132,7 +1134,7 @@ namespace details
     template <typename T, typename Arg, typename... Args>
     std::enable_if_t<
         !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
-    static_as_span_helper(Arg, Args... args)
+        static_as_span_helper(Arg, Args... args)
     {
         return static_as_span_helper<T>(args...);
     }
@@ -1250,8 +1252,8 @@ public:
     }
 
     // construct from pointer + length - multidimensional
-    constexpr multi_span(pointer data, bounds_type bounds) noexcept
-        : data_(data), bounds_(std::move(bounds))
+    constexpr multi_span(pointer data, bounds_type bounds) noexcept : data_(data),
+                                                                      bounds_(std::move(bounds))
     {
         Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
     }
@@ -1347,7 +1349,8 @@ public:
               typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value &&
                                           std::is_convertible<OtherBounds, bounds_type>::value>>
     constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept
-        : data_(other.data_), bounds_(other.bounds_)
+        : data_(other.data_),
+          bounds_(other.bounds_)
     {
     }
 
diff --git a/include/span.h b/include/span.h
index decc8e2..4d8e877 100644
--- a/include/span.h
+++ b/include/span.h
@@ -120,30 +120,33 @@ namespace details
 
     template <class From, class To>
     struct is_allowed_pointer_conversion
-        : public std::integral_constant<bool, std::is_pointer<From>::value && std::is_pointer<To>::value &&
-                             std::is_convertible<From, To>::value>
+        : public std::integral_constant<bool, std::is_pointer<From>::value &&
+                                                  std::is_pointer<To>::value &&
+                                                  std::is_convertible<From, To>::value>
     {
     };
 
     template <class From, class To>
     struct is_allowed_integral_conversion
-        : public std::integral_constant<bool, std::is_integral<From>::value && std::is_integral<To>::value &&
-                             sizeof(From) == sizeof(To) && alignof(From) == alignof(To) &&
-                             std::is_convertible<From, To>::value>
+        : public std::integral_constant<
+              bool, std::is_integral<From>::value && std::is_integral<To>::value &&
+                        sizeof(From) == sizeof(To) && alignof(From) == alignof(To) &&
+                        std::is_convertible<From, To>::value>
     {
     };
 
     template <std::ptrdiff_t From, std::ptrdiff_t To>
     struct is_allowed_extent_conversion
-        : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || To == gsl::dynamic_extent>
+        : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent ||
+                                                  To == gsl::dynamic_extent>
     {
     };
 
     template <class From, class To>
     struct is_allowed_element_type_conversion
         : public std::integral_constant<bool, std::is_same<From, std::remove_cv_t<To>>::value ||
-                             is_allowed_pointer_conversion<From, To>::value ||
-                             is_allowed_integral_conversion<From, To>::value>
+                                                  is_allowed_pointer_conversion<From, To>::value ||
+                                                  is_allowed_integral_conversion<From, To>::value>
     {
     };
 
@@ -392,9 +395,7 @@ namespace details
 
         void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
     private:
-        constexpr span_iterator(const base_type& base) : base_type(base)
-        {
-        }
+        constexpr span_iterator(const base_type& base) : base_type(base) {}
     };
 
     template <typename Span>
@@ -431,7 +432,7 @@ namespace details
     class extent_type
     {
     public:
-	using index_type = std::ptrdiff_t;
+        using index_type = std::ptrdiff_t;
 
         static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size.");
 
@@ -454,7 +455,7 @@ namespace details
     class extent_type<dynamic_extent>
     {
     public:
-	using index_type = std::ptrdiff_t;
+        using index_type = std::ptrdiff_t;
 
         template <index_type Other>
         explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
@@ -504,7 +505,7 @@ public:
     constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], details::extent_type<N>())
     {
     }
-    
+
     template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
     constexpr span(std::array<ArrayElementType, N>& arr) noexcept
         : storage_(&arr[0], details::extent_type<N>())
@@ -521,8 +522,7 @@ public:
     // 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 && 
+                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
                   std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
@@ -549,7 +549,8 @@ public:
             details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
     constexpr span(const span<OtherElementType, OtherExtent>& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), details::extent_type<OtherExtent>(other.size()))
+        : storage_(reinterpret_cast<pointer>(other.data()),
+                   details::extent_type<OtherExtent>(other.size()))
     {
     }
 
@@ -559,7 +560,8 @@ public:
             details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
             details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
     constexpr span(span<OtherElementType, OtherExtent>&& other)
-        : storage_(reinterpret_cast<pointer>(other.data()), details::extent_type<OtherExtent>(other.size()))
+        : storage_(reinterpret_cast<pointer>(other.data()),
+                   details::extent_type<OtherExtent>(other.size()))
     {
     }
 
@@ -664,7 +666,8 @@ private:
 
 // [span.comparison], span comparison operators
 template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent>
-constexpr bool operator==(const span<ElementType, FirstExtent>& l, const span<ElementType, SecondExtent>& r)
+constexpr bool operator==(const span<ElementType, FirstExtent>& l,
+                          const span<ElementType, SecondExtent>& r)
 {
     return std::equal(l.begin(), l.end(), r.begin(), r.end());
 }
@@ -711,7 +714,7 @@ namespace details
     struct calculate_byte_size
         : std::integral_constant<std::ptrdiff_t,
                                  static_cast<std::ptrdiff_t>(sizeof(ElementType) *
-                                                        static_cast<std::size_t>(Extent))>
+                                                             static_cast<std::size_t>(Extent))>
     {
     };
 
diff --git a/include/string_span.h b/include/string_span.h
index 723f650..1df7e6e 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -285,25 +285,27 @@ public:
     constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
     {
     }
-    
-    template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept
-    : span_(arr) {}
 
     template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept
-    : span_(arr) {}
+    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
+    {
+    }
+
+    template <size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
+    {
+    }
 
     // Container signature should work for basic_string after C++17 version exists
     template <class Traits, class Allocator>
     constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
-    : span_(&str[0], str.length())
+        : span_(&str[0], str.length())
     {
     }
 
     template <class Traits, class Allocator>
     constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str)
-    : span_(&str[0], str.length())
+        : span_(&str[0], str.length())
     {
     }
 
@@ -313,7 +315,8 @@ public:
                   !details::is_basic_string_span<Container>::value &&
                   !details::is_span<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer, decltype(std::declval<Container>().data())>::value>>
+                  std::is_convertible<typename Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
     constexpr basic_string_span(Container& cont) : span_(cont)
     {
     }
@@ -323,7 +326,8 @@ public:
                   !details::is_basic_string_span<Container>::value &&
                   !details::is_span<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer, decltype(std::declval<Container>().data())>::value>>
+                  std::is_convertible<typename Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
     constexpr basic_string_span(const Container& cont) : span_(cont)
     {
     }
@@ -342,53 +346,54 @@ public:
 
     template <typename = std::enable_if_t<
                   !std::is_same<std::remove_const_t<element_type>, value_type>::value>>
-    constexpr basic_string_span(const span<std::remove_const_t<element_type>, Extent>& other) 
+    constexpr basic_string_span(const span<std::remove_const_t<element_type>, Extent>& other)
         : span_(other)
     {
     }
 #endif
 
     // from string_span
-    template <class OtherValueType, std::ptrdiff_t OtherExtent,
-              class = std::enable_if_t<std::is_convertible<
-                  typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
-    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) 
+    template <
+        class OtherValueType, std::ptrdiff_t OtherExtent,
+        class = std::enable_if_t<std::is_convertible<
+            typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
+    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other)
         : span_(other.data(), other.length())
     {
     }
 
     // first Count elements
     template <index_type Count>
-    constexpr basic_string_span<element_type, Count> first() const 
+    constexpr basic_string_span<element_type, Count> first() const
     {
         return {span_.template first<Count>()};
     }
 
-    constexpr basic_string_span<index_type, dynamic_extent> first(index_type count) const 
+    constexpr basic_string_span<index_type, dynamic_extent> first(index_type count) const
     {
         return {span_.first(count)};
     }
 
     // last Count elements
     template <index_type Count>
-    constexpr basic_string_span<index_type, Count> last() const 
+    constexpr basic_string_span<index_type, Count> last() const
     {
         return {span_.template last<Count>()};
     }
 
-    constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const 
+    constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const
     {
         return {span_.last(count)};
     }
 
     template <index_type Offset, index_type Count>
-    constexpr basic_string_span<element_type, Count> subspan() const 
+    constexpr basic_string_span<element_type, Count> subspan() const
     {
         return {span_.template subspan<Offset, Count>()};
     }
 
     constexpr basic_string_span<element_type, dynamic_extent>
-    subspan(index_type offset, index_type count = dynamic_extent) const 
+    subspan(index_type offset, index_type count = dynamic_extent) const
     {
         return {span_.subspan(offset, count)};
     }
@@ -406,10 +411,10 @@ public:
 
     constexpr iterator begin() const noexcept { return span_.begin(); }
     constexpr iterator end() const noexcept { return span_.end(); }
-    
+
     constexpr const_iterator cbegin() const noexcept { return span_.cbegin(); }
     constexpr const_iterator cend() const noexcept { return span_.cend(); }
-    
+
     constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); }
     constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
 
@@ -417,13 +422,13 @@ public:
     constexpr const_reverse_iterator crend() const noexcept { return span_.crend(); }
 
 private:
-    static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) 
+    static impl_type remove_z(pointer const& sz, std::ptrdiff_t max)
     {
         return {sz, details::length_func<element_type>()(sz, max)};
     }
 
     template <size_t N>
-    static impl_type remove_z(element_type (&sz)[N]) 
+    static impl_type remove_z(element_type (&sz)[N])
     {
         return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N));
     }
@@ -556,8 +561,9 @@ using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
 
 // operator ==
 template <class CharT, std::ptrdiff_t Extent, class T,
-          class = std::enable_if_t<details::is_basic_string_span<T>::value || std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
+          class = std::enable_if_t<
+              details::is_basic_string_span<T>::value ||
+              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
 bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>> tmp(other);
@@ -568,11 +574,10 @@ bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other
 #endif
 }
 
-template <
-    class CharT, std::ptrdiff_t Extent, class T,
-    class = std::enable_if_t<!details::is_basic_string_span<T>::value && 
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value 
-        >>
+template <class CharT, std::ptrdiff_t Extent, class T,
+          class = std::enable_if_t<
+              !details::is_basic_string_span<T>::value &&
+              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
 bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other) noexcept
 {
     gsl::basic_string_span<std::add_const_t<CharT>> tmp(one);

From a88cfb168a32c2bccccd4ad698c6787e77ad6a4d Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Wed, 27 Jul 2016 13:48:29 -0700
Subject: [PATCH 35/42] Fixed type-name mixup in string_span.

---
 include/string_span.h | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/include/string_span.h b/include/string_span.h
index 1df7e6e..0ca3c51 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -362,21 +362,19 @@ public:
     {
     }
 
-    // first Count elements
     template <index_type Count>
     constexpr basic_string_span<element_type, Count> first() const
     {
         return {span_.template first<Count>()};
     }
 
-    constexpr basic_string_span<index_type, dynamic_extent> first(index_type count) const
+    constexpr basic_string_span<element_type, dynamic_extent> first(index_type count) const
     {
         return {span_.first(count)};
     }
 
-    // last Count elements
     template <index_type Count>
-    constexpr basic_string_span<index_type, Count> last() const
+    constexpr basic_string_span<element_type, Count> last() const
     {
         return {span_.template last<Count>()};
     }

From a0cf1ecc499b9a5609dd3436c5d83d08a3377f9d Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Thu, 28 Jul 2016 17:27:22 -0700
Subject: [PATCH 36/42] Renamed as_span() to as_multi_span() for clarity.

---
 include/multi_span.h         | 44 +++++++++++-----------
 tests/multi_span_tests.cpp   | 72 ++++++++++++++++++------------------
 tests/strided_span_tests.cpp | 40 ++++++++++----------
 3 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index cfe2d5c..a59c4dc 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -1127,25 +1127,25 @@ namespace details
     };
 
     template <typename T, typename... Args>
-    T static_as_span_helper(Sep, Args... args)
+    T static_as_multi_span_helper(Sep, Args... args)
     {
         return T{narrow_cast<typename T::size_type>(args)...};
     }
     template <typename T, typename Arg, typename... Args>
     std::enable_if_t<
         !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
-        static_as_span_helper(Arg, Args... args)
+        static_as_multi_span_helper(Arg, Args... args)
     {
-        return static_as_span_helper<T>(args...);
+        return static_as_multi_span_helper<T>(args...);
     }
     template <typename T, typename... Args>
-    T static_as_span_helper(dim<dynamic_range> val, Args... args)
+    T static_as_multi_span_helper(dim<dynamic_range> val, Args... args)
     {
-        return static_as_span_helper<T>(args..., val.dvalue);
+        return static_as_multi_span_helper<T>(args..., val.dvalue);
     }
 
     template <typename... Dimensions>
-    struct static_as_span_static_bounds_helper
+    struct static_as_multi_span_static_bounds_helper
     {
         using type = static_bounds<(Dimensions::value)...>;
     };
@@ -1599,13 +1599,13 @@ public:
 template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2),
           bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
 constexpr multi_span<typename SpanType::value_type, Dimensions2::value...>
-as_span(SpanType s, Dimensions2... dims)
+as_multi_span(SpanType s, Dimensions2... dims)
 {
     static_assert(details::is_multi_span<SpanType>::value,
-                  "Variadic as_span() is for reshaping existing spans.");
+                  "Variadic as_multi_span() is for reshaping existing spans.");
     using BoundsType =
         typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
-    auto tobounds = details::static_as_span_helper<BoundsType>(dims..., details::Sep{});
+    auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{});
     details::verifyBoundsReshape(s.bounds(), tobounds);
     return {s.data(), tobounds};
 }
@@ -1636,7 +1636,7 @@ multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span<
+constexpr auto as_multi_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span<
     const U, static_cast<std::ptrdiff_t>(
                  multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
                      ? (static_cast<size_t>(
@@ -1661,7 +1661,7 @@ constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept -> mult
 // on all implementations. It should be considered an experimental extension
 // to the standard GSL interface.
 template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept
+constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) noexcept
     -> multi_span<U, narrow_cast<std::ptrdiff_t>(
                          multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
                              ? static_cast<std::size_t>(
@@ -1682,49 +1682,49 @@ constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept
 }
 
 template <typename T, std::ptrdiff_t... Dimensions>
-constexpr auto as_span(T* const& ptr, dim<Dimensions>... args)
+constexpr auto as_multi_span(T* const& ptr, dim<Dimensions>... args)
     -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
 {
     return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
-            details::static_as_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})};
+            details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})};
 }
 
 template <typename T>
-constexpr auto as_span(T* arr, std::ptrdiff_t len) ->
+constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) ->
     typename details::SpanArrayTraits<T, dynamic_range>::type
 {
     return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
 }
 
 template <typename T, size_t N>
-constexpr auto as_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
+constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
 {
     return {arr};
 }
 
 template <typename T, size_t N>
-constexpr multi_span<const T, N> as_span(const std::array<T, N>& arr)
+constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr)
 {
     return {arr};
 }
 
 template <typename T, size_t N>
-constexpr multi_span<const T, N> as_span(const std::array<T, N>&&) = delete;
+constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete;
 
 template <typename T, size_t N>
-constexpr multi_span<T, N> as_span(std::array<T, N>& arr)
+constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr)
 {
     return {arr};
 }
 
 template <typename T>
-constexpr multi_span<T, dynamic_range> as_span(T* begin, T* end)
+constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end)
 {
     return {begin, end};
 }
 
 template <typename Cont>
-constexpr auto as_span(Cont& arr) -> std::enable_if_t<
+constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t<
     !details::is_multi_span<std::decay_t<Cont>>::value,
     multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
 {
@@ -1733,13 +1733,13 @@ constexpr auto as_span(Cont& arr) -> std::enable_if_t<
 }
 
 template <typename Cont>
-constexpr auto as_span(Cont&& arr) -> std::enable_if_t<
+constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t<
     !details::is_multi_span<std::decay_t<Cont>>::value,
     multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
 
 // from basic_string which doesn't have nonconst .data() member like other contiguous containers
 template <typename CharT, typename Traits, typename Allocator>
-constexpr auto as_span(std::basic_string<CharT, Traits, Allocator>& str)
+constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
     -> multi_span<CharT, dynamic_range>
 {
     Expects(str.size() < PTRDIFF_MAX);
diff --git a/tests/multi_span_tests.cpp b/tests/multi_span_tests.cpp
index 207428d..7432057 100644
--- a/tests/multi_span_tests.cpp
+++ b/tests/multi_span_tests.cpp
@@ -680,22 +680,22 @@ SUITE(multi_span_tests)
     {
         static_assert(Bounds::static_size == 60, "static bounds is wrong size");
     }
-    TEST(as_span_reshape)
+    TEST(as_multi_span_reshape)
     {
         int a[3][4][5];
-        auto av = as_span(a);
+        auto av = as_multi_span(a);
         fn(av.bounds());
-        auto av2 = as_span(av, dim<60>());
-        auto av3 = as_span(av2, dim<3>(), dim<4>(), dim<5>());
-        auto av4 = as_span(av3, dim<4>(), dim<>(3), dim<5>());
-        auto av5 = as_span(av4, dim<3>(), dim<4>(), dim<5>());
-        auto av6 = as_span(av5, dim<12>(), dim<>(5));
+        auto av2 = as_multi_span(av, dim<60>());
+        auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>());
+        auto av4 = as_multi_span(av3, dim<4>(), dim<>(3), dim<5>());
+        auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>());
+        auto av6 = as_multi_span(av5, dim<12>(), dim<>(5));
 
         fill(av6.begin(), av6.end(), 1);
 
         auto av7 = as_bytes(av6);
 
-        auto av8 = as_span<int>(av7);
+        auto av8 = as_multi_span<int>(av7);
 
         CHECK(av8.size() == av6.size());
         for (auto i = 0; i < av8.size(); i++) {
@@ -949,12 +949,12 @@ SUITE(multi_span_tests)
     {
         {
             int arr[10][2];
-            auto s1 = as_span(arr);
+            auto s1 = as_multi_span(arr);
             multi_span<const int, dynamic_range, 2> s2 = s1;
 
             CHECK(s1 == s2);
 
-            multi_span<int, 20> s3 = as_span(s1, dim<>(20));
+            multi_span<int, 20> s3 = as_multi_span(s1, dim<>(20));
             CHECK(s3 == s2 && s3 == s1);
         }
 
@@ -1059,7 +1059,7 @@ SUITE(multi_span_tests)
 
     TEST(basics)
     {
-        auto ptr = as_span(new int[10], 10);
+        auto ptr = as_multi_span(new int[10], 10);
         fill(ptr.begin(), ptr.end(), 99);
         for (int num : ptr) {
             CHECK(num == 99);
@@ -1071,7 +1071,7 @@ SUITE(multi_span_tests)
     TEST(bounds_checks)
     {
         int arr[10][2];
-        auto av = as_span(arr);
+        auto av = as_multi_span(arr);
 
         fill(begin(av), end(av), 0);
 
@@ -1111,7 +1111,7 @@ SUITE(multi_span_tests)
     {
         auto data = new int[4][3][5];
 
-        auto av = as_span(data, 4);
+        auto av = as_multi_span(data, 4);
 
         CHECK(av.size() == 60);
 
@@ -1122,7 +1122,7 @@ SUITE(multi_span_tests)
         CHECK(count == 34 * 60);
         overloaded_func(av, 34);
 
-        overloaded_func(as_span(av, dim<>(4), dim<>(3), dim<>(5)), 34);
+        overloaded_func(as_multi_span(av, dim<>(4), dim<>(3), dim<>(5)), 34);
 
         // fixed_func(av, 34);
         delete[] data;
@@ -1137,7 +1137,7 @@ SUITE(multi_span_tests)
 
         // size check will be done
         auto image_view =
-            as_span(as_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>());
+            as_multi_span(as_multi_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>());
 
         iota(image_view.begin(), image_view.end(), 1);
 
@@ -1160,12 +1160,12 @@ SUITE(multi_span_tests)
         }
     }
 
-    TEST(as_span)
+    TEST(as_multi_span)
     {
         {
             int* arr = new int[150];
 
-            auto av = as_span(arr, dim<10>(), dim<>(3), dim<5>());
+            auto av = as_multi_span(arr, dim<10>(), dim<>(3), dim<5>());
 
             fill(av.begin(), av.end(), 24);
             overloaded_func(av, 24);
@@ -1173,44 +1173,44 @@ SUITE(multi_span_tests)
             delete[] arr;
 
             array<int, 15> stdarr{0};
-            auto av2 = as_span(stdarr);
-            overloaded_func(as_span(av2, dim<>(1), dim<3>(), dim<5>()), 0);
+            auto av2 = as_multi_span(stdarr);
+            overloaded_func(as_multi_span(av2, dim<>(1), dim<3>(), dim<5>()), 0);
 
             string str = "ttttttttttttttt"; // size = 15
             auto t = str.data();
             (void) t;
-            auto av3 = as_span(str);
-            overloaded_func(as_span(av3, dim<>(1), dim<3>(), dim<5>()), 't');
+            auto av3 = as_multi_span(str);
+            overloaded_func(as_multi_span(av3, dim<>(1), dim<3>(), dim<5>()), 't');
         }
 
         {
             string str;
-            multi_span<char> strspan = as_span(str);
+            multi_span<char> strspan = as_multi_span(str);
             (void) strspan;
             const string cstr;
-            multi_span<const char> cstrspan = as_span(cstr);
+            multi_span<const char> cstrspan = as_multi_span(cstr);
             (void) cstrspan;
         }
 
         {
             int a[3][4][5];
-            auto av = as_span(a);
+            auto av = as_multi_span(a);
             const int(*b)[4][5];
             b = a;
-            auto bv = as_span(b, 3);
+            auto bv = as_multi_span(b, 3);
 
             CHECK(av == bv);
 
             const std::array<double, 3> arr = {0.0, 0.0, 0.0};
-            auto cv = as_span(arr);
+            auto cv = as_multi_span(arr);
             (void) cv;
 
             vector<float> vec(3);
-            auto dv = as_span(vec);
+            auto dv = as_multi_span(vec);
             (void) dv;
 
 #ifdef CONFIRM_COMPILATION_ERRORS
-            auto dv2 = as_span(std::move(vec));
+            auto dv2 = as_multi_span(std::move(vec));
 #endif
         }
     }
@@ -1258,7 +1258,7 @@ SUITE(multi_span_tests)
 
         CHECK(av[i] == 4);
 
-        auto av2 = as_span(av, dim<4>(), dim<>(2));
+        auto av2 = as_multi_span(av, dim<4>(), dim<>(2));
         ptrdiff_t a2[2] = {0, 1};
         index<2> i2 = a2;
 
@@ -1486,21 +1486,21 @@ SUITE(multi_span_tests)
             arr[i] = i;
         }
 
-        auto av = as_span(arr, size);
+        auto av = as_multi_span(arr, size);
 
         // first bound is dynamic
         {
-            multi_span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
         // second bound is dynamic
         {
-            multi_span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
         // both bounds are dynamic
         {
-            multi_span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width));
             iterate_second_column(av2);
         }
 
@@ -1521,7 +1521,7 @@ SUITE(multi_span_tests)
 
         CHECK_THROW(av1[10][3][4], fail_fast);
 
-        multi_span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>());
+        multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim<>(5), dim<6>(), dim<4>());
         (void) av2;
     }
 
@@ -1562,13 +1562,13 @@ SUITE(multi_span_tests)
 #ifdef CONFIRM_COMPILATION_ERRORS
         {
             multi_span<int, dynamic_range> av = arr;
-            multi_span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>());
+            multi_span<int, 2, 1> av2 = av.as_multi_span(dim<2>(), dim<2>());
         }
 #endif
 
         {
             multi_span<int, dynamic_range> av = arr;
-            multi_span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2));
+            multi_span<int, 2, 1> av2 = as_multi_span(av, dim<>(2), dim<>(2));
             auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
             CHECK(workaround_macro());
         }
diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp
index 9fcdfeb..19056b1 100644
--- a/tests/strided_span_tests.cpp
+++ b/tests/strided_span_tests.cpp
@@ -39,7 +39,7 @@ SUITE(strided_span_tests)
 	{
 		int a[30][4][5];
 		
-		auto av = as_span(a);
+		auto av = as_multi_span(a);
 		auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2});
 		auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1});
 		(void)subsub;
@@ -49,7 +49,7 @@ SUITE(strided_span_tests)
 	{
 		std::vector<int> data(5 * 10);
 		std::iota(begin(data), end(data), 0);
-        const multi_span<int, 5, 10> av = as_span(multi_span<int>{data}, dim<5>(), dim<10>());
+        const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());
 
 		strided_span<int, 2> av_section_1 = av.section({ 1, 2 }, { 3, 4 });
 		CHECK((av_section_1[{0, 0}] == 12));
@@ -258,7 +258,7 @@ SUITE(strided_span_tests)
 	{
 		std::vector<int> data(5 * 10);
 		std::iota(begin(data), end(data), 0);
-        const multi_span<int, 5, 10> src = as_span(multi_span<int>{data}, dim<5>(), dim<10>());
+        const multi_span<int, 5, 10> src = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());
 
 		const strided_span<int, 2> sav{ src, {{5, 10}, {10, 1}} };
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -413,18 +413,18 @@ SUITE(strided_span_tests)
 			strided_span<int, 1> sav2{ arr, { 1,1,1 } };
 			strided_span<int, 1> sav3{ av, { 1 } };
 			strided_span<int, 1> sav4{ av, { 1,1,1 } };
-			strided_span<int, 2> sav5{ av.as_span(dim<2>(), dim<2>()), { 1 } };
-			strided_span<int, 2> sav6{ av.as_span(dim<2>(), dim<2>()), { 1,1,1 } };
-			strided_span<int, 2> sav7{ av.as_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } };
+			strided_span<int, 2> sav5{ av.as_multi_span(dim<2>(), dim<2>()), { 1 } };
+			strided_span<int, 2> sav6{ av.as_multi_span(dim<2>(), dim<2>()), { 1,1,1 } };
+			strided_span<int, 2> sav7{ av.as_multi_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } };
 
 			index<1> index{ 0, 1 };
 			strided_span<int, 1> sav8{ arr,{ 1,{ 1,1 } } };
 			strided_span<int, 1> sav9{ arr,{ { 1,1 },{ 1,1 } } };
 			strided_span<int, 1> sav10{ av,{ 1,{ 1,1 } } };
 			strided_span<int, 1> sav11{ av,{ { 1,1 },{ 1,1 } } };
-			strided_span<int, 2> sav12{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } };
-			strided_span<int, 2> sav13{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } };
-			strided_span<int, 2> sav14{ av.as_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } };
+			strided_span<int, 2> sav12{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } };
+			strided_span<int, 2> sav13{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } };
+			strided_span<int, 2> sav14{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } };
 		}
 #endif
 	}
@@ -463,7 +463,7 @@ SUITE(strided_span_tests)
 		// retype strided array with regular strides - from multi_span
 		{
 			strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
 			CHECK(sav3[0][0] == 0);
@@ -475,7 +475,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension of the array is too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -483,7 +483,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides are too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -491,7 +491,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -499,7 +499,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -606,7 +606,7 @@ SUITE(strided_span_tests)
             arr[2 * i + 1] = i;
         }
 
-        auto av = as_span(arr, 8);
+        auto av = as_multi_span(arr, 8);
         iterate_every_other_element(av);
 
         delete[] arr;
@@ -670,22 +670,22 @@ SUITE(strided_span_tests)
         }
 
         {
-            auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<2>());
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>());
             iterate_second_slice(av);
         }
 
         {
-            auto av = as_span(as_span(arr, 24), dim<>(3), dim<4>(), dim<2>());
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<>(3), dim<4>(), dim<2>());
             iterate_second_slice(av);
         }
 
         {
-            auto av = as_span(as_span(arr, 24), dim<3>(), dim<>(4), dim<2>());
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<>(4), dim<2>());
             iterate_second_slice(av);
         }
 
         {
-            auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<>(2));
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<>(2));
             iterate_second_slice(av);
         }
         delete[] arr;
@@ -704,7 +704,7 @@ SUITE(strided_span_tests)
         auto d1 = sizeof(int) * 12 / d2;
 
         // convert to 4x12 array of bytes
-        auto av = as_span(as_bytes(as_span(arr, 4)), dim<>(d1), dim<>(d2));
+        auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim<>(d1), dim<>(d2));
 
         CHECK(av.bounds().index_bounds()[0] == 4);
         CHECK(av.bounds().index_bounds()[1] == 12);

From 8e31f53f8a3132c497363bd87f03204d3d7969af Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Fri, 29 Jul 2016 11:16:06 -0700
Subject: [PATCH 37/42] Building clean with MSVC12.

---
 include/multi_span.h  |  7 ++++---
 include/span.h        | 22 ++++++++++++++++++++--
 include/string_span.h | 23 +----------------------
 tests/span_tests.cpp  |  8 ++++++++
 tests/utils_tests.cpp |  2 +-
 5 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index a59c4dc..e35fc33 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -1594,12 +1594,13 @@ public:
 // Free functions for manipulating spans
 //
 
+
 // reshape a multi_span into a different dimensionality
 // DimCount and Enabled here are workarounds for a bug in MSVC 2015
 template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2),
-          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
-constexpr multi_span<typename SpanType::value_type, Dimensions2::value...>
-as_multi_span(SpanType s, Dimensions2... dims)
+          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled> >
+constexpr auto
+as_multi_span(SpanType s, Dimensions2... dims) -> multi_span<typename SpanType::value_type, Dimensions2::value...>
 {
     static_assert(details::is_multi_span<SpanType>::value,
                   "Variadic as_multi_span() is for reshaping existing spans.");
diff --git a/include/span.h b/include/span.h
index 4d8e877..44e1b8d 100644
--- a/include/span.h
+++ b/include/span.h
@@ -49,7 +49,8 @@
 #if _MSC_VER <= 1800
 
 #define GSL_MSVC_HAS_VARIADIC_CTOR_BUG
-#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT
+#define GSL_MSVC_NO_DEFAULT_MOVE_CTOR
+#define GSL_MSVC_NO_CPP14_STD_EQUAL
 
 // noexcept is not understood
 #ifndef GSL_THROW_ON_CONTRACT_VIOLATION
@@ -57,6 +58,9 @@
 #define noexcept /* nothing */
 #endif
 
+#pragma push_macro("alignof")
+#define alignof __alignof
+
 // turn off some misguided warnings
 #pragma warning(push)
 #pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior
@@ -541,7 +545,11 @@ public:
     }
 
     constexpr span(const span& other) noexcept = default;
+#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr span(span&& other) noexcept = default;
+#else
+    constexpr span(span&& other) noexcept : storage_(std::move(other.storage_)) {}
+#endif
 
     template <
         class OtherElementType, std::ptrdiff_t OtherExtent,
@@ -567,8 +575,12 @@ public:
 
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
-    constexpr span& operator=(span&& other) noexcept = default;
 
+#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
+    constexpr span& operator=(span&& other) noexcept = default;
+#else
+    constexpr span& operator=(span&& other) noexcept { storage_ = std::move(other.storage_); return *this; }
+#endif
     // [span.sub], span subviews
     template <std::ptrdiff_t Count>
     constexpr span<element_type, Count> first() const
@@ -669,7 +681,11 @@ template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondEx
 constexpr bool operator==(const span<ElementType, FirstExtent>& l,
                           const span<ElementType, SecondExtent>& r)
 {
+#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL
+    return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin());
+#else
     return std::equal(l.begin(), l.end(), r.begin(), r.end());
+#endif
 }
 
 template <class ElementType, std::ptrdiff_t Extent>
@@ -756,6 +772,8 @@ as_writeable_bytes(span<ElementType, Extent> s) noexcept
 #pragma pop_macro("noexcept")
 #endif // GSL_THROW_ON_CONTRACT_VIOLATION
 
+#pragma pop_macro("alignof")
+
 #undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG
 
 #endif // _MSC_VER <= 1800
diff --git a/include/string_span.h b/include/string_span.h
index 0ca3c51..3fe826f 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -24,6 +24,7 @@
 #include "span.h"
 #include <cstring>
 #include <string>
+#include <cstdint>
 
 #ifdef _MSC_VER
 
@@ -313,7 +314,6 @@ public:
     template <class Container,
               class = std::enable_if_t<
                   !details::is_basic_string_span<Container>::value &&
-                  !details::is_span<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
                   std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
@@ -324,7 +324,6 @@ public:
     template <class Container,
               class = std::enable_if_t<
                   !details::is_basic_string_span<Container>::value &&
-                  !details::is_span<Container>::value &&
                   std::is_convertible<typename Container::pointer, pointer>::value &&
                   std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
@@ -332,26 +331,6 @@ public:
     {
     }
 
-#ifndef GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE
-    // from span
-    template <typename OtherValueType, std::ptrdiff_t OtherExtent,
-              typename Dummy = std::enable_if_t<
-                  std::is_convertible<span<OtherValueType, OtherExtent>, impl_type>::value>>
-    constexpr basic_string_span(const span<OtherValueType, OtherExtent>& other) : span_(other)
-    {
-    }
-#else
-    // from span
-    constexpr basic_string_span(span<element_type, Extent> other) : span_(other) {}
-
-    template <typename = std::enable_if_t<
-                  !std::is_same<std::remove_const_t<element_type>, value_type>::value>>
-    constexpr basic_string_span(const span<std::remove_const_t<element_type>, Extent>& other)
-        : span_(other)
-    {
-    }
-#endif
-
     // from string_span
     template <
         class OtherValueType, std::ptrdiff_t OtherExtent,
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 77b799a..8c9829d 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -839,7 +839,9 @@ SUITE(span_tests)
             CHECK(it - beyond == 0);
 
             for (auto& n : s)
+            {
                 CHECK(n == 5);
+            }
         }
     }
 
@@ -881,7 +883,9 @@ SUITE(span_tests)
             CHECK(it - beyond == 0);
 
             for (auto& n : s)
+            {
                 CHECK(n == 5);
+            }
         }
     }
 
@@ -923,7 +927,9 @@ SUITE(span_tests)
             CHECK(it - beyond == 0);
 
             for (auto& n : s)
+            {
                 CHECK(n == 5);
+            }
         }
     }
 
@@ -965,7 +971,9 @@ SUITE(span_tests)
             CHECK(it - beyond == 0);
 
             for (auto& n : s)
+            {
                 CHECK(n == 5);
+            }
         }
     }
 
diff --git a/tests/utils_tests.cpp b/tests/utils_tests.cpp
index a46d6e4..11582de 100644
--- a/tests/utils_tests.cpp
+++ b/tests/utils_tests.cpp
@@ -103,7 +103,7 @@ SUITE(utils_tests)
 
         CHECK(narrow<uint32_t>(int32_t(0)) == 0);
         CHECK(narrow<uint32_t>(int32_t(1)) == 1);
-        CHECK(narrow<uint32_t>(int32_max) == int32_max);
+        CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
 
         CHECK_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
         CHECK_THROW(narrow<uint32_t>(int32_min), narrowing_error);

From 1bd2d04c2e76f0eed41507d830070e2499b1290d Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 1 Aug 2016 13:10:02 -0700
Subject: [PATCH 38/42] Another round of clang-formatting.

---
 include/multi_span.h  | 10 +++++-----
 include/span.h        |  6 +++++-
 include/string_span.h |  2 +-
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index e35fc33..a8a1af2 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -1594,13 +1594,12 @@ public:
 // Free functions for manipulating spans
 //
 
-
 // reshape a multi_span into a different dimensionality
 // DimCount and Enabled here are workarounds for a bug in MSVC 2015
 template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2),
-          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled> >
-constexpr auto
-as_multi_span(SpanType s, Dimensions2... dims) -> multi_span<typename SpanType::value_type, Dimensions2::value...>
+          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
+constexpr auto as_multi_span(SpanType s, Dimensions2... dims)
+    -> multi_span<typename SpanType::value_type, Dimensions2::value...>
 {
     static_assert(details::is_multi_span<SpanType>::value,
                   "Variadic as_multi_span() is for reshaping existing spans.");
@@ -1687,7 +1686,8 @@ constexpr auto as_multi_span(T* const& ptr, dim<Dimensions>... args)
     -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
 {
     return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
-            details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})};
+            details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args...,
+                                                                               details::Sep{})};
 }
 
 template <typename T>
diff --git a/include/span.h b/include/span.h
index 44e1b8d..98e08fd 100644
--- a/include/span.h
+++ b/include/span.h
@@ -579,7 +579,11 @@ public:
 #ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR
     constexpr span& operator=(span&& other) noexcept = default;
 #else
-    constexpr span& operator=(span&& other) noexcept { storage_ = std::move(other.storage_); return *this; }
+    constexpr span& operator=(span&& other) noexcept
+    {
+        storage_ = std::move(other.storage_);
+        return *this;
+    }
 #endif
     // [span.sub], span subviews
     template <std::ptrdiff_t Count>
diff --git a/include/string_span.h b/include/string_span.h
index 3fe826f..e18e07a 100644
--- a/include/string_span.h
+++ b/include/string_span.h
@@ -22,9 +22,9 @@
 #include "gsl_assert.h"
 #include "gsl_util.h"
 #include "span.h"
+#include <cstdint>
 #include <cstring>
 #include <string>
-#include <cstdint>
 
 #ifdef _MSC_VER
 

From 94afa1fbd7e11dabe2e2eff100c7588e37ae3cf6 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 1 Aug 2016 18:49:48 -0700
Subject: [PATCH 39/42] Removed unnecessary inheritance between iterators.

---
 include/span.h | 78 ++++++++++++++++++++++++++++++++++----------------
 1 file changed, 53 insertions(+), 25 deletions(-)

diff --git a/include/span.h b/include/span.h
index 98e08fd..004afc7 100644
--- a/include/span.h
+++ b/include/span.h
@@ -1,3 +1,4 @@
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
@@ -191,6 +192,7 @@ namespace details
             Expects(span_);
             return (*span_)[index_];
         }
+
         constexpr pointer operator->() const
         {
             Expects(span_);
@@ -300,10 +302,8 @@ namespace details
     };
 
     template <class Span>
-    class span_iterator : public const_span_iterator<Span>
+    class span_iterator 
     {
-        using base_type = const_span_iterator<Span>;
-
     public:
         using iterator_category = std::random_access_iterator_tag;
         using value_type = typename Span::element_type;
@@ -312,67 +312,88 @@ namespace details
         using pointer = value_type*;
         using reference = value_type&;
 
-        constexpr span_iterator() : base_type() {}
+        constexpr span_iterator() : span_iterator(nullptr, 0) {}
         constexpr span_iterator(const Span* span, typename Span::index_type index)
-            : base_type(span, index)
+            : span_(span), index_(index)
         {
+            Expects(span == nullptr || (index_ >= 0 && index <= span_->length()));
         }
 
         constexpr reference operator*() const
         {
-            return const_cast<reference>(base_type::operator*());
+            Expects(span_);
+            return (*span_)[index_];
         }
+
         constexpr pointer operator->() const
         {
-            return const_cast<pointer>(base_type::operator->());
+            Expects(span_);
+            return &((*span_)[index_]);
         }
 
         constexpr span_iterator& operator++() noexcept
         {
-            base_type::operator++();
+            Expects(span_ && index_ >= 0 && index_ < span_->length());
+            ++index_;
             return *this;
         }
 
-        constexpr span_iterator operator++(int) noexcept { return base_type::operator++(1); }
+        constexpr span_iterator operator++(int) noexcept
+        {
+            auto ret = *this;
+            ++(*this);
+            return ret;
+        }
 
         constexpr span_iterator& operator--() noexcept
         {
-            base_type::operator--();
+            Expects(span_ && index_ > 0 && index_ <= span_->length());
+            --index_;
             return *this;
         }
 
-        constexpr span_iterator operator--(int) noexcept { return base_type::operator--(1); }
+        constexpr span_iterator operator--(int) noexcept
+        {
+            auto ret = *this;
+            --(*this);
+            return ret;
+        }
 
         constexpr span_iterator operator+(difference_type n) const noexcept
         {
-            return {base_type::operator+(n)};
+            auto ret = *this;
+            return ret += n;
         }
 
         constexpr span_iterator& operator+=(difference_type n) noexcept
         {
-            return {base_type::operator+=(n)};
+            Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length());
+            index_ += n;
+            return *this;
         }
 
         constexpr span_iterator operator-(difference_type n) const noexcept
         {
-            return base_type::operator-(n);
+            auto ret = *this;
+            return ret -= n;
         }
 
         constexpr span_iterator& operator-=(difference_type n) noexcept
         {
-            return base_type::operator-=(n);
+            return *this += -n;
         }
 
         constexpr difference_type operator-(const span_iterator& rhs) const noexcept
         {
-            return base_type::operator-(rhs);
+            Expects(span_ == rhs.span_);
+            return index_ - rhs.index_;
         }
 
         constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); }
 
         constexpr bool operator==(const span_iterator& rhs) const noexcept
         {
-            return base_type::operator==(rhs);
+            return span_ == rhs.span_ && index_ == rhs.index_;
         }
 
         constexpr bool operator!=(const span_iterator& rhs) const noexcept
@@ -382,7 +403,8 @@ namespace details
 
         constexpr bool operator<(const span_iterator& rhs) const noexcept
         {
-            return base_type::operator<(rhs);
+            Expects(span_ == rhs.span_);
+            return index_ < rhs.index_;
         }
 
         constexpr bool operator<=(const span_iterator& rhs) const noexcept
@@ -397,9 +419,15 @@ namespace details
             return !(rhs > *this);
         }
 
-        void swap(span_iterator& rhs) noexcept { base_type::swap(rhs); }
+        void swap(span_iterator& rhs) noexcept
+        {
+            std::swap(index_, rhs.index_);
+            std::swap(span_, rhs.span_);
+        }
+
     private:
-        constexpr span_iterator(const base_type& base) : base_type(base) {}
+        const Span* span_;
+        std::ptrdiff_t index_;
     };
 
     template <typename Span>
@@ -487,7 +515,7 @@ public:
     using reference = element_type&;
 
     using iterator = details::span_iterator<span<ElementType, Extent>>;
-    using const_iterator = details::const_span_iterator<span>;
+    using const_iterator = details::const_span_iterator<span<ElementType,Extent>>;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
@@ -651,11 +679,11 @@ public:
     const_iterator cbegin() const noexcept { return {this, 0}; }
     const_iterator cend() const noexcept { return {this, length()}; }
 
-    reverse_iterator rbegin() const noexcept { return reverse_iterator{{this, length()}}; }
-    reverse_iterator rend() const noexcept { return reverse_iterator{{this, 0}}; }
+    reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
+    reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
 
-    const_reverse_iterator crbegin() const noexcept { return reverse_iterator{{this, length()}}; }
-    const_reverse_iterator crend() const noexcept { return reverse_iterator{{this, 0}}; }
+    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; }
+    const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; }
 
 private:
     // this implementation detail class lets us take advantage of the

From 6c7be2c8ee2052f17bcfb43d9e97b28f32840283 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Mon, 1 Aug 2016 21:41:20 -0700
Subject: [PATCH 40/42] clang-format run.

---
 include/span.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/include/span.h b/include/span.h
index 004afc7..a5d2823 100644
--- a/include/span.h
+++ b/include/span.h
@@ -302,7 +302,7 @@ namespace details
     };
 
     template <class Span>
-    class span_iterator 
+    class span_iterator
     {
     public:
         using iterator_category = std::random_access_iterator_tag;
@@ -378,10 +378,7 @@ namespace details
             return ret -= n;
         }
 
-        constexpr span_iterator& operator-=(difference_type n) noexcept
-        {
-            return *this += -n;
-        }
+        constexpr span_iterator& operator-=(difference_type n) noexcept { return *this += -n; }
 
         constexpr difference_type operator-(const span_iterator& rhs) const noexcept
         {
@@ -515,7 +512,7 @@ public:
     using reference = element_type&;
 
     using iterator = details::span_iterator<span<ElementType, Extent>>;
-    using const_iterator = details::const_span_iterator<span<ElementType,Extent>>;
+    using const_iterator = details::const_span_iterator<span<ElementType, Extent>>;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 

From 3836e124d8a80dfdaa009591bf34ee783de418e8 Mon Sep 17 00:00:00 2001
From: Neil MacIntosh <neilmac@microsoft.com>
Date: Tue, 2 Aug 2016 14:59:57 -0700
Subject: [PATCH 41/42] Added code of conduct statement to README.

---
 README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/README.md b/README.md
index 35e93e4..3c440c2 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@ it is simplest to just include [gsl.h](./include/gsl.h) and gain access to the e
 > NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to
 other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing.
 
+# Project Code of Conduct
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
 # Quick Start
 ## Supported Platforms
 The test suite that exercises GSL has been built and passes successfully on the following platforms:

From c4817358aa9c5d2b9b64fa959df4bab0369d2470 Mon Sep 17 00:00:00 2001
From: Som1Lse <adrianbibbywalther@gmail.com>
Date: Wed, 3 Aug 2016 22:28:25 +0200
Subject: [PATCH 42/42] Implemented https://github.com/Microsoft/GSL/issues/260

---
 include/multi_span.h         | 22 ++++++++++++++++------
 tests/multi_span_tests.cpp   | 28 ++++++++++++++--------------
 tests/strided_span_tests.cpp | 18 +++++++++---------
 3 files changed, 39 insertions(+), 29 deletions(-)

diff --git a/include/multi_span.h b/include/multi_span.h
index a8a1af2..c883fb0 100644
--- a/include/multi_span.h
+++ b/include/multi_span.h
@@ -1053,18 +1053,28 @@ template <typename Span>
 class general_span_iterator;
 
 template <std::ptrdiff_t DimSize = dynamic_range>
-struct dim
+struct dim_t
 {
     static const std::ptrdiff_t value = DimSize;
 };
 template <>
-struct dim<dynamic_range>
+struct dim_t<dynamic_range>
 {
     static const std::ptrdiff_t value = dynamic_range;
     const std::ptrdiff_t dvalue;
-    dim(std::ptrdiff_t size) : dvalue(size) {}
+    dim_t(std::ptrdiff_t size) : dvalue(size) {}
 };
 
+template <std::ptrdiff_t N>
+constexpr std::enable_if_t<(N >= 0),dim_t<N>> dim() noexcept {
+    return dim_t<N>();
+}
+
+template <std::ptrdiff_t N = dynamic_range>
+constexpr std::enable_if_t<N == dynamic_range,dim_t<N>> dim(std::ptrdiff_t n) noexcept {
+    return dim_t<>(n);
+}
+
 template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
           std::ptrdiff_t... RestDimensions>
 class multi_span;
@@ -1133,13 +1143,13 @@ namespace details
     }
     template <typename T, typename Arg, typename... Args>
     std::enable_if_t<
-        !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
+        !std::is_same<Arg, dim_t<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
         static_as_multi_span_helper(Arg, Args... args)
     {
         return static_as_multi_span_helper<T>(args...);
     }
     template <typename T, typename... Args>
-    T static_as_multi_span_helper(dim<dynamic_range> val, Args... args)
+    T static_as_multi_span_helper(dim_t<dynamic_range> val, Args... args)
     {
         return static_as_multi_span_helper<T>(args..., val.dvalue);
     }
@@ -1682,7 +1692,7 @@ constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) noexcept
 }
 
 template <typename T, std::ptrdiff_t... Dimensions>
-constexpr auto as_multi_span(T* const& ptr, dim<Dimensions>... args)
+constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args)
     -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
 {
     return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
diff --git a/tests/multi_span_tests.cpp b/tests/multi_span_tests.cpp
index 7432057..003d236 100644
--- a/tests/multi_span_tests.cpp
+++ b/tests/multi_span_tests.cpp
@@ -687,9 +687,9 @@ SUITE(multi_span_tests)
         fn(av.bounds());
         auto av2 = as_multi_span(av, dim<60>());
         auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>());
-        auto av4 = as_multi_span(av3, dim<4>(), dim<>(3), dim<5>());
+        auto av4 = as_multi_span(av3, dim<4>(), dim(3), dim<5>());
         auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>());
-        auto av6 = as_multi_span(av5, dim<12>(), dim<>(5));
+        auto av6 = as_multi_span(av5, dim<12>(), dim(5));
 
         fill(av6.begin(), av6.end(), 1);
 
@@ -954,7 +954,7 @@ SUITE(multi_span_tests)
 
             CHECK(s1 == s2);
 
-            multi_span<int, 20> s3 = as_multi_span(s1, dim<>(20));
+            multi_span<int, 20> s3 = as_multi_span(s1, dim(20));
             CHECK(s3 == s2 && s3 == s1);
         }
 
@@ -1122,7 +1122,7 @@ SUITE(multi_span_tests)
         CHECK(count == 34 * 60);
         overloaded_func(av, 34);
 
-        overloaded_func(as_multi_span(av, dim<>(4), dim<>(3), dim<>(5)), 34);
+        overloaded_func(as_multi_span(av, dim(4), dim(3), dim(5)), 34);
 
         // fixed_func(av, 34);
         delete[] data;
@@ -1137,7 +1137,7 @@ SUITE(multi_span_tests)
 
         // size check will be done
         auto image_view =
-            as_multi_span(as_multi_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>());
+            as_multi_span(as_multi_span(image_ptr, imgSize), dim(height), dim(width), dim<3>());
 
         iota(image_view.begin(), image_view.end(), 1);
 
@@ -1165,7 +1165,7 @@ SUITE(multi_span_tests)
         {
             int* arr = new int[150];
 
-            auto av = as_multi_span(arr, dim<10>(), dim<>(3), dim<5>());
+            auto av = as_multi_span(arr, dim<10>(), dim(3), dim<5>());
 
             fill(av.begin(), av.end(), 24);
             overloaded_func(av, 24);
@@ -1174,13 +1174,13 @@ SUITE(multi_span_tests)
 
             array<int, 15> stdarr{0};
             auto av2 = as_multi_span(stdarr);
-            overloaded_func(as_multi_span(av2, dim<>(1), dim<3>(), dim<5>()), 0);
+            overloaded_func(as_multi_span(av2, dim(1), dim<3>(), dim<5>()), 0);
 
             string str = "ttttttttttttttt"; // size = 15
             auto t = str.data();
             (void) t;
             auto av3 = as_multi_span(str);
-            overloaded_func(as_multi_span(av3, dim<>(1), dim<3>(), dim<5>()), 't');
+            overloaded_func(as_multi_span(av3, dim(1), dim<3>(), dim<5>()), 't');
         }
 
         {
@@ -1258,7 +1258,7 @@ SUITE(multi_span_tests)
 
         CHECK(av[i] == 4);
 
-        auto av2 = as_multi_span(av, dim<4>(), dim<>(2));
+        auto av2 = as_multi_span(av, dim<4>(), dim(2));
         ptrdiff_t a2[2] = {0, 1};
         index<2> i2 = a2;
 
@@ -1490,17 +1490,17 @@ SUITE(multi_span_tests)
 
         // first bound is dynamic
         {
-            multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim(height), dim(width));
             iterate_second_column(av2);
         }
         // second bound is dynamic
         {
-            multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width));
+            multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim(height), dim(width));
             iterate_second_column(av2);
         }
         // both bounds are dynamic
         {
-            multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width));
+            multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim(height), dim(width));
             iterate_second_column(av2);
         }
 
@@ -1521,7 +1521,7 @@ SUITE(multi_span_tests)
 
         CHECK_THROW(av1[10][3][4], fail_fast);
 
-        multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim<>(5), dim<6>(), dim<4>());
+        multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim(5), dim<6>(), dim<4>());
         (void) av2;
     }
 
@@ -1568,7 +1568,7 @@ SUITE(multi_span_tests)
 
         {
             multi_span<int, dynamic_range> av = arr;
-            multi_span<int, 2, 1> av2 = as_multi_span(av, dim<>(2), dim<>(2));
+            multi_span<int, 2, 1> av2 = as_multi_span(av, dim(2), dim(2));
             auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
             CHECK(workaround_macro());
         }
diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp
index 19056b1..b81a5e7 100644
--- a/tests/strided_span_tests.cpp
+++ b/tests/strided_span_tests.cpp
@@ -463,7 +463,7 @@ SUITE(strided_span_tests)
 		// retype strided array with regular strides - from multi_span
 		{
 			strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
 			CHECK(sav3[0][0] == 0);
@@ -475,7 +475,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension of the array is too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -483,7 +483,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides are too small
 		{
 			strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -491,7 +491,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - last dimension does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -499,7 +499,7 @@ SUITE(strided_span_tests)
 		// retype strided array with not enough elements - strides does not divide by the new typesize
 		{
 			strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } };
-			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2));
+			multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
 			strided_span<const byte, 2> sav2{ bytes2, bounds };
 			CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
 		}
@@ -675,17 +675,17 @@ SUITE(strided_span_tests)
         }
 
         {
-            auto av = as_multi_span(as_multi_span(arr, 24), dim<>(3), dim<4>(), dim<2>());
+            auto av = as_multi_span(as_multi_span(arr, 24), dim(3), dim<4>(), dim<2>());
             iterate_second_slice(av);
         }
 
         {
-            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<>(4), dim<2>());
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim(4), dim<2>());
             iterate_second_slice(av);
         }
 
         {
-            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<>(2));
+            auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim(2));
             iterate_second_slice(av);
         }
         delete[] arr;
@@ -704,7 +704,7 @@ SUITE(strided_span_tests)
         auto d1 = sizeof(int) * 12 / d2;
 
         // convert to 4x12 array of bytes
-        auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim<>(d1), dim<>(d2));
+        auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim(d1), dim(d2));
 
         CHECK(av.bounds().index_bounds()[0] == 4);
         CHECK(av.bounds().index_bounds()[1] == 12);