Skip to content

Readonly ​

readonly trata de mutabilidad: dice que no se puede escribir a través de un valor, a ninguna profundidad. No trata del rebinding, que es lo que deciden const y let, ni de estrechar un tipo a un literal, que es lo que agrega as const.

La palabra clave aparece en seis lugares distintos. Todos producen la misma garantía, nada detrás de este valor puede recibir una asignación, y difieren solo en aquello a lo que se aplican.

FormaDónde vaQué protege
readonly id: i32propiedad de interfazesa propiedad, y todo lo que hay debajo
readonly Configposición de tipotodo valor de ese tipo
config: readonly Configparámetroel argumento, mientras dure la llamada
Readonly<Config>tipo utilitariotodas las propiedades de una interfaz a la vez
[1, 2] as constsufijo de expresiónel valor, y estrecha cada elemento a su tipo literal
readonly const PRIMES: i32[]declaraciónel binding, en profundidad

La garantía es recursiva en todas ellas. Un valor readonly un nivel más abajo sigue siendo readonly, así que una escritura anidada se rechaza igual que la escritura de superficie.

readonly en propiedad de interfaz ​

La forma más estrecha: una propiedad de una interfaz. Todo lo demás de la interfaz sigue siendo escribible.

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 en posición de tipo ​

Escrito antes de un tipo, readonly produce la vista de solo lectura de él. En un array esto quita los métodos que mutan.

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);
    ^^^^^

Un valor readonly tampoco puede colarse dentro de un binding mutable, lo que devolvería justamente el acceso de escritura que el tipo rechazó.

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 en parámetro ​

Un parámetro recibe readonly en la posición del tipo, no antes del nombre. readonly config: Config se rechaza; config: readonly Config es la forma.

tyrus
interface Config {
    port: i32;
}

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

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

Esta es la firma que conviene cuando una función lee un valor que no creó: quien llama ve solo por la firma que su valor vuelve 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 el calificador a todas las propiedades de una interfaz a la vez, en lugar de una por una. Es recursivo. La descripción completa, con los casos anidado y de array, está en la página Objetos e interfaces.

as const ​

as const hace dos cosas, y solo una de ellas es sobre mutabilidad. Congela el valor y estrecha cada elemento a su propio tipo literal: en [3000, 3001] as const el primer elemento tiene el tipo 3000, no i32.

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

as const no sustituye a readonly

Use readonly cuando el punto sea que nada puede escribirse. Use as const cuando el punto sea que los valores literales exactos forman parte del tipo. El congelamiento que viene con as const es consecuencia de ese estrechamiento, no su finalidad.

readonly const ​

readonly const es la forma de declaración. El binding nunca se reasigna, porque es un const, y nada detrás de él puede escribirse, porque es readonly.

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

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

Un readonly const global cuyo inicializador es una tabla literal no cuesta nada en tiempo de ejecución: se emite en memoria de solo lectura, sin asignación, sin stores de elemento y sin nada que liberar.

readonly const x: T y const x: readonly T son la misma declaración, así que el formateador fija la primera grafía y escribe ambas así. El único lugar donde no lo hace es el inicializador de un for, donde la gramática solo admite const y let.

La palabra clave va antes de const, y el orden se verifica.

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

La anotación es obligatoria, porque no hay nada más a lo que el calificador pueda sujetarse.

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 califica solo a const. Un let puede reasignarse, así que un let readonly prometería algo que la línea siguiente podría quitar, y se rechaza.

readonly no es const ​

Los dos se confunden fácilmente porque un binding const ya es profundamente inmutable en tyrus. La diferencia aparece en cuanto el valor viaja.

const es una propiedad del binding: impide que ese nombre se reasigne e impide escrituras a través de ese nombre. No dice nada sobre el tipo, así que pasar el valor a una función que recibe un parámetro mutable está permitido.

readonly es una propiedad del tipo: viaja con el valor a parámetros, tipos de retorno, campos y otros bindings. Eso es lo que lo hace utilizable en una firma, y lo que diferencia un readonly const de un const común, la protección sobrevive a la entrega del valor.