Módulos nativos

La biblioteca estándar se importa por nombre. El motor usa Rust estándar y rustls para TLS; no hay frameworks ni un gestor de paquetes: todo lo que aparece aquí viene con el binario.

importar json
importar mate como mat
importar archivo

json

importar json

datos = json.convertir("{\"nombre\": \"Ada\", \"edad\": 36}")
imprimir(datos.nombre)                       # Ada

texto = json.serializar(datos)                # compacto
bonito = json.serializar(datos, verdadero)    # con indentación
valido = json.valido(texto)                   # verdadero

json.convertir lanza un error de ejecución si el texto no es JSON válido o si el anidamiento supera los 300 niveles. json.serializar serializa listas, diccionarios e instancias (por sus campos) y limita la profundidad a 128; las funciones, clases y tareas no son serializables.

bd

Conexiones SQLite con consultas parametrizadas. Los valores nunca se interpolan en el SQL: se envían como parámetros enlazados.

importar bd

db = bd.conectar("sqlite:datos.db")
memoria = bd.conectar("sqlite::memory:")

DSN

bd.sqlite(ruta) es un atajo de bd.conectar("sqlite:" + ruta).

Modo de apertura

Por defecto, si el archivo no existe, SQLite lo crea vacío. Puedes cambiar ese comportamiento:

# Falla si el archivo no existe (no lo crea).
db = bd.conectar("sqlite:datos.db", {"crear": falso})

# Solo lectura: falla si no existe y rechaza escrituras.
db = bd.abrir_solo_lectura("datos.db")

db = bd.conectar("sqlite:datos.db", {
    "solo_lectura": verdadero,
    "tiempo_espera": 2000
})

• La carpeta padre debe existir; Vaca no crea directorios.
• sqlite::memory: no admite solo_lectura.
• Puedes comprobar el modo con db.solo_lectura().

Crear y consultar

importar bd

db = bd.conectar("sqlite:tienda.db")

db.ejecutar("CREATE TABLE IF NOT EXISTS productos (id INTEGER PRIMARY KEY AUTOINCREMENT, nombre TEXT, precio REAL)")

resultado = db.ejecutar(
    "INSERT INTO productos (nombre, precio) VALUES (?, ?)",
    ["Café", 8.5]
)
imprimir(resultado.filas)       # 1
imprimir(resultado.ultimo_id)   # id generado

filas = db.consultar("SELECT id, nombre, precio FROM productos WHERE precio > ?", [5])
para fila en filas {
    imprimir(a"{fila.nombre}: {fila.precio}")
}

uno = db.una("SELECT * FROM productos ORDER BY precio DESC")
nombre = db.valor("SELECT nombre FROM productos WHERE id = ?", [1])

Métodos

db.tipo devuelve conexion.

Transacciones

db.iniciar()
intentar {
    db.ejecutar("INSERT INTO productos (nombre, precio) VALUES (?, ?)", ["Té", 4.0])
    db.ejecutar("UPDATE productos SET precio = ? WHERE nombre = ?", [4.5, "Té"])
    db.confirmar()
} atrapar error {
    db.revertir()
    lanzar error
}

Tipos

SQLite no tiene fecha nativa: guarda fechas como TEXT ISO o como epoch y conviértelas en Vaca. Las columnas JSON también son TEXT; usa json.convertir.

Notas

• Cada conectar abre una conexión. Los métodos se serializan con un mutex; para muchas peticiones concurrentes, abre una conexión por tarea.
• ultimo_id solo se devuelve tras un INSERT.
• ejecutar no devuelve filas: para INSERT ... RETURNING usa consultar.
• Al abrir en solo lectura, cualquier INSERT, UPDATE o DELETE falla.
• Los parámetros admiten enteros, decimales, textos, lógicos y nulo.
• Si un SELECT repite el mismo nombre de columna, usa alias (AS) para no perder valores en el diccionario.
• No hay agrupación de conexiones ni migraciones automáticas.
• Vaca solo incluye SQLite de forma nativa; para otro motor necesitas otro binario o un módulo externo.

mate

importar mate

imprimir(mate.PI)
imprimir(mate.raiz(16))              # 4
imprimir(mate.potencia(2, 10))       # 1024
imprimir(mate.redondear(3.14159, 2)) # 3.14
imprimir(mate.aleatorio_entero(1, 6))

promedio, minimo, maximo y sumar aceptan una lista o argumentos separados:

imprimir(mate.promedio([10, 20, 30]))   # 20
imprimir(mate.promedio(10, 20, 30))     # 20

tiempo

Todas las fechas son UTC. Un epoch son segundos desde 1970-01-01T00:00:00Z; si se omite, se usa el momento actual.

importar tiempo

imprimir(tiempo.ahora())                  # segundos Unix
imprimir(tiempo.millis())                 # milisegundos Unix
imprimir(tiempo.fecha_iso())              # 2026-10-20T12:00:00Z
imprimir(tiempo.fecha_iso("A-M-D"))       # 2026-10-20
imprimir(tiempo.formatear("A/M/D", 0))    # 1970/01/01
tiempo.dormir(250)                        # bloquea 250 ms

fecha y fecha_iso aceptan un formato como primer argumento:

tiempo.fecha_iso("A-M-D", 1700000000)     # 2023-11-14
tiempo.fecha("H:m:S", 1700000000)         # 22:13:20
tiempo.iso("A", 0)                        # 1970
tiempo.formatear("W", 0)                  # 4 (jueves)

Códigos de formato

M es mes y m es minuto. Los demás caracteres se copian tal cual. Usa \ para escapar un código: formatear("\\A", epoch) devuelve A.

Partes

