GHA fix 3

.github/workflows/ci.yml

@@ -142,8 +142,9 @@ jobs:
           - toolset: clang
             compiler: clang++-16
             cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-24.04
+            os: ubuntu-latest
             install: clang-16
+            container: ubuntu:24.04
           - toolset: clang
             compiler: clang++-17
             cxxstd: "03,11,14,17,20,2b"
@@ -224,6 +225,10 @@ jobs:
             cxxstd: 14,latest
             addrmd: 32,64
             os: windows-2019
+          - toolset: msvc-14.1
+            cxxstd: "11,14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
           - toolset: msvc-14.2
             cxxstd: "14,17,20,latest"
             addrmd: 32,64

doc/11_development.qbk

@@ -50,18 +50,6 @@ 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

@@ -197,9 +197,6 @@ 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 __GO_TO__]``
         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__]``
-
         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

@@ -2,7 +2,6 @@
     Boost.Optional
 
     Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-    Copyright (C) 2014 - 2026 Andrzej Krzemieński.
 
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
@@ -26,31 +25,31 @@ __SPACE__
 
 [: `constexpr optional<T>::optional() noexcept;`]
 
-* [*Postconditions:] `*this` does ['not] contain a value (is "uninitialized").
-* [*Remarks:] No contained value is initialized. For every object type `T` these constructors are core constant expressions.
+* [*Effect:] Default-Constructs an `optional`.
+* [*Postconditions:] `*this` is [_uninitialized].
+* [*Notes:] T's default constructor [_is not] called.
 * [*Example:]
 ``
-optional<T> oN ;
-assert ( !oN ) ;
+optional<T> def ;
+assert ( !def ) ;
 ``
 
 __SPACE__
 
-
 [#reference_optional_constructor_none_t]
+
 [: `constexpr optional<T>::optional( none_t ) noexcept;`]
 
-* [*Postconditions:] `*this` does ['not] contain a value (is "uninitialized").
-* [*Remarks:] No contained value is initialized. For every object type `T` these constructors are core constant expressions. The expression
+* [*Effect:] Constructs an `optional` uninitialized.
+* [*Postconditions:] `*this` is [_uninitialized].
+* [*Notes:] `T`'s default constructor [_is not] called. The expression
 `boost::none` denotes an instance of `boost::none_t` that can be used as
 the parameter.
 * [*Example:]
 ``
 #include <boost/none.hpp>
-
 optional<T> n(none) ;
 assert ( !n ) ;
-assert ( n == none ) ;
 ``
 
 __SPACE__
@@ -753,26 +752,6 @@ __SPACE__
 
 __SPACE__
 
-
-[#reference_optional_conversion_to_ref]
-
-[: `constexpr optional<T>::operator optional<T&>() & noexcept ;`]
-
-* [*Returns:] If `*this` contains a value `optional<T&>(**this)`, otherwise `optional<T&>()`.
-
-[: `constexpr optional<T>::operator optional<T const&>() const& noexcept ;`]
-
-* [*Returns:] If `*this` contains a value `optional<T const&>(**this)`, otherwise `optional<T&>()`.
-
-* [*Example:]
-``
-const optional<int> oi = 1;
-optional<const int&> ri = oi;
-``
-
-__SPACE__
-
-
 [#reference_optional_get_value_or_value]
 
 [: `T const& optional<T>::get_value_or( T const& default) const ;`]

doc/90_dependencies.qbk

@@ -72,6 +72,7 @@ The implementation uses the following other Boost modules:
 # assert
 # config
 # core
+# static_assert
 # throw_exception
 # type_traits
 

doc/91_comparison_with_std.qbk

@@ -47,17 +47,7 @@
   `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`. ] ]
-
-  [ [```
-  void test(vector<optional<T>> rng, T val) {
-    std::ranges::find(rng, val);
-  }
-  ```] [```
-  void test(vector<optional<T>> rng, T val) {
-    std::ranges::find(rng, make_optional(val));
-  }
-  ```] [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

@@ -18,7 +18,7 @@
   `constexpr` support:
 
     * In C++11, some constructors and `const`-qualified accessors become usable
-      in compile-time contexts (are ['core constant expressions]) for types
+      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
@@ -26,7 +26,7 @@
     * In C++17 all constructors (including copy and move) become core constant expressions
       for co-operating types.
 
-  This addresses issues [@https://github.com/boostorg/optional/issues/132 #132] and [@https://github.com/boostorg/optional/issues/143 #143].
+  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.
@@ -37,31 +37,10 @@
   * 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`.
 
-* In the said implementation, added a conversion from `optional<T>&` to `optional<T&>`. This addresses [@https://github.com/boostorg/optional/issues/142 issue #142].
-
 * `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.
 
-* *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.

include/boost/optional/detail/union_optional.hpp

@@ -74,20 +74,9 @@ union constexpr_union_storage_t
 
     constexpr constexpr_union_storage_t( trivial_init_t ) noexcept : dummy_() {};
 
-#if defined(BOOST_GCC) && (__GNUC__ >= 7)
-// false positive, see https://github.com/boostorg/variant2/issues/55,
-//   https://github.com/boostorg/url/issues/979
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
     template <class... Args>
     constexpr constexpr_union_storage_t( Args&&... args ) : value_(forward_<Args>(args)...) {}
 
-#if defined(BOOST_GCC) && (__GNUC__ >= 7)
-# pragma GCC diagnostic pop
-#endif
-
     //~constexpr_union_storage_t() = default; // No need to destroy a trivially-destructible type
 };
 
@@ -99,20 +88,9 @@ union fallback_union_storage_t
 
   constexpr fallback_union_storage_t( trivial_init_t ) noexcept : dummy_() {};
 
-#if defined(BOOST_GCC) && (__GNUC__ >= 7)
-// false positive, see https://github.com/boostorg/variant2/issues/55,
-//   https://github.com/boostorg/url/issues/979
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
   template <class... Args>
   constexpr fallback_union_storage_t( Args&&... args ) : value_(forward_<Args>(args)...) {}
 
-#if defined(BOOST_GCC) && (__GNUC__ >= 7)
-# pragma GCC diagnostic pop
-#endif
-
   ~fallback_union_storage_t(){} // My owner will destroy the `T` if needed.
                                 // Cannot default in a union with nontrivial `T`.
 };
@@ -144,15 +122,6 @@ struct constexpr_guarded_storage
     BOOST_CXX14_CONSTEXPR void reset () noexcept { init_ = false; }
 
     //~constexpr_guarded_storage() = default;
-
-#if (defined(_MSC_VER) && 1910 <= _MSC_VER && _MSC_VER <= 1916)
-  // Workaround for MSVC 14.1x bug where it eagerly tries to define the copy/move operations
-  // these are declared but never defined
-    constexpr_guarded_storage(const constexpr_guarded_storage&);
-    constexpr_guarded_storage(constexpr_guarded_storage&&);
-    constexpr_guarded_storage& operator=(const constexpr_guarded_storage&);
-    constexpr_guarded_storage& operator=(constexpr_guarded_storage&&);
-#endif
 };
 
 
@@ -186,15 +155,6 @@ struct fallback_guarded_storage
     }
 
     ~fallback_guarded_storage() { if (init_) storage_.value_.T::~T(); }
-
-#if (defined(_MSC_VER) && 1910 <= _MSC_VER && _MSC_VER <= 1916)
-// Workaround for MSVC 14.1x bug where it eagerly tries to define the copy/move operations
-// These are declared but never defined
-  fallback_guarded_storage(const fallback_guarded_storage&);
-  fallback_guarded_storage(fallback_guarded_storage&&);
-  fallback_guarded_storage& operator=(const fallback_guarded_storage&);
-  fallback_guarded_storage& operator=(fallback_guarded_storage&&);
-#endif
 };
 
 
@@ -389,9 +349,7 @@ namespace boost {
     }
 
     template <typename U,
-              BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U&&>),
-              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_typed_in_place_factory<U>),
-              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_in_place_factory<U>)>
+              BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U&&>)>
     constexpr explicit optional(U&& v)
     : storage(optional_ns::in_place_init, optional_detail::forward_<U>(v))
     {}
