Add more robust constexpr support

Author: akrzemi1

doc/00_optional.qbk

@@ -1,8 +1,8 @@
 [library Boost.Optional
-    [quickbook 1.4]
+    [quickbook 1.7]
     [authors [Cacciola Carballal, Fernando Luis]]
     [copyright 2003-2007 Fernando Luis Cacciola Carballal]
-    [copyright 2014-2026 Andrzej Krzemieński]
+    [copyright 2014-2026 Andrzej Krzemieński]
     [category miscellaneous]
     [id optional]
     [dirname optional]

doc/16_optional_references.qbk

@@ -27,7 +27,7 @@ rather than the reference itself.
 On compilers that do not conform to Standard C++ rules of reference binding,
 some operations on optional references are disabled in order to prevent subtle
 bugs. For more details see
-[link boost_optional.dependencies_and_portability.optional_reference_binding Dependencies and Portability section].
+[link optional_reference_binding Dependencies and Portability section].
 ]
 
 [heading Rvalue references]
@@ -39,6 +39,8 @@ Rvalue references and lvalue references to const have the ability in C++ to exte
 
 [endsect]
 
+
+[#optional_ref_rebinding_semantics]
 [section Rebinding semantics for assignment of optional references]
 
 If you assign to an ['uninitialized ] `optional<T&>` the effect is to bind (for

doc/17_in_place_factories.qbk

@@ -1,5 +1,5 @@
 
-[section In-Place Factories]
+[section:in_place_factories In-Place Factories][#boost_optional_factories]
 
 One of the typical problems with wrappers and containers is that their
 interfaces usually provide an operation to initialize or assign the
@@ -138,4 +138,4 @@ The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and __TYP
 
 [caution The support for in-place factories is deprecated. Use constructor taking `in_place_init` tag and function `.emplace()` instead.]
 
-[endsect]
+[endsect:in_place_factories]

doc/1A_type_requirements.qbk

@@ -8,7 +8,7 @@ The very minimum requirement of `optional<T>` is that `T` is a complete type and
     assert(!o);        //
     o.value();         // always throws
 
-But this is practically useless. In order for `optional<T>` to be able to do anything useful and offer all the spectrum of ways of accessing the contained value, `T` needs to have at least one accessible constructor. In that case you need to initialize the optional object with function `emplace()`, or if your compiler does not support it, resort to [link boost_optional.design.in_place_factories In-Place Factories]:
+But this is practically useless. In order for `optional<T>` to be able to do anything useful and offer all the spectrum of ways of accessing the contained value, `T` needs to have at least one accessible constructor. In that case you need to initialize the optional object with function `emplace()`, or if your compiler does not support it, resort to [link boost_optional_factories In-Place Factories]:
 
     optional<T> o;
     o.emplace("T", "ctor", "params");

doc/21_ref_none.qbk

@@ -2,7 +2,7 @@
     Boost.Optional
 
     Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-    Copyright (c) 2015 Andrzej Krzemienski
+    Copyright (c) 2015 Andrzej Krzemieński
 
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
@@ -15,14 +15,25 @@
 ```
 namespace boost {
 
-class none_t {/* see below */};
+class none_t
+{
+  friend constexpr bool operator==(none_t, none_t) = default;
+  /* see below */
+};
 
 inline constexpr none_t none (/* see below */);
 
 } // namespace boost
 ```
 
-Class `none_t` is meant to serve as a tag for selecting appropriate overloads of from `optional`'s interface. It is an empty, trivially copyable class with disabled default constructor.
+Class `none_t` is meant to serve as a tag for selecting appropriate overloads of from `optional`'s interface.
+It is an empty class.
+
+It is [@https://en.cppreference.com/w/cpp/named_req/TriviallyCopyable.html trivially copyable].
+
+It is ['not] [@https://en.cppreference.com/w/cpp/named_req/DefaultConstructible default-constructible].
+
+It models concept [@https://en.cppreference.com/w/cpp/concepts/equality_comparable `std::equality_comparable`].
 
 Constant `none` is used to indicate an optional object that does not contain a value in initialization, assignment and relational operations of `optional`.
 

doc/28_ref_optional_semantics.qbk

@@ -281,7 +281,7 @@ factory.
 * [*Postconditions: ] `*this` is [_initialized] and its value is ['directly given]
 from the factory `f` (i.e., the value [_is not copied]).
 * [*Throws:] Whatever the `T` constructor called by the factory throws.
-* [*Notes:] See [link boost_optional.design.in_place_factories In-Place Factories]
+* [*Notes:] See [link boost_optional_factories In-Place Factories]
 * [*Exception Safety:] Exceptions can only be thrown during the call to
 the `T` constructor used by the factory; in that case, this constructor has
 no effect.
@@ -524,7 +524,7 @@ factory.
 * [*Postconditions: ] `*this` is [_initialized] and its value is ['directly given]
 from the factory `f` (i.e., the value [_is not copied]).
 * [*Throws:] Whatever the `T` constructor called by the factory throws.
-* [*Notes:] See [link boost_optional.design.in_place_factories In-Place Factories]
+* [*Notes:] See [link boost_optional_factories In-Place Factories]
 * [*Exception Safety:] Exceptions can only be thrown during the call to
 the `T` constructor used by the factory; in that case, the `optional` object
 will be reset to be ['uninitialized].
@@ -956,7 +956,7 @@ __SPACE__
 
 * [*Postconditions:] `bool(*this) == bool(rhs)`.
 
-* [*Notes:] This behaviour is called ['rebinding semantics]. See [link boost_optional.design.optional_references.rebinding_semantics_for_assignment_of_optional_references here] for details.
+* [*Notes:] This behaviour is called ['rebinding semantics]. See [link optional_ref_rebinding_semantics here] for details.
 
 * [*Example:]
 ``

doc/29_ref_optional_convenience.qbk

@@ -11,7 +11,7 @@
 
 [section Header <boost/optional.hpp>]
 
-This is an alias for header [link boost_optional.reference.header__boost_optional_optional_hpp_.header_optional_optional `<boost/optional/optional.hpp>`].
+This is an alias for header [link ref_header_optional_optional_hpp `<boost/optional/optional.hpp>`].
 
 
 [endsect]

doc/90_dependencies.qbk

@@ -13,13 +13,55 @@
 
 
 [section Minimum System Requirements]
-This library requires C++11 as minimum. However some features are disabled.
+This library requires C++11 as minimum. However, in C++11 some features are disabled.
 
-For C++14 and higher this library provides a `constexpr` interface for non-mutable
-member functions and some mutable member functions.
+[section:constexpr Support for `constexpr`]
+
+[section C++11]
+For compilers fully supporting C++11 (including unconstrained unions and ref-qualifiers),
+for trivially-destructible `T`s, `optional<T>` is a ['literal type] and its constructors
+with `this->has_value() == false` as postcondition:
+
+* `optional()`,
+* `optional(none_t)`,
+
+are ['core constant expressions]. Even for other `T`s, these constructors are guaranteed to
+perform ['constant initialization]: they are never subject to "initialization order fiasco".
+
+Other constructors with `this->has_value() == true`
+as postcondition are core constant expressions if the expression required to initialize
+the contained value is a core constant expression. This includes constructors:
+
+* `template <typename... Args> optional(in_place_init, Args&&...)`,
+* `template <typename U> optional(U&&)`,
+* `optional(const T&)`,
+* `optional(T&&)`.
+
+Other constructors, including the copy and move constructos, are ['not] core constant expressions.
+
+Member functions `.has_value`, `operator bool` and (non)equality comparisons with `none` are core-constant expressions for trivially-destructible `T`s.
+
+Also all `const`-qualified non-static member functions and comparison operators are core constant expressions, if the corresponding operations on `T`
+are core constant expressions.
+[endsect]
+
+[section C++14]
+For C++14 and higher this library, for trivially-destructible `T`s provides the `constexpr` interface for all mutable and non-mutable
+member functions, as long as:
+
+* the corresponding operations on `T` are core constant expressions and
+* the member never attempts to change the `optional`'s state from not containing a value to containing a value.
 
 [note For types that overload unary `operator&` (address) some member functions in `optional`, like `operator->`,
 cannot be implemented as `constexpr` on some compilers.]
+[endsect]
+
+[section C++17]
+In C++17 all non-deprecated constructors are core constant expressions as long as
+`T` is a literal type and its constructor used is a core constant expression.
+[endsect]
+
+[endsect:constexpr]
 
 [endsect]
 

doc/91_comparison_with_std.qbk

@@ -11,8 +11,7 @@
 
 [section:std_comp Comparison with `std::optional`]
 
-[table
-  []
+[table Comparison with `std::optional`
   [ [[*`boost::optional`]] [[*`std::optional`]] [] ]
   [ [`optional<int> o = none;`] [`optional<int> o = nullopt;`] [Different name for no-value tag.] ]
   [ [`optional<X> o {in_place_init, a, b};`] [`optional<int> o {in_place, a, b};`] [Different name for in-place initialization tag.] ]
@@ -42,6 +41,12 @@
   [ [`make_optional(cond, v);`] [] [No `make_optional` with condition in `std`.] ]
   [ [] [`make_optional<T>(a, b);`] [No `make_optional` with specified `T` in `boost`.] ]
   [ [`std::cout << optional<int>{};`] [] [No printing to IOStreams in `std`.]]
+
+  [ [`std::vector<optional<int>> rng;`
+
+  `std::ranges::find(rng, boost::none)`] [`std::vector<optional<int>> rng;`
+
+  `std::ranges::find(rng, boost::optional<int>{})`] [optional<T> is never [@https://en.cppreference.com/w/cpp/concepts/equality_comparable `std::equality_comparable_with`] `nullopt_t` in `std`. ] ]
 ]
 
 

doc/92_relnotes.qbk

@@ -11,9 +11,35 @@
 
 [section:relnotes Release Notes]
 
-
-
-
+[heading Boost Release 1.91]
+
+* For compilers with full C++11 support (including "unrestricted  unions" and ref-qualifiers)
+  changed the implementation from aligned storage to union storage. This enables the gradual
+  `constexpr` support:
+
+    * In C++11, some constructors and `const`-qualified accessors become usable
+      in compile-time contexts (are ['core constant expressions] for types
+      satisfying certain constraints.
+    * In C++14 even some mutating operations become core constant expressions (those
+      that do not require changing the state of `optional` from not having a value to
+      having a value), for co-operating types.
+    * In C++17 all constructors (including copy and move) become core constant expressions
+      for co-operating types.
+
+  This addresses [@https://github.com/boostorg/optional/issues/143 issue #143].
+
+* *Breaking change.* In the said implementation, abandoned the mechanism for customizing
+  `swap`. Hardly anyone knows about this mechanism and it was never documented.
+
+* In the said implementation, applied a couple of small changes to get closer to the interface of `std::optional`:
+  * Enabled syntax `o = {}` for putting optional objects to no-value state.
+  * Enabled syntax `o.value_or({})`, which uses a default-constructed `T`.
+  * Construct `o = u`, where `o` is of type `optional<T>` and `u` is of type `U` convertible to `T`,
+    does not create a temporary `T`.
+
+* `none_t` is now `std::equality_comparable`, which means that `none_t` and `optional<T>`
+  model concept `std::equality_comparable_with` (for `std::equality_comparable` `T`s),
+  which means that you can `std::ranges::find(rng, boost::none)` for a range of optional objects.
 
 [heading Boost Release 1.87]