With const_guards you can express certain compile time constraints on rust's const_generics using the unstable generic_const_exprs feature.
For documentation visit docs.rs.
Consider the following usage of the first method on arrays from the standard library:
rust
let array: [(); 1] = [(); 1];
let head: Option<&()> = array.first();
Would it be nice if we could just write
rust
let head: &() = array.first();
since the compiler should know this array has length 1 at this point.
With const guards we can express such as follows:
```rust
fn first<'a, T, const N: usize>(array: &'a [T; N]) -> &'a T {
&array[0]
}
The index call on the array `&array[0]` cannot possible fail because we enforced the length of the array to be `> 0` at compile time. We could now call it as follows
rust
let array: [(); 1] = [(); 1];
let head: &() = first(&array);
while the case where the array is actually empty would _fail to compile_:
let array: [(); 0] = [(); 0];
let head: &() = first(&array);
Finally we could even express this as a trait to make it more accessable:
rust
trait ArrayHead
impl
fn main() { let array: &[(); 1] = &[(); 1]; let head: &() = array.head(); } ``` Though, as you can see, we need to introduce generics not introduced by the guarded item explicitly.
Consider this simple example of a const guard: ```rust fn main() { f::<0>() }
fn f
and have a look at the expanded form:
rust
struct Guard
trait Protect {}
impl Protect for Guard
fn main() { f::<0>() }
fn f