Scala for Backend Engineering & Functional Programming · Lezione

Composizione

andThen e compose

Composizione è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Combinare le funzioni

La composizione di funzioni consiste nel creare una nuova funzione collegandone due esistenti, in modo che l'output di una diventi l'input della successiva. Scala mette a disposizione andThen e compose per questo scopo.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: da sinistra a destra

f andThen g esegue prima f e poi g. La lettura da sinistra a destra corrisponde all'ordine di esecuzione, che molti trovano intuitivo.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: da destra a sinistra

f compose g esegue prima g e poi f, secondo l'ordine matematico f(g(x)).

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen e compose

Le due operazioni sono immagini speculari:

f andThen g = g compose f
f compose g = g andThen f

Scelga quella che si legge in modo più naturale nella situazione specifica.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

concatenare più funzioni

È possibile concatenare molte funzioni usando più volte andThen, per creare una pipeline più lunga che scorre dall'alto verso il basso.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

La composizione modifica i tipi

Le funzioni composte devono avere tipi compatibili: il tipo di output della prima deve corrispondere al tipo di input della seconda. La pipeline può modificare i tipi durante il percorso.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

La funzione identità

identity restituisce il proprio input senza modificarlo. È l'elemento neutro della composizione: f andThen identity == f. Utile come valore predefinito nei fold e nelle condizioni.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

Composizione con reduce

Poiché le funzioni sono valori, è possibile memorizzarne diverse in una lista e comporle tutte usando reduce con andThen.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Creazione di pipeline riutilizzabili

La composizione favorisce funzioni piccole e con un unico scopo, che si assemblano per creare comportamenti più complessi: un'idea fondamentale della programmazione funzionale.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

Composizione con map

Una funzione composta è semplicemente una funzione, quindi è possibile passarla direttamente a map per applicare l'intera pipeline a una collezione.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Leggere attentamente l'ordine della composizione

Un errore comune consiste nel confondere andThen e compose. Ricordi sempre: andThen = prima questa, poi quella; compose = l'ordine inverso.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Verifica rapida

Dati f e g, che cosa calcola (f andThen g)(x)?

Riepilogo

Ha imparato la composizione di funzioni:

f andThen g → g(f(x)) (da sinistra a destra)
f compose g → f(g(x)) (da destra a sinistra)
Sono l'una l'immagine speculare dell'altra
identity è l'elemento neutro
È possibile comporre liste di funzioni con reduce(_ andThen _)

Domande Frequenti

La lezione «Composizione» è gratuita?

Sì — il testo completo di «Composizione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Composizione»?

andThen e compose Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Composizione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming