Explicit Constructors
`explicit basic_outcome(basic_outcome<A, B, C, D> &&)`
Explicit converting move constructor from compatible basic_outcome. Calls void on_outcome_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<A, B, C, D> is true. Complexity: Same as for the move constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(basic_result<A, B, C> &&)`
Explicit converting move constructor from compatible basic_result. Calls void on_outcome_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<A, B, void, C> is true. Complexity: Same as for the move constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(basic_result<A, B, C> &&)`
Explicit converting move constructor from compatible basic_result. Calls void on_outcome_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_error_code_compatible_conversion<A, B, void, C> is true. Complexity: Same as for the move constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(concepts::value_or_error<T, E> &&)`
Explicit converting constructor from concepts::value_or_error<T, E> concept matching types. Delegates to the basic_result move constructor explicit basic_outcome(basic_result<A, B, C> &&) . Requires: convert::value_or_error<T, U> has an available call operator, and if the input is a basic_result or basic_outcome, then convert::value_or_error<> has enabled those inputs for that convert::value_or_error<> specialisation. Complexity: Same as for the copy or move constructor from the input’s .value() or .error() respectively. Constexpr, triviality and noexcept of underlying operations is propagated. »
`explicit basic_outcome(const basic_outcome<A, B, C, D> &)`
Explicit converting copy constructor from compatible basic_outcome. Calls void on_outcome_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<A, B, C, D> is true. Complexity: Same as for the copy constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(const basic_result<A, B, C> &)`
Explicit converting copy constructor from compatible basic_result. Calls void on_outcome_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<A, B, void, C> is true. Complexity: Same as for the copy constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(const basic_result<A, B, C> &)`
Explicit converting copy constructor from compatible basic_result. Calls void on_outcome_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_error_code_compatible_conversion<A, B, void, C> is true. Complexity: Same as for the copy constructors of the underlying types. Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the object is left in a partially completed state, as per the normal rules for the same operation on a struct. »
`explicit basic_outcome(in_place_type_t<error_type_if_enabled>, Args ...)`
Explicit inplace error constructor. Calls void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept with this, in_place_type<error_type> and Args .... Requires: predicate::enable_inplace_error_constructor<Args ...> is true. Complexity: Same as for the error_type constructor which accepts Args .... Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the state of the Args is left indeterminate. »
`explicit basic_outcome(in_place_type_t<error_type_if_enabled>, std::initializer_list<U>, Args ...)`
Explicit inplace error constructor. Calls void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept with this, in_place_type<error_type>, std::initializer_list<U> and Args .... Requires: predicate::enable_inplace_error_constructor<std::initializer_list<U>, Args ...> is true. Complexity: Same as for the error_type constructor which accepts std::initializer_list<U>, Args .... Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the state of the Args is left indeterminate. »
`explicit basic_outcome(in_place_type_t<exception_type_if_enabled>, Args ...)`
Explicit inplace exception constructor. Calls void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept with this, in_place_type<exception_type> and Args .... Requires: predicate::enable_inplace_exception_constructor<Args ...> is true. Complexity: Same as for the exception_type constructor which accepts Args .... Constexpr, triviality and noexcept of underlying operations is propagated. Guarantees: If an exception is thrown during the operation, the state of the Args is left indeterminate. »