Ok, found it. Now, the rub. We have plugins, which register interest in things. When they call a base-class register() function to register interest, they pass in the slot that they want the thing's signal to be connected to. So, the plugin base class (who we want to inherit from boost:;signals::trackable) keeps a map of interested thing to (formerly a boost::function) object. When changed to a signal_t::slot_type, compilation dies. Looking at slot.hpp, it looks like a slot does not have a copy constructor, nor an assignment operator. This means we can't store the slot in an STL container, nor can we pass a boost::function through the register() function without breaking trackable. Note: The functions are bound to class instance member functions, so we're using boost::bind. We were hitting an issue, where the connections weren't being torn down when the plugin unloads, causing a segfault when the signal was emitted. Trackable seemed like the easiest mechanism to add this functionality. So, can we delay turning the bind into a slot somehow? What does bind actually return? It would seem that if I can store that *bound* object, and just wait until we need to call connect, we should be fine. ------------------------------------ Just re-read the above, I'll write some pseudo-code to illustrate our problem ------------------------------------- Class plugin_base : boost::signals::trackable { Public: Plugin_base(){}; // We need to make sure that we tear down our connections... ~plugin_base(){}; Register(int id, boost::function slot) { registerMap[id] = slot; } Connect(object obj) // connect obj's signal to plugin_concrete's slot { // Prefer not to keep list of connections here. // Automate via trackable is preferred. Obj.sig.connect(registerMap[obj.id]); } Private: Std::map registerMap; } // I live in a shared library. // If I am unloaded while still connected to object, we go boom // when obj.sig() is called. Class plugin_concrete : plugin_base { Plugin_concrete() { Register(SOME_ID, boost::bind(&plugin_concrete::some_slot, this)); } Void some_slot(){}; } Class object { Public: Boost::signals::signal< void (void) > sig; Int id; } --------------------------------------------------- Thanks --dw