Skip to content

Sintaxis TypeScriptSemántica RustUn lenguaje de programación hecho para devs

Logotipo de Tyrus

Lenguaje backend compilado

Escribe código familiar en .tyr

Tyrus usa sintaxis concisa en archivos .tyr y agrega ejecución nativa, semántica de memoria determinística con NLL, diagnósticos precisos y tooling enfocado en backend.

tyrus
const main = () => {
    print("Hello, World!");
};

Superpoderes del lenguaje

Validator decorations

Reglas integradas como @email, @minLength y @min, más validaciones personalizadas con validator function. Validación declarativa sin boilerplate en runtime.

Comptime en compilación

Ejecuta lógica pura durante la compilación con comptime(...). Precalcula tablas de búsqueda, constantes y configuraciones sin costo en runtime.

Env sellado y espejo

Cifra .env en target/<profile>/.env.sealed con huellas digitales binarias. El espejo .env.example se sincroniza automáticamente con cada cambio.

Tipos

Enteros y floats u8..u128, i8..i128, f32..f128, decimal, boolean, string, char y tipos Result<T, E> nativos.

Seguridad determinística de memoria

Ownership, borrowing y NLL.

Seguridad de memoria sin garbage collector. Los tipos que no son Copy se mueven por asignación, mientras que los préstamos se validan en compilación. Con Non-Lexical Lifetimes (NLL), los préstamos expiran después de su último uso real, liberando variables para mutación inmediata sin esperar el final del bloque.

tyrus
const greeting: string = "hello";
const copy: string = greeting;

print(copy); // hello
print(greeting); // error: `greeting` was moved to `copy`

Limpieza por ámbito

Ejecuta la limpieza siempre o solo ante errores.

defer se ejecuta al salir del ámbito. errdefer se ejecuta solo cuando un retorno opcional o Result sale con error, haciendo explícita la reversión.

Más información sobre la limpieza diferida

tyrus
function transfer(ok: boolean): Result<void, string> {
    defer print("cleanup"); // cleanup
    errdefer print("rollback"); // rollback

    if (!ok) {
        return Err("transfer failed");
    }
    
    return Ok();
}

const main = (): void => {
    match (transfer(false)) {
        Ok() => print("transfer complete"); // transfer complete
        Err(error) => printError(error); // transfer failed
    }
};

Pattern matching exhaustivo

Cualquier forma. Cada rama estrechada.

Unions marcadas, variantes de enums algebraicos y match con guard clauses dan flujo de control exhaustivo. El compilador garantiza que cada variante se maneja y estrecha los tipos en cada brazo.

tyrus
const main = () => {
    const getLetterGrade = (score: u8): string => {
        match (score) {
            90..=100 => "A";
            80..=89 => "B";
            70..=79 => "C";
            60..=69 => "D";
            0..=59 => "F";
            _ => "Invalid Score";
        }
    };

    print(getLetterGrade(95)); // A
};

Sin null. Sin undefined. Solo T?

La ausencia es un estado, no un valor.

Un return; vacío produce ausencia. ?. y ?? la propagan de forma segura. El compilador te obliga a manejar el caso ausente antes de que el valor llegue a producción, sin sorpresas en runtime.

tyrus
const findAccount = (id: i32): Account? => {
    if (id > 0) {
        return { id, nickname: "ada" };
    }
    
    return;  // absence
};

const account: Account? = findAccount(1);
print(account?.nickname ?? "anon");

// Uninitialized optional starts empty
let pending: i32?;
print(pending ?? 0);  // 0

Éxito y fallo explícitos

Representa errores recuperables con Result.

Result<T, E> contiene un valor Ok o un valor Err. Combina ambas variantes o propaga el error con ?.

Más información sobre Result

tyrus
function lookupName(found: boolean): Result<string, string> {
    if (found) {
        return Ok("Ada");
    }
    
    return Err("user not found");
}

const main = (): void => {
    match (lookupName(false)) {
        Ok(name) => print(name);
        Err(message) => printError(message); // user not found
    }
};

Gestión de errores en la llamada

Mantén claro el camino exitoso con onfail.

Adjunta un handler de error al inicializador de un Result. El handler recibe el error, mientras que la variable contiene el valor exitoso si la ejecución continúa.

Más información sobre onfail

tyrus
function lookupName(found: boolean): Result<string, string> {
    if (found) {
        return Ok("Ada");
    }

    return Err("user not found");
}

function showName(found: boolean): void {
    const name = lookupName(found) onfail {
        printError(name); // user not found

        return;
    };
    
    print(name); // Ada
}

const main = () => showName(true);

Operador pipe

Los datos fluyen de arriba a abajo.

El operador |> enhebra valores a través de cadenas de funciones. El token % permite colocar el valor pipeado exactamente donde debe estar, sin variables intermedias, sin anidamiento.

tyrus
const main = (): void => {
    const double = (n: i64): i64 => n * 2;
    const increment = (n: i64): i64 => n + 1;
    const clamp = (value: i64, min: i64, max: i64): i64 => value < min ? min : value > max ? max : value;

    // Pipe chains read top-to-bottom
    const result: i64 = 5
        |> double
        |> increment
        |> double;  // 5 -> 10 -> 11 -> 22

    // Topic token % places the piped value exactly
    const clamped: i64 = 80 |> clamp(30, %, 100); // 80
    print(clamped); // 80
};

Código asíncrono nativo

Escribe funciones async y espera sus resultados.

Las funciones async devuelven Promise<T>. Usa await para obtener el valor cuando termine la operación asíncrona.

Más información sobre async y await

tyrus
async function loadName(): Promise<string> {
    return "Ada";
}

async function main(): Promise<void> {
    const name = await loadName();
    
    print(`Hello, ${name}`); // Hello, Ada
}

Kernels numéricos de alto rendimiento

Métodos algebraicos de punto flotante.

Los primitivos f32 e f64 proporcionan algebraicAdd, algebraicSub, algebraicMul, algebraicDiv y algebraicRem. Otorgan permiso explícito al compilador para reasociar cálculos de punto flotante para vectorización SIMD y aceleración matemática en hardware.

tyrus
const main = (): void => {
    const left: f64 = 6.0;
    const right: f64 = 4.0;

    // Explicit compiler permission for fast-math reassociation:
    const sum: f64 = left.algebraicAdd(right);
    const diff: f64 = left.algebraicSub(right);
    const prod: f64 = left.algebraicMul(right);
    const quot: f64 = left.algebraicDiv(right);
    const rem: f64 = left.algebraicRem(right);

    print(prod); // 24.0
};

Protección de secretos en producción

Env sellado y .env.example sincronizado.

La configuración security.envSealed cifra .env en target/<profile>/.env.sealed con claves asimétricas e inserta una huella digital en el binario para que los contenedores nunca expongan secretos en texto plano. En desarrollo, el compilador refleja claves y comentarios en .env.example con valores limpios automáticamente.

json
{
  "security": {
    "envFile": ".env",
    "envSealed": true
  }
}
text
# .env (local secrets)         # .env.example (mirrored & committed)
@type(u16)                     @type(u16)
@port()                        @port()
PORT=8080                      PORT=

@type(string)                  @type(string)
@startsWith("postgres://")     @startsWith("postgres://")
DATABASE_URL=postgres://...    DATABASE_URL=

@type(string)                  @type(string)
@minLength(16)                 @minLength(16)
API_SECRET=super_secret_value  API_SECRET=

ORM y ODM tipados

Usa una API de Model con SQL y MongoDB.

Define modelos como interfaces tipadas y consulta de forma asíncrona. La misma API de Model funciona con bases de datos relacionales y MongoDB, y devuelve los errores recuperables en Result.

Explora el módulo de bases de datos

tyrus
import { User } from "./models/User";

async function main(): Promise<void> {
    const users = await User.findMany({ active: true });
}

Evaluación en tiempo de compilación

Ejecuta código durante la compilación. Costo cero en runtime.

Las funciones declaradas con comptime se ejecutan durante la compilación e incorporan su resultado como escalares o literales estáticos directamente en el binario. Calcula tablas de búsqueda, constantes matemáticas y configuraciones con seguridad de tipos completa.

tyrus
comptime function fibonacci(index: i32): i64 {
    let previous: i64 = 0;
    let current: i64 = 1;

    for (let pos: i32 = 0; pos < index; pos++) {
        const next: i64 = previous + current;
        previous = current;
        current = next;
    }

    return previous;
}

// Evaluated once at compile time, zero runtime calculation:
const maxLimit: i64 = comptime(fibonacci(50));

const main = (): void => {
    print(maxLimit); // 12586269025
};

Exploración interactiva

Pruébalo en la terminal. Ejecútalo en el navegador.

Explora Tyrus al instante sin configurar proyectos. tyrus repl proporciona una consola interactiva con evaluación JIT a través de LLVM en proceso, edición multilínea, persistencia de sesiones e inspección con :type. ¿Prefieres el navegador? Abre el Web Playground en playground.tyruslang.org para escribir, compilar a WebAssembly y ejecutar código directamente en el navegador con enlaces compartibles.

text
tyrus repl
  ______                         ____  __________  __ 
 /_  __/_  _________  _______   / __ \/ ____/ __ \/ / 
  / / / / / / ___/ / / / ___/  / /_/ / __/ / /_/ / /  
 / / / /_/ / /  / /_/ (__  )  / _, _/ /___/ ____/ /___
/_/  \__, /_/   \__,_/____/  /_/ |_/_____/_/   /_____/
    /____/                                            

Type :help for available commands.

tyrus> :help
Commands (prefix with :):
  :help                              Show this help
  :clear                             Clear screen and session buffer
  :load <file>                       Load and evaluate a .tyr file
  :type <expr>                       Show the inferred type of an expression
  :doc <symbol>                      Show documentation for a symbol
  :edit                              Edit session buffer in external editor ($EDITOR)
  :save <name.tyr>                   Save session buffer to ~/.tyrus/repl/<name>.tyr
  :restore <name|file> [--merge|-m]  Restore a saved session (resets first; --merge keeps the current buffer)
  :delete <name>                     Delete a saved session from ~/.tyrus/repl
  :list                              List sessions saved via :save (~/.tyrus/repl)
  :reset                             Reset the entire session
  :exit                              Exit the REPL
  :quit                              Alias for :exit
  :q                                 Alias for :exit

