Merge pull request #5 from boostorg/develop

Merge from develop

doc/01_quick_start.qbk

@@ -17,18 +17,18 @@
 Let's write and use a converter function that converts an a `std::string` to an `int`. It is possible that for a given string (e.g. `"cat"`) there exist no value of type `int` capable of representing the conversion result. We do not consider such situation an error. We expect that the converter can be used only to check if the conversion is possible. A natural signature for this function can be:
 
     #include <boost/optional.hpp>
-    boost::optionl<int> convert(const std::string& text);
+    boost::optional<int> convert(const std::string& text);
 
 All necessary functionality can be included with one header `<boost/optional.hpp>`. The above function signature means that the function can either return a value of type `int` or a flag indicating that no value of `int` is available. This does not indicate an error. It is like one additional value of `int`. This is how we can use our function:
 
     const std::string& text = /*... */;
-    boost::optionl<int> oi = convert(text); // move-construct
-    if (oi)                                 // contextual conversion to bool
-      int i = *oi;                          // operator*
+    boost::optional<int> oi = convert(text); // move-construct
+    if (oi)                                  // contextual conversion to bool
+      int i = *oi;                           // operator*
     
 In order to test if `optional` contains a value, we use the contextual conversion to type `bool`. Because of this we can combine the initialization of the optional object and the test into one instruction:
 
