diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 3fe80f32cc4..b8b786d9260 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -68,6 +68,7 @@ std_headers = \ ${std_srcdir}/scoped_allocator \ ${std_srcdir}/set \ ${std_srcdir}/shared_mutex \ + ${std_srcdir}/span \ ${std_srcdir}/sstream \ ${std_srcdir}/stack \ ${std_srcdir}/stdexcept \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index b675d356cd4..cd1e9df5482 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -412,6 +412,7 @@ std_headers = \ ${std_srcdir}/scoped_allocator \ ${std_srcdir}/set \ ${std_srcdir}/shared_mutex \ + ${std_srcdir}/span \ ${std_srcdir}/sstream \ ${std_srcdir}/stack \ ${std_srcdir}/stdexcept \ diff --git a/libstdc++-v3/include/bits/range_access.h b/libstdc++-v3/include/bits/range_access.h index d1e74711433..3acaebadcf1 100644 --- a/libstdc++-v3/include/bits/range_access.h +++ b/libstdc++-v3/include/bits/range_access.h @@ -318,6 +318,72 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // C++17 +#if __cplusplus > 201703L + // "why are these in namespace std:: and not __gnu_cxx:: ?" + // because if we don't put them here it's impossible to + // have implicit ADL with "using std::begin/end/size/data;". + template + constexpr auto + __adl_begin(_Container& __cont) noexcept(noexcept(begin(__cont))) + { return begin(__cont); } + + template + constexpr auto + __adl_end(_Container& __cont) noexcept(noexcept(end(__cont))) + { return end(__cont); } + + template + constexpr auto + __adl_cbegin(_Container& __cont) noexcept(noexcept(cbegin(__cont))) + { return cbegin(__cont); } + + template + constexpr auto + __adl_cend(_Container& __cont) noexcept(noexcept(cend(__cont))) + { return cend(__cont); } + + template + constexpr auto + __adl_rbegin(_Container& __cont) noexcept(noexcept(rbegin(__cont))) + { return rbegin(__cont); } + + template + constexpr auto + __adl_rend(_Container& __cont) noexcept(noexcept(rend(__cont))) + { return rend(__cont); } + + template + constexpr auto + __adl_crbegin(_Container& __cont) noexcept(noexcept(crbegin(__cont))) + { return crbegin(__cont); } + + template + constexpr auto + __adl_crend(_Container& __cont) noexcept(noexcept(crend(__cont))) + { return crend(__cont); } + + template + constexpr auto + __adl_data(_Container& __cont) noexcept(noexcept(data(__cont))) + { return data(__cont); } + + template + constexpr auto + __adl_cdata(_Container& __cont) noexcept(noexcept(cdata(__cont))) + { return cdata(__cont); } + + template + constexpr auto + __adl_size(_Container& __cont) noexcept(noexcept(size(__cont))) + { return size(__cont); } + + template + constexpr auto + __adl_empty(_Container& __cont) noexcept(noexcept(empty(__cont))) + { return empty(__cont); } + +#endif // C++20 + _GLIBCXX_END_NAMESPACE_VERSION } // namespace diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span new file mode 100644 index 00000000000..9bbf9ed9e23 --- /dev/null +++ b/libstdc++-v3/include/std/span @@ -0,0 +1,549 @@ +// Components for manipulating non-owning sequences of objects -*- C++ -*- + +// Copyright (C) 2019-2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file span + * This is a Standard C++ Library header. + */ + +// +// P0122 span library +// Contributed by ThePhD +// + +#ifndef _GLIBCXX_SPAN +#define _GLIBCXX_SPAN 1 + +#pragma GCC system_header + +#if __cplusplus > 201703L + +#include +#include +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ + _GLIBCXX_BEGIN_NAMESPACE_VERSION + +// WARNING: they forgot this feature test macro +// get on someone's back about it in Belfast!!! +#define __cpp_lib_span 201911 + + inline constexpr ::std::size_t dynamic_extent = static_cast<::std::size_t>(-1); + + namespace __detail + { + + template + using __is_base_derived_safe_convertible = + ::std::is_convertible<_Element (*)[], _ToElement (*)[]>; + + template + static constexpr inline bool __is_base_derived_safe_convertible_v = + __is_base_derived_safe_convertible<_Element, _ToElement>::value; + + template + struct __is_std_array : ::std::false_type + { + }; + + template + struct __is_std_array<::std::array<_Element, _Extent>> : ::std::true_type + { + }; + +#ifdef _GLIBCXX_DEBUG + template + struct __is_std_array<::std::__debug::array<_Element, _Extent>> : ::std::true_type + { + }; +#endif // debug/array + + template + inline constexpr bool __is_std_array_v = __is_std_array<_Type>::value; + + template<::std::size_t _Extent> + struct __extent_storage + { + + constexpr __extent_storage() noexcept = default; + constexpr __extent_storage(::std::size_t) noexcept + { + } + + static constexpr ::std::size_t + _M_extent() noexcept + { + return _Extent; + } + }; + + template<> + struct __extent_storage(-1)> + { + ::std::size_t _M_extent_value; + + constexpr __extent_storage() noexcept : _M_extent_value(0){}; + constexpr __extent_storage(::std::size_t __extent) noexcept : _M_extent_value(__extent) + { + } + + constexpr ::std::size_t + _M_extent() const noexcept + { + return this->_M_extent_value; + } + }; + + } // namespace __detail + + template + class span : private ::std::__detail::__extent_storage<_Extent> + { + public: + // member types + using value_type = ::std::remove_cv_t<_Type>; + using element_type = _Type; + using index_type = ::std::size_t; + using reference = element_type&; + using const_reference = const element_type&; + using pointer = _Type*; + using const_pointer = const _Type*; + using iterator = pointer; + using const_iterator = const_pointer; + using reverse_iterator = ::std::reverse_iterator; + using const_reverse_iterator = ::std::reverse_iterator; + using difference_type = ::std::ptrdiff_t; + // Official wording has no size_type -- why?? + // using size_type = ::std::size_t; + + // member constants + static inline constexpr ::std::size_t extent = _Extent; + + private: + using __base_t = ::std::__detail::__extent_storage<_Extent>; + + public: + // constructors + constexpr span() noexcept : __base_t(), _M_ptr(nullptr) + { + } + + constexpr span(const span&) noexcept = default; + + template<::std::size_t _ArrayExtent, + ::std::enable_if_t<(_Extent == ::std::dynamic_extent || _ArrayExtent == _Extent) && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t()))>, + element_type>>* = nullptr> + constexpr span(element_type (&__arr)[_ArrayExtent]) noexcept(noexcept(::std::__adl_data(__arr))) + : span(::std::__adl_data(__arr), _ArrayExtent) + { + } + + template<::std::size_t _ArrayExtent, + ::std::enable_if_t<(_Extent == ::std::dynamic_extent || _ArrayExtent == _Extent) && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t&>()))>, + element_type>>* = nullptr> + constexpr span(::std::array& __arr) noexcept( + noexcept(::std::__adl_data(__arr))) + : span(::std::__adl_data(__arr), _ArrayExtent) + { + } + + template<::std::size_t _ArrayExtent, + ::std::enable_if_t<(_Extent == ::std::dynamic_extent || _ArrayExtent == _Extent) && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t&>()))>, + element_type>>* = nullptr> + constexpr span(const ::std::array& __arr) noexcept( + noexcept(::std::__adl_data(__arr))) + : span(::std::__adl_data(__arr), _ArrayExtent) + { + } + + // NOTE: when the time comes, and P1394 - + // range constructors for std::span - ships in + // the standard, delete the #else block and remove + // the conditional + // if the paper fails, delete #if block + // and keep the crappy #else block + // and then cry that NB comments failed C++20... + // but maybe for C++23? +#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394 + template, span> && + !::std::__detail::__is_std_array_v<::std::remove_cvref_t<_Range>> && + !::std::is_array_v<::std::remove_cvref_t<_Range>> && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t()))>, + element_type>>* = nullptr> + constexpr span(_Range&& __range) noexcept( + noexcept(::std::__adl_data(__range)) && noexcept(::std::__adl_size(__range))) + : span(::std::__adl_data(__range), ::std::__adl_size(__range)) + { + } + + template && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_reference_t< + typename ::std::iterator_traits<_ContiguousIterator>::reference>, + element_type>>* = nullptr> + constexpr span(_ContiguousIterator __first, _Sentinel __last) + : span(::std::move(__first), static_cast(__last - __first)) + { + } + + template + constexpr span(_ContiguousIterator __first, index_type __count) noexcept( + noexcept(::std::to_address(__first))) + : __base_t(__count), _M_ptr(::std::to_address(__first)) + { + } +#else + template, span> && + !::std::__detail::__is_std_array_v< + ::std::remove_cvref_t<_Container>> && + !::std::is_array_v<::std::remove_cvref_t<_Container>> && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t()))>, + element_type>>* = nullptr> + constexpr span(_Container& __range) noexcept( + noexcept(::std::__adl_data(__range)) && noexcept(::std::__adl_size(__range))) + : span(::std::__adl_data(__range), ::std::__adl_size(__range)) + { + } + + template, span> && + !::std::__detail::__is_std_array_v< + ::std::remove_cvref_t<_Container>> && + !::std::is_array_v<::std::remove_cvref_t<_Container>> && + ::std::__detail::__is_base_derived_safe_convertible_v< + ::std::remove_pointer_t()))>, + element_type>>* = nullptr> + constexpr span(const _Container& __range) noexcept( + noexcept(::std::__adl_data(__range)) && noexcept(::std::__adl_size(__range))) + : span(::std::__adl_data(__range), ::std::__adl_size(__range)) + { + } + + constexpr span(pointer __first, pointer __last) noexcept + : span(::std::move(__first), static_cast(__last - __first)) + { + } + constexpr span(pointer __first, index_type __count) noexcept + : __base_t(__count), _M_ptr(static_cast(__first)) + { + } +#endif // P1394 + + // assignment + constexpr span& + operator=(const span&) noexcept = default; + + // observers + constexpr reference + front() noexcept + { + return *this->begin(); + } + + constexpr const_reference + front() const noexcept + { + return *this->begin(); + } + + constexpr reference + back() noexcept + { + return *(this->begin() + 1); + } + + constexpr const_reference + back() const noexcept + { + return *(this->end() - 1); + } + + constexpr reference operator[](index_type __idx) noexcept + { + return *(this->_M_ptr + __idx); + } + + constexpr const_reference operator[](index_type __idx) const noexcept + { + return *(this->_M_ptr + __idx); + } + + constexpr pointer + data() const noexcept + { + return this->_M_ptr; + } + + constexpr index_type + size() const noexcept + { + return this->__base_t::_M_extent(); + } + + constexpr index_type + size_bytes() const noexcept + { + return this->__base_t::_M_extent() * sizeof(element_type); + } + + constexpr bool + empty() const noexcept + { + return size() == 0; + } + + // observers: iterators + constexpr iterator + begin() const noexcept + { + return iterator(this->_M_ptr); + } + + constexpr const_iterator + cbegin() const noexcept + { + return const_iterator(this->_M_ptr); + } + + constexpr iterator + end() const noexcept + { + return iterator(this->_M_ptr + this->size()); + } + + constexpr const_iterator + cend() const noexcept + { + return const_iterator(this->_M_ptr + this->size()); + } + + constexpr reverse_iterator + rbegin() const noexcept + { + return reverse_iterator(this->begin()); + } + + constexpr const_reverse_iterator + crbegin() const noexcept + { + return const_reverse_iterator(this->cbegin()); + } + + constexpr reverse_iterator + rend() const noexcept + { + return reverse_iterator(this->end()); + } + + constexpr const_reverse_iterator + crend() const noexcept + { + return const_reverse_iterator(this->cend()); + } + + // observers: subranges + template<::std::size_t _Count> + constexpr auto + first() const + { + using __span_t = ::std::span; + return __span_t(this->data(), _Count); + } + + constexpr auto + first(index_type __count) const + { + using __span_t = ::std::span; + return __span_t(this->data(), __count); + } + + template<::std::size_t _Count> + constexpr ::std::span + last() const + { + static_assert( + _Count == ::std::dynamic_extent || _Extent == ::std::dynamic_extent || _Count <= _Extent, + "bad span length"); + using __span_t = ::std::span; + return __span_t(this->data() + (this->size() - _Count), _Count); + } + + constexpr auto + last(index_type __count) const + { + using __span_t = ::std::span; + return __span_t(this->data() + (this->size() - __count), __count); + } + + template<::std::size_t _Offset, ::std::size_t _Count = ::std::dynamic_extent> + constexpr auto + subspan() const + { + static_assert(_Count == ::std::dynamic_extent || _Extent == ::std::dynamic_extent || + (_Offset + _Count) <= _Extent, + "bad span length"); + constexpr ::std::size_t __span_extent = + (_Count != ::std::dynamic_extent + ? _Count + : (_Extent != ::std::dynamic_extent ? _Extent - _Offset : ::std::dynamic_extent)); + using __span_t = ::std::span; + return __span_t(this->data() + _Offset, + (_Count == ::std::dynamic_extent ? this->size() - _Offset : _Count)); + } + + constexpr auto + subspan(index_type __offset, index_type __count = ::std::dynamic_extent) const + { + using __span_t = ::std::span; + return __span_t(this->data() + __offset, + __count == ::std::dynamic_extent ? this->size() - __offset : __count); + } + + // observers: range helpers + friend constexpr iterator + begin(span __sp) noexcept + { + return __sp.begin(); + } + + friend constexpr iterator + end(span __sp) noexcept + { + return __sp.end(); + } + + private: + pointer _M_ptr; + }; + + template + auto as_bytes(::std::span<_Type, _Extent> __sp) noexcept + { + constexpr ::std::size_t __byte_extent = + (_Extent == ::std::dynamic_extent + ? _Extent + : (_Extent * sizeof(typename ::std::span<_Type, _Extent>::element_type))); + using __byte_span_t = ::std::span; + return __byte_span_t(reinterpret_cast(__sp.data()), __sp.size_bytes()); + } + + template + auto as_writable_bytes(::std::span<_Type, _Extent> __sp) noexcept + { + constexpr ::std::size_t __byte_extent = + (_Extent == ::std::dynamic_extent + ? _Extent + : (_Extent * sizeof(typename ::std::span<_Type, _Extent>::element_type))); + using __byte_span_t = ::std::span<::std::byte, __byte_extent>; + return __byte_span_t(reinterpret_cast<::std::byte*>(__sp.data()), __sp.size_bytes()); + } + + // tuple helpers + template<::std::size_t _Index, typename _Type, ::std::size_t _Extent, + ::std::enable_if_t<(_Extent > 0) && (_Index < _Extent)>* = nullptr> + constexpr typename ::std::span<_Type, _Extent>::reference get( + ::std::span<_Type, _Extent> __sp) noexcept + { + return __sp[_Index]; + } + + template + class tuple_size<::std::span<_Type, _Extent>> + : public ::std::integral_constant<::std::size_t, _Extent> + { + }; + + template + class tuple_size<::std::span<_Type, ::std::dynamic_extent>>; + + template<::std::size_t _Index, typename _Type, ::std::size_t _Extent> + struct tuple_element<_Index, ::std::span<_Type, _Extent>> + { + static_assert(_Index < _Extent, "invalid index"); + using type = typename ::std::span<_Type, _Extent>::element_type; + }; + + // deduction guides + template + span(_Type(&)[_ArrayExtent])->span<_Type, _ArrayExtent>; + + template + span(::std::array<_Type, _ArrayExtent>&)->span<_Type, _ArrayExtent>; + + template + span(const ::std::array<_Type, _ArrayExtent>&)->span; + +#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394 + + template + span(_ContiguousIterator, _Sentinel) + ->span< + ::std::remove_reference_t::reference>>; + + template + span(_Range &&) + ->span<::std::remove_reference_t()))>::reference>>; + +#else + + template + span(_Container&)->span; + + template + span(const _Container&)->span; + +#endif // P1394 + + _GLIBCXX_END_NAMESPACE_VERSION +} // namespace std_GLIBCXX_VISIBILITY(default) + +#endif // C++20 + +#endif diff --git a/libstdc++-v3/testsuite/23_containers/span/everything.cc b/libstdc++-v3/testsuite/23_containers/span/everything.cc new file mode 100644 index 00000000000..7e82767ea7f --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/span/everything.cc @@ -0,0 +1,202 @@ +// Copyright (C) 2019-2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-options "-std=c++2a" } +// { dg-do run { target c++2a } } + +#include + +#include +#include +#include +#include +#include + +int +main() +{ + struct alignas(256) strawman + { + int x; + int y; + bool z; + int w; + }; + + struct naked_span + { + char* p; + std::size_t n; + }; + + struct strawman_span + { + strawman* p; + std::size_t n; + }; + + static_assert(sizeof(std::span) <= sizeof(char*)); + static_assert(sizeof(std::span) <= sizeof(const char*)); + static_assert(sizeof(std::span) <= sizeof(strawman*)); + static_assert(sizeof(std::span) <= sizeof(strawman*)); + static_assert(sizeof(std::span) <= sizeof(naked_span)); + static_assert(sizeof(std::span) <= sizeof(naked_span)); + + constexpr static std::array arr_data{ 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + constexpr auto arr_data_span = std::span(arr_data); + static_assert(arr_data_span.size() == 9); + static_assert(arr_data_span.size_bytes() == 9 * sizeof(int)); + static_assert(*arr_data_span.begin() == 0); + static_assert(*arr_data_span.data() == 0); + static_assert(arr_data_span.front() == 0); + static_assert(arr_data_span.back() == 8); + static_assert(arr_data_span[0] == 0); + static_assert(arr_data_span[1] == 1); + static_assert(arr_data_span[2] == 2); + static_assert(arr_data_span[3] == 3); + static_assert(arr_data_span[4] == 4); + static_assert(arr_data_span[5] == 5); + static_assert(arr_data_span[6] == 6); + static_assert(arr_data_span[7] == 7); + static_assert(arr_data_span[8] == 8); + static_assert(!arr_data_span.empty()); + static_assert(decltype(arr_data_span)::extent == 9); + + constexpr static int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + constexpr auto data_span = std::span(data); + static_assert(data_span.size() == 9); + static_assert(data_span.size_bytes() == 9 * sizeof(int)); + static_assert(*data_span.begin() == 0); + static_assert(*data_span.data() == 0); + static_assert(data_span.front() == 0); + static_assert(data_span.back() == 8); + static_assert(data_span[0] == 0); + static_assert(data_span[1] == 1); + static_assert(data_span[2] == 2); + static_assert(data_span[3] == 3); + static_assert(data_span[4] == 4); + static_assert(data_span[5] == 5); + static_assert(data_span[6] == 6); + static_assert(data_span[7] == 7); + static_assert(data_span[8] == 8); + static_assert(!data_span.empty()); + static_assert(decltype(data_span)::extent == 9); + + constexpr auto data_span_first = data_span.first<3>(); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_first)::extent == 3); + static_assert(data_span_first.size() == 3); + static_assert(data_span_first.front() == 0); + static_assert(data_span_first.back() == 2); + static_assert(std::tuple_size_v == 3); + static_assert(std::is_same_v, const int>); + + constexpr auto data_span_first_dyn = data_span.first(4); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_first_dyn)::extent == std::dynamic_extent); + static_assert(data_span_first_dyn.size() == 4); + static_assert(data_span_first_dyn.front() == 0); + static_assert(data_span_first_dyn.back() == 3); + + constexpr auto data_span_last = data_span.last<5>(); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_last)::extent == 5); + static_assert(data_span_last.size() == 5); + static_assert(data_span_last.front() == 4); + static_assert(data_span_last.back() == 8); + static_assert(std::tuple_size_v == 5); + static_assert(std::is_same_v, const int>); + + constexpr auto data_span_last_dyn = data_span.last(6); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_last_dyn)::extent == std::dynamic_extent); + static_assert(data_span_last_dyn.size() == 6); + static_assert(data_span_last_dyn.front() == 3); + static_assert(data_span_last_dyn.back() == 8); + + constexpr auto data_span_subspan = data_span.subspan<1, 3>(); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_subspan)::extent == 3); + static_assert(data_span_subspan.size() == 3); + static_assert(data_span_subspan.front() == 1); + static_assert(data_span_subspan.back() == 3); + + constexpr auto data_span_subspan_offset = data_span.subspan<8>(); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_subspan_offset)::extent == 1); + static_assert(data_span_subspan_offset.size() == 1); + static_assert(data_span_subspan_offset.front() == 8); + static_assert(data_span_subspan_offset.back() == 8); + + constexpr auto data_span_subspan_empty = data_span.subspan(9, 0); + static_assert( + std::is_same_v, std::span>); + static_assert(decltype(data_span_subspan_empty)::extent == std::dynamic_extent); + static_assert(data_span_subspan_empty.size() == 0); + + constexpr auto data_span_subspan_empty_static = data_span.subspan<9>(); + static_assert(std::is_same_v, + std::span>); + static_assert(decltype(data_span_subspan_empty_static)::extent == 0); + static_assert(data_span_subspan_empty.size() == 0); + + std::span shorts{}; + bool really_empty0 = shorts.empty(); + bool really_empty1 = std::empty(shorts); + bool really_empty2 = shorts.data() == nullptr; + bool really_empty3 = shorts.begin() == shorts.end(); + bool really_empty4 = shorts.cbegin() == shorts.cend(); + bool really_empty = + really_empty0 && really_empty1 && really_empty2 && really_empty3 && really_empty4; + (void)really_empty; + VERIFY(really_empty); + + std::vector value{ 0 }; + std::span muh_span(value); + VERIFY(muh_span.size() == 1); + std::byte* original_bytes = reinterpret_cast(value.data()); + original_bytes[0] = static_cast(1); + original_bytes[1] = static_cast(2); + original_bytes[2] = static_cast(3); + original_bytes[3] = static_cast(4); + std::span muh_byte_span = std::as_bytes(muh_span); + std::span muh_mutable_byte_span = std::as_writable_bytes(muh_span); + std::span muh_original_byte_span(original_bytes, original_bytes + 4); + bool definitely_reinterpret_casted0 = std::equal(muh_byte_span.cbegin(), muh_byte_span.cend(), + muh_original_byte_span.cbegin(), muh_original_byte_span.cend()); + bool definitely_reinterpret_casted1 = std::equal(muh_mutable_byte_span.cbegin(), + muh_byte_span.cend(), muh_original_byte_span.cbegin(), muh_original_byte_span.cend()); + bool definitely_reinterpret_casted = + definitely_reinterpret_casted0 && definitely_reinterpret_casted1; + (void)definitely_reinterpret_casted; + VERIFY(definitely_reinterpret_casted); + + std::span muh_original_byte_span_ptr_size(original_bytes, 4); + bool definitely_equivalent = + std::equal(muh_original_byte_span_ptr_size.cbegin(), muh_original_byte_span_ptr_size.cend(), + muh_original_byte_span.cbegin(), muh_original_byte_span.cend()); + (void)definitely_equivalent; + VERIFY(definitely_equivalent); + + return definitely_equivalent && definitely_reinterpret_casted && really_empty ? 0 : 1; +}