From 6cc4ea72bc8b952fffdc54bde244d53d679d7e10 Mon Sep 17 00:00:00 2001
From: Filip Sajdak <filip.sajdak@gmail.com>
Date: Sun, 14 Apr 2024 13:31:22 +0200
Subject: [PATCH 1/5] Extend is() to handle free function predicates

This change address to issues:
1. implicit downcasting of arguments,
2. add support for predicates with generic type argument

1. Currently, if is() is checked against predicate the predicate argument
can be implicitly casted that can lead to downcasting double to int

    equal_pi: (x:int) -> bool = { return x == 3; };

    d := 3.14;

    if d is (equal_pi) { // d will be casted to int and will return true
      // ...
    }

After this change downcasting will not happen no false positive/negative
matches will happen.

2. Currently, if is() is checked against predicate with generic type
it does not compile.

After this change the code will compile and work as expected.
---
 include/cpp2util.h                            | 79 ++++++++++++++++++-
 ...ure2-is-with-free-functions-predicate.cpp2 | 31 ++++++++
 .../mixed-inspect-values.cpp.execution        |  2 +-
 ...ith-free-functions-predicate.cpp.execution |  6 ++
 ...s-with-free-functions-predicate.cpp.output |  0
 ...pure2-is-with-free-functions-predicate.cpp | 68 ++++++++++++++++
 ...-with-free-functions-predicate.cpp2.output |  2 +
 7 files changed, 183 insertions(+), 5 deletions(-)
 create mode 100644 regression-tests/pure2-is-with-free-functions-predicate.cpp2
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.execution
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.output
 create mode 100644 regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp
 create mode 100644 regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp2.output

diff --git a/include/cpp2util.h b/include/cpp2util.h
index cffd93ac9..1a560c22a 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -356,6 +356,71 @@ using longdouble = long double;
 using _schar     = signed char;      // normally use i8 instead
 using _uchar     = unsigned char;    // normally use u8 instead
 
+//-----------------------------------------------------------------------
+//
+//  Helper for concepts
+//
+//-----------------------------------------------------------------------
+//
+
+template<typename Ret, typename Arg>
+auto argument_of_helper(Ret(*) (Arg)) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg)) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg) const) -> Arg;
+
+template <typename F>
+auto argument_of_helper(F) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));
+
+template <typename T>
+using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));
+
+template <typename T>
+using pointee_t = std::iter_value_t<T>;
+
+//-----------------------------------------------------------------------
+//
+//  Concepts
+//
+//-----------------------------------------------------------------------
+//
+
+template <typename X>
+concept dereferencable = requires (X x) { *x; };
+
+template <typename X>
+concept default_constructible = std::is_default_constructible_v<std::remove_cvref_t<X>>;
+
+template <typename X>
+concept bounded_array = std::is_bounded_array_v<std::remove_cvref_t<X>>;
+
+template <typename X>
+concept pointer_like = dereferencable<X> && default_constructible<X> && std::equality_comparable<X>
+                       && !bounded_array<X>;
+
+template< typename From, typename To >
+concept brace_initializable_to = requires (From x) { To{x}; };
+
+template< typename X, typename C >
+concept same_type_as = std::same_as<std::remove_cvref_t<X>, std::remove_cvref_t<C>>;
+
+template <typename X>
+concept has_defined_argument = requires {
+	std::declval<argument_of_t<X>>();
+};
+
+template <typename X, typename F>
+concept covertible_to_argument_of = same_type_as<X,argument_of_t<F>>
+                                 || (pointer_like<argument_of_t<F>> && brace_initializable_to<X, pointee_t<argument_of_t<F>>>)
+                                 || (!pointer_like<argument_of_t<F>> && brace_initializable_to<X, argument_of_t<F>>)
+                                 ;
+
+template <typename F, typename X>
+concept valid_predicate = (std::predicate<F, X> && !has_defined_argument<F>)
+                          || (std::predicate<F, X> && has_defined_argument<F> && covertible_to_argument_of<X, F>);
 
 //-----------------------------------------------------------------------
 //
@@ -1225,12 +1290,9 @@ inline constexpr auto is( auto const& x, auto&& value ) -> bool
     }
 
     //  Predicate case