-    if (boost::optionl<int> oi = convert(text))
+    if (boost::optional<int> oi = convert(text))
       int i = *oi;
 
 We extract the contained value with `operator*` (and with `operator->` where it makes sense). An attempt to extract the contained value of an uninitialized optional object is an ['undefined behaviour] (UB). This implementation guards the call with `BOOST_ASSERT`. Therefore you should be sure that the contained value is there before extracting. For instance, the following code is reasonably UB-safe:
@@ -50,16 +50,19 @@ This version throws an exception upon an attempt to access a non-existent contai
     
 This uses the `atoi`-like approach to conversions: if `text` does not represent an integral number just return `0`. Finally, you can provide a callback to be called when trying to access the contained value fails:
 
-    int l = convert(text).value_or_eval([]() -> int { 
-      cout << "could not convert; using -1 instead" << endl; 
+    int fallback_to_default()
+    {
+      cerr << "could not convert; using -1 instead" << endl; 
       return -1;
-    });
+    }
+    
+    int l = convert(text).value_or_eval(fallback_to_default);
 
 This will call the provided callback and return whatever the callback returns. The callback can have side effects: they will only be observed when the optional object does not contain a value.
 
 Now, let's consider how function `convert` can be implemented.
 
-    boost::optionl<int> convert(const std::string& text)
+    boost::optional<int> convert(const std::string& text)
     {  
       std::stringstream s(text);
       int i;
@@ -77,9 +80,9 @@ Observe the two return statements. `return i` uses the converting constructor th
 
 We could write function `convert` in a slightly different manner, so that it has a single `return`-statement:
 
-    boost::optionl<int> convert(const std::string& text)
+    boost::optional<int> convert(const std::string& text)
     {
-      boost::optionl<int> ans;
+      boost::optional<int> ans;
       std::stringstream s(text);
       int i;
       if ((s >> i) && s.get() == std::char_traits<char>::eof())

doc/20_reference.qbk

@@ -326,7 +326,7 @@ __SPACE__
 value is another reference to the same object referenced by `*rhs`; else
 `*this` is uninitialized.
 * [*Throws:] Nothing.
-* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will reefer to the
+* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will refer to the
 same object (they alias).
 * [*Example:]
 ``
@@ -360,7 +360,8 @@ __SPACE__
 * [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
 its value is move constructed from `rhs`; else `*this` is uninitialized.
 * [*Throws:] Whatever `T::T( T&& )` throws.
-* [*Notes:] If `rhs` is initialized, `T::T( T && )` is called. The expression inside `noexcept` is equivalent to `is_nothrow_move_constructible<T>::value`.
+* [*Remarks:] The expression inside `noexcept` is equivalent to `is_nothrow_move_constructible<T>::value`.
+* [*Notes:] If `rhs` is initialized, `T::T( T && )` is called.
 * [*Exception Safety:] Exceptions can only be thrown during
 `T::T( T&& );` in that case, `rhs` remains initialized and the value of `*rhs` is determined by exception safety of `T::T(T&&)`.
 * [*Example:]
@@ -390,7 +391,7 @@ __SPACE__
 value is another reference to the same object referenced by `*rhs`; else
 `*this` is uninitialized.
 * [*Throws:] Nothing.
-* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will reefer to the
+* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will refer to the
 same object (they alias).
 * [*Example:]
 ``
@@ -599,18 +600,17 @@ __SPACE__
 
 [: `optional& optional<T` ['(not a ref)]`>::operator= ( optional const& rhs ) ;`]
 
-* [*Effect:] Assigns another `optional` to an `optional`.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is a ['copy] of the value of `rhs`; else `*this` is uninitialized.
-* [*Throws:] Whatever `T::operator( T const&)` or  `T::T( T const& )` throws.
-* [*Notes:] If both `*this` and `rhs` are initially initialized, `T`'s
-['assignment operator] is used. If `*this` is initially initialized but `rhs` is
-uninitialized, `T`'s [destructor] is called. If `*this` is initially uninitialized
-but `rhs` is initialized, `T`'s ['copy constructor] is called.
-* [*Exception Safety:] In the event of an exception, the initialization state of
-`*this` is unchanged and its value unspecified as far as optional is concerned
-(it is up to `T`'s `operator=()`). If `*this` is initially uninitialized and
-`T`'s ['copy constructor] fails, `*this` is left properly uninitialized.
+* [*Requires:] `T` is __COPY_CONSTRUCTIBLE__ and `CopyAssignable`.
+* [*Effects:]
+  * If `!*this && !rhs` no effect, otherwise
+  * if `bool(*this) && !rhs`, destroys the contained value by calling `val->T::~T()`, otherwise
+  * if `!*this && bool(rhs)`, initializes the contained value as if direct-initializing an object of type `T` with `*rhs`, otherwise
+  * (if `bool(*this) && bool(rhs)`) assigns `*rhs` to the contained value.
+* [*Returns:] `*this`;
+* [*Postconditions:] `bool(rhs) == bool(*this)`. 
+* [*Exception Safety:] If any exception is thrown, the initialization state of `*this` and `rhs` remains unchanged.
+If an exception is thrown during the call to `T`'s copy constructor, no effect.
+If an exception is thrown during the call to `T`'s copy assignment, the state of its contained value is as defined by the exception safety guarantee of `T`'s copy assignment.
 * [*Example:]
 ``
 T v;
@@ -660,18 +660,18 @@ __SPACE__
 
 [: `optional& optional<T` ['(not a ref)]`>::operator= ( optional&& rhs ) noexcept(`['see below]`);`]
 
-* [*Effect:] Move-assigns another `optional` to an `optional`.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is moved from `*rhs`, `rhs` remains initialized; else `*this` is uninitialized.
-* [*Throws:] Whatever `T::operator( T&& )` or  `T::T( T && )` throws.
-* [*Notes:] If both `*this` and `rhs` are initially initialized, `T`'s
-['move assignment operator] is used. If `*this` is initially initialized but `rhs` is
-uninitialized, `T`'s [destructor] is called. If `*this` is initially uninitialized
-but `rhs` is initialized, `T`'s ['move constructor] is called. The expression inside `noexcept` is equivalent to `is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value`.
-* [*Exception Safety:] In the event of an exception, the initialization state of
-`*this` is unchanged and its value unspecified as far as optional is concerned
-(it is up to `T`'s `operator=()`). If `*this` is initially uninitialized and
-`T`'s ['move constructor] fails, `*this` is left properly uninitialized.
+* [*Requires:] `T` is __MOVE_CONSTRUCTIBLE__ and `MoveAssignable`.
+* [*Effects:]
+  * If `!*this && !rhs` no effect, otherwise
+  * if `bool(*this) && !rhs`, destroys the contained value by calling `val->T::~T()`, otherwise
+  * if `!*this && bool(rhs)`, initializes the contained value as if direct-initializing an object of type `T` with `std::move(*rhs)`, otherwise
+  * (if `bool(*this) && bool(rhs)`) assigns `std::move(*rhs)` to the contained value.
+* [*Returns:] `*this`;
+* [*Postconditions:] `bool(rhs) == bool(*this)`. 
+* [*Remarks:] The expression inside `noexcept` is equivalent to `is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value`.
+* [*Exception Safety:] If any exception is thrown, the initialization state of `*this` and `rhs` remains unchanged. If an exception is
+thrown during the call to `T`'s move constructor, the state of `*rhs` is determined by the exception safety guarantee
+of `T`'s move constructor. If an exception is thrown during the call to T's move-assignment, the state of `**this` and `*rhs` is determined by the exception safety guarantee of T's move assignment.
 * [*Example:]
 ``
 optional<T> opt(T(2)) ;
@@ -749,6 +749,8 @@ optional<T> opt0(v);
 optional<U> opt1;
 
 opt1 = std::move(opt0) ;
+assert ( opt0 );
+assert ( opt1 ) 
 assert ( *opt1 == static_cast<U>(v) ) ;
 ``
 
@@ -932,8 +934,7 @@ __SPACE__
 [: `template<class U> T optional<T>::value_or(U && v) const& ;`]
 
 * [*Requires:] `T` is __COPY_CONSTRUCTIBLE__ and `U &&` is convertible to `T`.
-* [*Returns:] `bool(*this) ? **this : static_cast<T>(std::forward<U>(v))`.
-* [*Throws:] Any exception thrown by the selected constructor of `T`.
+* [*Effects:] `if (*this) return **this; else return std::forward<U>(v);`.
 * [*Notes:] On compilers that do not support ref-qualifiers on member functions this overload is replaced with the `const`-qualified member function. On compilers without rvalue reference support the type of `v` becomes `U const&`.
 
 __SPACE__
@@ -943,8 +944,7 @@ __SPACE__
 [: `template<class U> T optional<T>::value_or(U && v) && ;`]
 
 * [*Requires:] `T` is __MOVE_CONSTRUCTIBLE__ and `U &&` is convertible to `T`.
-* [*Returns:] `bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v))`.
-* [*Throws:] Any exception thrown by the selected constructor of `T`.
+* [*Effects:] `if (*this) return std::move(**this); else return std::forward<U>(v);`.
 * [*Notes:] On compilers that do not support ref-qualifiers on member functions this overload is not present.
 
 __SPACE__
@@ -954,9 +954,8 @@ __SPACE__
 [: `template<class F> T optional<T>::value_or_eval(F f) const& ;`]
 
 * [*Requires:] `T` is __COPY_CONSTRUCTIBLE__ and `F` models a __SGI_GENERATOR__ whose result type is convertible to `T`.
-* [*Returns:] `bool(*this) ? **this : static_cast<T>(f())`.
-* [*Throws:] Any exception thrown by the selected constructor of `T` or by `f`.
-* [*Notes:] Function `f` is only evaluated if `bool(*this) == false`. On compilers that do not support ref-qualifiers on member functions this overload is replaced with the `const`-qualified member function.
+* [*Effects:] `if (*this) return **this; else return f();`.
+* [*Notes:] On compilers that do not support ref-qualifiers on member functions this overload is replaced with the `const`-qualified member function.
 * [*Example:]
 ``
 int complain_and_0()
@@ -982,9 +981,8 @@ __SPACE__
 [: `template<class F> T optional<T>::value_or_eval(F f) && ;`]
 
 * [*Requires:] `T` is __MOVE_CONSTRUCTIBLE__ and `F` models a __SGI_GENERATOR__ whose result type is convertible to `T`.
-* [*Returns:] `bool(*this) ? std::move(**this) : static_cast<T>(f())`.
-* [*Throws:] Any exception thrown by the selected constructor of `T` or by `f`.
-* [*Notes:] Function `f` is only evaluated if `bool(*this) == false`. On compilers that do not support ref-qualifiers on member functions this overload is not present.
+* [*Effects:] `if (*this) return std::move(**this); else return f();`.
+* [*Notes:] On compilers that do not support ref-qualifiers on member functions this overload is not present.
 
 __SPACE__
 
@@ -1146,38 +1144,28 @@ __SPACE__
 
 [: `bool operator == ( optional<T> const& x, optional<T> const& y );`]
 
-* [*Requires:] `T` shall meet requirements of `EqualityComparable`.
+* [*Requires:] `T` shall meet requirements of __SGI_EQUALITY_COMPARABLE__.
 * [*Returns:] If both `x` and `y` are initialized, `(*x == *y)`. If only
 `x` or `y` is initialized, `false`. If both are uninitialized, `true`.
-* [*Throws:] Nothing.
 * [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator ==` directly in generic
+deep relational operators. Do not use `operator==` directly in generic
 code which expect to be given either an `optional<T>` or a pointer; use
 __FUNCTION_EQUAL_POINTEES__ instead
 * [*Example:]
 ``
-T x(12);
-T y(12);
-T z(21);
-optional<T> def0 ;
-optional<T> def1 ;
-optional<T> optX(x);
-optional<T> optY(y);
-optional<T> optZ(z);
+optional<T> oN, oN_;
+optional<T> o1(T(1)), o1_(T(1));
+optional<T> o2(T(2));
 
-// Identity always hold
-assert ( def0 == def0 );
-assert ( optX == optX );
+assert ( oN == oN );  // Identity implies equality
+assert ( o1 == o1 );  //
 
-// Both uninitialized compare equal
-assert ( def0 == def1 );
+assert ( oN == oN_ ); // Both uninitialized compare equal
 
-// Only one initialized compare unequal.
-assert ( def0 != optX );
+assert ( oN != o1 );  // Initialized unequal to initialized.
 
-// Both initialized compare as (*lhs == *rhs)
-assert ( optX == optY ) ;
-assert ( optX != optZ ) ;
+assert ( o1 == o1_ ); // Both initialized compare as (*lhs == *rhs)
+assert ( o1 != o2 );  //
 ``
 
 __SPACE__
@@ -1186,35 +1174,29 @@ __SPACE__
 
 [: `bool operator < ( optional<T> const& x, optional<T> const& y );`]
 
-* [*Requires:] `T` shall meet requirements of `LessThanComparable`.
-* [*Returns:] If `y` is not initialized, `false`. If `y` is initialized
-and `x` is not initialized, `true`. If both `x` and `y` are initialized,
-`(*x < *y)`.
-* [*Throws:] Nothing.
+* [*Requires:] Expression `*x < *y` shall be well-formed and its result shall be convertible to `bool`.
+* [*Returns:] `(!y) ? false : (!x) ? true : *x < *y`.
 * [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator <` directly in generic code
-which expect to be given either an `optional<T>` or a pointer; use __FUNCTION_LESS_POINTEES__ instead.
+deep relational operators. Do not use `operator<` directly in generic code
+which expect to be given either an `optional<T>` or a pointer; use __FUNCTION_LESS_POINTEES__ instead. `T` need not be __SGI_LESS_THAN_COMPARABLE__. Only single `operator<` is required. Other relational operations are defined in terms of this one. If `T`'s `operator<` satisfies the axioms of __SGI_LESS_THAN_COMPARABLE__ (transitivity, antisymmetry and irreflexivity), `optinal<T>` is __SGI_LESS_THAN_COMPARABLE__.
 * [*Example:]
 ``
-T x(12);
-T y(34);
-optional<T> def ;
-optional<T> optX(x);
-optional<T> optY(y);
+optional<T> oN, oN_;
+optional<T> o0(T(0));
+optional<T> o1(T(1));
 
-// Identity always hold
-assert ( !(def < def) );
-assert ( optX == optX );
+assert ( !(oN < oN) );  // Identity implies equivalence
+assert ( !(o1 < o1) );
 
-// Both uninitialized compare equal
-assert ( def0 == def1 );
+assert ( !(oN < oN_) ); // Two uninitialized are equivalent
+assert ( !(oN_ < oN) );
 
-// Only one initialized compare unequal.
-assert ( def0 != optX );
+assert ( oN < o0 );     // Uninitialized is less than initialized
+assert ( !(o0 < oN) );
 
-// Both initialized compare as (*lhs == *rhs)
-assert ( optX == optY ) ;
-assert ( optX != optZ ) ;
+assert ( o1 < o2 ) ;    // Two initialized compare as (*lhs < *rhs)
+assert ( !(o2 < o1) ) ;
+assert ( !(o2 < o2) ) ;
 ``
 
 __SPACE__
@@ -1224,7 +1206,6 @@ __SPACE__
 [: `bool operator != ( optional<T> const& x, optional<T> const& y );`]
 
 * [*Returns: ] `!( x == y );`
-* [*Throws:] Nothing.
 
 __SPACE__
 
@@ -1233,7 +1214,6 @@ __SPACE__
 [: `bool operator > ( optional<T> const& x, optional<T> const& y );`]
 
 * [*Returns: ] `( y < x );`
-* [*Throws:] Nothing.
 
 __SPACE__
 
@@ -1242,7 +1222,6 @@ __SPACE__
 [: `bool operator <= ( optional<T> const& x, optional<T> const& y );`]
 
 * [*Returns: ] `!( y < x );`
-* [*Throws:] Nothing.
 
 __SPACE__
 
@@ -1250,15 +1229,17 @@ __SPACE__
 
 [: `bool operator >= ( optional<T> const& x, optional<T> const& y );`]
 
-* [*Returns: ] `!( x<y );`
-* [*Throws:] Nothing.
+* [*Returns: ] `!( x < y );`
+
+__SPACE__
 
 [#reference_operator_compare_equal_optional_none]
 
 [: `bool operator == ( optional<T> const& x, none_t ) noexcept;`]
+[: `bool operator == ( none_t, optional<T> const& x ) noexcept;`]
 
 * [*Returns:] `!x`.
-* [*Notes:] `T` need not meet requirements of `EqualityComparable`.
+* [*Notes:] `T` need not meet requirements of __SGI_EQUALITY_COMPARABLE__.
 
 
 __SPACE__
@@ -1266,6 +1247,7 @@ __SPACE__
 [#reference_operator_compare_not_equal_optional_none]
 
 [: `bool operator != ( optional<T> const& x, none_t ) noexcept;`]
+[: `bool operator != ( none_t, optional<T> const& x ) noexcept;`]
 
 * [*Returns: ] `!( x == y );`
 
@@ -1276,19 +1258,15 @@ __SPACE__
 
 [: `void swap ( optional<T>& x, optional<T>& y ) ;`]
 
-* [*Effect:] If both `x` and `y` are initialized, calls `swap(*x,*y)`
-using `std::swap`. If only one is initialized, say `x`, calls:
-`y.reset(*x); x.reset();` If none is initialized, does nothing.
+* [*Requires:] Lvalues of type `T` shall be swappable and `T` shall be __MOVE_CONSTRUCTIBLE__.
+* [*Effects:]
+  * If `!*this && !rhs`, no effect, otherwise
+  * if `bool(*this) && !rhs`, initializes the contained value of `rhs` as if direct-initializing an object of type `T` with the expression `std::move(*(*this))`, followed by `val->T::~T()`, `*this` does not contain a value and `rhs` contains a value, otherwise
+  * if `!*this && bool(rhs)`, initializes the contained value of `*this` as if direct-initializing an object of type `T` with the expression `std::move(*rhs)`, followed by `rhs.val->T::~T()`, `*this` contains a value and `rhs` does not contain a value, otherwise
+  * (if `bool(*this) && bool(rhs)`) calls `swap(*(*this), *rhs)`.
 * [*Postconditions:] The states of `x` and `y` interchanged.
 * [*Throws:] If both are initialized, whatever `swap(T&,T&)` throws. If only
 one is initialized, whatever `T::T ( T&& )` throws.
-* [*Notes:] If both are initialized, `swap(T&,T&)` is used unqualified but
-with `std::swap` introduced in scope.
-If only one is initialized, `T::~T()` and `T::T( T&& )` is called.
-* [*Exception Safety:] If both are initialized, this operation has the
-exception safety guarantees of `swap(T&,T&)`.
-If only one is initialized, it has the same basic guarantee as
-`optional<T>::operator= ( T&& )`.
 * [*Example:]
 ``
 T x(12);

doc/Jamfile.v2

@@ -24,7 +24,8 @@ boostbook standalone
     :
         optional
     :
-        <xsl:param>boost.root=../../../..
+        <format>html:<xsl:param>boost.root=../../../..
+        <format>html:<xsl:param>boost.libraries=../../../../libs/libraries.htm
         <xsl:param>chapter.autolabel=0
         <xsl:param>chunk.section.depth=8
         <xsl:param>toc.section.depth=2
@@ -32,6 +33,7 @@ boostbook standalone
         <xsl:param>generate.section.toc.level=1
         <format>pdf:<xsl:param>img.src.path=$(images)/
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/optional/doc/html
+        <format>docbook:<auto-index-internal>on
     ;
 
 

doc/html/boost_optional/quick_start.html

@@ -53,7 +53,7 @@
         is possible. A natural signature for this function can be:
       </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">);</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">);</span>
 </pre>
 <p>
         All necessary functionality can be included with one header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
@@ -65,16 +65,16 @@
         can use our function:
       </p>
 <pre class="programlisting"><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span> <span class="special">=</span> <span class="comment">/*... */</span><span class="special">;</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">oi</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">);</span> <span class="comment">// move-construct</span>
-<span class="keyword">if</span> <span class="special">(</span><span class="identifier">oi</span><span class="special">)</span>                                 <span class="comment">// contextual conversion to bool</span>
-  <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">oi</span><span class="special">;</span>                          <span class="comment">// operator*</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">oi</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">);</span> <span class="comment">// move-construct</span>
+<span class="keyword">if</span> <span class="special">(</span><span class="identifier">oi</span><span class="special">)</span>                                  <span class="comment">// contextual conversion to bool</span>
+  <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">oi</span><span class="special">;</span>                           <span class="comment">// operator*</span>
 </pre>
 <p>
         In order to test if <code class="computeroutput"><span class="identifier">optional</span></code>
         contains a value, we use the contextual conversion to type <code class="computeroutput"><span class="keyword">bool</span></code>. Because of this we can combine the initialization
         of the optional object and the test into one instruction:
       </p>
-<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">oi</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">))</span>
+<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">oi</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">))</span>
   <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">oi</span><span class="special">;</span>
 </pre>
 <p>
@@ -114,10 +114,13 @@
         Finally, you can provide a callback to be called when trying to access the
         contained value fails:
       </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">).</span><span class="identifier">value_or_eval</span><span class="special">([]()</span> <span class="special">-&gt;</span> <span class="keyword">int</span> <span class="special">{</span>
-  <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"could not convert; using -1 instead"</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">fallback_to_default</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"could not convert; using -1 instead"</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="special">-</span><span class="number">1</span><span class="special">;</span>
-<span class="special">});</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">text</span><span class="special">).</span><span class="identifier">value_or_eval</span><span class="special">(</span><span class="identifier">fallback_to_default</span><span class="special">);</span>
 </pre>
 <p>
         This will call the provided callback and return whatever the callback returns.
@@ -128,7 +131,7 @@
         Now, let's consider how function <code class="computeroutput"><span class="identifier">convert</span></code>
         can be implemented.
       </p>
-<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
 <span class="special">{</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">s</span><span class="special">(</span><span class="identifier">text</span><span class="special">);</span>
   <span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span>

doc/html/boost_optional/quick_start/optional_automatic_variables.html

@@ -31,9 +31,9 @@
         We could write function <code class="computeroutput"><span class="identifier">convert</span></code>
         in a slightly different manner, so that it has a single <code class="computeroutput"><span class="keyword">return</span></code>-statement:
       </p>
-<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">convert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
 <span class="special">{</span>
-  <span class="identifier">boost</span><span class="special">::</span><span class="identifier">optionl</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">ans</span><span class="special">;</span>
+  <span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">ans</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">s</span><span class="special">(</span><span class="identifier">text</span><span class="special">);</span>
   <span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="keyword">if</span> <span class="special">((</span><span class="identifier">s</span> <span class="special">&gt;&gt;</span> <span class="identifier">i</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">char_traits</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">eof</span><span class="special">())</span>

doc/html/boost_optional/reference/detailed_semantics.html

@@ -352,7 +352,7 @@
             <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
             is initialized, both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
             and <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>
-            will reefer to the same object (they alias).
+            will refer to the same object (they alias).
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
@@ -402,12 +402,13 @@
             <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span></code>
             throws.
           </li>
+<li class="listitem">
+            <span class="bold"><strong>Remarks:</strong></span> The expression inside <code class="computeroutput"><span class="keyword">noexcept</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
+          </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
             is initialized, <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span> <span class="special">&amp;&amp;</span>
-            <span class="special">)</span></code> is called. The expression inside
-            <code class="computeroutput"><span class="keyword">noexcept</span></code> is equivalent to
-            <code class="computeroutput"><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
+            <span class="special">)</span></code> is called.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Exception Safety:</strong></span> Exceptions can only
@@ -461,7 +462,7 @@
             <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
             is initialized, both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
             and <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>
-            will reefer to the same object (they alias).
+            will refer to the same object (they alias).
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
@@ -803,36 +804,48 @@
         </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
-            <span class="bold"><strong>Effect:</strong></span> Assigns another <code class="computeroutput"><span class="identifier">optional</span></code> to an <code class="computeroutput"><span class="identifier">optional</span></code>.
+            <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+            is <a href="../../../../../utility/CopyConstructible.html" target="_top"><code class="computeroutput"><span class="identifier">CopyConstructible</span></code></a> and <code class="computeroutput"><span class="identifier">CopyAssignable</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
-            is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initialized and its value is a <span class="emphasis"><em>copy</em></span> of the value
-            of <code class="computeroutput"><span class="identifier">rhs</span></code>; else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is uninitialized.
+            <span class="bold"><strong>Effects:</strong></span>
+            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
+<li class="listitem">
+                  If <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code> no effect, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code>, destroys the contained value
+                  by calling <code class="computeroutput"><span class="identifier">val</span><span class="special">-&gt;</span><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>, initializes the contained value
+                  as if direct-initializing an object of type <code class="computeroutput"><span class="identifier">T</span></code>
+                  with <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>,
+                  otherwise
+                </li>
+<li class="listitem">
+                  (if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>) assigns <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code> to the contained value.
+                </li>
+</ul></div>
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span></code>
-            or <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>
-            throws.
+            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>;
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Notes:</strong></span> If both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code>
-            are initially initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>assignment operator</em></span> is used. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initially initialized but <code class="computeroutput"><span class="identifier">rhs</span></code> is uninitialized, <code class="computeroutput"><span class="identifier">T</span></code>'s [destructor] is called. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initially uninitialized but <code class="computeroutput"><span class="identifier">rhs</span></code>
-            is initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>copy constructor</em></span> is called.
+            <span class="bold"><strong>Postconditions:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Exception Safety:</strong></span> In the event of an
-            exception, the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is unchanged and its value unspecified
-            as far as optional is concerned (it is up to <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <code class="computeroutput"><span class="keyword">operator</span><span class="special">=()</span></code>).
-            If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initially uninitialized and <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>copy constructor</em></span> fails, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is left properly uninitialized.
+            <span class="bold"><strong>Exception Safety:</strong></span> If any exception is
+            thrown, the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code>
+            remains unchanged. If an exception is thrown during the call to <code class="computeroutput"><span class="identifier">T</span></code>'s copy constructor, no effect. If
+            an exception is thrown during the call to <code class="computeroutput"><span class="identifier">T</span></code>'s
+            copy assignment, the state of its contained value is as defined by the
+            exception safety guarantee of <code class="computeroutput"><span class="identifier">T</span></code>'s
+            copy assignment.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
@@ -901,39 +914,55 @@
         </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
-            <span class="bold"><strong>Effect:</strong></span> Move-assigns another <code class="computeroutput"><span class="identifier">optional</span></code> to an <code class="computeroutput"><span class="identifier">optional</span></code>.
+            <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+            is <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
+            and <code class="computeroutput"><span class="identifier">MoveAssignable</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
-            is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initialized and its value is moved from <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>, <code class="computeroutput"><span class="identifier">rhs</span></code>
-            remains initialized; else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized.
+            <span class="bold"><strong>Effects:</strong></span>
+            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
+<li class="listitem">
+                  If <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code> no effect, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code>, destroys the contained value
+                  by calling <code class="computeroutput"><span class="identifier">val</span><span class="special">-&gt;</span><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>, initializes the contained value
+                  as if direct-initializing an object of type <code class="computeroutput"><span class="identifier">T</span></code>
+                  with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(*</span><span class="identifier">rhs</span><span class="special">)</span></code>,
+                  otherwise
+                </li>
+<li class="listitem">
+                  (if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>) assigns <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(*</span><span class="identifier">rhs</span><span class="special">)</span></code> to the contained value.
+                </li>
+</ul></div>
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span></code>
-            or <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span> <span class="special">&amp;&amp;</span>
-            <span class="special">)</span></code> throws.
+            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>;
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Notes:</strong></span> If both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code>
-            are initially initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>move assignment operator</em></span> is used. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initially initialized but <code class="computeroutput"><span class="identifier">rhs</span></code>
-            is uninitialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
-            [destructor] is called. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initially uninitialized but <code class="computeroutput"><span class="identifier">rhs</span></code> is initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>move constructor</em></span> is called. The expression inside
-            <code class="computeroutput"><span class="keyword">noexcept</span></code> is equivalent to
-            <code class="computeroutput"><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
-            <span class="special">&amp;&amp;</span> <span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
+            <span class="bold"><strong>Postconditions:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Exception Safety:</strong></span> In the event of an
-            exception, the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is unchanged and its value unspecified
-            as far as optional is concerned (it is up to <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <code class="computeroutput"><span class="keyword">operator</span><span class="special">=()</span></code>).
-            If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
-            is initially uninitialized and <code class="computeroutput"><span class="identifier">T</span></code>'s
-            <span class="emphasis"><em>move constructor</em></span> fails, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is left properly uninitialized.
+            <span class="bold"><strong>Remarks:</strong></span> The expression inside <code class="computeroutput"><span class="keyword">noexcept</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span>
+            <span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>Exception Safety:</strong></span> If any exception is
+            thrown, the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code>
+            remains unchanged. If an exception is thrown during the call to <code class="computeroutput"><span class="identifier">T</span></code>'s move constructor, the state of
+            <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>
+            is determined by the exception safety guarantee of <code class="computeroutput"><span class="identifier">T</span></code>'s
+            move constructor. If an exception is thrown during the call to T's move-assignment,
+            the state of <code class="computeroutput"><span class="special">**</span><span class="keyword">this</span></code>
+            and <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>
+            is determined by the exception safety guarantee of T's move assignment.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
@@ -1062,6 +1091,8 @@
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">opt1</span><span class="special">;</span>
 
 <span class="identifier">opt1</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">opt0</span><span class="special">)</span> <span class="special">;</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">opt0</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">opt1</span> <span class="special">)</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">*</span><span class="identifier">opt1</span> <span class="special">==</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
 </pre>
           </li>
@@ -1455,11 +1486,8 @@
             is convertible to <code class="computeroutput"><span class="identifier">T</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">?</span> <span class="special">**</span><span class="keyword">this</span> <span class="special">:</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">))</span></code>.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Any exception thrown by the
