Quando provo a trasformare una classe con uno stato mutabile in una immutabile, faccio regolarmente fatica a scegliere tra due alternative: 1) o estrae lo stato in un altro oggetto di stato (immutabile) e passare questo stato alla classe con ogni chiamata al metodo (e restituire il nuovo stato) o 2) rendere lo stato parte della classe immutabile e restituire una nuova istanza di classe con stato potenzialmente modificato con ogni chiamata di metodo.
Ecco un esempio in Scala:
Questo è il punto in cui vengo
class SomeApiWrapper(val credentials: ApiCredentials) {
var nonce = 1L // mutable field
def apiCall(someParam: String): Unit = {
// make api call
// increase nonce
}
}
Opzione 1 - Stato separato
class SomeApiWrapper(val credentials: ApiCredentials) {
def apiCall(someParam: String, s: ApiWrapperState) = {
// get nonce from state
// api call
// return new state with increased nonce
}
}
Opzione 2 - Nuova istanza con ogni chiamata di metodo
class SomeApiWrapper(val credentials: ApiCredentials, val nonce: Long) {
def apiCall(someParam: String): SomeApiWrapper = {
// api call with nonce
SomeApiWrapper(credentials, nonce + 1)
}
}
Mi piace la chiara separazione dei parametri di configurazione (credenziali) dallo stato nel costruttore per l'opzione 1, tuttavia, è un po 'fastidioso che per ogni classe ora ne ho due (uno in più per lo stato) e io devi passare intorno allo stato tutto il tempo.
Ci sono altri buoni argomenti per scegliere la prima o la seconda opzione? Mi manca un'altra opzione qui? Dovrei farlo completamente un modo differente? C'è qualche letteratura standard su cui leggere questo?