@@ -401,20 +359,6 @@ namespace boost {
     : storage(in_place_init, optional_detail::forward_<Args>(args)...)
     {}
 
-    BOOST_CXX14_CONSTEXPR operator optional<T&>() & noexcept
-    {
-      return this->has_value() ? optional<T&>(**this) : optional<T&>();
-    }
-
-    BOOST_CONSTEXPR operator optional<const T&>() const& noexcept
-    {
-      return this->has_value() ? optional<const T&>(**this) : optional<const T&>();
-    }
-
-    BOOST_CXX14_CONSTEXPR operator optional<T&>() && noexcept = delete;
-    BOOST_CONSTEXPR operator optional<const T&>() const&& noexcept = delete;
-
-
     BOOST_CXX14_CONSTEXPR void reset() noexcept
     {
       storage.reset();
@@ -519,9 +463,7 @@ namespace boost {
               BOOST_OPTIONAL_REQUIRES(!::std::is_same<typename ::std::decay<U>::type, optional>),
               BOOST_OPTIONAL_REQUIRES(!optional_detail::conjunction<::std::is_scalar<T>, ::std::is_same<T, BOOST_OPTIONAL_DECAY(U)>>),
               BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U>),
-              BOOST_OPTIONAL_REQUIRES(::std::is_assignable<T&, U>),
-              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_typed_in_place_factory<U>),
-              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_in_place_factory<U>)
+              BOOST_OPTIONAL_REQUIRES(::std::is_assignable<T&, U>)
              >
     BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(U&& v)
     {

test/Jamfile.v2

@@ -28,6 +28,7 @@ project
             cxx11_explicit_conversion_operators
 #            cxx11_noexcept
             cxx11_rvalue_references
+            cxx11_static_assert
             cxx11_variadic_templates
         ]
     ;
