"Peter Dimov"
From: "Edward Diener"
The suggestion is that you explain how to bind specific arguments to boost::bind, the need to specify placeholders for all the other
arguments,
and also how to eventually pass arguments for placeholders. I know you are giving various examples when specifying how to use boost::bind with different types of functors, but they don't explain it all in a methodical way. I find the examples good but the general mechanism eluded me when I first read it. I think I understand it now but because it is not explained clearly at the beginning before you give practical examples, it made it much harder to fathom how it all worked. BTW, as a binding mechanism I think it is great work, but I don't think you need even assume that programmers who use it even understand std::bind1st or std::bind2nd if you explain it a bit better.
This helps, thank you. One more question: it seems that you are using bind() to implement closures. Are you migrating from another closure library, or do you have expectations of how a closure library works, that have got in the way?
I am using boost::function to implement closures for a Visual C++ 3rd party library and suggesting boost::bind as the main way to bind member functions to my boost::function implementations. I have even provided some macros which make binding an end user member function to the particular boost::function closures of my classes, using boost::bind, easier. For C++ Builder, as you may know, Borland has a __closure addition to the C++ language, totally non-standard C++, which makes the usage of boost::function and boost::bind unnecessary. Although I am coming from C++ Builder's mechanism, I am very appreciative of the work done with boost::function and boost::bind which makes closures a possibility using pure C++ as it now stands. My expectations have not got in the way once I understood how to use boost::function and boost::bind to implement closures. I find both mechanisms well done even if using a C++ Builder __closure extension is much simpler ( I still like C++ Builder's __closure concept as a possible future native type addition to the C++ language, but that discussion belongs someplace else, probably comp.std.c++ ). It was understanding how boost::bind actually worked which took a while and the fault may well be mine as I restudied bind1st and bind2nd adapters to make sure I knew what was happening there before looking at your documentation on boost::bind again. I admit that I didn't understand intially that when binding one had to supply all the arguments, either in the form of an actual parameter or as a placeholder. That is one of the reasons I suggested that you present a general explanation of the boost::bind mechanism, focusing on what binding is, binding a specific argument, using placeholder arguments, and calling the binding functor with actual values. I know you cover this later in examples for the different uses of boost::bind but I think it would be much more effective if you explain this at the beginning. However I might be unfair in not assuming a greater degree of C++ sophistication in users of Boost and of your implementation.