Per tutto l'anno scorso ho scritto il codice Scala (proveniente da uno sfondo Java) . Mi è piaciuto molto il modo in cui è possibile creare codice più semplice e più pulito, con vals, case classes, funzioni map / filter / lambda, impliciti e inferenza del tipo. L'ho usato principalmente per un'applicazione Akka .
Quest'anno parteciperò a un progetto Scala con un nuovo team, che apprezza molto la programmazione funzionale. Usano pesantemente Scalaz , e il codice è riempito ovunque con applicazioni, limiti di contesto, lettore / scrittore / stato, anche il metodo principale è "avvolto" in una monade I / O. Il loro ragionamento è che questo fa sì che il compilatore "lavori per noi" nell'affermare che il codice è corretto e ogni funzione è priva di effetti collaterali.
Anche così, dal mio punto di vista tutta questa sintassi interferisce con la logica del business. Ad esempio, un tipo di "MyBusinessObject" va bene, così come tipi "List [MyBusinessObject]", "Option [MyBusinessObject]" o anche "Future [MyBusinessObject]". Hanno tutti un significato e uno scopo chiari. D'altra parte, codice come:
def method[M[_]: Applicative] = {
case (a, b) => (ca[M](a) |@| cb[M](b)) {
case t @ (ra, rb) =>
if (ra.result && rb.result) t.right
else t.left
}
}
aggiunge complessità al programma, o sono solo io che non sono abituato a questo modo di programmazione?