Skip to content

Sintaxe TypeScriptSemântica RustUma linguagem de programação feita para devs

Logotipo do Tyrus

Linguagem backend compilada

Escreva código familiar em .tyr

Tyrus usa sintaxe concisa em arquivos .tyr e adiciona execução nativa, semântica de memória determinística com NLL, diagnósticos precisos e tooling focado em backend.

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

Superpoderes da linguagem

Validator decorations

Regras embutidas como @email, @minLength e @min, além de validações customizadas com validator function. Validação declarativa sem boilerplate em runtime.

Comptime em compilação

Execute lógica pura durante a compilação com comptime(...). Pré-compute tabelas de lookup, constantes e configurações com zero custo em runtime.

Env selado e espelho

Criptografe o .env em target/<profile>/.env.sealed com impressões digitais binárias. O espelho .env.example é sincronizado automaticamente a cada mudança.

Tipos

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

Segurança determinística de memória

Ownership, borrowing e NLL.

Segurança de memória sem garbage collector. Tipos que não são Copy movem por atribuição, enquanto empréstimos são validados em compilação. Com Non-Lexical Lifetimes (NLL), os empréstimos expiram após o último uso real, liberando variáveis para mutação imediata sem esperar o término do bloco.

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

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

Limpeza por escopo

Execute a limpeza sempre ou somente em erros.

defer executa quando o escopo termina. errdefer executa apenas quando um retorno opcional ou Result sai com erro, deixando o rollback explícito.

Saiba mais sobre limpeza adiada

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 exaustivo

Combine qualquer forma. Estreite cada branch.

Unions marcadas, variantes de enums algébricos e match com guard clauses dão controle de fluxo exaustivo. O compilador garante que toda variante é tratada e estreita os tipos em cada ramo.

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

Sem null. Sem undefined. Só T?

Ausência é um estado, não um valor.

Um return; vazio produz ausência. ?. e ?? propagam de forma segura. O compilador força você a tratar o caso ausente antes que o valor chegue em produção, sem surpresas em 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

Sucesso e falha explícitos

Represente erros recuperáveis com Result.

Result<T, E> contém um valor Ok ou um valor Err. Combine as duas variantes ou propague o erro com ?.

Saiba mais 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
    }
};

Tratamento de erros no ponto de chamada

Mantenha o caminho de sucesso claro com onfail.

Anexe um handler de erro ao inicializador de um Result. O handler recebe o erro, enquanto a variável contém o valor de sucesso quando a execução continua.

Saiba mais 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

Dados fluem de cima para baixo.

O operador |> encadeia valores em cadeias de função. O token % permite posicionar o valor pipeado exatamente onde ele deve ficar, sem variáveis intermediárias, sem aninhamento.

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 assíncrono nativo

Escreva funções async e aguarde seus resultados.

Funções async retornam Promise<T>. Use await para ler o valor quando a operação assíncrona terminar.

Saiba mais sobre async e 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 alta performance

Métodos algébricos de ponto flutuante.

Os primitivos f32 e f64 fornecem algebraicAdd, algebraicSub, algebraicMul, algebraicDiv e algebraicRem. Eles concedem permissão explícita ao compilador para reassociar cálculos de ponto flutuante para vetorização SIMD e aceleração matemática em 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
};

Proteção de segredos em produção

Env selado e .env.example sincronizado.

A configuração security.envSealed criptografa o .env em target/<profile>/.env.sealed com chaves assimétricas e insere uma impressão digital no binário para que contêineres nunca exponham segredos em texto puro. Em desenvolvimento, o compilador espelha chaves e comentários em .env.example com valores limpos automaticamente.

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 e ODM tipados

Use uma API de Model com SQL e MongoDB.

Defina Models como interfaces tipadas e consulte-os de forma assíncrona. A mesma API de Model funciona em bancos relacionais e MongoDB, com falhas recuperáveis retornadas em Result.

Explore o módulo de banco de dados

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

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

Avaliação em tempo de compilação

Execute código durante a compilação. Custo zero em runtime.

Funções declaradas com comptime executam durante a compilação e incorporam seu resultado como escalares ou literais estáticos diretamente no binário. Calcule tabelas de lookup, constantes matemáticas e configurações com tipagem 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
};

Exploração interativa

Experimente no terminal. Execute no navegador.