-            selected constructor of <code class="computeroutput"><span class="identifier">T</span></code>.
+            <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="keyword">if</span>
+            <span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="keyword">return</span> <span class="special">**</span><span class="keyword">this</span><span class="special">;</span> <span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">);</span></code>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> On compilers that do not support
@@ -1485,11 +1513,9 @@
             is convertible to <code class="computeroutput"><span class="identifier">T</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">?</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(**</span><span class="keyword">this</span><span class="special">)</span> <span class="special">:</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">))</span></code>.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Any exception thrown by the
-            selected constructor of <code class="computeroutput"><span class="identifier">T</span></code>.
+            <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="keyword">if</span>
+            <span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(**</span><span class="keyword">this</span><span class="special">);</span> <span class="keyword">else</span> <span class="keyword">return</span>
+            <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">);</span></code>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> On compilers that do not support
@@ -1509,16 +1535,11 @@
             is convertible to <code class="computeroutput"><span class="identifier">T</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">?</span> <span class="special">**</span><span class="keyword">this</span> <span class="special">:</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">())</span></code>.
+            <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="keyword">if</span>
+            <span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="keyword">return</span> <span class="special">**</span><span class="keyword">this</span><span class="special">;</span> <span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">f</span><span class="special">();</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Any exception thrown by the
-            selected constructor of <code class="computeroutput"><span class="identifier">T</span></code>
-            or by <code class="computeroutput"><span class="identifier">f</span></code>.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Notes:</strong></span> Function <code class="computeroutput"><span class="identifier">f</span></code>
-            is only evaluated if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>. On compilers that do not support
+            <span class="bold"><strong>Notes:</strong></span> On compilers that do not support
             ref-qualifiers on member functions this overload is replaced with the
             <code class="computeroutput"><span class="keyword">const</span></code>-qualified member function.
           </li>
