让我们从这个开始：

template <typename T>
concept HasDataAndSize =
    requires(T t) { t.size(); } && requires(T t) { t.data(); } &&
    requires(T t) { std::is_same<decltype(t.size()), std::size_t>::value; } &&
    requires(T t) { std::is_pointer<decltype(t.data())>::value; };

首先也是最重要的，没有必要将所有内容分离到自己的requires-expression中，这增加了大量语法，但没有任何好处。这相当于：

template <typename T>
concept HasDataAndSize =
    requires(T t) {
        t.size();
        t.data();
        std::is_same<decltype(t.size()), std::size_t>::value; // (1)
        std::is_pointer<decltype(t.data())>::value;           // (2)
    };

接下来，上面标记为(1)和(2)的行就不会了。做你认为他们会做的事事实上，他们什么都不做。您要检查的是 expressionstd::is_same<T, U>::value是一个有效的表达式--当然是有效的，不管T和U是什么。实际上并不是检查类型是否相同。
为了做到这一点，你需要在表达式前面加上requires，或者使用复合需求语法：

template <typename T>
concept HasDataAndSize =
    requires(T t) {
        // t.size() needs to be size_t
        { t.size() } -> std::same_as<size_t>;

        // t.data() needs to be valid and have pointer type
        t.data();
        requires std::is_pointer_v<decltype(t.data())>;
    };

一旦我们到了那里，你还有另一个问题

template<HasDataAndSize T> void write(const T& data)

这是检查T是否有data()和size()，但这不是真正相关的问题，因为data不是T，而是T const。在这里，你需要做：

template <class T>
    requires HasDataAndSize<T const>
void write(const T& data)

或引入助手概念：

template <class T> concept HasConstDataAndSize = HasDataAndSize<T const>;
template<HasConstDataAndSize T> void write(const T& data)

或者使用转发引用（这将确保T以对概念有用的方式推导）：

template<HasDataAndSize T> void write(T&& data)

最后，这更像是一个API问题，但最好完全避免这个问题，只写：

void write(std::span<std::byte> );
void read(std::span<std::byte const> );

虽然一般来说我并不真正理解这里的API应该做什么。