Procesamiento de texto

El módulo text proporciona expresiones regulares, comparación y aplicación de parches de texto y división de documentos. Esta página es una referencia de API. Sus bloques cortos son llamadas aisladas; los bloques de división más largos son recetas parciales cuyos documentos, recursos de sistema de archivos configurados y procesamiento posterior pertenecen a la aplicación contenedora.

Carga

local text = require("text")

Expresiones regulares

text.regexp.compile

Compila una expresión regular compatible con RE2.

local re, err = text.regexp.compile("[0-9]+")
if err then
    return nil, err
end

Devuelve: Regexp, error

re:match_string

Comprueba si una cadena coincide con la expresión compilada.

local ok = re:match_string("abc123")

Devuelve: boolean

re:find_string

Busca la primera subcadena coincidente.

local match = re:find_string("abc123def")

Devuelve: string | nil

En esta versión del runtime, una coincidencia de cadena vacía también se representa como nil; usa un patrón que consuma al menos un carácter cuando sea necesario distinguir una coincidencia vacía de la ausencia de coincidencia.

re:find_all_string

Busca todas las subcadenas coincidentes.

local matches = re:find_all_string("a1b2c3")

Devuelve: string[]

re:find_string_submatch

Busca la primera coincidencia y sus grupos de captura.

local match = re:find_string_submatch("user@example.com")

Devuelve: string[] | nil (coincidencia completa + grupos de captura)

re:find_all_string_submatch

Busca todas las coincidencias y sus grupos de captura.

local matches = re:find_all_string_submatch("a=1 b=2")

Devuelve: string[][]

re:find_string_index

Busca los límites basados en 1 de la primera coincidencia.

local pos = re:find_string_index("abc123")

Devuelve: table | nil ({start, end}, basado en 1)

re:find_all_string_index

Busca los límites de todas las coincidencias.

local positions = re:find_all_string_index("a1b2c3")

Devuelve: table[] | nil (nil cuando no hay coincidencias)

re:replace_all_string

Reemplaza todas las subcadenas coincidentes.

local result = re:replace_all_string("a1b2", "X")

Devuelve: string

re:split

Divide una cadena en las coincidencias de la expresión compilada.

local parts = re:split("a,b,c", -1)

Devuelve: string[]

re:num_subexp

Devuelve el número de subexpresiones de captura.

local count = re:num_subexp()

Devuelve: number

re:subexp_names

Devuelve los nombres de las subexpresiones de captura.

local names = re:subexp_names()

Devuelve: string[]

re:string

Devuelve la cadena del patrón compilado.

local pattern = re:string()

Devuelve: string

Comparación de texto

Comparar versiones de texto y generar parches. Basado en go-diff (diff-match-patch de Google).

text.diff.new

Crea un comparador de texto con opciones predeterminadas o personalizadas.

local diff, err = text.diff.new()
local diff, err = text.diff.new(options)

Devuelve: Differ, error

Opciones {id="diff-options"}

diff:compare

Compara dos cadenas y devuelve las operaciones que transforman text1 en text2.

local diff, diff_err = text.diff.new()
if diff_err then
    return nil, diff_err
end
local diffs, err = diff:compare("hello world", "hello there")
if err then
    return nil, err
end

-- diffs contains:
-- {operation = "equal", text = "hello "}
-- {operation = "delete", text = "world"}
-- {operation = "insert", text = "there"}

Devuelve: table, error (array de {operation, text})

Operaciones: "equal", "delete", "insert"

diff:summarize

Cuenta los bytes UTF-8 sin cambios, insertados y eliminados. Para texto no ASCII, estos totales no son recuentos de puntos de código Unicode ni de grafemas.

-- `diffs` is the checked result from diff:compare.
local summary = diff:summarize(diffs)

-- summary.equals = 6 (bytes unchanged)
-- summary.deletions = 5 (bytes removed)
-- summary.insertions = 5 (bytes added)

Devuelve: table ({insertions, deletions, equals})

diff:pretty_text

Formatear diff con colores ANSI para visualizacion en terminal.

local formatted, err = diff:pretty_text(diffs)
if err then
    return nil, err
end
print(formatted)

Devuelve: string, error

diff:pretty_html

