Function parse

regexer/src/lexer/ast.rs:121–215

TODO: define a `consume` function to not keep repeating the peeks_tokens.next() all the time

(tokens: Vec<tokens::Token>)

// TODO: define a `consume` function to not keep repeating the peeks_tokens.next() all the time
pub fn parse(tokens: Vec<tokens::Token>) -> Vec<Function> {
    let mut peeks_tokens = tokens.clone().into_iter().enumerate().peekable();
    let mut functions: Vec<Function> = vec![];

    while let Some((index, token)) = peeks_tokens.peek() {
        if let tokens::Token::Identifier(identifier) = token {
            match identifier.as_str() {
                "letter" | "letters" => {
                    let (func_tokens, right_pos_idx) = slice_until_end_func(&tokens, &index);

                    let casing = find_casing_parameter(func_tokens, "upcase".to_string());
                    let select = find_int_parameter(func_tokens, "select".to_string());

                    if identifier == "letter" {
                        functions.push(Function::Letter {
                            casing: casing.clone(),
                            select: select.clone(),
                        });
                    }

                    if identifier == "letters" {
                        functions.push(Function::Letters {
                            casing: casing.clone(),
                        });
                    }

                    peeks_tokens.nth(right_pos_idx + 1);
                }
                "number" => {
                    let (func_tokens, right_pos_idx) = slice_until_end_func(&tokens, &index);

                    let select = find_int_parameter(func_tokens, "select".to_string());

                    functions.push(Function::Number {
                        select: select.clone(),
                    });

                    peeks_tokens.nth(right_pos_idx + 1);
                }
                "numbers" => {
                    peeks_tokens.next();
                    functions.push(Function::Numbers)
                }
                "glob" => {
                    let (func_tokens, right_pos_idx) = slice_until_end_func(&tokens, &index);
                    if func_tokens
                        == [
                            tokens::Token::LeftParen,
                            tokens::Token::Parameter("rest".to_string()),
                            tokens::Token::Equal,
                            tokens::Token::True,
                            tokens::Token::RightParen,
                        ]
                    {
                        functions.push(Function::Glob { rest: true });
                    }

                    if func_tokens