Can i use split_view with a delimiter that's comparable, but otherwise not related to the split range's value type?

std::ranges::split_view works by taking a range that is to be split paired with a delimiter.

However, said delimiter is defined in quite a peculiar way - it needs to be a forward_range.

Fortunately, the standard allows the usage of split_view such that a range and a single element is passed. Notably, this is an example from the standard:

string str{"the quick brown fox"};

for (auto word : views::split(str, ' ')) {
    cout << string_view(word) << '*';
}

As you can see, we can pass ' ' as a delimiter. To my knowledge, this works by employing the following constructor:

template<forward_range R>
requires constructible_from<V, views::all_t<R>> 
         && constructible_from<Pattern, single_view<range_value_t<R>>>
constexpr explicit split_view(R&& r, range_value_t<R> e);

This allows us to pass an std::string as the range R and a char as the delimiter e. The requires clause ensures that this will work by checking whether char is the range_value_t of an std::string (it is) and if it's possible to create an std::ranges::single_view<char> (potentially to always delegate to the implementation that assumes that the delimiter is a range). Works wonders.

But what if I wanted to heavily customize my splitting behavior? For example, I wanted to split on any whitespace. Foolishly, I thought that this will work:

struct Whitespace {
    auto operator==(char const c) const noexcept -> bool {
        return std::isspace(static_cast<unsigned char>(c));
    }

    friend auto operator==(char const c, Whitespace const ws) noexcept -> bool {
        return ws == c;
    }
} whitespace;

auto main() -> int {
    auto const text = std::string("3213 421 43 3 532 5 53 53 5 3535 5353");

    namespace views = std::ranges::views;

    auto numbers = text | views::split(whitespace);
}

But Whitespace is a type that is neither a range, not you can create an std::ranges::single_view<char> from it. And even if it was and if you could, there would be no way to retain its custom behaviors, given the fact that the mentioned constructor would convert it to plain, old char.

Can I somehow use std::views::split with a custom logic for splitting, let's say, ranges of chars?

No. split_view requires indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>, and ranges::equal_to requires equality_comparable_with (with an minor caveat not relevant here). The semantic requirements of that concept disallows non-transitive "equality" (i.e., t1 == u, t2 == u but t1 != t2), which is necessary for any u that matches more than one value.

It follows that all attempts to do such things either are IFNDR or have undefined behavior.