-    else if constexpr (requires{ bool{ value(x) }; }) {
+    else if constexpr (valid_predicate<decltype(value), decltype(x)>) {
         return value(x);
     }
-    else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {
-        return false;
-    }
 
     //  Value equality case
     else if constexpr (requires{ bool{x == value}; }) {
@@ -1239,6 +1301,15 @@ inline constexpr auto is( auto const& x, auto&& value ) -> bool
     return false;
 }
 
+//-----------------------------------------------------------------------
+//
+//  and "is predicate" for generic function used as predicate
+//
+
+template <typename X>
+inline constexpr auto is( X const& x, bool (*value)(X const&) ) -> bool {
+    return value(x);
+}
 
 //-------------------------------------------------------------------------------------------------------------
 //  Built-in as
diff --git a/regression-tests/pure2-is-with-free-functions-predicate.cpp2 b/regression-tests/pure2-is-with-free-functions-predicate.cpp2
new file mode 100644
index 000000000..b2e0f145c
--- /dev/null
+++ b/regression-tests/pure2-is-with-free-functions-predicate.cpp2
@@ -0,0 +1,31 @@
+fun: (v) = {
+    if v is (pred_i) {
+        std::cout << "(v)$ is integer bigger than 3" << std::endl;
+    }
+
+    if v is (pred_d) {
+        std::cout << "(v)$ is double bigger than 3" << std::endl;
+    }
+
+    if v is (pred_) {
+        std::cout << "(v)$ is bigger than 3" << std::endl;
+    }
+}
+
+main: () -> int = {
+    fun(3.14);
+    fun(42);
+    fun('a');
+}
+
+pred_i: (x : int ) -> bool = {
+    return x > 3;
+}
+
+pred_d: (x : double ) -> bool = {
+    return x > 3;
+}
+
+pred_: (x) -> bool = {
+    return x > 3;
+}
diff --git a/regression-tests/test-results/apple-clang-14/mixed-inspect-values.cpp.execution b/regression-tests/test-results/apple-clang-14/mixed-inspect-values.cpp.execution
index 245368cfc..e7130e0f8 100644
--- a/regression-tests/test-results/apple-clang-14/mixed-inspect-values.cpp.execution
+++ b/regression-tests/test-results/apple-clang-14/mixed-inspect-values.cpp.execution
@@ -9,4 +9,4 @@ zero
 3
 integer -42
 xyzzy
-3
+(no match)
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.execution b/regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.output b/regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp b/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp
new file mode 100644
index 000000000..63dbefc80
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp
@@ -0,0 +1,68 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-is-with-free-functions-predicate.cpp2"
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-is-with-free-functions-predicate.cpp2"
+auto fun(auto const& v) -> void;
+
+#line 15 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto main() -> int;
+
+#line 21 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_i(cpp2::impl::in<int> x) -> bool;
+
+#line 25 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_d(cpp2::impl::in<double> x) -> bool;
+
+#line 29 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_(auto const& x) -> bool;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-is-with-free-functions-predicate.cpp2"
+auto fun(auto const& v) -> void{
+#line 2 "pure2-is-with-free-functions-predicate.cpp2"
+    if (cpp2::impl::is(v, (pred_i))) {
+        std::cout << (cpp2::to_string(v) + " is integer bigger than 3") << std::endl;
+    }
+
+    if (cpp2::impl::is(v, (pred_d))) {
+        std::cout << (cpp2::to_string(v) + " is double bigger than 3") << std::endl;
+    }
+
+    if (cpp2::impl::is(v, (pred_))) {
+        std::cout << (cpp2::to_string(v) + " is bigger than 3") << std::endl;
+    }
+}
+
+#line 15 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto main() -> int{
+    fun(3.14);
+    fun(42);
+    fun('a');
+}
+
+#line 21 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_i(cpp2::impl::in<int> x) -> bool{
+    return cpp2::impl::cmp_greater(x,3); 
+}
+
+#line 25 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_d(cpp2::impl::in<double> x) -> bool{
+    return cpp2::impl::cmp_greater(x,3); 
+}
+
+#line 29 "pure2-is-with-free-functions-predicate.cpp2"
+[[nodiscard]] auto pred_(auto const& x) -> bool{
+    return cpp2::impl::cmp_greater(x,3); 
+}
+
diff --git a/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp2.output b/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp2.output
new file mode 100644
index 000000000..cd9cc4aec
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-free-functions-predicate.cpp2.output
@@ -0,0 +1,2 @@
+pure2-is-with-free-functions-predicate.cpp2... ok (all Cpp2, passes safety checks)
+

From 5d533851dd3d7df4f0cd8ade636be32b79d1d73e Mon Sep 17 00:00:00 2001
From: Filip Sajdak <filip.sajdak@gmail.com>
Date: Sun, 14 Apr 2024 13:31:23 +0200
Subject: [PATCH 2/5] Add test for is with unnamed predicates

Adding test for using is with lambdas, and generic lambdas.
---
 .../pure2-is-with-unnamed-predicates.cpp2     | 19 ++++++++
 ...2-is-with-unnamed-predicates.cpp.execution |  6 +++
 ...ure2-is-with-unnamed-predicates.cpp.output |  0
 .../pure2-is-with-unnamed-predicates.cpp      | 44 +++++++++++++++++++
 ...re2-is-with-unnamed-predicates.cpp2.output |  2 +
 5 files changed, 71 insertions(+)
 create mode 100644 regression-tests/pure2-is-with-unnamed-predicates.cpp2
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.execution
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.output
 create mode 100644 regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
 create mode 100644 regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp2.output

