C++ and templates: restrict what types can be used in a template

Very interesting!

If using g++ to build it, I correctly see the following:

error: 'requires' does not name a type
  requires std::is_arithmetic<R>::value

note: 'requires' only available with '-std=c++20' or '-fconcepts'

All is fine, of course, when I add the specified switch.

However, Arduino IDE is a bit vague:

error: 'requires' does not name a type
 requires std::is_arithmetic<R>::value
 ^~~~~~~~

exit status 1

Compilation error: 'requires' does not name a type

It fails to mention that the reason is the switch is missing. A pity the IDE doesn't support it, because this sort of feature is excellent for real-time applications, and would be a nice way to demonstrate. Still, at least Pico can build with it (using -std=c++20 in the COMPILE_OPTIONS in CMakeLists.txt

for pico C sdk:

for eclipse:

No idea how to set in Arduino IDE V2. V1 had a platform file, that you could edit.

when you press ctl+shift+p in Arduino IDE2, you get a command pallet. There you can set  preferences user/workspace (with a form or directly in settings.json) 
If the dialect can be set, I'd suspect it's there ...

Ahh thanks for the tip! Simpler to remember than the compile-line option I was using for Pico SDK.

no, the option is not there

 shabaz I found where you can set it for Arduino IDE 2.X on windows:

C:\Users\jancu\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.4\platform.txt

You need to replace jancu with your windows user name, and controller family with the board you are working for. And std=gnu++11 with std=c++20

compiler.cpp.flags=-c -g -Os {compiler.warning_flags} -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto

edit: I don't think that this is useful for code that you want to share with others.
edit edit: the setting gets overwritten when updating the IDE
edit edit edit: and avr-gcc 7.x does not support c++20

I added the option to use a callback that doesn't return anything , e.g.:  void handler(...) 

First, I allowed the template constraint to accept both arithmetic and void return values.

template <typename R, typename... Args>
// restrict to arithmetic data types for return value, or void
  requires std::is_void<R>::value || std::is_arithmetic_v<R>
class Callback {

And altered the call() function in the template, to not return a value if the return type is void:

	/*
	 * R can either be an arithmetic type, or void
	 */
	inline R call(Args... args) {
		if constexpr (std::is_void<R>::value) {
			if (_callback == nullptr) {
				return;
			}
			(*_callback)(args...);
		}

		if constexpr (! std::is_void<R>::value) {
			if (_callback == nullptr) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			}
			return (*_callback)(args...);
		}
	}

Here's an example that uses a bool handler,

	// scenario: return a bool
    Callback<bool, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> bool {
        return num1 == num2;
    });

    printf("Value: %s\n", cb.call(a, b) ? "true" : "false");
	fflush(stdout);
	}

and a void handler:

    // scenario: use void
    Callback<void, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) {
        return;
    });
    cb.call(a, b);

There are more lines of code in the template class definition. But all of that is compile time resolved.

No executable code is added.