diff --git a/pw_span/public/pw_span/span.h b/pw_span/public/pw_span/span.h
index 2ea01ff..8aa270d 100644
--- a/pw_span/public/pw_span/span.h
+++ b/pw_span/public/pw_span/span.h
@@ -19,7 +19,7 @@
 // a template parameter, so this class can be used to without stating its size.
 //
 // This file a modified version of base::span from Chromium:
-//   https://chromium.googlesource.com/chromium/src/+/ef71f9c29f0dc6eddae474879c4ca5232ca93a6c/base/containers/span.h
+//   https://chromium.googlesource.com/chromium/src/+/d93ae920e4309682deb9352a4637cfc2941c1d1f/base/containers/span.h
 //
 // In order to minimize changes from the original, this file does NOT fully
 // adhere to Pigweed's style guide.
@@ -246,9 +246,7 @@
   using pointer = T*;
   using reference = T&;
   using iterator = T*;
-  using const_iterator = const T*;
   using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
   static constexpr size_t extent = Extent;
 
   // [span.cons], span constructors, copy, assignment, and destructor
@@ -273,19 +271,18 @@
                 span_internal::EnableIfSpanCompatibleArray<T (&)[N], T, Extent>>
   constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
 
-  template <
-      size_t N,
-      typename = span_internal::
-          EnableIfSpanCompatibleArray<std::array<value_type, N>&, T, Extent>>
-  constexpr span(std::array<value_type, N>& array) noexcept
+  template <typename U,
+            size_t N,
+            typename = span_internal::
+                EnableIfSpanCompatibleArray<std::array<U, N>&, T, Extent>>
+  constexpr span(std::array<U, N>& array) noexcept
       : span(std::data(array), N) {}
 
-  template <size_t N,
-            typename = span_internal::EnableIfSpanCompatibleArray<
-                const std::array<value_type, N>&,
-                T,
-                Extent>>
-  constexpr span(const std::array<value_type, N>& array) noexcept
+  template <typename U,
+            size_t N,
+            typename = span_internal::
+                EnableIfSpanCompatibleArray<const std::array<U, N>&, T, Extent>>
+  constexpr span(const std::array<U, N>& array) noexcept
       : span(std::data(array), N) {}
 
   // Conversion from a container that has compatible std::data() and integral
@@ -326,16 +323,14 @@
   // [span.sub], span subviews
   template <size_t Count>
   constexpr span<T, Count> first() const noexcept {
-    static_assert(Extent == dynamic_extent || Count <= Extent,
-                  "Count must not exceed Extent");
+    static_assert(Count <= Extent, "Count must not exceed Extent");
     _PW_SPAN_ASSERT(Extent != dynamic_extent || Count <= size());
     return {data(), Count};
   }
 
   template <size_t Count>
   constexpr span<T, Count> last() const noexcept {
-    static_assert(Extent == dynamic_extent || Count <= Extent,
-                  "Count must not exceed Extent");
+    static_assert(Count <= Extent, "Count must not exceed Extent");
     _PW_SPAN_ASSERT(Extent != dynamic_extent || Count <= size());
     return {data() + (size() - Count), Count};
   }
@@ -347,10 +342,8 @@
                       : (Extent != dynamic_extent ? Extent - Offset
                                                   : dynamic_extent))>
   subspan() const noexcept {
-    static_assert(Extent == dynamic_extent || Offset <= Extent,
-                  "Offset must not exceed Extent");
-    static_assert(Extent == dynamic_extent || Count == dynamic_extent ||
-                      Count <= Extent - Offset,
+    static_assert(Offset <= Extent, "Offset must not exceed Extent");
+    static_assert(Count == dynamic_extent || Count <= Extent - Offset,
                   "Count must not exceed Extent - Offset");
     _PW_SPAN_ASSERT(Extent != dynamic_extent || Offset <= size());
     _PW_SPAN_ASSERT(Extent != dynamic_extent || Count == dynamic_extent ||
@@ -410,9 +403,6 @@
   constexpr iterator begin() const noexcept { return data_; }
   constexpr iterator end() const noexcept { return data_ + size(); }
 
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-  constexpr const_iterator cend() const noexcept { return end(); }
-
   constexpr reverse_iterator rbegin() const noexcept {
     return reverse_iterator(end());
   }
@@ -420,13 +410,6 @@
     return reverse_iterator(begin());
   }
 
-  constexpr const_reverse_iterator crbegin() const noexcept {
-    return const_reverse_iterator(cend());
-  }
-  constexpr const_reverse_iterator crend() const noexcept {
-    return const_reverse_iterator(cbegin());
-  }
-
  private:
   T* data_;
 };
@@ -486,49 +469,4 @@
 
 }  // namespace pw
 
