include/experimental/optional

// -*- C++ -*-
//===-------------------------- optional ----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_EXPERIMENTAL_OPTIONAL
#define _LIBCPP_EXPERIMENTAL_OPTIONAL

/*
 optional synopsis

// C++1y

namespace std { namespace experimental { inline namespace fundamentals_v1 {

 // 5.3, optional for object types
 template <class T> class optional;

 // 5.4, In-place construction
 struct in_place_t{};
 constexpr in_place_t in_place{};

 // 5.5, No-value state indicator
 struct nullopt_t{see below};
 constexpr nullopt_t nullopt(unspecified);

 // 5.6, Class bad_optional_access
 class bad_optional_access;

 // 5.7, Relational operators
 template <class T>
 constexpr bool operator==(const optional<T>&, const optional<T>&);
 template <class T>
 constexpr bool operator!=(const optional<T>&, const optional<T>&);
 template <class T>
 constexpr bool operator<(const optional<T>&, const optional<T>&);
 template <class T>
 constexpr bool operator>(const optional<T>&, const optional<T>&);
 template <class T>
 constexpr bool operator<=(const optional<T>&, const optional<T>&);
 template <class T>
 constexpr bool operator>=(const optional<T>&, const optional<T>&);

 // 5.8, Comparison with nullopt
 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
 template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
 template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
 template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;

 // 5.9, Comparison with T
 template <class T> constexpr bool operator==(const optional<T>&, const T&);
 template <class T> constexpr bool operator==(const T&, const optional<T>&);
 template <class T> constexpr bool operator!=(const optional<T>&, const T&);
 template <class T> constexpr bool operator!=(const T&, const optional<T>&);
 template <class T> constexpr bool operator<(const optional<T>&, const T&);
 template <class T> constexpr bool operator<(const T&, const optional<T>&);
 template <class T> constexpr bool operator<=(const optional<T>&, const T&);
 template <class T> constexpr bool operator<=(const T&, const optional<T>&);
 template <class T> constexpr bool operator>(const optional<T>&, const T&);
 template <class T> constexpr bool operator>(const T&, const optional<T>&);
 template <class T> constexpr bool operator>=(const optional<T>&, const T&);
 template <class T> constexpr bool operator>=(const T&, const optional<T>&);

 // 5.10, Specialized algorithms
 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
 template <class T> constexpr optional<see below> make_optional(T&&);

template <class T>
class optional
{
public:
 typedef T value_type;

 // 5.3.1, Constructors
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 optional(const optional&);
 optional(optional&&) noexcept(see below);
 constexpr optional(const T&);
 constexpr optional(T&&);
 template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
 template <class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);

 // 5.3.2, Destructor
 ~optional();

 // 5.3.3, Assignment
 optional& operator=(nullopt_t) noexcept;
 optional& operator=(const optional&);
 optional& operator=(optional&&) noexcept(see below);
 template <class U> optional& operator=(U&&);
 template <class... Args> void emplace(Args&&...);
 template <class U, class... Args>
void emplace(initializer_list<U>, Args&&...);

 // 5.3.4, Swap
 void swap(optional&) noexcept(see below);

 // 5.3.5, Observers
 constexpr T const* operator ->() const;
 constexpr T* operator ->();
 constexpr T const& operator *() const &;
 constexpr T& operator *() &;
 constexpr T&& operator *() &&;
 constexpr const T&& operator *() const &&;
 constexpr explicit operator bool() const noexcept;
 constexpr T const& value() const &;
 constexpr T& value() &;
 constexpr T&& value() &&;
 constexpr const T&& value() const &&;
 template <class U> constexpr T value_or(U&&) const &;
 template <class U> constexpr T value_or(U&&) &&;

private:
 T* val; // exposition only
};

 } // namespace fundamentals_v1
 } // namespace experimental

 // 5.11, Hash support
 template <class T> struct hash;
 template <class T> struct hash<experimental::optional<T>>;

} // namespace std

*/

#include <experimental/__config>
#include <functional>
#include <stdexcept>
#if _LIBCPP_STD_VER > 11
#include <initializer_list>
#include <type_traits>
#include <new>
#include <__functional_base>
#include <__debug>
#endif

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

_LIBCPP_PUSH_MACROS
#include <__undef_macros>


_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
 : public std::logic_error
{
public:
bad_optional_access() : std::logic_error("Bad optional Access") {}

//	Get the key function ~bad_optional_access() into the dylib
 virtual ~bad_optional_access() _NOEXCEPT;
};

