Summary - Variance

Write a program comparing variance rules.

Summary - Variance

Variance rules describe how a subtype relationship propagates to function types. Covariance keeps the relationship in the same direction (return type, arrays). Contravariance reverses it (parameter type, under strictFunctionTypes). Bivariance accepts both directions (method shorthand or strict off).

class Animal {}
class Dog extends Animal {}

// Covariance (return type):
const a: () => Animal = () => new Dog();

// Contravariance (parameter, under strict):
const b: (d: Dog) => void = (x: Animal) => {};

// Bivariance (method shorthand):
interface Kennel { keep(d: Dog): void; }
const k: Kennel = { keep(x: Animal) {} };

Exercise Show all three rules in one program

Define a Dog class extending Animal. Show three things: (1) Covariance: assign a () => Dog function to a () => Animal type and print the name of the returned object. (2) Contravariance: assign a (a: Animal) => void function to a (d: Dog) => void type. (3) Bivariance: write a Kennel interface with a keep(d: Dog): void method and implement it as keep(a: Animal) {}. Print the labels "covariance", "contravariance", "bivariance" via console.log before each section.

Show example solution

class Animal {
  name = "animal";
}

class Dog extends Animal {}

console.log("covariance");
const makeAnimal: () => Animal = () => new Dog();
console.log(makeAnimal().name);

console.log("contravariance");
const dogHandler: (d: Dog) => void = (a: Animal) => {};
dogHandler(new Dog());

console.log("bivariance");
interface Kennel {
  keep(d: Dog): void;
}
const k: Kennel = {
  keep(a: Animal) {}
};
k.keep(new Dog());

Test yourself

How is the return type checked in a function type (with strictFunctionTypes on)?
- Invariant
- Contravariant
- Covariant
- Bivariant
Show answer

Covariant — The return type is always checked covariantly; a function returning a subtype is assignable where a supertype return is expected.

Which type for a contravariant parameter

class Animal {}
class Dog extends Animal {}

// Contravariance örneği: h, Dog beklerken implementation Animal kabul eder
const h: (d: Dog) => void = (x: ____) => {};

Show answer

class Animal {}
class Dog extends Animal {}

// Contravariance örneği: h, Dog beklerken implementation Animal kabul eder
const h: (d: Dog) => void = (x: Animal) => {};

Variance rules matching

Dönüş türü

Covariance
Parametre (strict altında)

Contravariance
Method shorthand

Bivariance
Dog döndüren fonksiyon

assignable to Animal-returning expectation

Next lesson: What is a branded type?

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies