Minimal AST uniquify example

uniq.rs

use std::collections::HashMap;
use std::rc::Rc;

#[derive(Debug)]
enum AST {
    Symbol(Rc<String>),
    Int(i32),
    Let(Vec<(Rc<String>, Box<AST>)>, Box<AST>),
}

static mut VAR_COUNTER : i32 = 0;
pub fn get_unique_varname(stem: &str) -> String {
    unsafe {
        VAR_COUNTER += 1;
        return stem.to_string() + &VAR_COUNTER.to_string();
    }
}

impl AST {
    fn uniquify(self, mapping: &mut HashMap<Rc<String>, Rc<String>>) -> Self {
        match self {
            AST::Int(_) => self,
            AST::Symbol(sym) => {
                let uniq_sym = Rc::new(mapping.get(&sym)
                                       .unwrap()
                                       .to_string());
                AST::Symbol(uniq_sym)
            },
            AST::Let(bindings, body) => {
                let mut new_bindings = vec![];
                for (k, v) in bindings {
                    let uniq_k = Rc::new(get_unique_varname(&k));
                    new_bindings.push((uniq_k.clone(),
                                       Box::new(v.uniquify(mapping))));
                    mapping.insert(k, uniq_k.clone());
                    
                }
                AST::Let(new_bindings,
                         Box::new(body.uniquify(mapping)))
            },
        }
    }
}

fn main() {
    let x = Rc::new("x".to_string());
    // (let ((x 10))
    //   (let ((x 12))
    //     x))
    let a = AST::Let(vec![(x.clone(), Box::new(AST::Int(10)))],
                     Box::new(AST::Let(vec![(x.clone(), 
                                             Box::new(AST::Int(12)))],
                                       Box::new(AST::Symbol(x.clone())))));

    let mut uniquify_mapping = HashMap::new();
    println!("{:?}", a.uniquify(&mut uniquify_mapping));
}