diff --git a/regression-tests/pure2-is-with-unnamed-predicates.cpp2 b/regression-tests/pure2-is-with-unnamed-predicates.cpp2
new file mode 100644
index 000000000..d7253551e
--- /dev/null
+++ b/regression-tests/pure2-is-with-unnamed-predicates.cpp2
@@ -0,0 +1,19 @@
+fun: (v) = {
+    if v is (:(x:int) x>3;) {
+        std::cout << "(v)$ is integer bigger than 3" << std::endl;
+    }
+
+    if v is (:(x:double) x>3;) {
+        std::cout << "(v)$ is double bigger than 3" << std::endl;
+    }
+
+    if v is (:(x) x>3;) {
+        std::cout << "(v)$ is bigger than 3" << std::endl;
+    }
+}
+
+main: () -> int = {
+    fun(3.14);
+    fun(42);
+    fun('a');
+}
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.execution b/regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.output b/regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
new file mode 100644
index 000000000..5689749ac
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
@@ -0,0 +1,44 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-is-with-unnamed-predicates.cpp2"
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-is-with-unnamed-predicates.cpp2"
+auto fun(auto const& v) -> void;
+
+#line 15 "pure2-is-with-unnamed-predicates.cpp2"
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-is-with-unnamed-predicates.cpp2"
+auto fun(auto const& v) -> void{
+#line 2 "pure2-is-with-unnamed-predicates.cpp2"
+    if (cpp2::impl::is(v, ([](cpp2::impl::in<int> x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+        std::cout << (cpp2::to_string(v) + " is integer bigger than 3") << std::endl;
+    }
+
+    if (cpp2::impl::is(v, ([](cpp2::impl::in<double> x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+        std::cout << (cpp2::to_string(v) + " is double bigger than 3") << std::endl;
+    }
+
+    if (cpp2::impl::is(v, ([](auto const& x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+        std::cout << (cpp2::to_string(v) + " is bigger than 3") << std::endl;
+    }
+}
+
+#line 15 "pure2-is-with-unnamed-predicates.cpp2"
+[[nodiscard]] auto main() -> int{
+    fun(3.14);
+    fun(42);
+    fun('a');
+}
+
diff --git a/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp2.output b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp2.output
new file mode 100644
index 000000000..6065d9729
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp2.output
@@ -0,0 +1,2 @@
+pure2-is-with-unnamed-predicates.cpp2... ok (all Cpp2, passes safety checks)
+

From 5d00337f9b9efa8f73dc3f8c64b767ec568d536a Mon Sep 17 00:00:00 2001
From: Filip Sajdak <filip.sajdak@gmail.com>
Date: Sun, 14 Apr 2024 13:31:23 +0200
Subject: [PATCH 3/5] Rewrite is() for variables and templates

Adjust to new style of using one function for a match and series
of constexpr ifs.

There is a possibility to extend is() for matching std::integer_sequence
but unfortunatelly clang is not support it (gcc & msvc do).

    template <template <typename, typename, typename...> class C, typename X>
    constexpr auto is( X const& ) {
        if constexpr (specialization_of_template<X, C>) {
            return std::true_type{};
        }
        else {
            return std::false_type{};
        }
    }

    template <template <typename, auto...> class C, typename X>
    constexpr auto is( X const& ) {
        if constexpr (specialization_of_template_type_and_nttp<X, C>) {
            return std::true_type{};
        }
        else {
            return std::false_type{};
        }
    }

Alternatively we can support more matches for gcc & msvc by providing:

    #if defined(__clang__)
        template <template <typename...> class C, typename X>
    #else
        // allow us to support std::integer_sequence on gcc and msvc
        template <template <typename, typename, typename...> class C, typename X>
    #endif
        constexpr auto is( X const& ) {
            if constexpr (specialization_of_template<X, C>) {
                return std::true_type{};
            }
            else {
                return std::false_type{};
            }
        }

    #if defined(__clang__)
        template <template <typename, auto> class C, typename X>
    #else
        // allow us to support std::integer_sequence on gcc and msvc
        template <template <typename, auto...> class C, typename X>
    #endif
        constexpr auto is( X const& ) {
            if constexpr (specialization_of_template_type_and_nttp<X, C>) {
                return std::true_type{};
            }
            else {
                return std::false_type{};
            }
        }
---
 include/cpp2util.h | 56 +++++++++++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 21 deletions(-)

diff --git a/include/cpp2util.h b/include/cpp2util.h
index 1a560c22a..2ba115f75 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -381,6 +381,17 @@ using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));
 template <typename T>
 using pointee_t = std::iter_value_t<T>;
 
+template <template <typename...> class C, typename... Ts>
+constexpr auto specialization_of_template_helper(C< Ts...> const& ) -> std::true_type {
+    return {};
+}
+
+template <template <typename, auto...> class C, typename T, auto... Ns>
+    requires (sizeof...(Ns) > 0)
+constexpr auto specialization_of_template_helper(C< T, Ns... > const& ) -> std::true_type {
+    return {};
+}
+
 //-----------------------------------------------------------------------
 //
 //  Concepts
@@ -388,6 +399,16 @@ using pointee_t = std::iter_value_t<T>;
 //-----------------------------------------------------------------------
 //
 
+template <typename X, template<typename...> class C>
+concept specialization_of_template = requires (X x) {
+    { specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;
+};
+
+template <typename X, template<typename,auto...> class C>
+concept specialization_of_template_type_and_nttp = requires (X x) {
+    { specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;
+};
+
 template <typename X>
 concept dereferencable = requires (X x) { *x; };
 
@@ -1214,31 +1235,24 @@ using empty = void;
 
 //  Templates
 //
-template <template <typename...> class C, typename... Ts>
-constexpr auto is(C< Ts...> const& ) -> bool {
-    return true;
-}
-
-#if defined(_MSC_VER)
-    template <template <typename, typename...> class C, typename T>
-    constexpr auto is( T const& ) -> bool {
-        return false;
+template <template <typename...> class C, typename X>
+constexpr auto is( X&& ) {
+    if constexpr (specialization_of_template<X, C>) {
+        return std::true_type{};
     }
-#else
-    template <template <typename...> class C, typename T>
-    constexpr auto is( T const& ) -> bool {
-        return false;
+    else {
+        return std::false_type{};
     }
-#endif
-
-template <template <typename,auto> class C, typename T, auto V>
-constexpr auto is( C<T, V> const& ) -> bool {
-    return true;
 }
 
-template <template <typename,auto> class C, typename T>
-constexpr auto is( T const& ) -> bool {
-    return false;
+template <template <typename, auto> class C, typename X>
+constexpr auto is( X&& ) {
+    if constexpr (specialization_of_template_type_and_nttp<X, C>) {
+        return std::true_type{};
+    }
+    else {
+        return std::false_type{};
+    }
 }
 
 //  Types

From 1f29e9147b6bfb60ce55988f5f09749b91271911 Mon Sep 17 00:00:00 2001
From: Filip Sajdak <filip.sajdak@gmail.com>
Date: Sun, 14 Apr 2024 13:31:24 +0200
Subject: [PATCH 4/5] Extend is() to correctly handle custom is operator

In current implementation custom is operator (`is_op()` member function)
suffers from implicit casting of its argument. The same issue that were
with function predicates.

After this change we added the check if the cast is lossless or
if the custom is operator is generic function.

Added tests to verify is with various values.

Added new concepts to make checks more readable:
- valid_custom_is_operator
- defined - to check if type is defined (used to determined generic fun)
- predicate_member_fun - to check if member function is a predicate,

Added new type trait:
- argument_of_op_is_t to determined the type of op_is argument,

Correct helper methods:
- argument_of_helper - to handle ref-qualified member functions,
- argument_of_helper - to work with non-copyable types,
---
 include/cpp2util.h                            |  37 ++++++-
 .../pure2-is-with-variable-and-value.cpp2     |  41 +++++++
 ...2-is-with-variable-and-value.cpp.execution |   9 ++
 ...ure2-is-with-variable-and-value.cpp.output |   0
 .../pure2-is-with-variable-and-value.cpp      | 104 ++++++++++++++++++
 ...re2-is-with-variable-and-value.cpp2.output |   2 +
 6 files changed, 191 insertions(+), 2 deletions(-)
 create mode 100644 regression-tests/pure2-is-with-variable-and-value.cpp2
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.execution
 create mode 100644 regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.output
 create mode 100644 regression-tests/test-results/pure2-is-with-variable-and-value.cpp
 create mode 100644 regression-tests/test-results/pure2-is-with-variable-and-value.cpp2.output

diff --git a/include/cpp2util.h b/include/cpp2util.h
index 2ba115f75..82791c57f 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -369,15 +369,33 @@ auto argument_of_helper(Ret(*) (Arg)) -> Arg;
 template<typename Ret, typename F, typename Arg>
 auto argument_of_helper(Ret(F::*) (Arg)) -> Arg;
 
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg)&) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg)&&) -> Arg;
+
 template<typename Ret, typename F, typename Arg>
 auto argument_of_helper(Ret(F::*) (Arg) const) -> Arg;
 
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg) const&) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg) const&&) -> Arg;
+
 template <typename F>
-auto argument_of_helper(F) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));
+auto argument_of_helper(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));
 
 template <typename T>
 using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));
 
