April 2019 - Boost - lists.preview.boost.org

Variant2 review
by Niall Douglas 07 Apr '19

07 Apr '19

I'll firstly apologise for the brevity of this review. It is just before the ACCU conference where I am speaking on a topic I have little knowledge of, and I have done almost no prep due to insufficient hours in the day. I am aware that if I don't make a review now, then I won't at all, so this will have to do. 1. Overall I like the library, it adds significant benefit (primarily removal of dynamic memory allocation) over Boost.Variant. 2. I don't like the lack of propagation of triviality of each individual special member functions. std::variant does this. std::expected does this. I can see Peter's point that for long lists of alternative states, implementing this is a lot of pain for almost no gain. However I do NOT agree with him for Expected. For a two-state variant, it is very highly likely that triviality of special member function will be very important for not a small number of use cases. I personally am happy for Variant2 to implement Expected without review approval here IF that Expected matches exactly std::expected. I am NOT happy if Variant2's Expected breaks conformance on triviality of special member function. If that is the only option on the table, then either please do not include an Expected implementation, or don't include Variant2. This raises a wider point though. What is good for a two-state variant still applies, though less so, to three-state variants, four-state variants and so on. I think there is a fundamental design issue here. If Variant2 can't propagate triviality of individual special member functions for small-number-of-state variants, then there is something fundamentally wrong here. 3. I find the design choice to randomly permute state to avoid an empty state baffling when there is a double buffer based design choice available. I do not like, one bit, the random permutation of state. I think it will lead to buggy code with hard-to-test corner cases. I think it needs to go away in the proposed design. I also don't get the dislike of the double buffer based design. Peter seems to really dislike it, and avoids it whenever possible. I can't understand why. If you can employ a double buffer design in order to eliminate random permutation of state, to me this is an unalloyed good in every way. Nowhere does it say that a variant must be no larger than the largest of its possible states. There is nothing wrong, *whatsoever*, with a variant which is sized the largest of its possible states multiplied by two. So please change the design to that instead. That should be the default design, and design claims. Programmers should write code assuming that design. IF it can be proven that a double buffer is unnecessary e.g. all alternative types are noexcept, a monostate alternative is available etc, THEN you can employ a single buffer implementation as an *optimisation*. That makes thing simple for the end user: add monostate, get single buffer sized. Otherwise assume double buffer sized. With a default double buffer design, most of the other issues which other reviewers have raised go away. Even Robert's concerns about assignment operators, with a double-buffer-by-default design one can always implement the strong guarantee. I badly need to depart, so I'll have to end there by saying that I vote to ACCEPT, conditional on (i) propagation of triviality of special member functions for at least small numbers of alternative states and (ii) removal of ANY POSSIBILITY of random permutation of chosen state under ANY circumstances. Finally, thanks Peter for bringing this library for review. Nice library. Niall

1 0

Proposal for GSoC'19 ( Random Points Generation)
by Mudit Agarwal 06 Apr '19

06 Apr '19

Hi I am submitting my first draft of the proposal for the project, Implementing algorithm for random point generation according to some given distribution in a geometry. I have also implemented competency test for the project https://github.com/Mudit-1999/Random_Points_Generation. It would be really helpful if you could please check if I have fulfilled all the points mentioned to pass competency test. Can you also please review my proposal and suggest any improvement. Hereby attach is my proposal. Thanking you in advance Regards, Mudit Agarwal

1 0

[review][variant2] Variant2 Review Starts April 1
by Michael Caisse 06 Apr '19

06 Apr '19

