diff --git a/folly/algorithm/simd/FindFixed.h b/folly/algorithm/simd/FindFixed.h
index 547b02a6b3a..455799ad206 100644
--- a/folly/algorithm/simd/FindFixed.h
+++ b/folly/algorithm/simd/FindFixed.h
@@ -293,7 +293,8 @@ constexpr std::optional<std::size_t> findFixed(std::span<const T, N> where, U x)
     return find_fixed_detail::findFixedConstexpr(std::span<const T>(where), x);
   } else {
     return find_fixed_detail::findFixedDispatch(
-        detail::asSimdFriendlyUint(where), detail::asSimdFriendlyUint(x));
+        simd::detail::asSimdFriendlyUint(where),
+        simd::detail::asSimdFriendlyUint(x));
   }
 }
 
diff --git a/folly/algorithm/simd/detail/BUCK b/folly/algorithm/simd/detail/BUCK
index 53a172a2e6b..7a347fb5333 100644
--- a/folly/algorithm/simd/detail/BUCK
+++ b/folly/algorithm/simd/detail/BUCK
@@ -40,6 +40,7 @@ cpp_library(
     name = "traits",
     headers = ["Traits.h"],
     exported_deps = [
+        "//folly:c_portability",
         "//folly:memory",
         "//folly:traits",
         "//folly/container:span",
diff --git a/folly/algorithm/simd/detail/Traits.h b/folly/algorithm/simd/detail/Traits.h
index ee2ef3d5105..f3e34cb7eee 100644
--- a/folly/algorithm/simd/detail/Traits.h
+++ b/folly/algorithm/simd/detail/Traits.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <folly/CPortability.h>
 #include <folly/Memory.h>
 #include <folly/Traits.h>
 #include <folly/container/span.h>
@@ -23,7 +24,7 @@
 #include <concepts>
 #include <type_traits>
 
-namespace folly::detail {
+namespace folly::simd::detail {
 
 template <typename T>
 auto findSimdFriendlyEquivalent() {
@@ -36,65 +37,75 @@ auto findSimdFriendlyEquivalent() {
       return double{};
     }
   } else if constexpr (std::is_signed_v<T>) {
-    if constexpr (sizeof(T) == 1) {
-      return std::int8_t{};
-    } else if constexpr (sizeof(T) == 2) {
-      return std::int16_t{};
-    } else if constexpr (sizeof(T) == 4) {
-      return std::int32_t{};
-    } else if constexpr (sizeof(T) == 8) {
-      return std::int64_t{};
-    }
+    return int_bits_t<sizeof(T) * 8>{};
   } else if constexpr (std::is_unsigned_v<T>) {
-    if constexpr (sizeof(T) == 1) {
-      return std::uint8_t{};
-    } else if constexpr (sizeof(T) == 2) {
-      return std::uint16_t{};
-    } else if constexpr (sizeof(T) == 4) {
-      return std::uint32_t{};
-    } else if constexpr (sizeof(T) == 8) {
-      return std::uint64_t{};
-    }
+    return uint_bits_t<sizeof(T) * 8>{};
   }
 }
 
 template <typename T>
-concept has_simd_friendly_equivalent =
+constexpr bool has_simd_friendly_equivalent_scalar =
     !std::is_same_v<void, decltype(findSimdFriendlyEquivalent<T>())>;
 
-template <has_simd_friendly_equivalent T>
-using simd_friendly_equivalent_t = folly::like_t< //
-    T,
-    decltype(findSimdFriendlyEquivalent<std::remove_const_t<T>>())>;
+template <typename T>
+using simd_friendly_equivalent_scalar_t = std::enable_if_t<
+    has_simd_friendly_equivalent_scalar<T>,
+    like_t<T, decltype(findSimdFriendlyEquivalent<std::remove_const_t<T>>())>>;
 
 template <typename T>
-concept has_integral_simd_friendly_equivalent =
-    has_simd_friendly_equivalent<T> && // have to explicitly specify this for
-                                       // subsumption to work
-    std::integral<simd_friendly_equivalent_t<T>>;
+constexpr bool has_integral_simd_friendly_equivalent_scalar =
+    std::is_integral_v< // void will return false
+        decltype(findSimdFriendlyEquivalent<std::remove_const_t<T>>())>;
 
-template <has_integral_simd_friendly_equivalent T>
-using integral_simd_friendly_equivalent = simd_friendly_equivalent_t<T>;
+template <typename T>
+using unsigned_simd_friendly_equivalent_scalar_t = std::enable_if_t<
+    has_integral_simd_friendly_equivalent_scalar<T>,
+    like_t<T, uint_bits_t<sizeof(T) * 8>>>;
 
-template <has_simd_friendly_equivalent T, std::size_t Extend>
-auto asSimdFriendly(folly::span<T, Extend> s) {
-  return folly::reinterpret_span_cast<simd_friendly_equivalent_t<T>>(s);
-}
+template <typename R>
+using span_for = decltype(folly::span(std::declval<const R&>()));
 
-template <has_simd_friendly_equivalent T>
-constexpr auto asSimdFriendly(T x) {
-  return static_cast<simd_friendly_equivalent_t<T>>(x);
-}
+struct AsSimdFriendlyFn {
+  template <typename T, std::size_t extent>
+  FOLLY_ERASE auto operator()(folly::span<T, extent> s) const
+      -> folly::span<simd_friendly_equivalent_scalar_t<T>, extent> {
+    return reinterpret_span_cast<simd_friendly_equivalent_scalar_t<T>>(s);
+  }
 
-template <has_simd_friendly_equivalent T, std::size_t Extend>
-auto asSimdFriendlyUint(folly::span<T, Extend> s) {
-  return folly::reinterpret_span_cast<
-      folly::like_t<T, uint_bits_t<sizeof(T) * 8>>>(s);
-}
+  template <typename R>
+  FOLLY_ERASE auto operator()(R&& r) const
+      -> decltype(operator()(span_for<R>(r))) {
+    return operator()(folly::span(r));
+  }
 
-template <has_simd_friendly_equivalent T>
-constexpr auto asSimdFriendlyUint(T x) {
-  return static_cast<uint_bits_t<sizeof(T) * 8>>(x);
-}
+  template <typename T>
+  FOLLY_ERASE constexpr auto operator()(T x) const
+      -> simd_friendly_equivalent_scalar_t<T> {
+    return static_cast<simd_friendly_equivalent_scalar_t<T>>(x);
+  }
+};
+inline constexpr AsSimdFriendlyFn asSimdFriendly;
+
+struct AsSimdFriendlyUintFn {
+  template <typename T, std::size_t extent>
+  FOLLY_ERASE auto operator()(folly::span<T, extent> s) const
+      -> folly::span<unsigned_simd_friendly_equivalent_scalar_t<T>, extent> {
+    return reinterpret_span_cast<unsigned_simd_friendly_equivalent_scalar_t<T>>(
+        s);
+  }
+
+  template <typename R>
+  FOLLY_ERASE auto operator()(R&& r) const
+      -> decltype(operator()(span_for<R>(r))) {
+    return operator()(folly::span(r));
+  }
+
+  template <typename T>
+  FOLLY_ERASE constexpr auto operator()(T x) const
+      -> unsigned_simd_friendly_equivalent_scalar_t<T> {
+    return static_cast<unsigned_simd_friendly_equivalent_scalar_t<T>>(x);
+  }
+};
+inline constexpr AsSimdFriendlyUintFn asSimdFriendlyUint;
 
-} // namespace folly::detail
+} // namespace folly::simd::detail
diff --git a/folly/algorithm/simd/detail/test/BUCK b/folly/algorithm/simd/detail/test/BUCK
index 6661c2ce012..dea91d505cf 100644
--- a/folly/algorithm/simd/detail/test/BUCK
+++ b/folly/algorithm/simd/detail/test/BUCK
@@ -27,6 +27,7 @@ cpp_unittest(
 cpp_unittest(
     name = "traits_test",
     srcs = ["TraitsTest.cpp"],
+    compiler_flags = ["--std=c++17"],
     deps = [
         "//folly/algorithm/simd/detail:traits",
         "//folly/portability:gmock",
diff --git a/folly/algorithm/simd/detail/test/TraitsTest.cpp b/folly/algorithm/simd/detail/test/TraitsTest.cpp
index 5d01d9630df..23247b0c6f5 100644
--- a/folly/algorithm/simd/detail/test/TraitsTest.cpp
+++ b/folly/algorithm/simd/detail/test/TraitsTest.cpp
@@ -19,84 +19,147 @@
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
 
-namespace folly::detail {
+#include <set>
+#include <vector>
+
+namespace folly::simd::detail {
 
 struct FollySimdTraitsTest : testing::Test {};
 
-namespace simd_friendly_equivalent_test {
+namespace simd_friendly_equivalent_scalar_test {
 
 // ints
-static_assert(
-    std::is_same_v<std::int8_t, simd_friendly_equivalent_t<signed char>>);
-static_assert(
-    std::is_same_v<std::uint8_t, simd_friendly_equivalent_t<unsigned char>>);
+static_assert(std::is_same_v<
+              std::int8_t,
+              simd_friendly_equivalent_scalar_t<signed char>>);
+static_assert(std::is_same_v<
+              std::uint8_t,
+              simd_friendly_equivalent_scalar_t<unsigned char>>);
 
-static_assert(std::is_same_v<std::int16_t, simd_friendly_equivalent_t<short>>);
 static_assert(
-    std::is_same_v<std::uint16_t, simd_friendly_equivalent_t<unsigned short>>);
+    std::is_same_v<std::int16_t, simd_friendly_equivalent_scalar_t<short>>);
+static_assert(std::is_same_v<
+              std::uint16_t,
+              simd_friendly_equivalent_scalar_t<unsigned short>>);
 
-static_assert(std::is_same_v<std::int32_t, simd_friendly_equivalent_t<int>>);
 static_assert(
-    std::is_same_v<std::uint32_t, simd_friendly_equivalent_t<unsigned int>>);
-
-static_assert(
-    std::is_same_v<std::int64_t, simd_friendly_equivalent_t<std::int64_t>>);
-static_assert(
-    std::is_same_v<std::uint64_t, simd_friendly_equivalent_t<std::uint64_t>>);
+    std::is_same_v<std::int32_t, simd_friendly_equivalent_scalar_t<int>>);
+static_assert(std::is_same_v<
+              std::uint32_t,
+              simd_friendly_equivalent_scalar_t<unsigned int>>);
+
+static_assert(std::is_same_v<
+              std::int64_t,
+              simd_friendly_equivalent_scalar_t<std::int64_t>>);
+static_assert(std::is_same_v<
+              std::uint64_t,
+              simd_friendly_equivalent_scalar_t<std::uint64_t>>);
 
 // floats
-static_assert(std::is_same_v<float, simd_friendly_equivalent_t<float>>);
-static_assert(std::is_same_v<double, simd_friendly_equivalent_t<double>>);
+static_assert(std::is_same_v<float, simd_friendly_equivalent_scalar_t<float>>);
+static_assert(
+    std::is_same_v<double, simd_friendly_equivalent_scalar_t<double>>);
 
 // enum
 enum SomeInt {};
 enum class SomeIntClass : std::int32_t {};
 
 static_assert(
-    std::is_same_v<std::uint32_t, simd_friendly_equivalent_t<SomeInt>>);
-static_assert(
-    std::is_same_v<std::int32_t, simd_friendly_equivalent_t<SomeIntClass>>);
+    std::is_same_v<std::uint32_t, simd_friendly_equivalent_scalar_t<SomeInt>>);
+static_assert(std::is_same_v<
+              std::int32_t,
+              simd_friendly_equivalent_scalar_t<SomeIntClass>>);
 
 // const
 
-static_assert(
-    std::is_same_v<const std::int32_t, simd_friendly_equivalent_t<const int>>);
+static_assert(std::is_same_v<
+              const std::int32_t,
+              simd_friendly_equivalent_scalar_t<const int>>);
 
 // sfinae
-constexpr auto sfinae_call =
-    []<typename T>(T) -> simd_friendly_equivalent_t<T> { return {}; };
 
-static_assert(std::invocable<decltype(sfinae_call), int>);
+struct sfinae_call {
+  template <typename T>
+  simd_friendly_equivalent_scalar_t<T> operator()(T) const {
+    return {};
+  }
+};
+
+static_assert(std::is_invocable_v<sfinae_call, int>);
 
 struct NotSimdFriendly {};
-static_assert(!std::invocable<decltype(sfinae_call), NotSimdFriendly>);
+static_assert(!std::is_invocable_v<sfinae_call, NotSimdFriendly>);
 
-} // namespace simd_friendly_equivalent_test
+} // namespace simd_friendly_equivalent_scalar_test
 
-namespace integral_simd_friendly_equivalent_test {
+namespace as_simd_friendly_type_test {
 
-static_assert(std::is_same_v< //
-              std::int8_t,
-              integral_simd_friendly_equivalent<signed char>>);
+template <typename T>
+using asSimdFriendlyResult = std::invoke_result_t<AsSimdFriendlyFn, T>;
 
-struct Overloading {
-  constexpr int operator()(auto) { return 0; }
-  constexpr int operator()(has_simd_friendly_equivalent auto) { return 1; }
-  constexpr int operator()(has_integral_simd_friendly_equivalent auto) {
-    return 2;
-  }
-};
+static_assert(std::is_same_v<
+              folly::span<std::int32_t>,
+              asSimdFriendlyResult<folly::span<std::int32_t>>>);
 
-// Subsumption tests
-struct NotSimdFriendly {};
-enum class SomeInt {};
+static_assert(std::is_same_v<
+              folly::span<std::int32_t>,
+              asSimdFriendlyResult<folly::span<int>>>);
+
+static_assert(std::is_same_v<
+              folly::span<std::int32_t>,
+              asSimdFriendlyResult<std::vector<int>&>>);
+
+static_assert(std::is_same_v<
+              folly::span<const std::int32_t>,
+              asSimdFriendlyResult<const std::vector<int>&>>);
+
+static_assert(std::is_same_v<
+              folly::span<const double>,
+              asSimdFriendlyResult<const std::vector<double>&>>);
+
+static_assert(std::is_same_v<double, asSimdFriendlyResult<double>>);
 
-static_assert(Overloading{}(NotSimdFriendly{}) == 0);
-static_assert(Overloading{}(float{}) == 1);
-static_assert(Overloading{}(int{}) == 2);
-static_assert(Overloading{}(SomeInt{}) == 2);
+static_assert(!std::is_invocable_v<AsSimdFriendlyFn, std::set<int>>);
 
-} // namespace integral_simd_friendly_equivalent_test
+} // namespace as_simd_friendly_type_test
+
+namespace as_simd_friendly_uint_type_test {
+
+template <typename T>
+using asSimdFriendlyUintResult = std::invoke_result_t<AsSimdFriendlyUintFn, T>;
+
+static_assert(std::is_same_v<
+              folly::span<std::uint32_t>,
+              asSimdFriendlyUintResult<folly::span<std::uint32_t>>>);
+
+static_assert(std::is_same_v<
+              folly::span<std::uint32_t>,
+              asSimdFriendlyUintResult<folly::span<std::int32_t>>>);
+
+static_assert(std::is_same_v<
+              folly::span<std::uint32_t>,
+              asSimdFriendlyUintResult<folly::span<int>>>);
+
+static_assert(std::is_same_v<
+              folly::span<std::uint32_t>,
+              asSimdFriendlyUintResult<std::vector<int>&>>);
+
+static_assert(std::is_same_v<
+              folly::span<const std::uint32_t>,
+              asSimdFriendlyUintResult<const std::vector<std::uint32_t>&>>);
+
+static_assert(
+    std::is_same_v<std::uint32_t, asSimdFriendlyUintResult<std::int32_t>>);
+
+static_assert(
+    !std::is_invocable_v<AsSimdFriendlyUintFn, const std::vector<double>&>);
+
+static_assert(
+    !std::is_invocable_v<AsSimdFriendlyUintFn, const std::vector<double>&>);
+
+static_assert(!std::is_invocable_v<AsSimdFriendlyUintFn, std::set<int>>);
+
+} // namespace as_simd_friendly_uint_type_test
 
 TEST_F(FollySimdTraitsTest, AsSimdFriendly) {
   enum SomeEnum : int { Foo = 1, Bar, Baz };
@@ -108,32 +171,14 @@ TEST_F(FollySimdTraitsTest, AsSimdFriendly) {
   ASSERT_THAT(castSpan, testing::ElementsAre(1, 2, 3));
 }
 
-template <typename T, typename U>
-void isSameTest(const T&, const U&) = delete;
-
-template <typename T>
-void isSameTest(const T&, const T&) {}
-
-template <typename From, typename To>
-void asSimdFriendlyUintTypeTest() {
-  isSameTest(asSimdFriendlyUint(From{}), To{});
-  isSameTest(asSimdFriendlyUint(std::span<From>{}), std::span<To>{});
-  isSameTest(
-      asSimdFriendlyUint(std::span<const From>{}), std::span<const To>{});
-}
-
 TEST_F(FollySimdTraitsTest, AsSimdFriendlyUint) {
   enum SomeEnum : int { Foo = 1, Bar, Baz };
 
   static_assert(asSimdFriendlyUint(SomeEnum::Foo) == 1U);
 
-  asSimdFriendlyUintTypeTest<char, std::uint8_t>();
-  asSimdFriendlyUintTypeTest<short, std::uint16_t>();
-  asSimdFriendlyUintTypeTest<int, std::uint32_t>();
-  asSimdFriendlyUintTypeTest<unsigned, std::uint32_t>();
-  asSimdFriendlyUintTypeTest<float, std::uint32_t>();
-  asSimdFriendlyUintTypeTest<int64_t, std::uint64_t>();
-  asSimdFriendlyUintTypeTest<double, std::uint64_t>();
+  std::array arr{SomeEnum::Foo, SomeEnum::Bar, SomeEnum::Baz};
+  folly::span<std::uint32_t, 3> castSpan = asSimdFriendlyUint(folly::span(arr));
+  ASSERT_THAT(castSpan, testing::ElementsAre(1, 2, 3));
 }
 
-} // namespace folly::detail
+} // namespace folly::simd::detail
diff --git a/folly/container/BUCK b/folly/container/BUCK
index 528f8b81fad..61ab6de5431 100644
--- a/folly/container/BUCK
+++ b/folly/container/BUCK
@@ -172,11 +172,12 @@ cpp_library(
     name = "span",
     headers = ["span.h"],
     exported_deps = [
+        ":access",
+        ":iterator",
         "//folly:cpp_attributes",
         "//folly:portability",
         "//folly:traits",
         "//folly:utility",
-        "//folly/container:access",
         "//folly/functional:invoke",
         "//folly/portability:constexpr",
     ],
diff --git a/folly/container/Iterator.h b/folly/container/Iterator.h
index 68e1baacf9a..bfecb51e753 100644
--- a/folly/container/Iterator.h
+++ b/folly/container/Iterator.h
@@ -112,6 +112,12 @@ inline constexpr bool iterator_category_matches_v =
 template <typename Iter>
 using iterator_value_type_t = typename std::iterator_traits<Iter>::value_type;
 
+//  iterator_reference_type_t
+//
+//  Extracts reference from an iterator (C++20 iter_reference_t backported)
+template <typename Iter>
+using iterator_reference_t = decltype(*std::declval<Iter&>());
+
 //  iterator_key_type_t
 //
 //  Extracts a key type from an iterator, leverages the knowledge that
diff --git a/folly/container/span.h b/folly/container/span.h
index f326bcf0cbf..50aa4eb7468 100644
--- a/folly/container/span.h
+++ b/folly/container/span.h
@@ -27,6 +27,7 @@
 #include <folly/Traits.h>
 #include <folly/Utility.h>
 #include <folly/container/Access.h>
+#include <folly/container/Iterator.h>
 #include <folly/functional/Invoke.h>
 #include <folly/portability/Constexpr.h>
 
@@ -247,6 +248,22 @@ class span {
   }
 };
 
+template <typename T, typename EndOrSize>
+span(T*, EndOrSize) -> span<T>;
+
+template <typename T, std::size_t N>
+span(T (&)[N]) -> span<T, N>;
+
+template <typename T, std::size_t N>
+span(std::array<T, N>&) -> span<T, N>;
+
+template <typename T, std::size_t N>
+span(const std::array<T, N>&) -> span<const T, N>;
+
+template <typename R>
+span(R&&) -> span<std::remove_reference_t<
+              iterator_reference_t<decltype(std::begin(std::declval<R&>()))>>>;
+
 } // namespace fallback_span
 
 } // namespace detail
