El modelo de String: grafemas y no bytes

Casi todos los lenguajes te mienten sobre qué es una cadena. Unos te venden un vector de bytes, otros un vector de unidades de dieciséis bits, y en ambos casos la longitud es un número que ya estaba guardado y que devuelven sin pensar. El precio de esa comodidad lo paga el usuario: una letra acentuada mide dos, un emoji de familia mide once, y cortar por la mitad produce basura. Swift tomó la decisión contraria y la sostuvo hasta el final: la unidad de String es el grafema, aquello que una persona señalaría con el dedo y llamaría un carácter. Todo lo que te resulte extraño en esta parte del lenguaje deriva de esa única decisión.

El grafema como unidad

Un Character de Swift no es un byte ni un punto de código: es un cluster de grafemas extendido, la unidad que el anexo 29 del estándar Unicode define como lo que una persona percibe como un carácter. Esa definición no es una metáfora, es un algoritmo: una máquina de estados que recorre la secuencia de escalares y decide, entre cada par consecutivo, si hay frontera o no la hay. Una letra base seguida de una tilde combinante no tiene frontera en medio, así que forman un solo Character. Dos indicadores regionales forman una bandera y tampoco se separan. Una familia de emoji son siete escalares cosidos por juntadores de anchura cero, y sigue siendo un Character.

let precompuesta = "é"          // un escalar, U+00E9
let compuesta = "e\u{0301}"     // e mas tilde combinante

print(precompuesta.count)               // 1
print(compuesta.count)                  // 1
print(compuesta.unicodeScalars.count)   // 2
print(compuesta.utf8.count)             // 3

let familia = "👨‍👩‍👧‍👦"
print(familia.count)                    // 1
print(familia.unicodeScalars.count)     // 7
print(familia.utf8.count)               // 25

Fíjate en lo que acaba de ocurrir. Tres números distintos describen la misma cadena y los tres son correctos, porque responden a tres preguntas distintas: cuántas cosas ve el lector, cuántos puntos de código define Unicode y cuántos bytes ocupa en memoria. Un lenguaje que solo expone el tercero te obliga a fingir que es el primero, y ahí nacen los cortes a mitad de emoji. Swift expone los tres, pero pone el primero en la puerta principal.

El propio Character lleva encima una capa de conveniencia que conviene conocer antes de bajar de nivel. Sabe si es letra, dígito, espacio o signo, sabe su valor numérico cuando lo tiene, y responde a esas preguntas agregando las propiedades de los escalares que lo componen. Para la mayoría de los validadores cotidianos, esa capa basta y evita tener que razonar sobre puntos de código.

let c: Character = "7"
print(c.isNumber, c.wholeNumberValue ?? -1)     // true 7

let letra: Character = "Ñ"
print(letra.isLetter, letra.isUppercase)        // true true

// Un Character puede contener varios escalares; un escalar es indivisible
print(letra.unicodeScalars.count)               // 1
print(Character("👍🏽").unicodeScalars.count)     // 2

// El literal de un solo elemento se infiere como String salvo anotacion
let comoCadena = "a"            // String
let comoCaracter: Character = "a"

Por qué contar es recorrer

La consecuencia inmediata es que la longitud no está guardada en ninguna parte. Lo que hay en memoria es una secuencia de bytes en UTF-8 y una cabecera con la cantidad de bytes; el número de grafemas no es una función barata de ese dato, porque depende de reglas que solo pueden aplicarse mirando el contenido. Para saber cuántos Character hay, la biblioteca estándar decodifica los bytes a escalares, aplica la segmentación y cuenta los saltos de frontera. Es un recorrido completo, y por eso count sobre String es lineal en el tamaño y no constante.

flowchart TD
A[Bytes UTF8 en memoria] --> B[Decodificar a escalares Unicode]
B --> C[Aplicar reglas de segmentacion del anexo 29]
C --> D[Marcar fronteras de cluster]
D --> E[Un Character por cada cluster]
E --> F[count es el numero de pasos dados]

Esto también explica una omisión que sorprende a quien llega de otros lenguajes: String conforma BidirectionalCollection, no RandomAccessCollection. La conformidad no es un descuido, es una declaración honesta de complejidad. Puedes avanzar y retroceder de a un grafema, pero no puedes saltar al enésimo sin pasar por los anteriores, y el sistema de protocolos lo dice en voz alta en vez de esconderlo detrás de un subíndice que parece barato.

La igualdad no es comparar bytes

El compromiso con el grafema llega hasta el operador de igualdad. Swift compara cadenas por equivalencia canónica, según las reglas de normalización de Unicode: dos cadenas son iguales si representan el mismo texto, aunque sus bytes difieran. La letra con tilde precompuesta y la letra seguida de tilde combinante son la misma cadena para Swift, ocupan distinto espacio y producen el mismo valor de hashValue, que es la condición imprescindible para que funcionen como claves de un diccionario.

let a = "café"
let b = "cafe\u{0301}"

print(a == b)                  // true
print(a.utf8.count, b.utf8.count)   // 5 6

var indice: [String: Int] = [:]
indice[a] = 1
print(indice[b] ?? 0)          // 1, la misma clave

// La comparacion binaria hay que pedirla explicitamente
print(Array(a.utf8) == Array(b.utf8))   // false

La implementación no es ingenua: hay un camino rápido que compara los buffers byte a byte y termina en cuanto son idénticos, que es el caso mayoritario, y solo cuando difieren entra la normalización perezosa que compara segmento a segmento sin materializar una copia normalizada. Aun así, el modelo mental correcto es que la igualdad de String es semántica, no física. Si necesitas la física, porque estás calculando una firma criptográfica o comparando un identificador de protocolo, baja a la vista de bytes y compara ahí.

El coste, y cómo no pagarlo dos veces

Nada de lo anterior es lento en términos absolutos: recorrer una cadena de mil grafemas cuesta microsegundos. El problema aparece cuando el recorrido se anida dentro de otro recorrido y una operación lineal se multiplica hasta volverse cuadrática. Los dos patrones que lo provocan son siempre los mismos y ambos se reconocen a simple vista.

// Cuadratico: count recorre la cadena en cada vuelta
for i in 0..<texto.count {
  usar(texto[texto.index(texto.startIndex, offsetBy: i)])
}

// Lineal: el iterador ya mantiene la posicion
for caracter in texto {
  usar(caracter)
}

// Cuadratico disfrazado: preguntar por vacio contando
if texto.count == 0 { ... }

// Constante
if texto.isEmpty { ... }