În acest articol vom continua să explorăm universul programării funcționale utilizând limbajul de programare Scala. Acesta este cel de-al doilea articol despre Scala dintr-o serie de trei. În cele ce urmează, o să prezint cel mai des folosite metode pe colecții de date immutable care oferă o eleganță aparte acestui limbaj. Primul, pe care vă sugerez să-l parcurgeți înainte (ScalaFP) descrie particularitățile, avantajele și dezavantajele programării funcționale folosind Scala. Ultimul articol va consta în rezolvarea unor probleme de algoritmică în format 100% pur funcțional. La finalul acestei serii, am deplină siguranță că veți deține un nou bagaj de cunoștințe care ar putea să vă creeze un mindset diferit în abordarea problemelor.
Multe din particularitățile arătate pot fi întâlnite și în alte limbaje, prin urmare oricine cu noțiuni de bază în programare și/sau experiență cu alte tehnologii poate urmări cu ușurință conținutul. Dacă, totuși, printre cititori se vor afla persoane fără cunoștințe tehnice sau fără tangențe cu Java/Scala, intrați mai întâi pe acest articol, scris în engleză: Scala Introduction, un precursor al celor din revistă, apoi reveniți.
Notă: voi folosi Scala 2.13, însă bucățile de cod sunt compatibile și cu Scala 3.
În paradigma funcțională, funcțiile sunt piatra de temelie în implementarea programelor. Am dori, și ar fi ideal, însă imposibil mereu, să avem de-a face doar cu funcții pure și imutabilitate. Putem folosi și în programarea orientată pe obiecte, funcții care iau sau returnează alte funcții și metode care sunt definite în interiorul altora. Dar, în cea funcțională, le întâlnim la orice pas, oferind o naturalețe aparte și reducând drastic numărul liniilor de cod.
Reamintim că HOF sunt metode sau funcții care preiau una sau mai multe funcții ca parametri și returnează o singură funcție ca rezultat. Structurile de date implementate în Scala (List, Set, HashMap, Tree) sunt de două feluri: immutable și mutable. Se află în package-ul scala.collection.immutable sau scala.collection.mutable. În mod implicit, cele immutable vor fi alese pentru a scrie cod, iar dacă vrei să modifici o colecție ca parte a unui side effect, trebuie să specifici atunci când imporți o structură că vrei să facă parte din cele mutable. Asupra acestor colecții, există nenumărate metode care permit scrierea de cod fără a fi nevoie să utilizezi iterații - for loops. Toate sunt High Order Functions, pot accepta și funcții anonime ca parametri.
După ce am străbătut conținutul anterior, voi prezenta unele dintre cele mai des utilizate metode. Așa cum am spus, ele sunt HOFs, creând un cod ușor de menținut și optim din punct de vedere al firelor de execuție (thread-safe).
Creează o nouă colecție aplicând o funcție de transformare asupra fiecărui element al colecției inițiale. Are următoarea formă:
trait Collection[A]{
def map[B](f:A => B): Collection[B]
}O colecție cu elemente tip A va fi transformată de funcția "f" într-o colecție de tip B:
Pentru toți fanii fotbalului, mai jos aveți un exemplu strict didactic de folosire a metodei map. Fiecare echipă din Premier League are prefixul "Big Four", să ne aducem aminte de vremurile când acestea dominau fotbalul englez, dar și competițiile europene.
object Practice {
val listOfTeams = Seq("Man United", "Arsenal",
"Liverpool", "Chelsea")
val bigFour: Seq[String] =
listOfTeams.map(team => "Big four club: " + team)
def main(args: Array[String]): Unit = {
println(bigFour)
}
}Rezultatul:
Aplică o funcție "f" asupra fiecărui element, iar toate sub elementele formate sunt flattened sau aplatizate într-o singură colecție, rezultatul nostru dorit. Poate fi definit ca trait:
trait FlatMapCollection[A]{
def flatMap[B](f: A=> FlatMapCollection[B])
: FlatMapCollection[B]
}Presupunem că avem o secvență de numere și avem de creat o listă de numere conținând fiecare element urmat de dublul acestuia. Folosim flatMap, care este de preferat, sau map împreună cu flatten.
object Practice {
val result: Seq[Int] = Seq(0, 1, 2, 3).flatMap
{ number => Seq(number, 2 * number) }
val resultMap: Seq[Seq[Int]] = Seq(0, 1, 2, 3)
.map { number => Seq(number, 2 * number) }
val result2: Seq[Int] = resultMap.flatten
val result3: Seq[Int] = Seq(0, 1, 2, 3)
.map { number => Seq(number, 2 * number) }.flatten
def main(args: Array[String]): Unit = {
println(result)
println(resultMap)
println(result3)
}
}Când vom rula într-un IDE, vom da peste un mesaj de avertizare, un mic warning. Dacă am fi printat valoarea înainte de "aplatizare", programul ar fi returnat o listă de perechi (vezi result3).
Ce se întâmplă intern poate fi analizat în următoarea diagramă:
Construiește o colecție de date având doar elementele care satisfac o condiție (predicate), iar celelalte sunt eliminate.
trait Filter[A]{
def filter(predicate: A => Boolean):Filter[A]
}Pentru a demonstra puterea acestei metode, avem o secvență cu numele unor colegi. Hai să micșorăm lista, păstrând doar pe cei ai căror nume conține litera "r" or "R". Exemplu:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad",
"Ionelia", "Robert", "Ryad", "Razvan", "Marius",
"Alina", "Nora", "Radu", "Tudor")
val filteredR: Seq[String] = colleagues
.filter(name => name.contains("r") ||
name.contains("R"))
def main(args: Array[String]): Unit = {
println(filteredR)
}
}
//Output: List(Andrei, Robert, Ryad, Razvan, Marius, Nora, Radu, Tudor)Diagrama de mai jos arată cum funcționează metoda intern:
Aplică un operator binar asupra unor perechi de elemente (tuple) succesiv până la rezultatul dorit. Există și câteva derivate: reduceLeft, reduceLeftOption, reduceOption, reduceRight, reduceRightOption. Pentru colecții goale, funcția "operator" aruncă UnsupportedOperationException exception.
trait ReduceCollection[A]{
def reduce(operator: (A, A)=> A): A
}Revenind la exemplul de dinainte, să presupunem că vrem, tot în scop didactic, să aflăm cel mai lung nume din lista de colegi. Folosim reduce sau reduceLeft. Apoi, aș vrea să primesc produsul scorurilor jocului:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad", "Ionelia", "Robert", "Ryad", "Razvan", "Marius", "Alina", "Nora", "Radu", "Tudor")
val longestName: String = colleagues
.reduceLeft((x, y) => if(x.length > y.length)
x else y)
val scores = Seq(100, 97, 90, 87, 78)
val product = scores.reduce(_ * _)
// inlocuieste wildcard-urile cu scores.product, pt
// eliminarea warning-ului
def main(args: Array[String]): Unit = {
println(longestName)
println(product)
}
}
//Output: longestName = Ionelia, product = 1629210704Diagrama internă este următoarea:
Aplică tot un operator binar asupra elementelor unei colecții, dar are o valoare inițială, "seed", care poate fi reutilizată. Foarte apropiată de reduce ca funcționalitate. Alte forme: foldLeft, foldRight.
trait FoldedCollection[A]{
def fold(seed: A)(operator: (A, A)=>A):A
}Ca parte a demonstrației, să considerăm că vreau să aflu suma lungimilor numelor colegilor mei. După, vreau concatenarea numelor, dar de la dreapta la stânga. Aplicăm foldLeft pentru prima operație, foldRight pentru a doua. Țineți minte că valoarea inițială determină tipul rezultatului, în primul caz Integer, în al doilea String:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad", "Ionelia", "Robert", "Ryad", "Razvan", "Marius", "Alina", "Nora", "Radu", "Tudor")
val sumLengthOfStrings: Int =
colleagues.foldLeft(0)((acc, currElem) =>
acc + currElem.length)
val concatenate: String = colleagues.foldRight("")
((elem, acc) => acc + elem)
def main(args: Array[String]): Unit = {
println(sumLengthOfStrings)
println(concatenate)
}
}Structura internă:
Creează o colecție din rezultatele intermediare prin aplicarea unui operator binar "op" pe fiecare element, de la dreapta la stânga sau invers. Inițial, valoarea "seed" este introdusă în operator.
trait ScanLeft[A]{
def scanLeft[B](seed: B)
(operator: (B,A)=>B):ScanLeft[B]
}
trait ScanRight[A]{
def scanRight[B](seed: B)
(operator: (A,B)=>B):ScanRight[B]
}Revenind la lista de colegi, vrem să observăm o concatenare în sens invers, de la lista cu toate valorile la cea cu un singur element folosind scanRight, precum și suma scorurilor, tot succesiv, la fiecare iterație, cu scanLeft.
Notă: Am făcut drop la ultimul element, o virgulă, folosind *dropRight(n)*, o altă metodă Scala, adică șterge ultimele n elemente, aici fiind vorba doar de unul singur. Rezultatele finale sunt:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad",
"Ionelia", "Robert", "Ryad", "Razvan", "Marius",
"Alina", "Nora", "Radu", "Tudor")
val sumLengthOfStringsScan: Seq[Int] = colleagues
.scanLeft(0)((acc, currElem) => acc +
currElem.length)
val concatenateScanRight: Seq[String] = colleagues
.scanRight("")((elem, acc) => acc + elem)
.dropRight(1)
def main(args: Array[String]): Unit = {
println(sumLengthOfStringsScan)
println(concatenateScanRight)
}
}
Dacă sunteți interesați ce se întâmplă în spatele scenei, aveți diagramele pentru fiecare metodă:
scanLeft și scanRight
Formează o nouă colecție prin alăturarea fiecărui element dintr-o colecție cu unul din a doua colecție care are același index, pe aceeași poziție, eliminând elementele care nu pot forma pereche. Mai există o structură, *zipWithIndex, care face perechi între fiecare element și propriul index. De asemenea, zipAll, care împerechează toate elementele din cele două colecții și dacă una este mai scurtă, adaugă valori cu rol de placeholder*, pentru a avea aceeași lungime ca cealaltă.
trait ZipCollection[A]{
def zip[B[(bs: ZipCollection[B]):
ZipCollection[(A, b)]
}Revenind la colegii dragi, cum ar fi să creăm un tuplu "coleg-scor" la un joc? Foarte simplu. Apelăm zip. Iată cum:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad",
"Ionelia", "Robert", "Ryad", "Razvan", "Marius",
"Alina", "Nora", "Radu", "Tudor")
val scores = List(80, 97, 23, 45, 77, 21, 71, 90,
103, 27)
val zipped: Seq[(String, Int)] = colleagues
.zip(scores)
def main(args: Array[String]): Unit = {
println(zipped)
}
}
// Output
// List((Andrei,80), (Stefan,97), (Vlad,23),
// (Ionelia,45), (Robert,77), //(Ryad,21),
// (Razvan,71), (Marius,90), (Alina,103), (Nora,27))După cum vedeți, toți colegii al căror index nu are un corespondent cu cel din lista de scoruri este ignorat.
Construiește o colecție de elemente ca rezultat al aplicării funcției parțiale "f" asupra lor și eliminarea celor care nu corespund funcției.
trait Collect[A]{
def collect[B](f: PartialFunction[A, B]): Collect[B]
}Acum vreau să am o listă doar cu numele colegilor care au numărul de litere par. Folosim collect și verificăm rezultatul. Dacă niciun nume nu are un număr par de litere, returnează-mi o listă goală:
object Practice {
val colleagues = List("Andrei", "Stefan", "Vlad",
"Ionelia", "Robert", "Ryad", "Razvan", "Marius",
"Alina", "Nora", "Radu", "Tudor")
val collected: List[String] = colleagues
.collect({ case name if name.length % 2 == 0
=> name }) match {
case names => names
case Nil => List.empty
}
def main(args: Array[String]): Unit = {
println(collected)
}
}
// Output: List(Andrei, Stefan, Vlad, Robert, Ryad,
// Razvan, Marius, Nora, Radu)Și diagrama:
Am mai adăugat ceva la cunoștințele noastre! Ne oprim aici. Mai avem de văzut și cum le putem îmbina în exerciții practice pentru a rezolva probleme logice sau matematice, dar asta în ultimul articol. Până atunci, continuați să exersați conceptele Scala și recapitulați cunoștințele dobândite până acum: https://www.scala-exercises.org/, folosind contul de Github.
Alte resurse pe care le puteți străbate ar fi (le-am menționat și data trecută, dar e bine să vă reamintesc):
Baeldung -> o mulțime de tutoriale despre Java, Spring Framework, Spring Security, dar și Scala.
RockTheJvm -> canal Youtube cu o multitudine de Scala tips and tricks - creatorul de conținut este român.
Pe data viitoare!