diff --git a/include/cpp2util.h b/include/cpp2util.h
index 4e2323e236..f29997e35f 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -191,7 +191,7 @@
         // in our -pure-cpp2 "import std;" simulation mode... if you need this,
         // use mixed mode (not -pure-cpp2) and #include all the headers you need
         // including this one
-        // 
+        //
         // #include <execution>
     #endif
 
@@ -464,7 +464,7 @@ template<typename T>
 auto Typeid() -> decltype(auto) {
 #ifdef CPP2_NO_RTTI
     Type.expects(
-        !"'any' dynamic casting is disabled with -fno-rtti", // more likely to appear on console 
+        !"'any' dynamic casting is disabled with -fno-rtti", // more likely to appear on console
          "'any' dynamic casting is disabled with -fno-rtti"  // make message available to hooked handlers
     );
 #else
@@ -807,55 +807,59 @@ using empty = void;
 //  Templates
 //
 template <template <typename...> class C, typename... Ts>
-constexpr auto is(C< Ts...> const& ) -> bool {
-    return true;
+constexpr auto is(C< Ts...> const& ) -> std::true_type {
+    return {};
 }
 
 #if defined(_MSC_VER)
     template <template <typename, typename...> class C, typename T>
-    constexpr auto is( T const& ) -> bool {
-        return false;
+    constexpr auto is( T const& ) -> std::false_type {
+        return {};
     }
 #else
     template <template <typename...> class C, typename T>
-    constexpr auto is( T const& ) -> bool {
-        return false;
+    constexpr auto is( T const& ) -> std::false_type {
+        return {};
     }
 #endif
 
 template <template <typename,auto> class C, typename T, auto V>
-constexpr auto is( C<T, V> const& ) -> bool {
-    return true;
+constexpr auto is( C<T, V> const& ) -> std::true_type {
+    return {};
 }
 
 template <template <typename,auto> class C, typename T>
-constexpr auto is( T const& ) -> bool {
-    return false;
+constexpr auto is( T const& ) -> std::false_type {
+    return {};
 }
 
 //  Types
 //
 template< typename C, typename X >
-auto is( X const& ) -> bool {
-    return false;
+auto is( X const& ) -> std::false_type {
+    return {};
 }
 
 template< typename C, typename X >
     requires std::is_same_v<C, X>
-auto is( X const& ) -> bool {
-    return true;
+auto is( X const& ) -> std::true_type {
+    return {};
 }
 
 template< typename C, typename X >
-    requires (std::is_base_of_v<C, X> && !std::is_same_v<C,X>)
-auto is( X const& ) -> bool {
-    return true;
+    requires (
+        std::is_base_of_v<C, X>
+        && !std::is_polymorphic_v<C>
+        && !std::is_polymorphic_v<X>
+        && !std::is_same_v<C,X>)
+auto is( X const& ) -> std::true_type {
+    return {};
 }
 
 template< typename C, typename X >
     requires (
-        ( std::is_base_of_v<X, C> || 
-          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>) 
+        ( std::is_base_of_v<X, C> ||
+          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>)
         ) && !std::is_same_v<C,X>)
 auto is( X const& x ) -> bool {
     return Dynamic_cast<C const*>(&x) != nullptr;
@@ -863,8 +867,8 @@ auto is( X const& x ) -> bool {
 
 template< typename C, typename X >
     requires (
-        ( std::is_base_of_v<X, C> || 
-          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>) 
+        ( std::is_base_of_v<X, C> ||
+          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>)
         ) && !std::is_same_v<C,X>)
 auto is( X const* x ) -> bool {
     return Dynamic_cast<C const*>(x) != nullptr;
@@ -879,21 +883,19 @@ auto is( X const& x ) -> bool {
 
 //  Values
 //
-inline constexpr auto is( auto const& x, auto const& value ) -> bool
+template< typename X, typename P >
+constexpr auto is( X const& x, P const& value ) -> auto
+    requires std::predicate<P const&, X const&>
 {
     //  Predicate case
-    if constexpr (requires{ bool{ value(x) }; }) {
-        return value(x);
-    }
-    else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {
-        return false;
-    }
+    return value(x);
+}
 
+constexpr auto is( auto const& x, auto const& value ) -> bool
+    requires requires{ bool{x == value}; }
+{
     //  Value case
-    else if constexpr (requires{ bool{x == value}; }) {
-        return x == value;
-    }
-    return false;
+    return bool{x == value};
 }
 
 
@@ -1048,33 +1050,21 @@ auto as( X x ) -> C {
 //  Common internal helper
 //
 template<size_t I, typename... Ts>
+    requires (I < std::variant_size_v<std::variant<Ts...>>)
 constexpr auto operator_as( std::variant<Ts...> && x ) -> decltype(auto) {
-    if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {
-        return std::get<I>( x );
-    }
-    else {
-        return nonesuch;
-    }
+    return std::get<I>( x );
 }
 
 template<size_t I, typename... Ts>
+    requires (I < std::variant_size_v<std::variant<Ts...>>)
 constexpr auto operator_as( std::variant<Ts...> & x ) -> decltype(auto) {
-    if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {
-        return std::get<I>( x );
-    }
-    else {
-        return nonesuch;
-    }
+    return std::get<I>( x );
 }
 
 template<size_t I, typename... Ts>
+    requires (I < std::variant_size_v<std::variant<Ts...>>)
 constexpr auto operator_as( std::variant<Ts...> const& x ) -> decltype(auto) {
-    if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {
-        return std::get<I>( x );
-    }
-    else {
-        return nonesuch;
-    }
+    return std::get<I>( x );
 }
 
 
@@ -1086,6 +1076,33 @@ constexpr auto operator_is( std::variant<Ts...> const& x ) {
 }
 
 template<typename T, typename... Ts>
+concept __is_variant = requires (std::variant<Ts...> const& x) {
+    requires
+        std::is_same_v< empty, T >
+        || requires { operator_as< 0>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >
+        || requires { operator_as< 1>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >
+        || requires { operator_as< 2>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >
+        || requires { operator_as< 3>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >
+        || requires { operator_as< 4>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >
+        || requires { operator_as< 5>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >
+        || requires { operator_as< 6>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >
+        || requires { operator_as< 7>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >
+        || requires { operator_as< 8>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >
+        || requires { operator_as< 9>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >
+        || requires { operator_as<10>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >
+        || requires { operator_as<11>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >
+        || requires { operator_as<12>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >
+        || requires { operator_as<13>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >
+        || requires { operator_as<14>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >
+        || requires { operator_as<15>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >
+        || requires { operator_as<16>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >
+        || requires { operator_as<17>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >
+        || requires { operator_as<18>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >
+        || requires { operator_as<19>(x); } && std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >;
+};
+
+template<typename T, typename... Ts>
+    requires __is_variant<T, Ts...>
 auto is( std::variant<Ts...> const& x );
 
 
@@ -1152,27 +1169,28 @@ template <class T, class... Ts>
 inline constexpr auto is_any = std::disjunction_v<std::is_same<T, Ts>...>;
 
 template<typename T, typename... Ts>
+    requires __is_variant<T, Ts...>
 auto is( std::variant<Ts...> const& x ) {
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return true; }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return true; }
+    if constexpr (requires { operator_as< 0>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return true; } }
+    if constexpr (requires { operator_as< 1>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return true; } }
+    if constexpr (requires { operator_as< 2>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return true; } }
+    if constexpr (requires { operator_as< 3>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return true; } }
+    if constexpr (requires { operator_as< 4>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return true; } }
+    if constexpr (requires { operator_as< 5>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return true; } }
+    if constexpr (requires { operator_as< 6>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return true; } }
+    if constexpr (requires { operator_as< 7>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return true; } }
+    if constexpr (requires { operator_as< 8>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return true; } }
+    if constexpr (requires { operator_as< 9>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return true; } }
+    if constexpr (requires { operator_as<10>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return true; } }
+    if constexpr (requires { operator_as<11>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return true; } }
+    if constexpr (requires { operator_as<12>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return true; } }
+    if constexpr (requires { operator_as<13>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return true; } }
+    if constexpr (requires { operator_as<14>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return true; } }
+    if constexpr (requires { operator_as<15>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return true; } }
+    if constexpr (requires { operator_as<16>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return true; } }
+    if constexpr (requires { operator_as<17>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return true; } }
+    if constexpr (requires { operator_as<18>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return true; } }
+    if constexpr (requires { operator_as<19>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return true; } }
     if constexpr (std::is_same_v< T, empty > ) {
         if (x.valueless_by_exception()) return true;
         //  Need to guard this with is_any otherwise the get_if is illegal
@@ -1183,76 +1201,76 @@ auto is( std::variant<Ts...> const& x ) {
 
 template<typename T, typename... Ts>
 auto as( std::variant<Ts...> && x ) -> decltype(auto) {
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); }
+    if constexpr (requires { operator_as< 0>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); } }
+    if constexpr (requires { operator_as< 1>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); } }
+    if constexpr (requires { operator_as< 2>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); } }
+    if constexpr (requires { operator_as< 3>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); } }
+    if constexpr (requires { operator_as< 4>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); } }
+    if constexpr (requires { operator_as< 5>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); } }
+    if constexpr (requires { operator_as< 6>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); } }
+    if constexpr (requires { operator_as< 7>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); } }
+    if constexpr (requires { operator_as< 8>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); } }
+    if constexpr (requires { operator_as< 9>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); } }
+    if constexpr (requires { operator_as<10>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } }
+    if constexpr (requires { operator_as<11>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } }
+    if constexpr (requires { operator_as<12>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } }
+    if constexpr (requires { operator_as<13>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } }
+    if constexpr (requires { operator_as<14>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } }
+    if constexpr (requires { operator_as<15>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } }
+    if constexpr (requires { operator_as<16>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } }
+    if constexpr (requires { operator_as<17>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } }
+    if constexpr (requires { operator_as<18>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } }
+    if constexpr (requires { operator_as<19>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } }
     Throw( std::bad_variant_access(), "'as' cast failed for 'variant'");
 }
 
 template<typename T, typename... Ts>
 auto as( std::variant<Ts...> & x ) -> decltype(auto) {
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); }
+    if constexpr (requires { operator_as< 0>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); } }
+    if constexpr (requires { operator_as< 1>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); } }
+    if constexpr (requires { operator_as< 2>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); } }
+    if constexpr (requires { operator_as< 3>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); } }
+    if constexpr (requires { operator_as< 4>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); } }
+    if constexpr (requires { operator_as< 5>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); } }
+    if constexpr (requires { operator_as< 6>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); } }
+    if constexpr (requires { operator_as< 7>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); } }
+    if constexpr (requires { operator_as< 8>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); } }
+    if constexpr (requires { operator_as< 9>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); } }
+    if constexpr (requires { operator_as<10>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } }
+    if constexpr (requires { operator_as<11>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } }
+    if constexpr (requires { operator_as<12>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } }
+    if constexpr (requires { operator_as<13>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } }
+    if constexpr (requires { operator_as<14>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } }
+    if constexpr (requires { operator_as<15>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } }
+    if constexpr (requires { operator_as<16>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } }
+    if constexpr (requires { operator_as<17>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } }
+    if constexpr (requires { operator_as<18>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } }
+    if constexpr (requires { operator_as<19>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } }
     Throw( std::bad_variant_access(), "'as' cast failed for 'variant'");
 }
 
 template<typename T, typename... Ts>
 auto as( std::variant<Ts...> const& x ) -> decltype(auto) {
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); }
-    if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); }
+    if constexpr (requires { operator_as< 0>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return operator_as<0>(x); } }
+    if constexpr (requires { operator_as< 1>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 1>(x)), T >) { if (x.index() ==  1) return operator_as<1>(x); } }
+    if constexpr (requires { operator_as< 2>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 2>(x)), T >) { if (x.index() ==  2) return operator_as<2>(x); } }
+    if constexpr (requires { operator_as< 3>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 3>(x)), T >) { if (x.index() ==  3) return operator_as<3>(x); } }
+    if constexpr (requires { operator_as< 4>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 4>(x)), T >) { if (x.index() ==  4) return operator_as<4>(x); } }
+    if constexpr (requires { operator_as< 5>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 5>(x)), T >) { if (x.index() ==  5) return operator_as<5>(x); } }
+    if constexpr (requires { operator_as< 6>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 6>(x)), T >) { if (x.index() ==  6) return operator_as<6>(x); } }
+    if constexpr (requires { operator_as< 7>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 7>(x)), T >) { if (x.index() ==  7) return operator_as<7>(x); } }
+    if constexpr (requires { operator_as< 8>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 8>(x)), T >) { if (x.index() ==  8) return operator_as<8>(x); } }
+    if constexpr (requires { operator_as< 9>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 9>(x)), T >) { if (x.index() ==  9) return operator_as<9>(x); } }
+    if constexpr (requires { operator_as<10>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<10>(x)), T >) { if (x.index() == 10) return operator_as<10>(x); } }
+    if constexpr (requires { operator_as<11>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<11>(x)), T >) { if (x.index() == 11) return operator_as<11>(x); } }
+    if constexpr (requires { operator_as<12>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<12>(x)), T >) { if (x.index() == 12) return operator_as<12>(x); } }
+    if constexpr (requires { operator_as<13>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<13>(x)), T >) { if (x.index() == 13) return operator_as<13>(x); } }
+    if constexpr (requires { operator_as<14>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<14>(x)), T >) { if (x.index() == 14) return operator_as<14>(x); } }
+    if constexpr (requires { operator_as<15>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<15>(x)), T >) { if (x.index() == 15) return operator_as<15>(x); } }
+    if constexpr (requires { operator_as<16>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<16>(x)), T >) { if (x.index() == 16) return operator_as<16>(x); } }
+    if constexpr (requires { operator_as<17>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<17>(x)), T >) { if (x.index() == 17) return operator_as<17>(x); } }
+    if constexpr (requires { operator_as<18>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<18>(x)), T >) { if (x.index() == 18) return operator_as<18>(x); } }
+    if constexpr (requires { operator_as<19>(x); }) { if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<19>(x)), T >) { if (x.index() == 19) return operator_as<19>(x); } }
     Throw( std::bad_variant_access(), "'as' cast failed for 'variant'");
 }
 