@@ -1555,16 +1576,12 @@
             whose result type is convertible to <code class="computeroutput"><span class="identifier">T</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">?</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(**</span><span class="keyword">this</span><span class="special">)</span> <span class="special">:</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">())</span></code>.
+            <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="keyword">if</span>
+            <span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(**</span><span class="keyword">this</span><span class="special">);</span> <span class="keyword">else</span> <span class="keyword">return</span>
+            <span class="identifier">f</span><span class="special">();</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Any exception thrown by the
-            selected constructor of <code class="computeroutput"><span class="identifier">T</span></code>
-            or by <code class="computeroutput"><span class="identifier">f</span></code>.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Notes:</strong></span> Function <code class="computeroutput"><span class="identifier">f</span></code>
-            is only evaluated if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>. On compilers that do not support
+            <span class="bold"><strong>Notes:</strong></span> On compilers that do not support
             ref-qualifiers on member functions this overload is not present.
           </li>
 </ul></div>
@@ -1835,7 +1852,7 @@
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
             <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
-            shall meet requirements of <code class="computeroutput"><span class="identifier">EqualityComparable</span></code>.
+            shall meet requirements of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="computeroutput"><span class="identifier">EqualityComparable</span></code></a>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Returns:</strong></span> If both <code class="computeroutput"><span class="identifier">x</span></code>
@@ -1845,41 +1862,28 @@
             If only <code class="computeroutput"><span class="identifier">x</span></code> or <code class="computeroutput"><span class="identifier">y</span></code> is initialized, <code class="computeroutput"><span class="keyword">false</span></code>.
             If both are uninitialized, <code class="computeroutput"><span class="keyword">true</span></code>.
           </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
