template method of functor "can't deduce template parameter"

[kurt.kru...@gmail.com]

g++ with std=c++14 is giving me a "couldn't deduce template parameter 'Key'" error, on a template method of a functor class (that isn't itself a template).
I can't figure out why. The code looks like it should work.

I am implementing a 2 3 tree, and it has a level order traversal method that takes a functor.
operator. The tree23 code is basically this:

template<class Key, class Value> class tree23 {
public:
class Node23 {
friend class tree23<Key, Value>;
public:
// snip...

friend std::ostream& operator<<(std::ostream& ostr, const Node23& node23)
{
// snip... outputs the keys and values of node23 to ostr.
}

private:

Node23 *parent;
std::array<Key, 2> keys;
std::array<Value, 2> values;
std::array<std::unique_ptr<Node23>, 3> children;

int totalItems; // either TwoNodeItems or ThreeNodeItems
// snip...
};

template<typename Functor> void levelOrderTraverse(Functor f) const noexcept;
// snip...
};

The level order traversal invokes the functor's function call operator, passing it two parameters.

template<class Key, class Value> template<typename Functor> \
void tree23<Key, Value>::levelOrderTraverse(Functor f) const noexcept
{
std::queue< std::pair<const Node23*, int> > queue;

Node23 *proot = root.get();

if (proot == nullptr) return;

auto initial_level = 1; // initial, top level is 1, the root.

queue.push(std::make_pair(proot, initial_level));

while (!queue.empty()) {

std::pair<const Node23 *, int> pair_ = queue.front();

const Node23 *current = pair_.first;

int current_tree_level = pair_.second;

// invokes functor's operator()(const Node23&, int)?
f(*current, current_tree_level);

if (!current->isLeaf()) {

for(auto i = 0; i < current->getChildCount(); ++i) {

queue.push(std::make_pair(current->children[i].get(), current_tree_level + 1));
}
}

queue.pop();
}
}

The functor is quite simple:

class levelOrderPrinter {

private:
// snip...
public:
levelOrderPrinter(std::ostream& ostr_lhs, int depth);
levelOrderPrinter(levelOrderPrinter&);
levelOrderPrinter(const levelOrderPrinter&);

template<class Key, class Value>
void operator()(const typename tree23<Key, Value>::Node23& node,
int current_level) noexcept;
};

template<class Key, class Value>
void levelOrderPrinter::operator()(const typename tree23<Key, Value>::Node23& node,
int current_level) noexcept
{
// Did level change?
if (level != current_level) {

level = current_level;
ostr << "\n\n" << "level = " << level;

// Provide some basic spacing to tree appearance.
std::size_t num = tree_depth - level + 1;

std::string str( num, ' ');

ostr << str;
}

ostr << node;
}

[kurt.kru...@gmail.com]

Changing

f(*current, current_tree_level)

in the method

template<class Key, class Value> template<typename Functor> void tree23<Key, Value>::levelOrderTraverse(Functor f) const noexcept

to be

f.template operator()<Key, Value>(*current, current_tree_level);

gets rid of the "unable to deduct template parameter 'Key'" error, and it now compiles successfully.