TypeScript Academy · Lección

Composición de funciones con tipos

Componga funciones conservando la seguridad de tipos.

Composición de funciones con tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué es la composición?

La composición de funciones combina funciones pequeñas para formar una más grande. compose(f, g) produce una función que aplica primero g y después pasa el resultado a f.

La definición fundamental

Matemáticamente, compose(f, g)(x) = f(g(x)). Las funciones se ejecutan de derecha a izquierda: la que está más a la derecha se ejecuta primero.

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)

Orden de derecha a izquierda

El orden es importante. compose(inc, dbl) duplica primero y después incrementa, mientras que compose(dbl, inc) incrementa primero. Lea la composición desde dentro hacia fuera.

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

Tipar la composición con genéricos

Los genéricos permiten que los tipos de entrada y salida sean diferentes. g transforma A en B, f transforma B en C y el resultado transforma A en C.

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

Cambiar los tipos durante el proceso

Como los genéricos forman la cadena A -> B -> C, la composición puede transformar un valor entre varias formas, por ejemplo, de cadena a número y después de nuevo a cadena.

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

Los tipos en los límites deben coincidir

La salida de g debe coincidir con la entrada de f. Si no coinciden, el compilador rechaza la composición y detecta pronto los errores de conexión.

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

Componer tres funciones

Puede anidar composiciones o escribir una versión de tres argumentos. La regla de derecha a izquierda sigue aplicándose en todos los casos.

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 composición crea canalizaciones

Al componer funciones pequeñas y puras, puede ensamblar transformaciones complejas de forma declarativa. Cada pieza sigue siendo comprobable de manera aislada.

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

Por qué las funciones puras se componen mejor

La composición supone que cada función depende únicamente de su entrada. Las funciones puras garantizan esto, por lo que al componerlas se obtiene otra función pura y predecible.

compose frente a pipe

compose se ejecuta de derecha a izquierda y refleja la notación matemática. Muchas personas prefieren leer de izquierda a derecha, que es lo que ofrece pipe, como verá a continuación.

Mantener las piezas pequeñas

La composición resulta especialmente útil cuando cada función hace una sola tarea pequeña. Los pasos pequeños, con nombre y puros, hacen que la canalización compuesta se explique por sí misma y sea fácil de reorganizar.

Comprobación rápida

Comprobación rápida de esta lección.

Resumen

compose(f, g)(x) = f(g(x)) se ejecuta de derecha a izquierda. Los tipos genéricos forman la cadena A -> B -> C, por lo que la salida de g debe coincidir con la entrada de f. Así, el compilador puede verificar la canalización de funciones pequeñas y puras.

Preguntas frecuentes

¿La lección «Composición de funciones con tipos» es gratis?

Sí — el texto completo de «Composición de funciones con tipos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Composición de funciones con tipos»?

Componga funciones conservando la seguridad de tipos. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Composición de funciones con tipos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a TypeScript Academy