Procesamiento de Texto

Expresiones regulares, comparacion de texto y division semantica de texto.

Carga

local text = require("text")

Expresiones Regulares

Compilar

local re, err = text.regexp.compile("[0-9]+")

Devuelve: Regexp, error

Coincidencia

local ok = re:match_string("abc123")

Devuelve: boolean

Buscar

local match = re:find_string("abc123def")

Devuelve: string | nil

Buscar Todas

local matches = re:find_all_string("a1b2c3")

Devuelve: string[]

Buscar con Grupos

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

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

Buscar Todas con Grupos

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

Devuelve: string[][]

Buscar Indice

local pos = re:find_string_index("abc123")

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

Buscar Todos los Indices

local positions = re:find_all_string_index("a1b2c3")

Devuelve: table[]

Reemplazar

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

Devuelve: string

Dividir

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

Devuelve: string[]

Conteo de Subexpresiones

local count = re:num_subexp()

Devuelve: number

Nombres de Subexpresiones

local names = re:subexp_names()

Devuelve: string[]

String de Patrón

local pattern = re:string()

Devuelve: string

Comparacion de Texto

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

Crear Comparador

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

Devuelve: Differ, error

Opciones {id="diff-options"}

Comparar

Encontrar diferencias entre dos textos. Devuelve un array de operaciones describiendo como transformar text1 en text2.

local diff, _ = text.diff.new()
local diffs, err = diff:compare("hello world", "hello there")

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

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

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

Resumir

Contar caracteres cambiados entre versiones.

local diffs, _ = diff:compare("hello world", "hello there")
local summary = diff:summarize(diffs)

-- summary.equals = 6 (caracteres sin cambiar)
-- summary.deletions = 5 (caracteres eliminados)
-- summary.insertions = 5 (caracteres agregados)

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

Texto Formateado

Formatear diff con colores ANSI para visualizacion en terminal.

local formatted, err = diff:pretty_text(diffs)
print(formatted)

Devuelve: string, error

HTML Formateado

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

local html, err = diff:pretty_html(diffs)
-- Devuelve: "hello <del>world</del><ins>there</ins>"

Devuelve: string, error

Crear Parches

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)

Devuelve: table, error

Aplicar Parches

Aplicar parches para transformar texto. Devuelve el resultado y si todos los parches se aplicaron exitosamente.

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

Devuelve: string, boolean

Division de Texto

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

Divisor Recursivo

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
})

local long_text = "This is a long text that needs splitting..."
local chunks, err = splitter:split_text(long_text)
-- chunks = {"This is a long...", "...text that needs...", "...splitting..."}

Devuelve: Splitter, error

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

Divisor de 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
})

local readme = fs.read("README.md")
local chunks, err = splitter:split_text(readme)

Devuelve: Splitter, error

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

Dividir Texto

Dividir un solo documento en un array de fragmentos.

local chunks, err = splitter:split_text(document)

for i, chunk in ipairs(chunks) do
    -- Procesar cada fragmento (ej., crear embedding, enviar a LLM)
    process(chunk)
end

Devuelve: string[], error

Dividir Lote

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.

-- Entrada: paginas de un PDF con numeros de pagina
local pages = {
    {content = "First page content...", metadata = {page = 1}},
    {content = "Second page content...", metadata = {page = 2}}
}

local chunks, err = splitter:split_batch(pages)

-- Salida: cada fragmento sabe de que pagina vino
for _, chunk in ipairs(chunks) do
    print("Page " .. chunk.metadata.page .. ": " .. chunk.content:sub(1, 50))
end

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

Errores

Consulte Manejo de Errores para trabajar con errores.