@@ -80,7 +81,6 @@ compile-fail optional_test_fail3b.cpp ;
 compile-fail optional_test_ref_fail1.cpp ;
 compile-fail optional_test_ref_fail3.cpp ;
 compile-fail optional_test_ref_fail4.cpp ;
-compile-fail optional_test_ref_fail_convert_from_temporary_optional_T.cpp ;
 compile-fail optional_test_inplace_fail.cpp ;
 compile-fail optional_test_inplace_fail2.cpp ;
 compile-fail optional_test_fail_implicit_bool_convert.cpp ;

test/optional_test_constexpr.cpp

@@ -10,6 +10,7 @@
 //  akrzemi1@gmail.com
 
 #include "boost/optional.hpp"
+#include <string>
 
 #ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
 
@@ -129,4 +130,24 @@ namespace test_optional_ref
   static_assert(*iref == 9, "");
 }
 
+namespace test_msvc_14_1
+{
+  struct Aggr
+  {
+    boost::optional<std::string> os;
+  };
+
+  void test()
+  {
+    Aggr a;
+    Aggr b = a;
+    b = a;
+    Aggr c = Aggr();
+    b = Aggr();
+    (void)a;
+    (void)b;
+    (void)c;
+  }
+}
+
 #endif // BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION

test/optional_test_convert_from_T.cpp

@@ -45,8 +45,6 @@ void test_optional_of_superconverting_T() // compile-time test
   superconv<optional<int> > s;
    superconv<optional<int> > & rs = s;
   optional<superconv<optional<int> > > os = rs;
-  (void)s;
-  (void)os;
 #endif
 }
 

test/optional_test_inplace_factory.cpp

@@ -105,42 +105,9 @@ void test_assign()
 #endif
 }
 
-// begin Boost.Log case
-
-template <typename CharT>
-struct basic_formatter
-{
-  template< typename FunT >
-  basic_formatter(FunT&&) {}
-
-  template< typename FunT >
-  basic_formatter& operator= (FunT&&)
-  {
-      return *this;
-  }
-};
-
-template< typename CharT>
-struct chained_formatter
-{
-};
-
-void test_boost_log_case()
-{
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-
-  boost::optional<basic_formatter<char>> of( boost::in_place(chained_formatter<char>()) );
-  of = boost::in_place(chained_formatter<char>());
-
-#endif //BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-}
-
-// end Boost.Log case
-
 int main()
 {
   test_ctor();
   test_assign();
-  test_boost_log_case();
   return boost::report_errors();
 }

test/optional_test_msvc_bug_workaround.cpp

@@ -32,7 +32,6 @@ void test()
   //BOOST_TEST(v);
   boost::optional<boost::optional<int>> vv;
   bool xx = vv?true : false;
-  (void)xx;
   BOOST_TEST_EQ(*v, 7);
 #endif
 }

