fn abstract_step(&self, state: AbstractState, instruction: Bytecode) -> AbstractState {
        // TODO: Handle error case in way that reflects VM behavior
        let should_error = summaries::instruction_summary(instruction.clone())
            .preconditions
            .iter()
            .any(|precondition| !precondition(&state));
        if should_error {
            let mut state = state.clone();
            state.abort();
            state
        } else {
            summaries::instruction_summary(instruction)
                .effects
                .iter()
                .fold(state, |acc, effect| {
                    effect(&acc).unwrap_or_else(|err| {
                        unreachable!("Error applying instruction effect: {}", err)
                    })
                })
        }
    }
/// Transition an abstract state, `state` to the next state by applying all of the effects
/// of a particular bytecode instruction, `instruction`.
Transition an abstract state, `state` to the next state by applying all of the effects
of a particular bytecode instruction, `instruction`.
Transition an abstract state ` state ` to the next state by applying all of the effects of a particular bytecode instruction ` instruction ` .
fn abstract_step(&self, state: AbstractState, instruction: Bytecode) -> AbstractState {
        // TODO: Handle error case in way that reflects VM behavior
        let should_error = summaries::instruction_summary(instruction.clone())
            .preconditions
            .iter()
            .any(|precondition| !precondition(&state));
        if should_error {
            let mut state = state.clone();
            state.abort();
            state
        } else {
            summaries::instruction_summary(instruction)
                .effects
                .iter()
                .fold(state, |acc, effect| {
                    effect(&acc).unwrap_or_else(|err| {
                        unreachable!("Error applying instruction effect: {}", err)
                    })
                })
        }
    }
fn abstract_step ( & self , state : AbstractState , instruction : Bytecode ) -> AbstractState { // TODO: Handle error case in way that reflects VM behavior let should_error = summaries :: instruction_summary ( instruction . clone ( ) ) . preconditions . iter ( ) . any ( | precondition | ! precondition ( & state ) ) ; if should_error { let mut state = state . clone ( ) ; state . abort ( ) ; state } else { summaries :: instruction_summary ( instruction ) . effects . iter ( ) . fold ( state , | acc , effect | { effect ( & acc ) . unwrap_or_else ( | err | { unreachable ! ( " " err ) } ) } ) } }
Transition an abstract state, `state` to the next state by applying all of the effects
of a particular bytecode instruction, `instruction`.
Transition an abstract state ` state ` to the next state by applying all of the effects of a particular bytecode instruction ` instruction ` .
&self
state
AbstractState
instruction
Bytecode