Unicode

El módulo Unicode proporciona funcionalidad esencial para gestionar caracteres y cadenas Unicode. Incluye validación, determinación de categorías, normalización, transformación de mayúsculas y minúsculas, y segmentación de grafemas, lo que permite un manejo efectivo de datos Unicode.

Unicode.julia_chartransform(c::Union{Char,Integer})

Mapea el carácter Unicode (Char) o el punto de código (Integer) c al correspondiente carácter o punto de código "equivalente", respectivamente, de acuerdo con la equivalencia personalizada utilizada dentro del analizador de Julia (además de la normalización NFC).

Por ejemplo, 'µ' (U+00B5 micro) se trata como equivalente a 'μ' (U+03BC mu) por el analizador de Julia, por lo que julia_chartransform realiza esta transformación mientras deja otros caracteres sin cambios:

julia> Unicode.julia_chartransform('µ')
'μ': Unicode U+03BC (categoría Ll: Letra, minúscula)

julia> Unicode.julia_chartransform('x')
'x': ASCII/Unicode U+0078 (categoría Ll: Letra, minúscula)

julia_chartransform es principalmente útil para pasar a la función Unicode.normalize con el fin de imitar la normalización utilizada por el analizador de Julia:

julia> s = "µö"
"µö"

julia> s2 = Unicode.normalize(s, compose=true, stable=true, chartransform=Unicode.julia_chartransform)
"μö"

julia> collect(s2)
2-element Vector{Char}:
 'μ': Unicode U+03BC (categoría Ll: Letra, minúscula)
 'ö': Unicode U+00F6 (categoría Ll: Letra, minúscula)

julia> s2 == string(Meta.parse(s))
true

Unicode.isassigned(c) -> Bool

Devuelve true si el carácter o entero dado es un punto de código Unicode asignado.

Ejemplos

julia> Unicode.isassigned(101)
true

julia> Unicode.isassigned('\x01')
true

isequal_normalized(s1::AbstractString, s2::AbstractString; casefold=false, stripmark=false, chartransform=identity)

Devuelve si s1 y s2 son cadenas Unicode equivalentes de manera canónica. Si casefold=true, ignora mayúsculas y minúsculas (realiza un plegado de mayúsculas Unicode); si stripmark=true, elimina marcas diacríticas y otros caracteres combinantes.

Al igual que con Unicode.normalize, también puedes pasar una función arbitraria a través de la palabra clave chartransform (mapeando puntos de código Integer a puntos de código) para realizar normalizaciones personalizadas, como Unicode.julia_chartransform.

Ejemplos

Por ejemplo, la cadena "noël" se puede construir de dos maneras equivalentes de manera canónica en Unicode, dependiendo de si "ë" se forma a partir de un solo punto de código U+00EB o a partir del carácter ASCII 'e' seguido del carácter combinante U+0308 diaeresis.

julia> s1 = "noël"
"noël"

julia> s2 = "noël"
"noël"

julia> s1 == s2
false

julia> isequal_normalized(s1, s2)
true

julia> isequal_normalized(s1, "noel", stripmark=true)
true

julia> isequal_normalized(s1, "NOËL", casefold=true)
true

Unicode.normalize(s::AbstractString; keywords...)
Unicode.normalize(s::AbstractString, normalform::Symbol)

Normaliza la cadena s. Por defecto, se realiza la composición canónica (compose=true) sin garantizar la estabilidad de la versión de Unicode (compat=false), lo que produce la cadena equivalente más corta posible, pero puede introducir caracteres de composición que no están presentes en versiones anteriores de Unicode.

Alternativamente, se puede especificar una de las cuatro "formas normales" del estándar Unicode: normalform puede ser :NFC, :NFD, :NFKC o :NFKD. Las formas normales C (composición canónica) y D (decomposición canónica) convierten diferentes representaciones visualmente idénticas de la misma cadena abstracta en una única forma canónica, siendo la forma C más compacta. Las formas normales KC y KD además canonizan "equivalentes de compatibilidad": convierten caracteres que son abstractamente similares pero visualmente distintos en una única elección canónica (por ejemplo, expanden ligaduras en los caracteres individuales), siendo la forma KC más compacta.