The Boost formal review of Peter Dimov's Variant2 library will take place April 1 - 10, 2019. Please consider participating in this review. The success of Boost is partially a result of the quality review process which is conducted by the community. You are part of the Boost community. I will be grateful to receive a review based on whatever level of effort or time you can devote. Variant2 is a never-valueless C++11/14/17 implementation of std::variant. >From the README: The class boost::variant2::variant<T...> is an almost conforming implementation of std::variant with the following differences: * A converting constructor from, e.g. variant<int, float> to variant<float, double, int> is provided as an extension; * The reverse operation, going from variant<float, double, int> to variant<int, float> is provided as the member function subset<U...>. (This operation can throw if the current state of the variant cannot be represented.) * variant<T...> is not trivial when all contained types are trivial. To avoid going into a valueless-by-exception state, this implementation falls back to using double storage unless * one of the alternatives is the type monostate, * one of the alternatives has a nonthrowing default constructor, or * all the contained types are nothrow move constructible. If the first two bullets don't hold, but the third does, the variant uses single storage, but emplace constructs a temporary and moves it into place if the construction of the object can throw. In case this is undesirable, one can force emplace into always constructing in- place by adding monostate as one of the alternatives. You can find the source code here: <https://github.com/pdimov/variant2> and the documentation here: <https://pdimov.github.io/variant2/doc/html/variant2.html> Please take an early look at the library and ask questions now. Peter Dimov is very active on the Cpplang Slack #boost channel; however, please consider using the Boost Dev or User Mail Lists so that the entire community might benefit from your conversation. Note: The repository contains an expected implementation also; however, that is not being considered in this review. Thank you for your participation! michael -- Michael Caisse Ciere Consulting ciere.com

5 12

[gsoc19] looking for mentor
by Aziz Mousa 06 Apr '19

06 Apr '19

hi, I have my idea to contribute in boost project, I read the boost libraries list and see that the author of Algorithm is "Marshall Clow" I want to know how to contact with him to tell him about my idea. thanks.

1 0

Call for Speakers: International Conference on Information Society (i-Society 2019)
by International Conference on Information Society 06 Apr '19

06 Apr '19

If you are not able to see this mail, click http://r.confinfosoc.org/mk/mr/qLUGBQMxp4Sjs2NE4YExi3z5lvlWCZKGhXcL8vLsIM2b… for Speakers: International Conference on Information Society (i-Society 2019) [ ]( http://r.confinfosoc.org/mk/cl/f/SUXNTtBZKKIQS3K7XMAgqz2d4gwN08R7QeY-JpBOAY… ) Submission i-Society 2019 Call for Speakers is an open invitation. We sincerely hope that you could give a talk to the diversity of participants. Increase numbers of renowned speakers have confirmed their participation. If you are interested in giving a talk, please complete the form at http://r.confinfosoc.org/mk/cl/f/WcSYgytshsQLNmvIxy3wVH45pNQcePlyBDtX1_3wdq… before or by the 1st of May, 2019. [ Submission ]( http://r.confinfosoc.org/mk/cl/f/-hT6brTC-Gpj8JwZIfXWMoq1tq9fO0kmb4uz_A4rSS… ) This email was sent to boost(a)lists.boost.org You received this email because you are registered with Infonomics Society [ Unsubscribe here ]( http://r.confinfosoc.org/mk/un/IcFogLSqu5RwSkorQ9Mu-bTdNLGBdU-QcdZpGWjlqfqJ… ) Sent by [ ]( http://r.confinfosoc.org/mk/cl/f/3aG3a0Qf4pxEQF2aHlpkSK0PjUVKbrOE2FXQYnchXN… ) © 2019 Infonomics Society

1 0

auto_link.hpp update for Visual Studio 2019 GA release
by Trueman, Chris 06 Apr '19

06 Apr '19

Building boost with the GA release of Visual Studio 2019 names the outputs with v142 (which matches what VS 2019 names its build tools). But auto_link.hpp causes the linker to look for files named with v141. I changed auto_link.hpp to: # elif defined(BOOST_MSVC) && (BOOST_MSVC < 1910) // vc14: # define BOOST_LIB_TOOLSET "vc140" # elif defined(BOOST_MSVC) && (BOOST_MSVC < 1920) // vc14.1: # define BOOST_LIB_TOOLSET "vc141" # elif defined(BOOST_MSVC) // vc14.2: # define BOOST_LIB_TOOLSET "vc142" This corrected the linker errors on my machine. I'm happy to submit this properly but thought I'd check it with folks here first. Chris. INTELLICORP LEGAL NOTICE: This E-Mail message and all attachments transmitted with it are intended solely for the use of the addressee and may contain legally privileged and confidential information. If the reader of this message is not the intended recipient, or an employee or agent responsible for delivering this message to the intended recipient, you are hereby notified that any dissemination, distribution, copying or other use of this message or its attachments is strictly prohibited. If you received this message in error, please notify the sender immediately by replying to this message, and then delete it.

