Clase 4. Funciones y datos¶
Jueves 1 de octubre de 2026.
Hasta ahora lo que se abstraía era el cálculo: una función que recibe otra función y deja huecos donde algo cambia. Esta sesión abstrae el otro lado, el dato. Una fecha son tres enteros —día, mes y año—, y aun así nadie piensa en tres enteros: piensa en una fecha. Eso es lo que se arma aquí, con los racionales en la mañana y con los vectores en la tarde.
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 ocho ejercicios interactivos de la sesión están en
Ejercicios.
Referencia: Odersky, Spoon y Venners, Programming in Scala, 3.ª edición, capítulos 4, 6 y 10.
El problema que abrió la clase¶
Un racional es a/b con a y b enteros y b distinto de cero. Con los
tipos que ya hay, el intento natural es un Double:
val a: Double = 1 / 3.0
val b: Double = 1 / 9.0
println(a + b)
println(4 / 9.0)
0.4444444444444444
0.4444444444444444
Los dos coinciden, y aun así el Double no guarda un tercio: guarda la
aproximación que cabe en 64 bits. Entre 0 y 1 hay infinitos reales y los bits
son finitos, así que lo que se almacena es lo más cercano representable. Que
estas dos sumas coincidan es suerte del redondeo, no exactitud; basta correr
otro caso para verlo:
0.1 + 0.2 0.30000000000000004
(0.1 + 0.2) == 0.3 false
De ahí sale el encargo: si el racional se guarda como dos enteros, la aritmética vuelve a ser exacta. Y dos enteros sueltos no bastan: hay que poder tratarlos como una sola cosa.
En la tarde el mismo problema con vectores de dos dimensiones, escritos sin abstracción:
val x1: Int = 1; val y1: Int = 10
val x2: Int = 12; val y2: Int = 10
val x3: Int = x1 + x2
val y3: Int = y1 + y2
v1 1,10
v2 12,10
v3 13,20
Funciona, y con tres vectores ya son seis nombres. La pregunta que cerró el tramo fue qué pasa cuando hay muchos: la respuesta es que el programa se llena de variables que solo existen porque el dato no tiene nombre propio.
La clase y su constructor¶
En Scala el constructor va en la declaración de la clase: los parámetros se escriben al lado del nombre.
class Racional(a: Int, b: Int) {
val num = a
val den = b
}
El nombre Vector no se puede usar para la clase de la tarde, porque ya existe
en la librería de Scala; por eso quedó Vectores.
La primera corrida, antes de tocar nada más, no imprime lo que se espera:
Vectores@4f3f5b24
Eso viene del toString que toda clase hereda, y que muestra el nombre de la
clase y una referencia. Para que el objeto se imprima como lo que es hay que
sobreescribirlo:
override def toString(): String = this.num + "/" + this.den
En vectores, "(" + this.x + "," + this.y + ")".
Normalizar dentro del constructor¶
La suma de 1/3 y 1/9 da 12/27, que es correcto y está sin reducir. Para
reducirlo hace falta el máximo común divisor, con el algoritmo de Euclides por
residuos:
private def mcd(a: Int, b: Int): Int = {
if (b == 0) a
else mcd(b, a % b)
}
Para mcd(12, 27):
12 mod 27 = 12
27 mod 12 = 3
12 mod 3 = 0 -> el mcd es 3
y 12/27 queda en 4/9. El mcd se calcula al construir, de modo que ningún
racional existe sin reducir:
val num = a / mcd(a, b)
val den = b / mcd(a, b)
En la tarde se aplicó la misma idea al vector, dividiendo por la norma:
val x = a / norma(a, b)
val y = b / norma(a, b)
private def norma(x: Double, y: Double): Double = Math.sqrt(x * x + y * y)
Aquí la analogía se rompe, y vale la pena ver dónde. Dividir por el máximo
común divisor no cambia el número: 12/27 y 4/9 son el mismo racional.
Dividir por la norma sí cambia el vector: lo deja de longitud uno. Por eso
new Vectores(2, 3) no guarda (2, 3):
(0.5547001962252291,0.8320502943378437)
y la suma de dos vectores ya normalizados se vuelve a normalizar al
construirse, así que tampoco es la suma de las coordenadas originales. Sin la
norma, a.suma(b) con (2,3) y (4,5) daría (6,8), que es lo que se vio
antes de agregarla.
Encapsulación¶
mcd y norma van private. Son cuentas internas: existen para que el
constructor deje el dato en forma, y nadie fuera de la clase tiene por qué
llamarlas ni depender de ellas. Lo que queda público es lo que el dato ofrece.
Las operaciones devuelven objetos nuevos¶
def suma(r: Racional): Racional = {
new Racional(this.num * r.den + this.den * r.num,
this.den * r.den)
}
Ninguna operación modifica el receptor: cada una construye un racional nuevo.
r1.suma(r2) 4/9
r1.resta(r2) 2/9
r1.multiplicacion(r2) 1/27
con r1 = 1/3 y r2 = 1/9. Un tercio son tres novenos, así que la resta deja
dos novenos; y un tercio por un noveno, uno sobre veintisiete.
El argumento implícito¶
suma recibe un parámetro y, sin embargo, trabaja con dos racionales. El
segundo entra sin escribirse: es this, el objeto sobre el que se llamó el
método. La firma, puesta por completo, sería:
def suma(this: Racional, r: Racional): Racional
this es la instancia; el área de memoria con los campos de este objeto. Todo
método dentro de una clase lo recibe, aunque no aparezca, y por eso cuando el
cuerpo nombra num sin calificar, el compilador lee this.num:
def obtenerX() = x // lo que se escribe
def obtenerX() = this.x // lo que se compila
En Python ese argumento se escribe:
class Ejemplo:
def __init__(self, x, y):
self.x = x
self.y = y
self es el mismo puntero, con nombre por convención y puesto a mano. Un
método que lo omite no alcanza el objeto, y llamarlo falla con un error de
cantidad de argumentos. Scala y Java lo ponen solos; Python, no. Es una
decisión de cada lenguaje, no una diferencia de fondo.
Notación infija¶
Cuando un método recibe un solo parámetro se puede escribir sin punto y sin paréntesis:
r1.suma(r2) // con punto
r1 suma r2 // infija
Las dos formas son la misma llamada. El operador puede ir delante de los operandos (prefija), en medio (infija) o detrás (posfija); la aritmética que todos leemos es infija, y eso es lo que Scala permite recuperar.
Operadores como métodos¶
Si suma se puede escribir en el medio, el paso siguiente es llamarla por el
símbolo que ya le corresponde:
def +(r: Racional): Racional = this.suma(r)
def -(r: Racional): Racional = this.resta(r)
def *(r: Racional): Racional = this.multiplicacion(r)
r1 + r2 4/9
r1 - r2 2/9
r1 * r2 1/27
Los mismos números que antes. + no es sintaxis privilegiada: es un nombre de
método. Scala admite dos clases de identificador. Los alfanuméricos empiezan
con letra y siguen con letras o dígitos, como suma o x1. Los simbólicos
están hechos de símbolos de operador: +, ++, :::.
La precedencia la fija el primer carácter del símbolo, no el orden en que se lee la línea. Con los vectores:
a * b + c (0.5317491236059955,0.846901924395178)
c + a * b (0.5317491236059955,0.846901924395178)
(c + a) * b (0.4877808772051354,0.8729661023390247)
Las dos primeras coinciden porque * se agrupa antes que + en los dos
sentidos. La tercera, con los paréntesis puestos a mano, da otra cosa: ahí se
ve que la agrupación de las dos primeras no era casualidad.
Precondiciones¶
Un racional con denominador cero no es un racional. Mientras la clase no diga
nada, new Racional(1, 0) se construye sin protestar y luego no sirve para
nada. La condición se declara en el constructor:
require(b > 0, "El denominador debe ser positivo")
java.lang.IllegalArgumentException: requirement failed: El denominador debe ser positivo
La condición es b > 0 y no b != 0 a propósito: con denominadores negativos
habría que decidir dónde vive el signo y arrastrar esa decisión por todas las
operaciones. Exigir el denominador positivo quita el problema de encima.
require y assert no son lo mismo: require es una condición sobre los
argumentos y impide que el objeto se construya; assert comprueba algo que
debería cumplirse y falla cuando el objeto ya existe.
Modelo de sustitución con clases¶
Las reglas de evaluación de las sesiones anteriores siguen sirviendo, con un reemplazo más. Para una clase
class C(x1, ..., xm) { ... def f(y1, ..., yn) = b ... }
evaluar new C(v1, ..., vm).f(w1, ..., wn) consiste en reemplazar, dentro del
cuerpo b, cada parámetro de la clase xi por su valor vi, cada parámetro
del método yi por su argumento wi, y this por el objeto receptor,
new C(v1, ..., vm).
El ejercicio de la sesión¶
Números complejos con sus operadores. La parte que dejó enseñanza fue la depuración contra las pruebas, que falló varias veces por motivos distintos:
- El redondeo a tres decimales. Multiplicar por mil, redondear a entero y
dividir por mil:
Math.round(n * 1000) / 1000.0. - La división. La parte imaginaria es
(a2·b1 − a1·b2) / (a2² + b2²), y estaba escrita con el producto cambiado. Se encontró contrastando el código con la fórmula del enunciado, no mirando el código solo. - La prueba de precedencia. Comprueba que
1 + 2 * 3sobre complejos se agrupe como en los enteros. Falló, y la sospecha fue que Scala no estaba aplicando la precedencia. No era eso: la suma tenía un*donde iba un+. La precedencia no se programa; el compilador la aplica por el nombre del operador, y lo que estaba mal era la implementación.
Para aislar el problema se quitó el redondeo a propósito: con menos cosas encima, se ve cuál prueba falla por cuál motivo.
Lo que queda¶
En seis puntos, que es como cerró la sesión:
- Datos compuestos, con nombre propio: un objeto.
- Las operaciones quedan currificadas, con un parámetro explícito y
this. toStringse sobreescribe para que el dato se lea.- Las operaciones se pueden escribir en notación infija:
a.+(b)esa + b. - Las precondiciones se declaran con
requireyassert. - El dato compuesto evita arrastrar variables sueltas:
numydenviven dentro del racional,xeydentro del punto.
El Taller 2 se entrega el 21 de octubre.
Lo que sigue: qué pasa cuando varios datos comparten operaciones, que es herencia, clases abstractas y traits; y cómo se descompone un dato según su forma, que es el reconocimiento de patrones.