Varianza en TypeScript

Dónde se acepta un subtipo, y las anotaciones que lo declaran.

interface Animal {
  name: string;
}
interface Dog extends Animal {
  breed: string;
}

type Producer<out T> = () => T;
type Consumer<in T> = (value: T) => void;

const dogProducer: Producer<Dog> = () => ({ name: "rex", breed: "lab" });
const animalProducer: Producer<Animal> = dogProducer; // covariante

const animalConsumer: Consumer<Animal> = (animal) => console.log(animal.name);
const dogConsumer: Consumer<Dog> = animalConsumer; // contravariante

const dogs: Dog[] = [{ name: "rex", breed: "lab" }];
const animals: Animal[] = dogs; // los arreglos son covariantes e inseguros
console.log(animalProducer().name, animals.length);
dogConsumer({ name: "fido", breed: "corgi" });

Cómo funciona

1. Un productor es covariante: out.
2. Un consumidor es contravariante: in.
3. Los parámetros de métodos se chequean de forma bivariante, un hueco conocido.

Palabras clave y builtins usados aquí

• Animal
• Consumer
• Dog
• Producer
• T
• const
• extends
• interface
• string
• type

El intento, en números

Líneas

20

Caracteres a escribir

678

Tokens

168

Ritmo de tres estrellas

100 tpm

Al ritmo de tres estrellas de 100 tokens por minuto, este intento toma unos 101 segundos.

Escribe este fragmento

Paso 4 de 4 en Parámetros de tipo; paso 4 de 20 en Genéricos.

← Anterior Siguiente →