@@ -1276,23 +1294,14 @@ constexpr auto is( X const& x ) -> bool
 
 //  is Value
 //
-inline constexpr auto is( std::any const& x, auto const& value ) -> bool
+template<typename X>
+    requires std::is_same_v<X,std::any>
+constexpr auto is( X const& x, auto const& value ) -> bool
+    requires requires{ bool{ *std::any_cast<CPP2_TYPEOF(value)>(&x) == value }; }
 {
-    //  Predicate case
-    if constexpr (requires{ bool{ value(x) }; }) {
-        return value(x);
-    }
-    else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {
-        return false;
-    }
-
     //  Value case
-    else if constexpr (requires{ bool{ *std::any_cast<CPP2_TYPEOF(value)>(&x) == value }; }) {
-        auto pvalue = std::any_cast<CPP2_TYPEOF(value)>(&x);
-        return pvalue && *pvalue == value;
-    }
-    //  else
-    return false;
+    auto pvalue = std::any_cast<CPP2_TYPEOF(value)>(&x);
+    return pvalue && *pvalue == value;
 }
 
 
@@ -1325,20 +1334,10 @@ constexpr auto is( std::optional<U> const& x ) -> bool
 //
 template<typename T>
 constexpr auto is( std::optional<T> const& x, auto const& value ) -> bool
