diff --git a/cpp/src/arrow/array/concatenate.cc b/cpp/src/arrow/array/concatenate.cc
index 2b832b977f2..90ae952a2e8 100644
--- a/cpp/src/arrow/array/concatenate.cc
+++ b/cpp/src/arrow/array/concatenate.cc
@@ -424,7 +424,7 @@ class ConcatenateImpl {
     out_->buffers.resize(2);
 
     for (const auto& in_data : in_) {
-      for (const auto& buf : util::span(in_data->buffers).subspan(2)) {
+      for (const auto& buf : std::span(in_data->buffers).subspan(2)) {
         out_->buffers.push_back(buf);
       }
     }
diff --git a/cpp/src/arrow/array/data.cc b/cpp/src/arrow/array/data.cc
index 1c56a485062..51ba77863b1 100644
--- a/cpp/src/arrow/array/data.cc
+++ b/cpp/src/arrow/array/data.cc
@@ -102,7 +102,7 @@ bool DictionaryMayHaveLogicalNulls(const ArrayData& data) {
 
 namespace {
 
-BufferSpan PackVariadicBuffers(util::span<const std::shared_ptr<Buffer>> buffers) {
+BufferSpan PackVariadicBuffers(std::span<const std::shared_ptr<Buffer>> buffers) {
   return {const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buffers.data())),
           static_cast<int64_t>(buffers.size() * sizeof(std::shared_ptr<Buffer>))};
 }
@@ -322,7 +322,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
 
   if (type_id == Type::STRING_VIEW || type_id == Type::BINARY_VIEW) {
     // store the span of data buffers in the third buffer
-    this->buffers[2] = internal::PackVariadicBuffers(util::span(data.buffers).subspan(2));
+    this->buffers[2] = internal::PackVariadicBuffers(std::span(data.buffers).subspan(2));
   }
 
   if (type_id == Type::DICTIONARY) {
@@ -679,7 +679,7 @@ std::shared_ptr<ArrayData> ArraySpan::ToArrayData() const {
   return result;
 }
 
-util::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
+std::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
   DCHECK(HasVariadicBuffers());
   return {buffers[2].data_as<std::shared_ptr<Buffer>>(),
           static_cast<size_t>(buffers[2].size) / sizeof(std::shared_ptr<Buffer>)};
diff --git a/cpp/src/arrow/array/data.h b/cpp/src/arrow/array/data.h
index c6636df9bb3..200d92a54c6 100644
--- a/cpp/src/arrow/array/data.h
+++ b/cpp/src/arrow/array/data.h
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <utility>
 #include <vector>
 
@@ -31,9 +32,7 @@
 #include "arrow/type_fwd.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/macros.h"
-#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
-
 namespace arrow {
 
 namespace internal {
@@ -577,11 +576,11 @@ struct ARROW_EXPORT ArraySpan {
   /// this array type
   /// \return A span<const T> of the requested length
   template <typename T>
-  util::span<const T> GetSpan(int i, int64_t length) const {
+  std::span<const T> GetSpan(int i, int64_t length) const {
     const int64_t buffer_length = buffers[i].size / static_cast<int64_t>(sizeof(T));
     assert(i > 0 && length + offset <= buffer_length);
     ARROW_UNUSED(buffer_length);
-    return util::span<const T>(buffers[i].data_as<T>() + this->offset, length);
+    return std::span<const T>(buffers[i].data_as<T>() + this->offset, length);
   }
 
   /// \brief Access a buffer's data as a span
@@ -593,11 +592,11 @@ struct ARROW_EXPORT ArraySpan {
   /// this array type
   /// \return A span<T> of the requested length
   template <typename T>
-  util::span<T> GetSpan(int i, int64_t length) {
+  std::span<T> GetSpan(int i, int64_t length) {
     const int64_t buffer_length = buffers[i].size / static_cast<int64_t>(sizeof(T));
     assert(i > 0 && length + offset <= buffer_length);
     ARROW_UNUSED(buffer_length);
-    return util::span<T>(buffers[i].mutable_data_as<T>() + this->offset, length);
+    return std::span<T>(buffers[i].mutable_data_as<T>() + this->offset, length);
   }
 
   inline bool IsNull(int64_t i) const { return !IsValid(i); }
@@ -709,7 +708,7 @@ struct ARROW_EXPORT ArraySpan {
   /// sizeof(shared_ptr<Buffer>).
   ///
   /// \see HasVariadicBuffers
-  util::span<const std::shared_ptr<Buffer>> GetVariadicBuffers() const;
+  std::span<const std::shared_ptr<Buffer>> GetVariadicBuffers() const;
   bool HasVariadicBuffers() const;
 
  private:
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index 03d8c32c4e3..5b8b5ed3c86 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -44,10 +44,8 @@
 #include "arrow/util/endian.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/sort_internal.h"
-#include "arrow/util/span.h"
 #include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
-
 namespace arrow {
 
 using internal::checked_cast;
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index bd0d00126d5..fe203539548 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -650,9 +650,9 @@ struct ValidateArrayImpl {
                              HexEncode(data, BinaryViewType::kPrefixSize));
     };
 
-    util::span views(data.GetValues<BinaryViewType::c_type>(1),
+    std::span views(data.GetValues<BinaryViewType::c_type>(1),
                      static_cast<size_t>(data.length));
-    util::span data_buffers(data.buffers.data() + 2, data.buffers.size() - 2);
+    std::span data_buffers(data.buffers.data() + 2, data.buffers.size() - 2);
 
     for (size_t i = 0; i < static_cast<size_t>(data.length); ++i) {
       if (data.IsNull(i)) continue;
@@ -663,7 +663,7 @@ struct ValidateArrayImpl {
       }
 
       if (views[i].is_inline()) {
-        auto padding_bytes = util::span(views[i].inlined.data).subspan(views[i].size());
+        auto padding_bytes = std::span(views[i].inlined.data).subspan(views[i].size());
         for (auto padding_byte : padding_bytes) {
           if (padding_byte != 0) {
             return Status::Invalid("View at slot ", i, " was inline with size ",
diff --git a/cpp/src/arrow/buffer.h b/cpp/src/arrow/buffer.h
index ce909a3ea18..a2c84120827 100644
--- a/cpp/src/arrow/buffer.h
+++ b/cpp/src/arrow/buffer.h
@@ -21,6 +21,7 @@
 #include <cstring>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -30,7 +31,6 @@
 #include "arrow/status.h"
 #include "arrow/type_fwd.h"
 #include "arrow/util/macros.h"
-#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
@@ -236,8 +236,8 @@ class ARROW_EXPORT Buffer {
 
   /// \brief Return the buffer's data as a span
   template <typename T>
-  util::span<const T> span_as() const {
-    return util::span(data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
+  std::span<const T> span_as() const {
+    return std::span(data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
   }
 
   /// \brief Return a writable pointer to the buffer's data
@@ -269,8 +269,8 @@ class ARROW_EXPORT Buffer {
 
   /// \brief Return the buffer's mutable data as a span
   template <typename T>
-  util::span<T> mutable_span_as() {
-    return util::span(mutable_data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
+  std::span<T> mutable_span_as() {
+    return std::span(mutable_data_as<T>(), static_cast<size_t>(size() / sizeof(T)));
   }
 
   /// \brief Return the device address of the buffer's data
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index dd25ed299dd..eef4ce0862e 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -603,7 +603,7 @@ struct ArrayExporter {
                    });
 
     if (need_variadic_buffer_sizes) {
-      auto variadic_buffers = util::span(data->buffers).subspan(2);
+      auto variadic_buffers = std::span(data->buffers).subspan(2);
       export_.variadic_buffer_sizes_.resize(variadic_buffers.size());
       size_t i = 0;
       for (const auto& buf : variadic_buffers) {
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index c6a5e01e038..d56f1555d5d 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -592,8 +592,8 @@ struct ArrayExportChecker {
       ASSERT_EQ(c_export->buffers[i], expected_ptr);
     }
     if (has_variadic_buffer_sizes) {
-      auto variadic_buffers = util::span(expected_data.buffers).subspan(2);
-      auto variadic_buffer_sizes = util::span(
+      auto variadic_buffers = std::span(expected_data.buffers).subspan(2);
+      auto variadic_buffer_sizes = std::span(
           static_cast<const int64_t*>(c_export->buffers[c_export->n_buffers - 1]),
           variadic_buffers.size());
       for (auto [buf, size] : Zip(variadic_buffers, variadic_buffer_sizes)) {
diff --git a/cpp/src/arrow/chunk_resolver.cc b/cpp/src/arrow/chunk_resolver.cc
index 7fc259f38c2..a78548757ed 100644
--- a/cpp/src/arrow/chunk_resolver.cc
+++ b/cpp/src/arrow/chunk_resolver.cc
@@ -28,8 +28,6 @@
 
 namespace arrow {
 
-using util::span;
-
 namespace {
 template <typename T>
 int64_t GetLength(const T& array) {
@@ -44,7 +42,7 @@ int64_t GetLength<std::shared_ptr<RecordBatch>>(
 }
 
 template <typename T>
-inline std::vector<int64_t> MakeChunksOffsets(span<T> chunks) {
+inline std::vector<int64_t> MakeChunksOffsets(std::span<T> chunks) {
   std::vector<int64_t> offsets(chunks.size() + 1);
   int64_t offset = 0;
   std::transform(chunks.begin(), chunks.end(), offsets.begin(),
@@ -114,13 +112,13 @@ void ResolveManyInline(uint32_t num_offsets, const int64_t* signed_offsets,
 }  // namespace
 
 ChunkResolver::ChunkResolver(const ArrayVector& chunks) noexcept
-    : offsets_(MakeChunksOffsets(span(chunks))), cached_chunk_(0) {}
+    : offsets_(MakeChunksOffsets(std::span(chunks))), cached_chunk_(0) {}
 
-ChunkResolver::ChunkResolver(span<const Array* const> chunks) noexcept
+ChunkResolver::ChunkResolver(std::span<const Array* const> chunks) noexcept
     : offsets_(MakeChunksOffsets(chunks)), cached_chunk_(0) {}
 
 ChunkResolver::ChunkResolver(const RecordBatchVector& batches) noexcept
-    : offsets_(MakeChunksOffsets(span(batches))), cached_chunk_(0) {}
+    : offsets_(MakeChunksOffsets(std::span(batches))), cached_chunk_(0) {}
 
 ChunkResolver::ChunkResolver(ChunkResolver&& other) noexcept
     : offsets_(std::move(other.offsets_)),
diff --git a/cpp/src/arrow/chunk_resolver.h b/cpp/src/arrow/chunk_resolver.h
index 3d6458167fa..fbf84876e3d 100644
--- a/cpp/src/arrow/chunk_resolver.h
+++ b/cpp/src/arrow/chunk_resolver.h
@@ -21,12 +21,12 @@
 #include <cassert>
 #include <cstdint>
 #include <limits>
+#include <span>
 #include <type_traits>
 #include <vector>
 
 #include "arrow/type_fwd.h"
 #include "arrow/util/macros.h"
-#include "arrow/util/span.h"
 
 namespace arrow {
 
@@ -77,7 +77,7 @@ class ARROW_EXPORT ChunkResolver {
 
  public:
   explicit ChunkResolver(const ArrayVector& chunks) noexcept;
-  explicit ChunkResolver(util::span<const Array* const> chunks) noexcept;
+  explicit ChunkResolver(std::span<const Array* const> chunks) noexcept;
   explicit ChunkResolver(const RecordBatchVector& batches) noexcept;
 
   /// \brief Construct a ChunkResolver from a vector of chunks.size() + 1 offsets.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_pivot.cc b/cpp/src/arrow/compute/kernels/aggregate_pivot.cc
index 504c7cdd26d..8b73ecfe554 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_pivot.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_pivot.cc
@@ -29,8 +29,6 @@ namespace arrow::compute::internal {
 namespace {
 
 using arrow::internal::VisitSetBitRunsVoid;
-using arrow::util::span;
-
 struct PivotImpl : public ScalarAggregator {
   Status Init(const PivotWiderOptions& options, const std::vector<TypeHolder>& in_types,
               ExecContext* ctx) {
diff --git a/cpp/src/arrow/compute/kernels/chunked_internal.cc b/cpp/src/arrow/compute/kernels/chunked_internal.cc
index bf574fcafd0..b62dc1436c2 100644
--- a/cpp/src/arrow/compute/kernels/chunked_internal.cc
+++ b/cpp/src/arrow/compute/kernels/chunked_internal.cc
@@ -32,7 +32,7 @@ std::vector<const Array*> GetArrayPointers(const ArrayVector& arrays) {
 }
 
 std::vector<int64_t> ChunkedIndexMapper::GetChunkLengths(
-    util::span<const Array* const> chunks) {
+    std::span<const Array* const> chunks) {
   std::vector<int64_t> chunk_lengths(chunks.size());
   for (int64_t i = 0; i < static_cast<int64_t>(chunks.size()); ++i) {
     chunk_lengths[i] = chunks[i]->length();
diff --git a/cpp/src/arrow/compute/kernels/chunked_internal.h b/cpp/src/arrow/compute/kernels/chunked_internal.h
index 330bd185f25..1c3105f6915 100644
--- a/cpp/src/arrow/compute/kernels/chunked_internal.h
+++ b/cpp/src/arrow/compute/kernels/chunked_internal.h
@@ -20,15 +20,14 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <utility>
 #include <vector>
 
 #include "arrow/array.h"
 #include "arrow/chunk_resolver.h"
 #include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
-
 namespace arrow::compute::internal {
 
 // The target chunk in a chunked array.
@@ -92,13 +91,13 @@ static_assert(sizeof(uint64_t) == sizeof(CompressedChunkLocation));
 class ChunkedArrayResolver {
  private:
   ChunkResolver resolver_;
-  util::span<const Array* const> chunks_;
+  std::span<const Array* const> chunks_;
   std::vector<const Array*> owned_chunks_;
 
  public:
   explicit ChunkedArrayResolver(std::vector<const Array*>&& chunks)
       : resolver_(chunks), chunks_(chunks), owned_chunks_(std::move(chunks)) {}
-  explicit ChunkedArrayResolver(util::span<const Array* const> chunks)
+  explicit ChunkedArrayResolver(std::span<const Array* const> chunks)
       : resolver_(chunks), chunks_(chunks) {}
 
   ARROW_DEFAULT_MOVE_AND_ASSIGN(ChunkedArrayResolver);
@@ -129,8 +128,8 @@ class ARROW_EXPORT ChunkedIndexMapper {
  public:
   ChunkedIndexMapper(const std::vector<const Array*>& chunks, uint64_t* indices_begin,
                      uint64_t* indices_end)
-      : ChunkedIndexMapper(util::span(chunks), indices_begin, indices_end) {}
-  ChunkedIndexMapper(util::span<const Array* const> chunks, uint64_t* indices_begin,
+      : ChunkedIndexMapper(std::span(chunks), indices_begin, indices_end) {}
+  ChunkedIndexMapper(std::span<const Array* const> chunks, uint64_t* indices_begin,
                      uint64_t* indices_end)
       : chunk_lengths_(GetChunkLengths(chunks)),
         indices_begin_(indices_begin),
@@ -154,7 +153,7 @@ class ARROW_EXPORT ChunkedIndexMapper {
   Status PhysicalToLogical();
 
  private:
-  static std::vector<int64_t> GetChunkLengths(util::span<const Array* const> chunks);
+  static std::vector<int64_t> GetChunkLengths(std::span<const Array* const> chunks);
   static std::vector<int64_t> GetChunkLengths(const RecordBatchVector& chunks);
 
   std::vector<int64_t> chunk_lengths_;
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index ed50025ef5f..5ab9ff46d7b 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -19,6 +19,7 @@
 #include <concepts>
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -45,15 +46,11 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/ree_util.h"
-#include "arrow/util/span.h"
 #include "arrow/visit_type_inline.h"
-
 namespace arrow::compute::internal {
 
 using ::arrow::internal::checked_cast;
 using ::arrow::internal::FirstTimeBitmapWriter;
-using ::arrow::util::span;
-
 namespace {
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_numeric.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_numeric.cc
index aa231430aa0..652684dd48c 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_numeric.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_numeric.cc
@@ -18,6 +18,7 @@
 #include <cmath>
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -32,10 +33,8 @@
 #include "arrow/compute/row/grouper.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/int128_internal.h"
-#include "arrow/util/span.h"
 #include "arrow/util/tdigest_internal.h"
 #include "arrow/visit_type_inline.h"
-
 namespace arrow::compute::internal {
 namespace {
 
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_pivot.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_pivot.cc
index f60aa367ca2..030a862afc0 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_pivot.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_pivot.cc
@@ -18,6 +18,7 @@
 #include <cmath>
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -33,13 +34,10 @@
 #include "arrow/util/bit_block_counter.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging_internal.h"
-#include "arrow/util/span.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow::compute::internal {
 
-using ::arrow::util::span;
-
 namespace {
 
 // ----------------------------------------------------------------------
@@ -57,7 +55,7 @@ struct GroupedPivotAccumulator {
     return Status::OK();
   }
 
-  Status Consume(span<const uint32_t> groups, const std::shared_ptr<ArrayData>& keys,
+  Status Consume(std::span<const uint32_t> groups, const std::shared_ptr<ArrayData>& keys,
                  const ArraySpan& values) {
     // To dispatch the values into the right (group, key) coordinates,
     // we first compute a vector of take indices for each output column.
@@ -178,8 +176,8 @@ struct GroupedPivotAccumulator {
     return MergeColumns(std::move(new_columns));
   }
 
-  Status Consume(span<const uint32_t> groups, std::optional<PivotWiderKeyIndex> maybe_key,
-                 const ArraySpan& values) {
+  Status Consume(std::span<const uint32_t> groups,
+                 std::optional<PivotWiderKeyIndex> maybe_key, const ArraySpan& values) {
     if (!maybe_key.has_value()) {
       // Nothing to update
       return Status::OK();
diff --git a/cpp/src/arrow/compute/kernels/pivot_internal.cc b/cpp/src/arrow/compute/kernels/pivot_internal.cc
index e9065152d7f..c9ccc7d6076 100644
--- a/cpp/src/arrow/compute/kernels/pivot_internal.cc
+++ b/cpp/src/arrow/compute/kernels/pivot_internal.cc
@@ -37,8 +37,6 @@
 
 namespace arrow::compute::internal {
 
-using ::arrow::util::span;
-
 struct ConcretePivotWiderKeyMapper : public PivotWiderKeyMapper {
   Status Init(const DataType& key_type, const PivotWiderOptions* options,
               ExecContext* ctx) {
diff --git a/cpp/src/arrow/compute/kernels/vector_rank.cc b/cpp/src/arrow/compute/kernels/vector_rank.cc
index ef7419ea7c5..adac794902d 100644
--- a/cpp/src/arrow/compute/kernels/vector_rank.cc
+++ b/cpp/src/arrow/compute/kernels/vector_rank.cc
@@ -27,8 +27,6 @@
 
 namespace arrow::compute::internal {
 
-using ::arrow::util::span;
-
 namespace {
 
 // ----------------------------------------------------------------------
@@ -103,7 +101,8 @@ Result<NullPartitionResult> DoSortAndMarkDuplicate(
                                          physical_chunks, order, null_placement));
   if (needs_duplicates) {
     const auto arrays = GetArrayPointers(physical_chunks);
-    auto value_selector = [resolver = ChunkedArrayResolver(span(arrays))](int64_t index) {
+    auto value_selector = [resolver =
+                               ChunkedArrayResolver(std::span(arrays))](int64_t index) {
       return resolver.Resolve(index).Value<ArrowType>();
     };
     MarkDuplicates(sorted, value_selector);
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 41cb0a357a4..7cf60d1c2f2 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -26,8 +26,6 @@
 namespace arrow {
 
 using internal::checked_cast;
-using util::span;
-
 namespace compute {
 namespace internal {
 
@@ -177,7 +175,8 @@ class ChunkedArraySorter : public TypeVisitor {
   template <typename ArrayType>
   void MergeNonNulls(CompressedChunkLocation* range_begin,
                      CompressedChunkLocation* range_middle,
-                     CompressedChunkLocation* range_end, span<const Array* const> arrays,
+                     CompressedChunkLocation* range_end,
+                     std::span<const Array* const> arrays,
                      CompressedChunkLocation* temp_indices) {
     using ArrowType = typename ArrayType::TypeClass;
 
@@ -202,7 +201,8 @@ class ChunkedArraySorter : public TypeVisitor {
   }
 
   template <typename ArrowType>
-  auto ChunkValue(span<const Array* const> arrays, CompressedChunkLocation loc) const {
+  auto ChunkValue(std::span<const Array* const> arrays,
+                  CompressedChunkLocation loc) const {
     return ResolvedChunk(arrays[loc.chunk_index()],
                          static_cast<int64_t>(loc.index_in_chunk()))
         .template Value<ArrowType>();
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_internal.h b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
index 49704ff8069..8744a0a9182 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_internal.h
+++ b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
@@ -272,7 +272,7 @@ NullPartitionResult PartitionNullsOnly(uint64_t* indices_begin, uint64_t* indice
 template <typename Partitioner>
 ChunkedNullPartitionResult PartitionNullsOnly(CompressedChunkLocation* locations_begin,
                                               CompressedChunkLocation* locations_end,
-                                              util::span<const Array* const> chunks,
+                                              std::span<const Array* const> chunks,
                                               int64_t null_count,
                                               NullPlacement null_placement) {
   if (null_count == 0) {
diff --git a/cpp/src/arrow/integration/json_internal.cc b/cpp/src/arrow/integration/json_internal.cc
index 4b0fc693931..7ae5a2144bd 100644
--- a/cpp/src/arrow/integration/json_internal.cc
+++ b/cpp/src/arrow/integration/json_internal.cc
@@ -15,13 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/integration/json_internal.h"
-
 #include <cstdint>
 #include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <memory>
+#include <span>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -33,6 +32,7 @@
 #include "arrow/array/builder_primitive.h"
 #include "arrow/array/builder_time.h"
 #include "arrow/extension_type.h"
+#include "arrow/integration/json_internal.h"
 #include "arrow/ipc/dictionary.h"
 #include "arrow/record_batch.h"
 #include "arrow/result.h"
@@ -48,12 +48,10 @@
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/range.h"
-#include "arrow/util/span.h"
 #include "arrow/util/string.h"
 #include "arrow/util/value_parsing.h"
 #include "arrow/visit_array_inline.h"
 #include "arrow/visit_type_inline.h"
-
 using arrow::internal::checked_cast;
 using arrow::internal::Enumerate;
 using arrow::internal::ParseValue;
@@ -1461,11 +1459,10 @@ class ArrayReader {
                           GetMemberArray(obj_, "VARIADIC_DATA_BUFFERS"));
 
     using internal::Zip;
-    using util::span;
 
     BufferVector buffers;
     buffers.resize(json_variadic_bufs.Size() + 2);
-    for (auto [json_buf, buf] : Zip(json_variadic_bufs, span{buffers}.subspan(2))) {
+    for (auto [json_buf, buf] : Zip(json_variadic_bufs, std::span{buffers}.subspan(2))) {
       ARROW_ASSIGN_OR_RAISE(auto hex_string, GetStringView(json_buf));
       ARROW_ASSIGN_OR_RAISE(
           buf, AllocateBuffer(static_cast<int64_t>(hex_string.size()) / 2, pool_));
@@ -1482,8 +1479,8 @@ class ArrayReader {
     ARROW_ASSIGN_OR_RAISE(
         buffers[1], AllocateBuffer(length_ * sizeof(BinaryViewType::c_type), pool_));
 
-    span views{buffers[1]->mutable_data_as<BinaryViewType::c_type>(),
-               static_cast<size_t>(length_)};
+    std::span views{buffers[1]->mutable_data_as<BinaryViewType::c_type>(),
+                    static_cast<size_t>(length_)};
 
     int64_t null_count = 0;
     for (auto [json_view, out_view, is_valid] : Zip(json_views, views, is_valid_)) {
diff --git a/cpp/src/arrow/util/binary_view_util.h b/cpp/src/arrow/util/binary_view_util.h
index eb079e2c548..edd585d8a4b 100644
--- a/cpp/src/arrow/util/binary_view_util.h
+++ b/cpp/src/arrow/util/binary_view_util.h
@@ -17,11 +17,11 @@
 
 #pragma once
 
+#include <span>
 #include <string_view>
 #include <utility>
 
 #include "arrow/type.h"
-#include "arrow/util/span.h"
 
 namespace arrow::util {
 
diff --git a/cpp/src/arrow/util/bitmap.h b/cpp/src/arrow/util/bitmap.h
index 141d558c3a8..af5c6ecb5a7 100644
--- a/cpp/src/arrow/util/bitmap.h
+++ b/cpp/src/arrow/util/bitmap.h
@@ -24,6 +24,7 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <span>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -36,10 +37,8 @@
 #include "arrow/util/compare.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/functional.h"
-#include "arrow/util/span.h"
 #include "arrow/util/string_util.h"
 #include "arrow/util/visibility.h"
-
 namespace arrow {
 
 class BooleanArray;
@@ -155,7 +154,7 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
     Bitmap bitmaps[N];
     int64_t offsets[N];
     int64_t bit_length = BitLength(bitmaps_arg, N);
-    util::span<const Word> words[N];
+    std::span<const Word> words[N];
     for (size_t i = 0; i < N; ++i) {
       bitmaps[i] = bitmaps_arg[i];
       offsets[i] = bitmaps[i].template word_offset<Word>();
@@ -384,7 +383,7 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
   int64_t length() const { return length_; }
 
   /// span of all bytes which contain any bit in this Bitmap
-  util::span<const uint8_t> bytes() const {
+  std::span<const uint8_t> bytes() const {
     auto byte_offset = offset_ / 8;
     auto byte_count = bit_util::CeilDiv(offset_ + length_, 8) - byte_offset;
     return {data_ + byte_offset, static_cast<size_t>(byte_count)};
@@ -404,7 +403,7 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
   /// \warning The words may contain bytes which lie outside the buffer or are
   /// uninitialized.
   template <typename Word>
-  util::span<const Word> words() const {
+  std::span<const Word> words() const {
     auto bytes_addr = reinterpret_cast<intptr_t>(bytes().data());
     auto words_addr = bytes_addr - bytes_addr % sizeof(Word);
     auto word_byte_count =
diff --git a/cpp/src/arrow/util/bitmap_builders.cc b/cpp/src/arrow/util/bitmap_builders.cc
index 000dda718d0..0014384d5ce 100644
--- a/cpp/src/arrow/util/bitmap_builders.cc
+++ b/cpp/src/arrow/util/bitmap_builders.cc
@@ -33,7 +33,7 @@ namespace internal {
 
 namespace {
 
-void FillBitsFromBytes(util::span<const uint8_t> bytes, uint8_t* bits) {
+void FillBitsFromBytes(std::span<const uint8_t> bytes, uint8_t* bits) {
   for (size_t i = 0; i < bytes.size(); ++i) {
     if (bytes[i] > 0) {
       bit_util::SetBit(bits, i);
@@ -43,7 +43,7 @@ void FillBitsFromBytes(util::span<const uint8_t> bytes, uint8_t* bits) {
 
 }  // namespace
 
-Result<std::shared_ptr<Buffer>> BytesToBits(util::span<const uint8_t> bytes,
+Result<std::shared_ptr<Buffer>> BytesToBits(std::span<const uint8_t> bytes,
                                             MemoryPool* pool) {
   int64_t bit_length = bit_util::BytesForBits(bytes.size());
 
diff --git a/cpp/src/arrow/util/bitmap_builders.h b/cpp/src/arrow/util/bitmap_builders.h
index 4bf2edfdcbd..b9f98f679d0 100644
--- a/cpp/src/arrow/util/bitmap_builders.h
+++ b/cpp/src/arrow/util/bitmap_builders.h
@@ -19,13 +19,12 @@
 
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <vector>
 
 #include "arrow/result.h"
 #include "arrow/type_fwd.h"
-#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
-
 namespace arrow {
 namespace internal {
 
@@ -37,7 +36,7 @@ Result<std::shared_ptr<Buffer>> BitmapAllButOne(MemoryPool* pool, int64_t length
 
 /// \brief Convert vector of bytes to bitmap buffer
 ARROW_EXPORT
-Result<std::shared_ptr<Buffer>> BytesToBits(util::span<const uint8_t> bytes,
+Result<std::shared_ptr<Buffer>> BytesToBits(std::span<const uint8_t> bytes,
                                             MemoryPool* pool = default_memory_pool());
 
 }  // namespace internal
diff --git a/cpp/src/arrow/util/float16_test.cc b/cpp/src/arrow/util/float16_test.cc
index 5918381a269..63670a6b33a 100644
--- a/cpp/src/arrow/util/float16_test.cc
+++ b/cpp/src/arrow/util/float16_test.cc
@@ -17,6 +17,7 @@
 
 #include <array>
 #include <cmath>
+#include <span>
 #include <utility>
 
 #include <gtest/gtest.h>
@@ -24,9 +25,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/float16.h"
-#include "arrow/util/span.h"
 #include "arrow/util/ubsan.h"
-
 namespace arrow::util {
 namespace {
 
diff --git a/cpp/src/arrow/util/rle_encoding_test.cc b/cpp/src/arrow/util/rle_encoding_test.cc
index b2d4f7df6f1..92eb3af8ea9 100644
--- a/cpp/src/arrow/util/rle_encoding_test.cc
+++ b/cpp/src/arrow/util/rle_encoding_test.cc
@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <cstring>
 #include <random>
+#include <span>
 #include <vector>
 
 #include <gtest/gtest.h>
@@ -35,8 +36,6 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/rle_encoding_internal.h"
-#include "arrow/util/span.h"
-
 namespace arrow::util {
 
 const int MAX_WIDTH = 32;
diff --git a/cpp/src/arrow/util/secure_string.cc b/cpp/src/arrow/util/secure_string.cc
index bd52c55f312..d29edf080da 100644
--- a/cpp/src/arrow/util/secure_string.cc
+++ b/cpp/src/arrow/util/secure_string.cc
@@ -19,6 +19,7 @@
 // https://en.cppreference.com/w/c/string/byte/memset
 #define __STDC_WANT_LIB_EXT1__ 1
 #include <string.h>
+#include <span>
 #include <utility>
 
 #if defined(ARROW_USE_OPENSSL)
@@ -26,15 +27,13 @@
 #  include <openssl/opensslv.h>
 #endif
 
+#include "arrow/util/logging.h"
+#include "arrow/util/secure_string.h"
 #include "arrow/util/windows_compatibility.h"
+
 #if defined(_WIN32)
 #  include <windows.h>
 #endif
-
-#include "arrow/util/logging.h"
-#include "arrow/util/secure_string.h"
-#include "arrow/util/span.h"
-
 namespace arrow::util {
 
 /// Note:
@@ -181,11 +180,11 @@ std::size_t SecureString::length() const { return secret_.length(); }
 
 std::size_t SecureString::capacity() const { return secret_.capacity(); }
 
-span<uint8_t> SecureString::as_span() {
+std::span<uint8_t> SecureString::as_span() {
   return {reinterpret_cast<uint8_t*>(secret_.data()), secret_.size()};
 }
 
-span<const uint8_t> SecureString::as_span() const {
+std::span<const uint8_t> SecureString::as_span() const {
   return {reinterpret_cast<const uint8_t*>(secret_.data()), secret_.size()};
 }
 
diff --git a/cpp/src/arrow/util/secure_string.h b/cpp/src/arrow/util/secure_string.h
index 30088c78d4c..36602c6a92f 100644
--- a/cpp/src/arrow/util/secure_string.h
+++ b/cpp/src/arrow/util/secure_string.h
@@ -18,9 +18,9 @@
 #pragma once
 
 #include <cstdint>
+#include <span>
 #include <string>
 
-#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow::util {
@@ -56,8 +56,8 @@ class ARROW_EXPORT SecureString {
   [[nodiscard]] std::size_t length() const;
   [[nodiscard]] std::size_t capacity() const;
 
-  [[nodiscard]] span<uint8_t> as_span();
-  [[nodiscard]] span<const uint8_t> as_span() const;
+  [[nodiscard]] std::span<uint8_t> as_span();
+  [[nodiscard]] std::span<const uint8_t> as_span() const;
   [[nodiscard]] std::string_view as_view() const;
 
   void Dispose();
diff --git a/cpp/src/arrow/util/span.h b/cpp/src/arrow/util/span.h
deleted file mode 100644
index abe8e61bebb..00000000000
--- a/cpp/src/arrow/util/span.h
+++ /dev/null
@@ -1,132 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <type_traits>
-
-namespace arrow::util {
-
-template <class T>
-class span;
-
-/// std::span polyfill.
-///
-/// Does not support static extents.
-template <typename T>
-class span {
-  static_assert(sizeof(T),
-                R"(
-std::span allows contiguous_iterators instead of just pointers, the enforcement
-of which requires T to be a complete type. arrow::util::span does not support
-contiguous_iterators, but T is still required to be a complete type to prevent
-writing code which would break when it is replaced by std::span.)");
-
- public:
-  using element_type = T;
-  using value_type = std::remove_cv_t<T>;
-  using iterator = T*;
-  using const_iterator = const T*;
-
-  span() = default;
-  span(const span&) = default;
-  span& operator=(const span&) = default;
-
-  template <typename M, typename = std::enable_if_t<std::is_same_v<T, const M>>>
-  // NOLINTNEXTLINE runtime/explicit
-  constexpr span(span<M> mut) : span{mut.data(), mut.size()} {}
-
-  constexpr span(T* data, size_t count) : data_{data}, size_{count} {}
-
-  constexpr span(T* begin, T* end)
-      : data_{begin}, size_{static_cast<size_t>(end - begin)} {}
-
-  template <typename R, typename RD = decltype(std::data(std::declval<R>())),
-            typename RS = decltype(std::size(std::declval<R>())),
-            typename E = std::enable_if_t<std::is_constructible_v<T*, RD> &&
-                                          std::is_constructible_v<size_t, RS>>>
-  // NOLINTNEXTLINE runtime/explicit, non-const reference
-  constexpr span(R&& range) : data_{std::data(range)}, size_{std::size(range)} {}
-
-  constexpr T* begin() const { return data_; }
-  constexpr T* end() const { return data_ + size_; }
-  constexpr T* data() const { return data_; }
-
-  constexpr size_t size() const { return size_; }
-  constexpr size_t size_bytes() const { return size_ * sizeof(T); }
-  constexpr bool empty() const { return size_ == 0; }
-
-  constexpr T& operator[](size_t i) { return data_[i]; }
-  constexpr const T& operator[](size_t i) const { return data_[i]; }
-
-  constexpr span subspan(size_t offset) const {
-    if (offset > size_) return {data_, data_};
-    return {data_ + offset, size_ - offset};
-  }
-
-  constexpr span subspan(size_t offset, size_t count) const {
-    auto out = subspan(offset);
-    if (count < out.size_) {
-      out.size_ = count;
-    }
-    return out;
-  }
-
-  constexpr bool operator==(const span& other) const {
-    if (size_ != other.size_) return false;
-
-    if constexpr (std::is_integral_v<T>) {
-      if (size_ == 0) {
-        return true;  // memcmp does not handle null pointers, even if size_ == 0
-      }
-      return std::memcmp(data_, other.data_, size_bytes()) == 0;
-    } else {
-      T* ptr = data_;
-      for (const T& e : other) {
-        if (*ptr++ != e) return false;
-      }
-      return true;
-    }
-  }
-  constexpr bool operator!=(const span& other) const { return !(*this == other); }
-
- private:
-  T* data_{};
-  size_t size_{};
-};
-
-template <typename R>
-span(R& range) -> span<std::remove_pointer_t<decltype(std::data(range))>>;
-
-template <typename T>
-span(T*, size_t) -> span<T>;
-
-template <typename T>
-constexpr span<const std::byte> as_bytes(span<T> s) {
-  return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
-}
-
-template <typename T>
-constexpr span<std::byte> as_writable_bytes(span<T> s) {
-  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
-}
-
-}  // namespace arrow::util
diff --git a/cpp/src/arrow/util/span_test.cc b/cpp/src/arrow/util/span_test.cc
deleted file mode 100644
index 01460c2bd03..00000000000
--- a/cpp/src/arrow/util/span_test.cc
+++ /dev/null
@@ -1,204 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <cstddef>
-#include <iostream>
-
-#include <gtest/gtest.h>
-
-#include "arrow/testing/gtest_util.h"
-#include "arrow/testing/matchers.h"
-#include "arrow/util/span.h"
-
-using testing::ElementsAre;
-using testing::ElementsAreArray;
-using testing::PrintToString;
-
-namespace arrow::util {
-
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const span<T>& span) {
-  // Inefficient but good enough for testing
-  os << PrintToString(std::vector(span.begin(), span.end()));
-  return os;
-}
-
-TEST(Span, Construction) {
-  // const spans may be constructed from mutable spans
-  static_assert(std::is_constructible_v<span<const int>, span<int>>);
-  // ... but mutable spans may be constructed from const spans
-  static_assert(!std::is_constructible_v<span<int>, span<const int>>);
-
-  int arr[] = {1, 2, 3};
-  constexpr int const_arr[] = {7, 8, 9};
-
-  static_assert(std::is_constructible_v<span<int>, decltype(arr)&>);
-  static_assert(!std::is_constructible_v<span<int>, decltype(const_arr)&>);
-
-  static_assert(std::is_constructible_v<span<const int>, decltype(arr)&>);
-  static_assert(std::is_constructible_v<span<const int>, decltype(const_arr)&>);
-
-  static_assert(std::is_constructible_v<span<int>, std::vector<int>&>);
-  static_assert(!std::is_constructible_v<span<int>, const std::vector<int>&>);
-  static_assert(!std::is_constructible_v<span<int>, std::vector<int>&&>);
-
-  static_assert(std::is_constructible_v<span<const int>, std::vector<int>&>);
-  static_assert(std::is_constructible_v<span<const int>, const std::vector<int>&>);
-  // const spans may even be constructed from rvalue ranges
-  static_assert(std::is_constructible_v<span<const int>, std::vector<int>&&>);
-
-  EXPECT_THAT(span<const int>(const_arr), ElementsAreArray(const_arr));
-  EXPECT_THAT(span<int>(arr), ElementsAreArray(arr));
-
-  static_assert(!std::is_constructible_v<span<const unsigned>, decltype(const_arr)&>);
-  static_assert(!std::is_constructible_v<span<const std::byte>, decltype(const_arr)&>);
-}
-
-TEST(Span, TemplateArgumentDeduction) {
-  int arr[3];
-  const int const_arr[] = {1, 2, 3};
-  std::vector<int> vec;
-  const std::vector<int> const_vec;
-  static_assert(std::is_same_v<decltype(span(arr)), span<int>>);
-  static_assert(std::is_same_v<decltype(span(vec)), span<int>>);
-  static_assert(std::is_same_v<decltype(span(const_arr)), span<const int>>);
-  static_assert(std::is_same_v<decltype(span(const_vec)), span<const int>>);
-}
-
-TEST(Span, Size) {
-  int arr[] = {1, 2, 3};
-  EXPECT_EQ(span(arr).size(), 3);
-  EXPECT_EQ(span(arr).size_bytes(), sizeof(int) * 3);
-
-  std::vector<int> vec;
-  EXPECT_TRUE(span(vec).empty());
-  EXPECT_EQ(span(vec).size(), 0);
-  EXPECT_EQ(span(vec).size_bytes(), 0);
-
-  vec.resize(999);
-  EXPECT_FALSE(span(vec).empty());
-  EXPECT_EQ(span(vec).size(), 999);
-  EXPECT_EQ(span(vec).size_bytes(), sizeof(int) * 999);
-}
-
-TEST(Span, Equality) {
-  auto check_eq = [](auto l, auto r) {
-    ARROW_SCOPED_TRACE("l = ", l, ", r = ", r);
-    EXPECT_TRUE(l == r);
-    EXPECT_FALSE(l != r);
-  };
-  auto check_ne = [](auto l, auto r) {
-    ARROW_SCOPED_TRACE("l = ", l, ", r = ", r);
-    EXPECT_TRUE(l != r);
-    EXPECT_FALSE(l == r);
-  };
-
-  {
-    // exercise integral branch with memcmp
-    check_eq(span<int>(), span<int>());
-
-    int arr[] = {1, 2, 3};
-    check_eq(span(arr), span(arr));
-    check_eq(span(arr).subspan(1), span(arr).subspan(1));
-    check_ne(span(arr).subspan(1), span(arr).subspan(2));
-
-    std::vector<int> vec{1, 2, 3};
-    check_eq(span(vec), span(arr));
-    check_eq(span(vec).subspan(1), span(arr).subspan(1));
-
-    vec = {2, 3, 4};
-    check_ne(span(vec), span(arr));
-    check_eq(span(vec).subspan(0, 2), span(arr).subspan(1));
-
-    // 0-sized
-    vec = {};
-    check_ne(span(vec), span(arr));
-    check_eq(span(vec), span(arr).subspan(3));
-  }
-  {
-    // exercise non-integral branch with for loop
-    check_eq(span<std::string>(), span<std::string>());
-
-    std::string arr[] = {"a", "b", "c"};
-    check_eq(span(arr), span(arr));
-    check_eq(span(arr).subspan(1), span(arr).subspan(1));
-
-    std::vector<std::string> vec{"a", "b", "c"};
-    check_eq(span(vec), span(arr));
-    check_eq(span(vec).subspan(1), span(arr).subspan(1));
-
-    vec = {"b", "c", "d"};
-    check_ne(span(vec), span(arr));
-    check_eq(span(vec).subspan(0, 2), span(arr).subspan(1));
-
-    // 0-sized
-    vec = {};
-    check_ne(span(vec), span(arr));
-    check_eq(span(vec), span(arr).subspan(3));
-  }
-}
-
-TEST(Span, SubSpan) {
-  int arr[] = {1, 2, 3};
-  span s(arr);
-
-  auto ExpectIdentical = [](span<int> l, span<int> r) {
-    EXPECT_EQ(l.data(), r.data());
-    EXPECT_EQ(l.size(), r.size());
-  };
-
-  ExpectIdentical(s.subspan(0), s);
-  ExpectIdentical(s.subspan(0, s.size()), s);
-
-  for (size_t offset = 0; offset < s.size(); ++offset) {
-    span expected(arr + offset, s.size() - offset);
-    ExpectIdentical(s.subspan(offset), expected);
-    ExpectIdentical(s.subspan(offset, s.size() * 3), expected);
-  }
-  EXPECT_TRUE(s.subspan(s.size()).empty());
-  EXPECT_TRUE(s.subspan(s.size() * 3).empty());
-
-  for (size_t length = 0; length < s.size(); ++length) {
-    span expected(arr, length);
-    ExpectIdentical(s.subspan(0, length), expected);
-  }
-
-  ExpectIdentical(s.subspan(1, 1), span(arr + 1, 1));
-}
-
-TEST(Span, Mutation) {
-  size_t arr[] = {9, 9, 9, 9, 9};
-
-  span s(arr);
-  for (size_t i = 0; i < s.size(); ++i) {
-    s[i] = i * i;
-  }
-
-  EXPECT_THAT(arr, ElementsAre(0, 1, 4, 9, 16));
-
-  auto set = [](span<size_t> lhs, size_t rhs) {
-    for (size_t& i : lhs) {
-      i = rhs;
-    }
-  };
-  set(span(arr), 0);
-  set(span(arr).subspan(1), 1);
-  set(span(arr).subspan(2, 2), 23);
-  EXPECT_THAT(arr, ElementsAre(0, 1, 23, 23, 1));
-}
-
-}  // namespace arrow::util
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 94b67dfa807..f671651b31e 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -1781,7 +1781,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
     }
 
     auto add_levels = [](std::vector<int64_t>& level_histogram,
-                         ::arrow::util::span<const int16_t> levels, int16_t max_level) {
+                         std::span<const int16_t> levels, int16_t max_level) {
       if (max_level == 0) {
         return;
       }
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 66a3f7647fa..b7ac32ccfde 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -15,15 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <gtest/gtest.h>
-
 #include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <limits>
+#include <span>
 #include <utility>
 #include <vector>
 
+#include <gtest/gtest.h>
+
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/builder_dict.h"
@@ -39,18 +40,15 @@
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/endian.h"
-#include "arrow/util/span.h"
 #include "arrow/util/string.h"
 #include "parquet/encoding.h"
 #include "parquet/platform.h"
 #include "parquet/schema.h"
 #include "parquet/test_util.h"
 #include "parquet/types.h"
-
 using arrow::default_memory_pool;
 using arrow::MemoryPool;
 using arrow::internal::checked_cast;
-using arrow::util::span;
 
 namespace bit_util = arrow::bit_util;
 
@@ -1461,7 +1459,8 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
   USING_BASE_MEMBERS();
 
   template <typename U>
-  void CheckDecode(span<const uint8_t> encoded_data, span<const U> expected_decoded_data,
+  void CheckDecode(std::span<const uint8_t> encoded_data,
+                   std::span<const U> expected_decoded_data,
                    const ColumnDescriptor* descr = nullptr) {
     static_assert(sizeof(U) == sizeof(c_type));
     static_assert(std::is_same_v<U, FLBA> == std::is_same_v<c_type, FLBA>);
@@ -1479,8 +1478,8 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
     if constexpr (std::is_same_v<c_type, FLBA>) {
       auto type_length = descr->type_length();
       for (int i = 0; i < num_elements; ++i) {
-        ASSERT_EQ(span<const uint8_t>(expected_decoded_data[i].ptr, type_length),
-                  span<const uint8_t>(decoded_data[i].ptr, type_length));
+        ASSERT_EQ(std::span<const uint8_t>(expected_decoded_data[i].ptr, type_length),
+                  std::span<const uint8_t>(decoded_data[i].ptr, type_length));
       }
     } else {
       for (int i = 0; i < num_elements; ++i) {
@@ -1491,7 +1490,8 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
   }
 
   template <typename U>
-  void CheckEncode(span<const U> data, span<const uint8_t> expected_encoded_data,
+  void CheckEncode(std::span<const U> data,
+                   std::span<const uint8_t> expected_encoded_data,
                    const ColumnDescriptor* descr = nullptr) {
     static_assert(sizeof(U) == sizeof(c_type));
     static_assert(std::is_same_v<U, FLBA> == std::is_same_v<c_type, FLBA>);
@@ -1544,7 +1544,8 @@ void TestByteStreamSplitEncoding<Type>::CheckDecode() {
       const std::vector<FLBA> expected_output{
           FLBA{&raw_expected_output[0]}, FLBA{&raw_expected_output[3]},
           FLBA{&raw_expected_output[6]}, FLBA{&raw_expected_output[9]}};
-      CheckDecode(span{data}, span{expected_output}, FLBAColumnDescriptor(3).get());
+      CheckDecode(std::span{data}, std::span{expected_output},
+                  FLBAColumnDescriptor(3).get());
     }
     // - type_length = 1
     {
@@ -1553,7 +1554,8 @@ void TestByteStreamSplitEncoding<Type>::CheckDecode() {
       const std::vector<FLBA> expected_output{FLBA{&raw_expected_output[0]},
                                               FLBA{&raw_expected_output[1]},
                                               FLBA{&raw_expected_output[2]}};
-      CheckDecode(span{data}, span{expected_output}, FLBAColumnDescriptor(1).get());
+      CheckDecode(std::span{data}, std::span{expected_output},
+                  FLBAColumnDescriptor(1).get());
     }
   } else if constexpr (sizeof(c_type) == 4) {
     // INT32, FLOAT
@@ -1561,14 +1563,14 @@ void TestByteStreamSplitEncoding<Type>::CheckDecode() {
                                     0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC};
     const auto expected_output =
         ToLittleEndian<uint32_t>({0xAA774411U, 0xBB885522U, 0xCC996633U});
-    CheckDecode(span{data}, span{expected_output});
+    CheckDecode(std::span{data}, std::span{expected_output});
   } else {
     // INT64, DOUBLE
     const std::vector<uint8_t> data{0xDE, 0xC0, 0x37, 0x13, 0x11, 0x22, 0x33, 0x44,
                                     0xAA, 0xBB, 0xCC, 0xDD, 0x55, 0x66, 0x77, 0x88};
     const auto expected_output =
         ToLittleEndian<uint64_t>({0x7755CCAA331137DEULL, 0x8866DDBB442213C0ULL});
-    CheckDecode(span{data}, span{expected_output});
+    CheckDecode(std::span{data}, std::span{expected_output});
   }
 }
 
@@ -1584,7 +1586,8 @@ void TestByteStreamSplitEncoding<Type>::CheckEncode() {
                                    FLBA{&raw_data[6]}, FLBA{&raw_data[9]}};
       const std::vector<uint8_t> expected_output{0x11, 0x44, 0x77, 0xAA, 0x22, 0x55,
                                                  0x88, 0xBB, 0x33, 0x66, 0x99, 0xCC};
-      CheckEncode(span{data}, span{expected_output}, FLBAColumnDescriptor(3).get());
+      CheckEncode(std::span{data}, std::span{expected_output},
+                  FLBAColumnDescriptor(3).get());
     }
     // - type_length = 1
     {
@@ -1592,14 +1595,15 @@ void TestByteStreamSplitEncoding<Type>::CheckEncode() {
       const std::vector<FLBA> data{FLBA{&raw_data[0]}, FLBA{&raw_data[1]},
                                    FLBA{&raw_data[2]}};
       const std::vector<uint8_t> expected_output{0x11, 0x22, 0x33};
-      CheckEncode(span{data}, span{expected_output}, FLBAColumnDescriptor(1).get());
+      CheckEncode(std::span{data}, std::span{expected_output},
+                  FLBAColumnDescriptor(1).get());
     }
   } else if constexpr (sizeof(c_type) == 4) {
     // INT32, FLOAT
     const auto data = ToLittleEndian<uint32_t>({0xaabbccddUL, 0x11223344UL});
     const std::vector<uint8_t> expected_output{0xdd, 0x44, 0xcc, 0x33,
                                                0xbb, 0x22, 0xaa, 0x11};
-    CheckEncode(span{data}, span{expected_output});
+    CheckEncode(std::span{data}, std::span{expected_output});
   } else {
     // INT64, DOUBLE
     const auto data = ToLittleEndian<uint64_t>(
@@ -1608,7 +1612,7 @@ void TestByteStreamSplitEncoding<Type>::CheckEncode() {
         0x48, 0x08, 0xb8, 0x47, 0x07, 0xb7, 0x46, 0x06, 0xb6, 0x45, 0x05, 0xb5,
         0x44, 0x04, 0xb4, 0x43, 0x03, 0xb3, 0x42, 0x02, 0xb2, 0x41, 0x01, 0xb1,
     };
-    CheckEncode(span{data}, span{expected_output});
+    CheckEncode(std::span{data}, std::span{expected_output});
   }
 }
 
@@ -2111,7 +2115,7 @@ std::shared_ptr<Buffer> DeltaEncode(std::vector<int32_t> lengths) {
   return encoder->FlushValues();
 }
 
-std::shared_ptr<Buffer> DeltaEncode(::arrow::util::span<const int32_t> lengths) {
+std::shared_ptr<Buffer> DeltaEncode(std::span<const int32_t> lengths) {
   auto encoder = MakeTypedEncoder<Int32Type>(Encoding::DELTA_BINARY_PACKED);
   encoder->Put(lengths.data(), static_cast<int>(lengths.size()));
   return encoder->FlushValues();
@@ -2119,8 +2123,8 @@ std::shared_ptr<Buffer> DeltaEncode(::arrow::util::span<const int32_t> lengths)
 
 std::shared_ptr<Buffer> DeltaEncode(std::shared_ptr<::arrow::Array>& lengths) {
   auto data = ::arrow::internal::checked_pointer_cast<const ::arrow::Int32Array>(lengths);
-  auto span = ::arrow::util::span<const int32_t>{data->raw_values(),
-                                                 static_cast<size_t>(lengths->length())};
+  auto span = std::span<const int32_t>{data->raw_values(),
+                                       static_cast<size_t>(lengths->length())};
   return DeltaEncode(span);
 }
 
diff --git a/cpp/src/parquet/encryption/encryption.h b/cpp/src/parquet/encryption/encryption.h
index b4634b70473..023a536fd91 100644
--- a/cpp/src/parquet/encryption/encryption.h
+++ b/cpp/src/parquet/encryption/encryption.h
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <map>
 #include <memory>
+#include <span>
 #include <string>
 #include <utility>
 
@@ -95,7 +96,7 @@ class PARQUET_EXPORT KeyAccessDeniedException : public ParquetException {
       : ParquetException(columnPath.c_str()) {}
 };
 
-inline ::arrow::util::span<const uint8_t> str2span(const std::string& str) {
+inline std::span<const uint8_t> str2span(const std::string& str) {
   if (str.empty()) {
     return {};
   }
diff --git a/cpp/src/parquet/encryption/encryption_internal.cc b/cpp/src/parquet/encryption/encryption_internal.cc
index 9400fae0adf..e9fa2f545d6 100644
--- a/cpp/src/parquet/encryption/encryption_internal.cc
+++ b/cpp/src/parquet/encryption/encryption_internal.cc
@@ -15,25 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "parquet/encryption/encryption_internal.h"
-
-#include <openssl/aes.h>
-#include <openssl/err.h>
-#include <openssl/evp.h>
-#include <openssl/rand.h>
-
 #include <algorithm>
 #include <array>
 #include <iostream>
 #include <memory>
+#include <span>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include <openssl/aes.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/rand.h>
+
+#include "parquet/encryption/encryption_internal.h"
 #include "parquet/encryption/openssl_internal.h"
 #include "parquet/exception.h"
-
-using ::arrow::util::span;
 using parquet::ParquetException;
 
 namespace parquet::encryption {
@@ -109,12 +107,13 @@ class AesEncryptor::AesEncryptorImpl : public AesCryptoContext {
   explicit AesEncryptorImpl(ParquetCipher::type alg_id, int32_t key_len, bool metadata,
                             bool write_length);
 
-  int32_t Encrypt(span<const uint8_t> plaintext, span<const uint8_t> key,
-                  span<const uint8_t> aad, span<uint8_t> ciphertext);
+  int32_t Encrypt(std::span<const uint8_t> plaintext, std::span<const uint8_t> key,
+                  std::span<const uint8_t> aad, std::span<uint8_t> ciphertext);
 
-  int32_t SignedFooterEncrypt(span<const uint8_t> footer, span<const uint8_t> key,
-                              span<const uint8_t> aad, span<const uint8_t> nonce,
-                              span<uint8_t> encrypted_footer);
+  int32_t SignedFooterEncrypt(std::span<const uint8_t> footer,
+                              std::span<const uint8_t> key, std::span<const uint8_t> aad,
+                              std::span<const uint8_t> nonce,
+                              std::span<uint8_t> encrypted_footer);
 
   [[nodiscard]] int32_t CiphertextLength(int64_t plaintext_len) const {
     if (plaintext_len < 0) {
@@ -135,12 +134,12 @@ class AesEncryptor::AesEncryptorImpl : public AesCryptoContext {
  private:
   [[nodiscard]] CipherContext MakeCipherContext() const;
 
-  int32_t GcmEncrypt(span<const uint8_t> plaintext, span<const uint8_t> key,
-                     span<const uint8_t> nonce, span<const uint8_t> aad,
-                     span<uint8_t> ciphertext);
+  int32_t GcmEncrypt(std::span<const uint8_t> plaintext, std::span<const uint8_t> key,
+                     std::span<const uint8_t> nonce, std::span<const uint8_t> aad,
+                     std::span<uint8_t> ciphertext);
 
-  int32_t CtrEncrypt(span<const uint8_t> plaintext, span<const uint8_t> key,
-                     span<const uint8_t> nonce, span<uint8_t> ciphertext);
+  int32_t CtrEncrypt(std::span<const uint8_t> plaintext, std::span<const uint8_t> key,
+                     std::span<const uint8_t> nonce, std::span<uint8_t> ciphertext);
 };
 
 AesEncryptor::AesEncryptorImpl::AesEncryptorImpl(ParquetCipher::type alg_id,
@@ -174,8 +173,9 @@ AesCryptoContext::CipherContext AesEncryptor::AesEncryptorImpl::MakeCipherContex
 }
 
 int32_t AesEncryptor::AesEncryptorImpl::SignedFooterEncrypt(
-    span<const uint8_t> footer, span<const uint8_t> key, span<const uint8_t> aad,
-    span<const uint8_t> nonce, span<uint8_t> encrypted_footer) {
+    std::span<const uint8_t> footer, std::span<const uint8_t> key,
+    std::span<const uint8_t> aad, std::span<const uint8_t> nonce,
+    std::span<uint8_t> encrypted_footer) {
   if (static_cast<size_t>(key_length_) != key.size()) {
     std::stringstream ss;
     ss << "Wrong key length " << key.size() << ". Should be " << key_length_;
@@ -196,10 +196,10 @@ int32_t AesEncryptor::AesEncryptorImpl::SignedFooterEncrypt(
   return GcmEncrypt(footer, key, nonce, aad, encrypted_footer);
 }
 
-int32_t AesEncryptor::AesEncryptorImpl::Encrypt(span<const uint8_t> plaintext,
-                                                span<const uint8_t> key,
-                                                span<const uint8_t> aad,
-                                                span<uint8_t> ciphertext) {
+int32_t AesEncryptor::AesEncryptorImpl::Encrypt(std::span<const uint8_t> plaintext,
+                                                std::span<const uint8_t> key,
+                                                std::span<const uint8_t> aad,
+                                                std::span<uint8_t> ciphertext) {
   if (static_cast<size_t>(key_length_) != key.size()) {
     std::stringstream ss;
     ss << "Wrong key length " << key.size() << ". Should be " << key_length_;
@@ -225,11 +225,11 @@ int32_t AesEncryptor::AesEncryptorImpl::Encrypt(span<const uint8_t> plaintext,
   return CtrEncrypt(plaintext, key, nonce, ciphertext);
 }
 
-int32_t AesEncryptor::AesEncryptorImpl::GcmEncrypt(span<const uint8_t> plaintext,
-                                                   span<const uint8_t> key,
-                                                   span<const uint8_t> nonce,
-                                                   span<const uint8_t> aad,
-                                                   span<uint8_t> ciphertext) {
+int32_t AesEncryptor::AesEncryptorImpl::GcmEncrypt(std::span<const uint8_t> plaintext,
+                                                   std::span<const uint8_t> key,
+                                                   std::span<const uint8_t> nonce,
+                                                   std::span<const uint8_t> aad,
+                                                   std::span<uint8_t> ciphertext) {
   int len;
   int32_t ciphertext_len;
 
@@ -304,10 +304,10 @@ int32_t AesEncryptor::AesEncryptorImpl::GcmEncrypt(span<const uint8_t> plaintext
   return length_buffer_length_ + buffer_size;
 }
 
-int32_t AesEncryptor::AesEncryptorImpl::CtrEncrypt(span<const uint8_t> plaintext,
-                                                   span<const uint8_t> key,
-                                                   span<const uint8_t> nonce,
-                                                   span<uint8_t> ciphertext) {
+int32_t AesEncryptor::AesEncryptorImpl::CtrEncrypt(std::span<const uint8_t> plaintext,
+                                                   std::span<const uint8_t> key,
+                                                   std::span<const uint8_t> nonce,
+                                                   std::span<uint8_t> ciphertext) {
   int len;
   int32_t ciphertext_len;
 
@@ -371,11 +371,11 @@ int32_t AesEncryptor::AesEncryptorImpl::CtrEncrypt(span<const uint8_t> plaintext
 
 AesEncryptor::~AesEncryptor() = default;
 
-int32_t AesEncryptor::SignedFooterEncrypt(span<const uint8_t> footer,
-                                          span<const uint8_t> key,
-                                          span<const uint8_t> aad,
-                                          span<const uint8_t> nonce,
-                                          span<uint8_t> encrypted_footer) {
+int32_t AesEncryptor::SignedFooterEncrypt(std::span<const uint8_t> footer,
+                                          std::span<const uint8_t> key,
+                                          std::span<const uint8_t> aad,
+                                          std::span<const uint8_t> nonce,
+                                          std::span<uint8_t> encrypted_footer) {
   return impl_->SignedFooterEncrypt(footer, key, aad, nonce, encrypted_footer);
 }
 
@@ -383,8 +383,9 @@ int32_t AesEncryptor::CiphertextLength(int64_t plaintext_len) const {
   return impl_->CiphertextLength(plaintext_len);
 }
 
-int32_t AesEncryptor::Encrypt(span<const uint8_t> plaintext, span<const uint8_t> key,
-                              span<const uint8_t> aad, span<uint8_t> ciphertext) {
+int32_t AesEncryptor::Encrypt(std::span<const uint8_t> plaintext,
+                              std::span<const uint8_t> key, std::span<const uint8_t> aad,
+                              std::span<uint8_t> ciphertext) {
   return impl_->Encrypt(plaintext, key, aad, ciphertext);
 }
 
@@ -398,8 +399,8 @@ class AesDecryptor::AesDecryptorImpl : AesCryptoContext {
   explicit AesDecryptorImpl(ParquetCipher::type alg_id, int32_t key_len, bool metadata,
                             bool contains_length);
 
-  int32_t Decrypt(span<const uint8_t> ciphertext, span<const uint8_t> key,
-                  span<const uint8_t> aad, span<uint8_t> plaintext);
+  int32_t Decrypt(std::span<const uint8_t> ciphertext, std::span<const uint8_t> key,
+                  std::span<const uint8_t> aad, std::span<uint8_t> plaintext);
 
   [[nodiscard]] int32_t PlaintextLength(int32_t ciphertext_len) const {
     if (ciphertext_len < ciphertext_size_delta_) {
@@ -431,17 +432,18 @@ class AesDecryptor::AesDecryptorImpl : AesCryptoContext {
 
   /// Get the actual ciphertext length, inclusive of the length buffer length,
   /// and validate that the provided buffer size is large enough.
-  [[nodiscard]] int32_t GetCiphertextLength(span<const uint8_t> ciphertext) const;
+  [[nodiscard]] int32_t GetCiphertextLength(std::span<const uint8_t> ciphertext) const;
 
-  int32_t GcmDecrypt(span<const uint8_t> ciphertext, span<const uint8_t> key,
-                     span<const uint8_t> aad, span<uint8_t> plaintext);
+  int32_t GcmDecrypt(std::span<const uint8_t> ciphertext, std::span<const uint8_t> key,
+                     std::span<const uint8_t> aad, std::span<uint8_t> plaintext);
 
-  int32_t CtrDecrypt(span<const uint8_t> ciphertext, span<const uint8_t> key,
-                     span<uint8_t> plaintext);
+  int32_t CtrDecrypt(std::span<const uint8_t> ciphertext, std::span<const uint8_t> key,
+                     std::span<uint8_t> plaintext);
 };
 
-int32_t AesDecryptor::Decrypt(span<const uint8_t> ciphertext, span<const uint8_t> key,
-                              span<const uint8_t> aad, span<uint8_t> plaintext) {
+int32_t AesDecryptor::Decrypt(std::span<const uint8_t> ciphertext,
+                              std::span<const uint8_t> key, std::span<const uint8_t> aad,
+                              std::span<uint8_t> plaintext) {
   return impl_->Decrypt(ciphertext, key, aad, plaintext);
 }
 
@@ -502,7 +504,7 @@ int32_t AesDecryptor::CiphertextLength(int32_t plaintext_len) const {
 }
 
 int32_t AesDecryptor::AesDecryptorImpl::GetCiphertextLength(
-    span<const uint8_t> ciphertext) const {
+    std::span<const uint8_t> ciphertext) const {
   if (length_buffer_length_ > 0) {
     // Note: length_buffer_length_ must be either 0 or kBufferSizeLength
     if (ciphertext.size() < static_cast<size_t>(kBufferSizeLength)) {
@@ -547,10 +549,10 @@ int32_t AesDecryptor::AesDecryptorImpl::GetCiphertextLength(
   }
 }
 
-int32_t AesDecryptor::AesDecryptorImpl::GcmDecrypt(span<const uint8_t> ciphertext,
-                                                   span<const uint8_t> key,
-                                                   span<const uint8_t> aad,
-                                                   span<uint8_t> plaintext) {
+int32_t AesDecryptor::AesDecryptorImpl::GcmDecrypt(std::span<const uint8_t> ciphertext,
+                                                   std::span<const uint8_t> key,
+                                                   std::span<const uint8_t> aad,
+                                                   std::span<uint8_t> plaintext) {
   int len;
   int32_t plaintext_len;
 
@@ -622,9 +624,9 @@ int32_t AesDecryptor::AesDecryptorImpl::GcmDecrypt(span<const uint8_t> ciphertex
   return plaintext_len;
 }
 
-int32_t AesDecryptor::AesDecryptorImpl::CtrDecrypt(span<const uint8_t> ciphertext,
-                                                   span<const uint8_t> key,
-                                                   span<uint8_t> plaintext) {
+int32_t AesDecryptor::AesDecryptorImpl::CtrDecrypt(std::span<const uint8_t> ciphertext,
+                                                   std::span<const uint8_t> key,
+                                                   std::span<uint8_t> plaintext) {
   int len;
   int32_t plaintext_len;
 
@@ -681,10 +683,10 @@ int32_t AesDecryptor::AesDecryptorImpl::CtrDecrypt(span<const uint8_t> ciphertex
   return plaintext_len;
 }
 
-int32_t AesDecryptor::AesDecryptorImpl::Decrypt(span<const uint8_t> ciphertext,
-                                                span<const uint8_t> key,
-                                                span<const uint8_t> aad,
-                                                span<uint8_t> plaintext) {
+int32_t AesDecryptor::AesDecryptorImpl::Decrypt(std::span<const uint8_t> ciphertext,
+                                                std::span<const uint8_t> key,
+                                                std::span<const uint8_t> aad,
+                                                std::span<uint8_t> plaintext) {
   if (static_cast<size_t>(key_length_) != key.size()) {
     std::stringstream ss;
     ss << "Wrong key length " << key.size() << ". Should be " << key_length_;
diff --git a/cpp/src/parquet/encryption/encryption_internal.h b/cpp/src/parquet/encryption/encryption_internal.h
index 06252749565..de256809fa9 100644
--- a/cpp/src/parquet/encryption/encryption_internal.h
+++ b/cpp/src/parquet/encryption/encryption_internal.h
@@ -18,10 +18,10 @@
 #pragma once
 
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
-#include "arrow/util/span.h"
 #include "parquet/properties.h"
 #include "parquet/types.h"
 
@@ -62,17 +62,14 @@ class PARQUET_EXPORT AesEncryptor {
 
   /// Encrypts plaintext with the key and aad. Key length is passed only for validation.
   /// If different from value in constructor, exception will be thrown.
-  int32_t Encrypt(::arrow::util::span<const uint8_t> plaintext,
-                  ::arrow::util::span<const uint8_t> key,
-                  ::arrow::util::span<const uint8_t> aad,
-                  ::arrow::util::span<uint8_t> ciphertext);
+  int32_t Encrypt(std::span<const uint8_t> plaintext, std::span<const uint8_t> key,
+                  std::span<const uint8_t> aad, std::span<uint8_t> ciphertext);
 
   /// Encrypts plaintext footer, in order to compute footer signature (tag).
-  int32_t SignedFooterEncrypt(::arrow::util::span<const uint8_t> footer,
-                              ::arrow::util::span<const uint8_t> key,
-                              ::arrow::util::span<const uint8_t> aad,
-                              ::arrow::util::span<const uint8_t> nonce,
-                              ::arrow::util::span<uint8_t> encrypted_footer);
+  int32_t SignedFooterEncrypt(std::span<const uint8_t> footer,
+                              std::span<const uint8_t> key, std::span<const uint8_t> aad,
+                              std::span<const uint8_t> nonce,
+                              std::span<uint8_t> encrypted_footer);
 
  private:
   // PIMPL Idiom
@@ -107,10 +104,8 @@ class PARQUET_EXPORT AesDecryptor {
   /// validation. If different from value in constructor, exception will be thrown.
   /// The caller is responsible for ensuring that the plaintext buffer is at least as
   /// large as PlaintextLength(ciphertext_len).
-  int32_t Decrypt(::arrow::util::span<const uint8_t> ciphertext,
-                  ::arrow::util::span<const uint8_t> key,
-                  ::arrow::util::span<const uint8_t> aad,
-                  ::arrow::util::span<uint8_t> plaintext);
+  int32_t Decrypt(std::span<const uint8_t> ciphertext, std::span<const uint8_t> key,
+                  std::span<const uint8_t> aad, std::span<uint8_t> plaintext);
 
  private:
   // PIMPL Idiom
diff --git a/cpp/src/parquet/encryption/encryption_internal_nossl.cc b/cpp/src/parquet/encryption/encryption_internal_nossl.cc
index 2450f8654d6..715806e65e5 100644
--- a/cpp/src/parquet/encryption/encryption_internal_nossl.cc
+++ b/cpp/src/parquet/encryption/encryption_internal_nossl.cc
@@ -33,11 +33,11 @@ class AesEncryptor::AesEncryptorImpl {};
 
 AesEncryptor::~AesEncryptor() {}
 
-int32_t AesEncryptor::SignedFooterEncrypt(::arrow::util::span<const uint8_t> footer,
-                                          ::arrow::util::span<const uint8_t> key,
-                                          ::arrow::util::span<const uint8_t> aad,
-                                          ::arrow::util::span<const uint8_t> nonce,
-                                          ::arrow::util::span<uint8_t> encrypted_footer) {
+int32_t AesEncryptor::SignedFooterEncrypt(std::span<const uint8_t> footer,
+                                          std::span<const uint8_t> key,
+                                          std::span<const uint8_t> aad,
+                                          std::span<const uint8_t> nonce,
+                                          std::span<uint8_t> encrypted_footer) {
   ThrowOpenSSLRequiredException();
   return -1;
 }
@@ -47,10 +47,10 @@ int32_t AesEncryptor::CiphertextLength(int64_t plaintext_len) const {
   return -1;
 }
 
-int32_t AesEncryptor::Encrypt(::arrow::util::span<const uint8_t> plaintext,
-                              ::arrow::util::span<const uint8_t> key,
-                              ::arrow::util::span<const uint8_t> aad,
-                              ::arrow::util::span<uint8_t> ciphertext) {
+int32_t AesEncryptor::Encrypt(std::span<const uint8_t> plaintext,
+                              std::span<const uint8_t> key,
+                              std::span<const uint8_t> aad,
+                              std::span<uint8_t> ciphertext) {
   ThrowOpenSSLRequiredException();
   return -1;
 }
@@ -62,10 +62,10 @@ AesEncryptor::AesEncryptor(ParquetCipher::type alg_id, int32_t key_len, bool met
 
 class AesDecryptor::AesDecryptorImpl {};
 
-int32_t AesDecryptor::Decrypt(::arrow::util::span<const uint8_t> ciphertext,
-                              ::arrow::util::span<const uint8_t> key,
-                              ::arrow::util::span<const uint8_t> aad,
-                              ::arrow::util::span<uint8_t> plaintext) {
+int32_t AesDecryptor::Decrypt(std::span<const uint8_t> ciphertext,
+                              std::span<const uint8_t> key,
+                              std::span<const uint8_t> aad,
+                              std::span<uint8_t> plaintext) {
   ThrowOpenSSLRequiredException();
   return -1;
 }
diff --git a/cpp/src/parquet/encryption/encryption_internal_test.cc b/cpp/src/parquet/encryption/encryption_internal_test.cc
index bf6607e3287..1c96f4cb721 100644
--- a/cpp/src/parquet/encryption/encryption_internal_test.cc
+++ b/cpp/src/parquet/encryption/encryption_internal_test.cc
@@ -97,7 +97,7 @@ class TestAesEncryption : public ::testing::Test {
     int32_t expected_plaintext_length = decryptor.PlaintextLength(ciphertext_length);
     std::vector<uint8_t> decrypted_text(expected_plaintext_length, '\0');
 
-    ::arrow::util::span<uint8_t> truncated_ciphertext(ciphertext.data(),
+    std::span<uint8_t> truncated_ciphertext(ciphertext.data(),
                                                       ciphertext_length - 1);
     EXPECT_THROW(decryptor.Decrypt(truncated_ciphertext, str2span(key_), str2span(aad_),
                                    decrypted_text),
diff --git a/cpp/src/parquet/encryption/internal_file_decryptor.cc b/cpp/src/parquet/encryption/internal_file_decryptor.cc
index b90d3158559..e7eed4529b9 100644
--- a/cpp/src/parquet/encryption/internal_file_decryptor.cc
+++ b/cpp/src/parquet/encryption/internal_file_decryptor.cc
@@ -47,8 +47,8 @@ int32_t Decryptor::CiphertextLength(int32_t plaintext_len) const {
   return aes_decryptor_->CiphertextLength(plaintext_len);
 }
 
-int32_t Decryptor::Decrypt(::arrow::util::span<const uint8_t> ciphertext,
-                           ::arrow::util::span<uint8_t> plaintext) {
+int32_t Decryptor::Decrypt(std::span<const uint8_t> ciphertext,
+                           std::span<uint8_t> plaintext) {
   return aes_decryptor_->Decrypt(ciphertext, key_.as_span(), str2span(aad_), plaintext);
 }
 
diff --git a/cpp/src/parquet/encryption/internal_file_decryptor.h b/cpp/src/parquet/encryption/internal_file_decryptor.h
index a365b4df4bf..7a21fa55a66 100644
--- a/cpp/src/parquet/encryption/internal_file_decryptor.h
+++ b/cpp/src/parquet/encryption/internal_file_decryptor.h
@@ -19,6 +19,7 @@
 
 #include <memory>
 #include <mutex>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -52,8 +53,8 @@ class PARQUET_EXPORT Decryptor {
 
   [[nodiscard]] int32_t PlaintextLength(int32_t ciphertext_len) const;
   [[nodiscard]] int32_t CiphertextLength(int32_t plaintext_len) const;
-  int32_t Decrypt(::arrow::util::span<const uint8_t> ciphertext,
-                  ::arrow::util::span<uint8_t> plaintext);
+  int32_t Decrypt(std::span<const uint8_t> ciphertext,
+                  std::span<uint8_t> plaintext);
 
  private:
   std::unique_ptr<encryption::AesDecryptor> aes_decryptor_;
diff --git a/cpp/src/parquet/encryption/internal_file_encryptor.cc b/cpp/src/parquet/encryption/internal_file_encryptor.cc
index f6fc0849984..ce5620d1e9b 100644
--- a/cpp/src/parquet/encryption/internal_file_encryptor.cc
+++ b/cpp/src/parquet/encryption/internal_file_encryptor.cc
@@ -37,8 +37,8 @@ int32_t Encryptor::CiphertextLength(int64_t plaintext_len) const {
   return aes_encryptor_->CiphertextLength(plaintext_len);
 }
 
-int32_t Encryptor::Encrypt(::arrow::util::span<const uint8_t> plaintext,
-                           ::arrow::util::span<uint8_t> ciphertext) {
+int32_t Encryptor::Encrypt(std::span<const uint8_t> plaintext,
+                           std::span<uint8_t> ciphertext) {
   return aes_encryptor_->Encrypt(plaintext, key_.as_span(), str2span(aad_), ciphertext);
 }
 
diff --git a/cpp/src/parquet/encryption/internal_file_encryptor.h b/cpp/src/parquet/encryption/internal_file_encryptor.h
index ee15fe32de9..b430c5cc139 100644
--- a/cpp/src/parquet/encryption/internal_file_encryptor.h
+++ b/cpp/src/parquet/encryption/internal_file_encryptor.h
@@ -19,6 +19,7 @@
 
 #include <map>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -44,8 +45,8 @@ class PARQUET_EXPORT Encryptor {
 
   [[nodiscard]] int32_t CiphertextLength(int64_t plaintext_len) const;
 
-  int32_t Encrypt(::arrow::util::span<const uint8_t> plaintext,
-                  ::arrow::util::span<uint8_t> ciphertext);
+  int32_t Encrypt(std::span<const uint8_t> plaintext,
+                  std::span<uint8_t> ciphertext);
 
   bool EncryptColumnMetaData(
       bool encrypted_footer,
diff --git a/cpp/src/parquet/encryption/key_toolkit_internal.cc b/cpp/src/parquet/encryption/key_toolkit_internal.cc
index 60a8a52206c..407d4297b2a 100644
--- a/cpp/src/parquet/encryption/key_toolkit_internal.cc
+++ b/cpp/src/parquet/encryption/key_toolkit_internal.cc
@@ -38,7 +38,7 @@ std::string EncryptKeyLocally(const SecureString& key_bytes,
   int32_t encrypted_key_len =
       key_encryptor.CiphertextLength(static_cast<int64_t>(key_bytes.size()));
   std::string encrypted_key(encrypted_key_len, '\0');
-  ::arrow::util::span<uint8_t> encrypted_key_span(
+  std::span<uint8_t> encrypted_key_span(
       reinterpret_cast<uint8_t*>(&encrypted_key[0]), encrypted_key_len);
 
   encrypted_key_len = key_encryptor.Encrypt(key_bytes.as_span(), master_key.as_span(),
diff --git a/cpp/src/parquet/geospatial/util_internal.cc b/cpp/src/parquet/geospatial/util_internal.cc
index d5c8d662884..9605d627a2a 100644
--- a/cpp/src/parquet/geospatial/util_internal.cc
+++ b/cpp/src/parquet/geospatial/util_internal.cc
@@ -147,11 +147,11 @@ std::vector<int32_t> WKBGeometryBounder::GeometryTypes() const {
 }
 
 void WKBGeometryBounder::MergeGeometry(std::string_view bytes_wkb) {
-  MergeGeometry(::arrow::util::span(reinterpret_cast<const uint8_t*>(bytes_wkb.data()),
+  MergeGeometry(std::span(reinterpret_cast<const uint8_t*>(bytes_wkb.data()),
                                     bytes_wkb.size()));
 }
 
-void WKBGeometryBounder::MergeGeometry(::arrow::util::span<const uint8_t> bytes_wkb) {
+void WKBGeometryBounder::MergeGeometry(std::span<const uint8_t> bytes_wkb) {
   WKBBuffer src{bytes_wkb.data(), static_cast<int64_t>(bytes_wkb.size())};
   MergeGeometryInternal(&src, /*record_wkb_type=*/true);
   if (src.size() != 0) {
diff --git a/cpp/src/parquet/geospatial/util_internal.h b/cpp/src/parquet/geospatial/util_internal.h
index 2de9e1d076f..362ea7ed55f 100644
--- a/cpp/src/parquet/geospatial/util_internal.h
+++ b/cpp/src/parquet/geospatial/util_internal.h
@@ -22,6 +22,7 @@
 #include <cmath>
 #include <iostream>
 #include <limits>
+#include <span>
 #include <string>
 #include <unordered_set>
 
@@ -94,19 +95,19 @@ struct PARQUET_EXPORT BoundingBox {
   BoundingBox& operator=(const BoundingBox&) = default;
 
   /// \brief Update the X and Y bounds to ensure these bounds contain coord
-  void UpdateXY(::arrow::util::span<const double> coord) {
+  void UpdateXY(std::span<const double> coord) {
     DCHECK_EQ(coord.size(), 2);
     UpdateInternal(coord);
   }
 
   /// \brief Update the X, Y, and Z bounds to ensure these bounds contain coord
-  void UpdateXYZ(::arrow::util::span<const double> coord) {
+  void UpdateXYZ(std::span<const double> coord) {
     DCHECK_EQ(coord.size(), 3);
     UpdateInternal(coord);
   }
 
   /// \brief Update the X, Y, and M bounds to ensure these bounds contain coord
-  void UpdateXYM(::arrow::util::span<const double> coord) {
+  void UpdateXYM(std::span<const double> coord) {
     DCHECK_EQ(coord.size(), 3);
     min[0] = std::min(min[0], coord[0]);
     min[1] = std::min(min[1], coord[1]);
@@ -117,7 +118,7 @@ struct PARQUET_EXPORT BoundingBox {
   }
 
   /// \brief Update the X, Y, Z, and M bounds to ensure these bounds contain coord
-  void UpdateXYZM(::arrow::util::span<const double> coord) {
+  void UpdateXYZM(std::span<const double> coord) {
     DCHECK_EQ(coord.size(), 4);
     UpdateInternal(coord);
   }
@@ -190,13 +191,13 @@ class PARQUET_EXPORT WKBGeometryBounder {
   /// the geometry is added to the internal geometry type list.
   void MergeGeometry(std::string_view bytes_wkb);
 
-  void MergeGeometry(::arrow::util::span<const uint8_t> bytes_wkb);
+  void MergeGeometry(std::span<const uint8_t> bytes_wkb);
 
   /// \brief Accumulate the bounds of a previously-calculated BoundingBox
   void MergeBox(const BoundingBox& box) { box_.Merge(box); }
 
   /// \brief Accumulate a previously-calculated list of geometry types
-  void MergeGeometryTypes(::arrow::util::span<const int32_t> geospatial_types) {
+  void MergeGeometryTypes(std::span<const int32_t> geospatial_types) {
     geospatial_types_.insert(geospatial_types.begin(), geospatial_types.end());
   }
 
diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc
index 42dd8e52ee9..0f04df8e4cb 100644
--- a/cpp/src/parquet/metadata.cc
+++ b/cpp/src/parquet/metadata.cc
@@ -22,6 +22,7 @@
 #include <memory>
 #include <ostream>
 #include <random>
+#include <span>
 #include <sstream>
 #include <string>
 #include <string_view>
@@ -40,7 +41,6 @@
 #include "parquet/size_statistics.h"
 #include "parquet/statistics.h"
 #include "parquet/thrift_internal.h"
-
 using ::arrow::util::SecureString;
 
 namespace parquet {
@@ -809,12 +809,11 @@ class FileMetaData::FileMetaDataImpl {
     uint32_t serialized_len = metadata_len_;
     ThriftSerializer serializer;
     serializer.SerializeToBuffer(metadata_.get(), &serialized_len, &serialized_data);
-    ::arrow::util::span<const uint8_t> serialized_data_span(serialized_data,
-                                                            serialized_len);
+    std::span<const uint8_t> serialized_data_span(serialized_data, serialized_len);
 
     // encrypt with nonce
-    ::arrow::util::span<const uint8_t> nonce(reinterpret_cast<const uint8_t*>(signature),
-                                             encryption::kNonceLength);
+    std::span<const uint8_t> nonce(reinterpret_cast<const uint8_t*>(signature),
+                                   encryption::kNonceLength);
     auto tag = reinterpret_cast<const uint8_t*>(signature) + encryption::kNonceLength;
 
     const SecureString& key = file_decryptor_->GetFooterKey();
@@ -867,8 +866,7 @@ class FileMetaData::FileMetaDataImpl {
       uint8_t* serialized_data;
       uint32_t serialized_len;
       serializer.SerializeToBuffer(metadata_.get(), &serialized_len, &serialized_data);
-      ::arrow::util::span<const uint8_t> serialized_data_span(serialized_data,
-                                                              serialized_len);
+      std::span<const uint8_t> serialized_data_span(serialized_data, serialized_len);
 
       // encrypt the footer key
       std::vector<uint8_t> encrypted_data(encryptor->CiphertextLength(serialized_len));
@@ -1737,8 +1735,7 @@ class ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilderImpl {
 
         serializer.SerializeToBuffer(&column_chunk_->meta_data, &serialized_len,
                                      &serialized_data);
-        ::arrow::util::span<const uint8_t> serialized_data_span(serialized_data,
-                                                                serialized_len);
+        std::span<const uint8_t> serialized_data_span(serialized_data, serialized_len);
 
         std::vector<uint8_t> encrypted_data(encryptor->CiphertextLength(serialized_len));
         int32_t encrypted_len = encryptor->Encrypt(serialized_data_span, encrypted_data);
diff --git a/cpp/src/parquet/size_statistics.cc b/cpp/src/parquet/size_statistics.cc
index 0b30d7c8bbd..d12a07c3dca 100644
--- a/cpp/src/parquet/size_statistics.cc
+++ b/cpp/src/parquet/size_statistics.cc
@@ -32,8 +32,8 @@ namespace parquet {
 
 namespace {
 
-void MergeLevelHistogram(::arrow::util::span<int64_t> histogram,
-                         ::arrow::util::span<const int64_t> other) {
+void MergeLevelHistogram(std::span<int64_t> histogram,
+                         std::span<const int64_t> other) {
   ARROW_DCHECK_EQ(histogram.size(), other.size());
   std::transform(histogram.begin(), histogram.end(), other.begin(), histogram.begin(),
                  std::plus<>());
@@ -143,8 +143,8 @@ std::ostream& operator<<(std::ostream& os, const SizeStatistics& size_stats) {
   return os;
 }
 
-void UpdateLevelHistogram(::arrow::util::span<const int16_t> levels,
-                          ::arrow::util::span<int64_t> histogram) {
+void UpdateLevelHistogram(std::span<const int16_t> levels,
+                          std::span<int64_t> histogram) {
   const int64_t num_levels = static_cast<int64_t>(levels.size());
   DCHECK_GE(histogram.size(), 1);
   const int16_t max_level = static_cast<int16_t>(histogram.size() - 1);
diff --git a/cpp/src/parquet/size_statistics.h b/cpp/src/parquet/size_statistics.h
index ec79b8c4f8b..5b41b0596b2 100644
--- a/cpp/src/parquet/size_statistics.h
+++ b/cpp/src/parquet/size_statistics.h
@@ -20,9 +20,9 @@
 #include <cstdint>
 #include <iosfwd>
 #include <optional>
+#include <span>
 #include <vector>
 
-#include "arrow/util/span.h"
 #include "parquet/platform.h"
 #include "parquet/type_fwd.h"
 
@@ -96,7 +96,6 @@ PARQUET_EXPORT
 std::ostream& operator<<(std::ostream&, const SizeStatistics&);
 
 PARQUET_EXPORT
-void UpdateLevelHistogram(::arrow::util::span<const int16_t> levels,
-                          ::arrow::util::span<int64_t> histogram);
+void UpdateLevelHistogram(std::span<const int16_t> levels, std::span<int64_t> histogram);
 
 }  // namespace parquet
diff --git a/cpp/src/parquet/size_statistics_test.cc b/cpp/src/parquet/size_statistics_test.cc
index 6e8cec9a130..463d28a934b 100644
--- a/cpp/src/parquet/size_statistics_test.cc
+++ b/cpp/src/parquet/size_statistics_test.cc
@@ -15,17 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
 #include <algorithm>
 #include <ostream>
 #include <random>
+#include <span>
 
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "arrow/buffer.h"
 #include "arrow/table.h"
 #include "arrow/testing/gtest_util.h"
-#include "arrow/util/span.h"
 #include "parquet/arrow/reader.h"
 #include "parquet/arrow/schema.h"
 #include "parquet/arrow/writer.h"
@@ -37,7 +36,6 @@
 #include "parquet/test_util.h"
 #include "parquet/thrift_internal.h"
 #include "parquet/types.h"
-
 namespace parquet {
 
 TEST(SizeStatistics, UpdateLevelHistogram) {
diff --git a/cpp/src/parquet/stream_writer.h b/cpp/src/parquet/stream_writer.h
index 76265140222..c4a3ccfe2fa 100644
--- a/cpp/src/parquet/stream_writer.h
+++ b/cpp/src/parquet/stream_writer.h
@@ -22,12 +22,11 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
 
-#include "arrow/util/span.h"
-
 #include "parquet/column_writer.h"
 #include "parquet/file_writer.h"
 
@@ -154,7 +153,7 @@ class PARQUET_EXPORT StreamWriter {
   StreamWriter& operator<<(::std::string_view v);
 
   /// \brief Helper class to write variable length raw data.
-  using RawDataView = ::arrow::util::span<const uint8_t>;
+  using RawDataView = std::span<const uint8_t>;
 
   /// \brief Output operators for variable length raw data.
   StreamWriter& operator<<(RawDataView v);
diff --git a/cpp/src/parquet/thrift_internal.h b/cpp/src/parquet/thrift_internal.h
index 1ffe99eb3c9..57f377144e3 100644
--- a/cpp/src/parquet/thrift_internal.h
+++ b/cpp/src/parquet/thrift_internal.h
@@ -21,14 +21,13 @@
 
 #include <cstdint>
 #include <limits>
-
 #include <memory>
+#include <span>
 #include <sstream>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
-
 // TCompactProtocol requires some #defines to work right.
 #define SIGNED_RIGHT_SHIFT_IS 1
 #define ARITHMETIC_RIGHT_SHIFT 1
@@ -580,7 +579,7 @@ class ThriftDeserializer {
       // decrypt
       auto decrypted_buffer = AllocateBuffer(
           decryptor->pool(), decryptor->PlaintextLength(static_cast<int32_t>(clen)));
-      ::arrow::util::span<const uint8_t> cipher_buf(buf, clen);
+      std::span<const uint8_t> cipher_buf(buf, clen);
       uint32_t decrypted_buffer_len =
           decryptor->Decrypt(cipher_buf, decrypted_buffer->mutable_span_as<uint8_t>());
       if (decrypted_buffer_len <= 0) {
@@ -690,7 +689,7 @@ class ThriftSerializer {
                                 uint32_t out_length, Encryptor* encryptor) {
     auto cipher_buffer =
         AllocateBuffer(encryptor->pool(), encryptor->CiphertextLength(out_length));
-    ::arrow::util::span<const uint8_t> out_span(out_buffer, out_length);
+    std::span<const uint8_t> out_span(out_buffer, out_length);
     int32_t cipher_buffer_len =
         encryptor->Encrypt(out_span, cipher_buffer->mutable_span_as<uint8_t>());