-          </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> Pointers have shallow relational
             operators while <code class="computeroutput"><span class="identifier">optional</span></code>
-            has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span>
-            <span class="special">==</span></code> directly in generic code which
-            expect to be given either an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> or a pointer; use <a href="../../../../../utility/OptionalPointee.html#equal" target="_top"><code class="computeroutput"><span class="identifier">equal_pointees</span><span class="special">()</span></code></a>
+            has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> directly in generic code which expect
+            to be given either an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> or a pointer; use <a href="../../../../../utility/OptionalPointee.html#equal" target="_top"><code class="computeroutput"><span class="identifier">equal_pointees</span><span class="special">()</span></code></a>
             instead
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
-<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
-<span class="identifier">T</span> <span class="identifier">y</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
-<span class="identifier">T</span> <span class="identifier">z</span><span class="special">(</span><span class="number">21</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def0</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def1</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">optX</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">optY</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">optZ</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">oN</span><span class="special">,</span> <span class="identifier">oN_</span><span class="special">;</span>
+<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">o1</span><span class="special">(</span><span class="identifier">T</span><span class="special">(</span><span class="number">1</span><span class="special">)),</span> <span class="identifier">o1_</span><span class="special">(</span><span class="identifier">T</span><span class="special">(</span><span class="number">1</span><span class="special">));</span>
+<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">o2</span><span class="special">(</span><span class="identifier">T</span><span class="special">(</span><span class="number">2</span><span class="special">));</span>
 
-<span class="comment">// Identity always hold</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def0</span> <span class="special">==</span> <span class="identifier">def0</span> <span class="special">);</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">==</span> <span class="identifier">optX</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">oN</span> <span class="special">==</span> <span class="identifier">oN</span> <span class="special">);</span>  <span class="comment">// Identity implies equality</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">o1</span> <span class="special">==</span> <span class="identifier">o1</span> <span class="special">);</span>  <span class="comment">//</span>
 
-<span class="comment">// Both uninitialized compare equal</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def0</span> <span class="special">==</span> <span class="identifier">def1</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">oN</span> <span class="special">==</span> <span class="identifier">oN_</span> <span class="special">);</span> <span class="comment">// Both uninitialized compare equal</span>
 
-<span class="comment">// Only one initialized compare unequal.</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def0</span> <span class="special">!=</span> <span class="identifier">optX</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">oN</span> <span class="special">!=</span> <span class="identifier">o1</span> <span class="special">);</span>  <span class="comment">// Initialized unequal to initialized.</span>
 
-<span class="comment">// Both initialized compare as (*lhs == *rhs)</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">==</span> <span class="identifier">optY</span> <span class="special">)</span> <span class="special">;</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">!=</span> <span class="identifier">optZ</span> <span class="special">)</span> <span class="special">;</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">o1</span> <span class="special">==</span> <span class="identifier">o1_</span> <span class="special">);</span> <span class="comment">// Both initialized compare as (*lhs == *rhs)</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">o1</span> <span class="special">!=</span> <span class="identifier">o2</span> <span class="special">);</span>  <span class="comment">//</span>
 </pre>
           </li>
 </ul></div>
@@ -1893,50 +1897,44 @@
         </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
-            <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
-            shall meet requirements of <code class="computeroutput"><span class="identifier">LessThanComparable</span></code>.
+            <span class="bold"><strong>Requires:</strong></span> Expression <code class="computeroutput"><span class="special">*</span><span class="identifier">x</span> <span class="special">&lt;</span> <span class="special">*</span><span class="identifier">y</span></code>
+            shall be well-formed and its result shall be convertible to <code class="computeroutput"><span class="keyword">bool</span></code>.
           </li>
 <li class="listitem">
-            <span class="bold"><strong>Returns:</strong></span> If <code class="computeroutput"><span class="identifier">y</span></code>
-            is not initialized, <code class="computeroutput"><span class="keyword">false</span></code>.
-            If <code class="computeroutput"><span class="identifier">y</span></code> is initialized and
-            <code class="computeroutput"><span class="identifier">x</span></code> is not initialized,
-            <code class="computeroutput"><span class="keyword">true</span></code>. If both <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="identifier">y</span></code>
-            are initialized, <code class="computeroutput"><span class="special">(*</span><span class="identifier">x</span>
-            <span class="special">&lt;</span> <span class="special">*</span><span class="identifier">y</span><span class="special">)</span></code>.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
+            <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">(!</span><span class="identifier">y</span><span class="special">)</span> <span class="special">?</span> <span class="keyword">false</span> <span class="special">:</span> <span class="special">(!</span><span class="identifier">x</span><span class="special">)</span> <span class="special">?</span> <span class="keyword">true</span>
+            <span class="special">:</span> <span class="special">*</span><span class="identifier">x</span> <span class="special">&lt;</span> <span class="special">*</span><span class="identifier">y</span></code>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> Pointers have shallow relational
             operators while <code class="computeroutput"><span class="identifier">optional</span></code>
-            has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span>
-            <span class="special">&lt;</span></code> directly in generic code
-            which expect to be given either an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> or a pointer; use <a href="../../../../../utility/OptionalPointee.html#less" target="_top"><code class="computeroutput"><span class="identifier">less_pointees</span><span class="special">()</span></code></a>
-            instead.
+            has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> directly in generic code which expect
+            to be given either an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> or a pointer; use <a href="../../../../../utility/OptionalPointee.html#less" target="_top"><code class="computeroutput"><span class="identifier">less_pointees</span><span class="special">()</span></code></a>
+            instead. <code class="computeroutput"><span class="identifier">T</span></code> need not be
+            <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top"><code class="computeroutput"><span class="identifier">LessThanComparable</span></code></a>. Only single
+            <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
+            is required. Other relational operations are defined in terms of this
+            one. If <code class="computeroutput"><span class="identifier">T</span></code>'s <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
+            satisfies the axioms of <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top"><code class="computeroutput"><span class="identifier">LessThanComparable</span></code></a> (transitivity,
+            antisymmetry and irreflexivity), <code class="computeroutput"><span class="identifier">optinal</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is <a href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top"><code class="computeroutput"><span class="identifier">LessThanComparable</span></code></a>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
-<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
-<span class="identifier">T</span> <span class="identifier">y</span><span class="special">(</span><span class="number">34</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">optX</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">optY</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">oN</span><span class="special">,</span> <span class="identifier">oN_</span><span class="special">;</span>
+<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">o0</span><span class="special">(</span><span class="identifier">T</span><span class="special">(</span><span class="number">0</span><span class="special">));</span>
+<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">o1</span><span class="special">(</span><span class="identifier">T</span><span class="special">(</span><span class="number">1</span><span class="special">));</span>
 
-<span class="comment">// Identity always hold</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">def</span> <span class="special">&lt;</span> <span class="identifier">def</span><span class="special">)</span> <span class="special">);</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">==</span> <span class="identifier">optX</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">oN</span> <span class="special">&lt;</span> <span class="identifier">oN</span><span class="special">)</span> <span class="special">);</span>  <span class="comment">// Identity implies equivalence</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">o1</span> <span class="special">&lt;</span> <span class="identifier">o1</span><span class="special">)</span> <span class="special">);</span>
 
-<span class="comment">// Both uninitialized compare equal</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def0</span> <span class="special">==</span> <span class="identifier">def1</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">oN</span> <span class="special">&lt;</span> <span class="identifier">oN_</span><span class="special">)</span> <span class="special">);</span> <span class="comment">// Two uninitialized are equivalent</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">oN_</span> <span class="special">&lt;</span> <span class="identifier">oN</span><span class="special">)</span> <span class="special">);</span>
 
-<span class="comment">// Only one initialized compare unequal.</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def0</span> <span class="special">!=</span> <span class="identifier">optX</span> <span class="special">);</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">oN</span> <span class="special">&lt;</span> <span class="identifier">o0</span> <span class="special">);</span>     <span class="comment">// Uninitialized is less than initialized</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">o0</span> <span class="special">&lt;</span> <span class="identifier">oN</span><span class="special">)</span> <span class="special">);</span>
 
-<span class="comment">// Both initialized compare as (*lhs == *rhs)</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">==</span> <span class="identifier">optY</span> <span class="special">)</span> <span class="special">;</span>
-<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">optX</span> <span class="special">!=</span> <span class="identifier">optZ</span> <span class="special">)</span> <span class="special">;</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">o1</span> <span class="special">&lt;</span> <span class="identifier">o2</span> <span class="special">)</span> <span class="special">;</span>    <span class="comment">// Two initialized compare as (*lhs &lt; *rhs)</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">o2</span> <span class="special">&lt;</span> <span class="identifier">o1</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
+<span class="identifier">assert</span> <span class="special">(</span> <span class="special">!(</span><span class="identifier">o2</span> <span class="special">&lt;</span> <span class="identifier">o2</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
 </pre>
           </li>
 </ul></div>
@@ -1947,16 +1945,11 @@
           <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
           <span class="special">!=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">);</span></code>
         </p></blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
             <span class="identifier">x</span> <span class="special">==</span>
             <span class="identifier">y</span> <span class="special">);</span></code>
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
-          </li>
-</ul></div>
+          </li></ul></div>
 <p>
         <span class="inlinemediaobject"><img src="../../images/space.png" alt="space"></span>
       </p>
@@ -1965,16 +1958,11 @@
           <span class="special">&gt;</span> <span class="special">(</span>
           <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">);</span></code>
         </p></blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">(</span>
             <span class="identifier">y</span> <span class="special">&lt;</span>
             <span class="identifier">x</span> <span class="special">);</span></code>
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
-          </li>
-</ul></div>
+          </li></ul></div>
 <p>
         <span class="inlinemediaobject"><img src="../../images/space.png" alt="space"></span>
       </p>
@@ -1983,16 +1971,11 @@
           <span class="special">&lt;=</span> <span class="special">(</span>
           <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">);</span></code>
         </p></blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
             <span class="identifier">y</span> <span class="special">&lt;</span>
             <span class="identifier">x</span> <span class="special">);</span></code>
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
-          </li>
-</ul></div>
+          </li></ul></div>
 <p>
         <span class="inlinemediaobject"><img src="../../images/space.png" alt="space"></span>
       </p>
@@ -2001,27 +1984,30 @@
           <span class="special">&gt;=</span> <span class="special">(</span>
           <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">);</span></code>
         </p></blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
-            <span class="identifier">x</span><span class="special">&lt;</span><span class="identifier">y</span> <span class="special">);</span></code>
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Throws:</strong></span> Nothing.
-          </li>
-</ul></div>
+            <span class="identifier">x</span> <span class="special">&lt;</span>
+            <span class="identifier">y</span> <span class="special">);</span></code>
+          </li></ul></div>
+<p>
+        <span class="inlinemediaobject"><img src="../../images/space.png" alt="space"></span>
+      </p>
 <a name="reference_operator_compare_equal_optional_none"></a><div class="blockquote"><blockquote class="blockquote"><p>
           <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
           <span class="special">==</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span>
           <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
         </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
