fn rule_prefix(&mut self, token_tree: &Spanned<TokenTree>) -> Result<Spanned<AST>, Syntax> {
        let result = match &token_tree.item {
            TokenTree::Lit(_) => self.literal(token_tree)?,
            TokenTree::Op(name) => {
                if let ResOp::Sub = Parser::to_op(name, &token_tree.span)? {
                    todo!()
                } else {
                    return Err(Syntax::error(
                        &format!("Unexpected operator `{}`", name),
                        &token_tree.span,
                    ));
                }
            }
            TokenTree::Label(_) => self.label(token_tree)?,
            TokenTree::Iden(_) => self.symbol(token_tree)?,
            TokenTree::Form(trees) => {
                dbg!(&trees);
                // TODO: handle builtin keywords
                if let Some(Spanned { item, .. }) = trees.first() {
                    if let TokenTree::Iden(iden) = item {
                        if let Some(keyword) = ResIden::try_new(iden) {
                            // TODO: this deep clone isn't necessary,
                            // we could either pass the vectors owned
                            // or use slices instead.
                            dbg!(&trees);
                            self.keyword(
                                &trees[1..]
                                    .into_iter()
                                    .map(|x| x.clone())
                                    .collect::<Vec<_>>(),
                                keyword,
                            )?;
                        }
                    }
                }

                self.expr(trees, &mut 0, Prec::None)?
            }
            // TODO: instead of expr, use prefix.
            TokenTree::Block(trees) => {
                let mut expressions = vec![];
                for tree in trees {
                    expressions.push(self.expr(&tree.item, &mut 0, Prec::None)?);
                }
                Spanned::new(AST::Base(Base::Block(expressions)), token_tree.span.clone())
            }
            TokenTree::List(_) => unimplemented!(),
        };
        Ok(result)
    }
Entry point to parse a token tree into an AST
passerine/src/compiler/parse.rs