pub(super) fn compile_setf(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let ty = compile_setf_for_stack(ctx, emit, symbols, args)?;

    serialize_stack_to_output(ctx, emit, ty)

}

pub(super) fn compile_setf_for_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    if !args.len().is_multiple_of(2) {

    }

    let pairs: Vec<&[Expr]> = args.chunks(2).collect();

    let Some(last) = pairs.len().checked_sub(1) else {

    let mut result_ty = WasmType::Bool;

    for (i, pair) in pairs.iter().enumerate() {

        let place = &pair[0];

        let value_expr = &pair[1];

        let is_last = i == last;

        let runtime_local = match place {

            Expr::Symbol(name) => {

                symbols

                    .lookup(name)

                    .and_then(|s| s.value())

                    .and_then(|v| match v {

                        Expr::WasmLocal(idx, ty) => Some((*idx, *ty)),

                        _ => None,

                    })

        match runtime_local {

            Some((idx, ty)) => {

                compile_for_stack_as(ctx, emit, symbols, value_expr, ty)?;

                if matches!(ty, WasmType::Closure(_)) {

                }

                if is_last {

                    emit.local_tee(idx);

                    result_ty = ty;

                } else {

                    emit.local_set(idx);

                }

                let value = if rhs_has_runtime_store(value_expr, symbols) {

                    compile_for_effect(ctx, emit, symbols, value_expr)?;

                    eval_value(&mut symbols.clone(), value_expr)?

                    eval_value(symbols, value_expr)?

                let assigned = set_place(symbols, place, value)?;

                if is_last {

                    result_ty = compile_for_stack(ctx, emit, symbols, &assigned)?;

    Ok(result_ty)

}

pub(in crate::compiler) fn rhs_has_runtime_store(expr: &Expr, symbols: &SymbolTable) -> bool {

    let Expr::List(elems) = expr else {

        return false;

    if let Some(Expr::Symbol(head)) = elems.first()

        && (head.eq_ignore_ascii_case("setf") || head.eq_ignore_ascii_case("set!"))

        for pair in elems[1..].chunks(2) {

            if let Some(Expr::Symbol(place)) = pair.first()

                    symbols.lookup(place).and_then(|s| s.value()),

                return true;

}

pub(super) fn defstruct(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.is_empty() {

    }

    let name = args[0].as_symbol().ok_or_else(|| {

    let fields: Vec<String> = args[1..]

        .iter()

        .map(|arg| {

            arg.as_symbol()

                .map(std::string::ToString::to_string)

                .ok_or_else(|| {

        })

        .collect::<Result<_>>()?;

    symbols.define_struct_fields(name.to_string(), fields.clone());

    let constructor_name = format!("MAKE-{name}");

    let constructor_params = LambdaParams {

        required: Vec::new(),

        optional: Vec::new(),

        rest: None,

        key: fields.iter().map(|field| (field.clone(), None)).collect(),

        aux: Vec::new(),

    let constructor_body = {

        let field_values: Vec<Expr> = fields

            .iter()

            .map(|field| Expr::Symbol(field.clone()))

            .collect();

        Expr::List(vec![

            Expr::Symbol("MAKE-STRUCT-INSTANCE".to_string()),

            Expr::Quote(Box::new(Expr::String(name.to_string()))),

            Expr::Quote(Box::new(Expr::List(

                fields.iter().map(|f| Expr::String(f.clone())).collect(),

            Expr::List(

                vec![Expr::Symbol("LIST".to_string())]

                    .into_iter()

                    .chain(field_values)

                    .collect(),

            ),

    let constructor = Expr::Lambda(constructor_params, Box::new(constructor_body));

    symbols.define(

        Symbol::new(&constructor_name, SymbolKind::Function).with_function(constructor.clone()),

    for field in &fields {

        let accessor_name = format!("{name}-{field}");

        let accessor_params = LambdaParams::simple(vec!["INSTANCE".to_string()]);

        let accessor_body = Expr::List(vec![

            Expr::Symbol("STRUCT-FIELD".to_string()),

            Expr::Symbol("INSTANCE".to_string()),

            Expr::Quote(Box::new(Expr::String(field.clone()))),

        ]);

        let accessor = Expr::Lambda(accessor_params, Box::new(accessor_body));

        symbols.define(Symbol::new(&accessor_name, SymbolKind::Function).with_function(accessor));

        let setf_accessor_name = format!("(SETF {accessor_name})");

        let setf_params =

            LambdaParams::simple(vec!["INSTANCE".to_string(), "NEW-VALUE".to_string()]);

        let setf_body = Expr::List(vec![

            Expr::Symbol("STRUCT-SET-FIELD".to_string()),

            Expr::Symbol("INSTANCE".to_string()),

            Expr::Quote(Box::new(Expr::String(field.clone()))),

            Expr::Symbol("NEW-VALUE".to_string()),

        ]);

        let setf_function = Expr::Lambda(setf_params, Box::new(setf_body));

        symbols.define(

            Symbol::new(&setf_accessor_name, SymbolKind::Function).with_function(setf_function),

        );

    }

    let predicate_name = format!("{name}-P");

    let predicate_params = LambdaParams::simple(vec!["OBJECT".to_string()]);

    let predicate_body = Expr::List(vec![

        Expr::Symbol("STRUCT-P".to_string()),

        Expr::Symbol("OBJECT".to_string()),

        Expr::Quote(Box::new(Expr::String(name.to_string()))),

    ]);

    let predicate = Expr::Lambda(predicate_params, Box::new(predicate_body));

    symbols.define(Symbol::new(&predicate_name, SymbolKind::Function).with_function(predicate));

    Ok(Expr::Quote(Box::new(Expr::Symbol(name.to_string()))))

}

pub(super) fn setf(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if !args.len().is_multiple_of(2) {

    }

    if args.is_empty() {

    }

    let mut last_value = Expr::Nil;

    for pair in args.chunks(2) {

        let place = &pair[0];

        let value = eval_value(symbols, &pair[1])?;

        last_value = set_place(symbols, place, value)?;

    Ok(last_value)

}

pub(in crate::compiler) fn set_place(

    symbols: &mut SymbolTable,

    place: &Expr,

    value: Expr,

) -> Result<Expr> {

    match place {

        Expr::Symbol(name) => {

            match symbols.lookup_mut(name) {

                Some(sym) if matches!(sym.value(), Some(Expr::WasmLocal(_, _))) => {}

                Some(sym) => sym.set_value(value.clone()),

                None => symbols

                    .define(Symbol::new(name, SymbolKind::Variable).with_value(value.clone())),

            Ok(value)

        Expr::List(exprs) if !exprs.is_empty() => {

            if let Expr::Symbol(func_name) = &exprs[0] {

                let setf_name = format!("(SETF {func_name})");

                if symbols.contains(&setf_name) {

                    let mut setf_args = exprs[1..].to_vec();

                    setf_args.push(value.clone());

                    let call_args: Vec<Expr> = [Expr::Symbol(setf_name)]

                        .into_iter()

                        .chain(setf_args)

                        .collect();

                    let new_whole = super::super::expr::call(symbols, &call_args)?;

                    if let Some(Expr::Symbol(target)) = exprs.get(1)

                        && symbols.contains(target)

                        set_place(symbols, &Expr::Symbol(target.clone()), new_whole.clone())?;

                    Ok(new_whole)

}