+template <typename F>
+auto argument_of_helper_op_is(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::op_is));
+
+template <typename T>
+using argument_of_op_is_t = CPP2_TYPEOF(argument_of_helper_op_is(std::declval<T>()));
+
 template <typename T>
 using pointee_t = std::iter_value_t<T>;
 
@@ -428,6 +446,9 @@ concept brace_initializable_to = requires (From x) { To{x}; };
 template< typename X, typename C >
 concept same_type_as = std::same_as<std::remove_cvref_t<X>, std::remove_cvref_t<C>>;
 
+template <typename X>
+concept defined = requires { std::declval<X>(); };
+
 template <typename X>
 concept has_defined_argument = requires {
 	std::declval<argument_of_t<X>>();
@@ -443,6 +464,18 @@ template <typename F, typename X>
 concept valid_predicate = (std::predicate<F, X> && !has_defined_argument<F>)
                           || (std::predicate<F, X> && has_defined_argument<F> && covertible_to_argument_of<X, F>);
 
+template <typename X, typename O, auto mem_fun_ptr>
+concept predicate_member_fun = requires (X x, O o) {
+    { (o.*mem_fun_ptr)(x) } -> std::convertible_to<bool>;
+};
+
+template <typename F, typename X>
+concept valid_custom_is_operator = predicate_member_fun<X, F, &F::op_is>
+                      && ( 
+                        !defined<argument_of_op_is_t<F>>
+                        || brace_initializable_to<X, argument_of_op_is_t<F>> 
+                      );
+
 //-----------------------------------------------------------------------
 //
 //  General helpers
@@ -1299,7 +1332,7 @@ auto is( X const& x ) -> bool {
 inline constexpr auto is( auto const& x, auto&& value ) -> bool
 {
     //  Value with customized operator_is case
-    if constexpr (requires{ x.op_is(value); }) {
+    if constexpr (valid_custom_is_operator<decltype(x), decltype(value)>) {
         return x.op_is(value);
     }
 
diff --git a/regression-tests/pure2-is-with-variable-and-value.cpp2 b/regression-tests/pure2-is-with-variable-and-value.cpp2
new file mode 100644
index 000000000..ce3ed8fc4
--- /dev/null
+++ b/regression-tests/pure2-is-with-variable-and-value.cpp2
@@ -0,0 +1,41 @@
+fun: (name, v) = {
+    std::cout << name << ": " << 
+                inspect v -> std::string {
+                is (42) = "42";
+                is (123) = "op_is";
+                is (-123) = "generic op_is";
+                is (4321) = "comperable";
+                is ("text") = "text";
+                is _ = "unknown";
+              }
+              << std::endl;
+}
+
+main: () -> int = {
+    fun("3.14", 3.14);
+    fun("42", 42);
+    fun("WithOp()", WithOp());
+    fun("WithGenOp()", WithGenOp());
+    fun("Cmp()", Cmp());
+    fun("std::string(\"text\")", std::string("text"));
+    fun("\"text\"", "text");
+    fun("std::string_view(\"text\")", std::string_view("text"));
+    fun(":std::vector = ('t','e','x','t','\\0')", :std::vector = ('t','e','x','t','\0'));
+}
+
+WithOp : type = {
+    op_is: (this, x : int) x == 123;
+}
+
+WithGenOp : type = {
+    op_is: (this, x) -> bool = {
+        if constexpr std::convertible_to<decltype(x), int> {
+            return x == -123;
+        }
+        return false;
+    }
+}
+
+Cmp : type = {
+    operator==: (this, x : int) -> bool = x == 4321;
+}
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.execution b/regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.execution
new file mode 100644
index 000000000..0b4a1cdf5
--- /dev/null
+++ b/regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.execution
@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comperable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown
diff --git a/regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.output b/regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/pure2-is-with-variable-and-value.cpp b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp
new file mode 100644
index 000000000..8b399e018
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp
@@ -0,0 +1,104 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+
+#line 26 "pure2-is-with-variable-and-value.cpp2"
+class WithOp;
+    
+
+#line 30 "pure2-is-with-variable-and-value.cpp2"
+class WithGenOp;
+    
+
+#line 39 "pure2-is-with-variable-and-value.cpp2"
+class Cmp;
+    
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+auto fun(auto const& name, auto const& v) -> void;
+
+#line 14 "pure2-is-with-variable-and-value.cpp2"
+[[nodiscard]] auto main() -> int;
+
+#line 26 "pure2-is-with-variable-and-value.cpp2"
+class WithOp {
+    public: [[nodiscard]] auto op_is(cpp2::impl::in<int> x) const& -> auto;
+    public: WithOp() = default;
+    public: WithOp(WithOp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(WithOp const&) -> void = delete;
+
+#line 28 "pure2-is-with-variable-and-value.cpp2"
+};
+
+class WithGenOp {
+    public: [[nodiscard]] auto op_is(auto const& x) const& -> bool;
+    public: WithGenOp() = default;
+    public: WithGenOp(WithGenOp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(WithGenOp const&) -> void = delete;
+
+
+#line 37 "pure2-is-with-variable-and-value.cpp2"
+};
+
+class Cmp {
+    public: [[nodiscard]] auto operator==(cpp2::impl::in<int> x) const& -> bool;
+    public: Cmp() = default;
+    public: Cmp(Cmp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(Cmp const&) -> void = delete;
+
+#line 41 "pure2-is-with-variable-and-value.cpp2"
+};
+
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+auto fun(auto const& name, auto const& v) -> void{
+#line 2 "pure2-is-with-variable-and-value.cpp2"
+    std::cout << name << ": " << 
+                [&] () -> std::string { auto&& _expr = v;
+                if (cpp2::impl::is(_expr, (42))) { if constexpr( requires{"42";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("42")),std::string> ) return "42"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, 123)) { if constexpr( requires{"op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("op_is")),std::string> ) return "op_is"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, -123)) { if constexpr( requires{"generic op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("generic op_is")),std::string> ) return "generic op_is"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, 4321)) { if constexpr( requires{"comperable";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("comperable")),std::string> ) return "comperable"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, "text")) { if constexpr( requires{"text";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("text")),std::string> ) return "text"; else return std::string{}; else return std::string{}; }
+                else return "unknown"; }
+              () 
+              << std::endl;
+}
+
+#line 14 "pure2-is-with-variable-and-value.cpp2"
+[[nodiscard]] auto main() -> int{
+    fun("3.14", 3.14);
+    fun("42", 42);
+    fun("WithOp()", WithOp());
+    fun("WithGenOp()", WithGenOp());
+    fun("Cmp()", Cmp());
+    fun("std::string(\"text\")", std::string("text"));
+    fun("\"text\"", "text");
+    fun("std::string_view(\"text\")", std::string_view("text"));
+    fun(":std::vector = ('t','e','x','t','\\0')", std::vector{'t', 'e', 'x', 't', '\0'});
+}
+
+#line 27 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto WithOp::op_is(cpp2::impl::in<int> x) const& -> auto { return x == 123;  }
+
+#line 31 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto WithGenOp::op_is(auto const& x) const& -> bool{
+        if constexpr (std::convertible_to<decltype(x),int>) {
+            return x == -123; 
+        }
+        return false; 
+    }
+
+#line 40 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto Cmp::operator==(cpp2::impl::in<int> x) const& -> bool { return x == 4321;  }
+
diff --git a/regression-tests/test-results/pure2-is-with-variable-and-value.cpp2.output b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp2.output
new file mode 100644
index 000000000..73c639fb2
--- /dev/null
+++ b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp2.output
@@ -0,0 +1,2 @@
+pure2-is-with-variable-and-value.cpp2... ok (all Cpp2, passes safety checks)
+

From fa21f0cff13c0a8dc2e538230afdcf3d76c36f2c Mon Sep 17 00:00:00 2001
From: Herb Sutter <herb.sutter@gmail.com>
Date: Sat, 11 May 2024 14:55:32 -0700
Subject: [PATCH 5/5] Did two minor tweaks, and updated tests

Add an array value-equality case (thanks to MSVC for warning about that)

Also stop forwarding the `value` to `std::vformat` to stay compatible with the `vformat` change
---
 include/cpp2util.h                            | 10 +++-
 .../pure2-is-with-variable-and-value.cpp2     |  4 +-
 ...mixed-bugfix-for-ufcs-non-local.cpp.output | 52 +++++++++----------
 .../mixed-inspect-values.cpp.execution        |  2 +-
 .../pure2-bugfix-for-ufcs-noexcept.cpp.output |  4 +-
 .../pure2-bugfix-for-ufcs-sfinae.cpp.output   |  8 +--
 ...ith-free-functions-predicate.cpp.execution |  6 +++
 ...s-with-free-functions-predicate.cpp.output |  0
 ...2-is-with-unnamed-predicates.cpp.execution |  6 +++
 ...ure2-is-with-unnamed-predicates.cpp.output |  0
 ...2-is-with-variable-and-value.cpp.execution |  9 ++++
 ...ure2-is-with-variable-and-value.cpp.output |  0
 .../gcc-10/mixed-inspect-values.cpp.execution |  2 +-
 ...ith-free-functions-predicate.cpp.execution |  6 +++
 ...s-with-free-functions-predicate.cpp.output |  0
 ...2-is-with-unnamed-predicates.cpp.execution |  6 +++
 ...ure2-is-with-unnamed-predicates.cpp.output |  0
 ...2-is-with-variable-and-value.cpp.execution |  9 ++++
 ...ure2-is-with-variable-and-value.cpp.output |  0
 .../test-results/gcc-13/gcc-version.output    |  2 +-
 ...mixed-bugfix-for-ufcs-non-local.cpp.output | 40 +++++++-------
 .../gcc-13/mixed-inspect-values.cpp.execution |  2 +-
 ...ith-free-functions-predicate.cpp.execution |  6 +++
 ...s-with-free-functions-predicate.cpp.output |  0
 ...2-is-with-unnamed-predicates.cpp.execution |  6 +++
 ...ure2-is-with-unnamed-predicates.cpp.output |  0
 ...2-is-with-variable-and-value.cpp.execution |  9 ++++
 ...ure2-is-with-variable-and-value.cpp.output |  0
 .../msvc-2022/MSVC-version.output             |  2 +-
 .../mixed-inspect-values.cpp.execution        |  2 +-
 ...ith-free-functions-predicate.cpp.execution |  6 +++
 ...s-with-free-functions-predicate.cpp.output |  1 +
 ...2-is-with-unnamed-predicates.cpp.execution |  6 +++
 ...ure2-is-with-unnamed-predicates.cpp.output |  1 +
 ...2-is-with-variable-and-value.cpp.execution |  9 ++++
 ...ure2-is-with-variable-and-value.cpp.output |  1 +
 .../pure2-is-with-variable-and-value.cpp      |  2 +-
 37 files changed, 156 insertions(+), 63 deletions(-)
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.execution
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.output
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.execution
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.output
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.execution
 create mode 100644 regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.output
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.output
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.output
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.output
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.output
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.output
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.execution
 create mode 100644 regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.output
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.execution
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.output
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.execution
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.output
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.execution
 create mode 100644 regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.output

diff --git a/include/cpp2util.h b/include/cpp2util.h
index 82791c57f..73124e563 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -1235,7 +1235,7 @@ inline auto to_string(std::tuple<Ts...> const& t) -> std::string
 #if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)
 inline auto to_string(auto&& value, std::string_view fmt) -> std::string
 {
-    return std::vformat(fmt, std::make_format_args(CPP2_FORWARD(value)));
+    return std::vformat(fmt, std::make_format_args(value));
 }
 #else
 inline auto to_string(auto&& value, std::string_view) -> std::string
@@ -1341,7 +1341,13 @@ inline constexpr auto is( auto const& x, auto&& value ) -> bool
         return value(x);
     }
 
-    //  Value equality case
+    //  Value equality case: C/C++ arrays or individual values
+    else if constexpr (std::is_array_v<CPP2_TYPEOF(x)> && std::is_array_v<CPP2_TYPEOF(value)>) {
+        if (std::ssize(x) == std::ssize(value)) {
+            return std::equal( std::begin(x), std::end(x), std::begin(value));
+        }
+        return false;
+    }
     else if constexpr (requires{ bool{x == value}; }) {
         return x == value;
     }
diff --git a/regression-tests/pure2-is-with-variable-and-value.cpp2 b/regression-tests/pure2-is-with-variable-and-value.cpp2
index ce3ed8fc4..c207cc2c2 100644
--- a/regression-tests/pure2-is-with-variable-and-value.cpp2
+++ b/regression-tests/pure2-is-with-variable-and-value.cpp2
@@ -1,10 +1,10 @@
 fun: (name, v) = {
-    std::cout << name << ": " << 
+    std::cout << name << ": " <<
                 inspect v -> std::string {
                 is (42) = "42";
                 is (123) = "op_is";
                 is (-123) = "generic op_is";
-                is (4321) = "comperable";
+                is (4321) = "comparable";
                 is ("text") = "text";
                 is _ = "unknown";
               }
diff --git a/regression-tests/test-results/clang-12/mixed-bugfix-for-ufcs-non-local.cpp.output b/regression-tests/test-results/clang-12/mixed-bugfix-for-ufcs-non-local.cpp.output
index 13c5abdbc..8db1cd1f2 100644
--- a/regression-tests/test-results/clang-12/mixed-bugfix-for-ufcs-non-local.cpp.output
+++ b/regression-tests/test-results/clang-12/mixed-bugfix-for-ufcs-non-local.cpp.output
@@ -1,118 +1,118 @@
 mixed-bugfix-for-ufcs-non-local.cpp2:13:12: error: a lambda expression cannot appear in this context
 template<t<CPP2_UFCS_NONLOCAL(f)(o)> UnnamedTypeParam1_1> bool inline constexpr v0 = false;// Fails on GCC ([GCC109781][]) and Clang 12 (a lambda expression cannot appear in this context)
            ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:15:3: error: a lambda expression cannot appear in this context
 t<CPP2_UFCS_NONLOCAL(f)(o)> inline constexpr v1 = t<true>();// Fails on Clang 12 (lambda in unevaluated context).
   ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:21:12: error: a lambda expression cannot appear in this context
 template<t<CPP2_UFCS_NONLOCAL(f)(o)> UnnamedTypeParam1_2> auto g() -> void;
            ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:23:42: error: a lambda expression cannot appear in this context
 auto g([[maybe_unused]] cpp2::impl::in<t<CPP2_UFCS_NONLOCAL(f)(o)>> unnamed_param_1) -> void;
                                          ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:27:29: error: a lambda expression cannot appear in this context
 [[nodiscard]] auto h() -> t<CPP2_UFCS_NONLOCAL(f)(o)>;
                             ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:31:12: error: a lambda expression cannot appear in this context
 template<t<CPP2_UFCS_NONLOCAL(f)(o)> UnnamedTypeParam1_3> using a = bool;// Fails on GCC ([GCC109781][]) and Clang 12 (a lambda expression cannot appear in this context)
            ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:33:12: error: a lambda expression cannot appear in this context
 template<t<CPP2_UFCS_NONLOCAL(f)(o)> UnnamedTypeParam1_4> auto inline constexpr b = false;// Fails on GCC ([GCC109781][]).
            ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:35:13: error: a lambda expression cannot appear in this context
 using c = t<CPP2_UFCS_NONLOCAL(f)(o)>;// Fails on Clang 12 (lambda in unevaluated context) and Clang 12 (a lambda expression cannot appear in this context)
             ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:37:29: error: a lambda expression cannot appear in this context
 auto inline constexpr d = t<CPP2_UFCS_NONLOCAL(f)(o)>();// Fails on Clang 12 (lambda in unevaluated context).
                             ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:21:12: error: a lambda expression cannot appear in this context
 template<t<CPP2_UFCS_NONLOCAL(f)(o)> UnnamedTypeParam1_2> auto g() -> void{}// Fails on GCC ([GCC109781][]) and Clang 12 (a lambda expression cannot appear in this context)
            ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:23:42: error: a lambda expression cannot appear in this context
 auto g([[maybe_unused]] cpp2::impl::in<t<CPP2_UFCS_NONLOCAL(f)(o)>> unnamed_param_1) -> void{}// Fails on Clang 12 (lambda in unevaluated context).
                                          ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:27:29: error: a lambda expression cannot appear in this context
 [[nodiscard]] auto h() -> t<CPP2_UFCS_NONLOCAL(f)(o)> { return o;  }// Fails on Clang 12 (lambda in unevaluated context).
                             ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:41:85: error: lambda expression in an unevaluated operand
   inline CPP2_CONSTEXPR bool u::c = [](cpp2::impl::in<std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(f)(o))>> x) mutable -> auto { return x; }(true);// Fails on Clang 12 (lambda in unevaluated context).
                                                                                     ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 13 errors generated.
diff --git a/regression-tests/test-results/clang-12/mixed-inspect-values.cpp.execution b/regression-tests/test-results/clang-12/mixed-inspect-values.cpp.execution
index 245368cfc..e7130e0f8 100644
--- a/regression-tests/test-results/clang-12/mixed-inspect-values.cpp.execution
+++ b/regression-tests/test-results/clang-12/mixed-inspect-values.cpp.execution
@@ -9,4 +9,4 @@ zero
 3
 integer -42
 xyzzy
-3
+(no match)
diff --git a/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-noexcept.cpp.output b/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-noexcept.cpp.output
index 455f6777b..63f630dff 100644
--- a/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-noexcept.cpp.output
+++ b/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-noexcept.cpp.output
@@ -1,10 +1,10 @@
 pure2-bugfix-for-ufcs-noexcept.cpp2:5:26: error: lambda expression in an unevaluated operand
   static_assert(noexcept(CPP2_UFCS(swap)(t(), t())));// Fails on Clang 12 (lambda in unevaluated context) and GCC 10 (static assertion failed)
                          ^
-../../../include/cpp2util.h:988:59: note: expanded from macro 'CPP2_UFCS'
+../../../include/cpp2util.h:1107:59: note: expanded from macro 'CPP2_UFCS'
 #define CPP2_UFCS(...)                                    CPP2_UFCS_(&,CPP2_UFCS_EMPTY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 1 error generated.
diff --git a/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-sfinae.cpp.output b/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-sfinae.cpp.output
index 00699f92d..98e3212be 100644
--- a/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-sfinae.cpp.output
+++ b/regression-tests/test-results/clang-12/pure2-bugfix-for-ufcs-sfinae.cpp.output
@@ -1,19 +1,19 @@
 pure2-bugfix-for-ufcs-sfinae.cpp2:1:78: error: lambda expression in an unevaluated operand
 template<typename T> [[nodiscard]] auto f() -> std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(a)(T()))>;
                                                                              ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 pure2-bugfix-for-ufcs-sfinae.cpp2:1:78: error: lambda expression in an unevaluated operand
 template<typename T> [[nodiscard]] auto f() -> std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(a)(T()))>{}// Fails on Clang 12 (lambda in unevaluated context).
                                                                              ^