test/optional_test_ref_fail_convert_from_temporary_optional_T.cpp

@@ -1,21 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_converting_initialization()
-{
-  boost::optional<const int&> o (boost::optional<int>(1));
-  (void)o;
-}

test/optional_test_ref_to_val.cpp

@@ -24,13 +24,7 @@ using boost::none;
 struct Value
 {
   int val;
-  BOOST_CONSTEXPR explicit Value(int v) : val(v) {}
-};
-
-struct Guard
-{
-  int val;
-  BOOST_CONSTEXPR explicit Guard(int v) : val(v) {}
+  explicit Value(int v) : val(v) {}
 };
 
 int val(int const& i)
@@ -43,11 +37,6 @@ int val(Value const& v)
   return v.val;
 }
 
-int val(Guard const& v)
-{
-  return v.val;
-}
-
 template <typename Tref>
 optional<Tref&> make_opt_ref(Tref& v)
 {
@@ -58,21 +47,21 @@ template <typename Tval, typename Tref>
 void test_construct_from_optional_ref()
 {
     Tref v1 (1), v2 (2);
-
+    
     optional<Tref&> opt_ref0;
     optional<Tref&> opt_ref1 (v1);
-
+    
     optional<Tval> opt_val0 (opt_ref0);
     optional<Tval> opt_val1 (opt_ref1);
     optional<Tval> opt_val2 (make_opt_ref(v2));
-
+    
     BOOST_TEST (!opt_val0);
     BOOST_TEST (opt_val1);
     BOOST_TEST (opt_val2);
-
+    
     BOOST_TEST_EQ (1, val(*opt_val1));
     BOOST_TEST_EQ (2, val(*opt_val2));
-
+    
     BOOST_TEST (boost::addressof(*opt_val1) != boost::addressof(v1));
     BOOST_TEST (boost::addressof(*opt_val2) != boost::addressof(v2));
 }
@@ -81,121 +70,29 @@ template <typename Tval, typename Tref>
 void test_assign_from_optional_ref()
 {
     Tref v1 (1), v2 (2);
-
+    
     optional<Tref&> opt_ref0;
     optional<Tref&> opt_ref1 (v1);
-
+    
     optional<Tval> opt_val0;
     optional<Tval> opt_val1;
     optional<Tval> opt_val2;
-
+    
     opt_val0 = opt_ref0;
     opt_val1 = opt_ref1;
     opt_val2 = make_opt_ref(v2);
-
+    
     BOOST_TEST (!opt_val0);
     BOOST_TEST (opt_val1);
     BOOST_TEST (opt_val2);
-
+    
     BOOST_TEST_EQ (1, val(*opt_val1));
     BOOST_TEST_EQ (2, val(*opt_val2));
-
+    
     BOOST_TEST (boost::addressof(*opt_val1) != boost::addressof(v1));
     BOOST_TEST (boost::addressof(*opt_val2) != boost::addressof(v2));
 }
 
-template <typename T>
-void test_convert_optional_T_to_optional_T_ref()
-{
-#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
-  using boost::optional;
-  using boost::in_place_init;
-
-  { // optional<T>& -> optional<T&>
-    optional<T> ovN, ov1(in_place_init, 1), ov2(in_place_init, 2);
-
-    optional<T&> orN = ovN;
-    optional<T&> or1 = ov1;
-    optional<T&> or2 = ov2;
-
-    BOOST_TEST_EQ (!!orN, !!ovN);
-    BOOST_TEST_EQ (!!or1, !!ov1);
-    BOOST_TEST_EQ (!!or2, !!ov2);
-
-    BOOST_TEST (or1);
-    BOOST_TEST (or2);
-    BOOST_TEST_EQ (val(*or1), 1);
-    BOOST_TEST_EQ (val(*or2), 2);
-    BOOST_TEST (boost::addressof(*or1) == boost::addressof(*ov1));
-    BOOST_TEST (boost::addressof(*or2) == boost::addressof(*ov2));
-  }
-
-  { // const optional<T>& -> optional<const T&>
-    constexpr optional<T> ovN;
-    constexpr optional<T> ov1(in_place_init, 1);
-    constexpr optional<T> ov2(in_place_init, 2);
-
-    optional<const T&> orN = ovN;
-    optional<const T&> or1 = ov1;
-    optional<const T&> or2 = ov2;
-
-    BOOST_TEST_EQ (!!orN, !!ovN);
-    BOOST_TEST_EQ (!!or1, !!ov1);
-    BOOST_TEST_EQ (!!or2, !!ov2);
-
-    BOOST_TEST (or1);
-    BOOST_TEST (or2);
-    BOOST_TEST_EQ (val(*or1), 1);
-    BOOST_TEST_EQ (val(*or2), 2);
-    BOOST_TEST (boost::addressof(*or1) == boost::addressof(*ov1));
-    BOOST_TEST (boost::addressof(*or2) == boost::addressof(*ov2));
-  }
-
-  { // optional<const T>& -> optional<const T&>
-    optional<const T> ovN;
-    optional<const T> ov1(in_place_init, 1);
-    optional<const T> ov2(in_place_init, 2);
-
-    optional<const T&> orN = ovN;
-    optional<const T&> or1 = ov1;
-    optional<const T&> or2 = ov2;
-
-    BOOST_TEST_EQ (!!orN, !!ovN);
-    BOOST_TEST_EQ (!!or1, !!ov1);
-    BOOST_TEST_EQ (!!or2, !!ov2);
-
-    BOOST_TEST (or1);
-    BOOST_TEST (or2);
-    BOOST_TEST_EQ (val(*or1), 1);
-    BOOST_TEST_EQ (val(*or2), 2);
-    BOOST_TEST (boost::addressof(*or1) == boost::addressof(*ov1));
-    BOOST_TEST (boost::addressof(*or2) == boost::addressof(*ov2));
-  }
-
-  { // optional<T>& -> optional<const T&>
-    optional<T> ovN;
-    optional<T> ov1(in_place_init, 1);
-    optional<T> ov2(in_place_init, 2);
-
-    optional<const T&> orN = ovN;
-    optional<const T&> or1 = ov1;
-    optional<const T&> or2 = ov2;
-
-    BOOST_TEST_EQ (!!orN, !!ovN);
-    BOOST_TEST_EQ (!!or1, !!ov1);
-    BOOST_TEST_EQ (!!or2, !!ov2);
-
-    BOOST_TEST (or1);
-    BOOST_TEST (or2);
-    BOOST_TEST_EQ (val(*or1), 1);
-    BOOST_TEST_EQ (val(*or2), 2);
-    BOOST_TEST (boost::addressof(*or1) == boost::addressof(*ov1));
-    BOOST_TEST (boost::addressof(*or2) == boost::addressof(*ov2));
-  }
-
-#endif // BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
-}
-
 
 int main()
 {
@@ -203,21 +100,17 @@ int main()
     test_construct_from_optional_ref<int, int const>();
     test_construct_from_optional_ref<int const, int const>();
     test_construct_from_optional_ref<int const, int>();
-
+    
     test_construct_from_optional_ref<Value, Value>();
     test_construct_from_optional_ref<Value, Value const>();
     test_construct_from_optional_ref<Value const, Value const>();
     test_construct_from_optional_ref<Value const, Value>();
-
+    
     test_assign_from_optional_ref<int, int>();
     test_assign_from_optional_ref<int, int const>();
 
     test_assign_from_optional_ref<Value, Value>();
     test_assign_from_optional_ref<Value, Value const>();
 
-    test_convert_optional_T_to_optional_T_ref<int>();
-    test_convert_optional_T_to_optional_T_ref<Value>();
-    test_convert_optional_T_to_optional_T_ref<Guard>();
-
     return boost::report_errors();
 }