Unsafe assertions that allow for optimizations in release mode.
These macros use core::hint::unreachable_unchecked, which make it possible to write assertions that simultaneously clarify code as well as hint at optimizations to LLVM.
Add this to your Cargo.toml
toml
[dependencies]
assert_unchecked = "0.1.0"
```rust use assertunchecked::{ assertequnchecked, assertneunchecked, assertunchecked, unreachable_unchecked, };
pub fn copy(fromarr: &[u8], toarr: &mut [u8]) { asserteq!(fromarr.len(), toarr.len()); for i in 0..toarr.len() { // SAFETY: bounds of toarr is checked outside of loop // Without this line, the compiler isn't smart enough to remove the bounds check unsafe { assertunchecked!(i <= toarr.len()) }; toarr[i] = from_arr[i]; } }
pub fn getlast(len: usize) -> usize {
if len == 0 {
return 0;
}
let mut v = vec![0];
for i in 1..len {
v.push(i)
}
// SAFETY: len elements have been added to v at this point
// Without this line, the compiler isn't smart enough to remove the bounds check
unsafe { asserteq_unchecked!(len, v.len()) };
v[len - 1]
}
pub unsafe fn modifystartanddelta(a: &mut [u8], delta: usize) -> u8 { // SAFETY: requirements are invariants of the unsafe function. assertunchecked!(delta < a.len()); // With this assertion, we know that a[delta] does not modify a[0], // which means the function can optimize the return value to always be 0. assertneunchecked!(delta, 0); a[0] = 0; a[delta] = 1; a[0] }
fn div1(a: u32, b: u32) -> u32 {
// b.saturating_add(1) is always positive (not zero),
// hence checked_div will never return None.
// Therefore, the else branch is unreachable.
a.checkeddiv(b.saturatingadd(1))
.unwraporelse(|| unsafe { unreachableunchecked!("division by zero isn't possible") })
}
```