Scala for Backend Engineering & Functional Programming · Lezione

Funzioni di ordine superiore e currying

Esplori concetti funzionali avanzati, come funzioni di ordine superiore e currying, per creare codice flessibile e riutilizzabile.

Funzioni di ordine superiore e currying è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 3. 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 3 lezioni in totale.

Sbloccare le funzioni di ordine superiore

Benvenuto alla Lezione 2! Nella programmazione funzionale, le funzioni sono potenti. Non servono solo a calcolare valori: possono anche essere trattate come qualsiasi altro dato.

Questo significa che le funzioni possono essere passate come argomenti ad altre funzioni o persino restituite come risultati. Quando una funzione fa questo, viene chiamata funzione di ordine superiore (HOF).

Le HOF accettano una o più funzioni come argomenti.
Le HOF restituiscono una funzione come risultato.
Oppure entrambe le cose!

HOF in azione: `map`

Una delle HOF più comuni in Scala è map. Trasforma ogni elemento di una collezione applicandovi una determinata funzione e restituisce una nuova collezione.

Provi a eseguire questo semplice esempio:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val doubledNumbers = numbers.map(x => x * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubledNumbers")
  }
}

HOF in azione: `filter`

Un'altra HOF utile è filter. Seleziona da una collezione gli elementi che soddisfano una determinata condizione (una funzione che restituisce un valore booleano), creando una nuova collezione.

Ecco come può usare filter per trovare i numeri pari:

object Main {
  def main(args: Array[String]): Unit = {
    val allNumbers = List(1, 2, 3, 4, 5, 6)
    val evenNumbers = allNumbers.filter(x => x % 2 == 0)
    println(s"All: $allNumbers")
    println(s"Even: $evenNumbers")
  }
}

Definire una propria HOF

Non è limitato alle HOF integrate! Può definire funzioni proprie che accettano altre funzioni come parametri. La sintassi per un tipo funzione è (InputType => ReturnType).

Questo esempio definisce una funzione applyOperation che accetta un Int e un'altra funzione op (che accetta un Int e restituisce un Int).

object Main {
  // A HOF that applies an operation to a number
  def applyOperation(x: Int, op: Int => Int): Int = {
    op(x)
  }

  def main(args: Array[String]): Unit = {
    val result = applyOperation(10, _ * 3) // Pass an anonymous function
    println(s"Result of 10 * 3: $result")

    val anotherResult = applyOperation(7, _ + 5)
    println(s"Result of 7 + 5: $anotherResult")
  }
}

Funzioni anonime e sintassi abbreviata

Quando passa funzioni alle HOF, usa spesso le funzioni anonime (chiamate anche lambda). Scala offre modi concisi per scriverle.

x => x * 2: funzione anonima completa.
_ * 2: sintassi abbreviata per una funzione anonima con un solo parametro.

Entrambe sono comuni e rendono il codice più breve e leggibile.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)

    // Using full anonymous function syntax
    val dividedByTwo = numbers.map(x => x / 2)
    println(s"Divided by two: $dividedByTwo")

    // Using shorthand `_` syntax
    val plusOne = numbers.map(_ + 1)
    println(s"Plus one: $plusOne")
  }
}

Introduzione al currying

Il currying è una tecnica che trasforma una funzione che accetta più argomenti in una sequenza di funzioni, ciascuna delle quali accetta un singolo argomento.

Il nome deriva dal logico Haskell Curry. In Scala, le funzioni con più liste di parametri vengono trasformate automaticamente tramite currying.

Invece di f(arg1, arg2), si scrive f(arg1)(arg2).

Esempio di currying: liste di parametri multiple

Vediamo il currying in azione. Noti come add accetti i propri argomenti in due liste di parametri separate.

Questo consente di applicare parzialmente la funzione, creando nuove funzioni fissando alcuni argomenti.

object Main {
  // A curried function with two parameter lists
  def add(a: Int)(b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    // Call the function normally
    println(s"5 + 3 = ${add(5)(3)}")

    // Partially apply the first argument
    val addFive = add(5)_ // `_` tells Scala to treat it as a partially applied function
    println(s"5 + 10 = ${addFive(10)}")
    println(s"5 + 20 = ${addFive(20)}")
  }
}

Vantaggi del currying

Perché usare il currying? Offre diversi vantaggi nella programmazione funzionale:

Applicazione parziale: crea versioni specializzate di una funzione fissando alcuni argomenti. Questo migliora il riutilizzo del codice.
Composizione di funzioni: le funzioni sottoposte a currying sono spesso più facili da comporre con altre funzioni.
Inferenza dei tipi: a volte può aiutare l'inferenza dei tipi di Scala, soprattutto quando si lavora con tipi generici complessi.

Currying per logger personalizzati

Immagini di voler creare diverse funzioni di logging per diversi livelli (ad esempio INFO ed ERROR), usando però la stessa logica di base. Il currying è perfetto per questo!

Può definire una funzione generale log e poi applicarla parzialmente per creare logger specifici.

object Main {
  def log(level: String)(message: String): Unit = {
    println(s"[$level] $message")
  }

  def main(args: Array[String]): Unit = {
    // Create specialized loggers using partial application
    val infoLogger = log("INFO")_
    val errorLogger = log("ERROR")_

    infoLogger("User logged in successfully.")
    errorLogger("Failed to connect to database!")
  }
}

Verifica rapida: HOF e currying

Consideri il seguente frammento di codice Scala:

def calculate(x: Int)(y: Int, op: (Int, Int) => Int): Int = {
  op(x, y)
}

val add = (a: Int, b: Int) => a + b
val multiply = (a: Int, b: Int) => a * b

val result1 = calculate(10)(5, add)
val result2 = calculate(2)(3, multiply)

Quali sono i valori di result1 e result2?

Riepilogo: HOF e currying

Ottimo lavoro! Ha esplorato due concetti potenti della programmazione funzionale:

Funzioni di ordine superiore (HOF): funzioni che possono accettare altre funzioni come argomenti o restituirle come risultati. Consentono di scrivere codice flessibile e riutilizzabile, come map e filter.
Currying: una tecnica per trasformare una funzione con più argomenti in una sequenza di funzioni, ciascuna delle quali accetta un singolo argomento. È ottima per l'applicazione parziale e la creazione di funzioni specializzate.

Questi concetti sono fondamentali per scrivere codice Scala espressivo e modulare!

Domande Frequenti

La lezione «Funzioni di ordine superiore e currying» è gratuita?

Sì — il testo completo di «Funzioni di ordine superiore e currying» è 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 3 lezioni in totale.

Cosa imparerò in «Funzioni di ordine superiore e currying»?

Esplori concetti funzionali avanzati, come funzioni di ordine superiore e currying, per creare codice flessibile e riutilizzabile. 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 2 di 3.

Quanto tempo richiede la lezione «Funzioni di ordine superiore e currying»?

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