//! The following code is licensed under `CC0-1.0`.

fn main() {
    let mut counter = Alphabets::<usize>::new();
    counter[b'A'] += 42;
    counter[b'Z'] += 100;
    dbg!(counter);
}

// "Associated constants" was stabilized in Rust 1.20
const A: u8 = b'A';

// "impl Trait" was stabilized in Rust 1.26
type Iter<'a, T> =
    std::iter::Map<std::iter::Enumerate<std::slice::Iter<'a, T>>, fn((usize, &T)) -> (u8, T)>;

#[derive(Default)]
struct Alphabets<T>([T; 26]);

impl<T: Default> Alphabets<T> {
    fn new() -> Self {
        Self::default()
    }
}

impl<T: Copy> Alphabets<T> {
    fn iter(&self) -> Iter<T> {
        self.0.iter().enumerate().map(|(i, &v)| (i as u8 + A, v))
    }

    fn values(&self) -> std::iter::Cloned<std::slice::Iter<T>> {
        self.0.iter().cloned()
    }
}

impl<T: Copy + Ord> Alphabets<T> {
    fn max(&self) -> T {
        self.0.iter().cloned().max().unwrap()
    }

    fn min(&self) -> T {
        self.0.iter().cloned().min().unwrap()
    }
}

impl<T> std::ops::Index<u8> for Alphabets<T> {
    type Output = T;

    fn index(&self, idx: u8) -> &T {
        &self.0[usize::from(idx - A)]
    }
}

impl<T> std::ops::IndexMut<u8> for Alphabets<T> {
    fn index_mut(&mut self, idx: u8) -> &mut T {
        &mut self.0[usize::from(idx - A)]
    }
}

impl<T: std::fmt::Debug> std::fmt::Debug for Alphabets<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        let mut fmt = fmt.debug_map();
        fmt.entries((A..A + 26).map(|c| (char::from(c), &self[c])));
        fmt.finish()
    }
}