ABONAMENTE VIDEO REDACȚIA
RO
EN
NOU
Numărul 143
Numărul 142 Numărul 141 Numărul 140 Numărul 139 Numărul 138 Numărul 137 Numărul 136 Numărul 135 Numărul 134 Numărul 133 Numărul 132 Numărul 131 Numărul 130 Numărul 129 Numărul 128 Numărul 127 Numărul 126 Numărul 125 Numărul 124 Numărul 123 Numărul 122 Numărul 121 Numărul 120 Numărul 119 Numărul 118 Numărul 117 Numărul 116 Numărul 115 Numărul 114 Numărul 113 Numărul 112 Numărul 111 Numărul 110 Numărul 109 Numărul 108 Numărul 107 Numărul 106 Numărul 105 Numărul 104 Numărul 103 Numărul 102 Numărul 101 Numărul 100 Numărul 99 Numărul 98 Numărul 97 Numărul 96 Numărul 95 Numărul 94 Numărul 93 Numărul 92 Numărul 91 Numărul 90 Numărul 89 Numărul 88 Numărul 87 Numărul 86 Numărul 85 Numărul 84 Numărul 83 Numărul 82 Numărul 81 Numărul 80 Numărul 79 Numărul 78 Numărul 77 Numărul 76 Numărul 75 Numărul 74 Numărul 73 Numărul 72 Numărul 71 Numărul 70 Numărul 69 Numărul 68 Numărul 67 Numărul 66 Numărul 65 Numărul 64 Numărul 63 Numărul 62 Numărul 61 Numărul 60 Numărul 59 Numărul 58 Numărul 57 Numărul 56 Numărul 55 Numărul 54 Numărul 53 Numărul 52 Numărul 51 Numărul 50 Numărul 49 Numărul 48 Numărul 47 Numărul 46 Numărul 45 Numărul 44 Numărul 43 Numărul 42 Numărul 41 Numărul 40 Numărul 39 Numărul 38 Numărul 37 Numărul 36 Numărul 35 Numărul 34 Numărul 33 Numărul 32 Numărul 31 Numărul 30 Numărul 29 Numărul 28 Numărul 27 Numărul 26 Numărul 25 Numărul 24 Numărul 23 Numărul 22 Numărul 21 Numărul 20 Numărul 19 Numărul 18 Numărul 17 Numărul 16 Numărul 15 Numărul 14 Numărul 13 Numărul 12 Numărul 11 Numărul 10 Numărul 9 Numărul 8 Numărul 7 Numărul 6 Numărul 5 Numărul 4 Numărul 3 Numărul 2 Numărul 1
×
▼ LISTĂ EDIȚII ▼
Numărul 127
Abonament PDF

Scala și programarea funcțională – High Order Functions

Andrei Muja
Scala Engineer @ Zenitech



PROGRAMARE


Î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.

Ce este programarea funcțională?

Î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.

Collection Methods și High Order Functions (HOF)

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.

Metode importante aplicate colecțiilor

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).

Map

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:

FlatMap

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ă:

Filter

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:

Reduce

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 = 1629210704

Diagrama internă este următoarea:

Fold

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ă:

ScanLeft / ScanRight

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

Zip

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.

Collect

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:

Cuvânt de final

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):

  1. Baeldung -> o mulțime de tutoriale despre Java, Spring Framework, Spring Security, dar și Scala.

  2. RockTheJvm -> canal Youtube cu o multitudine de Scala tips and tricks - creatorul de conținut este român.

  3. https://superruzafa.github.io/visual-scala-reference// -> aici puteți găsi mai multe metode ale colecțiilor Scala care nu au fost menționate în articol, informații suplimentare plus diagramele tehnice pentru fiecare.

Pe data viitoare!

LANSAREA NUMĂRULUI 143

Railroads

miercuri, 29 mai, ora 18:00

Târgu-Mureș, Studium Hub

Facebook Meetup StreamEvent YouTube

Conferință

NUMĂRUL 142 - Robotics & AI

Sponsori

  • Accenture
  • BT Code Crafters
  • Accesa
  • Bosch
  • Betfair
  • MHP
  • BoatyardX
  • .msg systems
  • Yardi
  • P3 group
  • Ing Hubs
  • Colors in projects

INTERVIURI VIDEO