Multi-line input is auto-detected by bracket matching.
tyrus>

Una toolchain de lenguaje, no solo un parser

REPL interactivo y CLI

tyrus repl para evaluación JIT a través de LLVM en proceso, tyrus dev para live reload y tyrus fmt para formateo sin configuración.

Diagnósticos y tyrus explain

Códigos de error estables con tyrus explain, rangos precisos, mensajes de ayuda, ejemplos de fallo y Quick Fixes en el editor.

Editores con soporte de LSP

Completion, hover, signature help, inlay hints, semantic tokens y code actions para VS Code, Neovim, Zed, IntelliJ y Kate.

Web Playground y tests

Ejecuta en el navegador mediante WebAssembly en playground.tyruslang.org y corre suites locales con tyrus test para archivos *.test.tyr.

Formato del código

Tyrus Formatter

tyrus fmt formatea archivos `.tyr` de forma consistente y aplica las opciones de tyrus-fmt.json del proyecto.

Lee la guía del Formatter

tyrus-fmt.json

json
{
  "indent_style": "spaces",
  "indent_width": 4,
  "line_width": 90,
  "quote_style": "double"
}

Análisis de código

Tyrus Lint

tyrus lint informa problemas de estilo, corrección, seguridad, rendimiento y arquitectura. Configura la severidad de cada regla en tyrus-lint.json del proyecto.

Lee la guía de Lint

tyrus-lint.json

json
{
  "no-unused-vars": "warn",
  "no-unused-imports": "warn",
  "prefer-const": "warn",
  "no-force-unwrap": "error"
}

Baterías incluidas

Módulos nativos integrados.

Todo lo necesario para construir servicios backend resilientes, herramientas de CLI y software de sistemas ya forma parte del runtime de Tyrus.

tyrus:algorithmMás de 50 algoritmos y estructuras de datos integrados: Dijkstra, A*, Trie y árbol rojo-negro.tyrus:archiveCreación, inspección y extracción de archivos Tar y Zip.tyrus:cliPrompts interactivos en la terminal: select, multiselect, password, confirm e input.tyrus:compressCompresión y descompresión con Zstandard, Brotli, Gzip y Deflate.tyrus:cryptoArgon2, SHA-256, SHA-512, AES-GCM, HMAC, JWT, UUID v7 y CSPRNG.tyrus:dbCliente de base de datos y ORM integrados para PostgreSQL, MySQL, SQLite y MongoDB.tyrus:encodingCodificadores nativos para Hex, Base64, URL, Varint, CSV y JSON.tyrus:fsSistema de archivos síncrono y asíncrono, escritura atómica, streaming, glob y vigilancia de archivos.tyrus:httpServidor HTTP/1.1 y HTTP/2, rutas automáticas, Swagger y WebSocket.tyrus:mathConstantes, trigonometría, teoría de números, geometría y combinatoria.tyrus:memoryOperaciones deterministas de memoria: sizeOf, alignOf, zeroize, swap y replace.tyrus:netSockets TCP y UDP, resolución DNS, búsqueda inversa, ping y traceroute.tyrus:osMetadatos del sistema, núcleos de CPU, estadísticas de memoria, temperaturas y notificaciones nativas.tyrus:processProcesos secundarios, ejecución de comandos, señales y supervisión de recursos.tyrus:simdIntrínsecos portables de matemática vectorial para operaciones numéricas de alto rendimiento.tyrus:streamPrimitivas componibles de streaming binario y de texto para I/O de alto rendimiento.tyrus:taskRuntime asíncrono, ejecución en múltiples hilos, canales, mutex, rwlock y cancelación.tyrus:temporalGestión moderna de fechas, horas, duraciones y zonas horarias con sintaxis ergonómica.tyrus:testEjecutor de pruebas integrado con describe, it y expect para archivos *.test.tyr.tyrus:utilsEstilización de texto en la terminal con styleText, colores ANSI y banners ASCII FIGlet.

Feedback de seguridad mientras escribes

Los errores forman parte de la experiencia del producto.

Los diagnósticos del compilador y del linter pasan por el mismo análisis usado por la CLI y el Language Server, así que terminal y editor coinciden sobre qué está mal y cómo corregirlo.

error

tyrus
const maxUsers: u32 = "100"; 
let retries: u32 = 3;

print(retries);
text
error[E0308]: type mismatch for `maxUsers`: expected `u32`, found `string`
at /src/main.tyr:1:7
const maxUsers: u32 = "100";
      ^^^^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Empieza con un comando

shell
tyrus new

Ejecuta con un comando

shell
tyrus run

Por qué este nombre

Una roca y un dios.

Tyrus es la grafia en latín de Tiro, la ciudad fenicia cuyo nombre significa "roca". Tyr es el dios de la guerra, la justicia y el coraje en la mitología nórdica.

Pero el nombre es la unión de las iniciales de TypeScript y Rust.