-../../../include/cpp2util.h:993:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
+../../../include/cpp2util.h:1112:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
                                                           ^
-../../../include/cpp2util.h:955:66: note: expanded from macro 'CPP2_UFCS_'
+../../../include/cpp2util.h:1074:66: note: expanded from macro 'CPP2_UFCS_'
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 2 errors generated.
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.execution b/regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.output b/regression-tests/test-results/clang-12/pure2-is-with-free-functions-predicate.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.execution b/regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.output b/regression-tests/test-results/clang-12/pure2-is-with-unnamed-predicates.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.execution b/regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.execution
new file mode 100644
index 000000000..a9bc0680a
--- /dev/null
+++ b/regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.execution
@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comparable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown
diff --git a/regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.output b/regression-tests/test-results/clang-12/pure2-is-with-variable-and-value.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-10/mixed-inspect-values.cpp.execution b/regression-tests/test-results/gcc-10/mixed-inspect-values.cpp.execution
index 245368cfc..e7130e0f8 100644
--- a/regression-tests/test-results/gcc-10/mixed-inspect-values.cpp.execution
+++ b/regression-tests/test-results/gcc-10/mixed-inspect-values.cpp.execution
@@ -9,4 +9,4 @@ zero
 3
 integer -42
 xyzzy
