Challenge 2: Variance

Solve a task testing variance rules.

Variance: covariance and contravariance

Variance describes how parameterized types propagate subtype relationships. Producers are covariant: Producer<Dog> is assignable to Producer<Animal>. Consumers are contravariant: Consumer<Animal> is assignable to Consumer<Dog>.

type Producer<T> = () => T;
type Consumer<T> = (x: T) => void;

let pA: Producer<Animal>;
let pD: Producer<Dog>;
pA = pD;  // OK (covariance)

With strictFunctionTypes on, function parameters are strictly contravariant; class methods stay bivariant.

Exercise Demonstrate covariance

Define an Animal class (field name = "hayvan") and Dog extends Animal. Write Producer<T> = () => T. Create a pDog: Producer<Dog> value, assign it to pAnimal: Producer<Animal> (covariance), and print pAnimal().name.

Show example solution

class Animal { name = "hayvan"; }
class Dog extends Animal { bark() {} }

type Producer<T> = () => T;

const pDog: Producer<Dog> = () => new Dog();
let pAnimal: Producer<Animal>;
pAnimal = pDog;
console.log(pAnimal().name);

Exercise Demonstrate contravariance

Define an Animal class (field name = "h") and Dog extends Animal. Write Consumer<T> = (x: T) => void. Make a cAnimal: Consumer<Animal> value that does console.log("yedi " + x.name). Assign cAnimal to cDog: Consumer<Dog> (contravariance) and call cDog(new Dog()).

Show example solution

class Animal { name = "h"; }
class Dog extends Animal {}

type Consumer<T> = (x: T) => void;

const cAnimal: Consumer<Animal> = (x) => { console.log("yedi " + x.name); };
let cDog: Consumer<Dog>;
cDog = cAnimal;
cDog(new Dog());

Test yourself

With `strictFunctionTypes` on, which assignment compiles?
```
type Consumer<T> = (x: T) => void;
class Animal { name = "a"; }
class Dog extends Animal {}
let cAnimal: Consumer<Animal>;
let cDog: Consumer<Dog>;
```
- Neither compiles
- cAnimal = cDog;
- cDog = cAnimal;
- Both cAnimal = cDog; and cDog = cAnimal;
Show answer

cDog = cAnimal; — Consumer types are contravariant; the more general `Consumer<Animal>` is assignable to the more specific `Consumer<Dog>`, not the other way.

Consumer definition

// T'yi parametre olarak tüketen fonksiyon
type Consumer<T> = (x: ____) => void;

Show answer

// T'yi parametre olarak tüketen fonksiyon
type Consumer<T> = (x: T) => void;

Variance concepts

Kovaryans

subtype relation of produced value propagates
Kontravaryans

relation of consumed parameter reverses
Bivaryans

both covariance and contravariance accepted
strictFunctionTypes

makes function parameters strict

Next lesson: Challenge 3: Branded + phantom

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies