types::c provides type aliases that are compatible with standard C builtin types
and typedefs, as specified ISO/IEC 9899 and POSIX, as well as convenience
functions for working with C types. This module is useful for C interop, for
instance if an external function returns a [[long]] or a [[ssize]], or if you
need to convert between a C string and a Hare string. The types provided here
shouldn't be used for most Hare code.

Some C types aren't provided by this module, since they are provided by the Hare
language itself:

--------------------------------------------------
| Hare type | C type       | C header            |
|===========|==============|=====================|
| bool      | _Bool, bool  | stdbool.h (C99-C17) |
|-----------|--------------|---------------------|
| int       | (signed) int | -                   |
|-----------|--------------|---------------------|
| size      | size_t       | stddef.h            |
|-----------|--------------|---------------------|
| uint      | unsigned int | -                   |
|-----------|--------------|---------------------|
| uintptr   | uintptr_t    | stdint.h            |
|-----------|--------------|---------------------|
| valist    | va_list      | stdarg.h            |
--------------------------------------------------

Some C types are mostly compatible with Hare types, with minor differences:

--------------------------------------------------------------------------------
| Hare type | C type            | Differences                                  |
|===========|===================|==============================================|
| void      | void              | Hare's void is a zero-size type; C's void is |
|           |                   | an incomplete opaque type. This distinction  |
|           |                   | isn't relevant for C interop. In both        |
|           |                   | languages, void pointers are used as generic |
|           |                   | pointers.                                    |
|-----------|-------------------|----------------------------------------------|
| f32       | float _Imaginary  | The types are equivalent in representation,  |
| f64       | double _Imaginary | but behavior differs when casting between    |
| [2]f32    | float _Complex    | real, imaginary, and complex types.          |
| [2]f64    | double _Complex   |                                              |
--------------------------------------------------------------------------------

Additional low-level or implementation-specific types may be defined in [[rt]].