Alternativamente, se puede obtener un control más fino y transformaciones adicionales llamando a Unicode.normalize(s; keywords...), donde se especifica cualquier número de las siguientes opciones booleanas de palabras clave (que todas tienen un valor predeterminado de false excepto compose):

• compose=false: no realizar composición canónica
• decompose=true: realizar decomposición canónica en lugar de composición canónica (compose=true se ignora si está presente)
• compat=true: los equivalentes de compatibilidad son canonizados
• casefold=true: realizar plegado de mayúsculas de Unicode, por ejemplo, para comparación de cadenas sin distinción de mayúsculas
• newline2lf=true, newline2ls=true o newline2ps=true: convertir varias secuencias de nueva línea (LF, CRLF, CR, NEL) en un carácter de salto de línea (LF), separación de líneas (LS) o separación de párrafos (PS), respectivamente
• stripmark=true: eliminar marcas diacríticas (por ejemplo, acentos)
• stripignore=true: eliminar los caracteres "ignorables por defecto" de Unicode (por ejemplo, el guion suave o el marcador de izquierda a derecha)
• stripcc=true: eliminar caracteres de control; los tabuladores horizontales y los avances de formulario se convierten en espacios; las nuevas líneas también se convierten en espacios a menos que se haya especificado una bandera de conversión de nueva línea
• rejectna=true: lanzar un error si se encuentran puntos de código no asignados
• stable=true: hacer cumplir la estabilidad de la versión de Unicode (nunca introducir caracteres que falten en versiones anteriores de Unicode)

También puedes usar la palabra clave chartransform (que tiene un valor predeterminado de identity) para pasar una función arbitraria que mapea puntos de código Integer a puntos de código, que se llama en cada carácter de s a medida que se procesa, con el fin de realizar normalizaciones adicionales arbitrarias. Por ejemplo, al pasar chartransform=Unicode.julia_chartransform, puedes aplicar algunas normalizaciones de caracteres específicas de Julia que se realizan al analizar identificadores (además de la normalización NFC: compose=true, stable=true).

Por ejemplo, NFKC corresponde a las opciones compose=true, compat=true, stable=true.

Ejemplos

julia> "é" == Unicode.normalize("é") #LHS: Unicode U+00e9, RHS: U+0065 & U+0301
true

julia> "μ" == Unicode.normalize("µ", compat=true) #LHS: Unicode U+03bc, RHS: Unicode U+00b5
true

julia> Unicode.normalize("JuLiA", casefold=true)
"julia"

julia> Unicode.normalize("JúLiA", stripmark=true)
"JuLiA"

graphemes(s::AbstractString) -> GraphemeIterator

Devuelve un iterador sobre las subcadenas de s que corresponden a los grafemas extendidos en la cadena, tal como se define en Unicode UAX #29. (A grandes rasgos, estos son lo que los usuarios percibirían como caracteres individuales, aunque puedan contener más de un punto de código; por ejemplo, una letra combinada con un acento es un solo grafema.)

graphemes(s::AbstractString, m:n) -> SubString

Devuelve un SubString de s que consiste en los grafemas del m-ésimo al n-ésimo de la cadena s, donde el segundo argumento m:n es un AbstractUnitRange de valores enteros.

Hablando de manera general, esto corresponde a los "caracteres" percibidos por el usuario del m:n-ésimo en la cadena. Por ejemplo:

julia> s = graphemes("exposé", 3:6)
"posé"

julia> collect(s)
5-element Vector{Char}:
 'p': ASCII/Unicode U+0070 (categoría Ll: Letra, minúscula)
 'o': ASCII/Unicode U+006F (categoría Ll: Letra, minúscula)
 's': ASCII/Unicode U+0073 (categoría Ll: Letra, minúscula)
 'e': ASCII/Unicode U+0065 (categoría Ll: Letra, minúscula)
 '́': Unicode U+0301 (categoría Mn: Marca, no espaciadora)

Esto consiste en los 3º a 7º puntos de código (Chars) en "exposé", porque el grafema "é" es en realidad dos puntos de código Unicode (una 'e' seguida de un carácter combinante de acento agudo U+0301).

Debido a que encontrar los límites de los grafemas requiere iterar sobre el contenido de la cadena, la función graphemes(s, m:n) requiere un tiempo proporcional a la longitud de la cadena (número de puntos de código) antes del final de la subcadena.