Passing struct attributes to another struct

[nova brook]

Code:

// impl compiler
  pub fn get_rule(&mut self, ttype: TokenType) -> ParseRule {
        macro_rules! rule {
            ($prefix:expr, $infix:expr, $prec:expr) => {
                ParseRule {
                    prefix: $prefix,
                    infix: $infix,
                    precedence: $prec,
                }
            };
        }

        let rules: [ParseRule; 40] = [
            rule!(Some(Compiler::grouping), None, Precedence::None), // TOKEN_LEFT_PAREN
            rule!(None, None, Precedence::None),                   // TOKEN_RIGHT_PAREN
            rule!(None, None, Precedence::None),                   // TOKEN_LEFT_BRACE
            rule!(None, None, Precedence::None),                   // TOKEN_RIGHT_BRACE
            rule!(None, None, Precedence::None),                   // TOKEN_COMMA
            rule!(None, None, Precedence::None),                   // TOKEN_DOT
            rule!(Some(Compiler::unary), Some(Compiler::binary), Precedence::Term), // TOKEN_MINUS
            rule!(None, Some(Compiler::binary), Precedence::Term),   // TOKEN_PLUS
            rule!(None, None, Precedence::None),                   // TOKEN_SEMICOLON
            rule!(None, Some(Compiler::binary), Precedence::Factor), // TOKEN_SLASH
            rule!(None, Some(Compiler::binary), Precedence::Factor), // TOKEN_STAR
            rule!(Some(Compiler::number), None, Precedence::None),   // TOKEN_NUMBER
            // continues
        ];

        if let Some(rule) = rules.get(ttype as usize) {
            return *rule;
        } else {
            return rule!(None, None, Precedence::None);
        }
    }

// the structs:
struct ParseRule {
    prefix: Option<ParseFn>,
    infix: Option<ParseFn>,
    precedence: Precedence,
}

pub struct Compiler {
    current: Option<Token>,
    previous: Option<Token>,
    compiling_chunk: Option<Chunk>,
    had_error: bool,
    panic_mode: bool,
    scanner: Scanner,
}

[teal portal]

it seems like you've declared the wrong function signature as ParseFn

what is the definition of ParseFn?

[nova brook]

ParseFn is just

type ParseFn = fn();

[teal portal]

that's exactly the problem

you need type ParseFn = fn(&mut Compiler);

[nova brook]

bruh is it that easy

[teal portal]

well, maybe

[nova brook]

indeed it is

[teal portal]

but you definitely should only use fn() if the function actually takes zero arguments and returns nothing!

[nova brook]

it does

[teal portal]

no, it takes one argument, &mut Compiler

method receivers are arguments too