O que é variância de tipo (covariância e contravariância)?

Question

Accepted Answer

**Variância** descreve como a subtipagem de um tipo composto se relaciona com a subtipagem de suas partes — ou seja, quando `Container_{` é atribuível a `Container`?

Seja `Dog` um subtipo de `Animal`.

## Covariância — preserva direção (o caso intuitivo)

```ts
let dogs: Dog[] = [];
let animals: Animal[] = dogs; // ✅ Dog[] is assignable to Animal[]
```

Tipos de retorno e arrays são **covariantes**: se `Dog` ⊆ `Animal`, então `Dog[]` ⊆ `Animal[]`. Uma função que retorna `Dog` é utilizável onde se espera uma que retorna `Animal`.

## Contravariância — inverte direção (parâmetros de função)

```ts
type Handler = (arg: T) => void;
let animalHandler: Handler = (a) => {};
let dogHandler: Handler = animalHandler; // ✅ (with strictFunctionTypes)
// a handler that accepts ANY Animal can safely handle a Dog
```

**Parâmetros** de função são contravariantes: `Handler` é atribuível a `Handler`, o *inverso* da relação de elementos. Isto é correto — algo que trata todos os animais certamente trata cães.

## O padrão inseguro para métodos

```ts
// Method parameters in TS are bivariant by default (a known unsound convenience)
interface Comparer { compare(a: T): void; }
```

TypeScript verifica tipos de função autonomia contravariantes apenas sob `strictFunctionTypes`; parâmetros de método são intencionalmente **bivariantes** por ergonomia, o que tecnicamente é inseguro.

## Por que isso importa

Variância explica *por que* certas atribuições são permitidas ou rejeitadas — por que `Dog[]` se ajusta a `Animal[]` mas um callback `(d: Dog) => void` nem sempre pode substituir `(a: Animal) => void`.

Compreender isso ajuda você a projetar APIs genéricas (por ex. posições somente leitura vs. escrita) e decodificar erros confusos "not assignable" envolvendo funções e genéricos.}