memcond 0.1.0

This crate provide a [memcond] macro that memoizes the outcome of an assertion and safely repeats this assertion when the variables used in the assertion are actually used.

use core::hint::black_box;
use memcond::memcond;

const NUM_PAGES: usize = 100;

memcond! {
    // This condition is checked in `PageNumber::new`.
    const fn is_page_number(number: usize) -> bool {
        number < 100
    }

    #[derive(Clone, Copy)]
    pub struct PageNumber;
}

// The macro generates roughly the following structure.
//
// ```rust
// pub struct PageNumber {
//     number: usize,
// }
// 
// impl PageNumber {
//     pub const fn new(number: usize) -> Result<Self, usize>
//     where
//         usize: memcond::Freeze
//     {
//         if !(number < 100) {
//             return Err(number);
//         }
//         Ok(Self { number })
//     }
// 
//     pub const fn number(self) -> usize {
//         // SAFETY: It's safe because condition arguments are internally immutable
//         // (all implement `Freeze`) and can't be changed via `impl PageNumber`.
//         unsafe { assert_unchecked(self.number < 100) };
//         self.number
//     }
// }
// ```

// Here the condition is checked and memoized.
let page = black_box(PageNumber::new(33).unwrap());
// A simple bitset for demonstration.
let mut pages = [false; NUM_PAGES];
// Here the condition is enforced again via `assert_unchecked` with no overhead
// because the outcome of the assertion was memoized.
// This line can be anywhere in the code with respect to `PageNumber::new`.
pages[page.number()] = true;
// As a result no index bounds checking code is generated by the compiler.

The structure is placed in its own module (not shown in the example for simplicity) to prevent implementations from accessing its fields and potentially changing the outcome of the condition. Immutability of the condition arguments is enforced via [Freeze]. Condition itself is const fn and forbids any unsafe code.

[memcond] expected condition arguments to be copiable. If this is not posible, then [memcond_ref] might be an option: this macro expects condition arguments to be passed by reference and generates into_inner method that allows one to extract the arguments without copying.