+    requires requires{ bool{ x.value() == value }; }
 {
-    //  Predicate case
-    if constexpr (requires{ bool{ value(x) }; }) {
-        return value(x);
-    }
-    else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {
-        return false;
-    }
-
     //  Value case
-    else if constexpr (requires{ bool{ x.value() == value }; }) {
-        return x.has_value() && x.value() == value;
-    }
-    return false;
+    return x.has_value() && x.value() == value;
 }
 
 
@@ -1452,7 +1451,7 @@ inline auto to_string(std::string const& s) -> std::string const&
 
 template<typename T>
 inline auto to_string(T const& sv) -> std::string
-    requires (std::is_convertible_v<T, std::string_view> 
+    requires (std::is_convertible_v<T, std::string_view>
               && !std::is_convertible_v<T, const char*>)
 {
     return std::string{sv};
diff --git a/regression-tests/mixed-type-safety-1.cpp2 b/regression-tests/mixed-type-safety-1.cpp2
index d7fb8adf99..d8d0a1836b 100644
--- a/regression-tests/mixed-type-safety-1.cpp2
+++ b/regression-tests/mixed-type-safety-1.cpp2
@@ -8,23 +8,18 @@ class Shape { public: virtual ~Shape() { } };
 class Circle : public Shape { };
 class Square : public Shape { };
 
-//--- printing helpers -----------------
+//--- printing setup -------------------
 
 print: ( msg: std::string, x: _ ) =
     std::cout << msg << x << "\n";
 
-print: ( msg: std::string, b: bool ) =
+
+main: () -> int =
 {
-    bmsg: * const char;
-    if b { bmsg = "true";  }
-    else { bmsg = "false"; }
-    std::cout << msg << bmsg << "\n";
-}
+    std::cout << std::boolalpha;
 
 //--- examples -------------------------
 
-main: () -> int = 
-{
     print( "1.1 is int? ", 1.1 is int );
     print( "1   is int? ", 1   is int );
 
diff --git a/regression-tests/pure2-bugfix-for-optimizing-inspect.cpp2 b/regression-tests/pure2-bugfix-for-optimizing-inspect.cpp2
new file mode 100644
index 0000000000..0ee0f35dc8
--- /dev/null
+++ b/regression-tests/pure2-bugfix-for-optimizing-inspect.cpp2
@@ -0,0 +1,151 @@
+main: () = {
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      // Condition is `false_type` for `int`, alternative not instantiated.
+      is std::string = x.substr(0);
+      is _           = true;
+    }]]
+  }(1);
+
+  {
+    pred := :<T> (y: T) -> std::true_type = {
+      std::terminate();
+      return ();
+    };
+    [[assert Testing: inspect 1 -> bool {
+      // Condition is `true_type` for `int`, statement unconditionally executed.
+      is (pred) = true;
+      is _      = false;
+    }]]
+  }
+
+  _ = :(x) = {
+    pred := :<T> (y: T) -> bool requires std::is_same_v<T, long> = {
+      std::terminate();
+      return true;
+    };
+    [[assert Testing: inspect x -> bool {
+      // Condition is non-viable for `int`, alternative not instantiated.
+      is (pred) = x.substr(0);
+      is _      = true;
+    }]]
+  }(1);
+
+  // Exercise all built-in `is` overloads.
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is std::vector          = x.substr(0);
+      is std::array           = x.substr(0);
+      is std::string          = x.substr(0);
+      is std::exception       = x.substr(0);
+      is cpp2::empty          = x.substr(0);
+      is (std::ranges::empty) = x.substr(0);
+      is ("")                 = x.substr(0);
+      is _                    = true;
+    }]]
+  }(1);
+  _ = :(x) = {
+    [[assert Testing: inspect x& -> bool {
+      is std::exception = x.substr(0);
+      is _              = true;
+    }]]
+  }(1);
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is std::vector = true;
+      is _           = false;
+    }]]
+  }(:std::vector = (1));
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is std::array = true;
+      is _          = false;
+    }]]
+  }(:std::array = (1));
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is int = true;
+      is _   = false;
+    }]]
+  }(1);
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      // FIXME
+      // Using `std::ranges::subrange<std::add_pointer_t<i32>>::view_interface` fails.
+      // The alternative is elided due to the `is` being ambiguous.
+      // Like in P2392, the cases of the built-in `is` should be a chain of conditions.
+      // Using overloads to implement that is tedious and error-prone.
+      is std::ranges::view_interface<std::ranges::subrange<std::add_pointer_t<i32>>> = true;
+      is _                                                                           = false;
+    }]]
+  }(:std::ranges::subrange<std::add_pointer_t<i32>> = ());
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is std::exception = true;
+      is _              = false;
+    }]]
+  }(:std::bad_exception = ());
+
+  _ = :(x) = {
+    [[assert Testing: inspect x& -> bool {
+      is std::exception = true;
+      is _              = false;
+    }]]
+  }(:std::bad_exception = ());
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is cpp2::empty = true;
+      is _           = false;
+    }]]
+  }(:std::optional<i32> = ());
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is (std::ranges::empty) = true;
+      is _                    = false;
+    }]]
+  }(:std::vector<i32> = ());
+
+  _ = :(x) = {
+    [[assert Testing: inspect x -> bool {
+      is (1) = true;
+      is _   = false;
+    }]]
+  }(1);
+
+  // Exercise `is` overloads for `std::` types.
+
+  {
+    f := :(x) = {
+      (pred := :<T> (y: T) -> bool requires std::is_same_v<T, i32> = {
+        std::terminate();
+        return true;
+      })
+        [[assert Testing: inspect x -> bool {
+          is (:std::span<i32> = ()) = x.substr(0);
+          is (pred)                 = x.substr(0);
+          is (1)                    = true;
+          is _                      = false;
+        }]]
+
+      (pred := :<T> (y: T) -> std::true_type = {
+        std::terminate();
+        return ();
+      }) {
+        [[assert Testing: inspect x -> bool {
+          is (pred) = true;
+          is _      = false;
+        }]]
+      }
+    };
+    f(:std::any      = 1);
+    f(:std::optional = 1);
+  }
+}
diff --git a/regression-tests/test-results/gcc-13/pure2-bugfix-for-optimizing-inspect.cpp.execution b/regression-tests/test-results/gcc-13/pure2-bugfix-for-optimizing-inspect.cpp.execution
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/regression-tests/test-results/gcc-13/pure2-bugfix-for-optimizing-inspect.cpp.output b/regression-tests/test-results/gcc-13/pure2-bugfix-for-optimizing-inspect.cpp.output
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/regression-tests/test-results/mixed-inspect-templates.cpp b/regression-tests/test-results/mixed-inspect-templates.cpp
index 9d0b42766a..f0eb8990f9 100644
--- a/regression-tests/test-results/mixed-inspect-templates.cpp
+++ b/regression-tests/test-results/mixed-inspect-templates.cpp
@@ -33,12 +33,12 @@ struct my_type {};
 #line 8 "mixed-inspect-templates.cpp2"
 [[nodiscard]] auto fun(auto const& v) -> std::string{
     return [&] () -> std::string { auto&& __expr = v;
-        if (cpp2::is<std::vector>(__expr)) { if constexpr( requires{"std::vector";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::vector")),std::string> ) return "std::vector"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::array>(__expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<my_type>(__expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; else return std::string{}; else return std::string{}; }
-        else return "unknown"; }
-    (); 
+        if constexpr (requires { cpp2::is<std::vector>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::true_type>) { return "std::vector"; } else { if (cpp2::is<std::vector>(__expr)) { return "std::vector"; } } } }
+        if constexpr (requires { cpp2::is<std::array>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::true_type>) { return "std::array"; } else { if (cpp2::is<std::array>(__expr)) { return "std::array"; } } } }
+        if constexpr (requires { cpp2::is<std::variant>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::variant>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::variant>(__expr)), std::true_type>) { return "std::variant";  } else { if (cpp2::is<std::variant>(__expr)) { return "std::variant";  } } } }
+        if constexpr (requires { cpp2::is<my_type>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<my_type>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<my_type>(__expr)), std::true_type>) { return "my_type"; } else { if (cpp2::is<my_type>(__expr)) { return "my_type"; } } } }
+        return "unknown";
+    }(); 
 }
 
 [[nodiscard]] auto fun2(auto const& v) -> std::string{
diff --git a/regression-tests/test-results/mixed-inspect-values-2.cpp b/regression-tests/test-results/mixed-inspect-values-2.cpp
index 4b2cde6324..58a7380d10 100644
--- a/regression-tests/test-results/mixed-inspect-values-2.cpp
+++ b/regression-tests/test-results/mixed-inspect-values-2.cpp
@@ -39,10 +39,10 @@ constexpr auto empty = [](auto&& x){
     auto i {15}; 
 
     std::cout << [&] () -> std::string { auto&& __expr = i;
-        if (cpp2::is(__expr, (less_than(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
-        else return "i is out of our interest"; }
-    () << std::endl;
+        if constexpr (requires { cpp2::is(__expr, (less_than(10))); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (less_than(10)))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (less_than(10)))), std::true_type>) { return "i less than 10";  } else { if (cpp2::is(__expr, (less_than(10)))) { return "i less than 10";  } } } }
+        if constexpr (requires { cpp2::is(__expr, in(11, 20)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, in(11, 20))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, in(11, 20))), std::true_type>) { return "i is between 11 and 20";  } else { if (cpp2::is(__expr, in(11, 20))) { return "i is between 11 and 20";  } } } }
+        return "i is out of our interest";
+    }() << std::endl;
 
     if (cpp2::is(i, (less_than(20)))) {
         std::cout << "less than 20" << std::endl;
diff --git a/regression-tests/test-results/mixed-inspect-values.cpp b/regression-tests/test-results/mixed-inspect-values.cpp
index d4e0430e76..a3882dd805 100644
--- a/regression-tests/test-results/mixed-inspect-values.cpp
+++ b/regression-tests/test-results/mixed-inspect-values.cpp
@@ -56,13 +56,13 @@ auto test(auto const& x) -> void;
 auto test(auto const& x) -> void{
     auto forty_two {42}; 
     std::cout << [&] () -> std::string { auto&& __expr = x;
-        if (cpp2::is(__expr, 0)) { if constexpr( requires{"zero";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("zero")),std::string> ) return "zero"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, (in(1, 2)))) { if constexpr( requires{"1 or 2";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("1 or 2")),std::string> ) return "1 or 2"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, in_2_3)) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); else return std::string{}; else return std::string{}; }
-        else return "(no match)"; }
-    () << "\n";
+        if constexpr (requires { cpp2::is(__expr, 0); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, 0)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, 0)), std::true_type>) { return "zero"; } else { if (cpp2::is(__expr, 0)) { return "zero"; } } } }
+        if constexpr (requires { cpp2::is(__expr, (in(1, 2))); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (in(1, 2)))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (in(1, 2)))), std::true_type>) { return "1 or 2"; } else { if (cpp2::is(__expr, (in(1, 2)))) { return "1 or 2"; } } } }
+        if constexpr (requires { cpp2::is(__expr, in_2_3); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, in_2_3)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, in_2_3)), std::true_type>) { return "3"; } else { if (cpp2::is(__expr, in_2_3)) { return "3"; } } } }
+        if constexpr (requires { cpp2::is(__expr, std::move(forty_two)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, std::move(forty_two))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, std::move(forty_two))), std::true_type>) { return "the answer";  } else { if (cpp2::is(__expr, std::move(forty_two))) { return "the answer";  } } } }
+        if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return "integer " + cpp2::to_string(x); } else { if (cpp2::is<int>(__expr)) { return "integer " + cpp2::to_string(x); } } } }
+        if constexpr (requires { cpp2::is<std::string>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::true_type>) { return cpp2::as<std::string>(x);  } else { if (cpp2::is<std::string>(__expr)) { return cpp2::as<std::string>(x);  } } } }
+        return "(no match)";
+    }() << "\n";
 }
 
