Acceso y llamada: get, set, invoke, contains e iterator

Las convenciones aritméticas y de comparación permiten que un tipo propio se parezca a un número. Las cuatro de esta lección van bastante más lejos: permiten que se parezca a una colección, a una función o a una estructura recorrible, y lo hacen sin exigir que implemente ninguna interfaz, sin heredar de nada y sin pedir permiso a quien escribió el tipo original. Aquí es donde el carácter estructural del mecanismo deja de ser una curiosidad de diseño y se convierte en una capacidad práctica de primer orden, porque permite retroadaptar tipos sellados de terceros a la sintaxis del lenguaje. Y es también donde aparece el coste que las lecciones anteriores solo insinuaban, porque tres de estas cuatro convenciones borran el nombre de la operación del sitio de llamada, y un sitio de llamada sin nombre es un sitio de llamada que no se puede buscar, leer ni estimar.

Indexación: get y set con aridad libre

La notación de corchetes admite cualquier número de índices y de cualquier tipo, porque la traducción se limita a trasladar los argumentos tal cual. En la escritura, el valor asignado se añade siempre como último parámetro, y lo que devuelva la función se descarta, de modo que la firma debe declarar Unit.

class Tablero(private val ancho: Int, private val alto: Int) {
    private val celdas = CharArray(ancho * alto) { ' ' }

    operator fun get(x: Int, y: Int): Char = celdas[y * ancho + x]
    operator fun set(x: Int, y: Int, valor: Char) { celdas[y * ancho + x] = valor }
}

val t = Tablero(8, 8)
t[3, 4] = 'R'          // t.set(3, 4, 'R')
val pieza = t[3, 4]    // t.get(3, 4)

Los índices se sobrecargan como cualquier parámetro, y ahí está uno de los usos más productivos de la convención: un tipo de configuración puede indexarse por clave textual, por clave tipada y por posición a la vez, y cada variante devolver un tipo distinto. Conviene, eso sí, recordar una expectativa que el lector trae puesta y que el compilador no protege: los corchetes prometen una operación barata y previsible. Un get que abre una conexión, lanza excepciones por elementos ausentes o recorre una lista entera traiciona esa promesa aunque compile perfectamente.

invoke: objetos que se llaman

La notación de llamada sobre algo que no es una función se traduce a invoke. La consecuencia más importante no es que puedas hacerlo con tus tipos, sino que explica cómo funciona el lenguaje entero: un tipo función es una interfaz con un método invoke, y por eso una variable que contiene una lambda se llama con paréntesis sin que exista ningún caso especial en la gramática.

class Regla(val nombre: String, private val test: (String) -> Boolean) {
    operator fun invoke(entrada: String): Boolean = test(entrada)
}

val noVacia = Regla("no vacia") { it.isNotBlank() }
val valido = noVacia("hola")        // noVacia.invoke("hola")

Declarado en un compañero, invoke produce el idioma de la factoría que se lee como una construcción, con el constructor primario cerrado y toda la validación concentrada en un solo punto de entrada. Es un recurso legítimo y muy usado en la construcción de lenguajes internos, donde el objeto que se llama es a la vez un nombre con significado y una operación.

class Puerto private constructor(val numero: Int) {
    companion object {
        operator fun invoke(numero: Int): Puerto {
            require(numero in 1..65535) { "puerto fuera de rango" }
            return Puerto(numero)
        }
    }
}

val p = Puerto(8080)      // parece un constructor, es Puerto.Companion.invoke

La ventaja frente a una función de nivel superior con el mismo nombre del tipo es que la operación queda dentro del espacio de nombres de la clase y se importa con ella. La desventaja es la de siempre en este nivel: el sitio de llamada ya no distingue entre construir y ejecutar una lógica arbitraria, y quien lea esa línea supondrá lo primero.

contains: el operando de la izquierda es el argumento

La pertenencia es la única convención de este nivel donde el receptor de la llamada es el operando derecho, y esa inversión sorprende cada vez. La forma negada se traduce a la misma llamada, negada, y la función debe devolver Boolean.

data class Rect(val x0: Int, val y0: Int, val x1: Int, val y1: Int) {
    operator fun contains(p: Punto): Boolean = p.x in x0..x1 && p.y in y0..y1
}

if (raton in areaBoton) pulsar()      // areaBoton.contains(raton)

Esa notación también funciona dentro de un when sin argumento de comparación explícito, lo que permite escribir condiciones de pertenencia muy legibles sobre tipos propios. Pero hay que separar con cuidado dos usos gramaticales de la misma palabra que no tienen nada que ver entre sí. En una expresión de condición, la palabra in significa pertenencia y llama a contains. En la cabecera de un bucle, la misma palabra forma parte de otra producción gramatical, significa recorrido y llama a iterator. Un tipo puede ofrecer una convención sin la otra, y de hecho es frecuente y deseable: un conjunto de intervalos puede responder a la pertenencia en tiempo logarítmico sin que tenga ningún sentido recorrer sus infinitos puntos.

iterator: el desazucarado del bucle

El bucle for no exige ninguna interfaz. Exige tres funciones que cumplan una forma, y las busca por nombre sobre el tipo de la expresión recorrida y sobre el tipo del iterador devuelto.

flowchart TD
A[for x in c] --> B[c.iterator]
B --> C{it.hasNext devuelve verdadero}
C -- No --> F[fin del bucle]
C -- Si --> D[val x igual it.next]
D --> E[cuerpo del bucle]
E --> C

Como la búsqueda es por nombre, la capacidad de recorrer un tipo puede añadirse desde fuera con una extensión, incluso sobre tipos sellados de una librería ajena que jamás previeron ser iterables.

operator fun ClosedRange<java.time.LocalDate>.iterator(): Iterator<java.time.LocalDate> =
    object : Iterator<java.time.LocalDate> {
        private var actual = start
        override fun hasNext() = actual <= endInclusive
        override fun next() = actual.also { actual = it.plusDays(1) }
    }

for (dia in inicio..fin) registrar(dia)

Hay una obligación implícita en ese protocolo que conviene enunciar, porque su incumplimiento produce fallos difíciles de atribuir: cada llamada a iterator debe devolver un recorrido nuevo desde el principio. Si la función entrega siempre el mismo objeto, el primer bucle lo agota y el segundo no ejecuta ni una vuelta, sin lanzar nada y sin dejar rastro. Los flujos de un solo uso son la excepción legítima a esa regla, y por eso la librería estándar los tipa aparte en lugar de disfrazarlos de colección.