Объясните variance и assignability в TypeScript: что это, как работает и когда применять.

Dog <: Animal            (Dog is a subtype of Animal)

Array<Dog>   <: Array<Animal>        ✅ covariant   — flows the same direction
(x: Animal)=>void <: (x: Dog)=>void  ✅ contravariant — flows the OPPOSITE direction

interface Handler<T> { handle(x: T): void }   // method → bivariant
type HandlerFn<T> = { handle: (x: T) => void } // property fn → contravariant

class Animal { legs = 4 }
class Dog extends Animal { bark() {} }

// Covariance — return/read positions flow with the subtype
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs;   // ✅ Array is (unsoundly) covariant

// The classic hole this opens:
animals.push(new Animal());       // ✅ compiles… but dogs now holds a non-Dog
dogs[1].bark();                   // 💥 runtime crash — bark is undefined

// Contravariance — a broader consumer is a valid narrower consumer
type Listener = (e: MouseEvent) => void;
const broad = (e: Event) => {};
const l: Listener = broad;         // ✅ accepting more is safe

// strictFunctionTypes catches the UNSAFE direction on function-typed params:
type Narrow = (e: MouseEvent) => void;
const wide: (e: Event) => void = (e: MouseEvent) => e.button; // ❌ error under strict