p = tiempo.partes(1709164800)
imprimir(p.año)        # 2024
imprimir(p.mes)         # 2
imprimir(p.dia)         # 29
imprimir(p.dia_del_año)    # 60
imprimir(p.semana)      # 9 (ISO)
imprimir(p.dia_semana)  # 4 (jueves)
imprimir(p.zona)        # UTC

tiempo.dormir bloquea el hilo. Para esperar sin bloquear el hilo principal, lánzalo dentro de una tarea async.

sistema

importar sistema

puerto = sistema.env("PUERTO", "8080")
imprimir(sistema.directorio())
imprimir(sistema.plataforma())     # linux, macos, windows...
imprimir(sistema.argumentos())     # argumentos extra del programa
sistema.salir(0)

salir no se puede capturar con intentar/atrapar.

Archivos .env

sistema.cargar_env lee un archivo .env y devuelve un diccionario. No modifica las variables de entorno del proceso:

importar sistema

config = sistema.cargar_env(".env")
puerto = sistema.env("PUERTO", config.obtener("PUERTO", "8080"))
imprimir(puerto)

• Sin argumentos lee .env desde el directorio del programa.
• Si el archivo no existe y obligatorio es falso, devuelve {}.
• Con obligatorio = verdadero, lanza un error.
• Soporta export, comillas simples y dobles, escapes en comillas dobles y comentarios # al principio o al final de la línea.
• En valores sin comillas, # solo inicia un comentario si va precedido de espacio; abc#def conserva el #.
• No expande ${VARIABLES} ni valores multilínea.

Ejemplo de .env:

# Configuración
PUERTO=8080
NOMBRE="Vaca servidor" # comentario al final
export DEBUG=true
URL=http://localhost:8080/api?x=1
CLAVE='valor # literal'

archivo

Las rutas relativas se resuelven desde el archivo principal.

importar archivo

archivo.escribir("datos.txt", "hola\n")
archivo.anexar("datos.txt", "mundo\n")
contenido = archivo.leer("datos.txt")
imprimir(contenido)

si archivo.existe("datos.txt") {
    imprimir(archivo.tamano("datos.txt"))
}

archivo.crear_dir("salida")
imprimir(archivo.listar("."))
archivo.eliminar("datos.txt")

cadenas

importar cadenas

imprimir(cadenas.mayusculas("vaca"))            # VACA
imprimir(cadenas.unir(["a", "b"], "-"))         # a-b
imprimir(cadenas.rellenar_izquierda("7", 3, "0")) # 007

dividir también está disponible como función global: dividir("a,b", ","). Con un separador vacío divide en caracteres. Conserva las partes vacías. | contiene(texto, buscado) | Lógico | | empieza_con(texto, prefijo) | Lógico | | termina_con(texto, sufijo) | Lógico | | repetir(texto, veces) | Repite | | rellenar_izquierda(texto, ancho, relleno = " ") | Rellena a la izquierda | | rellenar_derecha(texto, ancho, relleno = " ") | Rellena a la derecha | | longitud(texto) | Número de caracteres |

Los métodos de texto (texto.mayusculas(), texto.dividir(...), etc.) hacen lo mismo sin importar el módulo. Consulta El lenguaje para la lista completa.

datos

Un DataFrame es un diccionario con dos claves:

df = {
    "columnas": ["ciudad", "monto"],
    "filas": [["Madrid", 100], ["Lima", 50]]
}

Leer, ver y guardar

importar datos

df = datos.leer_csv("ventas.csv")
datos.ver(df)
datos.guardar_csv(df, "copia.csv")

Consultar

datos.dimensiones(df)          # [filas, columnas]
datos.nombres(df)              # ["ciudad", "monto"]
datos.columna(df, "monto")     # [100, 50, 30]

Filtrar y ordenar

grandes = datos.filtrar(df, "monto", ">=", 100)
ordenado = datos.ordenar(grandes, "monto", falso)

Operadores de filtro: ==, =, !=, <>, >, <, >=, <= y contiene. El tercer argumento de ordenar es ascendente y vale verdadero por defecto.

Mutar y agrupar

con_iva = datos.mutar(df, "monto_iva", fn(fila) {
    retornar fila.monto * 1.21
})

resumen = datos.agrupar_resumir(df, "ciudad", "monto", "suma")

Operaciones de resumen: suma, promedio, conteo, min, max, primero, ultimo y unir.

Otras operaciones

seleccion = datos.seleccionar(df, ["ciudad", "monto"])
sin_columna = datos.eliminar_columna(df, "id")
combinado = datos.unir(df1, df2)

json_df = datos.a_json(df)
df2 = datos.desde_json(json_df)

Los DataFrames son estructuras en memoria. Para datasets que no caben en RAM, procesa por lotes o usa una base de datos externa.

concurrencia

importar concurrencia

t = concurrencia.tarea(procesar, dato)
resultado = concurrencia.esperar_todas([t])

contador = concurrencia.contador(0)
contador.incrementar()
imprimir(contador.valor())

Los contadores exponen los mismos métodos:

contador.incrementar(10)
contador.valor()
contador.reiniciar()

Consulta HTTP y concurrencia para el modelo de hilos, las tareas async y los límites.

http

El módulo se documenta en detalle en HTTP y concurrencia. Resumen:

importar http

http.servidor(8080, manejador)
http.servidor("0.0.0.0", 8080, manejador, 1000)
http.servidor_tls(8443, "servidor.pem", "servidor-clave.pem", manejador, 1000)

respuesta = http.peticion("https://127.0.0.1:8443/salud")

Módulos de archivo

Cualquier archivo .vaca puede importarse como módulo:

importar "util.vaca" como util
importar util

El módulo expone sus funciones, constantes y variables. Las importaciones se cachean y los ciclos se detectan con un error.