1 1

GSoC'19 [Boost.Geometry : Implementing algorithms for the concave hull problem]
by yaghyavardhan singh khangarot 06 Apr '19

06 Apr '19

Hi, I am interested in contributing to Boost.Geometry and would like to work on the Project 1 (Implementing algorithms for the concave hull problem) as my GsoC’19 project. I had some discussion regarding this with Adam Wulkiewicz. I have read the paper ( Moreira, Adriano J. C., and Maribel Yasmina Santos. “Concave hull: A k-nearest neighbors approach for the computation of the region occupied by a set of points.”) and currently going through the paper “A New Concave Hull Algorithm and Concaveness Measure for n-dimensional Datasets*” ( https://www.iis.sinica.edu.tw/page/jise/2012/201205_10.pdf )) . These are the papers given in the project description. I am also searching for any other algorithms (newer or better) for the concave hull problem. Please direct me to any other algorithms related to this project. Regards Yaghyavardhan

2 3

[GSOD19] Mentors registration
by Damian Vicino 06 Apr '19

06 Apr '19

Hi, I started the registration process for Google Season of Docs, please contact me if you want to mentor to do the formalities. Each documentor requires 2 mentors in GSOD, so the work will be collaborative. Best regards, Damian Vicino

2 2

Re: [boost] [Boost-users] [release] Boost 1.70.0 Release Candidate 1 available
by Tom Kent 04 Apr '19

04 Apr '19

On Thu, Apr 4, 2019 at 9:27 AM Marshall Clow via Boost-users < boost-users(a)lists.boost.org> wrote: > The release candidates for the 1.70.0 release are now available at: > <https://dl.bintray.com/boostorg/release/1.70.0/source/> > > The SHA256 checksums are as follows: > 6e5cba1269225395bb5e78dda48441ccadaf745e42638180015e9e6257068336 > ./boost_1_70_0_rc1.7z > 35d8e1361e2063f70aa3a6ca0dd8af0877ceb75477ebbd2c726bb1d039658c7a > ./boost_1_70_0_rc1.tar.bz2 > ec8ddbbee2fd61e2f78a1dfe9a07ad83ca8f6a2f4c704d6f297d89c6afdc4f2c > ./boost_1_70_0_rc1.tar.gz > ee2c3b97ce10f85a31b6a105ad8edf1c20fb4b936c9a6e6008206059cb98ab1b > ./boost_1_70_0_rc1.zip > > As always, the release managers would appreciate it if you download > the candidate of your choice and give building it a try. Please report > both success and failure, and anything else that is noteworthy. > Windows/Visual Studio (msvc 10.0, 11.0, 12.0, 14.0, 14.1) builds look good. toolset arch compile Link Execute msvc-10.0 32 X X X msvc-10.0 64 X X X msvc-11.0 32 X X X msvc-11.0 64 X X X msvc-12.0 32 X X X msvc-12.0 64 X X X msvc-14.0 32 X X X msvc-14.0 64 X X X msvc-14.1 32 X X X msvc-14.1 64 X X X Compile means that the b2 command completed without errors Link means that visual studio was able to link a sample executable to a library (libboost_thread-vcXXX-mt[-gd]-1_XX.lib) generated Execute means that the linked program executed without errors. Full build logs can be found at: https://gist.github.com/teeks99/798df332c12ec98708e3710da35dd606 Tom

2 1

[variant2] Andrzej's review -- design
by Andrzej Krzemienski 04 Apr '19

04 Apr '19

Hi Everyone, First of all, I wanted to thank Peter for writing this non-trivial library and sharing it with the community. This is not a full review yet. I just wanted to discuss the design first, especially the never-empty guarantee. And I am going to rehash the old argument. The core of variant2 is its never-empty guarantee and the mechanism to achieve it: a number of different algorithms chosen depending on what the potentially stored types permit. In fact this mechanism is not much different than the one present in boost::variant. The issue to solve is what happens in copy/move assignment of variant<X, Y> when we have to change the stored type from X to Y. X has to be destroyed and Y initialized. But if the initialization of Y throws we would be left without either X (already destroyed) or Y (not successfully constructed). (The same problem applies to member function emplace()). Except for the last step boost::variant and variant2 try to apply the same sequence: 1. If all the subtypes have noexcept initialization, no safety measures need to be taken. 2. If sub-types have noexcept move constructor, a temporary local storage is used and the backup value is moved to and from it. 3. If one of the subtypes is a special type boost::blank or std::monostate respectively, in case of a throw this type is default constructed in the variant. 4. If there is any nothrow-default-constructible subtype in the variant, it gets default-constructed upon exception. If neither of the above can be applied, the two libraries apply different approaches. variant2 is big enough to fit two unions of X and Y within its storage. This way it does not have to destroy the X when initializing the Y. boost::variant, for the additional storage uses heap allocated memory. Interestingly, the double storage as in variant2 has been considered in the initial design of boost::variant but rejected by the community, because it added spacial overhead even for use cases that never invoked variant's assignment. This is described in the Rationale section of boost::variant documentation: https://www.boost.org/doc/libs/1_69_0/doc/html/variant/design.html#variant.… In boost.variant, only these programs pay for the overhead that really invoke the assignment operator. Neither of the solutions seems strictly superior than the other. The double storage could be thought as better because it seems to be able to cover use cases where heap allocations are banned altogether. On the other hand, in these applications it is difficult to imagine that X and Y would be throwing exceptions in move constructors or during initialization. One inferiority of boost::variant is that it can fail for its own reasons unrelated to failures of X and Y. Even if no operations on X and Y throw during the assignment of variant, the variant can still throw because it allocates memory. Some people believe that an application cannot recover from bad_alloc anyway, but this is not a universally held view. To me, the important question is, do we really need the never-empty guarantee. It was an unquestionable requirement for the initial design of boost::variant. Now, variant2 is advertised as an allegedly superior solution to std::variant, because the latter does not provide the never-empty guarantee, even though the cost of providing it is significant. But I myself fail to see the *practical* value of the never-empty guarantee. The argument I hear is that, we want to make it an invariant that either X or Y is stored in variant. I agree with this goal in general, but the costs and contortions required to satisfy it outweigh the benefit. Now, I hear that if the invariant is weakened everyone will have to check everywhere if any variant is in a valueless_by_exception state. This seems to be confirmed by the semantics of std::variant::visit(), which requires that valueless_by_exception is checked and an exception thrown on valueless. This last part is indeed strange in std::variant, but I do not agree that the fix is to provide a never-empty guarantee at the cost of compromising run-time performance and complicating the design. I can think of the following alternative design. The invariant of a variant (pun intended) allows for a valueless_by_exception state. There is no way to get to this state other than by throwing form the initialization of Y in variant's assignment or .emplace() operation. Calling .visit() on a valueless variant is UB. The destructor and reset functions such as assignment and .emplace() can handle the valueless state. This is almost what std::variant does except for UB in .visit(). Why I find this superior to variant2. 1. It is simpler, faster and smaller. 2. Observing the valueless state can only happen when somebody is handling exceptions incorrectly. And in that case this is exception handling strategy that needs to be fixed: not the variant's guarantees. It should be noted that variant2 DOES NOT PROVIDE A STRONG EXCEPTION SAFETY GUARANTEE. The never-empty guarantee has a certain negative effect of confusing people so that they are led to believe that they have strong exception safety. But they don't. even expert programmers in this forum expressed their surprise that changing from X to Y in variant<X, Y, Z> can get them a variant storing Z. Sometimes it is even trickier: X may be a container that currently stores 10 elements. You assign Y, and after the exception you get an X that stores zero elements. Because of these problems, the only reasonable thing to do is to follow the advice from Dave Abraham's article: https://www.boost.org/community/exception_safety.html To quote the relevant part, "If a component has many valid states, after an exception we have no idea what state the component is in; only that the state is valid. The options for recovery in this case are limited: either destruction or resetting the component to some known state before further use." If this principle is followed no-one will ever observe the valueless_by_exception state. This also applies to variant2. If this principle from Dave Abrahams is followed, no-one will ever benefit from the never-empty guarantee (but people will still pay the costs of providing it). You cannot do anything meaningful with variant that threw other than destroy or reset it. (But it is probably best to destroy it.) If objects are allowed to survive the stack unwinding, they should either offer a strong exception safety guarantee, or you have to have some very detailed knowledge of a given particular type how its state gets modified under exceptions, but this is usually very difficult and best left to experts. I have started a thread in this list a while ago, requesting for an example of code that *correctly handles exceptions* (does not stop stack unwinding at random places), where the programmer would make use of the never-empty guarantee , and chose something else than destroying or resetting the variant. And although I received some generic statements, referring to the purity of the design, strength of the invariants, and the easiness of thinking or "correctness", none of the proponents of the never-empty guarantee gave such an example. Which might be an indication that the problem we are solving may be nonexistent. I am not sure of this claim, but I have not seen any convincing example either. I believe that we are facing one of this problems where the strong invariants of the type need to be weakened due to practical considerations. I can see no correctness issues with valueless state other than in programs that are already exception-unsafe. Also, I have heard claims that if someone is fine with valueless state they should put std::monostate as one of the types and the same effect without double buffering is achieved. But this is not true. Variant with monostate can get the degenerate state in a correct program; often: in the variant constructor. Now I really have to special-case it whenever I inspect the variant object, which is a nightmare: this is really a weak invariant in an allegedly strong-invariant variant. In contrast, for std::variant you only get the valueless state in the program that incorrectly handles exceptions: no need to special-case the valueless_state when doing visitation.. variant2 is not a replacement for std::variant, as the choice to support never-empty guarantee at the cost of more expensive operations and increased object size is not necessarily superior. Even if my view is not generally held, it has to be acknowledged that the issue is controversial. Variant2 cannot replace boost::variant either. This is not only about supporting pre c++11, but also for different trade-offs in never-empty guarantee, which were deemed inferior in boost::variant design. variant2 is ismply a third point in the multi-dimensional design space of different trade offs for variant-like libraries. On a different subject, one thing that is missing from both: boost::variant, and std::variant, is the narrow-contract observers for the specific stored type, useful when I know by other means what is currently stored in the variant object. This is something the third variant implementation has a chance to change, however it chose to follow its predecessors. This seems somewhat counter to the spirit of C++. We requested a similar thing of Niall's Outcome library, and the narrow-contract observers were added. Below is the comparison between boost::variant, std::variant and variant2. I do not know how to make a table in the email discussion interface, so I will have to make it with a list. 1. Works in pre-c++11 dialects * boost::variant: yes * std::variant: no * variant2: no 2. Size of variant<X, Y> (when X and Y are unfriendly) * boost::variant: sizeof(void*) + SXY (SXY is the size of union{X x; Y y;}) * boost::variant: sizeof(int) + SXY * variant2::variant: sizeof(int) + 2 * SXY 3. Uses heap allocations * boost::variant: yes * std::variant: no * variant2: no 4. Throws its own exceptions in assignment * boost::variant: yes * std::variant: no * variant2: no 5. Fast (narrow contract) access to X alternative. * boost::variant: no * std::variant: no * variant2: no 7. Strong exception-safety guarantee * boost::variant: no * std::variant: no * variant2: no 8. Never-empty guarantee * boost::variant: yes * std::variant: no * variant2: yes 9. Throws its own exceptions in visitation * boost::variant: no * std::variant: yes * variant2: no Regards, &rzej;

5 19