-3
+(no match)
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.execution b/regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.output b/regression-tests/test-results/gcc-10/pure2-is-with-free-functions-predicate.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.execution b/regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.output b/regression-tests/test-results/gcc-10/pure2-is-with-unnamed-predicates.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.execution b/regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.execution
new file mode 100644
index 000000000..a9bc0680a
--- /dev/null
+++ b/regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.execution
@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comparable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown
diff --git a/regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.output b/regression-tests/test-results/gcc-10/pure2-is-with-variable-and-value.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-13/gcc-version.output b/regression-tests/test-results/gcc-13/gcc-version.output
index b06b2e08d..e0a9e3e94 100644
--- a/regression-tests/test-results/gcc-13/gcc-version.output
+++ b/regression-tests/test-results/gcc-13/gcc-version.output
@@ -1,4 +1,4 @@
-g++ (GCC) 13.2.1 20231011 (Red Hat 13.2.1-4)
+g++ (GCC) 13.2.1 20240316 (Red Hat 13.2.1-7)
 Copyright (C) 2023 Free Software Foundation, Inc.
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
diff --git a/regression-tests/test-results/gcc-13/mixed-bugfix-for-ufcs-non-local.cpp.output b/regression-tests/test-results/gcc-13/mixed-bugfix-for-ufcs-non-local.cpp.output
index 4d902ce2d..aa1b15b7a 100644
--- a/regression-tests/test-results/gcc-13/mixed-bugfix-for-ufcs-non-local.cpp.output
+++ b/regression-tests/test-results/gcc-13/mixed-bugfix-for-ufcs-non-local.cpp.output
@@ -1,41 +1,41 @@
 In file included from mixed-bugfix-for-ufcs-non-local.cpp:6:
-../../../include/cpp2util.h:956:1: error: lambda-expression in template parameter type
-  956 | [LAMBDADEFCAPT]< \
+../../../include/cpp2util.h:1075:1: error: lambda-expression in template parameter type
+ 1075 | [LAMBDADEFCAPT]< \
       | ^
-../../../include/cpp2util.h:993:59: note: in expansion of macro ‘CPP2_UFCS_’
-  993 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
+../../../include/cpp2util.h:1112:59: note: in expansion of macro ‘CPP2_UFCS_’
+ 1112 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
       |                                                           ^~~~~~~~~~
 mixed-bugfix-for-ufcs-non-local.cpp2:13:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’
 mixed-bugfix-for-ufcs-non-local.cpp2:13:36: error: template argument 1 is invalid
-../../../include/cpp2util.h:956:1: error: lambda-expression in template parameter type
-  956 | [LAMBDADEFCAPT]< \
+../../../include/cpp2util.h:1075:1: error: lambda-expression in template parameter type
+ 1075 | [LAMBDADEFCAPT]< \
       | ^
-../../../include/cpp2util.h:993:59: note: in expansion of macro ‘CPP2_UFCS_’
-  993 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
+../../../include/cpp2util.h:1112:59: note: in expansion of macro ‘CPP2_UFCS_’
+ 1112 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
       |                                                           ^~~~~~~~~~
 mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’
 mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid
-../../../include/cpp2util.h:956:1: error: lambda-expression in template parameter type
-  956 | [LAMBDADEFCAPT]< \
+../../../include/cpp2util.h:1075:1: error: lambda-expression in template parameter type
+ 1075 | [LAMBDADEFCAPT]< \
       | ^
-../../../include/cpp2util.h:993:59: note: in expansion of macro ‘CPP2_UFCS_’
-  993 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
+../../../include/cpp2util.h:1112:59: note: in expansion of macro ‘CPP2_UFCS_’
+ 1112 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
       |                                                           ^~~~~~~~~~
 mixed-bugfix-for-ufcs-non-local.cpp2:31:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’
 mixed-bugfix-for-ufcs-non-local.cpp2:31:36: error: template argument 1 is invalid
-../../../include/cpp2util.h:956:1: error: lambda-expression in template parameter type
-  956 | [LAMBDADEFCAPT]< \
+../../../include/cpp2util.h:1075:1: error: lambda-expression in template parameter type
+ 1075 | [LAMBDADEFCAPT]< \
       | ^