-// Note: std::tuple_size, std::tuple_element and std::get are specialized for
-// static spans, so that they can be used in C++17's structured bindings.
-namespace std {
-
-// [span.tuple], tuple interface
-#if defined(__clang__)
-// Due to https://llvm.org/PR39871 and https://llvm.org/PR41331 and their
-// respective fixes different versions of libc++ declare std::tuple_size and
-// std::tuple_element either as classes or structs. In order to be able to
-// specialize std::tuple_size and std::tuple_element for custom pw types we
-// thus need to disable -Wmismatched-tags in order to support all build
-// configurations. Note that this is blessed by the standard in
-// https://timsong-cpp.github.io/cppwp/n4140/dcl.type.elab#3.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmismatched-tags"
-#endif
-template <typename T, size_t X>
-struct tuple_size<pw::span<T, X>> : public integral_constant<size_t, X> {};
-
-template <typename T>
-struct tuple_size<pw::span<T, pw::dynamic_extent>>;  // not defined
-
-template <size_t I, typename T, size_t X>
-struct tuple_element<I, pw::span<T, X>> {
-  static_assert(
-      pw::dynamic_extent != X,
-      "std::tuple_element<> not supported for pw::span<T, dynamic_extent>");
-  static_assert(I < X,
-                "Index out of bounds in std::tuple_element<> (pw::span)");
-  using type = T;
-};
-#if defined(__clang__)
-#pragma clang diagnostic pop  // -Wmismatched-tags
-#endif
-
-template <size_t I, typename T, size_t X>
-constexpr T& get(pw::span<T, X> s) noexcept {
-  static_assert(pw::dynamic_extent != X,
-                "std::get<> not supported for pw::span<T, dynamic_extent>");
-  static_assert(I < X, "Index out of bounds in std::get<> (pw::span)");
-  return s[I];
-}
-
-}  // namespace std
-
 #undef _PW_SPAN_ASSERT
diff --git a/pw_span/span_test.cc b/pw_span/span_test.cc
index 37875f6..37d5ee4 100644
--- a/pw_span/span_test.cc
+++ b/pw_span/span_test.cc
@@ -260,6 +260,99 @@
     EXPECT_EQ(vector[i], static_span[i]);
 }
 
