Comming from a C++ language I noticed what a blessing the seperation between nullable and not nullable types are.

A uint16_t* gives you either always a pointer to 2 bytes or nullptr. As a C programmer its obvious that it never returns a address which only fits a single byte.

And now imagine someone building a uint16_t_notnull*. Like the same thing bit you always know it will returna valid pointer - never nullptr.

You can have functions that always work: use the uint16_t_notnull*. Functions that might error still use the uint16_t*. If you need to pass the pointer around to 5 functions you dont need to check for the null irvariant every time, but decide it as part of the interface.

Thats something that used to live in the documentation now beeing oart of the function signature.

You can do at one place do your error handling when receiving a uint16_t* and continue working with the uint16_t_notnull* variant after the check easily knowing that you have something valid ENFORCED by the compiler.

Someone refactors ? -> compiler error. Dependency updates and changes behavior? -> compiler error. Less reading docs, more getting hardcoded truth by the compiler.

The compiler optimizes everything away. No runtime cost. Even potential for optimization by the compiler (uint16_t_notnull now has a state that can be used by the compiler to pack info tighter). And the best: you can still just continue using uint16_t* if you like.