Include constant time integer operation inside core

Go-Lang has it's subtle to help developers write secure systems and servers by providing functions to do constant time integer operations.

Rust's goal is identical to this (writing secure systems and servers), so ideally shouldn't it provide a similar functionality?

These are simple re-definitions of primitive operations:

• Equality checking on Ints (u8, u16, u32, u64, usize)
• Equality checking on Slices ( &[u8], &[u16], &[u32], &[u64], &[usize])
• Conditional Copying of Slices (of Ints)
• Conditional Swapping of Ints

I am NOT proposing changes to std/core on how integer and/or slices work. Solid performance defaults are important.

I am proposing the inclusion of a few dozen free functions in core that are OPT IN ONLY. Where I'm not 100% sure. The swap/equality checking seems like they should be attached to their primitives. The slice comparisons, and cloning are weird.

Lastly the traditional method of doing this requires a degree of UB on how bit masking is done:

Returns X if Flag == 1

Returns Y if Flag == 0

Returns undefined values Flag is not 1 or 0

I've made a demo crate. But it is un-audited.

Edit 1:

I've implemented the boolean conversion and verified the ASM generated uses no branching or conditionals on x86/x86_64.

Start by reading the proposed operations in the issue and the linked consistenttime demo crate, then compare them with the existing core primitives and slice APIs. Work out the API placement and opt-in scope for constant-time integer and slice operations, and verify the generated x86/x86_64 assembly has no branches or conditionals.