From: Niall Douglas (s_sourceforge_at_[hidden])
Date: 2019-10-10 13:25:08
Just as a heads up to those who care, and any pretesting of these
changes in advance of the Boost release is welcome.
There are two breaking changes:
1. The git submodule mechanism used by standalone Outcome of specifying
dependent libraries has been replaced with a cmake superbuild of
dependencies mechanism instead. Upon cmake configure, an internal copy
of quickcpplib will be git cloned, built and installed into the build
directory from where an internal `find_package()` uses it. This breaks
the use of the unconfigured Outcome repo as an implementation of
Outcome, one must now do one of:
1. Add Outcome as subdirectory to cmake build
2. Use cmake superbuild (i.e. `ExternalProject_Add()`) to build and
install Outcome into
a local installation.
3. Use one of the single header editions.
2. For standalone Outcome, the current compiler is now checked for
whether it will compile code containing C++ Concepts, and if it does,
all cmake consumers of Outcome will enable C++ Concepts. Set the cmake
variable `CXX_CONCEPTS_FLAGS` to an empty string to prevent auto
detection and enabling of C++ Concepts support occurring.
There are two new features:
- Standalone outcome is now `make install`-able, and cmake
`find_package()` can find it. Note that you must separately install and
`find_package()` Outcome's dependency, quickcpplib, else
`find_package()` of Outcome will fail.
- Support for C++ Coroutines has been added. This comes in two parts,
firstly there is now an `OUTCOME_CO_TRY()` operation suitable for
performing the `TRY` operation from within a C++ Coroutine. Secondly, in
the header `outcome/coroutine_support.hpp` there are implementations of
`eager<OutcomeType>` and `lazy<OutcomeType>` which let you more
naturally and efficiently use `basic_result` or `basic_outcome` from
within C++ Coroutines -- specifically, if the result or outcome will
construct from an exception pointer, exceptions thrown in the coroutine
return an errored or excepted result with the thrown exception instead
of throwing the exception through the coroutine machinery (which in
current compilers, has a high likelihood of blowing up the program).
Both `eager<T>` and `lazy<T>` can accept any `T` as well. Both have been
tested and found working on VS2019 and clang 9.
More detail can be found at:
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk