docs update

doc/11_development.qbk

@@ -50,6 +50,18 @@ In the general case, the internal representation is something equivalent to:
     alignas(T) char _value [sizeof(T)];
   };
 
+or:
+
+  template <typename T>
+  class Optional
+  {
+    bool _has_value = false;
+    union {
+      T         _value;
+      DummyType _non_value;
+    };
+  };
+
 Next, because we need to pass around these "optional" `int`s as normal `int`s,
 like returning them from functions, when copying, we need to copy `_has_value`,
 which indicates whether we have the value or not, and, if we do have value, and

doc/27_ref_optional_synopsis.qbk

@@ -198,7 +198,7 @@ They are empty, trivially copyable classes with disabled default constructor.
         template<class F> constexpr auto flat_map( F f ) && -> ``['see below]``; ``[link reference_optional_flat_map_move __GO_TO__]``
 
         constexpr operator optional<T&>() & noexcept; ``[link reference_optional_conversion_to_ref __GO_TO__]``
-        constexpr operator optional<T const&&>() const& noexcept; ``[link reference_optional_conversion_to_ref __GO_TO__]``
+        constexpr operator optional<T const&>() const& noexcept; ``[link reference_optional_conversion_to_ref __GO_TO__]``
 
         T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
         T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``

doc/28_ref_optional_semantics.qbk

@@ -47,8 +47,10 @@ the parameter.
 * [*Example:]
 ``
 #include <boost/none.hpp>
+
 optional<T> n(none) ;
 assert ( !n ) ;
+assert ( n == none ) ;
 ``
 
 __SPACE__

doc/91_comparison_with_std.qbk

@@ -56,9 +56,8 @@
   void test(vector<optional<T>> rng, T val) {
     std::ranges::find(rng, make_optional(val));
   }
-  ```] [The same code for `std::optional` compiles but is ['undefined behavior] when `T` is itself an `optional`. ] ]
+  ```] [For `std::optional`, code without `make_optional()` compiles but is ['undefined behavior] when `T` is itself an `optional`. ] ]
 
 ]
 
-
 [endsect][/ std_comp]

doc/92_relnotes.qbk

@@ -26,7 +26,7 @@
     * 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].
+  This addresses issues [@https://github.com/boostorg/optional/issues/132 #132] and [@https://github.com/boostorg/optional/issues/143 #143].
 
 * *Breaking change.* In the said implementation, abandoned the mechanism for customizing
   `swap`. Hardly anyone knows about this mechanism and it was never documented.
@@ -43,6 +43,25 @@
   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.
 
+* *Warning.* In the future releases we intend to introduce the range interface
+  in `optional`, so that `std::ranges::range<optional<T>>` will be `true`.
+  This may affect the overload resolution in programs that make decisions based
+  on predicates such as `std::ranges::range`. For instance, the following code
+  will start behaving differently:
+
+  ```
+  template <typename T>
+  void serialize(T const& v)
+  {
+    if constexpr (std::ranges::range<T>)
+      serialize_as_range(v);
+    else if constexpr (custom::is_optional_like<T>)
+      serialize_as_optional(v);
+    else
+      serialize_as_value(v);
+  }
+  ```
+
 [heading Boost Release 1.87]
 
 * *Breaking change.* Dropped support for C++03. C++11 is now the required minimum; at least some C++11 features.