Formatear diff como HTML con tags <del> e <ins>.

local html, err = diff:pretty_html(diffs)
if err then
    return nil, err
end
-- `html` is an HTML fragment with equal, deleted, and inserted spans.

Devuelve: string, error

diff:patch_make

Generar parches que pueden aplicarse para transformar un texto en otro. Los parches pueden serializarse y aplicarse despues.

local text1 = "The quick brown fox jumps over the lazy dog"
local text2 = "The quick red fox jumps over the lazy cat"

local patches, err = diff:patch_make(text1, text2)
if err then
    return nil, err
end

Devuelve: table, error

diff:patch_apply

Aplica parches a una cadena y devuelve el resultado e indica si todos los parches se aplicaron correctamente.

local result, success = diff:patch_apply(patches, text1)
-- result = "The quick red fox jumps over the lazy cat"
-- success = true

Comprueba success antes de tratar result como la transformación solicitada. Pasa tablas de parches producidas por patch_make; en esta versión del runtime, el texto de parche serializado con formato incorrecto dentro de una tabla construida manualmente puede omitirse en vez de notificarse por separado.

Devuelve: string, boolean

División de texto

Dividir documentos grandes en fragmentos mas pequenos preservando limites semanticos. Basado en el divisor de texto de langchaingo.

text.splitter.recursive

Divide texto usando una jerarquia de separadores. Primero intenta dividir en dobles nuevas lineas (parrafos), luego nuevas lineas simples, luego espacios, luego caracteres. Recurre a separadores mas pequenos cuando los fragmentos exceden el limite de tamano.

local splitter, err = text.splitter.recursive({
    chunk_size = 1000,
    chunk_overlap = 100
})
if err then
    return nil, err
end

local long_text = "This is a long text that needs splitting..."
local chunks, split_err = splitter:split_text(long_text)
if split_err then
    return nil, split_err
end

Devuelve: Splitter, error

Opciones {id="recursive-splitter-options"}

text.splitter.markdown

Divide documentos markdown respetando la estructura. Intenta mantener encabezados con su contenido, bloques de código intactos y filas de tabla juntas.

local splitter, err = text.splitter.markdown({
    chunk_size = 2000,
    code_blocks = true,
    heading_hierarchy = true
})
if err then
    return nil, err
end

local readme = fs.get("app:docs"):readfile("README.md")
local chunks, err = splitter:split_text(readme)

Esta receta parcial requiere que la entrada habilite tanto text como fs, un recurso de sistema de archivos app:docs configurado y un archivo README.md legible dentro de ese recurso.

Devuelve: Splitter, error

Opciones {id="markdown-splitter-options"}

splitter:split_text

Dividir un solo documento en un array de fragmentos.

local chunks, err = splitter:split_text(document)
if err then
    return nil, err
end

for i, chunk in ipairs(chunks) do
    -- Process each chunk (e.g., create embedding, send to LLM)
    process(chunk)
end

Aquí, splitter es un divisor creado correctamente, mientras que document y process son proporcionados por la aplicación.

Devuelve: string[], error

splitter:split_batch

Dividir multiples documentos preservando sus metadatos. Cada documento de entrada puede producir multiples fragmentos de salida. Todos los fragmentos heredan los metadatos de su documento fuente.

-- Input: pages from a PDF with page numbers
local pages = {
    {content = "First page content...", metadata = {page = 1}},
    {content = "Second page content...", metadata = {page = 2}}
}

local chunks, err = splitter:split_batch(pages)
if err then
    return nil, err
end

-- Output: each chunk knows which page it came from
for _, chunk in ipairs(chunks) do
    print("Page " .. chunk.metadata.page .. ": " .. chunk.content:sub(1, 50))
end

Devuelve: table, error (array de {content, metadata})

split_batch omite silenciosamente un elemento cuando este no es una tabla, falta su campo content, está vacío o no es una cadena, o falla la división de ese elemento. Aun así, devuelve los fragmentos restantes con un error nil. Valida cada elemento de entrada antes de la llamada y comprueba en el código de la aplicación cualquier requisito de cardinalidad; no trates una llamada correcta como prueba de que se representaron todas las entradas.

Errores

Consulta Manejo de errores para trabajar con errores.