TypeScript Academy · Lezione

Utility pipe e flow tipizzate

Costruisca pipeline da sinistra a destra con un’inferenza accurata.

Lezione 4 di 413 passaggi

Utility pipe e flow tipizzate è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Da compose a pipe

pipe fa passare un valore attraverso le funzioni da sinistra a destra, seguendo l'ordine di lettura preferito dalla maggior parte delle persone. pipe(x, f, g) significa g(f(x)).

Una pipe in due passaggi

La forma più semplice di pipe accetta un valore e una funzione e restituisce il risultato. Leggere dall'alto verso il basso corrisponde all'ordine di esecuzione.

const pipe2 = <A, B>(a: A, f: (a: A) => B): B => f(a);
console.log(pipe2(5, n => n + 1)); // 6

Passare attraverso più funzioni

Una pipe a tre argomenti applica le funzioni in sequenza. L'output di ogni passaggio diventa l'input del passaggio successivo.

function pipe<A, B, C>(a: A, f: (a: A) => B, g: (b: B) => C): C {
  return g(f(a));
}
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(pipe(5, inc, dbl)); // 12

Lettura da sinistra a destra

A differenza di compose, pipe elenca i passaggi nell'ordine in cui vengono eseguiti. pipe(5, inc, dbl) incrementa e poi raddoppia, esattamente nell'ordine scritto.

console.log(pipe(5, dbl, inc)); // 11 (double then inc)

Perché servono gli overload

I diversi punti di chiamata passano numeri diversi di funzioni. Per tipizzare con precisione ogni arità, pipe usa firme di overload, una per ogni lunghezza supportata.

function pipe<A, B>(a: A, f: (a: A) => B): B;
function pipe<A, B, C>(a: A, f: (a: A) => B, g: (b: B) => C): C;
function pipe(a: unknown, ...fns: Function[]): unknown {
  return fns.reduce((v, fn) => fn(v), a);
}

Ogni overload concatena i tipi

L'overload per due funzioni concatena A -> B; quello per tre funzioni concatena A -> B -> C. Il compilatore sceglie l'overload corrispondente in base al numero di funzioni passate.

L'implementazione a runtime

Alla base degli overload, una singola reduce applica ogni funzione a turno. La firma dell'implementazione usa tipi meno restrittivi, mentre chi effettua la chiamata vede gli overload precisi.

function pipe(a: any, ...fns: Array<(x: any) => any>): any {
  return fns.reduce((acc, fn) => fn(acc), a);
}
console.log(pipe("  hi ", s => s.trim(), s => s.toUpperCase())); // HI

Cambiamenti di tipo lungo la pipe

Poiché ogni overload concatena i tipi generici, una pipe può trasformare un valore attraverso diversi tipi mantenendo il controllo completo dei tipi.

const out = pipe("hello", s => s.length, n => n > 3);
console.log(out); // true (string -> number -> boolean)

flow: pipe senza il valore

flow è simile a pipe, ma accetta solo le funzioni e restituisce una nuova funzione. Il valore viene fornito in seguito, il che lo rende ideale per il riutilizzo.

const flow = <A, B, C>(f: (a: A) => B, g: (b: B) => C) =>
  (a: A): C => g(f(a));
const process = flow((n: number) => n + 1, (n: number) => n * 2);
console.log(process(5)); // 12

pipe, flow e compose

pipe applica le funzioni a un valore da sinistra a destra; flow crea una funzione riutilizzabile da sinistra a destra; compose crea una funzione da destra a sinistra. La scelta dipende dall'ordine di lettura e dalla necessità di riutilizzo.

Pipeline pratiche

Librerie come fp-ts ed Effect forniscono una pipe robusta e completamente tipizzata, con numerosi overload. Costruirne una versione semplice mostra esattamente come funziona la tipizzazione.

Verifica rapida

Una breve verifica su questa lezione.

Rispondi nella lezione interattiva

Riepilogo

pipe(x, f, g) = g(f(x)) viene eseguito da sinistra a destra e usa le firme di overload per tipizzare con precisione ogni arità, con una singola implementazione basata su reduce. flow è la variante point-free che restituisce una funzione riutilizzabile.

Gratis per iniziare

Impara TypeScript con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 101
Lezioni: 352

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Utility pipe e flow tipizzate» è gratuita?

Sì — il testo completo di «Utility pipe e flow tipizzate» è 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 «Utility pipe e flow tipizzate»?

Costruisca pipeline da sinistra a destra con un’inferenza accurata. 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 4 di 4.

Quanto tempo richiede la lezione «Utility pipe e flow tipizzate»?

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