From c946f3edb7724b29c513e0cf50029f0ffea9f583 Mon Sep 17 00:00:00 2001
From: Eric Niebler <eniebler@boost.org>
Date: Tue, 24 Jan 2017 14:32:17 -0800
Subject: [PATCH] rework a bunch of the *tructible concepts, Movable requires
 object types

---
 include/stl2/detail/concepts/core.hpp         |   2 +-
 .../detail/concepts/object/assignable.hpp     |  11 +-
 .../stl2/detail/concepts/object/movable.hpp   |   5 +-
 .../concepts/object/move_constructible.hpp    | 123 ++++--------------
 include/stl2/detail/ebo_box.hpp               |   3 +-
 .../stl2/detail/iterator/basic_iterator.hpp   |   1 +
 include/stl2/detail/semiregular_box.hpp       |   3 +-
 include/stl2/detail/temporary_vector.hpp      |   4 +-
 include/stl2/optional.hpp                     |   4 +-
 test/concepts/object.cpp                      |  71 +++-------
 test/optional.cpp                             |   6 +-
 11 files changed, 67 insertions(+), 166 deletions(-)

diff --git a/include/stl2/detail/concepts/core.hpp b/include/stl2/detail/concepts/core.hpp
index bc0485c29..afc227cd7 100644
--- a/include/stl2/detail/concepts/core.hpp
+++ b/include/stl2/detail/concepts/core.hpp
@@ -27,7 +27,7 @@ STL2_OPEN_NAMESPACE {
 	concept bool _Is = _Valid<T, U, V...> && T<U, V...>::value;
 
 	template <class U, template <class...> class T, class...V>
-	concept bool _IsNot = !_Is<U, T, V...>;
+	concept bool _IsNot = _Valid<T, U, V...> && !T<U, V...>::value;
 
 	// U is a cv/ref-qualified specialization of class template T.
 	template <class U, template <class...> class T>
diff --git a/include/stl2/detail/concepts/object/assignable.hpp b/include/stl2/detail/concepts/object/assignable.hpp
index 2ed829b5c..254a223b9 100644
--- a/include/stl2/detail/concepts/object/assignable.hpp
+++ b/include/stl2/detail/concepts/object/assignable.hpp
@@ -22,18 +22,21 @@ STL2_OPEN_NAMESPACE {
 	///////////////////////////////////////////////////////////////////////////
 	// Assignable [concepts.lib.corelang.assignable]
 	//
+	// Not to spec
+	// See https://github.com/ericniebler/stl2/issues/229
 	template <class, class>
 	constexpr bool __assignable = false;
 	template <class T, class U>
 	requires
-		requires(T&& t, U&& u) {
-			STL2_EXACT_TYPE_CONSTRAINT((T&&)t = (U&&)u, T&);
+		requires(T& t, U&& u) {
+			STL2_EXACT_TYPE_CONSTRAINT(t = (U&&)u, T&);
 		}
-	constexpr bool __assignable<T, U> = true;
+	constexpr bool __assignable<T&, U> = true;
 
 	template <class T, class U>
 	concept bool Assignable() {
-		return CommonReference<const T&, const U&>() &&
+		return Same<T, decay_t<T>&>() &&
+		    CommonReference<T, const U&>() &&
 			__assignable<T, U>;
 	}
 
diff --git a/include/stl2/detail/concepts/object/movable.hpp b/include/stl2/detail/concepts/object/movable.hpp
index 469ed59bc..695c9a890 100644
--- a/include/stl2/detail/concepts/object/movable.hpp
+++ b/include/stl2/detail/concepts/object/movable.hpp
@@ -22,9 +22,12 @@ STL2_OPEN_NAMESPACE {
 	///////////////////////////////////////////////////////////////////////////
 	// Movable [concepts.lib.object.movable]
 	//
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/310
 	template <class T>
 	concept bool Movable() {
-		return MoveConstructible<T>() &&
+		return _Is<T, is_object> &&
+			MoveConstructible<T>() &&
 			Assignable<T&, T&&>() &&
 			Swappable<T&>();
 	}
diff --git a/include/stl2/detail/concepts/object/move_constructible.hpp b/include/stl2/detail/concepts/object/move_constructible.hpp
index c13a393a5..68b859dc1 100644
--- a/include/stl2/detail/concepts/object/move_constructible.hpp
+++ b/include/stl2/detail/concepts/object/move_constructible.hpp
@@ -24,6 +24,10 @@ STL2_OPEN_NAMESPACE {
 	//
 	template <class>
 	constexpr bool __addressable = false;
+	template <class T>
+	constexpr bool __addressable<T&> = true;
+	template <class T>
+	constexpr bool __addressable<T&&> = true;
 	template <class T>
 		requires requires(T& t, const T& ct) {
 			STL2_EXACT_TYPE_CONSTRAINT(&t, T*);
@@ -35,7 +39,7 @@ STL2_OPEN_NAMESPACE {
 	namespace ext {
 		template <class T>
 		concept bool Addressable() {
-			return __addressable<T>;
+			return _Is<T, is_object> && __addressable<T>;
 		}
 	}
 
@@ -46,122 +50,43 @@ STL2_OPEN_NAMESPACE {
 		constexpr bool Addressable<T> = true;
 	}
 
-	namespace detail {
-		template <class>
-		constexpr bool is_complete_object = false;
-
-		template <_Is<is_object> T>
-		requires
-			sizeof(T) > 0
-		constexpr bool is_complete_object<T> = true;
-
-		template <class T>
-		constexpr bool MustBeComplete() {
-			static_assert(is_complete_object<T>, "Concept check for incomplete type T.");
-			return true;
-		}
-	}
-
 	///////////////////////////////////////////////////////////////////////////
 	// Destructible [concepts.lib.object.destructible]
-	// Not to spec: is_object and accepting the parameters by reference are
-	//              necessary to prevent hard errors in the requires clause
-	//              with odd types.
-	//
-	template <class>
-	constexpr bool __destructible = false;
-	template <class T>
-		requires _Is<T, is_object> &&
-			_IsNot<T, is_array> &&
-			detail::MustBeComplete<T>() &&
-			requires(T& t, T* const p) {
-				{ t.~T() } noexcept;
-				delete p;
-				delete[] p;
-			}
-	constexpr bool __destructible<T> = true;
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/301
+	namespace models {
+		template <class T>
+		constexpr bool Destructible = is_nothrow_destructible<T>::value && __addressable<T>;
+	}
 
 	template <class T>
 	concept bool Destructible() {
-		return ext::Addressable<T>() && __destructible<T>;
-	}
-
-	namespace models {
-		template <class>
-		constexpr bool Destructible = false;
-		__stl2::Destructible{T}
-		constexpr bool Destructible<T> = true;
+		return models::Destructible<T>;
 	}
 
 	///////////////////////////////////////////////////////////////////////////
 	// Constructible [concepts.lib.object.constructible]
-	// Extension: ConstructibleObject and BindableReference are user-visible.
-	//
-	namespace ext {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Waddress"
-		template <class T, class...Args>
-		constexpr bool __constructible_object = false;
-		template <class T, class...Args>
-			requires requires(Args&&...args) {
-				T{ (Args&&)args... };
-				new T{ (Args&&)args... };
-			}
-		constexpr bool __constructible_object<T, Args...> = true;
-
-		template <class T, class...Args>
-		concept bool ConstructibleObject =
-			Destructible<T>() && __constructible_object<T, Args...>;
-#pragma GCC diagnostic pop
-
-		// 20150718: Not to spec: spec is broken.
-		// FIXME: Correct wording.
-		template <class T, class...Args>
-		concept bool BindableReference =
-			_Is<T, is_reference> &&
-			// requires(Args&&...args) { T{ (Args&&)args... }; };
-			// requires(Args&&...args) { T( (Args&&)args... ); };
-			_Is<T, is_constructible, Args...>;
+	// Not to spec
+	// See https://github.com/ericniebler/stl2/issues/301
+	template <class T, class... Args>
+	concept bool Constructible() {
+		return Destructible<T>() && _Is<T, is_constructible, Args...>;
 	}
 
 	namespace models {
-		template <class T, class...Args>
-		constexpr bool ConstructibleObject = false;
-		__stl2::ext::ConstructibleObject{T, ...Args}
-		constexpr bool ConstructibleObject<T, Args...> = true;
-
-		template <class T, class...Args>
-		constexpr bool BindableReference = false;
-		__stl2::ext::BindableReference{T, ...Args}
-		constexpr bool BindableReference<T, Args...> = true;
-
-		template <class T, class...Args>
-		constexpr bool Constructible =
-			ConstructibleObject<T, Args...> ||
-			BindableReference<T, Args...>;
-	}
-
-	template <class T, class...Args>
-	concept bool Constructible() {
-		return models::Constructible<T, Args...>;
+		template <class, class...>
+		constexpr bool Constructible = false;
+		__stl2::Constructible{T, ...Args}
+		constexpr bool Constructible<T, Args...> = true;
 	}
 
 	///////////////////////////////////////////////////////////////////////////
 	// DefaultConstructible [concepts.lib.object.defaultconstructible]
-	// Note: Due to implementation variance around DR1518, may not correctly
-	// enforce the requirement that the default constructor be non-explicit.
-	//
-	template <class T>
-	constexpr bool __default_constructible = false;
-	template <class T>
-		requires requires(const std::size_t n) {
-			new T[n]{}; // not required to be equality preserving
-		}
-	constexpr bool __default_constructible<T> = true;
-
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/301
 	template <class T>
 	concept bool DefaultConstructible() {
-		return Constructible<T>() && __default_constructible<T>;
+		return Constructible<T>();
 	}
 
 	namespace models {
diff --git a/include/stl2/detail/ebo_box.hpp b/include/stl2/detail/ebo_box.hpp
index 3750ad779..44b8e100c 100644
--- a/include/stl2/detail/ebo_box.hpp
+++ b/include/stl2/detail/ebo_box.hpp
@@ -24,6 +24,7 @@ STL2_OPEN_NAMESPACE {
 			is_class<T>::value && !is_final<T>::value;
 
 		template <Destructible T, class Tag = void>
+		requires _Is<T, is_object>
 		class ebo_box {
 		public:
 			ebo_box() requires DefaultConstructible<T>() = default;
@@ -54,7 +55,7 @@ STL2_OPEN_NAMESPACE {
 		};
 
 		template <Destructible T, class Tag>
-		requires __non_final_class<T>
+		requires _Is<T, is_object> && __non_final_class<T>
 		class ebo_box<T, Tag> : private T {
 		public:
 			using T::T;
diff --git a/include/stl2/detail/iterator/basic_iterator.hpp b/include/stl2/detail/iterator/basic_iterator.hpp
index a84d0ce98..c86a1640e 100644
--- a/include/stl2/detail/iterator/basic_iterator.hpp
+++ b/include/stl2/detail/iterator/basic_iterator.hpp
@@ -31,6 +31,7 @@
 
 STL2_OPEN_NAMESPACE {
 	template <Destructible T>
+	requires _Is<T, is_object>
 	class basic_mixin : protected detail::ebo_box<T, basic_mixin<T>> {
 		using box_t = detail::ebo_box<T, basic_mixin<T>>;
 	public:
diff --git a/include/stl2/detail/semiregular_box.hpp b/include/stl2/detail/semiregular_box.hpp
index 3631961cc..8244e6fa2 100644
--- a/include/stl2/detail/semiregular_box.hpp
+++ b/include/stl2/detail/semiregular_box.hpp
@@ -20,7 +20,8 @@
 
 STL2_OPEN_NAMESPACE {
 	namespace detail {
-		Destructible{T}
+		template <Destructible T>
+		requires _Is<T, is_object>
 		class semiregular_box {
 		public:
 			semiregular_box() = default;
diff --git a/include/stl2/detail/temporary_vector.hpp b/include/stl2/detail/temporary_vector.hpp
index af25bc558..95c23d5f4 100644
--- a/include/stl2/detail/temporary_vector.hpp
+++ b/include/stl2/detail/temporary_vector.hpp
@@ -90,6 +90,7 @@ STL2_OPEN_NAMESPACE {
 		};
 
 		template <Destructible T>
+		requires _Is<T, is_object>
 		class temporary_vector {
 			T* begin_ = nullptr;
 			T* end_ = nullptr;
@@ -159,7 +160,8 @@ STL2_OPEN_NAMESPACE {
 			{ emplace_back(__stl2::move(t)); }
 		};
 
-		Destructible{T}
+		template <Destructible T>
+		requires _Is<T, is_object>
 		temporary_vector<T> make_temporary_vector(temporary_buffer<T>& buf) {
 			return {buf};
 		}
diff --git a/include/stl2/optional.hpp b/include/stl2/optional.hpp
index 9fddebf42..289664632 100644
--- a/include/stl2/optional.hpp
+++ b/include/stl2/optional.hpp
@@ -46,7 +46,7 @@ STL2_OPEN_NAMESPACE {
 	};
 
 	template <class T>
-	requires models::Destructible<T>
+	requires models::Destructible<T> && _Is<T, is_object>
 	class optional;
 
 	namespace __optional {
@@ -233,7 +233,7 @@ STL2_OPEN_NAMESPACE {
 	}
 
 	template <class T>
-	requires models::Destructible<T>
+	requires models::Destructible<T> && _Is<T, is_object>
 	class optional
 	: public meta::_t<ext::optional_storage<T>>
 	, detail::smf_control::copy<models::CopyConstructible<T>>
diff --git a/test/concepts/object.cpp b/test/concepts/object.cpp
index a49346e58..fe70a8de1 100644
--- a/test/concepts/object.cpp
+++ b/test/concepts/object.cpp
@@ -16,14 +16,6 @@ namespace models {
 template <class T>
 constexpr bool Destructible = ranges::Destructible<T>();
 
-template <class T, class...Args>
-constexpr bool ConstructibleObject =
-	ranges::concepts::models<ranges::concepts::ConstructibleObject, T, Args...>();
-
-template <class T, class...Args>
-constexpr bool BindableReference =
-	ranges::concepts::models<ranges::concepts::BindableReference, T, Args...>();
-
 template <class T, class...Args>
 constexpr bool Constructible = ranges::Constructible<T, Args...>();
 
@@ -82,6 +74,10 @@ struct indestructible {
 	~indestructible() = delete;
 };
 
+struct throwing_destructor {
+	~throwing_destructor() noexcept(false);
+};
+
 struct explicit_default {
 	explicit explicit_default() {}
 };
@@ -133,17 +129,19 @@ struct XXX
 CONCEPT_ASSERT(models::Destructible<int>);
 CONCEPT_ASSERT(models::Destructible<const int>);
 CONCEPT_ASSERT(!models::Destructible<void>);
-CONCEPT_ASSERT(!models::Destructible<int&>);
+CONCEPT_ASSERT(models::Destructible<int&>);
 CONCEPT_ASSERT(!models::Destructible<void()>);
 CONCEPT_ASSERT(models::Destructible<void(*)()>);
-CONCEPT_ASSERT(!models::Destructible<void(&)()>);
+CONCEPT_ASSERT(models::Destructible<void(&)()>);
 CONCEPT_ASSERT(!models::Destructible<int[]>);
-CONCEPT_ASSERT(!models::Destructible<int[2]>);
+CONCEPT_ASSERT(models::Destructible<int[2]>);
 CONCEPT_ASSERT(models::Destructible<int(*)[2]>);
-CONCEPT_ASSERT(!models::Destructible<int(&)[2]>);
+CONCEPT_ASSERT(!models::Addressable<int(&)[2]>);
+CONCEPT_ASSERT(models::Destructible<int(&)[2]>);
 CONCEPT_ASSERT(models::Destructible<moveonly>);
 CONCEPT_ASSERT(models::Destructible<nonmovable>);
 CONCEPT_ASSERT(!models::Destructible<indestructible>);
+CONCEPT_ASSERT(!models::Destructible<throwing_destructor>);
 
 #if 0
 // ill-formed (hard error)
@@ -162,17 +160,11 @@ CONCEPT_ASSERT(!models::Constructible<int const&>);
 CONCEPT_ASSERT(!models::Constructible<int()>);
 CONCEPT_ASSERT(!models::Constructible<int(&)()>);
 CONCEPT_ASSERT(!models::Constructible<int[]>);
-CONCEPT_ASSERT(!models::Constructible<int[5]>);
+CONCEPT_ASSERT(models::Constructible<int[5]>);
 CONCEPT_ASSERT(!models::Constructible<nondefaultconstructible>);
 CONCEPT_ASSERT(models::Constructible<int const(&)[5], int(&)[5]>);
 CONCEPT_ASSERT(!models::Constructible<int, int(&)[3]>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<int, int>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, int&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, int&&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int&&>);
 CONCEPT_ASSERT(models::Constructible<int, int>);
 CONCEPT_ASSERT(models::Constructible<int, int&>);
 CONCEPT_ASSERT(models::Constructible<int, int&&>);
@@ -180,12 +172,6 @@ CONCEPT_ASSERT(models::Constructible<int, const int>);
 CONCEPT_ASSERT(models::Constructible<int, const int&>);
 CONCEPT_ASSERT(models::Constructible<int, const int&&>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable&&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable&&>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable&>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable&&>);
@@ -193,12 +179,6 @@ CONCEPT_ASSERT(models::Constructible<copyable, const copyable>);
 CONCEPT_ASSERT(models::Constructible<copyable, const copyable&>);
 CONCEPT_ASSERT(models::Constructible<copyable, const copyable&&>);
 
-CONCEPT_ASSERT(!models::BindableReference<int&, int>);
-CONCEPT_ASSERT(models::BindableReference<int&, int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, int&&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int&&>);
 CONCEPT_ASSERT(!models::Constructible<int&, int>);
 CONCEPT_ASSERT(models::Constructible<int&, int&>);
 CONCEPT_ASSERT(!models::Constructible<int&, int&&>);
@@ -206,12 +186,6 @@ CONCEPT_ASSERT(!models::Constructible<int&, const int>);
 CONCEPT_ASSERT(!models::Constructible<int&, const int&>);
 CONCEPT_ASSERT(!models::Constructible<int&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<const int&, int>);
-CONCEPT_ASSERT(models::BindableReference<const int&, int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, int&&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<const int&, int>);
 CONCEPT_ASSERT(models::Constructible<const int&, int&>);
 CONCEPT_ASSERT(models::Constructible<const int&, int&&>);
@@ -219,12 +193,6 @@ CONCEPT_ASSERT(models::Constructible<const int&, const int>);
 CONCEPT_ASSERT(models::Constructible<const int&, const int&>);
 CONCEPT_ASSERT(models::Constructible<const int&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<int&&, int>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, int&>);
-CONCEPT_ASSERT(models::BindableReference<int&&, int&&>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<int&&, int>);
 CONCEPT_ASSERT(!models::Constructible<int&&, int&>);
 CONCEPT_ASSERT(models::Constructible<int&&, int&&>);
@@ -232,12 +200,6 @@ CONCEPT_ASSERT(!models::Constructible<int&&, const int>);
 CONCEPT_ASSERT(!models::Constructible<int&&, const int&>);
 CONCEPT_ASSERT(!models::Constructible<int&&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<const int&&, int>);
-CONCEPT_ASSERT(!models::BindableReference<const int&&, int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, int&&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<const int&&, const int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<const int&&, int>);
 CONCEPT_ASSERT(!models::Constructible<const int&&, int&>);
 CONCEPT_ASSERT(models::Constructible<const int&&, int&&>);
@@ -256,7 +218,7 @@ CONCEPT_ASSERT(!models::DefaultConstructible<int(&)()>);
 CONCEPT_ASSERT(models::DefaultConstructible<double>);
 CONCEPT_ASSERT(!models::DefaultConstructible<void>);
 CONCEPT_ASSERT(!models::DefaultConstructible<int[]>);
-CONCEPT_ASSERT(!models::DefaultConstructible<int[2]>);
+CONCEPT_ASSERT(models::DefaultConstructible<int[2]>);
 CONCEPT_ASSERT(!models::DefaultConstructible<nondefaultconstructible>);
 
 // It's hard to catch explicit default constructors, see
@@ -275,7 +237,6 @@ CONCEPT_ASSERT(models::MoveConstructible<int &&>);
 CONCEPT_ASSERT(models::MoveConstructible<const int &>);
 CONCEPT_ASSERT(models::MoveConstructible<const int &&>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<moveonly, moveonly>);
 CONCEPT_ASSERT(models::Constructible<moveonly, moveonly>);
 CONCEPT_ASSERT(models::MoveConstructible<copyable>);
 CONCEPT_ASSERT(models::MoveConstructible<moveonly>);
@@ -354,12 +315,16 @@ CONCEPT_ASSERT(!models::Regular<copyonly>);
 CONCEPT_ASSERT(!models::Regular<explicit_move>);
 CONCEPT_ASSERT(!models::Regular<explicit_copy>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<std::initializer_list<int>>);
 CONCEPT_ASSERT(models::Constructible<std::initializer_list<int>>);
 CONCEPT_ASSERT(models::DefaultConstructible<std::initializer_list<int>>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<int*>);
 CONCEPT_ASSERT(models::Constructible<int*>);
 CONCEPT_ASSERT(models::DefaultConstructible<int*>);
 
+// https://github.com/ericniebler/stl2/issues/301
+CONCEPT_ASSERT(!models::Constructible<int&, long&>);
+
+// https://github.com/ericniebler/stl2/issues/310
+CONCEPT_ASSERT(!models::Movable<int&&>);
+
 int main() {}
diff --git a/test/optional.cpp b/test/optional.cpp
index 147518360..fb81fa8f0 100644
--- a/test/optional.cpp
+++ b/test/optional.cpp
@@ -226,11 +226,11 @@ int main() {
 		static_assert(models::Constructible<OL, OI>);
 		static_assert(models::ConvertibleTo<OI, OL>);
 
-		static_assert(!models::ConvertibleTo<OL, OI>);
-		static_assert(!models::Constructible<OI, OL>);
+		static_assert(models::ConvertibleTo<OL, OI>);
+		static_assert(models::Constructible<OI, OL>);
 
 		static_assert(models::ConvertibleTo<long, int>);
-		static_assert(!models::Constructible<int, long>); // narrowing
+		static_assert(models::Constructible<int, long>);
 
 		static_assert(!models::Swappable<OI&, OL&>);
 	}