Skip to content

Variáveis ​

O Tyrus fornece duas palavras-chave para declaração de bindings: const e let. Ambas impõem escopo léxico estrito e participam da checagem estática de tipos, mas diferem em mutabilidade, regras de reatribuição e requisitos de inicialização.

const vs let ​

A escolha entre const e let estabelece se um binding e seus dados subjacentes podem sofrer mutações.

Recursoconstlet
ReatribuiçãoProibida em tempo de compilaçãoPermitida
Imutabilidade profundaAplicada recursivamente a objetos e arraysNão aplicada (propriedades e elementos são mutáveis)
Inicializador obrigatórioSempre obrigatórioOpcional (let x: i32; é permitido)
ShadowingProibidoProibido

Bindings imutáveis com const ​

const declara um binding imutável cujo valor não pode ser reatribuído após a inicialização. Use const por padrão sempre que uma variável não exigir reatribuição.

tyrus
const maxRetries: i32 = 3;
const appName: string = "tyrus";

print(maxRetries); // 3
print(appName); // tyrus

Tentar atribuir um novo valor a um binding const gera erro em tempo de compilação.

error

tyrus
const maxRetries: i32 = 3;

maxRetries = 5; 
text
error[E0384]: cannot assign to immutable variable `maxRetries`
at /src/main.tyr:3:1
maxRetries = 5;
^^^^^^^^^^
help: declare `maxRetries` with `let` to allow assignment

Imutabilidade profunda com const ​

No Tyrus, const garante imutabilidade profunda. No Tyrus proíbe modificar propriedades de objetos ou elementos de arrays declarados com const.

tyrus
const numbers: i32[] = [1, 2, 3];

print(numbers[0]); // 1
print(numbers.length); // 3

Modificar um campo de objeto ou elemento de array através de uma referência const é rejeitado pelo compilador.

error

tyrus
const numbers: i32[] = [1, 2, 3];

numbers[0] = 99; 
text
error[E0384]: cannot assign through immutable `numbers`
at /src/main.tyr:3:1
numbers[0] = 99;
^^^^^^^
help: declare `numbers` with `let` to allow assignment

Bindings mutáveis com let ​

let declara um binding mutável. Ele permite tanto a reatribuição da variável quanto a mutação in-place de estruturas compostas como arrays e objetos.

tyrus
let counter: i32 = 0;
counter = 1;
counter += 2;
print(counter); // 3

let scores: i32[] = [10, 20, 30];
scores[0] = 95;
print(scores[0]); // 95

A reatribuição deve continuar respeitando o tipo estaticamente declarado ou inferido da variável.

error

tyrus
let counter: i32 = 0;

counter = "two"; 
text
error[E0308]: type mismatch for `counter`: expected `i32`, found `string`
at /src/main.tyr:3:11
counter = "two";
          ^^^^^
help: change the value or the annotation so their types match

Bindings let sem inicializador ​

Uma variável declarada com let pode ser declarada sem um inicializador imediato, mesmo para tipos não opcionais como let number: i32;. Bindings opcionais (T?) iniciam vazios e podem ser inspecionados com segurança via coalescência nula (??), enquanto bindings não opcionais devem ser atribuídos antes de serem lidos.

tyrus
let total: i32;
total = 100;
print(total); // 100

let status: string?;
print(status ?? "ready"); // ready

Ler uma variável não opcional não inicializada antes da atribuição é um erro, e declarar um const sem inicializador é proibido.

error

tyrus
let total: i32;

print(total); 
text
error[E0381]: `total` is used before being assigned a value
at /src/main.tyr:3:7
print(total);
      ^^^^^
help: assign a value to `total` before reading it

Shadowing não é permitido ​

O Tyrus não permite shadowing de variáveis no mesmo escopo. Para atualizar um valor, declare uma vinculação mutável com let e faça a reatribuição em vez de redeclarar a variável.

tyrus
let count: i32 = 1;
count = 2;

print(count); // 2

Tentar redeclarar uma variável com let ou const no mesmo escopo é rejeitado pelo compilador.

error

tyrus
let count: i32 = 1;

let count: i32 = 2; 
text
error[E0428]: identifier `count` is declared more than once in this scope
at /src/main.tyr:3:5
let count: i32 = 2;
    ^^^^^
related: previous declaration of `count` is here
at /src/main.tyr:1:5
let count: i32 = 1;
    ^^^^^

Inferência de tipos e anotações ​

Os tipos das variáveis podem ser anotados explicitamente ou inferidos automaticamente a partir da expressão do inicializador.

tyrus
const timeout: u32 = 5000;
let endpoint = "/api/v1";

print(timeout); // 5000
print(endpoint); // /api/v1

Quando uma anotação de tipo explícita é fornecida, o valor atribuído deve atender à restrição desse tipo.

error

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