diff --git a/regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp b/regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp
index 9698ad3b5c..0ea122dbc6 100644
--- a/regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp
+++ b/regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp
@@ -29,9 +29,9 @@ auto calc() {
 #line 7 "mixed-inspect-with-typeof-of-template-arg-list.cpp2"
 [[nodiscard]] auto fun(auto const& v) -> int{
     return [&] () -> int { auto&& __expr = v;
-        if (cpp2::is<int>(__expr)) { if constexpr( requires{calc<1,2>();} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((calc<1,2>())),int> ) return calc<1,2>(); else return int{}; else return int{}; }
-        else return 0; }
-    (); 
+        if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return calc<1,2>(); } else { if (cpp2::is<int>(__expr)) { return calc<1,2>(); } } } }
+        return 0;
+    }(); 
 }
 
 [[nodiscard]] auto main() -> int{
diff --git a/regression-tests/test-results/mixed-type-safety-1.cpp b/regression-tests/test-results/mixed-type-safety-1.cpp
index 4d07c63c3a..7aa7f5cfa0 100644
--- a/regression-tests/test-results/mixed-type-safety-1.cpp
+++ b/regression-tests/test-results/mixed-type-safety-1.cpp
@@ -19,17 +19,13 @@ class Shape { public: virtual ~Shape() { } };
 class Circle : public Shape { };
 class Square : public Shape { };
 
-//--- printing helpers -----------------
+//--- printing setup -------------------
 
 #line 13 "mixed-type-safety-1.cpp2"
 auto print(cpp2::in<std::string> msg, auto const& x) -> void;
     
 
-auto print(cpp2::in<std::string> msg, cpp2::in<bool> b) -> void;
-
-#line 24 "mixed-type-safety-1.cpp2"
-//--- examples -------------------------
-
+#line 17 "mixed-type-safety-1.cpp2"
 [[nodiscard]] auto main() -> int;
 
 
@@ -40,17 +36,13 @@ auto print(cpp2::in<std::string> msg, cpp2::in<bool> b) -> void;
 auto print(cpp2::in<std::string> msg, auto const& x) -> void { 
     std::cout << msg << x << "\n";  }
 
-auto print(cpp2::in<std::string> msg, cpp2::in<bool> b) -> void
-{
-    cpp2::deferred_init<char const*> bmsg; 
-    if (b) { bmsg.construct("true");}
-    else {bmsg.construct("false"); }
-    std::cout << msg << std::move(bmsg.value()) << "\n";
-}
-
-#line 26 "mixed-type-safety-1.cpp2"
+#line 17 "mixed-type-safety-1.cpp2"
 [[nodiscard]] auto main() -> int
 {
+    std::cout << std::boolalpha;
+
+//--- examples -------------------------
+
     print("1.1 is int? ", cpp2::is<int>(1.1));
     print( "1   is int? ", cpp2::is<int>(1));
 
diff --git a/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp b/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp
new file mode 100644
index 0000000000..5da2bd33b4
--- /dev/null
+++ b/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp
@@ -0,0 +1,178 @@
+
+#define CPP2_USE_MODULES         Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-bugfix-for-optimizing-inspect.cpp2"
+auto main() -> int;
+  
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-bugfix-for-optimizing-inspect.cpp2"
+auto main() -> int{
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      // Condition is `false_type` for `int`, alternative not instantiated.
+      if constexpr (requires { cpp2::is<std::string>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0);  } else { if (cpp2::is<std::string>(__expr)) { return CPP2_UFCS(substr, x, 0);  } } } }
+      return true;
+    }(), "");
+  }(1);
+
+  {
+    auto pred {[]<typename T>(T const& y) -> std::true_type{
+      std::terminate();
+      return {  }; 
+    }}; 
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = 1;
+      // Condition is `true_type` for `int`, statement unconditionally executed.
+      if constexpr (requires { cpp2::is(__expr, (std::move(pred))); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (std::move(pred)))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (std::move(pred)))), std::true_type>) { return true;  } else { if (cpp2::is(__expr, (std::move(pred)))) { return true;  } } } }
+      return false;
+    }(), "");
+  }
+
+  (void) [](auto const& x) -> void{
+    auto pred {[]<typename T>(T const& y) -> bool
+requires (std::is_same_v<T,long>)
+#line 23 "pure2-bugfix-for-optimizing-inspect.cpp2"
+    {
+      std::terminate();
+      return true; 
+    }}; 
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      // Condition is non-viable for `int`, alternative not instantiated.
+      if constexpr (requires { cpp2::is(__expr, (std::move(pred))); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (std::move(pred)))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (std::move(pred)))), std::true_type>) { return CPP2_UFCS(substr, x, 0);  } else { if (cpp2::is(__expr, (std::move(pred)))) { return CPP2_UFCS(substr, x, 0);  } } } }
+      return true;
+    }(), "");
+  }(1);
+
+  // Exercise all built-in `is` overloads.
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<std::vector>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is<std::vector>(__expr)) { return CPP2_UFCS(substr, x, 0); } } } }
+      if constexpr (requires { cpp2::is<std::array>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is<std::array>(__expr)) { return CPP2_UFCS(substr, x, 0); } } } }
+      if constexpr (requires { cpp2::is<std::string>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is<std::string>(__expr)) { return CPP2_UFCS(substr, x, 0); } } } }
+      if constexpr (requires { cpp2::is<std::exception>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is<std::exception>(__expr)) { return CPP2_UFCS(substr, x, 0); } } } }
+      if constexpr (requires { cpp2::is<cpp2::empty>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<cpp2::empty>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<cpp2::empty>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is<cpp2::empty>(__expr)) { return CPP2_UFCS(substr, x, 0); } } } }
+      if constexpr (requires { cpp2::is(__expr, (std::ranges::empty)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (std::ranges::empty))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (std::ranges::empty))), std::true_type>) { return CPP2_UFCS(substr, x, 0);  } else { if (cpp2::is(__expr, (std::ranges::empty))) { return CPP2_UFCS(substr, x, 0);  } } } }
+      if constexpr (requires { cpp2::is(__expr, ""); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, "")), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, "")), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is(__expr, "")) { return CPP2_UFCS(substr, x, 0); } } } }
+      return true;
+    }(), "");
+  }(1);
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = &x;
+      if constexpr (requires { cpp2::is<std::exception>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::true_type>) { return CPP2_UFCS(substr, x, 0);  } else { if (cpp2::is<std::exception>(__expr)) { return CPP2_UFCS(substr, x, 0);  } } } }
+      return true;
+    }(), "");
+  }(1);
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<std::vector>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::vector>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<std::vector>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::vector{1});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<std::array>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::array>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<std::array>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::array{1});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<int>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(1);
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      // FIXME
+      // Using `std::ranges::subrange<std::add_pointer_t<i32>>::view_interface` fails.
+      // The alternative is elided due to the `is` being ambiguous.
+      // Like in P2392, the cases of the built-in `is` should be a chain of conditions.
+      // Using overloads to implement that is tedious and error-prone.
+      if constexpr (requires { cpp2::is<std::ranges::view_interface<std::ranges::subrange<std::add_pointer_t<cpp2::i32>>>>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::ranges::view_interface<std::ranges::subrange<std::add_pointer_t<cpp2::i32>>>>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::ranges::view_interface<std::ranges::subrange<std::add_pointer_t<cpp2::i32>>>>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<std::ranges::view_interface<std::ranges::subrange<std::add_pointer_t<cpp2::i32>>>>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::ranges::subrange<std::add_pointer_t<cpp2::i32>>{});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<std::exception>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<std::exception>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::bad_exception{});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = &x;
+      if constexpr (requires { cpp2::is<std::exception>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::exception>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<std::exception>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::bad_exception{});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is<cpp2::empty>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<cpp2::empty>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<cpp2::empty>(__expr)), std::true_type>) { return true;  } else { if (cpp2::is<cpp2::empty>(__expr)) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::optional<cpp2::i32>{});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is(__expr, (std::ranges::empty)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (std::ranges::empty))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (std::ranges::empty))), std::true_type>) { return true;  } else { if (cpp2::is(__expr, (std::ranges::empty))) { return true;  } } } }
+      return false;
+    }(), "");
+  }(std::vector<cpp2::i32>{});
+
+  (void) [](auto const& x) -> void{
+    cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+      if constexpr (requires { cpp2::is(__expr, (1)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (1))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (1))), std::true_type>) { return true;  } else { if (cpp2::is(__expr, (1))) { return true;  } } } }
+      return false;
+    }(), "");
+  }(1);
+
+  // Exercise `is` overloads for `std::` types.
+
+  {
+    auto f {[](auto const& x) -> void{
+{
+auto const& pred = []<typename T>(T const& y) -> bool
+requires (std::is_same_v<T,cpp2::i32>){std::terminate();return true; };
+
+#line 131 "pure2-bugfix-for-optimizing-inspect.cpp2"
+        cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+          if constexpr (requires { cpp2::is(__expr, (std::span<cpp2::i32>{})); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (std::span<cpp2::i32>{}))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (std::span<cpp2::i32>{}))), std::true_type>) { return CPP2_UFCS(substr, x, 0);  } else { if (cpp2::is(__expr, (std::span<cpp2::i32>{}))) { return CPP2_UFCS(substr, x, 0);  } } } }
+          if constexpr (requires { cpp2::is(__expr, pred); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, pred)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, pred)), std::true_type>) { return CPP2_UFCS(substr, x, 0); } else { if (cpp2::is(__expr, pred)) { return CPP2_UFCS(substr, x, 0); } } } }
+          if constexpr (requires { cpp2::is(__expr, 1); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, 1)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, 1)), std::true_type>) { return true; } else { if (cpp2::is(__expr, 1)) { return true; } } } }
+          return false;
+        }(), "");
+}
+{
+auto const& pred = []<typename T>(T const& y) -> std::true_type{std::terminate();return {  }; };
+
+#line 141 "pure2-bugfix-for-optimizing-inspect.cpp2"
+      {
+        cpp2::Testing.expects([&] () -> bool { auto&& __expr = x;
+          if constexpr (requires { cpp2::is(__expr, (pred)); }) { if constexpr (!std::is_same_v<decltype(cpp2::is(__expr, (pred))), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is(__expr, (pred))), std::true_type>) { return true;  } else { if (cpp2::is(__expr, (pred))) { return true;  } } } }
+          return false;
+        }(), "");
+      }
+}
+#line 147 "pure2-bugfix-for-optimizing-inspect.cpp2"
+    }}; 
+    f(std::any{   1});
+    std::move(f)(std::optional{1});
+  }
+}
+
diff --git a/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp2.output b/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp2.output
new file mode 100644
index 0000000000..093d1ebbf0
--- /dev/null
+++ b/regression-tests/test-results/pure2-bugfix-for-optimizing-inspect.cpp2.output
@@ -0,0 +1,2 @@
+pure2-bugfix-for-optimizing-inspect.cpp2... ok (all Cpp2, passes safety checks)
+
diff --git a/regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp b/regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp
index 6a879b6562..84c69e2741 100644
--- a/regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp
+++ b/regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp
@@ -45,10 +45,10 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << std::setw(30) << msg 
         << " value is " 
         << [&] () -> std::string { auto&& __expr = x;
-            if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + std::to_string(cpp2::as<int>(x)))),std::string> ) return "integer " + std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
-            else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{'"' + cpp2::as<std::string>(x) + '"';} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(('"' + cpp2::as<std::string>(x) + '"')),std::string> ) return '"' + cpp2::as<std::string>(x) + '"'; else return std::string{}; else return std::string{}; }
-            else return "not an int or string"; }
-        () 
+            if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return "integer " + std::to_string(cpp2::as<int>(x));  } else { if (cpp2::is<int>(__expr)) { return "integer " + std::to_string(cpp2::as<int>(x));  } } } }
+            if constexpr (requires { cpp2::is<std::string>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::true_type>) { return '"' + cpp2::as<std::string>(x) + '"';  } else { if (cpp2::is<std::string>(__expr)) { return '"' + cpp2::as<std::string>(x) + '"';  } } } }
+            return "not an int or string";
+        }() 
         << "\n";
 }
 