+          <span class="special">==</span> <span class="special">(</span> <span class="identifier">none_t</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
+        </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
             <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">!</span><span class="identifier">x</span></code>.
           </li>
 <li class="listitem">
             <span class="bold"><strong>Notes:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
-            need not meet requirements of <code class="computeroutput"><span class="identifier">EqualityComparable</span></code>.
+            need not meet requirements of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="computeroutput"><span class="identifier">EqualityComparable</span></code></a>.
           </li>
 </ul></div>
 <p>
@@ -2032,6 +2018,10 @@
           <span class="special">!=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span>
           <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
         </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
+          <span class="special">!=</span> <span class="special">(</span> <span class="identifier">none_t</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
+        </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
             <span class="identifier">x</span> <span class="special">==</span>
@@ -2047,12 +2037,37 @@
         </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
-            <span class="bold"><strong>Effect:</strong></span> If both <code class="computeroutput"><span class="identifier">x</span></code>
-            and <code class="computeroutput"><span class="identifier">y</span></code> are initialized,
-            calls <code class="computeroutput"><span class="identifier">swap</span><span class="special">(*</span><span class="identifier">x</span><span class="special">,*</span><span class="identifier">y</span><span class="special">)</span></code>
-            using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>. If only one is initialized, say
-            <code class="computeroutput"><span class="identifier">x</span></code>, calls: <code class="computeroutput"><span class="identifier">y</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(*</span><span class="identifier">x</span><span class="special">);</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span></code>
-            If none is initialized, does nothing.
+            <span class="bold"><strong>Requires:</strong></span> Lvalues of type <code class="computeroutput"><span class="identifier">T</span></code> shall be swappable and <code class="computeroutput"><span class="identifier">T</span></code> shall be <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>.
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>Effects:</strong></span>
+            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
+<li class="listitem">
+                  If <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code>, no effect, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">rhs</span></code>, initializes the contained
+                  value of <code class="computeroutput"><span class="identifier">rhs</span></code> as
+                  if direct-initializing an object of type <code class="computeroutput"><span class="identifier">T</span></code>
+                  with the expression <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(*(*</span><span class="keyword">this</span><span class="special">))</span></code>, followed by <code class="computeroutput"><span class="identifier">val</span><span class="special">-&gt;</span><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> does not contain a value and
+                  <code class="computeroutput"><span class="identifier">rhs</span></code> contains a
+                  value, otherwise
+                </li>
+<li class="listitem">
+                  if <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>, initializes the contained value
+                  of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
+                  as if direct-initializing an object of type <code class="computeroutput"><span class="identifier">T</span></code>
+                  with the expression <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(*</span><span class="identifier">rhs</span><span class="special">)</span></code>, followed by <code class="computeroutput"><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">val</span><span class="special">-&gt;</span><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> contains a value and <code class="computeroutput"><span class="identifier">rhs</span></code> does not contain a value,
+                  otherwise
+                </li>
+<li class="listitem">
+                  (if <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+                  <span class="special">&amp;&amp;</span> <span class="keyword">bool</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">)</span></code>) calls <code class="computeroutput"><span class="identifier">swap</span><span class="special">(*(*</span><span class="keyword">this</span><span class="special">),</span> <span class="special">*</span><span class="identifier">rhs</span><span class="special">)</span></code>.
+                </li>
+</ul></div>
           </li>
 <li class="listitem">
             <span class="bold"><strong>Postconditions:</strong></span> The states of <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="identifier">y</span></code>
@@ -2064,17 +2079,6 @@
             throws. If only one is initialized, whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span></code>
             throws.
           </li>
-<li class="listitem">
-            <span class="bold"><strong>Notes:</strong></span> If both are initialized, <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code>
-            is used unqualified but with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>
-            introduced in scope. If only one is initialized, <code class="computeroutput"><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code> and <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span></code>
-            is called.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Exception Safety:</strong></span> If both are initialized,
-            this operation has the exception safety guarantees of <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code>. If only one is initialized, it
-            has the same basic guarantee as <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span></code>.
-          </li>
 <li class="listitem">
             <span class="bold"><strong>Example:</strong></span>
 <pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>

doc/html/index.html

@@ -133,7 +133,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: June 18, 2014 at 14:36:35 GMT</small></p></td>
+<td align="left"><p><small>Last revised: June 20, 2014 at 20:25:26 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

include/boost/optional/optional.hpp

@@ -112,28 +112,6 @@ class typed_in_place_factory_base ;
 template<class T> void swap ( optional<T>& x, optional<T>& y );
 
 namespace optional_detail {
-
-// converts type U to type T using only implicit conversions/constructors
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template <typename TT, typename UU>
-    TT convert(UU && u)
-    {
-        return forward<UU>(u);
-    }
-#else
-    template <typename TT, typename UU>
-    TT convert(const UU& u)
-    {
-        return u;
-    }
-    
-    template <typename TT, typename UU>
-    TT convert(UU& u)
-    {
-        return u;
-    }
-#endif
-
 // This local class is used instead of that in "aligned_storage.hpp"
 // because I've found the 'official' class to ICE BCB5.5
 // when some types are used with optional<>
@@ -1082,25 +1060,37 @@ class optional : public optional_detail::optional_base<T>
     template <class U>
     value_type value_or ( U&& v ) const&
       { 
-        return this->is_initialized() ? get() : optional_detail::convert<value_type>(boost::forward<U>(v));
+        if (this->is_initialized())
+          return get();
+        else
+          return boost::forward<U>(v);
       }
     
     template <class U>
     value_type value_or ( U&& v ) && 
       { 
-        return this->is_initialized() ? boost::move(get()) : optional_detail::convert<value_type>(boost::forward<U>(v));
+        if (this->is_initialized())
+          return boost::move(get());
+        else
+          return boost::forward<U>(v);
       }
 #elif !defined BOOST_NO_CXX11_RVALUE_REFERENCES
     template <class U>
     value_type value_or ( U&& v ) const 
-      { 
-        return this->is_initialized() ? get() : optional_detail::convert<value_type>(boost::forward<U>(v));
+      {
+        if (this->is_initialized())
+          return get();
+        else
+          return boost::forward<U>(v);
       }
 #else
     template <class U>
     value_type value_or ( U const& v ) const 
       { 
-        return this->is_initialized() ? get() : optional_detail::convert<value_type>(v);
+        if (this->is_initialized())
+          return get();
+        else
+          return v;
       }
 #endif
 
@@ -1109,19 +1099,28 @@ class optional : public optional_detail::optional_base<T>
     template <typename F>
     value_type value_or_eval ( F f ) const&
       {
-        return this->is_initialized() ? get() : optional_detail::convert<value_type>(f());
+        if (this->is_initialized())
+          return get();
+        else
+          return f();
       }
       
     template <typename F>
     value_type value_or_eval ( F f ) &&
       {
-        return this->is_initialized() ? boost::move(get()) : optional_detail::convert<value_type>(f());
+        if (this->is_initialized())
+          return boost::move(get());
+        else
+          return f();
       }
 #else
     template <typename F>
     value_type value_or_eval ( F f ) const
       {
-        return this->is_initialized() ? get() : optional_detail::convert<value_type>(f());
+        if (this->is_initialized())
+          return get();
+        else
+          return f();
       }
 #endif
       

test/optional_test_value_access.cpp

@@ -149,7 +149,7 @@ int throw_()
     throw int();
 }
 
-void test_function_value_or_call()
+void test_function_value_or_eval()
 {
     optional<int> o1 = 1;
     optional<int> oN;
@@ -237,7 +237,7 @@ int test_main( int, char* [] )
   {
     test_function_value();
     test_function_value_or();
-    test_function_value_or_call();
+    test_function_value_or_eval();
   }
   catch ( ... )
   {