diff --git a/folly/container/test/span_test.cpp b/folly/container/test/span_test.cpp
index 226c7d05cee..5d09f165391 100644
--- a/folly/container/test/span_test.cpp
+++ b/folly/container/test/span_test.cpp
@@ -324,6 +324,46 @@ TYPED_TEST_P(SpanTest, fix_as_bytes) {
   EXPECT_EQ(20, wbytes.size());
 }
 
+namespace fallback_span_ctad {
+
+namespace fallback = folly::detail::fallback_span;
+
+template <typename... Ts>
+using deduced_for = decltype(fallback::span(std::declval<Ts>()...));
+
+static_assert( //
+    std::is_same_v<
+        fallback::span<const int>,
+        deduced_for<const int*, std::size_t>>);
+
+static_assert( //
+    std::is_same_v<
+        fallback::span<const int>,
+        deduced_for<const std::vector<int>&>>);
+
+static_assert( //
+    std::is_same_v<fallback::span<int>, deduced_for<std::vector<int>&>>);
+
+static_assert(
+    std::is_same_v<fallback::span<int, 3>, deduced_for<std::array<int, 3>&>>);
+
+static_assert( //
+    std::is_same_v<
+        fallback::span<const int, 3>,
+        deduced_for<const std::array<int, 3>&>>);
+
+int arr1[3];
+static_assert( //
+    std::is_same_v<fallback::span<int, 3>, decltype(fallback::span(arr1))>);
+
+constexpr int arr2[3]{0, 1, 2};
+static_assert( //
+    std::is_same_v<
+        fallback::span<const int, 3>,
+        decltype(fallback::span(arr2))>);
+
+} // namespace fallback_span_ctad
+
 // clang-format off
 REGISTER_TYPED_TEST_SUITE_P(
     SpanTest