Quindi, molto spesso nel tuo codice hai istruzioni / algoritmi come questo:
if (!myCollection.contains(unit))
throw new IllegalArgumentException(s"$unit is not available")
Il problema che ho con questo approccio che ingombra il codice sorgente - questo è particolarmente vero se hai bisogno di controlli approfonditi.
Stavo pensando se tali algoritmi, controlli, ecc. ripetitivi siano più risolvibili in scala, ad es. da un DSL?
Mentre puoi usare certe astrazioni come una DSL per semplificare cose come il controllo degli argomenti, nella programmazione funzionale, quella sorta di gestione degli errori per effetto collaterale viene solitamente evitata del tutto dal modo in cui strutturi il programma.
Ad esempio, un controllo di disponibilità potrebbe essere simile a questo:
def firstAvailableUnit(): Option[Unit] = {
val available = units filter {_.available == true }
filter {_.occupancy == 4 }
filter {_.haunted == false }
available.headOption
}
// The calling code:
println(firstAvailableUnit() map {_.name} getOrElse "No units available")
OOP usa una sorta di approccio alla validazione dello strumento contundente. Una volta che hai capito il modo idiomatico di FP, ti sembra un po 'come se le tue argomentazioni fossero state già convalidate magicamente per te.
Leggi altre domande sui tag scala