pub fn verify(&self) -> bool {
        // go through each opcode
        // check the number of arguments
        // check that the arguments are valid
        let mut index = 0;

        while index < self.code.len() {
            // safely decode an opcode
            let opcode = match Opcode::from_byte_safe(self.code[index]) {
                Some(o) => o,
                None => {
                    return false;
                }
            };

            index += 1;
            let bounds = self.bounds(opcode);
            let args_result = self.args_safe(index, &bounds);

            index += match args_result {
                Some((_args, consumed)) => consumed,
                None => {
                    return false;
                }
            }
        }

        return true;
    }
NOTE: WIP, do not use.
Statically verifies some bytecode safely,
By ensuring bytecode ops are within bounds,
As well as the arguments those ops take.
Returns `false` if the bytecode is invalid.
passerine-common/src/lambda.rs