diff --git a/regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp b/regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp
index 422360f099..f8a3b2044a 100644
--- a/regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp
+++ b/regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp
@@ -32,9 +32,9 @@ auto print_an_int(auto const& x) -> void{
         << std::setw(30) << cpp2::to_string(x) 
         << " value is " 
         << [&] () -> std::string { auto&& __expr = x;
-            if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
-            else return "not an int"; }
-        () 
+            if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return std::to_string(cpp2::as<int>(x));  } else { if (cpp2::is<int>(__expr)) { return std::to_string(cpp2::as<int>(x));  } } } }
+            return "not an int";
+        }() 
         << "\n";
 }
 
diff --git a/regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp b/regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp
index 7d7662bdcd..43c2c2e56f 100644
--- a/regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp
+++ b/regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp
@@ -39,12 +39,12 @@ auto test_generic(auto const& x, auto const& msg) -> void{
     std::cout 
         << "\n" << msg << "\n    ..." 
         << [&] () -> std::string { auto&& __expr = x;
-            if (cpp2::is<std::string>(__expr)) { if constexpr( requires{" matches std::string";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::string")),std::string> ) return " matches std::string"; else return std::string{}; else return std::string{}; }
-            else if (cpp2::is<std::variant<int,std::string>>(__expr)) { if constexpr( requires{" matches std::variant<int, std::string>";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::variant<int, std::string>")),std::string> ) return " matches std::variant<int, std::string>"; else return std::string{}; else return std::string{}; }
-            else if (cpp2::is<std::any>(__expr)) { if constexpr( requires{" matches std::any";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::any")),std::string> ) return " matches std::any"; else return std::string{}; else return std::string{}; }
-            else if (cpp2::is<std::optional<std::string>>(__expr)) { if constexpr( requires{" matches std::optional<std::string>";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::optional<std::string>")),std::string> ) return " matches std::optional<std::string>"; else return std::string{}; else return std::string{}; }
-            else return " no match"; }
-        () 
+            if constexpr (requires { cpp2::is<std::string>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::string>(__expr)), std::true_type>) { return " matches std::string";  } else { if (cpp2::is<std::string>(__expr)) { return " matches std::string";  } } } }
+            if constexpr (requires { cpp2::is<std::variant<int,std::string>>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::variant<int,std::string>>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::variant<int,std::string>>(__expr)), std::true_type>) { return " matches std::variant<int, std::string>";  } else { if (cpp2::is<std::variant<int,std::string>>(__expr)) { return " matches std::variant<int, std::string>";  } } } }
+            if constexpr (requires { cpp2::is<std::any>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::any>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::any>(__expr)), std::true_type>) { return " matches std::any";  } else { if (cpp2::is<std::any>(__expr)) { return " matches std::any";  } } } }
+            if constexpr (requires { cpp2::is<std::optional<std::string>>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<std::optional<std::string>>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<std::optional<std::string>>(__expr)), std::true_type>) { return " matches std::optional<std::string>";  } else { if (cpp2::is<std::optional<std::string>>(__expr)) { return " matches std::optional<std::string>";  } } } }
+            return " no match";
+        }() 
         << "\n";
 }
 
diff --git a/regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp b/regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp
index 24cb1df600..addde5a856 100644
--- a/regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp
+++ b/regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp
@@ -43,9 +43,9 @@ auto test_generic(auto const& x, auto const& msg) -> void{
     std::cout 
         << "\n" << msg << "\n    ..." 
         << [&] () -> std::string { auto&& __expr = x;
-            if (cpp2::is<void>(__expr)) { if constexpr( requires{" VOYDE AND EMPTIE";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" VOYDE AND EMPTIE")),std::string> ) return " VOYDE AND EMPTIE"; else return std::string{}; else return std::string{}; }
-            else return " no match"; }
-        () 
+            if constexpr (requires { cpp2::is<void>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<void>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<void>(__expr)), std::true_type>) { return " VOYDE AND EMPTIE";  } else { if (cpp2::is<void>(__expr)) { return " VOYDE AND EMPTIE";  } } } }
+            return " no match";
+        }() 
         << "\n";
 }
 