+TEST(SpanTest, AllowedConversionsFromStdArray) {
+  // In the following assertions we use std::is_convertible_v<From, To>, which
+  // for non-void types is equivalent to checking whether the following
+  // expression is well-formed:
+  //
+  // T obj = std::declval<From>();
+  //
+  // In particular we are checking whether From is implicitly convertible to To,
+  // which also implies that To is explicitly constructible from From.
+  static_assert(
+      std::is_convertible<std::array<int, 3>&, span<int>>::value,
+      "Error: l-value reference to std::array<int> should be convertible to "
+      "span<int> with dynamic extent.");
+  static_assert(
+      std::is_convertible<std::array<int, 3>&, span<int, 3>>::value,
+      "Error: l-value reference to std::array<int> should be convertible to "
+      "span<int> with the same static extent.");
+  static_assert(
+      std::is_convertible<std::array<int, 3>&, span<const int>>::value,
+      "Error: l-value reference to std::array<int> should be convertible to "
+      "span<const int> with dynamic extent.");
+  static_assert(
+      std::is_convertible<std::array<int, 3>&, span<const int, 3>>::value,
+      "Error: l-value reference to std::array<int> should be convertible to "
+      "span<const int> with the same static extent.");
+  static_assert(
+      std::is_convertible<const std::array<int, 3>&, span<const int>>::value,
+      "Error: const l-value reference to std::array<int> should be "
+      "convertible to span<const int> with dynamic extent.");
+  static_assert(
+      std::is_convertible<const std::array<int, 3>&, span<const int, 3>>::value,
+      "Error: const l-value reference to std::array<int> should be convertible "
+      "to span<const int> with the same static extent.");
+  static_assert(
+      std::is_convertible<std::array<const int, 3>&, span<const int>>::value,
+      "Error: l-value reference to std::array<const int> should be "
+      "convertible to span<const int> with dynamic extent.");
+  static_assert(
+      std::is_convertible<std::array<const int, 3>&, span<const int, 3>>::value,
+      "Error: l-value reference to std::array<const int> should be convertible "
+      "to span<const int> with the same static extent.");
+  static_assert(
+      std::is_convertible<const std::array<const int, 3>&,
+                          span<const int>>::value,
+      "Error: const l-value reference to std::array<const int> should be "
+      "convertible to span<const int> with dynamic extent.");
+  static_assert(
+      std::is_convertible<const std::array<const int, 3>&,
+                          span<const int, 3>>::value,
+      "Error: const l-value reference to std::array<const int> should be "
+      "convertible to span<const int> with the same static extent.");
+}
+
+TEST(SpanTest, DisallowedConstructionsFromStdArray) {
+  // In the following assertions we use !std::is_constructible_v<T, Args>, which
+  // is equivalent to checking whether the following expression is malformed:
+  //
+  // T obj(std::declval<Args>()...);
+  //
+  // In particular we are checking that T is not explicitly constructible from
+  // Args, which also implies that T is not implicitly constructible from Args
+  // as well.
+  static_assert(
+      !std::is_constructible<span<int>, const std::array<int, 3>&>::value,
+      "Error: span<int> with dynamic extent should not be constructible "
+      "from const l-value reference to std::array<int>");
+
+  static_assert(
+      !std::is_constructible<span<int>, std::array<const int, 3>&>::value,
+      "Error: span<int> with dynamic extent should not be constructible "
+      "from l-value reference to std::array<const int>");
+
+  static_assert(
+      !std::is_constructible<span<int>, const std::array<const int, 3>&>::value,
+      "Error: span<int> with dynamic extent should not be constructible "
+      "const from l-value reference to std::array<const int>");
+
+  static_assert(
+      !std::is_constructible<span<int, 2>, std::array<int, 3>&>::value,
+      "Error: span<int> with static extent should not be constructible "
+      "from l-value reference to std::array<int> with different extent");
+
+  static_assert(
+      !std::is_constructible<span<int, 4>, std::array<int, 3>&>::value,
+      "Error: span<int> with dynamic extent should not be constructible "
+      "from l-value reference to std::array<int> with different extent");
+
+  static_assert(
+      !std::is_constructible<span<int>, std::array<bool, 3>&>::value,
+      "Error: span<int> with dynamic extent should not be constructible "
+      "from l-value reference to std::array<bool>");
+}
+
 TEST(SpanTest, ConstructFromConstexprArray) {
   static constexpr int kArray[] = {5, 4, 3, 2, 1};
 
@@ -1143,8 +1236,10 @@
 
   EXPECT_TRUE(std::equal(
       std::rbegin(kArray), std::rend(kArray), span.rbegin(), span.rend()));
-  EXPECT_TRUE(std::equal(
-      std::crbegin(kArray), std::crend(kArray), span.crbegin(), span.crend()));
+  EXPECT_TRUE(std::equal(std::crbegin(kArray),
+                         std::crend(kArray),
+                         std::crbegin(span),
+                         std::crend(span)));
 }
 
 // Pigweed: These are tests for make_span, which is not included in Pigweed's
@@ -1379,46 +1474,6 @@
 }
 #endif  // 0
 
