Cannot use std::not_fn with immediate functions

Question

I try to apply std::not_fn wrapper to an immediate consteval function.

But even the simplest C++20 example

#include <functional>

consteval bool f() { return false; }

// ok in GCC and Clang, error in MSVC
static_assert( std::not_fn(f)() );

works fine in GCC/Clang, but fails in Visual Studio with the error:

error C7596: 'f': cannot take address of immediate function outside of an immediate invocation

In C++26 we will get std::not_fn with the statically determined callable target. Currently it is implemented only in libc++ from Clang. But the example

static_assert( std::not_fn<f>()() );

fails with the following error in Clang:

error: no matching function for call to 'not_fn'
note: candidate template ignored: invalid explicitly-specified argument for template

Online demo: https://gcc.godbolt.org/z/dKofrdhb8

All errors are resolved if declare the function f as constexpr instead of consteval.

Shall std::not_fn (one or both overloads) be compatible with immediate functions?

Barry · Accepted Answer · 2025-09-13 16:23:49Z

25

The short version is

#include <functional>

consteval bool f() { return false; }

static_assert( std::not_fn(f)() );   // this is ok
static_assert( std::not_fn<f>()() ); // but this is ill-formed
auto x = std::not_fn<f>();           // ... because this is ill-formed

f is an immediate function. There are tight restrictions around how it can be used. Basically, it can be used in an immediate function context or as part of an expression that is a constant expression.

In particular, there are some things you cannot do with immediate functions. The result of a constant expression cannot include a pointer (or reference) to immediate function anywhere all the way down. Which means that std::not_fn<f>() is ill-formed because initializing the constant template parameter of std::not_fn with f would be a constant expression that has a "constituent value" that is an immediate function. That's just not allowed. And it's important to understand why this might be the case:

consteval bool is_even(int x) { return x % 2 == 0; }

template <auto F>
bool call_f(int x) { return F(x); }

int main(int argc, char**) {
    return call_f<is_even>(argc);
}

If we were allowed to initialize the constant template argument with is_even, then what would prevent the call F(x)? F would just be a bool(*)(int) at that point right? But that would require persisting the function to runtime, which consteval is expressly there to avoid doing.

But this is fine:

static_assert( std::not_fn(f)() );

The use of f there makes this immediate-escalating which requires the whole expression to either be constant (which it is) or within an immediate function context (which it also is), so that works.

Note that Peter Dimov and I have a paper (P3603) which seeks to address this issue by properly formalizing the notion of consteval-only value, which would permit std::not_fn<f> to work by effectively being able to propagate through the "consteval-ness" of the value. Or, for my is_even example earlier, call_f<is_even> itself would be fine, but the call F(x) in the body would be ill-formed because it would have to be constant (and it is not).

edited Sep 13 at 16:23

answered Sep 12 at 18:26

Barry

312k32 gold badges735 silver badges1.1k bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Gerdiner Sep 19 at 21:35

Will this paper get in to c++26 or will it be heading for the next revision?

Barry Sep 19 at 21:45

@Gerdiner Still unclear.

Barry Nov 10 at 1:51

@Gerdiner Alright now it's clear, heading for C++29.

Collectives™ on Stack Overflow

Cannot use std::not_fn with immediate functions

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related