Ttykuu

C++20 added the span library under the header <span>.
As voluntary exercise (not homework!),
I spent approximately 1.5 hours implement it under C++17.
Please tell me if I used stuff that is not available under C++17.

Most stuff is in the namespace ::my_std, but tuple_size, etc. are in the namespace ::std, otherwise they are useless. The ::my_std::span_detail namespace contains implementation details that are not to be exposed.

I used the C++ standard draft, HTML version as a reference.

Here is my code, within 400 lines:

// a C++17 implementation of <span>

#ifndef INC_SPAN_HPP_c2GLAK6Onz
#define INC_SPAN_HPP_c2GLAK6Onz

#include <array> // for std::array, etc.
#include <cassert> // for assert
#include <cstddef> // for std::size_t, etc.
#include <iterator> // for std::reverse_iterator, etc.
#include <type_traits> // for std::enable_if, etc.

#define CONSTRAINT(...) 
 std::enable_if_t<(__VA_ARGS__), int> = 0
#define EXPECTS(...) 
 assert((__VA_ARGS__))

namespace my_std 

 // constants

 // equivalent to std::numeric_limits<std::size_t>::max()
 inline constexpr std::size_t dynamic_extent = -1;

 // class template span

 template <class T, std::size_t N = dynamic_extent>
 class span;

 namespace span_detail 

 // detect specializations of span

 template <class T>
 struct is_span :std::false_type ;

 template <class T, std::size_t N>
 struct is_span<span<T, N>> :std::true_type ;

 template <class T>
 inline constexpr bool is_span_v = is_span<T>::value;

 // detect specializations of std::array

 template <class T>
 struct is_array :std::false_type ;

 template <class T, std::size_t N>
 struct is_array<std::array<T, N>> :std::true_type ;

 template <class T>
 inline constexpr bool is_array_v = is_array<T>::value;

 // ADL-aware data() and size()

 using std::data;
 using std::size;

 template <class C>
 constexpr decltype(auto) my_data(C& c)
 
 return data(c);
 

 template <class C>
 constexpr decltype(auto) my_size(C& c)
 
 return size(c);
 

 // detect container

 template <class C, class = void>
 struct is_cont :std::false_type ;

 template <class C>
 struct is_cont<C,
 std::void_t<
 std::enable_if_t<!is_span_v<C>>,
 std::enable_if_t<!is_array_v<C>>,
 std::enable_if_t<!std::is_array_v<C>>,
 decltype(data(std::declval<C>())),
 decltype(size(std::declval<C>()))
 >> :std::true_type ;

 template <class C>
 inline constexpr bool is_cont_v = is_cont<C>::value;
 

 template <class T, std::size_t N>
 class span N == M
 && std::is_convertible_v<std::remove_pointer_t<decltype(span_detail::my_data(std::declval<T(&)[M]>()))>(*)[], T(*)[]>)>
 constexpr span(T (&arr)[M]) noexcept
 : size_M, data_arr
 
 

 template <std::size_t M,
 CONSTRAINT(N == dynamic_extent ;

 // deduction guide

 template <class T, std::size_t N>
 span(T (&)[N]) -> span<T, N>;

 template <class T, std::size_t N>
 span(std::array<T, N>&) -> span<T, N>;

 template <class T, std::size_t N>
 span(const std::array<T, N>&) -> span<const T, N>;

 template <class Cont>
 span(Cont&) -> span<typename Cont::value_type>;

 template <class Cont>
 span(const Cont&) -> span<const typename Cont::value_type>;

 // views of objects representation

 template <class T, std::size_t N>
 auto as_bytes(span<T, N> s) noexcept
 -> span<const std::byte,
 N == dynamic_extent ? dynamic_extent : sizeof(T) * N>
 
 return reinterpret_cast<const std::byte*>(s.data()), s.size_bytes();
 

 template <class T, std::size_t N,
 CONSTRAINT(!std::is_const_v<T>)>
 auto as_writable_bytes(span<T, N> s) noexcept
 -> span<std::byte,
 N == dynamic_extent ? dynamic_extent : sizeof(T) * N>
 
 return reinterpret_cast<std::byte*>(s.data()), s.size_bytes();
 



namespace std 

 // tuple interface
 // the primary template declarations are included in <array>

 template <class T, std::size_t N>
 struct tuple_size<my_std::span<T, N>>
 : std::integral_constant<std::size_t, N> ;

 // not defined
 template <class T>
 struct tuple_size<my_std::span<T, my_std::dynamic_extent>>;

 template <std::size_t I, class T, std::size_t N>
 struct tuple_element<I, my_std::span<T, N>> 
 static_assert(N != my_std::dynamic_extent && I < N);
 using type = T;
 ;

 template <std::size_t I, class T, std::size_t N>
 constexpr T& get(my_std::span<T, N> s) noexcept
 
 static_assert(N != my_std::dynamic_extent && I < N);
 return s[I];
 



#undef CONSTRAINT
#undef EXPECTS

#endif

Constructive criticism is highly appreciated!