-TEST(SpanTest, StdTupleSize) {
-  static_assert(std::tuple_size<span<int, 0>>::value == 0, "");
-  static_assert(std::tuple_size<span<int, 1>>::value == 1, "");
-  static_assert(std::tuple_size<span<int, 2>>::value == 2, "");
-}
-
-TEST(SpanTest, StdTupleElement) {
-  static_assert(std::is_same<int, std::tuple_element_t<0, span<int, 1>>>::value,
-                "");
-  static_assert(
-      std::is_same<const int,
-                   std::tuple_element_t<0, span<const int, 2>>>::value,
-      "");
-  static_assert(
-      std::is_same<const int*,
-                   std::tuple_element_t<1, span<const int*, 2>>>::value,
-      "");
-}
-
-TEST(SpanTest, StdGet) {
-  static constexpr int kArray[] = {1, 6, 1, 8, 0};
-  constexpr span<const int, 5> span(kArray);
-
-  static_assert(
-      &kArray[0] == &std::get<0>(span),
-      "std::get<0>(span) does not refer to the same element as kArray[0]");
-  static_assert(
-      &kArray[1] == &std::get<1>(span),
-      "std::get<1>(span) does not refer to the same element as kArray[1]");
-  static_assert(
-      &kArray[2] == &std::get<2>(span),
-      "std::get<2>(span) does not refer to the same element as kArray[2]");
-  static_assert(
-      &kArray[3] == &std::get<3>(span),
-      "std::get<3>(span) does not refer to the same element as kArray[3]");
-  static_assert(
-      &kArray[4] == &std::get<4>(span),
-      "std::get<4>(span) does not refer to the same element as kArray[4]");
-}
-
 TEST(SpanTest, EnsureConstexprGoodness) {
   static constexpr int kArray[] = {5, 4, 3, 2, 1};
   constexpr span<const int> constexpr_span(kArray);
@@ -1488,7 +1543,7 @@
             span.data() + dest_start_index,
             span.data() + dest_start_index + kNumElements)));
     EXPECT_FALSE(CheckedContiguousConstIterator<const int>::IsRangeMoveSafe(
-        span.cbegin(), span.cend(),
+        std::cbegin(span), std::cend(span),
         CheckedContiguousConstIterator<const int>(
             span.data() + dest_start_index,
             span.data() + dest_start_index + kNumElements)));
@@ -1502,7 +1557,7 @@
             span.data() + dest_start_index,
             span.data() + dest_start_index + kNumElements)));
     EXPECT_TRUE(CheckedContiguousConstIterator<const int>::IsRangeMoveSafe(
-        span.cbegin(), span.cend(),
+        std::cbegin(span), std::cend(span),
         CheckedContiguousConstIterator<const int>(
             span.data() + dest_start_index,
             span.data() + dest_start_index + kNumElements)));
@@ -1513,7 +1568,7 @@
       span.begin(), span.begin(),
       CheckedContiguousIterator<const int>(span.data(), span.data())));
   EXPECT_TRUE(CheckedContiguousConstIterator<const int>::IsRangeMoveSafe(
-      span.cbegin(), span.cbegin(),
+      std::cbegin(span), std::cbegin(span),
       CheckedContiguousConstIterator<const int>(span.data(), span.data())));
 
   // IsRangeMoveSafe is false if end < begin.
@@ -1521,7 +1576,7 @@
       span.end(), span.begin(),
       CheckedContiguousIterator<const int>(span.data(), span.data())));
   EXPECT_FALSE(CheckedContiguousConstIterator<const int>::IsRangeMoveSafe(
-      span.cend(), span.cbegin(),
+      std::cend(span), std::cbegin(span),
       CheckedContiguousConstIterator<const int>(span.data(), span.data())));
 }
 
@@ -1566,12 +1621,12 @@
 
 TEST(SpanTest, IteratorConversions) {
   static_assert(std::is_convertible<span<int>::iterator,
-                                    span<int>::const_iterator>::value,
-                "Error: iterator should be convertible to const_iterator");
+                                    span<const int>::iterator>::value,
+                "Error: iterator should be convertible to const iterator");
 
-  static_assert(!std::is_convertible<span<int>::const_iterator,
+  static_assert(!std::is_convertible<span<const int>::iterator,
                                      span<int>::iterator>::value,
-                "Error: const_iterator should not be convertible to iterator");
+                "Error: const iterator should not be convertible to iterator");
 }
 
 }  // namespace pw