ah compiles better

@@ -50,6 +50,7 @@ project "TEngine"
 	if _OPTIONS.relpath == "64" then defines{"TE4_RELPATH64"} end
 
 	links { "m" }
+	links { "stdc++" }
 	cppconfig()
 
 	if _OPTIONS.no_rwops_size then defines{"NO_RWOPS_SIZE"} end

@@ -71,16 +71,8 @@ configuration "windows"
  	}
 end
 
-function cppconfig(what)
-	links { "stdc++" }
-end
-
-configuration "macosx"
-	premake.gcc.cc  = 'clang'
-	premake.gcc.cxx = 'clang++'
-
-	buildoptions { "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk", "-mmacosx-version-min=10.7" }
-	function cppconfig(what)
+cppconfig = function(what)
+	if os.get() == "macosx" then
 		if what == "web" then
 			buildoptions { "-stdlib=libstdc++" }
 			linkoptions { "-stdlib=libstdc++" }
@@ -88,8 +80,15 @@ configuration "macosx"
 			buildoptions { "-stdlib=libc++" }
 			linkoptions { "-stdlib=libc++" }
 		end
-		links { "stdc++" }
 	end
+	-- links { "stdc++" }
+end
+
+configuration "macosx"
+	premake.gcc.cc  = 'clang'
+	premake.gcc.cxx = 'clang++'
+
+	buildoptions { "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk", "-mmacosx-version-min=10.7" }
 	includedirs {
                         "/Library/Frameworks/SDL2.framework/Headers",
                         "/Library/Frameworks/SDL2_image.framework/Headers",

@@ -93,7 +93,7 @@ static void generate_table_from_output(lua_State *L, WFCOverlapping *config) {
 static bool wfc_generate_overlapping(WFCOverlapping *config) {
 	OverlappingWFCOptions options = {config->periodic_in, config->periodic_out, config->output.height, config->output.width, config->symmetry, config->has_foundation, config->n};
 	OverlappingWFC<char> wfc(config->sample, options, gen_rand32());
-	cl::optional<Array2D<char>> success = wfc.run();
+	nonstd::optional<Array2D<char>> success = wfc.run();
 	if (success.has_value()) {
 		config->output.import(success.value());
 		return true;

-// Copyright (c) 2016, Charles Lechasseur
-// Distributed under the MIT license (see LICENSE).
+//
+// Copyright (c) 2014-2018 Martin Moene
+//
+// https://github.com/martinmoene/optional-lite
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-// Implementation of C++17's std::optional
+#pragma once
 
-#ifndef CL_OPTIONAL_H
-#define CL_OPTIONAL_H
+#ifndef NONSTD_OPTIONAL_LITE_HPP
+#define NONSTD_OPTIONAL_LITE_HPP
 
-#include <functional>
+#define optional_lite_MAJOR  3
+#define optional_lite_MINOR  1
+#define optional_lite_PATCH  1
+
+#define optional_lite_VERSION  optional_STRINGIFY(optional_lite_MAJOR) "." optional_STRINGIFY(optional_lite_MINOR) "." optional_STRINGIFY(optional_lite_PATCH)
+
+#define optional_STRINGIFY(  x )  optional_STRINGIFY_( x )
+#define optional_STRINGIFY_( x )  #x
+
+// optional-lite configuration:
+
+#define optional_OPTIONAL_DEFAULT  0
+#define optional_OPTIONAL_NONSTD   1
+#define optional_OPTIONAL_STD      2
+
+#if !defined( optional_CONFIG_SELECT_OPTIONAL )
+# define optional_CONFIG_SELECT_OPTIONAL  ( optional_HAVE_STD_OPTIONAL ? optional_OPTIONAL_STD : optional_OPTIONAL_NONSTD )
+#endif
+
+// C++ language version detection (C++20 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef   optional_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+#  define optional_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+#  define optional_CPLUSPLUS  __cplusplus
+# endif
+#endif
+
+#define optional_CPP98_OR_GREATER  ( optional_CPLUSPLUS >= 199711L )
+#define optional_CPP11_OR_GREATER  ( optional_CPLUSPLUS >= 201103L )
+#define optional_CPP11_OR_GREATER_ ( optional_CPLUSPLUS >= 201103L )
+#define optional_CPP14_OR_GREATER  ( optional_CPLUSPLUS >= 201402L )
+#define optional_CPP17_OR_GREATER  ( optional_CPLUSPLUS >= 201703L )
+#define optional_CPP20_OR_GREATER  ( optional_CPLUSPLUS >= 202000L )
+
+// C++ language version (represent 98 as 3):
+
+#define optional_CPLUSPLUS_V  ( optional_CPLUSPLUS / 100 - (optional_CPLUSPLUS > 200000 ? 2000 : 1994) )
+
+// Use C++17 std::optional if available and requested:
+
+#if optional_CPP17_OR_GREATER && defined(__has_include )
+# if __has_include( <optional> )
+#  define optional_HAVE_STD_OPTIONAL  1
+# else
+#  define optional_HAVE_STD_OPTIONAL  0
+# endif
+#else
+# define  optional_HAVE_STD_OPTIONAL  0
+#endif
+
+#define optional_USES_STD_OPTIONAL  ( (optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_STD) || ((optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_DEFAULT) && optional_HAVE_STD_OPTIONAL) )
+
+//
+// in_place: code duplicated in any-lite, expected-lite, optional-lite, value-ptr-lite, variant-lite:
+//
+
+#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
+#define nonstd_lite_HAVE_IN_PLACE_TYPES  1
+
+// C++17 std::in_place in <utility>:
+
+#if optional_CPP17_OR_GREATER
+
+#include <utility>
+
+namespace nonstd {
+
+using std::in_place;
+using std::in_place_type;
+using std::in_place_index;
+using std::in_place_t;
+using std::in_place_type_t;
+using std::in_place_index_t;
+
+#define nonstd_lite_in_place_t(      T)  std::in_place_t
+#define nonstd_lite_in_place_type_t( T)  std::in_place_type_t<T>
+#define nonstd_lite_in_place_index_t(K)  std::in_place_index_t<K>
+
+#define nonstd_lite_in_place(      T)    std::in_place_t{}
+#define nonstd_lite_in_place_type( T)    std::in_place_type_t<T>{}
+#define nonstd_lite_in_place_index(K)    std::in_place_index_t<K>{}
+
+} // namespace nonstd
+
+#else // optional_CPP17_OR_GREATER
+
+#include <cstddef>
+
+namespace nonstd {
+namespace detail {
+
+template< class T >
+struct in_place_type_tag {};
+
+template< std::size_t K >
+struct in_place_index_tag {};
+
+} // namespace detail
+
+struct in_place_t {};
+
+template< class T >
+inline in_place_t in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
+{
+    return in_place_t();
+}
+
+template< std::size_t K >
+inline in_place_t in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
+{
+    return in_place_t();
+}
+
+template< class T >
+inline in_place_t in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
+{
+    return in_place_t();
+}
+
+template< std::size_t K >
+inline in_place_t in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
+{
+    return in_place_t();
+}
+
+// mimic templated typedef:
+
+#define nonstd_lite_in_place_t(      T)  nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T>  )
+#define nonstd_lite_in_place_type_t( T)  nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T>  )
+#define nonstd_lite_in_place_index_t(K)  nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
+
+#define nonstd_lite_in_place(      T)    nonstd::in_place_type<T>
+#define nonstd_lite_in_place_type( T)    nonstd::in_place_type<T>
+#define nonstd_lite_in_place_index(K)    nonstd::in_place_index<K>
+
+} // namespace nonstd
+
+#endif // optional_CPP17_OR_GREATER
+#endif // nonstd_lite_HAVE_IN_PLACE_TYPES
+
+//
+// Using std::optional:
+//
+
+#if optional_USES_STD_OPTIONAL
+
+#include <optional>
+
+namespace nonstd {
+
+    using std::optional;
+    using std::bad_optional_access;
+    using std::hash;
+
+    using std::nullopt;
+    using std::nullopt_t;
+
+    using std::operator==;
+    using std::operator!=;
+    using std::operator<;
+    using std::operator<=;
+    using std::operator>;
+    using std::operator>=;
+    using std::make_optional;
+    using std::swap;
+}
+
+#else // optional_USES_STD_OPTIONAL
+
+#include <cassert>
 #include <stdexcept>
-#include <string>
-#include <type_traits>
 #include <utility>
 
+// optional-lite alignment configuration:
+
+#ifndef  optional_CONFIG_MAX_ALIGN_HACK
+# define optional_CONFIG_MAX_ALIGN_HACK  0
+#endif
+
+#ifndef  optional_CONFIG_ALIGN_AS
+// no default, used in #if defined()
+#endif
+
+#ifndef  optional_CONFIG_ALIGN_AS_FALLBACK
+# define optional_CONFIG_ALIGN_AS_FALLBACK  double
+#endif
+
+// Compiler warning suppression:
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wundef"
+#elif defined(__GNUC__)
+# pragma GCC   diagnostic push
+# pragma GCC   diagnostic ignored "-Wundef"
+#endif
+
+// half-open range [lo..hi):
+#define optional_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
+
+// Compiler versions:
+//
+// MSVC++ 6.0  _MSC_VER == 1200 (Visual Studio 6.0)
+// MSVC++ 7.0  _MSC_VER == 1300 (Visual Studio .NET 2002)
+// MSVC++ 7.1  _MSC_VER == 1310 (Visual Studio .NET 2003)
+// MSVC++ 8.0  _MSC_VER == 1400 (Visual Studio 2005)
+// MSVC++ 9.0  _MSC_VER == 1500 (Visual Studio 2008)
+// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
+// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
+// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+// MSVC++ 14.1 _MSC_VER >= 1910 (Visual Studio 2017)
+
+#if defined(_MSC_VER ) && !defined(__clang__)
+# define optional_COMPILER_MSVC_VER      (_MSC_VER )
+# define optional_COMPILER_MSVC_VERSION  (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
+#else
+# define optional_COMPILER_MSVC_VER      0
+# define optional_COMPILER_MSVC_VERSION  0
+#endif
+
+#define optional_COMPILER_VERSION( major, minor, patch )  ( 10 * (10 * major + minor ) + patch )
 
-// Compiler detection
-#if defined(_MSC_VER)
-#   if _MSC_VER >= 1800 // Visual Studio 2013
-#       define CL_OPTIONAL_VARIADIC
-#       define CL_OPTIONAL_EXPLICIT_OP_BOOL
-#       define CL_OPTIONAL_TEMPLATE_FUNCS_DEFAULT_PARAMS
-#   endif
-#   if _MSC_VER >= 1900 // Visual Studio 2015
-#       define CL_OPTIONAL_NORETURN
-#       define CL_OPTIONAL_MEMBERS_REF_QUALIFIERS
-#   endif
-#   if _MSC_VER >= 1910 // Visual Studio 2017
-#       define CL_OPTIONAL_NOEXCEPT     // Note: in theory this is supported in VC14, but a bug in VC14 update 3 can cause compiler errors
-#       define CL_OPTIONAL_CONSTEXPR
-#   endif
-#elif defined(__clang__)
-#   if __has_feature(cxx_noexcept)
-#       define CL_OPTIONAL_NOEXCEPT
-#   endif
-#   if __has_feature(cxx_constexpr) && __cplusplus >= 201402L
-#       define CL_OPTIONAL_CONSTEXPR
-#   endif
-#   if __has_feature(cxx_attributes)
-#       define CL_OPTIONAL_NORETURN
-#   endif
-#   if __has_feature(cxx_variadic_templates)
-#       define CL_OPTIONAL_VARIADIC
-#   endif
-#   if __has_feature(cxx_reference_qualified_functions) && __cplusplus >= 201402L
-#       define CL_OPTIONAL_MEMBERS_REF_QUALIFIERS
-#   endif
-#   if __has_feature(cxx_explicit_conversions)
-#       define CL_OPTIONAL_EXPLICIT_OP_BOOL
-#   endif
-#   if __has_feature(cxx_default_function_template_args)
-#       define CL_OPTIONAL_TEMPLATE_FUNCS_DEFAULT_PARAMS
-#   endif
-#elif defined(__GNUG__)
-#   if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-#       define CL_OPTIONAL_NOEXCEPT
-#       define CL_OPTIONAL_NORETURN
-#       define CL_OPTIONAL_VARIADIC
-#       define CL_OPTIONAL_MEMBERS_REF_QUALIFIERS
-#       define CL_OPTIONAL_EXPLICIT_OP_BOOL
-#       define CL_OPTIONAL_TEMPLATE_FUNCS_DEFAULT_PARAMS
-#   endif
-#   if __GNUC__ >= 5
-#       define CL_OPTIONAL_CONSTEXPR
-#   endif
-#endif
-
-
-// Define CL_OPTIONAL_NOEXCEPT to get noexcept specifications
-#ifdef CL_OPTIONAL_NOEXCEPT
-#   define _CL_OPT_NOEXCEPT         noexcept
-#   define _CL_OPT_NOEXCEPTEX(...)  noexcept(__VA_ARGS__)
+#if defined(__GNUC__) && !defined(__clang__)
+# define optional_COMPILER_GNUC_VERSION   optional_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 #else
-#   define _CL_OPT_NOEXCEPT
-#   define _CL_OPT_NOEXCEPTEX(...)
+# define optional_COMPILER_GNUC_VERSION   0
 #endif
 
-// Define CL_OPTIONAL_CONSTEXPR to get constexpr specifications
-#ifdef CL_OPTIONAL_CONSTEXPR
-#   define _CL_OPT_CONSTEXPR            constexpr
-#   define _CL_OPT_CONSTEXPR_OR_CONST   constexpr
+#if defined(__clang__)
+# define optional_COMPILER_CLANG_VERSION  optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 #else
-#   define _CL_OPT_CONSTEXPR
-#   define _CL_OPT_CONSTEXPR_OR_CONST   const
+# define optional_COMPILER_CLANG_VERSION  0
+#endif
+
+#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 140 )
+# pragma warning( push )
+# pragma warning( disable: 4345 )   // initialization behavior changed
+#endif
+
+#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 150 )
+# pragma warning( push )
+# pragma warning( disable: 4814 )   // in C++14 'constexpr' will not imply 'const'
 #endif
 
-// Define CL_OPTIONAL_VARIADIC to get variadic templates
-#ifdef CL_OPTIONAL_VARIADIC
-#   define _CL_OPT_VARIADIC 1
+// Presence of language and library features:
+
+#define optional_HAVE(FEATURE) ( optional_HAVE_##FEATURE )
+
+#ifdef _HAS_CPP0X
+# define optional_HAS_CPP0X  _HAS_CPP0X
+#else
+# define optional_HAS_CPP0X  0
+#endif
+
+// Unless defined otherwise below, consider VC14 as C++11 for optional-lite:
+
+#if optional_COMPILER_MSVC_VER >= 1900
+# undef  optional_CPP11_OR_GREATER
+# define optional_CPP11_OR_GREATER  1
+#endif
+
+#define optional_CPP11_90   (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1500)
+#define optional_CPP11_100  (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1600)
+#define optional_CPP11_110  (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1700)
+#define optional_CPP11_120  (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1800)
+#define optional_CPP11_140  (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1900)
+#define optional_CPP11_141  (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1910)
+
+#define optional_CPP14_000  (optional_CPP14_OR_GREATER)
+#define optional_CPP17_000  (optional_CPP17_OR_GREATER)
+
+// Presence of C++11 language features:
+
+#define optional_HAVE_CONSTEXPR_11      optional_CPP11_140
+#define optional_HAVE_NOEXCEPT          optional_CPP11_140
+#define optional_HAVE_NULLPTR           optional_CPP11_100
+#define optional_HAVE_REF_QUALIFIER     optional_CPP11_140
+
+// Presence of C++14 language features:
+
+#define optional_HAVE_CONSTEXPR_14      optional_CPP14_000
+
+// Presence of C++17 language features:
+
+// no flag
+
+// Presence of C++ library features:
+
+#define optional_HAVE_CONDITIONAL       optional_CPP11_120
+#define optional_HAVE_REMOVE_CV         optional_CPP11_120
+#define optional_HAVE_TYPE_TRAITS       optional_CPP11_90
+
+#define optional_HAVE_TR1_TYPE_TRAITS   (!! optional_COMPILER_GNUC_VERSION )
+#define optional_HAVE_TR1_ADD_POINTER   (!! optional_COMPILER_GNUC_VERSION )
+
+// C++ feature usage:
+
+#if optional_HAVE( CONSTEXPR_11 )
+# define optional_constexpr  constexpr
 #else
-#   define _CL_OPT_VARIADIC 0
+# define optional_constexpr  /*constexpr*/
 #endif
 
-// Define CL_OPTIONAL_NORETURN to get noreturn specifications
-#ifdef CL_OPTIONAL_NORETURN
-#   define _CL_OPT_NORETURN [[noreturn]]
+#if optional_HAVE( CONSTEXPR_14 )
+# define optional_constexpr14  constexpr
 #else
-#   define _CL_OPT_NORETURN
+# define optional_constexpr14  /*constexpr*/
 #endif
 
-// Define CL_OPTIONAL_MEMBERS_REF_QUALIFIERS to get lvalue- and rvalue-qualified members
-#ifdef CL_OPTIONAL_MEMBERS_REF_QUALIFIERS
-#   define _CL_OPT_MEMBERS_REF_QUALIFIERS   1
-#   define _CL_OPT_LVALUE_REF_QUALIF        &
+#if optional_HAVE( NOEXCEPT )
+# define optional_noexcept  noexcept
 #else
-#   define _CL_OPT_MEMBERS_REF_QUALIFIERS   0
-#   define _CL_OPT_LVALUE_REF_QUALIF
+# define optional_noexcept  /*noexcept*/
 #endif
 
-// Define CL_OPTIONAL_EXPLICIT_OP_BOOL to get explicit operator bool()
-#ifdef CL_OPTIONAL_EXPLICIT_OP_BOOL
-#   define _CL_OPT_OP_EXPLICIT  explicit
+#if optional_HAVE( NULLPTR )
+# define optional_nullptr  nullptr
 #else
-#   define _CL_OPT_OP_EXPLICIT
+# define optional_nullptr  NULL
 #endif
 
-// Define CL_OPTIONAL_TEMPLATE_FUNCS_DEFAULT_PARAMS to get template methods
-// with default template params, like assignment operator from value
-#ifdef CL_OPTIONAL_TEMPLATE_FUNCS_DEFAULT_PARAMS
-#   define _CL_OPT_TEMPL_FUNC_DEF_PARAMS    1
+#if optional_HAVE( REF_QUALIFIER )
+# define optional_ref_qual  &
+# define optional_refref_qual  &&
 #else
-#   define _CL_OPT_TEMPL_FUNC_DEF_PARAMS    0
+# define optional_ref_qual  /*&*/
+# define optional_refref_qual  /*&&*/
+#endif
+
+// additional includes:
+
+#if optional_CPP11_OR_GREATER
+# include <functional>
+#endif
+
+#if optional_HAVE( INITIALIZER_LIST )
+# include <initializer_list>
 #endif
 
+#if optional_HAVE( TYPE_TRAITS )
+# include <type_traits>
+#elif optional_HAVE( TR1_TYPE_TRAITS )
+# include <tr1/type_traits>
+#endif
+
+// Method enabling
+
+#if optional_CPP11_OR_GREATER
+
+# define optional_REQUIRES_T(...) \
+    , typename = typename std::enable_if<__VA_ARGS__>::type
+
+# define optional_REQUIRES_R(R, ...) \
+    typename std::enable_if<__VA_ARGS__, R>::type
+
+# define optional_REQUIRES_A(...) \
+    , typename std::enable_if<__VA_ARGS__, void*>::type = optional_nullptr
 
-#if _CL_OPT_VARIADIC
-#   include <initializer_list>
 #endif
 
-namespace cl {
+//
+// optional:
+//
+
+namespace nonstd { namespace optional_lite {
+
+namespace detail {
 
-// Type indicating an optional object with no value. See:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
-struct nullopt_t {
-    _CL_OPT_CONSTEXPR nullopt_t(int) { }
+#if optional_HAVE( CONDITIONAL )
+    using std::conditional;
+#else
+    template< bool B, typename T, typename F > struct conditional              { typedef T type; };
+    template<         typename T, typename F > struct conditional<false, T, F> { typedef F type; };
+#endif // optional_HAVE_CONDITIONAL
+
+} // namespace detail
+
+#if optional_CPP11_OR_GREATER
+
+namespace std20 {
+
+// type traits C++20:
+
+template< typename T >
+struct remove_cvref
+{
+    typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;
 };
 
-// Instance of nullopt_t passed to optional's members. See:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt
-_CL_OPT_CONSTEXPR_OR_CONST nullopt_t nullopt = 0;
+} // namespace std20
 
-#if _CL_OPT_VARIADIC
-// Empty type used for in_place functions. See:
-// http://en.cppreference.com/w/cpp/utility/in_place_tag
-struct in_place_tag {
-    in_place_tag() = delete;
-private:
-    in_place_tag(int) { }
-    friend in_place_tag in_place();
+#endif // optional_CPP11_OR_GREATER
+
+/// class optional
+
+template< typename T >
+class optional;
+
+namespace detail {
+
+// C++11 emulation:
+
+struct nulltype{};
+
+template< typename Head, typename Tail >
+struct typelist
+{
+    typedef Head head;
+    typedef Tail tail;
 };
 
-// Function to identify an optional method with in-place construction. See:
-// http://en.cppreference.com/w/cpp/utility/in_place
-inline in_place_tag in_place() { return in_place_tag(0); }
-using in_place_t = in_place_tag (&)();
-#endif // _CL_OPT_VARIADIC
+#if optional_CONFIG_MAX_ALIGN_HACK
 
-// Exception thrown by optional when trying to access
-// an optional with no value. See:
-// http://en.cppreference.com/w/cpp/utility/optional/bad_optional_access
-class bad_optional_access : public std::logic_error
+// Max align, use most restricted type for alignment:
+
+#define optional_UNIQUE(  name )       optional_UNIQUE2( name, __LINE__ )
+#define optional_UNIQUE2( name, line ) optional_UNIQUE3( name, line )
+#define optional_UNIQUE3( name, line ) name ## line
+
+#define optional_ALIGN_TYPE( type ) \
+    type optional_UNIQUE( _t ); struct_t< type > optional_UNIQUE( _st )
+
+template< typename T >
+struct struct_t { T _; };
+
+union max_align_t
 {
-public:
-    bad_optional_access(const std::string& what_arg)
-        : std::logic_error(what_arg) { }
-    bad_optional_access(const char* what_arg)
-        : std::logic_error(what_arg) { }
+    optional_ALIGN_TYPE( char );
+    optional_ALIGN_TYPE( short int );
+    optional_ALIGN_TYPE( int );
+    optional_ALIGN_TYPE( long int  );
+    optional_ALIGN_TYPE( float  );
+    optional_ALIGN_TYPE( double );
+    optional_ALIGN_TYPE( long double );
+    optional_ALIGN_TYPE( char * );
+    optional_ALIGN_TYPE( short int * );
+    optional_ALIGN_TYPE( int *  );
+    optional_ALIGN_TYPE( long int * );
+    optional_ALIGN_TYPE( float * );
+    optional_ALIGN_TYPE( double * );
+    optional_ALIGN_TYPE( long double * );
+    optional_ALIGN_TYPE( void * );
+
+#ifdef HAVE_LONG_LONG
+    optional_ALIGN_TYPE( long long );
+#endif
+
+    struct Unknown;
+
+    Unknown ( * optional_UNIQUE(_) )( Unknown );
+    Unknown * Unknown::* optional_UNIQUE(_);
+    Unknown ( Unknown::* optional_UNIQUE(_) )( Unknown );
+
+    struct_t< Unknown ( * )( Unknown)         > optional_UNIQUE(_);
+    struct_t< Unknown * Unknown::*            > optional_UNIQUE(_);
+    struct_t< Unknown ( Unknown::* )(Unknown) > optional_UNIQUE(_);
 };
 
-// Wrapper for an optional value. Part of future C++17 API. See:
-// http://en.cppreference.com/w/cpp/utility/optional
-template<typename T>
-class optional
+#undef optional_UNIQUE
+#undef optional_UNIQUE2
+#undef optional_UNIQUE3
+
+#undef optional_ALIGN_TYPE
+
+#elif defined( optional_CONFIG_ALIGN_AS ) // optional_CONFIG_MAX_ALIGN_HACK
+
+// Use user-specified type for alignment:
+
+#define optional_ALIGN_AS( unused ) \
+    optional_CONFIG_ALIGN_AS
+
+#else // optional_CONFIG_MAX_ALIGN_HACK
+
+// Determine POD type to use for alignment:
+
+#define optional_ALIGN_AS( to_align ) \
+    typename type_of_size< alignment_types, alignment_of< to_align >::value >::type
+
+template< typename T >
+struct alignment_of;
+
+template< typename T >
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+
+template< size_t A, size_t S >
+struct alignment_logic
 {
-    static_assert(!std::is_reference<T>::value, "cl::optional does not work with reference types");
-    static_assert(std::is_destructible<T>::value, "cl::optional requires type to be Destructible");
+    enum { value = A < S ? A : S };
+};
 
-private:
-    typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type stg_;   // We store any value here.
-    T* const pval_;                                                                     // Pointer to value stored in stg_.
-    bool has_value_;                                                                    // Whether we have a value in stg_.
+template< typename T >
+struct alignment_of
+{
+    enum { value = alignment_logic<
+        sizeof( alignment_of_hack<T> ) - sizeof(T), sizeof(T) >::value };
+};
+
+template< typename List, size_t N >
+struct type_of_size
+{
+    typedef typename conditional<
+        N == sizeof( typename List::head ),
+            typename List::head,
+            typename type_of_size<typename List::tail, N >::type >::type type;
+};
+
+template< size_t N >
+struct type_of_size< nulltype, N >
+{
+    typedef optional_CONFIG_ALIGN_AS_FALLBACK type;
+};
+
+template< typename T>
+struct struct_t { T _; };
+
+#define optional_ALIGN_TYPE( type ) \
+    typelist< type , typelist< struct_t< type >
+
+struct Unknown;
 
-    // Exception helpers
-    _CL_OPT_NORETURN void throw_bad_optional_access() const {
-        throw bad_optional_access("bad_optional_access");
+typedef
+    optional_ALIGN_TYPE( char ),
+    optional_ALIGN_TYPE( short ),
+    optional_ALIGN_TYPE( int ),
+    optional_ALIGN_TYPE( long ),
+    optional_ALIGN_TYPE( float ),
+    optional_ALIGN_TYPE( double ),
+    optional_ALIGN_TYPE( long double ),
+
+    optional_ALIGN_TYPE( char *),
+    optional_ALIGN_TYPE( short * ),
+    optional_ALIGN_TYPE( int * ),
+    optional_ALIGN_TYPE( long * ),
+    optional_ALIGN_TYPE( float * ),
+    optional_ALIGN_TYPE( double * ),
+    optional_ALIGN_TYPE( long double * ),
+
+    optional_ALIGN_TYPE( Unknown ( * )( Unknown ) ),
+    optional_ALIGN_TYPE( Unknown * Unknown::*     ),
+    optional_ALIGN_TYPE( Unknown ( Unknown::* )( Unknown ) ),
+
+    nulltype
+    > > > > > > >    > > > > > > >
+    > > > > > > >    > > > > > > >
+    > > > > > >
+    alignment_types;
+
+#undef optional_ALIGN_TYPE
+
+#endif // optional_CONFIG_MAX_ALIGN_HACK
+
+/// C++03 constructed union to hold value.
+
+template< typename T >
+union storage_t
+{
+//private:
+//    template< typename > friend class optional;
+
+    typedef T value_type;
+
+    storage_t() {}
+
+    storage_t( value_type const & v )
+    {
+        construct_value( v );
     }
 
-    // Helper for swap when one has a value and the other does not
-    static void swap_helper(optional& from, optional& to) _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value &&
-                                                                             std::is_nothrow_destructible<T>::value)
+    void construct_value( value_type const & v )
     {
-        new (to.pval_) T(std::move(*from.pval_));
-        from.pval_->~T();
-        to.has_value_ = true;
-        from.has_value_ = false;
+        ::new( value_ptr() ) value_type( v );
     }
 
-public:
-    typedef T   value_type;
+#if optional_CPP11_OR_GREATER
 
-    // Constructors of optional without a value
-    _CL_OPT_CONSTEXPR optional() _CL_OPT_NOEXCEPT
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(false) { }
-    _CL_OPT_CONSTEXPR optional(nullopt_t) _CL_OPT_NOEXCEPT
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(false) { }
+    storage_t( value_type && v )
+    {
+        construct_value( std::move( v ) );
+    }
 
-    // Copy constructor
-    optional(const optional& obj) _CL_OPT_NOEXCEPTEX(std::is_nothrow_copy_constructible<T>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(obj.has_value_)
+    void construct_value( value_type && v )
     {
-        if (has_value_) {
-            new (pval_) T(*obj.pval_);
-        }
+        ::new( value_ptr() ) value_type( std::move( v ) );
     }
 
-    // Move constructor (note: does not steal has_value_, see API)
-    optional(optional&& obj) _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(obj.has_value_)
+    template< class... Args >
+    void emplace( Args&&... args )
     {
-        if (has_value_) {
-            new (pval_) T(std::move(*obj.pval_));
-        }
+        ::new( value_ptr() ) value_type( std::forward<Args>(args)... );
     }
 
-    // Constructors of optional with a value
-    optional(const T& val) _CL_OPT_NOEXCEPTEX(std::is_nothrow_copy_constructible<T>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(true)
+    template< class U, class... Args >
+    void emplace( std::initializer_list<U> il, Args&&... args )
     {
-        new (pval_) T(val);
+        ::new( value_ptr() ) value_type( il, std::forward<Args>(args)... );
     }
-    optional(T&& val) _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(true)
+
+#endif
+
+    void destruct_value()
     {
-        new (pval_) T(std::move(val));
+        value_ptr()->~T();
     }
 
-#if _CL_OPT_VARIADIC
-    // In-place constructor of optional with a value
-    template<typename... Args>
-    _CL_OPT_CONSTEXPR explicit optional(in_place_t, Args&&... args)
-                _CL_OPT_NOEXCEPTEX(std::is_nothrow_constructible<T, Args&&...>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(true)
+    value_type const * value_ptr() const
     {
-        new (pval_) T(std::forward<Args>(args)...);
+        return as<value_type>();
     }
 
-    // Same but with an initializer_list thrown in just for fun
-    template<typename U, typename... Args,
-             typename = typename std::enable_if<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, void>::type>
-    _CL_OPT_CONSTEXPR explicit optional(in_place_t,
-                                         std::initializer_list<U> ilist,
-                                         Args&&... args)
-                _CL_OPT_NOEXCEPTEX(std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value)
-        : stg_(), pval_(reinterpret_cast<T*>(&stg_)), has_value_(true)
+    value_type * value_ptr()
     {
-        new (pval_) T(ilist, std::forward<Args>(args)...);
+        return as<value_type>();
     }
-#endif // _CL_OPT_VARIADIC
 
-    // Destructor
-    ~optional() _CL_OPT_NOEXCEPTEX(std::is_nothrow_destructible<T>::value) {
-        if (has_value_) {
-            // #clp TODO we should not do this for trivially-destructible types as per API
-            pval_->~T();
-        }
+    value_type const & value() const optional_ref_qual
+    {
+        return * value_ptr();
     }
 
-    // Assignment operator that clears any held value
-    optional& operator=(nullopt_t) _CL_OPT_NOEXCEPTEX(std::is_nothrow_destructible<T>::value)
+    value_type & value() optional_ref_qual
     {
-        if (has_value_) {
-            pval_->~T();
-            has_value_ = false;
-        }
-        return *this;
+        return * value_ptr();
     }
 
-    // Copy assignment operator
-    optional& operator=(const optional& obj) _CL_OPT_NOEXCEPTEX(std::is_nothrow_copy_constructible<T>::value &&
-                                                                std::is_nothrow_copy_assignable<T>::value &&
-                                                                std::is_nothrow_destructible<T>::value)
-    {
-        if (obj.has_value_) {
-            if (has_value_) {
-                // Can assign
-                *pval_ = *obj.pval_;
-            } else {
-                // Need to construct
-                new (pval_) T(*obj.pval_);
-                has_value_ = true;
-            }
-        } else if (has_value_) {
-            pval_->~T();
-            has_value_ = false;
-        }
-        return *this;
+#if optional_CPP11_OR_GREATER
+
+    value_type const && value() const optional_refref_qual
+    {
+        return std::move( value() );
     }
 
-    // Move assignment (note: does not steal has_value_, see API)
-    optional& operator=(optional&& obj) _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value &&
-                                                           std::is_nothrow_move_assignable<T>::value &&
-                                                           std::is_nothrow_destructible<T>::value)
-    {
-        if (obj.has_value_) {
-            if (has_value_) {
-                // Can assign
-                *pval_ = std::move(*obj.pval_);
-            } else {
-                // Need to construct
-                new (pval_) T(std::move(*obj.pval_));
-                has_value_ = true;
-            }
-        } else if (has_value_) {
-            pval_->~T();
-            has_value_ = false;
-        }
-        return *this;
+    value_type && value() optional_refref_qual
+    {
+        return std::move( value() );
     }
 
-#if _CL_OPT_TEMPL_FUNC_DEF_PARAMS
-    // Assignment from a value
-    template<typename U,
-             typename = typename std::enable_if<std::is_same<typename std::decay<U>::type, T>::value, void>::type>
-    optional& operator=(U&& val)
-            _CL_OPT_NOEXCEPTEX(std::is_nothrow_constructible<T, U>::value &&
-                               std::is_nothrow_assignable<T, U>::value)
-    {
-        if (has_value_) {
-            // Can assign
-            *pval_ = std::forward<U>(val);
-        } else {
-            // Need to construct
-            new (pval_) T(std::forward<U>(val));
-            has_value_ = true;
-        }
-        return *this;
+#endif
+
+#if optional_CPP11_OR_GREATER
+
+    using aligned_storage_t = typename std::aligned_storage< sizeof(value_type), alignof(value_type) >::type;
+    aligned_storage_t data;
+
+#elif optional_CONFIG_MAX_ALIGN_HACK
+
+    typedef struct { unsigned char data[ sizeof(value_type) ]; } aligned_storage_t;
+
+    max_align_t hack;
+    aligned_storage_t data;
+
+#else
+    typedef optional_ALIGN_AS(value_type) align_as_type;
+
+    typedef struct { align_as_type data[ 1 + ( sizeof(value_type) - 1 ) / sizeof(align_as_type) ]; } aligned_storage_t;
+    aligned_storage_t data;
+
+#   undef optional_ALIGN_AS
+
+#endif // optional_CONFIG_MAX_ALIGN_HACK
+
+    void * ptr() optional_noexcept
+    {
+        return &data;
     }
-#endif // _CL_OPT_TEMPL_FUNC_DEF_PARAMS
 
-    // Unchecked operators that access the value
-    _CL_OPT_CONSTEXPR const T* operator->() const {
-        return pval_;
+    void const * ptr() const optional_noexcept
+    {
+        return &data;
     }
-    _CL_OPT_CONSTEXPR T* operator->() {
-        return pval_;
+
+    template <typename U>
+    U * as()
+    {
+        return reinterpret_cast<U*>( ptr() );
     }
-    _CL_OPT_CONSTEXPR const T& operator*() const _CL_OPT_LVALUE_REF_QUALIF {
-        return *pval_;
+
+    template <typename U>
+    U const * as() const
+    {
+        return reinterpret_cast<U const *>( ptr() );
     }
-    _CL_OPT_CONSTEXPR T& operator*() _CL_OPT_LVALUE_REF_QUALIF {
-        return *pval_;
+};
+
+} // namespace detail
+
+/// disengaged state tag
+
+struct nullopt_t
+{
+    struct init{};
+    optional_constexpr nullopt_t( init ) {}
+};
+
+#if optional_HAVE( CONSTEXPR_11 )
+constexpr nullopt_t nullopt{ nullopt_t::init{} };
+#else
+// extra parenthesis to prevent the most vexing parse:
+const nullopt_t nullopt(( nullopt_t::init() ));
+#endif
+
+/// optional access error
+
+class bad_optional_access : public std::logic_error
+{
+public:
+  explicit bad_optional_access()
+  : logic_error( "bad optional access" ) {}
+};
+
+/// optional
+
+template< typename T>
+class optional
+{
+private:
+    template< typename > friend class optional;
+
+    typedef void (optional::*safe_bool)() const;
+
+public:
+    typedef T value_type;
+
+    // x.x.3.1, constructors
+
+    // 1a - default construct
+    optional_constexpr optional() optional_noexcept
+    : has_value_( false )
+    , contained()
+    {}
+
+    // 1b - construct explicitly empty
+    optional_constexpr optional( nullopt_t ) optional_noexcept
+    : has_value_( false )
+    , contained()
+    {}
+
+    // 2 - copy-construct
+    optional_constexpr14 optional( optional const & other
+#if optional_CPP11_OR_GREATER
+        optional_REQUIRES_A(
+            true || std::is_copy_constructible<T>::value
+        )
+#endif
+    )
+    : has_value_( other.has_value() )
+    {
+        if ( other.has_value() )
+            contained.construct_value( other.contained.value() );
     }
-#if _CL_OPT_MEMBERS_REF_QUALIFIERS
-    _CL_OPT_CONSTEXPR const T&& operator*() const && {
-        return std::move(*pval_);
+
+#if optional_CPP11_OR_GREATER
+
+    // 3 (C++11) - move-construct from optional
+    optional_constexpr14 optional( optional && other
+        optional_REQUIRES_A(
+            true || std::is_move_constructible<T>::value
+        )
+    ) noexcept( std::is_nothrow_move_constructible<T>::value )
+    : has_value_( other.has_value() )
+    {
+        if ( other.has_value() )
+            contained.construct_value( std::move( other.contained.value() ) );
     }
-    _CL_OPT_CONSTEXPR T&& operator*() && {
-        return std::move(*pval_);
+
+    // 4 (C++11) - explicit converting copy-construct from optional
+    template< typename U >
+    explicit optional( optional<U> const & other
+        optional_REQUIRES_A(
+            std::is_constructible<T, U const &>::value
+            && !std::is_constructible<T, optional<U> &          >::value
+            && !std::is_constructible<T, optional<U> &&         >::value
+            && !std::is_constructible<T, optional<U> const &    >::value
+            && !std::is_constructible<T, optional<U> const &&   >::value
+            && !std::is_convertible<     optional<U> &       , T>::value
+            && !std::is_convertible<     optional<U> &&      , T>::value
+            && !std::is_convertible<     optional<U> const & , T>::value
+            && !std::is_convertible<     optional<U> const &&, T>::value
+            && !std::is_convertible<               U const & , T>::value /*=> explicit */
+        )
+    )
+    : has_value_( other.has_value() )
+    {
+        if ( other.has_value() )
+            contained.construct_value( other.contained.value() );
     }
-#endif // _CL_OPT_MEMBERS_REF_QUALIFIERS
+#endif // optional_CPP11_OR_GREATER
 
-    // Value detection
-    _CL_OPT_CONSTEXPR _CL_OPT_OP_EXPLICIT operator bool() const _CL_OPT_NOEXCEPT {
-        return has_value_;
+    // 4 (C++98 and later) - non-explicit converting copy-construct from optional
+    template< typename U >
+    optional( optional<U> const & other
+#if optional_CPP11_OR_GREATER
+        optional_REQUIRES_A(
+            std::is_constructible<T, U const &>::value
+            && !std::is_constructible<T, optional<U> &          >::value
+            && !std::is_constructible<T, optional<U> &&         >::value
+            && !std::is_constructible<T, optional<U> const &    >::value
+            && !std::is_constructible<T, optional<U> const &&   >::value
+            && !std::is_convertible<     optional<U> &       , T>::value
+            && !std::is_convertible<     optional<U> &&      , T>::value
+            && !std::is_convertible<     optional<U> const & , T>::value
+            && !std::is_convertible<     optional<U> const &&, T>::value
+            &&  std::is_convertible<               U const & , T>::value /*=> non-explicit */
+        )
+#endif // optional_CPP11_OR_GREATER
+    )
+    : has_value_( other.has_value() )
+    {
+        if ( other.has_value() )
+            contained.construct_value( other.contained.value() );
     }
-    _CL_OPT_CONSTEXPR bool has_value() const _CL_OPT_NOEXCEPT {
-        return has_value_;
+
+#if optional_CPP11_OR_GREATER
+
+    // 5a (C++11) - explicit converting move-construct from optional
+    template< typename U >
+    optional( optional<U> && other
+        optional_REQUIRES_A(
+            std::is_constructible<T, U const &>::value
+            && !std::is_constructible<T, optional<U> &          >::value
+            && !std::is_constructible<T, optional<U> &&         >::value
+            && !std::is_constructible<T, optional<U> const &    >::value
+            && !std::is_constructible<T, optional<U> const &&   >::value
+            && !std::is_convertible<     optional<U> &       , T>::value
+            && !std::is_convertible<     optional<U> &&      , T>::value
+            && !std::is_convertible<     optional<U> const & , T>::value
+            && !std::is_convertible<     optional<U> const &&, T>::value
+            && !std::is_convertible<                     U &&, T>::value /*=> explicit */
+        )
+    )
+    : has_value_( other.has_value() )
+    {
+        if ( other.has_value() )
+            contained.construct_value( std::move( other.contained.value() ) );
     }
 
-    // Value accessors that throw if optional doesn't have a value
-    _CL_OPT_CONSTEXPR const T& value() const _CL_OPT_LVALUE_REF_QUALIF {
-        if (!has_value_) {
-            throw_bad_optional_access();
-        }
-        return *pval_;
-    }
-    _CL_OPT_CONSTEXPR T& value() _CL_OPT_LVALUE_REF_QUALIF {
-        if (!has_value_) {
-            throw_bad_optional_access();
-        }
-        return *pval_;
-    }
-#if _CL_OPT_MEMBERS_REF_QUALIFIERS
-    _CL_OPT_CONSTEXPR const T&& value() const && {
-        if (!has_value_) {
-            throw_bad_optional_access();
-        }
-        return std::move(*pval_);
-    }
-    _CL_OPT_CONSTEXPR T&& value() && {
-        if (!has_value_) {
-            throw_bad_optional_access();
-        }
-        return std::move(*pval_);
-    }
-#endif // _CL_OPT_MEMBERS_REF_QUALIFIERS
-
-    // Value accessors with an alternative if optional doesn't have a value
-    template<typename U>
-    _CL_OPT_CONSTEXPR T value_or(U&& default_val) const _CL_OPT_LVALUE_REF_QUALIF
-                _CL_OPT_NOEXCEPTEX(std::is_nothrow_copy_constructible<T>::value &&
-                                   std::is_nothrow_constructible<T, U>::value)
-    {
-        return has_value_ ? *pval_ : T(std::forward<U>(default_val));
-    }
-#if _CL_OPT_MEMBERS_REF_QUALIFIERS
-    template<typename U>
-    _CL_OPT_CONSTEXPR T value_or(U&& default_val) &&
-                _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value &&
-                                   std::is_nothrow_constructible<T, U>::value)
-    {
-        return has_value_ ? std::move(*pval_) : T(std::forward<U>(default_val));
-    }
-#endif // _CL_OPT_MEMBERS_REF_QUALIFIERS
-
-    // Swap implementation
-    void swap(optional& obj) _CL_OPT_NOEXCEPTEX(std::is_nothrow_move_constructible<T>::value &&
-                                                std::is_nothrow_destructible<T>::value &&
-                                                noexcept(std::swap(std::declval<T&>(), std::declval<T&>())))  // #clp TODO using std::swap here seems wrong, no?
-    {
-        if (obj.has_value_) {
-            if (has_value_) {
-                using std::swap;
-                swap(*pval_, *obj.pval_);
-            } else {
-                swap_helper(obj, *this);
-            }
-        } else if (has_value_) {
-            swap_helper(*this, obj);
-        }
-    }
-    // Non-member version of swap for ADL
-    friend void swap(optional& obj1, optional& obj2) {
-        obj1.swap(obj2);
-    }
-
-    // Removes any value held
-    void reset() _CL_OPT_NOEXCEPTEX(std::is_nothrow_destructible<T>::value)
-    {
-        if (has_value_) {
-            pval_->~T();
-            has_value_ = false;
-        }
-    }
-
-#if _CL_OPT_VARIADIC
-    // Destroys any held value and constructs a new one in-place
-    template<typename... Args>
-    void emplace(Args&&... args) _CL_OPT_NOEXCEPTEX(std::is_nothrow_destructible<T>::value &&
-                                                    std::is_nothrow_constructible<T, Args...>::value)
+    // 5a (C++11) - non-explicit converting move-construct from optional
+    template< typename U >
+    optional( optional<U> && other
+        optional_REQUIRES_A(
+            std::is_constructible<T, U const &>::value
+            && !std::is_constructible<T, optional<U> &          >::value
+            && !std::is_constructible<T, optional<U> &&         >::value
+            && !std::is_constructible<T, optional<U> const &    >::value
+            && !std::is_constructible<T, optional<U> const &&   >::value
+            && !std::is_convertible<     optional<U> &       , T>::value
+            && !std::is_convertible<     optional<U> &&      , T>::value
+            && !std::is_convertible<     optional<U> const & , T>::value
+            && !std::is_convertible<     optional<U> const &&, T>::value
+            &&  std::is_convertible<                     U &&, T>::value /*=> non-explicit */
+        )
+    )
+    : has_value_( other.has_value() )
     {
-        reset();
-        new (pval_) T(std::forward<Args>(args)...);
-        has_value_ = true;
+        if ( other.has_value() )
+            contained.construct_value( std::move( other.contained.value() ) );
+    }
+
+    // 6 (C++11) - in-place construct
+    template< typename... Args
+        optional_REQUIRES_T(
+            std::is_constructible<T, Args&&...>::value
+        )
+    >
+    optional_constexpr explicit optional( nonstd_lite_in_place_t(T), Args&&... args )
+    : has_value_( true )
+    , contained( T( std::forward<Args>(args)...) )
+    {}
+
+    // 7 (C++11) - in-place construct,  initializer-list
+    template< typename U, typename... Args
+        optional_REQUIRES_T(
+            std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value
+        )
+    >
+    optional_constexpr explicit optional( nonstd_lite_in_place_t(T), std::initializer_list<U> il, Args&&... args )
+    : has_value_( true )
+    , contained( T( il, std::forward<Args>(args)...) )
+    {}
+
+    // 8a (C++11) - explicit move construct from value
+    template< typename U = value_type >
+    optional_constexpr explicit optional( U && value
+        optional_REQUIRES_A(
+            std::is_constructible<T, U&&>::value
+            && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
+            && !std::is_same<typename std20::remove_cvref<U>::type, optional<T>>::value
+            && !std::is_convertible<U&&, T>::value /*=> explicit */
+        )
+    )
+    : has_value_( true )
+    , contained( std::forward<U>( value ) )
+    {}
+
+    // 8a (C++11) - non-explicit move construct from value
+    template< typename U = value_type >
+    optional_constexpr optional( U && value
+        optional_REQUIRES_A(
+            std::is_constructible<T, U&&>::value
+            && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
+            && !std::is_same<typename std20::remove_cvref<U>::type, optional<T>>::value
+            && std::is_convertible<U&&, T>::value /*=> non-explicit */
+        )
+    )
+    : has_value_( true )
+    , contained( std::forward<U>( value ) )