Barrett Adair
I posted about this a month ago, but I did not receive much response. Since then, I added an extended example use case, and I added a documentation section [1] that compares CallableTraits and Boost.FunctionTypes.
I received some positive feedback this week in Aspen, and r/cpp also seemed to respond well [2], so I thought I'd give this another shot.
Here are my questions for you:
1. Is there any interest in reviewing a future version of this for inclusion in Boost?
I think so. I've also heard a couple of people say that they needed similar functionality this week in Aspen, so I imagine this would be a useful addition to Boost. In the long term, I think we need something similar (perhaps a subset of CallableTraits) in the standard.
2. If so, does this belong in its own library, or should it be incorporated into Boost.TypeTraits or something similar?
No strong opinion here, though it might be a bit large for an addition to Boost.TypeTraits? In all cases, if there's a review of the library, you can count on me to submit one.
3. What you like to see added, removed, renamed, or redesigned?
Here are a few comments on the documentation and the library itself: - IMO, the overview should include explanations in running text rather than just comments in the code. Or if you want to keep code only, which might be a good idea, I would make it a bit shorter. Do not try to show all the features and details of the library; this is just an overview. - The Java-style interface example is _huge_, and IMO it doesn't fit into an example at the beginning of the documentation. It might be better to include it as an appendix. - The library documents many concepts, but it seems to me that they are not really concepts as we usually mean in C++. To me, most of them are just vocabulary terms (that could e.g. appear in a glossary). When I introduce concepts in a library, I usually design my concepts as some kind of hierarchy with semantic properties that allow me to describe a few key types of objects. Instead, I see some "concepts" in CallableTraits as just glossary terms without semantics. For example, instead of the "FunctionPtr" concept, you could have a "Function pointer" entry in a glossary. - Suggestion: use `replace_at` instead of `overwrite_at`? - A few metafunctions have the `_at` suffix; is this necessary? - Instead of `can_invoke`, something like `is_invokable` might be better? Querying traits often start with `is_`.
I'd say CallableTraits is about 85% finished. Here's what's left: * Add INVOKE semantics to a couple of things for consistency (arity, etc) * Remove unused/undocumented code * Account for transaction_safe and C++17 noexcept * Finish/test the calling convention features * Finish/update the reference documentation
Finishing the reference documentation is, IMO, the #1 priority if others express interest towards the library and you want to make it part of Boost. I don't think a formal review can take place before the documentation is done, but you might want to wait to see if there's interest before investing a lot of time in the documentation. Regards, Louis