rust bytestring trie

trie.rs

use std::collections::{HashMap};

#[derive(Debug)]
struct Trie<T> {
    un: HashMap<usize, (Option<T>, Box<Trie<T>>)>,
}

impl <T> Trie<T> {
    fn new() -> Self {
        Trie {
            un: HashMap::new(),
        }
    }

    #[inline]
    fn insert__(&mut self, k: &[u8], v: T) {
        let mut t = &mut self.un;
        let mut last: &mut _ = &mut None;
        for &ch in k {
            match t.entry(ch as usize).or_insert((None, Box::new(Trie { un: HashMap::new() }))) {
                next => {
                    t = &mut next.1.un;
                    last = &mut next.0;
                }
            }
        }
        *last = Some(v);
    }
    pub fn insert(&mut self, key: String, v: T) {
        self.insert__(key.as_bytes(), v)
    }

    #[inline]
    fn lookup__(&self, key: &[u8]) -> Option<&T> {
        let mut t = &self.un;
        let mut v = None;
        for &ch in key {
            match t.get(&(ch as usize)) {
                None => {
                    return v;
                }
                Some(next) => {
                    t = &next.1.un;
                    v = next.0.as_ref();
                }
            }
        }
        v
    }

    pub fn lookup(&self, key: &str) -> Option<&T> {
        self.lookup__(key.as_bytes())
    }

    #[inline]
    fn lookup_prefixes__(&self, key: &[u8]) -> Option<&T> {
        let mut t = &self.un;
        let mut v = None;
        for &ch in key {
            match t.get(&(ch as usize)) {
                None => {
                    return v;
                }
                Some(next) => {
                    t = &next.1.un;
                    if next.0.is_some() {
                        return next.0.as_ref();
                    }
                    v = next.0.as_ref();
                }
            }
        }
        v
    }
    fn lookup_prefixes(&self, key: &str) -> Option<&T> {
        self.lookup_prefixes__(key.as_bytes())
    }
}