diff --git a/regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp b/regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp
index 16da06a01d..aeecc9aabd 100644
--- a/regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp
+++ b/regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp
@@ -45,9 +45,9 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << std::setw(30) << msg 
         << " value is " 
         << [&] () -> std::string { auto&& __expr = x;
-            if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
-            else return "not an int"; }
-        () 
+            if constexpr (requires { cpp2::is<int>(__expr); }) { if constexpr (!std::is_same_v<decltype(cpp2::is<int>(__expr)), std::false_type>) { if constexpr (std::is_same_v<decltype(cpp2::is<int>(__expr)), std::true_type>) { return std::to_string(cpp2::as<int>(x));  } else { if (cpp2::is<int>(__expr)) { return std::to_string(cpp2::as<int>(x));  } } } }
+            return "not an int";
+        }() 
         << "\n";
 }
 
diff --git a/source/cppfront.cpp b/source/cppfront.cpp
index 5b89964d3a..1332427a6f 100644
--- a/source/cppfront.cpp
+++ b/source/cppfront.cpp
@@ -197,7 +197,7 @@ class positional_printer
     std::vector<comment> const* pcomments       = {}; // Cpp2 comments data
     source const*               psource         = {};
     parser const*               pparser         = {};
-                                                
+
     source_position curr_pos                    = {}; // current (line,col) in output
     lineno_t        generated_pos_line          = {}; // current line in generated output
     int             last_line_indentation       = {};
