Existe uma sintaxe para evitar a passagem de tipos dependentes duplicados?

Se eu quiser tornar a classe TopNStorage parametrizável com predicado de comparação, tenho que fazer algo como:

#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>

template <typename T, typename Pred = std::greater<T>>
class TopNStorage {
    std::priority_queue<T, std::vector<T>, Pred> counts;
    size_t n;
public: 
    TopNStorage(size_t n) : n(n) {  }

    void add(T value) {
        if (counts.size() >= n) {
            if (Pred()(value, counts.top())) {
                counts.pop();
                counts.push(value);
            }
        }
        else {
            counts.push(value);
        }
    }

    auto get_values() const { 
        std::vector<T> sorted_collocations_counts(counts.size());

        std::copy(&(counts.top()), &(counts.top()) + counts.size(), sorted_collocations_counts.begin());
        std::sort(sorted_collocations_counts.begin(), sorted_collocations_counts.end(),Compare());

        return sorted_collocations_counts;
    }
};

int main() {
    TopNStorage<int,std::less<int>> storage(3);

    for (int i = 1; i <= 5; ++i) {
        storage.add(i);
    }

    for (auto value : storage.get_values()) {
        std::cout << value << "\n";
    }
} 

Embora isso seja totalmente aceitável, o inttipo std::less<int>parece ser redundante nesses casos e eu gostaria de dizer ao compilador para retirá-lo typename Tda classe, mas não sei se posso parametrizar o modelo com outro modelo. Existe uma maneira de fazer o código do cliente parecer:

TopNStorage<int,std::less> storage(3);

Motivação

Não gosto de duplicação e quero evitar situações em que um tipo possa ser alterado sem alterar o outro (quando se trata de tipos e códigos mais complicados).

Fundo

Com base na pergunta Mantendo os N valores principais .