Не найдена соответствующая перегруженная функция, отсутствуют экземпляры шаблона функций

Пытаюсь написать шаблон функции:

#include <algorithm>
#include <cassert>
#include <iterator>

#include <iostream>
#include <string>

using namespace std::string_literals;

template<typename Type>
class SingleList {
    struct Node {
        Node() = default;
        Node(const Type& val, Node* next)
            : value(val)
            , next_node(next)
        {}
        Type value{};
        Node* next_node = nullptr;
    };

    template<typename ValueType>
    class BasicIterator {
        friend class SingleList;
        explicit BasicIterator(Node* node)
            : node_(node)
        {}

    public:
        BasicIterator() = default;

        BasicIterator(const BasicIterator& other) noexcept
            : node_(other.node_)
        {}
        BasicIterator& operator=(const BasicIterator& rhs) = default;

        BasicIterator& operator++() noexcept {
            assert(node_ != nullptr);
            node_ = node_->next_node;
            return *this;
        }
        BasicIterator& operator++(int) noexcept {
            BasicIterator it(*this);
            node_ = node_->next_node;
            return it;
        }

        [[nodiscard]] bool
            operator==(const BasicIterator<Type>& rhs) const noexcept {
            return node_ == rhs.node_;
        }

        [[nodiscard]] bool
            operator!=(const BasicIterator<Type>& rhs) const noexcept {
            return node_ != rhs.node_;
        }

        [[nodiscard]] ValueType& operator*() noexcept {
            assert(node_ != nullptr);
            return node_->value;
        }

    private:
        Node* node_ = nullptr;
    };

public:
    SingleList() = default;

    SingleList(std::initializer_list<Type> values) {
        assert(size_ == 0 && root_.next_node == nullptr);
        CopyContainer(values);
    }
    SingleList& operator=(std::initializer_list<Type> values) {
        assert(size_ == 0 && root_.next_node == nullptr);
        CopyContainer(values);
        return *this;
    }

    [[nodiscard]] size_t get_size() const noexcept {
        return size_;
    }

    void push_back(Type value) {
        Node* new_node = new Node(value, nullptr);
        if (last_node_ != nullptr) {
            last_node_->next_node = new_node;
        }
        last_node_ = new_node;
        if (root_.next_node == nullptr) {
            root_.next_node = new_node;
        }
        ++size_;
    }

    void print() const noexcept {
        Node* node = root_.next_node;
        std::cout << "["s;
        while (node != nullptr) {
            std::cout << node->value;
            if (node->next_node != nullptr) {
                std::cout << ", "s;
            }
            node = node->next_node;
        }
        std::cout << "]"s << std::endl;
    }

    using Iterator = BasicIterator<Type>;

    [[nodiscard]] Iterator begin() noexcept {
        return Iterator{ root_.next_node };
    }

    [[nodiscard]] Iterator end() noexcept {
        return Iterator{ nullptr };
    }

    void clear() noexcept {
        Node* next = nullptr;
        while (root_.next_node != nullptr) {
            next = root_.next_node->next_node;
            delete root_.next_node;
            root_.next_node = next;
        }
        size_ = 0;
        last_node_ = nullptr;
    }

    ~SingleList() {
        clear();
    }

private:
    Node root_ = {};
    Node* last_node_ = nullptr;
    size_t size_ = 0;

    template<typename ContainerType>
    void CopyContainer(ContainerType& values) {
        for (auto value : values) {
            push_back(value);
        }
    }
};

template<typename Type>
struct Result {
    Result() = default;

    Result(typename SingleList<Type>::Iterator it, bool result)
        : iterator(it)
        , is_palindrome(result)
    {}

    typename SingleList<Type>::Iterator iterator;
    bool is_palindrome = false;
};

template<typename Type>
Result<Type> IsPalindromeRecursive(typename SingleList<Type>::Iterator it,
    size_t length) {
    typename SingleList<Type>::Iterator end = 
    typename SingleList<Type>::Iterator{ nullptr };

    if (it == end || length == 0) {
        return Result<Type>(it, true);
    }
    else if (length == 1) {
        return Result<Type>(++it, true);
    }

    typename SingleList<Type>::Iterator next_it = it;

    Result<Type> result = IsPalindromeRecursive(++next_it, length - 2);

    if (result.iterator == end || !result.is_palindrome) {
        return result;
    }

    result.is_palindrome = (*it == *result.iterator);
    ++result.iterator;

    return result;
}

int main() {
    std::cout << std::boolalpha;

    SingleList<int> sl = { 0, 1, 2, 3, 9, 3, 2, 1, 0 };
    std::cout << "The original list :"s << std::endl;
    sl.print();
    std::cout << std::endl;

    typename SingleList<int>::Iterator begin = sl.begin();
    size_t size = sl.get_size();
    Result<int> result = IsPalindromeRecursive(begin, size);

    return 0;
}

При попытке вызова IsPalindromeRecursive получаю ошибку C2672: соответствующая перегруженная функция не найдена