Explicit Constructors
`explicit basic_outcome(in_place_type_t<exception_type_if_enabled>, std::initializer_list<U>, 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>, std::initializer_list<U> and Args .... Requires: predicate::enable_inplace_exception_constructor<std::initializer_list<U>, Args ...> is true. Complexity: Same as for the exception_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<value_type_if_enabled>, Args ...)`
Explicit inplace value constructor. Calls void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept with this, in_place_type<value_type> and Args .... Requires: predicate::enable_inplace_value_constructor<Args ...> is true. Complexity: Same as for the value_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<value_type_if_enabled>, std::initializer_list<U>, Args ...)`
Explicit inplace value constructor. Calls void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept with this, in_place_type<value_type>, ‘std::initializer_list’ and Args .... Requires: predicate::enable_inplace_value_constructor<std::initializer_list<U>, Args ...> is true. Complexity: Same as for the value_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_result(basic_result<R, S, P> &&)`
Explicit converting move constructor from compatible basic_result. Calls void on_result_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<R, S, P> 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_result(basic_result<R, S, P> &&)`
Explicit converting move constructor from compatible basic_result. Calls void on_result_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_error_code_compatible_conversion<R, S, P> 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_result(basic_result<R, S, P> &&)`
Explicit converting move constructor from compatible basic_result. Calls void on_result_move_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_exception_ptr_compatible_conversion<R, S, P> 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_result(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. 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. 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_result(const basic_result<R, S, P> &)`
Explicit converting copy constructor from compatible basic_result. Calls void on_result_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_compatible_conversion<R, S, P> 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_result(const basic_result<R, S, P> &)`
Explicit converting copy constructor from compatible basic_result. Calls void on_result_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_error_code_compatible_conversion<R, S, P> 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_result(const basic_result<R, S, P> &)`
Explicit converting copy constructor from compatible basic_result. Calls void on_result_copy_construction(T *, U &&) noexcept with this and the input. Requires: predicate::enable_make_exception_ptr_compatible_conversion<R, S, P> 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. »