Skip to content

Readonly ​

readonly trata de mutabilidade: diz que não se pode escrever através de um valor, em nenhuma profundidade. Não trata de rebinding, que é o que const e let decidem, nem de estreitar um tipo para um literal, que é o que o as const acrescenta por cima.

A palavra-chave aparece em seis lugares distintos. Todos produzem a mesma garantia, nada atrás deste valor pode receber atribuição, e diferem apenas naquilo a que se aplicam.

FormaOnde ficaO que protege
readonly id: i32propriedade de interfaceaquela propriedade, e tudo abaixo dela
readonly Configposição de tipotodo valor daquele tipo
config: readonly Configparâmetroo argumento, enquanto durar a chamada
Readonly<Config>tipo utilitáriotodas as propriedades de uma interface de uma vez
[1, 2] as constsufixo de expressãoo valor, e estreita cada elemento para o seu tipo literal
readonly const PRIMES: i32[]declaraçãoo binding, profundamente

A garantia é recursiva em todas elas. Um valor readonly um nível abaixo continua readonly, então uma escrita aninhada é recusada exatamente como a escrita de superfície.

readonly em propriedade de interface ​

A forma mais estreita: uma propriedade de uma interface. Todo o resto da interface continua gravável.

error

tyrus
interface User {
    readonly id: i32;
    name: string;
}

export function main(): void {
    let user: User = { id: 1, name: "Ada" };
    print(user.id);
    user.id = 2; 
}

error

text
error[E2542]: cannot assign to readonly property `id`
at /src/main.tyr:9:5
    user.id = 2;
    ^^^^^^^^^^^^

readonly em posição de tipo ​

Escrito antes de um tipo, readonly produz a visão somente leitura dele. Num array, isso remove os métodos que mutam.

error

tyrus
export function main(): void {
    let ports: readonly i32[] = [3000, 3001];
    print(ports[0]);
    ports.push(3002); 
}

error

text
error[E2540]: cannot call mutating method `push` on readonly array
at /src/main.tyr:4:5
    ports.push(3002);
    ^^^^^

Um valor readonly também não pode ser lavado para dentro de um binding mutável, o que devolveria justamente o acesso de escrita que o tipo recusou.

error

tyrus
readonly const PRIMES: i32[] = [2, 3, 5];

export function main(): void {
    let ps: i32[] = PRIMES; 
    print(ps[0]);
}

error

text
error[E0308]: type mismatch for `ps`: expected `i32[]`, found `readonly i32[]`
at /src/main.tyr:4:9
    let ps: i32[] = PRIMES;
        ^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

readonly em parâmetro ​

Um parâmetro recebe readonly na posição do tipo, não antes do nome. readonly config: Config é rejeitado; config: readonly Config é a forma.

tyrus
interface Config {
    port: i32;
}

const show = (config: readonly Config): void => {
    print(config.port);
};

export function main(): void {
    show({ port: 8080 });
}

Esta é a assinatura a escolher quando uma função lê um valor que não criou: quem chama enxerga só pela assinatura que o seu valor volta intacto.

error

tyrus
const bump = (config: readonly Config): void => {
    config.port = 9090; 
};

error

text
error[E0384]: cannot assign through immutable `config`
at /src/main.tyr:6:5
    config.port = 9090;
    ^^^^^^
help: declare `config` with `let` to allow assignment
error[E2541]: cannot assign to `port` through a readonly value
at /src/main.tyr:6:5
    config.port = 9090;
    ^^^^^^^^^^^^^^^^^^^
error[E0500]: cannot assign through immutable `config` (declared with `const`)
at /src/main.tyr:6:5
    config.port = 9090;
    ^^^^^^
help: declare `config` with `let` to allow mutation

Readonly<T> ​

Readonly<T> aplica o qualificador a todas as propriedades de uma interface de uma vez, em vez de uma por uma. É recursivo. A descrição completa, com os casos aninhado e de array, está na página Objetos e interfaces.

as const ​

as const faz duas coisas, e só uma delas é sobre mutabilidade. Congela o valor e estreita cada elemento para o seu próprio tipo literal: em [3000, 3001] as const o primeiro elemento tem o tipo 3000, não i32.

tyrus
export function main(): void {
    const ports = [3000, 3001] as const;
    print(ports[0]);
    print(ports.length);
}

as const não substitui readonly

Use readonly quando o ponto é que nada pode ser escrito. Use as const quando o ponto é que os valores literais exatos fazem parte do tipo. O congelamento que vem junto com as const é consequência desse estreitamento, não a sua finalidade.

readonly const ​

readonly const é a forma de declaração. O binding nunca é reatribuído, porque é um const, e nada atrás dele pode ser escrito, porque é readonly.

tyrus
readonly const PRIMES: i32[] = [2, 3, 5, 7, 11];

export function main(): void {
    print(PRIMES[3]);
    print(PRIMES.length);
}

Um readonly const global cujo inicializador é uma tabela literal não custa nada em tempo de execução: é emitido em memória somente leitura, sem alocação, sem stores de elemento e sem nada a liberar.

readonly const x: T e const x: readonly T são a mesma declaração, então o formatador fixa a primeira grafia e escreve as duas assim. O único lugar em que não faz isso é o inicializador de um for, onde a gramática só admite const e let.

A palavra-chave vem antes de const, e a ordem é verificada.

error

tyrus
const readonly PRIMES: i32[] = [2, 3, 5]; 

error

text
error[parse] in `/src/main.tyr`: `readonly` goes before `const`: write `readonly const <name>`, not `const readonly <name>`

A anotação é obrigatória, porque não há mais nada a que o qualificador possa se prender.

error

tyrus
readonly const PRIMES = [2, 3, 5]; 

error

text
error[parse] in `/src/main.tyr`: `readonly const` requires a type annotation: write `readonly const <name>: <type> = ...`

readonly qualifica apenas const. Um let pode ser reatribuído, então um let readonly prometeria algo que a linha seguinte poderia tirar, e é rejeitado.

readonly não é const ​

Os dois são fáceis de confundir porque um binding const já é profundamente imutável no tyrus. A diferença aparece assim que o valor viaja.

const é uma propriedade do binding: impede que aquele nome seja reatribuído e impede escritas através daquele nome. Não diz nada sobre o tipo, então passar o valor para uma função que recebe um parâmetro mutável é permitido.

readonly é uma propriedade do tipo: viaja com o valor para parâmetros, tipos de retorno, campos e outros bindings. É isso que o torna utilizável numa assinatura, e é isso que diferencia um readonly const de um const comum, a proteção sobrevive à entrega do valor.