pub fn tick(state: &mut SPState, trans: &[Vec<&Transition>], predicates: &[RunnerPredicate]) -> Vec<SPPath> {
        SPTicker::upd_preds(state, predicates);
        trans
            .iter()
            .flat_map(|ts| {
                let xs = SPTicker::tick_ts(state, ts);
                SPTicker::upd_preds(state, predicates);
                xs
            })
            .collect()
    }
/// The core tick function of the runner that tries to execute all transitions one step.
///
/// state is the state that will be updated
/// trans is a list of transition rows where each transition in a row is syncronized and will always fire together
/// predicates is all state predicate variables that should update after each state change. A state predicate is a boolean state
/// variable that is assigned its value based on a predicate on the current state.
///
/// A "transition row" can only execute if all guards of the transitions in the row are fullfilled and that no action tries to
/// change an already updated variable (when a variable has a next value). When the transitions fires, the actions takes in order
/// and if multiple actions tried to change the same variable, the first action will be used.
///
/// Tick returns the paths of the transitions that fired
///
The core tick function of the runner that tries to execute all transitions one step.
state is the state that will be updated
trans is a list of transition rows where each transition in a row is syncronized and will always fire together
predicates is all state predicate variables that should update after each state change. A state predicate is a boolean state
variable that is assigned its value based on a predicate on the current state.

A "transition row" can only execute if all guards of the transitions in the row are fullfilled and that no action tries to
change an already updated variable (when a variable has a next value). When the transitions fires, the actions takes in order
and if multiple actions tried to change the same variable, the first action will be used.

Tick returns the paths of the transitions that fired
The core tick function of the runner that tries to execute all transitions one step . state is the state that will be updated trans is a list of transition rows where each transition in a row is syncronized and will always fire together predicates is all state predicate variables that should update after each state change . A state predicate is a boolean state variable that is assigned its value based on a predicate on the current state . A " transition row " can only execute if all guards of the transitions in the row are fullfilled and that no action tries to change an already updated variable ( when a variable has a next value ) . When the transitions fires the actions takes in order and if multiple actions tried to change the same variable the first action will be used . Tick returns the paths of the transitions that fired
pub fn tick(state: &mut SPState, trans: &[Vec<&Transition>], predicates: &[RunnerPredicate]) -> Vec<SPPath> {
        SPTicker::upd_preds(state, predicates);
        trans
            .iter()
            .flat_map(|ts| {
                let xs = SPTicker::tick_ts(state, ts);
                SPTicker::upd_preds(state, predicates);
                xs
            })
            .collect()
    }
pub fn tick ( state : & mut SPState , trans : & [ Vec < & Transition > ] , predicates : & [ RunnerPredicate ] ) -> Vec < SPPath > { SPTicker :: upd_preds ( state , predicates ) ; trans . iter ( ) . flat_map ( | ts | { let xs = SPTicker :: tick_ts ( state , ts ) ; SPTicker :: upd_preds ( state , predicates ) ; xs } ) . collect ( ) }
The core tick function of the runner that tries to execute all transitions one step.
The core tick function of the runner that tries to execute all transitions one step .
state
&mut SPState
trans
&[Vec<&Transition>]
predicates
&[RunnerPredicate]