_LIBCPP_END_NAMESPACE_EXPERIMENTAL


#if _LIBCPP_STD_VER > 11

_LIBCPP_BEGIN_NAMESPACE_LFTS

struct in_place_t {};
constexpr in_place_t in_place{};

struct nullopt_t
{
 explicit constexpr nullopt_t(int) noexcept {}
};

constexpr nullopt_t nullopt{0};

template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
class __optional_storage
{
protected:
 typedef _Tp value_type;
 union
 {
 char __null_state_;
 value_type __val_;
 };
 bool __engaged_ = false;

 _LIBCPP_INLINE_VISIBILITY
 ~__optional_storage()
 {
 if (__engaged_)
 __val_.~value_type();
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage() noexcept
 : __null_state_('\0') {}

 _LIBCPP_INLINE_VISIBILITY
 __optional_storage(const __optional_storage& __x)
 : __engaged_(__x.__engaged_)
 {
 if (__engaged_)
 ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
 }

 _LIBCPP_INLINE_VISIBILITY
 __optional_storage(__optional_storage&& __x)
 noexcept(is_nothrow_move_constructible<value_type>::value)
 : __engaged_(__x.__engaged_)
 {
 if (__engaged_)
 ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage(const value_type& __v)
 : __val_(__v),
 __engaged_(true) {}

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage(value_type&& __v)
 : __val_(_VSTD::move(__v)),
 __engaged_(true) {}

 template <class... _Args>
 _LIBCPP_INLINE_VISIBILITY
 constexpr
 explicit __optional_storage(in_place_t, _Args&&... __args)
 : __val_(_VSTD::forward<_Args>(__args)...),
 __engaged_(true) {}
};

template <class _Tp>
class __optional_storage<_Tp, true>
{
protected:
 typedef _Tp value_type;
 union
 {
 char __null_state_;
 value_type __val_;
 };
 bool __engaged_ = false;

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage() noexcept
 : __null_state_('\0') {}

 _LIBCPP_INLINE_VISIBILITY
 __optional_storage(const __optional_storage& __x)
 : __engaged_(__x.__engaged_)
 {
 if (__engaged_)
 ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
 }

 _LIBCPP_INLINE_VISIBILITY
 __optional_storage(__optional_storage&& __x)
 noexcept(is_nothrow_move_constructible<value_type>::value)
 : __engaged_(__x.__engaged_)
 {
 if (__engaged_)
 ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage(const value_type& __v)
 : __val_(__v),
 __engaged_(true) {}

 _LIBCPP_INLINE_VISIBILITY
 constexpr __optional_storage(value_type&& __v)
 : __val_(_VSTD::move(__v)),
 __engaged_(true) {}

 template <class... _Args>
 _LIBCPP_INLINE_VISIBILITY
 constexpr
 explicit __optional_storage(in_place_t, _Args&&... __args)
 : __val_(_VSTD::forward<_Args>(__args)...),
 __engaged_(true) {}
};

template <class _Tp>
class optional
 : private __optional_storage<_Tp>
{
 typedef __optional_storage<_Tp> __base;
public:
 typedef _Tp value_type;

 static_assert(!is_reference<value_type>::value,
 "Instantiation of optional with a reference type is ill-formed.");
 static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value,
 "Instantiation of optional with a in_place_t type is ill-formed.");
 static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value,
 "Instantiation of optional with a nullopt_t type is ill-formed.");
 static_assert(is_object<value_type>::value,
 "Instantiation of optional with a non-object type is undefined behavior.");
 static_assert(is_nothrow_destructible<value_type>::value,
 "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");

 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
 _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
 _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
 _LIBCPP_INLINE_VISIBILITY ~optional() = default;
 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
 _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v)
 : __base(__v) {}
 _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v)
 : __base(_VSTD::move(__v)) {}

 template <class... _Args,
 class = typename enable_if
 <
 is_constructible<value_type, _Args...>::value
 >::type
 >
 _LIBCPP_INLINE_VISIBILITY
 constexpr
 explicit optional(in_place_t, _Args&&... __args)
 : __base(in_place, _VSTD::forward<_Args>(__args)...) {}

 template <class _Up, class... _Args,
 class = typename enable_if
 <
 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
 >::type
 >
 _LIBCPP_INLINE_VISIBILITY
 constexpr
 explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}

 _LIBCPP_INLINE_VISIBILITY
 optional& operator=(nullopt_t) noexcept
 {
 if (this->__engaged_)
 {
 this->__val_.~value_type();
 this->__engaged_ = false;
 }
 return *this;
 }

 _LIBCPP_INLINE_VISIBILITY
 optional&
 operator=(const optional& __opt)
 {
 if (this->__engaged_ == __opt.__engaged_)
 {
 if (this->__engaged_)
 this->__val_ = __opt.__val_;
 }
 else
 {
 if (this->__engaged_)
 this->__val_.~value_type();
 else
 ::new((void*)_VSTD::addressof(this->__val_)) value_type(__opt.__val_);
 this->__engaged_ = __opt.__engaged_;
 }
 return *this;
 }

 _LIBCPP_INLINE_VISIBILITY
 optional&
 operator=(optional&& __opt)
 noexcept(is_nothrow_move_assignable<value_type>::value &&
 is_nothrow_move_constructible<value_type>::value)
 {
 if (this->__engaged_ == __opt.__engaged_)
 {
 if (this->__engaged_)
 this->__val_ = _VSTD::move(__opt.__val_);
 }
 else
 {
 if (this->__engaged_)
 this->__val_.~value_type();
 else
 ::new((void*)_VSTD::addressof(this->__val_))
 value_type(_VSTD::move(__opt.__val_));
 this->__engaged_ = __opt.__engaged_;
 }
 return *this;
 }

 template <class _Up,
 class = typename enable_if
 <
 is_same<typename remove_reference<_Up>::type, value_type>::value &&
 is_constructible<value_type, _Up>::value &&
 is_assignable<value_type&, _Up>::value
 >::type
 >
 _LIBCPP_INLINE_VISIBILITY
 optional&
 operator=(_Up&& __v)
 {
 if (this->__engaged_)
 this->__val_ = _VSTD::forward<_Up>(__v);
 else
 {
 ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
 this->__engaged_ = true;
 }
 return *this;
 }

 template <class... _Args,
 class = typename enable_if
 <
 is_constructible<value_type, _Args...>::value
 >::type
 >
 _LIBCPP_INLINE_VISIBILITY
 void
 emplace(_Args&&... __args)
 {
 *this = nullopt;
 ::new((void*)_VSTD::addressof(this->__val_))
 value_type(_VSTD::forward<_Args>(__args)...);
 this->__engaged_ = true;
 }

 template <class _Up, class... _Args,
 class = typename enable_if
 <
 is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
 >::type
 >
 _LIBCPP_INLINE_VISIBILITY
 void
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 {
 *this = nullopt;
 ::new((void*)_VSTD::addressof(this->__val_))
 value_type(__il, _VSTD::forward<_Args>(__args)...);
 this->__engaged_ = true;
 }

 _LIBCPP_INLINE_VISIBILITY
 void
 swap(optional& __opt)
 noexcept(is_nothrow_move_constructible<value_type>::value &&
 __is_nothrow_swappable<value_type>::value)
 {
 using _VSTD::swap;
 if (this->__engaged_ == __opt.__engaged_)
 {
 if (this->__engaged_)
 swap(this->__val_, __opt.__val_);
 }
 else
 {
 if (this->__engaged_)
 {
 ::new((void*)_VSTD::addressof(__opt.__val_))
 value_type(_VSTD::move(this->__val_));
 this->__val_.~value_type();
 }
 else
 {
 ::new((void*)_VSTD::addressof(this->__val_))
 value_type(_VSTD::move(__opt.__val_));
 __opt.__val_.~value_type();
 }
 swap(this->__engaged_, __opt.__engaged_);
 }
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr
 value_type const*
 operator->() const
 {
 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
 return __builtin_addressof(this->__val_);
#else
 return __operator_arrow(__has_operator_addressof<value_type>{});
#endif
 }

 _LIBCPP_INLINE_VISIBILITY
 value_type*
 operator->()
 {
 _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
 return _VSTD::addressof(this->__val_);
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr
 const value_type&
 operator*() const
 {
 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
 return this->__val_;
 }

 _LIBCPP_INLINE_VISIBILITY
 value_type&
 operator*()
 {
 _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
 return this->__val_;
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr explicit operator bool() const noexcept {return this->__engaged_;}

_LIBCPP_NORETURN _LIBCPP_INLINE_VISIBILITY 
#ifndef _LIBCPP_NO_EXCEPTIONS
_LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
#endif
constexpr void __throw_bad_optional_access() const
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 throw bad_optional_access();
#else
 _VSTD::abort();
#endif
}

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 constexpr value_type const& value() const
 {
 if (!this->__engaged_)
 __throw_bad_optional_access();
 return this->__val_;
 }

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 value_type& value()
 {
 if (!this->__engaged_)
 __throw_bad_optional_access();
 return this->__val_;
 }

 template <class _Up>
 _LIBCPP_INLINE_VISIBILITY
 constexpr value_type value_or(_Up&& __v) const&
 {
 static_assert(is_copy_constructible<value_type>::value,
 "optional<T>::value_or: T must be copy constructible");
 static_assert(is_convertible<_Up, value_type>::value,
 "optional<T>::value_or: U must be convertible to T");
 return this->__engaged_ ? this->__val_ :
 static_cast<value_type>(_VSTD::forward<_Up>(__v));
 }

 template <class _Up>
 _LIBCPP_INLINE_VISIBILITY
 value_type value_or(_Up&& __v) &&
 {
 static_assert(is_move_constructible<value_type>::value,
 "optional<T>::value_or: T must be move constructible");
 static_assert(is_convertible<_Up, value_type>::value,
 "optional<T>::value_or: U must be convertible to T");
 return this->__engaged_ ? _VSTD::move(this->__val_) :
 static_cast<value_type>(_VSTD::forward<_Up>(__v));
 }

private:
 _LIBCPP_INLINE_VISIBILITY
 value_type const*
 __operator_arrow(true_type) const
 {
 return _VSTD::addressof(this->__val_);
 }

 _LIBCPP_INLINE_VISIBILITY
 constexpr
 value_type const*
 __operator_arrow(false_type) const
 {
 return &this->__val_;
 }
};

// Comparisons between optionals
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 if (static_cast<bool>(__x) != static_cast<bool>(__y))
 return false;
 if (!static_cast<bool>(__x))
 return true;
 return *__x == *__y;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 return !(__x == __y);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 if (!static_cast<bool>(__y))
 return false;
 if (!static_cast<bool>(__x))
 return true;
 return *__x < *__y;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 return __y < __x;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 return !(__y < __x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
 return !(__x < __y);
}


// Comparisons with nullopt
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, nullopt_t) noexcept
{
 return !static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(nullopt_t, const optional<_Tp>& __x) noexcept
{
 return !static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
{
 return static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
{
 return static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>&, nullopt_t) noexcept
{
 return false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(nullopt_t, const optional<_Tp>& __x) noexcept
{
 return static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
{
 return !static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(nullopt_t, const optional<_Tp>&) noexcept
{
 return true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, nullopt_t) noexcept
{
 return static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(nullopt_t, const optional<_Tp>&) noexcept
{
 return false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>&, nullopt_t) noexcept
{
 return true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
{
 return !static_cast<bool>(__x);
}

// Comparisons with T
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, const _Tp& __v)
{
 return static_cast<bool>(__x) ? *__x == __v : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const _Tp& __v, const optional<_Tp>& __x)
{
 return static_cast<bool>(__x) ? *__x == __v : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, const _Tp& __v)
{
 return static_cast<bool>(__x) ? !(*__x == __v) : true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const _Tp& __v, const optional<_Tp>& __x)
{
 return static_cast<bool>(__x) ? !(*__x == __v) : true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>& __x, const _Tp& __v)
{
 return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const _Tp& __v, const optional<_Tp>& __x)
{
 return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, const _Tp& __v)
{
 return !(__x > __v);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const _Tp& __v, const optional<_Tp>& __x)
{
 return !(__v > __x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, const _Tp& __v)
{
 return static_cast<bool>(__x) ? __v < __x : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const _Tp& __v, const optional<_Tp>& __x)
{
 return static_cast<bool>(__x) ? __x < __v : true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>& __x, const _Tp& __v)
{
 return !(__x < __v);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const _Tp& __v, const optional<_Tp>& __x)
{
 return !(__v < __x);
}


template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
{
 __x.swap(__y);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
optional<typename decay<_Tp>::type>
make_optional(_Tp&& __v)
{
 return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
}

_LIBCPP_END_NAMESPACE_LFTS

_LIBCPP_BEGIN_NAMESPACE_STD

template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::optional<_Tp> >
{
 typedef std::experimental::optional<_Tp> argument_type;
 typedef size_t result_type;

 _LIBCPP_INLINE_VISIBILITY
 result_type operator()(const argument_type& __opt) const _NOEXCEPT
 {
 return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
 }
};

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP_STD_VER > 11

_LIBCPP_POP_MACROS

#endif // _LIBCPP_EXPERIMENTAL_OPTIONAL