pub fn scan(input: &[u8]) -> Result<Vec<Token>, (TokenError, usize)> {

    pub fn scan(input: &[u8]) -> Result<Vec<(Token, usize)>, (TokenError, usize)> {

            .map(|(pos, inp)| map(inp).map_err(|err| (err, pos)))

            .map(|(pos, inp)| map(inp)
                .map(|tok| (tok, pos))
                .map_err(|err| (err, pos)))

    TokenError((tokenizer::TokenError, usize))

    TokenError((tokenizer::TokenError, usize)),
    UnexpectedEnd

fn parse_expr(tokens: &mut Peekable<IntoIter<Token>>) -> Result {

fn parse_expr(tokens: &mut Peekable<IntoIter<(Token, usize)>>) -> Result {

fn parse_expr_inner(tokens: &mut Peekable<IntoIter<Token>>, left: Expr) -> Result {

fn parse_expr_inner(tokens: &mut Peekable<IntoIter<(Token, usize)>>, left: Expr) -> Result {
    if matches!(tokens.peek(), Some((Token::Alt, _))) {
        let _ = tokens.next().unwrap();
        let right = parse_term(tokens)?;
        let expr = Expr::Alt(Box::new(left), Box::new(right));

        parse_expr_inner(tokens, expr)
    } else {
        Ok(left)
    }

fn parse_term(tokens: &mut Peekable<IntoIter<Token>>) -> Result {

fn parse_term(tokens: &mut Peekable<IntoIter<(Token, usize)>>) -> Result {

fn parse_term_inner(tokens: &mut Peekable<IntoIter<Token>>, left: Expr) -> Result {

fn parse_term_inner(tokens: &mut Peekable<IntoIter<(Token, usize)>>, left: Expr) -> Result {
    if matches!(tokens.peek(), Some((Token::Char(_), _)) | Some((Token::Dot, _))) {
        let right = parse_factor(tokens)?;
        let expr = Expr::Conc(Box::new(left), Box::new(right));

        parse_term_inner(tokens, expr)
    } else {
        Ok(left)
    }

fn parse_factor(tokens: &mut Peekable<IntoIter<Token>>) -> Result {

fn parse_factor(tokens: &mut Peekable<IntoIter<(Token, usize)>>) -> Result {
    match tokens.next() {
        Some((Token::Star, _)) => {
            Ok(Expr::Star(()))
        }

        _ => Err(ParseError::UnexpectedEnd)
    }