Saltar a contenido

Clase 3. Funciones de alto orden

Jueves 24 de septiembre de 2026.

Tres funciones que suman de 1 a n —los enteros, sus cuadrados, sus cubos— se escriben igual salvo por una línea. La sesión convierte esa línea en un parámetro, y después repite la operación con lo que queda: cómo se avanza al siguiente término y cómo se combinan los resultados. Al final la función recibe tres funciones y devuelve otra.

Las diapositivas están en el Campus Virtual. Aquí quedan las notas de lo que se dijo en el salón y el código que se escribió en vivo, en codigo/. Los doce ejercicios interactivos de la sesión están en Ejercicios.

Referencia: Odersky, Spoon y Venners, Programming in Scala, 3.ª edición, capítulos 8 y 9; Abelson y Sussman, Structure and Interpretation of Computer Programs, sección 1.3, Formulating Abstractions with Higher-Order Procedures.

El esquema que se repite

Las tres primeras funciones se escribieron con recursión de cola y acumulador:

def sumar(n: Int): Int = {
  @tailrec
  def sumarAux(n: Int, acc: Int): Int = {
    if (n == 0) acc
    else sumarAux(n - 1, acc + n)
  }
  sumarAux(n, 0)
}

sumarCuadrado es la misma, con acc + n * n en lugar de acc + n. producto cambia dos cosas: acc * n y el arranque en 1 en vez de 0.

sumar(10)         = 55
sumarCuadrado(10) = 385
producto(10)      = 3628800

Puestas una debajo de otra, lo que se repite es todo menos un pedazo:

Término Avance Arranque
sumar n n - 1 0
sumarCuadrado n * n n - 1 0
producto n (multiplicando) n - 1 1

En el tablero quedó marcado así: el n - 1 circulado en rojo, igual en las tres, y acc + n frente a acc + n * n circulado aparte, con la palabra diferente. Sumar los cubos pediría una cuarta copia del mismo esqueleto, y cada copia es una ocasión más de equivocarse.

Funciones como parámetro

Lo que cambia es qué se le hace a cada término, y eso no es un número: es una función. Para dejarlo como hueco hay que poder pasar una función como argumento.

def sumaGenerico(n: Int, f: Int => Int): Int = {
  @tailrec
  def sumarAux(n: Int, acc: Int): Int = {
    if (n == 0) acc
    else sumarAux(n - 1, acc + f(n))
  }
  sumarAux(n, 0)
}

El cuerpo es idéntico al de sumar; lo único distinto es acc + f(n) en lugar de acc + n. Con tres funciones con nombre, las tres sumas salen de la misma definición:

def identidad(n: Int): Int = n
def cuadrado(n: Int): Int = n * n
def cubo(n: Int): Int = n * n * n
sumaGenerico(10, identidad) = 55
sumaGenerico(10, cuadrado)  = 385
sumaGenerico(10, cubo)      = 3025

Una función de alto orden recibe funciones como argumento, devuelve una función como resultado, o las dos cosas.

Leer el tipo

Int => Int se lee de izquierda a derecha: a la izquierda de la flecha, la entrada; a la derecha, la salida. La salida es un solo tipo; las entradas pueden ser varias, y entonces van entre paréntesis:

(x: Int) => x        tiene tipo  Int => Int
(x: Int) => x * x    tiene tipo  Int => Int
(x: Int, y: Int) => x + y    tiene tipo  (Int, Int) => Int

Escritas en el REPL sin nombre, Scala responde con el tipo y con una referencia al objeto función: val res0: Int => Int = $Lambda$.... El tipo es lo que interesa; la referencia solo dice que ahí hay una función.

Funciones anónimas

identidad, cuadrado y cubo se usan una sola vez cada una. Declararlas con nombre para eso es trabajo de más: el literal se pasa directo.

sumaGenerico(10, (x: Int) => x)
sumaGenerico(10, (x: Int) => x * x)
sumaGenerico(10, (x: Int) => x * x * x)

Dan lo mismo que las tres anteriores. El criterio que se dio en clase: una función que se va a reutilizar muchas veces conviene declararla con nombre; una que se usa una vez y ahí queda, no.

Un literal es un valor, igual que un 15. Y con una función hay dos cosas que se pueden hacer: evaluarla —pasarle argumentos— o componerla, que incluye mandársela a otra función.

Los otros dos huecos

Sumar los impares pide cambiar el avance, no el término. Ese es el segundo hueco, y entra como otra función:

def sumaGenericaV2(n: Int, f: Int => Int, g: Int => Int): Int = {
  @tailrec
  def aux(a: Int, b: Int, acc: Int): Int = {
    if (a > b) acc
    else aux(g(a), b, f(a) + acc)
  }
  aux(1, n, 0)
}
sumaGenericaV2(15, identidad, suc)      = 120
sumaGenericaV2(15, identidad, dosEnDos) = 64
sumaGenericaV2(15, cuadrado, dosEnDos)  = 680

El segundo es 1 + 3 + 5 + ... + 15, y el tercero los mismos impares al cuadrado. Con f y g separados, la combinación sale sin escribir una función nueva.

Falta el tercer hueco: + está escrito en el cuerpo, y la productoria necesita *. Una función que recibe dos enteros y devuelve uno, (Int, Int) => Int:

def operacionGenerica(n: Int, f: Int => Int, g: Int => Int, h: (Int, Int) => Int): Int = {
  @tailrec
  def aux(a: Int, b: Int, acc: Int): Int = {
    if (a > b) acc
    else aux(g(a), b, h(f(a), acc))
  }
  val neutro = if (h(0, 1) == 0) 1 else 0
  aux(1, n, neutro)
}

El acumulador que arranca mal

