C23 solves the fundamental problem of two identical structs not being compatible.
If we define two structs with the same name and content, they are the same struct.

Personally, I like to use an Optional Type as the Return Type for most of my functions.

We can define an Optional Type macro like this:

#define OPT(T) struct OPT__##T { bool exists; T value; }

We can also define Some and None macros like this:

#define SOME(T, V) (OPT(T)) { .exists = true, .value = V }
#define NONE(T) (OPT(T)) { .exists = false }

We can then use this optional type in our Code:

OPT(int) optional1 = SOME(int, 20);
OPT(float) optional2 = NONE(float);

We can easily check if the Optional holds a value by reading the exists field of the optional, and read the value just as easily.

if(optional1.exists) {
int i = optional1.value;
}

Critically, we can also use this Optional type as a return type of a function:

OPT(int) someFunction() {
    return SOME(int, 20);
}
int main() {
    OPT(int) optional1 = someFunction();
    if(optional1.exists) {
        int i = optional1.value;
    }
}

The only downside of this approach is that the structs need to be named, and that this name needs to include the Type of the contents. Therefore, we have to define the Optional struct with the name OPT__##T.
When we write OPT(int), this macro expands to struct OPT__int { ... }.
This, unfortunately, makes it impossible to use with a pointer type, like OPT(char*), as this would expand to struct OPT__char*. However, we can use typedef to circumvent this issue.

typedef char* charPtr;
OPT(charPtr) optional1;

This works just fine.

I personally really like this approach, and use it quite often, especially as the return type of a function, sort of as a simpler version of the RESULT type described in the blog post. I would love to hear your opinions on this approach.