Come imitare un sistema di eventi con un sistema booleano

In un sistema booleano, dì che hai un ciclo while in corso. Quindi potresti avere questo:

if (just_did_x) {
  do_something()
}

Per evitare di chiamare do_something() più di una volta, puoi fare:

if (just_did_x) {
  do_something()
  just_did_x = false
}

Ma il problema è che potresti fare riferimento a questo booleano in più condizioni:

if (just_did_x) {
  do_something()
}

if (just_did_x && just_did_y) {
  do_something2()
}

if (just_did_x && just_did_z) {
  do_something3()
}

...

Quindi puoi impostare just_did_x = false in ciascuno di quei blocchi if , ma questa è un'ulteriore elaborazione / duplicazione. Anche in questo caso farebbe l'errore del codice:

if (just_did_x) {
  do_something()
  just_did_x = false
}

// just_did_x == false now, so this doesn't evaluate.
if (just_did_x && just_did_y) {
  do_something2()
  just_did_x = false
}

// same here.
if (just_did_x && just_did_z) {
  do_something3()
  just_did_x = false
}

...

Ciò significa che è necessario accodare impostando i valori booleani fino a quando tutte le condizioni sono state valutate. Questo aggiunge solo complessità. Inoltre, non puoi impostare il valore booleano just_did_x su falso finché just_did_y e just_did_z sono diventati veri (supponendo che funzionino come una coda). Quindi ora abbiamo bisogno di più variabili booleane.

if (just_did_x) {
  do_something()
  just_did_x_condition = true
}

if (just_did_x && just_did_y) {
  do_something2()
  just_did_x_just_did_y_condition = true
}

if (just_did_x && just_did_z) {
  do_something3()
  just_did_x_just_did_z_condition = true
}

if (just_did_x_condition
  && just_did_x_just_did_y_condition
  && just_did_x_just_did_z_condition) {
    just_did_x = false
    just_did_y = false
    just_did_z = false
  }

Ma non è giusto perché vuoi eseguire do_something() dopo ogni "evento" di just_did_x . Quindi sto iniziando a capire che il sistema booleano non è in grado di replicare il sistema degli eventi. Ma forse è ancora possibile!

Con gli eventi, non è necessario impostare e disinserire alcun valore, l'evento rimane in vita mentre viene gestito e poi si allontana. (Probabilmente c'è qualcosa di equivalente alla cosa booleana in background / con garbage collection, ma non so come funzioni). Con gli eventi, gestisci semplicemente l'evento:

handleEvent(just_did_x, function(event){
  do_something()
})

Con l'ascolto di più eventi, potrebbe essere simile al seguente:

handleEvent(just_did_x, just_did_y, function(event){
  do_something2()
})

handleEvent(just_did_x, just_did_z, function(event){
  do_something3()
})

...

Fondamentalmente quello che mi chiedo è se esiste un sistema per lavorare con variabili booleane che imitano il sistema degli eventi . Dato che qualcosa attiva il ciclo while per valutare le condizioni nel sistema booleano (attraverso un ciclo while infinito o un evento di sistema reale), come strutturare il sistema booleano in modo che funzioni esattamente come gli eventi.

Per "sistema booleano" intendo solo un insieme di variabili booleane utilizzate per tenere traccia di tutti gli eventi che simulano lo stato.