fn destructure(&mut self, pattern: Spanned<Pattern<UniqueSymbol>>, redeclare: bool) {
        self.lambda.emit_span(&pattern.span);

        match pattern.item {
            Pattern::Symbol(unique_symbol) => {
                self.resolve_assign(unique_symbol);
            }
            Pattern::Lit(expected) => {
                self.lit(expected);
                self.lambda.emit(Opcode::UnData);
            }
            Pattern::Label(name, pattern) => {
                todo!()
                // self.lit(Lit::Kind(name.0));
                // self.lambda.emit(Opcode::UnLabel);
                // self.destructure(*pattern, redeclare);
            }
            Pattern::Tuple(tuple) => {
                for (index, sub_pattern) in tuple.into_iter().enumerate() {
                    self.lambda.emit(Opcode::UnTuple);
                    self.lambda.emit_bytes(&mut split_number(index));
                    self.destructure(sub_pattern, redeclare);
                }
                // Delete the tuple moved to the top of the stack.
                self.lambda.emit(Opcode::Del);
            }
            Pattern::Chain(_) => todo!("handle pattern chains"),
        }
    }
Destructures a pattern into
a series of unpack and assign instructions.
Instructions match against the topmost stack item.
Does delete the data that is matched against.
passerine/src/compiler/compile.rs