Extension of is() part1: free function predicates, fix implicit cast for build-in and custom is operator, refactoring (#1053)

* 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.

* Add test for is with unnamed predicates

Adding test for using is with lambdas, and generic lambdas.

* 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{};
            }
        }

* 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,

* 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

---------

Co-authored-by: Herb Sutter <[email protected]>

Author: filipsajdak

Diff for: include/cpp2util.h

@@ -356,6 +356,125 @@ 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)&) -> 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 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>;
+
+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
+//
+//-----------------------------------------------------------------------
+//
+
+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; };
+
+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 defined = requires { std::declval<X>(); };
+
+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>);
+
+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>> 
+                      );
 
 //-----------------------------------------------------------------------
 //
@@ -1149,31 +1268,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
@@ -1220,25 +1332,37 @@ 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);
     }
 
     //  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(); }) {
+
+    //  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;
     }
-
-    //  Value equality case
     else if constexpr (requires{ bool{x == value}; }) {
         return x == value;
     }
     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 for: 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 for: 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 for: 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) = "comparable";
+                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 for: 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 for: 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 for: regression-tests/test-results/apple-clang-14/pure2-is-with-free-functions-predicate.cpp.output

@@ -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 for: regression-tests/test-results/apple-clang-14/pure2-is-with-unnamed-predicates.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