On 11/13/17 6:20 AM, Beman Dawes via Boost wrote:
Peter Sommerlad, committee member and C++Now presenter who often proposes additions to fill in holes in the standard library, asked me:
Are you aware of anybody who tried to provide a boost::operators style of automatically providing additional operators with a single base class that through SFINAE injects all possible operators based on the ones defined in the template parameter? This won't give you the control of the current boost::operators, but would be much easier to teach.
For example
struct Me : make_operators_for<Me>{ Me& operator+=(Me const&); // You get + bool operator<(Me const&) const; // You get all relops (<=> will make that obsolete) Me& operator++(); // you get postfix //etc. };
Today we have the facilities and compilers to make that happen.
What do you think? Who should I ask?
Anyone doing any work on operators or have any thoughts about updating boost::operators?
I'm pretty familiar with this. I used boost operators to create BOOST_STRONG_TYPE which a number of people liked. As time went on, and I wanted to make the serialization library more bullet proof, I fell out of love with it because it generated all the numeric operators, thus admitting errors (such as multiplying two object ids) I would have preferred to be trapped at compile time. So I eventually removed the usage of it. This kind of thinking eventually has led me to my current major project and likely last hurrah: my "Algebra" library. This was the subject of my presentation at CppCon 2016 “C++, Abstract Algebra and Practical Applications" https://www.youtube.com/watch?v=632a-DMM5J0 I spent significant amount of time looking at boost operators and other similar ideas for "automatically" adding "missing" operators. The problem which arises is trying to automatically determine which operators are missing. In the presentation I used the example of a quantity length. Given a length type and a corresponding + operator it makes sense to "generate" a += operator. But what about - ? one can take the difference of two lengths - but that operation is not guaranteed to yield a valid value for length - so the automatic operations wouldn't be a good choice. A similar type - Position - would have no problem with an automatically generated - operator. So I concluded that automatically generating "related" operators would turn in to a minefield littered with lots of special cases, exceptions, weird rules and a documentation nightmare. I've turned to the implementation of concepts of abstract algebra in terms of C++ as way to systematize the selection, declaration and definition of operators in C++ for specific types. It is currently a work in progress. The ultimate goal is to be able to specify algebraic types with a set of attributes which would create all appropriate operators while trapping any inappropriate usage. Such a facility, in conjunction with Boost Units (enhanced with improved easier to use documentation and perhaps some corresponding tweaks) would provide the base for writing provably correct programs. These programs would be written in terms of these strongly defined types such that it is almost impossible to get wrong. (of course these would be a bitch to compile - writing then normal crappy code is really fast and fun after all). An offshoot of this, which has been incredibly absorbing, is the safe numerics library whose implemenation requires some of the ideas mentioned above. This is proceeding apace - it has required more time and effort than anticipated. Robert Ramey