-../../../include/cpp2util.h:993:59: note: in expansion of macro ‘CPP2_UFCS_’
-  993 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
+../../../include/cpp2util.h:1112:59: note: in expansion of macro ‘CPP2_UFCS_’
+ 1112 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
       |                                                           ^~~~~~~~~~
 mixed-bugfix-for-ufcs-non-local.cpp2:33:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’
 mixed-bugfix-for-ufcs-non-local.cpp2:33:36: error: template argument 1 is invalid
-../../../include/cpp2util.h:956:1: error: lambda-expression in template parameter type
-  956 | [LAMBDADEFCAPT]< \
+../../../include/cpp2util.h:1075:1: error: lambda-expression in template parameter type
+ 1075 | [LAMBDADEFCAPT]< \
       | ^
-../../../include/cpp2util.h:993:59: note: in expansion of macro ‘CPP2_UFCS_’
-  993 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
+../../../include/cpp2util.h:1112:59: note: in expansion of macro ‘CPP2_UFCS_’
+ 1112 | #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
       |                                                           ^~~~~~~~~~
 mixed-bugfix-for-ufcs-non-local.cpp2:21:12: note: in expansion of macro ‘CPP2_UFCS_NONLOCAL’
 mixed-bugfix-for-ufcs-non-local.cpp2:21:36: error: template argument 1 is invalid
diff --git a/regression-tests/test-results/gcc-13/mixed-inspect-values.cpp.execution b/regression-tests/test-results/gcc-13/mixed-inspect-values.cpp.execution
index 245368cfc..e7130e0f8 100644
--- a/regression-tests/test-results/gcc-13/mixed-inspect-values.cpp.execution
+++ b/regression-tests/test-results/gcc-13/mixed-inspect-values.cpp.execution
@@ -9,4 +9,4 @@ zero
 3
 integer -42
 xyzzy
-3
+(no match)
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.execution b/regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.output b/regression-tests/test-results/gcc-13/pure2-is-with-free-functions-predicate.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.execution b/regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.output b/regression-tests/test-results/gcc-13/pure2-is-with-unnamed-predicates.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.execution b/regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.execution
new file mode 100644
index 000000000..a9bc0680a
--- /dev/null
+++ b/regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.execution
@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comparable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown
diff --git a/regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.output b/regression-tests/test-results/gcc-13/pure2-is-with-variable-and-value.cpp.output
new file mode 100644
index 000000000..e69de29bb
diff --git a/regression-tests/test-results/msvc-2022/MSVC-version.output b/regression-tests/test-results/msvc-2022/MSVC-version.output
index d8301eead..ba2c3c80f 100644
--- a/regression-tests/test-results/msvc-2022/MSVC-version.output
+++ b/regression-tests/test-results/msvc-2022/MSVC-version.output
@@ -1,3 +1,3 @@
-Microsoft (R) C/C++ Optimizing Compiler Version 19.39.33522 for x86
+Microsoft (R) C/C++ Optimizing Compiler Version 19.39.33523 for x86
 Copyright (C) Microsoft Corporation.  All rights reserved.
 
diff --git a/regression-tests/test-results/msvc-2022/mixed-inspect-values.cpp.execution b/regression-tests/test-results/msvc-2022/mixed-inspect-values.cpp.execution
index 245368cfc..e7130e0f8 100644
--- a/regression-tests/test-results/msvc-2022/mixed-inspect-values.cpp.execution
+++ b/regression-tests/test-results/msvc-2022/mixed-inspect-values.cpp.execution
@@ -9,4 +9,4 @@ zero
 3
 integer -42
 xyzzy
-3
+(no match)
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.execution b/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.output b/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.output
new file mode 100644
index 000000000..e2ffd5e62
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-free-functions-predicate.cpp.output
@@ -0,0 +1 @@
+pure2-is-with-free-functions-predicate.cpp
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.execution b/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.execution
new file mode 100644
index 000000000..c8a07e430
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.execution
@@ -0,0 +1,6 @@
+3.140000 is double bigger than 3
+3.140000 is bigger than 3
+42 is integer bigger than 3
+42 is bigger than 3
+a is integer bigger than 3
+a is bigger than 3
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.output b/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.output
new file mode 100644
index 000000000..67d1d00c8
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-unnamed-predicates.cpp.output
@@ -0,0 +1 @@
+pure2-is-with-unnamed-predicates.cpp
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.execution b/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.execution
new file mode 100644
index 000000000..a9bc0680a
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.execution
@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comparable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown
diff --git a/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.output b/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.output
new file mode 100644
index 000000000..4358a6f73
--- /dev/null
+++ b/regression-tests/test-results/msvc-2022/pure2-is-with-variable-and-value.cpp.output
@@ -0,0 +1 @@
+pure2-is-with-variable-and-value.cpp
diff --git a/regression-tests/test-results/pure2-is-with-variable-and-value.cpp b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp
index 8b399e018..c178e96a6 100644
--- a/regression-tests/test-results/pure2-is-with-variable-and-value.cpp
+++ b/regression-tests/test-results/pure2-is-with-variable-and-value.cpp
@@ -68,7 +68,7 @@ auto fun(auto const& name, auto const& v) -> void{
                 if (cpp2::impl::is(_expr, (42))) { if constexpr( requires{"42";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("42")),std::string> ) return "42"; else return std::string{}; else return std::string{}; }
                 else if (cpp2::impl::is(_expr, 123)) { if constexpr( requires{"op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("op_is")),std::string> ) return "op_is"; else return std::string{}; else return std::string{}; }
                 else if (cpp2::impl::is(_expr, -123)) { if constexpr( requires{"generic op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("generic op_is")),std::string> ) return "generic op_is"; else return std::string{}; else return std::string{}; }
-                else if (cpp2::impl::is(_expr, 4321)) { if constexpr( requires{"comperable";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("comperable")),std::string> ) return "comperable"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, 4321)) { if constexpr( requires{"comparable";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("comparable")),std::string> ) return "comparable"; else return std::string{}; else return std::string{}; }
                 else if (cpp2::impl::is(_expr, "text")) { if constexpr( requires{"text";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("text")),std::string> ) return "text"; else return std::string{}; else return std::string{}; }
                 else return "unknown"; }
               ()