✨ Shiny future story: Array split first method

Shiny future of status quo story

Barbara is working on her project. She has the idea to write a split_first function that will allow her to split out the first item from a fixed-length array; naturally, the array must be non-empty. It looks something like this:

#![allow(unused)]
fn main() {
// Note: this method has an implied where clause that `N - 1` evaluates without 
// erroring because `N - 1` is in the function signature
fn split_first<T, const N: usize>(arr: [T; N]) -> (T; [T; N - 1]) {
    // ...
    let tail: [T; N - 1] = // ...
    (head, tail)
}
}

Next she wants to write a function that uses split_first:

#![allow(unused)]
fn main() {
fn some_method<const N: usize>(arr: [u8; N]) {
    let (first, rest) = split_first(arr);
    for i in rest {
        // ...
    }
}
}

The compiler gives her a compile error:

error: the constant expression `N - 1` is not known to evaluate without underflowing
2 |     let (first, rest) = split_first(arr);
  |                         ^^^^^^^^^^^ `N - 1` not known to be evaluatable without underflowing
note: required by this expression in `split_first`'s function signature
5 |     fn split_first<T, const N: usize>(arr: [T; N]) -> (T; [T; N - 1]) {
  |                                                               ^^^^^
help: add a where clause to `some_method`
  | fn some_method<const N: usize>(arr: [u8; N]) where { N > 0; }

Barbara hits the 'quick fix' button in her IDE and it inserts the where clause for her- she immediately gets a compile error at another spot because she was calling some_method with an empty array:

error: the constant `0` is not greater than `0`
22 |     some_method([])
info: `0` must be greater than `0` because of this where clause
  | fn some_method<const N: usize>(arr: [u8; N]) where { N > 0; }
  |                                                    ----------

Barbara has no more compile errors, even the following code is compiling:

#![allow(unused)]
fn main() {
fn some_other_method<const N: usize>(arr: [u8; N]) where { N > 1; } {
    // ...
    let (first, rest) = split_first(arr);
    // ...
}
}