Variance: Covariance & Contravariance

1// Setup: type hierarchy
2interface Animal { name: string; }
3interface Dog extends Animal { breed: string; }
4interface Cat extends Animal { indoor: boolean; }
5
6// COVARIANCE — return/output position
7// Dog extends Animal → (() => Dog) extends (() => Animal)
8type AnimalFactory = () => Animal;
9type DogFactory = () => Dog;
10
11const makeDog: DogFactory = () => ({ name: "Rex", breed: "Lab" });
12const makeAnimal: AnimalFactory = makeDog; // ✅ Covariant!
13// A function that returns a Dog can be used where Animal is expected
14
15// CONTRAVARIANCE — parameter/input position (with strictFunctionTypes)
16// Dog extends Animal → ((a: Animal) => void) extends ((d: Dog) => void)
17type AnimalHandler = (animal: Animal) => void;
18type DogHandler = (dog: Dog) => void;
19
20const handleAnimal: AnimalHandler = (a) => console.log(a.name);
21const handleDog: DogHandler = handleAnimal; // ✅ Contravariant!
22// A handler for ANY animal can handle a Dog
23// const reverseHandleDog: AnimalHandler = handleDog; // ❌ Not safe!
24
25// Why contravariance for parameters is SAFE:
26function feedAnimal(handler: (a: Animal) => void) {
27  handler({ name: "Mystery Animal" }); // Might not be a Dog!
28}
29// If we allowed DogHandler here, handler would expect .breed — crash!
30
31// Array covariance (TypeScript is pragmatically unsound here)
32const dogs: Dog[] = [{ name: "Rex", breed: "Lab" }];
33const animals: Animal[] = dogs; // ✅ TypeScript allows this
34// animals.push({ name: "Kitty" }); // 😱 No breed! Runtime bug
35// This is a known unsoundness in TypeScript — pragmatism over purity
36
37// TypeScript 4.7+ explicit variance annotations
38interface Producer<out T> {   // Covariant — only outputs T
39  get(): T;
40}
41interface Consumer<in T> {    // Contravariant — only inputs T
42  accept(value: T): void;
43}
44interface Processor<in out T> { // Invariant — both inputs and outputs T
45  process(value: T): T;
46}
47
48// Practical: event handler variance
49interface EventMap {
50  click: MouseEvent;
51  keydown: KeyboardEvent;
52}
53
54// Contravariant parameter: handler for Event (base) works for MouseEvent
55type BaseHandler = (e: Event) => void;
56type ClickHandler = (e: MouseEvent) => void;
57
58const onClick: ClickHandler = (e) => console.log(e.clientX);
59const onEvent: BaseHandler = (e) => console.log(e.type);
60// const clickFromBase: ClickHandler = onEvent; // ✅ Safe in strict mode