Template argument deduction

I'm having a problem where it would seem like template arguments could
be deduced, but in reality the compiler barfs because it can't.
Suppose I have this generic functor:

struct HeapConvertInserter {
   template <class Value, class Key>
   shared_ptr<Value> operator()(const Key& key) { return
shared_ptr<Value>(new Value(key)); }
};

Now, consider a class which wraps a std::map<Key, shared_ptr<Value>>
and some kind of delegate class like HeapConvertInserter. One method
which uses the two goes as follows:

// table is the std::map<Key, shared_ptr<Value>> instance, delegate is
the HeapConvertInserter instance
if (table.count(key) == 0) {
   table.insert(std::map<Key, shared_ptr<Value>>::value_type(key,
delegate(key)));
}

When I try to compile, apparently it can't deduce the Value template
argument of the HeapConvertInserter's operator(), even though it would
appear that Value should appear as, well, Value as defined in the
std::map instance. Why is this happening? Is there a way to make
this work without moving the Value off of the operator() template and
into the class template?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]