pub fn insert(&mut self, name: &str) {

        if !self.names.iter().any(|n| n == name) {

            self.names.push(name.to_string());

        }

    }

    pub fn iter(&self) -> impl Iterator<Item = &str> {

        self.names.iter().map(String::as_str)

    }

    pub fn len(&self) -> usize {

        self.names.len()

    }

    pub fn contains(&self, name: &str) -> bool {

        self.names.iter().any(|n| n == name)

    }

pub fn compute_captures(symbols: &SymbolTable, params: &LambdaParams, body: &Expr) -> CaptureSet {

    let mut captures = CaptureSet::default();

    let bound = collect_param_names(params);

    walk(symbols, &bound, body, &mut captures);

    captures

}

fn collect_param_names(params: &LambdaParams) -> Vec<String> {

    let mut names = Vec::with_capacity(

        params.required.len()

            + params.optional.len()

            + usize::from(params.rest.is_some())

            + params.key.len()

            + params.aux.len(),

    names.extend(params.required.iter().cloned());

    names.extend(params.optional.iter().map(|(n, _)| n.clone()));

    if let Some(rest) = &params.rest {

    }

    names.extend(params.key.iter().map(|(n, _)| n.clone()));

    names.extend(params.aux.iter().map(|(n, _)| n.clone()));

    names

}

fn walk(symbols: &SymbolTable, bound: &[String], expr: &Expr, captures: &mut CaptureSet) {

    match expr {

        Expr::Symbol(name) => visit_symbol(symbols, bound, name, captures),

        Expr::List(elems) => walk_list(symbols, bound, elems, captures),

        Expr::Quote(_) | Expr::Quasiquote(_) => {

            // Quoted forms don't reference runtime bindings — symbols

            // inside a quote are data, not variable references.

        }

        _ => {

            // Atoms (Nil, Bool, Number, String, Keyword, Bytes,

            // RuntimeValue, WasmRuntime, WasmLocal) carry no symbol

            // references that could be captures.

        }

}

fn visit_symbol(symbols: &SymbolTable, bound: &[String], name: &str, captures: &mut CaptureSet) {

    if bound.iter().any(|n| n == name) {

        return;

    }

    let Some(sym) = symbols.lookup(name) else {

        return;

    if matches!(

        sym.value(),

    ) {

        captures.insert(name);

    }

}

fn walk_list(symbols: &SymbolTable, bound: &[String], elems: &[Expr], captures: &mut CaptureSet) {

    let head = elems

        .first()

        .and_then(Expr::as_symbol)

        .map(str::to_uppercase);

    match head.as_deref() {

        Some("LET") => walk_let(symbols, bound, elems, captures, false),

        Some("LET*") => walk_let(symbols, bound, elems, captures, true),

        Some("LAMBDA") => walk_lambda_form(symbols, bound, elems, captures),

        Some("LABELS") => walk_labels(symbols, bound, elems, captures),

        Some("DOLIST" | "DOTIMES") => walk_iteration(symbols, bound, elems, captures),

        Some("DO" | "DO*") => walk_do(

        Some("QUOTE") => {}

            for elem in elems {

                walk(symbols, bound, elem, captures);

            }

}

fn walk_let(

    symbols: &SymbolTable,

    bound: &[String],

    elems: &[Expr],

    captures: &mut CaptureSet,

    sequential: bool,

) {

    let Some(bindings_expr) = elems.get(1) else {

    let bindings = match bindings_expr {

        Expr::List(b) => b,

    let mut scope = bound.to_vec();

    for binding in bindings {

        let (name, init) = parse_let_binding(binding);

        if let Some(init_expr) = init {

            let init_scope = if sequential { &scope[..] } else { bound };

            walk(symbols, init_scope, init_expr, captures);

        if let Some(n) = name {

            scope.push(n);

        }

    for body_form in &elems[2..] {

        walk(symbols, &scope, body_form, captures);

    }

}

fn parse_let_binding(binding: &Expr) -> (Option<String>, Option<&Expr>) {

    match binding {

        Expr::List(parts) => match parts.as_slice() {

            [Expr::Symbol(name), init] => (Some(name.clone()), Some(init)),

}

fn walk_lambda_form(

    symbols: &SymbolTable,

    bound: &[String],

    elems: &[Expr],

    captures: &mut CaptureSet,

) {

    let Some(params_expr) = elems.get(1) else {

    let mut scope = bound.to_vec();

    if let Expr::List(params) = params_expr {

        for p in params {

            if let Expr::Symbol(name) = p

                && !is_lambda_keyword(name)

            {

                scope.push(name.clone());

            } else if let Expr::List(spec) = p

    for body_form in &elems[2..] {

        walk(symbols, &scope, body_form, captures);

    }

}

fn is_lambda_keyword(name: &str) -> bool {

        name.to_ascii_uppercase().as_str(),

        "&OPTIONAL" | "&REST" | "&KEY" | "&AUX"

}

fn walk_iteration(

    symbols: &SymbolTable,

    bound: &[String],

    elems: &[Expr],

    captures: &mut CaptureSet,

) {

    let Some(spec) = elems.get(1) else {

    let (var, exprs): (Option<String>, Vec<&Expr>) = match spec {

        Expr::List(parts) => {

            let var = parts.first().and_then(|p| match p {

                Expr::Symbol(n) => Some(n.clone()),

            });

            (var, parts.iter().skip(1).collect())

    for e in exprs {

        walk(symbols, bound, e, captures);

    }

    let mut scope = bound.to_vec();

    if let Some(v) = var {

        scope.push(v);

    }

    for body_form in &elems[2..] {

        walk(symbols, &scope, body_form, captures);

    }

}