@@ -1226,7 +1226,7 @@ class cppfront
 
         //---------------------------------------------------------------------
         //  Do lowered file prolog
-        // 
+        //
         //  Only emit extra lines if we actually have Cpp2, because
         //  we want pure-Cpp1 files to pass through with zero changes
         if (source.has_cpp2())
@@ -1284,7 +1284,7 @@ class cppfront
             }
         }
 
-        
+
         //---------------------------------------------------------------------
         //  Do phase1_type_defs_func_decls
         //
@@ -1641,7 +1641,7 @@ class cppfront
         {
             add_move = false;
         }
-    
+
         if (
             emitting_move_that_function
             && *n.identifier == "that"
@@ -1911,10 +1911,6 @@ class cppfront
         for (auto first = true; auto&& alt : n.alternatives)
         {
             assert(alt && alt->is_as_keyword);
-            if (!first) {
-                printer.print_cpp2("else ", alt->position());
-            }
-            first = false;
 
             auto id = std::string{};
             printer.emit_to_string(&id);
@@ -1938,64 +1934,46 @@ class cppfront
             {
                 //  Stringize the expression-statement now...
                 auto statement = std::string{};
+                if (is_expression) {
+                    statement = "return ";
+                }
                 printer.emit_to_string(&statement);
                 emit(*alt->statement);
                 printer.emit_to_string();
-                //  ... and jettison the final ; for an expression-statement
-                while (
-                    !statement.empty()
-                    && (
-                        statement.back() == ';'
-                        || isspace(statement.back())
-                        )
-                    )
-                {
-                    statement.pop_back();
-                }
 
                 replace_all( statement, "cpp2::as_<", "cpp2::as<" );
 
-                //  If this is an inspect-expression, we'll have to wrap each alternative
-                //  in an 'if constexpr' so that its type is ignored for mismatches with
-                //  the inspect-expression's type
-                auto return_prefix = std::string{};
-                auto return_suffix = std::string{";"};   // use this to tack the ; back on in the alternative body
-                if (is_expression) {
-                    return_prefix = "{ if constexpr( requires{" + statement + ";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" + statement + "))," + result_type + "> ) return ";
-                    return_suffix += " }";
-                }
 
                 if (id == "auto") {
                     found_wildcard = true;
-                    if (is_expression) {
-                        printer.print_cpp2("return ", alt->position());
-                    }
+                    printer.print_cpp2(statement, alt->position());
                 }
                 else {
-                    printer.print_cpp2("if " + constexpr_qualifier, alt->position());
+                    auto is_expression = std::string{};
                     if (alt->type_id) {
-                        printer.print_cpp2("(cpp2::is<" + id + ">(__expr)) ", alt->position());
+                        is_expression = "cpp2::is<" + id + ">(__expr)";
                     }
                     else {
                         assert (alt->value);
-                        printer.print_cpp2("(cpp2::is(__expr, " + id + ")) ", alt->position());
+                        is_expression = "cpp2::is(__expr, " + id + ")";
                     }
-                    printer.print_cpp2(return_prefix, alt->position());
-                }
-
-                printer.print_cpp2(statement, alt->position());
 
-                if (
-                    is_expression
-                    && id != "auto"
-                    )
-                {
-                    assert(alt->statement->is_expression());
-                    printer.print_cpp2("; else return " + result_type + "{}", alt->position());
-                    printer.print_cpp2("; else return " + result_type + "{}", alt->position());
+                    printer.print_cpp2("if constexpr (requires { ", alt->position());
+                    printer.print_cpp2(is_expression, alt->position());
+                    printer.print_cpp2("; }) { if constexpr (!std::is_same_v<decltype(", alt->position());
+                    printer.print_cpp2(is_expression, alt->position());
+                    printer.print_cpp2("), std::false_type>) { if constexpr (std::is_same_v<decltype(", alt->position());
+                    printer.print_cpp2(is_expression, alt->position());
+                    printer.print_cpp2("), std::true_type>) { ", alt->position());
+                    printer.print_cpp2(statement, alt->position());
+                    printer.print_cpp2(" } else { if ", alt->position());
+                    printer.print_cpp2(constexpr_qualifier, alt->position());
+                    printer.print_cpp2("(", alt->position());
+                    printer.print_cpp2(is_expression, alt->position());
+                    printer.print_cpp2(") { ", alt->position());
+                    printer.print_cpp2(statement, alt->position());
+                    printer.print_cpp2(" } } } }", alt->position());
                 }
-
-                printer.print_cpp2(return_suffix, alt->position());
             }
             else {
                 errors.emplace_back(
@@ -2015,9 +1993,7 @@ class cppfront
                 return;
             }
         }
-        else {
-            printer.print_cpp2("}", n.close_brace);
-        }
+        printer.print_cpp2("}", n.close_brace);
 
         //  If this is an expression, finally actually invoke the lambda
         if (is_expression) {
@@ -2253,7 +2229,7 @@ class cppfront
                     return;
                 } else if (
                     is_literal(tok->type()) || n.expression->expr->is_result_a_temporary_variable()
-                ) 
+                )
                 {
                     errors.emplace_back(
                         n.position(),
@@ -2545,7 +2521,7 @@ class cppfront
     )
         -> bool
     {
-        if (!fun_node) { 
+        if (!fun_node) {
             return false;
         }
         if (addr_cnt > deref_cnt) {
@@ -2572,11 +2548,11 @@ class cppfront
     )
         -> bool
     {
-        if (!type_id_node) { 
+        if (!type_id_node) {
             return false;
         }
         if (addr_cnt > deref_cnt) {
-            return true; 
+            return true;
         }
 
         if ( type_id_node->dereference_of ) {
@@ -2753,7 +2729,7 @@ class cppfront
             {
                 auto& unqual = std::get<id_expression_node::unqualified>(id->id);
                 assert(unqual);
-                //  TODO: Generalize this: 
+                //  TODO: Generalize this:
                 //        - we don't recognize pointer types from Cpp1
                 //        - we don't deduce pointer types from parameter_declaration_list_node
                 if ( is_pointer_declaration(unqual->identifier) ) {
@@ -4815,7 +4791,7 @@ class cppfront
         }
 
         //  If this is a generated declaration (negative source line number),
-        //  add a line break before 
+        //  add a line break before
         if (
             printer.get_phase() == printer.phase2_func_defs
             && n.position().lineno < 1
@@ -5450,7 +5426,7 @@ class cppfront
                             //  A2) This is '(out   this, move that)'
                             //      and no  '(inout this, move that)' was written by the user
                             //  (*) and no  '(inout this,      that)' was written by the user (*)
-                            //  
+                            //
                             //  (*) This third test is to tie-break M2 and A2 in favor of M2. Both M2 and A2
                             //      can generate a missing '(inout this, move that)', and if we have both
                             //      options then we should prefer to use M2 (generate move assignment from
@@ -5636,7 +5612,7 @@ class cppfront
                 printer.preempt_position_push( n.equal_sign );
 
                 //  *** NOTE =====================================================
-                // 
+                //
                 //      This branch to emit the requires-clause should maybe be
                 //      moved to location (A) above, so that it's also emitted
                 //      on the function declaration. But moving it to (A) triggers
@@ -5644,14 +5620,14 @@ class cppfront
                 //      break using a 'forward' parameter of a concrete type and
                 //      also explicitly user-written requires-clauses that do
                 //      similar decltype tests.
-                // 
+                //
                 //      I don't want to neednessly break compatibility with a
                 //      decently conforming C++20 compiler that works well for
                 //      everything else that Cpp2 needs from C++20. If the
                 //      'requires' down here doesn't cause a problem, I'll keep
                 //      it here for now... if we do encounter a reason it needs to
                 //      also be on the declaration, move this code to (A).
-                // 
+                //
                 //  Handle requires clause - an explicit one the user wrote,
                 //  and/or any conditions we generated while processing the
                 //  parameters (i.e., forwarding a concrete type)