template<forward_iterator I, sentinel_for<I> S,
         class T,
         class Pred = ranges::equal_to,
         class Proj = identity>
requires indirectly_comparable<I, const T*, Pred, Proj>
constexpr subrange<I>
    search_n(I first, S last, iter_difference_t<I> count,
             const T& value, Pred pred = {}, Proj proj = {});

template<forward_range R,
         class T,
         class Pred = ranges::equal_to,
         class Proj = identity>
requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
constexpr borrowed_subrange_t<R>
    search_n(R&& r, range_difference_t<R> count,
             const T& value, Pred pred = {}, Proj proj = {});

#include <iostream>
#include <algorithm>
#include <string>
namespace ranges = std::ranges;
using namespace std::string_literals;
using namespace std::string_view_literals;


template<class T, class Tp>
constexpr std::string_view
fn(T&& haystack, ranges::range_difference_t<T> count, Tp needle)
{
    if constexpr(ranges::borrowed_range<T>)
    {
        auto result = ranges::search_n(std::forward<T>(haystack), count, needle);
        return result.empty() ?
                "No matches." :
                std::string_view{result.cbegin(), result.cend()};
    }
    else
        return "haystack is an borrowed_range?";
}


int main()
{
    std::string str = "aabcdaef";

    for (auto c : fn(str, 2, 'a'))
        std::cout << c;
    std::cout << std::endl;

    for (auto c : fn(std::string_view(str), 2, 'a'))
        std::cout << c;
    std::cout << std::endl;

    for (auto c : fn(std::move(str), 2, 'a'))
        std::cout << c;
    std::cout << std::endl;
}

aa
aa
haystack is an borrowed_range?