La primera corrida con h en multiplicación devolvió 0. El acumulador arrancaba en 0, que es el neutro de la suma; en un producto, cualquier cosa por cero es cero.

Poner 1 fijo tampoco sirve: arruina la suma. El valor de arranque tiene que depender de la operación, y la operación llega como parámetro, así que se le pregunta a ella misma:

val neutro = if (h(0, 1) == 0) 1 else 0

Con h en suma, h(0, 1) es 1 y el neutro queda en 0. Con h en multiplicación, h(0, 1) es 0 y el neutro queda en 1. Es una salida por tanteo —así se presentó en el salón— y funciona porque el 0 absorbe en el producto y no en la suma.

operacionGenerica(15, identidad, suc, suma) = 120
operacionGenerica(15, identidad, suc, mul)  = 2004310016

El segundo número no es 15!. Es lo que queda de \(15! = 1\,307\,674\,368\,000\) después de desbordar el Int, que llega hasta \(2^{31} - 1\). El cálculo corrió entero y el tipo no alcanzó; Long o BigInt lo sostienen.

Funciones que devuelven funciones

El otro lado del trato: el resultado también puede ser una función.

def sumador(n: Int): Int => Int = (x: Int) => x + n

sumador(10) no es un número, es la función que suma diez. Imprimirla muestra la referencia del objeto, no un entero:

FuncionesQueDevuelven$$$Lambda$2/0x00007fed3c093788@5d3411d
25

El 25 es sumador(10)(15): el primer paréntesis fabrica la función, el segundo la aplica. Hacen falta los dos para llegar a un entero.

La motivación fue un llamado que repite un argumento:

println(suma(5, 1)); println(suma(5, 11)); println(suma(5, 18))

El 5 se escribe cada vez. Con una función que devuelve función, se fija una sola vez:

def sumaR(a: Int): Int => Int = {
  (b: Int) => a + b
}

val sumaCinco = sumaR(5)
sumaCinco(1)  = 6
sumaCinco(11) = 16
sumaCinco(18) = 23

El tipo de sumaR es Int => (Int => Int): recibe un entero y devuelve una función que espera otro entero.

La derivada

El mismo patrón sobre funciones de Double. La derivada es el límite del cociente incremental cuando el paso tiende a cero; con un paso fijo y pequeño queda una función que recibe una función y devuelve otra:

def derivada(f: Double => Double): Double => Double =
  (x: Double) => (f(x + 0.001) - f(x)) / 0.001

Con cubo, la derivada exacta es \(3x^2\). Lo que sale con paso 0.001:

derivada(cubo)(1) = 3.0030009999995055
derivada(cubo)(2) = 12.0060009999996
derivada(cubo)(3) = 27.009000999996147

Cerca de 3, 12 y 27, y ninguno exacto. El paso no puede ser cero —sería una división por cero— y cualquier paso mayor deja residuo.

A eso se suma el error de truncamiento. Un Double son 64 bits: uno de signo, 11 de exponente y el resto de mantisa, que es la que fija cuántos decimales caben. Lo que no cabe se corta, y las operaciones propagan ese corte. Por eso los bancos no manejan pesos en Double: operan en centavos, con enteros, y dividen por 100 al mostrar el saldo. Un entero se representa exacto; un decimal, no siempre.

Currificación

Los argumentos se pueden entregar en grupos separados, un paréntesis por grupo:

def sumaC(a: Int)(b: Int): Int = a + b

Cada grupo que se llena deja fija esa parte y devuelve una función que espera el resto. En el REPL:

val g = sumaC(10) _
g(11) = 21
g(15) = 25

g es sumar diez. El guion bajo pide la función sin terminar de aplicar.

Una función currificada recibe un argumento y devuelve otra función con ese argumento ya fijado. El tipo se escribe anidado y la flecha asocia a la derecha, así que Int => Int => Int es Int => (Int => Int).

La operación genérica, currificada

def operacionGenerica(f: Int => Int)(g: Int => Int)(h: (Int, Int) => Int)(n: Int): Int

Su tipo completo, sin aplicar nada, es una cadena de cuatro funciones:

(Int => Int) => ((Int => Int) => (((Int, Int) => Int) => (Int => Int)))

Cuatro grupos, cuatro aplicaciones antes de llegar al entero. Y con los tres primeros llenos quedan funciones con nombre propio:

val sumatoria = operacionGenerica((x: Int) => x)((y: Int) => y + 1)((a: Int, b: Int) => a + b) _
val sumatoriaImpares = operacionGenerica((x: Int) => x)((y: Int) => y + 2)((a: Int, b: Int) => a + b) _
sumatoria(15)        = 120
sumatoria(10)        = 55
sumatoriaImpares(15) = 64
sumatoriaImpares(10) = 25

Para eso sirve currificar: de una función genérica se sacan funciones específicas, fijando de a un grupo, sin escribir cada una desde cero.

Lo que queda

Los doce ejercicios de Ejercicios siguen los temas de la sesión en este mismo orden. En clase se recorrieron varios: el que arma el par f / prox para tres sumas escritas en matemáticas, la tabla de traza que se llena antes de correr, la reducción paso a paso y la que pide encontrar el paso equivocado en una traza escrita.

El ejercicio de la sesión se resuelve con ./gradlew test, que corre Scalastyle y después las pruebas. Al hacer push, las actions del fork repiten lo mismo y dejan el informe de pruebas como artefacto descargable: se baja, se descomprime y se abre index.html, que es el mismo reporte que queda en app/build/reports/tests/test/ al correrlo en el equipo.

Lo que sigue: listas, y sobre ellas map, filter y reduce. Encadenadas resuelven en una línea lo que hoy pide una función con tres parámetros — List(1, 2, 3).map(x => x * x).filter(x => x % 2 != 0) y de ahí en adelante— y cada una de esas operaciones recibe justamente una función.