On Mar 29, 2025, at 3:02 PM, Frederick Virchanza Gotham via Std-Proposals <std-proposals_at_[hidden]> wrote:
>
> It's horrible when you use a "std::uint16_t" only to find that it
> promotes to a signed 32-Bit integer. Believe it or not, I recently
> wrote the following code:
>
> using std::uint_fast32_t;
> // We can't use uint_fast32_t if it undergoes promotion,
> // so instead use long unsigned (which might be 64-Bit)
> typedef typename std::conditional<
> std::is_same< uint_fast32_t, decltype(uint_fast32_t() +
> uint_fast32_t()) >::value,
> uint_fast32_t,
> long unsigned >::type UIntType;
>
> So how about if we could tell the compiler that we want to use a
> specific integer type, and that we don't want it to promote. Perhaps
> here's how we'd define such an integer:
>
> short unsigned _NoPromo n = 0xFFFF;
>
> And similarly, if we already have a variable, and we want to do some
> calculations without it promoting at some point, then we make a
> _NoPromo reference to it:
>
> short unsigned original_variable = 0xFFFF;
>
> short unsigned _NoPromo &safe_variable = original_variable;
>
> safe_variable = ~safe_variable; // no promotion takes place here

Fwiw I’ve recently been working this area as a library, as opposed to a change to the language:

    https://github.com/HowardHinnant/bbi

It looks like:

    #include "bbi.h"
    #include <iostream>
    #include <type_traits>

    int
    main()
    {
        using namespace bbi::wrap;
        u16 x{0xFFFF};
        u16 y{1};
        auto z = x + y; // no integral promotion!
        std::cout << z << '\n’; // prints out 0
        std::cout << sizeof(z) << '\n’; // prints out 2
        static_assert(std::is_same_v<decltype(z), decltype(x)>);
    }

I’m not proposing bbi to the std. But if its design influences something that somebody else proposes, I’m good with that. Or if the open source code is simply useful to somebody else, I’m good with that too.

Howard