TypeScript Academy · Lezione

Composizione di funzioni con i tipi

Componga funzioni mantenendo la type safety.

Composizione di funzioni con i tipi è una lezione TypeScript Academy 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 TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Che cos'è la composizione?

La composizione di funzioni combina funzioni semplici in una funzione più grande. compose(f, g) produce una funzione che applica prima g, quindi passa il risultato a f.

Definizione fondamentale

Matematicamente, compose(f, g)(x) = f(g(x)). Le funzioni vengono eseguite da destra a sinistra: la funzione più a destra viene eseguita per prima.

const compose = (f: (n: number) => number, g: (n: number) => number) =>
  (x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)

Ordine da destra a sinistra

L'ordine è importante. compose(inc, dbl) raddoppia prima e poi incrementa, mentre compose(dbl, inc) incrementa prima. La composizione si legge dall'interno verso l'esterno.

console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)

Tipizzare la composizione con i tipi generici

I tipi generici permettono di avere tipi di input e output diversi. g mappa A in B, f mappa B in C e il risultato mappa A in C.

function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
  return a => f(g(a));
}

Cambiare tipo lungo il percorso

Poiché i tipi generici formano la catena A -> B -> C, la composizione può trasformare un valore attraverso diverse forme, ad esempio da stringa a numero e poi di nuovo a stringa.

const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5

I tipi ai confini devono corrispondere

L'output di g deve corrispondere all'input di f. Se non corrispondono, il compilatore rifiuta la composizione e rileva subito gli errori di collegamento.

// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.

Comporre tre funzioni

È possibile annidare le composizioni oppure scrivere una versione con tre argomenti. La regola da destra a sinistra continua ad applicarsi in entrambi i casi.

const compose3 = <A, B, C, D>(
  f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8

La composizione crea pipeline

Componendo piccole funzioni pure, si assemblano trasformazioni complesse in modo dichiarativo. Ogni elemento rimane testabile in isolamento.

const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean("  hi ")); // HI

Perché le funzioni pure si compongono meglio

La composizione presuppone che ogni funzione dipenda solo dal proprio input. Le funzioni pure lo garantiscono, quindi comporle produce un'altra funzione pura e prevedibile.

compose e pipe

compose viene eseguito da destra a sinistra e rispecchia la notazione matematica. Molti preferiscono leggere da sinistra a destra, ed è proprio ciò che offre pipe, come vedremo nella prossima lezione.

Mantenere piccoli gli elementi

La composizione dà il meglio di sé quando ogni funzione svolge un'unica operazione semplice. Passaggi piccoli, denominati e puri rendono la pipeline composta autoesplicativa e facile da riorganizzare.

Verifica rapida

Una breve verifica su questa lezione.

Riepilogo

compose(f, g)(x) = f(g(x)) viene eseguito da destra a sinistra. La tipizzazione generica forma la catena A -> B -> C, quindi l'output di g deve corrispondere all'input di f; in questo modo il compilatore può verificare la pipeline di piccole funzioni pure.

Domande Frequenti

La lezione «Composizione di funzioni con i tipi» è gratuita?

Sì — il testo completo di «Composizione di funzioni con i tipi» è 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 TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Composizione di funzioni con i tipi»?

Componga funzioni mantenendo la type safety. Eserciti TypeScript Academy 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 TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy 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 di funzioni con i tipi»?

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 TypeScript Academy?

Sì. Ogni lezione TypeScript Academy 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 TypeScript Academy