Datasets:

cartersusi
/

zig-llama

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 141k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

repo_id stringlengths 5 186	file_path stringlengths 15 223	content stringlengths 1 32.8M ⌀
repos/outcome/doc/src/content	repos/outcome/doc/src/content/videos/_index.md	+++ title = "Videos" weight = 40 +++ Outcome has been presented at some of the major C++ conferences as it has evolved. As the older content is less relevant to Outcome today, this list is given in reverse chronological order. --- ## Dublin C++ users group 2018 "Deterministic Disappointment" Literature review of the WG21 papers relating to deterministically handling failure, and using libraries such as Outcome to implement the same. {{< youtube cbUTAoHy6Ls >}} {{< slides "d/e/2PACX-1vRR3_ZXU8pC_1oFH6rctPJ1wijWCQY-uGIBEK2SzOLaVnuFjn7Ed76sYs8QE6pUl-oP2nrggw-b4fma" >}} --- ## Meeting C++ 2017 "Introduction to proposed std::expected<T, E>" Literature review of the several WG21 papers relating to std::expected<T, E>. {{< youtube JfMBLx7qE0I >}} {{< slides "d/e/2PACX-1vSnTCn_hX3_uKNco8LtJTgAg2LrRO0zOJ3JiQiWMFFG8pNVwvUZr2ooYjXO9V94kdlqLxSB7DLTLPf5" >}} --- ## ACCU 2017 "Mongrel Monads, Dirty, dirty, dirty" Covers the history of error handling in C++, and how the LEWG Expected works. (Note that the Expected presented here no longer exists, it was substantially changed after the Outcome v1 peer review. Furthermore the Outcome presented here no longer exists, the peer review demanded a complete rebuild) {{< youtube XVofgKH-uu4 >}} {{< slides "d/e/2PACX-1vQZXLxkB716ZIMcEqV8QkeUvKhG33BmzKJdzSvx6QRfEGjmjXjHjeLrXSjgTZwG2rCaBNAZTxj41r5n" >}}
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/_index.md	+++ title = "Experimental" weight = 15 +++ In `<outcome/experimental>`, there ships an Outcome-based simulation of the proposed [P1095 Zero overhead deterministic failure](https://wg21.link/P1095) specific implementation of [P0709 Zero overhead exceptions: Throwing values](http://wg21.link/P0709). This library-only implementation lets you use a close simulacrum of potential future C++ lightweight exceptions today in [any C++ 14 compiler which Outcome supports]({{< relref "/requirements" >}}). This Experimental Outcome implementation has been in production use for some years now. It has shipped on at least one billion devices, as part of a games suite very popular on Microsoft Windows, Apple iOS and Google Android devices. It powers big iron enterprise applications as well, indeed all trades including futures in the United States are captured live into a database for the SEC by an Experimental Outcome based codebase. Finally, Experimental Outcome is used in the firmware of parts of driver assisting cars where its particularly rich and flexible failure added information combined with compatibility with globally disabled C++ exceptions proved to be a big win. The base for failure handling in future C++ might be `std::error` from [P1028 `status_code`](https://wg21.link/P1028). This proposal is currently being refined before WG21's Library Evolution Working Group with the expectation that it will be standardised as a large enhancement and backwards compatible superset of `std::error_code` which is also capable of transporting any move-only type such as `std::exception_ptr`. Like `std::error_code`, proposed `std::error` occupies exactly two CPU registers of layout, and thus is extremely lightweight. It can wrap arbitrary third party error handling systems, and automatically constructs from `std::error_code` and `std::exception_ptr`, propagating the original underlying implementations (no matter how customised) exactly (e.g. `boost::exception_ptr`). Unlike `<system_error>`, `std::error` does not have dependencies on expensive standard library headers, so including it into your global build has a very low build time impact. `std::error` knows how to throw itself as a conventional C++ exception, and knows how to losslessly consume arbitrary C++ exception throws. Finally, `std::error` is ABI stable, and is a [P1029 move bitcopying](https://wg21.link/P1029) type whereby moved-from objects do not need to be destroyed. --- Experimental Outcome uses the [same proposed `std::error` object as P1095 would do for its `E` type](https://wg21.link/P1028) by bundling internally a copy of https://ned14.github.io/status-code/, the reference implementation library for proposed `std::error`. Outcome emulates move bitcopying semantics for types declaring themselves move bitcopying via the trait {{% api "is_move_bitcopying<T>" %}}, and status codes opt into this. This greatly improves codegen to be no worse than with `std::error_code` (a trivially copyable type), as https://godbolt.org/z/GEdEGc demonstrates, despite that proposed `std::error` is a move-only type with a non-trivial destructor. Outcome binds `status_code` into `basic_result` and `basic_outcome` customisations via the following headers: - `<outcome/experimental/status_result.hpp>` - `<outcome/experimental/status_outcome.hpp>` These headers import the entire contents of the `SYSTEM_ERROR2_NAMESPACE` namespace into the `OUTCOME_V2_NAMESPACE::experimental` namespace. You can thus address everything in `SYSTEM_ERROR2_NAMESPACE` via `OUTCOME_V2_NAMESPACE::experimental`. As P1095 also proposes C language support for lightweight C++ exceptions, experimental Outcome also has a macro-based C interface that enables C code to work with the C-compatible subset of `status_result<T, E>`: - `<outcome/experimental/result.h>` For non-Windows non-POSIX platforms such as some embedded systems, standalone Experimental Outcome can be used with the `SYSTEM_ERROR2_NOT_POSIX` macro defined. This does not include POSIX headers, and makes available a high fidelity, fully deterministic, alternative to C++ exceptions on such platforms. Finally, there is a single include edition of Experimental Outcome, which can be found at https://github.com/ned14/outcome/blob/develop/single-header/outcome-experimental.hpp. You can play with this on godbolt by `#include <outcome-experimental.hpp>`. {{% notice warning %}} <b>It is stressed, in the strongest possible terms, that any item inside `<outcome/experimental>` is subject to unannounced breaking change based on WG21 standards committee feedback</b>. That said, the chances are high that most of those breaking changes will be to naming rather than to fundamental semantics, so you can upgrade with a bit of find and replace. {{% /notice %}}
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/map.md	+++ title = "Approximate map between error code designs" weight = 10 +++ Much of the design of Boost.System (which went on to become `<system_error>`) has been retained in proposed `<system_error2>`, so an approximate map between `<system_error2>` and `<system_error>` and Boost.System can be given: <table width="100%" cellpadding="5" border="1"> <colgroup> <col width="25%"> <col width="25%"> <col width="50%"> </colgroup> <tr><th>C++ 17 <tt><system_error></tt><th>Boost.System<th>Proposed <tt><system_error2></tt> <tr> <td style="vertical-align: top;"><tt>std::errc</tt> <td style="vertical-align: top;"><tt>boost::system::errc</tt> <td style="vertical-align: top;"><tt>experimental::errc</tt> (almost identical) <tr> <td style="vertical-align: top;"><tt>std::error_category</tt> <td style="vertical-align: top;"><tt>boost::system::error_category</tt> <td style="vertical-align: top;"><tt>experimental::status_code_domain</tt> <tr> <td style="vertical-align: top;"><tt>std::generic_category</tt> <td style="vertical-align: top;"><tt>boost::system::generic_category</tt> <td style="vertical-align: top;"><tt>experimental::generic_code_domain</tt> <tr> <td style="vertical-align: top;"><tt>std::system_category</tt> <td style="vertical-align: top;"><tt>boost::system::system_category</tt> <td style="vertical-align: top;">One of:<ul> <li><tt>experimental::posix_code_domain</tt> (POSIX systems)<p> <li><tt>experimental::win32_code_domain</tt> (Microsoft Windows)<p> <li><tt>experimental::nt_code_domain</tt> (Microsoft Windows) </ul> Note that there are more precanned code categories though they require additional header inclusions: <tt>com_code</tt>, <tt>getaddrinfo_code</tt>. <tr> <td style="vertical-align: top;"><tt>std::error_condition</tt> <td style="vertical-align: top;"><tt>boost::system::error_condition</tt> <td style="vertical-align: top;"><b>No equivalent</b> (deliberately removed as hindsight proved it to be a design mistake leading to much confusing and hard to audit for correctness code) <tr> <td style="vertical-align: top;"><tt>std::error_code</tt> <td style="vertical-align: top;"><tt>boost::system::error_code</tt> <td style="vertical-align: top;">One of:<ul> <li><tt>experimental::status_code<DomainType></tt><p> <li><tt>const experimental::status_code<void> &</tt><p> <li><tt>experimental::status_code<erased<intptr_t>></tt> (aliased to <tt>experimental::system_code</tt>)<p> <li><tt>experimental::errored_status_code<DomainType></tt><p> <li><tt>const experimental::errored_status_code<void> &</tt><p> <li><tt>experimental::errored_status_code<erased<intptr_t>></tt> (aliased to <tt>experimental::error</tt>) </ul> The difference between status codes and errored status codes is that the latter are guaranteed to refer to a failure, whereas the former may refer to a success (including warnings and informationals). <tr> <td style="vertical-align: top;"><tt>std::system_error</tt> <td style="vertical-align: top;"><tt>boost::system::system_error</tt> <td style="vertical-align: top;">One of:<ul> <li><tt>const experimental::status_error<void> &</tt><p> <li><tt>experimental::status_error<DomainType></tt> </ul> </table> As is obvious from the above, in `<system_error2>` one must be much more specific and accurate with respect to intent and specification and desired semantics than with `<system_error>`. Much ambiguity and incorrectness which flies silently in `<system_error>` will refuse to compile in `<system_error2>`.
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/outcome.md	+++ title = "Tying it all together" weight = 75 +++ Firstly let's alias a more convenient form of `status_result`: {{% snippet "experimental_status_code.cpp" "typedef" %}} (The defaulting of `default_result_policy` is superfluous, it's already the default) What follows now is very standard Outcome code. Indeed, it would compile just fine under standard Outcome with only a few typedefs. {{% snippet "experimental_status_code.cpp" "open_file" %}} And running this program yields: ``` Returned error has a code domain of 'file i/o error domain', a message of 'No such file or directory (c:\users\ned\documents\boostish\outcome\doc\src\snippets\experimental_status_code.cpp:195)' And semantically comparing it to 'errc::no_such_file_or_directory' = 1 ``` ### Conclusion Once you get used to `<system_error2>` and the fact that any `result` with `E = error` is always move-only, using experimental Outcome is just like using normal Outcome. Except that codegen will be better, custom domains are safe to use in headers, semantic comparisons have guaranteed complexity bounds, and build times are much reduced. What's not to like? :) Finally, if you have feedback on using experimental Outcome which you think would be of use to the standards committee when evaluating possible implementations of [P0709 Zero overhead exceptions: Throwing values](http://wg21.link/P0709), please do get in touch! This especially includes successful experiences!!!
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/status_result.md	+++ title = "`status_result` and `status_outcome`" weight = 40 +++ `status_result` and `status_outcome` are type aliases to {{< api "basic_result<T, E, NoValuePolicy>" >}} and {{< api "basic_outcome<T, EC, EP, NoValuePolicy>" >}} in the usual way, but with a defaulted `NoValuePolicy` which selects on the basis of `status_code<DomainType>` instead. {{% notice note %}} If the `E` type is not some `status_code<>`, the default policy selector will complain. {{% /notice %}} The specifications are: ```c++ experimental::status_result<T, E = experimental::error> experimental::status_outcome<T, E = experimental::error, EP = std::exception_ptr> ``` So, the default `E` is the erased errored status code `system_code`, which can represent any `generic_code`, `posix_code`, `win32_code`, `nt_code`, `com_code` and many other integer error and status codings. Because it is an errored status code, it will always represent a failure. You can absolutely choose an `E` type which is non-erased e.g. `posix_code` directly. You can also choose an `E` type which is not contract guaranteed to be a failure, though your users may find that surprising. Whether to choose typed status codes versus the erased status codes depends on your use cases. Outcome replicates faithfully the implicit and explicit conversion semantics of its underlying types, so you can mix results and outcomes of `<system_error2>` types exactly as you can the `<system_error2>` types themselves e.g. typed forms will implicitly convert into erased forms if the source type is trivially copyable or move relocating. This means that you can return a `generic_code` from a function returning a `system_code` or `error`, and it'll work exactly as you'd expect (implicit conversion). {{% notice note %}} As `status_code<erased<T>>` is move-only, so is any `status_result` or `status_outcome`. For some reason this surprises a lot of people, and they tend to react by not using the erased form because it seems "difficult". {{% /notice %}} It is actually, in fact, a wise discipline to follow to make all functions return move-only types if you care about determinism and performance. Whilst C++ 17 onwards does much to have the compiler avoid copying of identical function return values thanks to guaranteed copy elision, when a chain of functions return different types, if the programmer forgets to scatter `std::move()` appropriately, copies rather than moves tend to occur in non-obvious ways. No doubt future C++ standards will improve on the automatic use of moves instead of copies where possible, but until then making all your `result` and `outcome` types move-only is an excellent discipline. Note that move-only `result` and `outcome` capable code (i.e. your project is in Experimental Outcome configuration) usually compiles fine when `result` and `outcome` are copyable (i.e. your project is in Standard Outcome configuration), albeit sometimes with a few compiler warnings about unnecessary use of `std::move()`.
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/advantages.md	+++ title = "The main advantages" weight = 5 +++ The main advantages of choosing `<outcome/experimental>` over default Outcome: 1. Codegen is tighter and less verbose[^1], sometimes remarkably so. 2. Build time impact is markedly lower, barely above the inclusion of naked `<basic_result.hpp>`, as the STL allocator machinery and `std::string` et al is not dragged into inclusion by including `<system_error>`. Note that `<outcome/experimental/status_outcome.hpp>` bring in `<exception>`, however `<outcome/experimental/status_result.hpp>` brings in no extra system headers. 3. More discipline is imposed on your use of Outcome, leading to less ambiguous code which is easier to optimise by the compiler, lower cost to maintain, and lower cognitive load to audit code based on experimental Outcome for correctness. 4. Code written to `<outcome/experimental>` can be fairly easily dual targeted, with just a few switching type aliases, to default Outcome. This author has several Outcome-based libraries with identical source code which can target either configuration of Outcome. The experimental Outcome build regularly beats the default Outcome build in benchmarks by 2-3%, and the dual target source code, being written to tighter discipline, is faster and more deterministic in the default target than it was before the (non-trivial) port to `<outcome/experimental>`. 5. If you want 'official' C support, experimental Outcome is able to provide that in a way not possible for default Outcome which cannot make sufficiently strong C compatibility assumptions about `std::error_code`. If you are building a codebase on top of Outcome expecting long term maintenance, the author's personal recommendation is that you design, write, test and optimise it for `<outcome/experimental>`. What you ship to your customers ought to be targeted at default Outcome however, so employ type aliases and macros as appropriate to switch the build configuration for production releases. This is what the Outcome author does himself, to date with great success, despite the fundamental architectural differences between `<system_error>` and proposed `<system_error2>`. [^1]: Boost.System's `error_code` has incorporated some of the design improvements of experimental `status_code`, and produces codegen somewhere in between experimental `status_code` and `std::error_code`.
repos/outcome/doc/src/content	repos/outcome/doc/src/content/experimental/differences.md	+++ title = "Major differences" weight = 20 +++ The major design differences between `<system_error>` and proposed `<system_error2>` are as follows: 1. `experimental::status_code<DomainType>` can represent warnings and form-of-success codes as well as failure codes. `experimental::errored_status_code<DomainType>` is more similar to `std::error_code`, in that it can only represent failures (this is enforced by C++ 20 contract or runtime assertion check). 2. The code's domain implementation defines the payload type to be transported around by `experimental::status_code<DomainType>`, rather than it being hardcoded to `int` as in `std::error_code`. The payload type can be anything you like, including non-trivially-copyable, move-only, complex etc types. This facility is extremely useful. Extra failure metadata such as stack backtraces can be returned, for example. You can absolutely vary the payload depending on whether `NDEBUG` or `_DEBUG` is defined, too. 3. If your domain defines a payload type which is trivially copyable or move relocating[^1], it gains an implicit convertibility to a move-only `experimental::status_code<erased<T>>` where `T` is another trivially copyable or move relocating type. This permits global headers to use a single, common, type erased, status code type which is highly desirable for code bases of any complexity. However, unlike `std::error_code`, which fulfils the exact same role in `<system_error>` based code, the type erased payload can be bigger than the hardcoded `int` in `std::error_code`. This facility is also extremely useful, as extra failure metadata can be type erased, transported through code with no knowledge of such things, and the original type with failure metadata resurrected at the handling point. Indeed P1095 proposed `std::error` is a type alias to `experimental::status_code<erased<intptr_t>>`, and it can transport erased `std::exception_ptr` instances, POSIX error codes, and much more besides. 4. Equality comparisons between status code's with non-identical domains are always <b><em>semantic</em></b> i.e. are they semantically equivalent, rather than exactly equal? This mirrors when you compare `std::error_code` to a `std::error_condition`, but as there is no equivalent for the latter in `<system_error2>`, this means that when you see the code: ```c++ if(code1 == code2) ... ``` ... you can be highly confident that this is an inexact, semantic, match operation. The same code under `<system_error>` is highly ambiguous as to whether exact or inexact comparison is being performed (after all, all there is is "`code1 == code2`", so it depends on the types of `code1` and `code2` which usually is not obvious). The ambiguity, and high cognitive load during auditing `<system_error>` code for correctness, has led to many surprising and unexpected failure handling bugs during the past decade in production C++. 5. `<system_error2>`, being a new design, has all-constexpr construction and destruction which avoids the need for static global variables, as `<system_error>` has. Each of those static global variables requires an atomic fence just in case it has not been initialised, thus every retrieval of an error category bloats code and inhibits optimisation, plus makes the use of custom error code categories in header-only libraries unreliable. Boost.System has replicated the all-constexpr construction and destruction from `<system_error2>`, and thus now has similar characteristics in this regard. 6. Finally, this is a small but important difference. Under `<system_error>`, this extremely common use case is ambiguous: ```c++ if(ec) ... ``` Does this code mean "if there was an error?", or "if the error code is set?", or "is the error code non-zero?". The correct answer according to the standard is the last choice, but a quick survey of open source `<system_error>` based code on github quickly demonstrates there is widespread confusion regarding correct usage. `<system_error2>` solves this by removing the boolean test entirely. One now writes `if(sc.success()) ...`, `if(sc.failure()) ...`, `if(sc.empty()) ...` and so on, thus eliminating ambiguity. [^1]: [Move relocating is not in the standard, it is currently within WG21 Evolution Working Group Incubator](http://wg21.link/P1029). It is defined to be a type whose move constructor `memcpy()`'s the bits from source to destination, followed by `memcpy()` of the bits of a default constructed instance to source, and with a programmer-given guarantee that the destructor, when called on a default constructed instance, has no observable side effects. A surprising number of standard library types can meet this definition of move relocating, including `std::vector<T>`, `std::shared_ptr<T>`, and `std::exception_ptr`.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/c-api/_index.md	+++ title = "Using Outcome from C code" description = "Interacting with `result` returning C++ functions from C code." weight = 90 +++ A long standing problem for C code (or more usually nowadays, the many other programming languages which can speak the C ABI but not the C++ ABI) is how to interpret C++ exception throws. The answer is of course that they cannot, thus requiring one to write C shim code on the C++ side of things of the form: ```c++ // The API we wish to expose to C const char get_value(double v); // The C shim function for the C++ get_value() function. extern "C" int c_get_value(const char ret, double v) { try { ret = get_value(v); return 0; // success } catch(const std::range_error &) { return ERANGE; } // More catch clauses may go in here ... catch(...) { return EAGAIN; } } ``` This is sufficiently painful that most reach for a bindings generator tool like [SWIG](http://www.swig.org/) to automate this sort of tedious boilerplate generation. And this is fine for larger projects, but for smaller projects the cost of setting up and configuring SWIG is also non-trivial. What would be really great is if `result<T>` returning `noexcept` C++ functions could be used straight from C. And indeed Experimental Outcome provides just that facility which this section covers next.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-cxx/example.md	+++ title = "Example C++ function" description = "" weight = 20 +++ Let us start with a simple C++ function which we wish to make available to C code: {{% snippet "cpp_api.cpp" "function" %}} As the alias `status_result<size_t>` defaults the erased type to the alias `system_code`, the `to_string()` function returns (in concrete types) `basic_result<size_t, status_code<erased<intptr_t>>>`. The standard Outcome function referenced is documented at {{% api "std::error_code error_from_exception(std::exception_ptr &&ep = std::current_exception(), std::error_code not_matched = std::make_error_code(std::errc::resource_unavailable_try_again)) noexcept" %}}. The proposed `<system_error2>` reference library implementation provides an identically named function taking similar parameters, but it returns a `outcome_e::system_code` (`status_code<erased<intptr_t>>`) instead of a `std::error_code`.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-cxx/_index.md	+++ title = "Calling C++ from C" description = "" weight = 20 +++ C++ has excellent two-way compatibility with the C ABI, but there are some limitations you must observe to write C++ code which C code can call without marshalling at the ABI boundary: 1. A C++ function may not throw exceptions if it is safe to call from C, and so should always be marked `noexcept`. 2. A C++ function should be annotated with `extern "C"` to prevent its symbol being mangled, and thus give it the C rather than C++ ABI. 3. You cannot use overloading in your `extern "C"` functions. 4. You may only use types in your C++ function declaration for which these traits are both true: - [`std::is_standard_layout_v<T>`](http://en.cppreference.com/w/cpp/types/is_standard_layout) - [`std::is_trivially_copyable_v<T>`](http://en.cppreference.com/w/cpp/types/is_trivially_copyable) (Note that `std::is_trivially_copyable_v<T>` requires trivial destruction, but NOT trivial construction. This means that C++ can do non-trivial construction of otherwise trivial types) --- The above is what the standard officially requires for well defined C and C++ interop. However, all of the three major compilers MSVC, GCC and clang are considerably more relaxed. In those three major compilers, "almost-standard-layout" C++ types work fine in C. "Almost-standard-layout" C++ types have these requirements: 1. No virtual functions or virtual base classes i.e. [`std::is_polymorphic_v<T>`](http://en.cppreference.com/w/cpp/types/is_polymorphic) must be false. This is because the vptrs offset the proper front of the data layout in an unknowable way to C. 2. Non-static data members of reference type appear to C as pointers. You must never supply from C to C++ a non-null pointer which is seen as a reference in C++. 3. C++ inheritance is seen in C data layout as if the most derived class has nested variables of the inherited types at the top, in order of inheritance. 4. Types with non-trivial destructors work fine so long as at least move construction and assignment is the same as copying bits like `memcpy()`. You just need to make sure instances of the type return to C++, and don't get orphaned in C. This was referred to in previous pages in this section as "move relocating" types. Experimental Outcome's support for being used from C does not meet the current strict requirements, and thus relies on the (very common) implementation defined behaviour just described (it is hoped that future C++ standards can relax the requirements to those just described). Specifically, proposed `status_code` is an almost-standard-layout type, and thus while it can't be returned from `extern "C"` functions as the compiler will complain, it is perfectly safe to return from C++ functions to C code on the three major compilers, as it is an "almost-standard-layout" C++ type if `T` is an "almost-standard-layout" C++ type.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-cxx/example2.md	+++ title = "Calling it from C" description = "" weight = 30 +++ Firstly we need to declare to C our `result` returning C++ function: {{% snippet "c_api.c" "preamble" %}} Now let's call the C++ function from C: {{% snippet "c_api.c" "example" %}} Running this C program yields: ``` to_string(9) fills buffer with '9' of 1 characters to_string(99) fills buffer with '99' of 2 characters to_string(999) fills buffer with '999' of 3 characters to_string(9999) failed with error code 105 (No buffer space available) ```
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-c/_index.md	+++ title = "C Results" description = "Outcome's C Result support" weight = 30 +++ The C macro API header `<outcome/experimental/result.h>` has some macros for working with any kind of Result: <dl> <dt><code>CXX_DECLARE_RESULT(ident, T, E)</code> <dd>Declares to C a <code>basic_result<T, E></code> type uniquely identified by <code>ident</code>. <code>T</code> is available at the member variable <code>.value</code>, and <code>E</code> is available at the member variable <code>.error</code>. If you call this from within C++, make SURE it is not within a <code>extern "C"</code> block! <dt><code>CXX_RESULT(ident)</code> <dd>A reference to a previously declared <code>result</code> type with unique <code>ident</code>. <dt><code>CXX_RESULT_HAS_VALUE(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code> has a value. <dt><code>CXX_RESULT_HAS_ERROR(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code> has an error. <dt><code>CXX_RESULT_ERROR_IS_ERRNO(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code>'s error value is a code in the POSIX <code>errno</code> domain. </dl> The above let you work, somewhat awkwardly, with any C-compatible `basic_result<T, E>`. `basic_result<T, E>` is trivially copyable and standard layout if its `T` and `E` are both so, and it has the C layout: ```c++ struct cxx_result_##ident { union { T value; E error; }; unsigned flags; }; ``` Note that this layout is different to that of [`CXX_DECLARE_STATUS_CODE`]({{% relref "../from-c" %}}) as the C++ `result` has a different layout if `E` is a status code.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-c/system_code.md	+++ title = "C system error results" description = "Status code's `std::error` in C" weight = 10 +++ In v2.2.11, C Result support went from second tier to first tier status, and now you can create, query and manipulate a subset of Result types entirely from within C by including `<outcome/experimental/result.h>`. The subset supported are those `result<T, E>` which are [a `status_result<T>`]({{% relref "../../status_result" %}}) i.e. the `E` is hardcoded to `experimental::error` which is the type erased runtime polymorphic holder for any errored `status_code` whose payload is not bigger than an `intptr_t`. This is the most useful subset of Outcome Experimental's possible Result types, allowing arbitrary custom error coding schemes from any unknown source to work seamlessly with all others, including errors from the system or third party libraries. The operations available to C are: <dl> <dt><code>CXX_DECLARE_RESULT_SYSTEM(ident, T)</code> <dd>Declares to C a <code>status_result<T></code> type uniquely identified by <code>ident</code>. <code>T</code> is available at the member variable <code>.value</code>, and <code>struct cxx_status_code_system</code> is available at the member variable <code>.error</code>. If in C++, implements C extern functions for making successful and failure results of this type. If you call this from within C++, make SURE it is not within a <code>extern "C"</code> block! <dt><code>CXX_RESULT_SYSTEM(ident)</code> <dd>A reference to a previously declared <code>status_result</code> type with unique <code>ident</code>. <dt><code>CXX_MAKE_RESULT_SYSTEM_SUCCESS(ident, expr)</code> (needs C++ counterpart linked into final binary) <dd>This invokes the aforementioned extern function which creates a <code>status_result</code> with a successful value of type <code>T</code>. <dt><code>CXX_MAKE_RESULT_SYSTEM_FAILURE_POSIX(ident, expr)</code> (needs C++ counterpart linked into final binary) <dd>This invokes the aforementioned extern function which creates a <code>status_result</code> with a failure of type <code>posix_code</code> representing a POSIX <code>errno</code>. <dt><code>CXX_MAKE_RESULT_SYSTEM_FAILURE_SYSTEM(ident, expr)</code> (needs C++ counterpart linked into final binary) <dd>This invokes the aforementioned extern function which creates a <code>status_result</code> with a failure of type <code>posix_code</code> representing a POSIX <code>errno</code> if on POSIX; if on Windows then a failure of type <code>win32_code</code> representing a Win32 error code from a Windows API. <br><br> <dt><code>CXX_RESULT_HAS_VALUE(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code> has a value. <dt><code>CXX_RESULT_HAS_ERROR(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code> has an error. <dt><code>CXX_RESULT_ERROR_IS_ERRNO(r)</code> <dd>Evaluates to 1 (true) if the input <code>result</code>'s error value is a code in the POSIX <code>errno</code> domain. <br><br> <dt><code>CXX_RESULT_SYSTEM_TRY(expr)</code> <dd>If the <code>status_result</code> returned by <code>expr</code> is errored, exit the current function returning the result. This obviously requires that the return type of the current function matches that of <code> expr</code>. <dt><code>CXX_RESULT_SYSTEM_TRY(cleanup, expr)</code> <dd>Same as the above, but execute <code>cleanup</code> just before exiting the function if returning failure. <dt><code>CXX_RESULT_SYSTEM_TRY(var, cleanup, expr)</code> <dd>Same as the above, but set <code>var</code> equal to the result's <code>.value</code> on success. <dt><code>CXX_RESULT_SYSTEM_TRY(var, ident, cleanup, expr)</code> <dd>Same as the above, but use <code>ident</code> as the return type instead. This allows the return type of the calling function to differ from that of <code>expr</code>. <br><br> <dt><code>CXX_DECLARE_RESULT_SYSTEM_FROM_ENUM(ident, enum_name, uuid, {enum mapping-sequence, ...})</code> <dd>This declares to C an extern function which creates a <code>status_result</code> from a C enum. If in C++, it implements a <code>quick_status_code_from_enum</code> for the C enum and the associated extern function, and you will need to supply <code>uuid</code> and the appropriate enum value mapping sequence <a href="{{% relref "../../worked-example" %}}"> as per the <code>quick_status_code_from_enum</code> documentation</a>. <dt><code>CXX_MAKE_RESULT_SYSTEM_FROM_ENUM(ident, enum_name, expr)</code> (needs C++ counterpart linked into final binary) <dd>This invokes the aforementioned extern function which creates a <code>status_result</code> from a C enum. </dl> The operations available to C++ are: <dl> <dt><code>CXX_TO_RESULT_SYSTEM_CODE(ident, status_code<T>)</code> <dd>Returns a previously declared C Result from its matching C++ <code>status_code</code>. NOTE that the destructor of the C++ status code is NOT called. If this is important to your status code, it is 100% on you to ensure that your C Result reenters a C++ Result at the end of its lifetime. <dt><code>to_result(any C Result)</code> <dd>This is an overloaded C++ free function which returns the C++ status_code<T> matching its input C Result. </dl> Using the above you can write C code using Outcome.Experimental's Result type quite effectively. Let's look at an example of use next.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-c/declare.md	+++ title = "Declare a Result" description = "Declaring a C Result" weight = 20 +++ {{% snippet "c_api2.cpp" "preamble" %}} The key to making C programming easy is to alias the long complex things into short easy thing. Obviously `SUCCESS(expr)` and `FAILURE(expr)` is too generic, but for the purposes of this documentation it makes thing easier.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-c/use.md	+++ title = "Using a Result" description = "Using a C Result" weight = 30 +++ This models [the earlier C++ example of use]({{% relref "/experimental/worked-example/implicit-construction" %}}), and its C equivalent isn't much more verbose thanks to our helper typedefs and macros: {{% snippet "c_api2.cpp" "using" %}} For this to link, the `CXX_DECLARE_RESULT_SYSTEM_FROM_ENUM` macro needs to be compiled at least once within C++ within the final binary to emit the extern functions needed by C.
repos/outcome/doc/src/content/experimental/c-api	repos/outcome/doc/src/content/experimental/c-api/from-c/try.md	+++ title = "TRY a C Result" description = "Operation TRY on a C Result" weight = 40 +++ Thanks to much of the magic of {{< api "OUTCOME_TRY(var, expr)" >}} being implemented using C preprocessor metaprogramming, we can offer a very similar experience for the C try operation and without needing anything compiled in C++ as support functions: {{% snippet "c_api2.cpp" "try" %}} The principle difference is that you can specify a cleanup routine to perform if failure is encountered. This is especially useful in C, which has no stack unwinding. Also due to lack of type sugaring and user defined implicit conversions, if your callers result type isn't your callee's, you may need to specify what your caller's result type is so the error state can be correctly propagated.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/string_ref.md	+++ title = "String refs" weight = 40 +++ `<system_error2>` does not use `std::string` to return possibly statically or dynamically allocated strings, and thus avoids dragging in a lot of the standard library which impacts build times. Instead status code domains have a [`string_ref`](https://ned14.github.io/status-code/doc_status_code_domain.html#standardese-system_error2__status_code_domain__string_ref), which has a polymorphic implementation which may or may not [manage a dynamic memory allocation using an atomic reference counter](https://ned14.github.io/status-code/doc_status_code_domain.html#standardese-system_error2__status_code_domain__atomic_refcounted_string_ref). Due to this polymorphism, you don't need to worry which implementation is actually in use under the bonnet when you pass around `string_ref` instances. `string_ref` provides the same member functions as a `span<const char>`, and so participates ordinarily in STL algorithms and containers. In particular, if you need to string search or slice it, you can construct a `string_view` on top easily. {{% snippet "experimental_status_code.cpp" "string_ref" %}} Now you understand what `string_ref` does, returning the name of the status code domain is self describing. Note we use the non-managing constructor of `string_ref`, as the string `"file i/o error domain"` is statically stored. We cache the returned value locally in static storage.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/_index.md	+++ title = "Worked example: Custom domain (the long way)" weight = 85 +++ Here follows a longer worked example of use of Experimental Outcome. It presents the same sample program I sent to the San Diego 2018 WG21 standards meeting after I was asked by the committee to demonstrate how P1095 implements P0709 in a working code example they could study and discuss. We will walk through this worked example, step by step, explaining how each part works in detail. This will help you implement your own code based on Experimental Outcome. Most users will not need this level of customisation, and for them the preceding [quick and easy approach]({{% relref "../worked-example" %}}) will be much easier. You may find it useful to open now in a separate browser tab the reference API documentation for proposed `<system_error2>` at https://ned14.github.io/status-code/ (scroll half way down). The references in the comments to P1028 are to [P1028 SG14 status_code and standard error object for P0709 Zero-overhead deterministic exceptions](http://wg21.link/P1028), which is the WG21 proposal paper for potential `<system_error2>`. ### Goal of this section We are going to define a simple custom code domain which defines that the status code's payload will consist of a POSIX error code, and the `__FILE__` and `__LINE__` where the failure occurred. This custom status code will have an implicit conversion to type erased `error` defined, which dynamically allocates memory for the original status code, and outputs an `error` which manages that dynamic allocation, indirecting all queries etc to the erased custom status code type such that the `error` instance quacks as if just like the original. This demonstrates that `error` could just as equally convey a `std::exception_ptr`, for example, or indeed manage the lifetime of any pointer.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/message.md	+++ title = "Redefining `message()`" weight = 50 +++ You may remember that our custom `_file_io_error_domain` inherits from `outcome_e::posix_code::domain_type`, and thus does not have to implement the many pure virtual functions required by `outcome_e::status_code_domain`. What we do need to do is reimplement `_do_message()` to append the file and line information to the POSIX error description string returned by `outcome_e::posix_code::domain_type`. This causes the status code's `.message()` observer to return a string with the extra payload information represented in text. {{% snippet "experimental_status_code.cpp" "message" %}}
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/implicit_conversion.md	+++ title = "Implicit conversion" weight = 70 +++ Back in [The payload]({{< relref "value_type" >}}), we mentioned that there was no default implicit conversion of `file_io_error` (`status_code<_file_io_error_domain>`) to `error`, as `error` is too small to hold `_file_io_error_domain::value_type`. We can tell the framework about available implicit conversions by defining an ADL discovered free function `make_status_code()` which takes our custom status code as input, and returns an `error`: {{% snippet "experimental_status_code.cpp" "implicit_conversion" %}} We are now ready to use Experimental Outcome!
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/value_type.md	+++ title = "The payload" weight = 20 +++ We define the code domain's `value_type` -- the payload to be transported by status codes using this code domain -- to be a POSIX `errno` value, an integer line number and a const char pointer. {{% snippet "experimental_status_code.cpp" "value_type" %}} You will note that this is a `TriviallyCopyable` type, and so gains an implicit conversion to any `status_code<erased<T>>` where `sizeof(T) >= sizeof(value_type)`. `error` is however `status_code<erased<intptr_t>>`, and `sizeof(intptr_t) < sizeof(value_type)`, so it is not possible to implicitly convert status codes from this domain into `error`. Instead, you must tell the compiler how to do the conversion, as we shall see later.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/preamble.md	+++ title = "Define a custom code domain" weight = 10 +++ Firstly let's alias the experimental Outcome namespace into something less tedious to type, declare our custom status code type, and get started on defining the custom status code domain implementation. {{% snippet "experimental_status_code.cpp" "preamble" %}} Note that we inherit from `outcome_e::posix_code::domain_type`, not from `outcome_e::status_code_domain`. We thus reuse most of the implementation of `outcome_e::posix_code::domain_type` rather than implementing required functionality. If you would like to see a fuller treatment of defining a custom status code domain from scratch, see [this worked example here](https://github.com/ned14/status-code/blob/master/doc/custom_domain_worked_example.md). [You may find looking at the API reference documentation for `status_code_domain` useful in the next few pages ](https://ned14.github.io/status-code/doc_status_code_domain.html#standardese-system_error2__status_code_domain).
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/source.md	+++ title = "Constexpr domain source" weight = 60 +++ Back in [The constructor]({{< relref "constructor" >}}), we declared but did not implement a `.get()` function which returns a constexpr static instance of the domain. We implement this now: {{% snippet "experimental_status_code.cpp" "constexpr_source" %}} As this is 100% constexpr, it can be (and is under optimisation) implemented entirely in the mind of the compiler with no run time representation.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example-long/constructor.md	+++ title = "The constructor" weight = 30 +++ Code domains are 100% constexpr to construct and destruct, as are status codes. This enables the compiler to 100% instantiate both only in its mind, and to emit zero code and thus zero overhead. Unfortunately it also means that it must be possible for each domain to be instantiated an infinite number of times, and being 100% in constexpr, any instances never have a unique address in memory either. Thus we cannot compare domains for equivalence using their address in memory, as {{% api "std::error_category" %}} does. We solve this by using a very random 64 bit number taken from a hard random number source. The website https://www.random.org/cgi-bin/randbyte?nbytes=8&format=h is strongly suggested as the source for this number. (In case you are wondering about the chance of collision for a 64 bit integer, SG14 estimated that approximately 190,000 separate domains would need to exist in a single process for there to be a 0.00000001% probability of collision if the random number source is very random) {{% snippet "experimental_status_code.cpp" "constructor" %}} A nice side effect of this approach is that custom error domains in header-only libraries are safe, unlike custom `<system_error>` error categories. Boost.System's error categories can now opt into this same safe mechanism in order to also be safe in header only library use cases.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example/_index.md	+++ title = "Worked example: Custom domain (the short way)" weight = 80 +++ The section after this one will take the long way through defining a custom domain which sometimes is necessary if you have particularly bespoke requirements. If however you just want to wrap a custom `enum` type of yours into its own custom code domain, the boilerplate can be automated away by filling in a few simple fields like this: {{% snippet "quick_status_code_from_enum.cpp" "preamble" %}} Here we supply the bare minimum requirements for a status code domain: 1. The name in text, so it can be printed. 2. The unique UUID to identify when multiple copies of the domain are the same. PLEASE use https://www.random.org/cgi-bin/randbyte?nbytes=16&format=h to generate this, do not twiddle a few bits. 3. For each enum value, its printable text and a sequence of `errc::` enumerations which you think it is semantically equivalent to i.e. its mapping onto `generic_code` which is how status code defines the common mapping between status codes. If you later compare the status code to one of those values (or to another status code which also provides a mapping), if the generic codes are equivalent then the comparison will return true. This means code like `if(sc == errc::no_such_file_or_directory) ...` would match all custom error codes which mean 'something was not found'. 4. OPTIONAL: if you would like the custom status code type generated by this to have additional member functions or additional payload, you can define a mixin here to inject either data or functions or both. If you omit this, nothing gets injected.
repos/outcome/doc/src/content/experimental	repos/outcome/doc/src/content/experimental/worked-example/implicit-construction.md	+++ title = "Implicit construction" weight = 10 +++ The preceding code had the compiler stamp out a custom status code domain for a user supplied `enum`. You now get the following types: {{% snippet "quick_status_code_from_enum.cpp" "implicit_construction" %}} As you can see, this is less work than [plugging your custom enum into `std::error_code`]({{% relref "/motivation/plug_error_code" %}}). It also has C compatibility, and generates better codegen.
repos/outcome/doc/src/content	repos/outcome/doc/src/content/tutorial/_index.md	+++ title = "Tutorial" weight = 10 +++ {{% children description="true" depth="2" %}}
repos/outcome/doc/src/content/tutorial	repos/outcome/doc/src/content/tutorial/advanced/_index.md	+++ title = "Advanced" description = "If you have a bit more time, this covers all the time-saving ways you can customise and automate Outcome for various use cases, especially in larger codebases made up of multiple third party libraries." weight = 20 +++ {{% children description="true" depth="2" %}}
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/conclusion.md	+++ title = "Conclusion" weight = 55 +++ This worked example was in fact excessively complex: a quicker route to achieving the same thing would be to add explicit converting constructors to `app::error_code` for each of the third party library `E` types. One then could have saved oneself with having to bother injecting custom converters into the `OUTCOME_V2_NAMESPACE::convert` namespace. If you control your application's `E` type, then that is probably a better, and certainly simpler, approach. However there are occasions when you don't have control over the implementation of the destination `E` type e.g. in callbacks. Outcome's `value_or_error` infrastructure lets you inject custom interop code for any pair of incommensurate third party `E` types, without needing to modify either's source code. This is without doubt a "power users" feature, but one which will prove useful as `T\|E` based C++ code proliferates.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/value-or-error.md	+++ title = "value_or_error Concept" weight = 7 tags = [ "value-or-error" ] +++ Something not really mentioned until now is how Outcome interoperates with the proposed {{% api "std::expected<T, E>" %}}, whose design lands in between {{% api "unchecked<T, E = varies>" %}} and {{% api "checked<T, E = varies>" %}} (both of which are type aliases hard coding no-value policies [as previously covered in this tutorial]({{< relref "/tutorial/essential/no-value/builtin" >}})). Expected and Outcome are [isomorphic to one another in design intent]({{< relref "/faq" >}}#why-doesn-t-outcome-duplicate-std-expected-t-e-s-design), but interoperation for code using Expected and Outcome ought to be seamless thanks to the [proposed `ValueOrError` concept framework](https://wg21.link/P0786), a subset of which Outcome implements. The {{% api "explicit basic_result(concepts::value_or_error<T, E> &&)" %}} and {{% api "explicit basic_outcome(concepts::value_or_error<T, E> &&)" %}} constructors will explicitly construct from any type matching the {{% api "concepts::value_or_error<T, E>" %}} concept, which includes `std::expected<A, B>`, if `A` is constructible to `X`, and `B` is constructible to `Y`. The `value_or_error` concept in turn is true if and only if the input type has: 1. A `.has_value()` observer returning a `bool`. 2. `.value()` and `.error()` observers. ## Implementation Outcome's machinery for implementing `concepts::value_or_error` conversion is user extensible by injection of specialisations of the {{% api "value_or_error<T, U>" %}} type into the `OUTCOME_V2_NAMESPACE::convert` namespace. Outcome's default `convert::value_or_error<T, U>` implementation explicitly excludes Outcome `result` and `outcome` types from the default mechanism as there is a major gotcha: the `value_or_error` matched type's `.value()` is often not callable in constexpr as it can throw, which makes this conversion mechanism pretty much useless for constexpr code. Besides, `outcome` has a converting constructor overload for `result` inputs which is constexpr capable. Note that if you do enable `outcome` inputs, a `result` will match an input `outcome`, but silently dropping any exception state. This is probably undesirable. Examples of how to implement your own `convert::value_or_error<T, U>` converter is demonstrated in the worked example, next.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/_index.md	+++ title = "Interoperation" description = "Interoperating with std::expected<T, E> and other ValueOrError concept matching types." weight = 80 +++ This is the final section of the tutorial, and it is unavoidably quite lengthy as we are going to tie together all of the material covered in the tutorial so far into a single, unified, application of Outcome's facilities. One thing which Outcome solves -- and which alternatives do not -- is how to non-intrusively tie together multiple third party libraries, each using Outcome -- or some other `T\|E` implementatation like {{% api "std::expected<T, E>" %}} -- with custom incommensurate `E` types, or indeed arbitrary return types which are "split" `T\|E` return types. Solving this well is the coup de grâce of Outcome against alternative approaches to this problem domain, including `std::expected<T, E>`. It is the major reason why you should consider using Outcome over alternatives, including Expected. Firstly we shall explore some of the problems faced by the software developer when `T\|E` return type based code proliferates at scale, where dozens of libraries may be using completely incompatible `T\|E` return types. Secondly we shall introduce the `ValueOrError` concept support in Outcome, which implements a subset of the proposed [WG21 `ValueOrError` concept framework](https://wg21.link/P0786). Finally, we shall then step through a worked example which mocks up a realistic situation that the software developer may find themselves in: tying together disparate third party libraries, whose source code cannot be modified, into an application-wide, mixed-mode `T\|E` and exception throwing universal error handling system which is capable of accurately representing the original failure, but also propagating it in a way that the application can deal with universally.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/tidylib.md	+++ title = "The HTMLTidy library" weight = 15 +++ {{% snippet "finale.cpp" "tidylib" %}} A C API may not initially appear to be a `T\|E` based API, but if failure returns some domained error code and causes no other effects, and success returns some value, then it is effectively a "split" `T\|E` API. The above is an example of exactly that form of "split" `T\|E` API.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/app-map-httplib2.md	+++ title = "Mapping the HTTP library into the Application `2/2`" weight = 35 +++ If you remember the tutorial section on the [`value_or_error` Concept](../value-or-error), this is an example of how to implement a custom `value_or_error` Concept converter in Outcome: {{% snippet "finale.cpp" "app_map_httplib2" %}} The first thing that you should note is that these custom converters must be injected directly into the `OUTCOME_V2_NAMESPACE::convert` namespace, and they must partially or completely specialise {{% api "value_or_error<T, U>" %}}. Here we specialise the converter for `value_or_error` conversions from `httplib::result<U>` to `app::outcome<T>` i.e. from our third party HTTP library's error type into our application's `outcome` type (which is unique to our application, as we hard code an `app`-local error type). The second thing to note is that you need to set `enable_result_inputs` and `enable_outcome_inputs` appropriately, otherwise `result` and `outcome` inputs will not be matched by this converter[^1]. In this converter, we really do wish to convert other `result` and `outcome` inputs, so we mark these booleans as `true`. The third thing to note is the requirements on `operator()`. If the requirements are not met, the `value_or_error` converting constructor in `basic_result` and `basic_outcome` disables. Note the requirement that the decayed `operator()` input `X` matches `httplib::result<U>`, and that `T` is constructible from `U`. This means that the {{% api "explicit basic_result(concepts::value_or_error<T, E> &&)" %}} and {{% api "explicit basic_outcome(concepts::value_or_error<T, E> &&)" %}} constructors are available if, and only if, the input type is a `httplib::result<U>`, and the result's value type is constructible from the input's value type. If `operator()` is available, it naturally converts a `httplib::result<U>` into an `app::outcome<T>` by either forwarding any success as-is, or calling `app::make_httplib_exception()` to type erase the `httplib::failure` into an `app::httplib_error`. [^1]: Here we refer to `result` and `outcome` as defined by this specific Outcome library. If `result` or `outcome` from another Outcome implementation is seen, those always must get parsed via the `ValueOrError` matching conversion framework.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/filelib.md	+++ title = "The File I/O library" weight = 20 +++ The File I/O library we shall be using is very similar [to the one we saw earlier in this tutorial](../../payload/copy_file2): {{% snippet "finale.cpp" "filelib" %}} This uses the advanced Outcome feature of programming the lazy synthesis of custom C++ exception throws from a payload carrying `E` type called `failure_info`. Like the HTTP library, it too template aliases a localised `result` implementation into its namespace with ADL bridging so Outcome customisation points can be discovered.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/app-map-filelib.md	+++ title = "Mapping the File I/O library into the Application" weight = 40 +++ To handle the File I/O library, once again we turn to custom `ValueOrError` converters: {{% snippet "finale.cpp" "app_map_filelib" %}} Note that the conversion exactly duplicates the implementation of `throw_as_system_error_with_payload(failure_info fi)` from namespace `filelib`. In a production implementation, you probably ought to call that function and catch the exception it throws into a pointer, as that would be more long term maintainable.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/app-go.md	+++ title = "In use" weight = 50 +++ This is how you might now write application code using these three libraries: {{% snippet "finale.cpp" "app_go" %}} The curiosity will be surely the `ext()` markup function, which needs explaining. It was felt important during Outcome's design that `value_or_error` conversions never be implicit, as they almost always represent a transition across an ABI or semantic boundary. They are also usually non-trivial to implement and compile, and it was felt important that the programmer ought to always mark the semantic boundary transition at the point of every use, as considerable amounts of code may execute. How the end user chooses to mark up their code is up to them, however above we use a simple `ext()` function to mark up that the function being called is external to the application. This ticks our box of requiring the documentation, at the point of use, of every transition in failure handling boundaries. Note that we are able to use `TRY` as normal throughout this function. Everything "just works". And most especially note that we never, at any stage, needed to modify the source code of `httplib`, `tidylib` nor `filelib`, nor inject custom things into their namespaces. This entire worked example was achieved solely by `app` based customisation points, and via `convert`.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/app.md	+++ title = "The Application" weight = 25 +++ The application is of course also based on Outcome, and like the HTTP library is also of mixed-failure design in that failure can be returned via error code, type erased `exception_ptr` or indeed a C++ exception throw. {{% snippet "finale.cpp" "app" %}} Here we localise a passthrough `error_code` solely for the purpose of ADL bridging, otherwise the localised `outcome` configured is the default one which comes with Outcome. [We covered this technique of "passthrough `error_code`" earlier in this tutorial]({{< relref "/tutorial/advanced/hooks/adl_bridging" >}}). The way we are going to configure interop is as follows: 1. The application shall use `error_code` for anticipated failure and C++ exception throws for unanticipated failure. 2. We shall choose the convention that `app::outcome` with exception ptr solely and exclusively represents a type erased failure from a third party library. Thus if one calls `.value()` on an `app::outcome`, both anticipated failure within the app and type erased failure from a third party library shall be converted to a C++ exception throw.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/httplib.md	+++ title = "The HTTP library" weight = 10 +++ Let us imagine a simple application: it fetches a HTTP page using a HTTP library, sends it through HTML tidy via the htmltidy library, and then writes it to disc using a filelib library. So three third party libraries, two using Outcome in incompatible ways, and the third being a C library just for kicks. Let us imagine that the HTTP library has the following public interface: {{% snippet "finale.cpp" "httplib" %}} The HTTP library is a mixed-failure design. Likely failures (HTTP status codes) are returned via `httplib::failure`, unlikely failures (e.g. out of memory) are returned via throw of the usual STL exception types. The sole API we bother describing is an implementation of HTTP GET. It fetches a URL, and either returns the contents or the failure reason why not.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/app-map-httplib1.md	+++ title = "Mapping the HTTP library into the Application `1/2`" weight = 30 +++ Firstly, remember that we are the application writer who has the problem of integrating three third party libraries into our application's Outcome-based failure handling mechanism. We cannot modify those third party library sources; we must be non-intrusive. We start by dealing with the HTTP library. We will integrate this into our application by wrapping up `httplib::failure` into a custom STL exception type. We then type erase it into an `exception_ptr` instance. Please note that this code is exclusively defined in the `app` namespace: {{% snippet "finale.cpp" "app_map_httplib1" %}} Most of the complexity in this code fragment is driven by the need to create some sort of descriptive string for `std::runtime_error` so its `.what()` returns a useful summary of the original failure. This is the main purpose of the `app::make_httplib_exception()` function. (Note that if you have Reflection in your C++ compiler, it may be possible to script the conversion of enum values to string representations) The only real thing to note about `app::httplib_error` is that it squirrels away the original `httplib::failure` in case that is ever needed.
repos/outcome/doc/src/content/tutorial/advanced	repos/outcome/doc/src/content/tutorial/advanced/interop/problem.md	+++ title = "Incommensurate E types" weight = 5 +++ Back in the essential tutorial section on `result`, we studied a likely very common initial choice of `E` type: [a strongly typed enum]({{< relref "/tutorial/essential/result" >}}). We saw how [by marking up strongly typed enums to tell the C++ standard library what they are]({{< relref "/motivation/plug_error_code" >}}), they gain implicit convertibility into `std::error_code`, and we then pointed out that you might as well now always set `E = std::error_code`, as that comes with the enormous advantage that you can use the boilerplate saving `OUTCOME_TRY` macro when the `E` type is always the same. We thus strongly recommend to users that for any given piece of code, always using the same `E` type across the codebase is very wise, except where you explicitly want to prevent implicit propagation of failure up a call stack e.g. local failures in some domain specific piece of code. However it is unreasonable to expect that any non-trivial codebase can make do with `E = std::error_code`. This is why Outcome allows you to use [custom `E` types which carry payload](../../payload) in addition to an error code, yet still have that custom type treated as if a `std::error_code`, including [lazy custom exception throw synthesis](../../payload/copy_file3). All this is good, but if library A uses `result<T, libraryA::failure_info>`, and library B uses `result<T, libraryB::error_info>` and so on, there becomes a problem for the application writer who is bringing in these third party dependencies and tying them together into an application. As a general rule, each third party library author will not have built in explicit interoperation support for unknown other third party libraries. The problem therefore lands with the application writer. The application writer has one of three choices: 1. In the application, the form of result used is `result<T, std::variant<E1, E2, ...>>` where `E1`, `E2` ... are the failure types for every third party library in use in the application. This has the advantage of preserving the original information exactly, but comes with a certain amount of use inconvenience and maybe excessive coupling between high level layers and implementation detail. 2. One can translate/map the third party's failure type into the application's failure type at the point of the failure exiting the third party library and entering the application. One might do this, say, with a C preprocessor macro wrapping every invocation of the third party API from the application. This approach may lose the original failure detail, or mis-map under certain circumstances if the mapping between the two systems is not one-one. 3. One can type erase the third party's failure type into some application failure type, which can later be reconstituted if necessary. This is the cleanest solution with the least coupling issues and no problems with mis-mapping, but it almost certainly requires the use of `malloc`, which the previous two did not. Things get even more complicated in the presence of callbacks. If in the callback you supply to library A, you call library B, you may need to insert switch statement maps or other mechanisms to convert library B's failures into something library A can understand, and then somehow extract that out -- preferably without loss of original information -- into the application's failure handling mechanism if library A subsequently returns failure as well. This implies transmitting state by which to track these interrelated pieces of failure data. Let us see what Outcome can do to help the application writer address some of these issues, next.