Explore o Tyrus instantaneamente sem configurar projetos. O tyrus repl fornece um console interativo com avaliação JIT via LLVM em processo, edição multilinha, persistência de sessões e inspeção com :type. Prefere o navegador? Abra o Web Playground em playground.tyruslang.org para escrever, compilar para WebAssembly e rodar código direto no navegador com links compartilháveis.

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>

Uma toolchain de linguagem, não só um parser

REPL interativo e CLI

tyrus repl para avaliação JIT via LLVM em processo, tyrus dev para live reload e tyrus fmt para formatação sem configuração.

Diagnósticos e tyrus explain

Códigos de erro estáveis com tyrus explain, ranges precisos, mensagens de ajuda, exemplos de falha e Quick Fixes no editor.

Editores com suporte a LSP

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

Web Playground e testes

Execute no navegador via WebAssembly em playground.tyruslang.org e rode suítes locais com tyrus test para arquivos *.test.tyr.

Formatação de código

Tyrus Formatter

tyrus fmt formata arquivos `.tyr` de maneira consistente e aplica as opções do tyrus-fmt.json do projeto.

Leia o guia do Formatter

tyrus-fmt.json

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

Análise de código

Tyrus Lint

tyrus lint aponta problemas de estilo, correção, segurança, desempenho e arquitetura. Defina a severidade de cada regra em tyrus-lint.json no projeto.

Leia o guia do Lint

tyrus-lint.json

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

Baterias incluídas

Módulos nativos integrados.

Tudo o que é necessário para construir serviços backend resilientes, ferramentas de CLI e software de sistemas já faz parte do runtime do Tyrus.

tyrus:algorithmMais de 50 algoritmos e estruturas de dados integrados: Dijkstra, A*, Trie e árvore rubro-negra.tyrus:archiveCriação, inspeção e extração de arquivos Tar e Zip.tyrus:cliPrompts interativos no terminal: select, multiselect, password, confirm e input.tyrus:compressCompressão e descompressão em Zstandard, Brotli, Gzip e Deflate.tyrus:cryptoArgon2, SHA-256, SHA-512, AES-GCM, HMAC, JWT, UUID v7 e CSPRNG.tyrus:dbCliente de banco de dados e ORM integrados para PostgreSQL, MySQL, SQLite e MongoDB.tyrus:encodingCodificadores nativos para Hex, Base64, URL, Varint, CSV e JSON.tyrus:fsSistema de arquivos síncrono e assíncrono, gravação atômica, streaming, glob e monitoramento de arquivos.tyrus:httpServidor HTTP/1.1 e HTTP/2, rotas automáticas, Swagger e WebSocket.tyrus:mathConstantes, trigonometria, teoria dos números, geometria e combinatória.tyrus:memoryOperações determinísticas de memória: sizeOf, alignOf, zeroize, swap e replace.tyrus:netSockets TCP e UDP, resolução DNS, busca reversa, ping e traceroute.tyrus:osMetadados do sistema, núcleos de CPU, estatísticas de memória, temperaturas e notificações nativas.tyrus:processProcessos filhos, execução de comandos, sinais e monitoramento de recursos.tyrus:simdIntrínsecos portáveis de matemática vetorial para operações numéricas de alto desempenho.tyrus:streamPrimitivas componíveis de streaming binário e de texto para I/O de alto desempenho.tyrus:taskRuntime assíncrono, criação de tarefas em múltiplas threads, canais, mutex, rwlock e cancelamento.tyrus:temporalGerenciamento moderno de datas, horários, durações e fusos horários com sintaxe ergonômica.tyrus:testExecutor de testes integrado com describe, it e expect para arquivos *.test.tyr.tyrus:utilsEstilização de texto no terminal com styleText, cores ANSI e banners ASCII FIGlet.

Feedback de segurança enquanto você digita

Erros fazem parte da experiência do produto.

Diagnósticos do compilador e do linter passam pela mesma análise usada pela CLI e pelo Language Server, então terminal e editor concordam sobre o que está errado e como corrigir.

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>`

Comece com um comando

shell
tyrus new

Execute com um comando

shell
tyrus run

Por que esse nome

Uma rocha e um deus.

Tyrus é a grafia em latim de Tiro, a cidade fenícia cujo nome significa "rocha". Tyr é o deus da guerra, da justiça e da coragem na mitologia nórdica.

Mas o nome é a junção das iniciais de TypeScript e Rust.