Explain covariance and contravariance.

interface Animal { name: string; }
interface Bird extends Animal { wingspan: number; }
interface Dog extends Animal { bark(): void; }

// A function that returns a Bird
type GetBird = () => Bird;

// A function that returns an Animal
type GetAnimal = () => Animal;

// Covariance: GetBird is assignable to GetAnimal because Bird extends Animal.
// You can safely use a function returning a more specific type (Bird)
// where a function returning a less specific type (Animal) is expected.
let getBirdFunc: GetBird = () => ({ name: "Sparrow", wingspan: 20 });
let getAnimalFunc: GetAnimal = getBirdFunc; // OK: Covariant return type

console.log(getAnimalFunc().name); // "Sparrow"
// console.log(getAnimalFunc().wingspan); // Error: Property 'wingspan' does not exist on type 'Animal'

interface Animal { name: string; move(): void; }
interface Bird extends Animal { fly(): void; }

class GenericAnimal implements Animal {
    constructor(public name: string) {}
    move() { console.log(`${this.name} moves.`); }
}

class Eagle extends GenericAnimal implements Bird {
    constructor() { super('Eagle'); }
    fly() { console.log(`${this.name} flies high.`); }
}

// A function that processes an Animal
type ProcessAnimal = (animal: Animal) => void;

// A function that processes a Bird
type ProcessBird = (bird: Bird) => void;

// Contravariance: ProcessAnimal is assignable to ProcessBird because Animal is a supertype of Bird.
// You can safely use a function accepting a less specific type (Animal)
// where a function accepting a more specific type (Bird) is expected.
let processAnimalFunc: ProcessAnimal = (animal) => console.log(`Processing animal: ${animal.name}`);
let processBirdFunc: ProcessBird = processAnimalFunc; // OK: Contravariant parameter type (with strictFunctionTypes)

processBirdFunc(new Eagle()); // This is safe. The Animal processor can handle an Eagle.

// If we tried to do the reverse:
// let processAnimalFunc2: ProcessAnimal = processBirdFunc; // Error (with strictFunctionTypes)
// This would be unsafe: processBirdFunc expects a Bird, but processAnimalFunc2 might be called with any Animal (e.g., a Dog).

// With strictFunctionTypes: false (default for older projects or specific needs)
interface Animal { name: string; }
interface Bird extends Animal { wingspan: number; }
interface Dog extends Animal { bark(): void; }

type Handler<T> = (data: T) => void;

let handleAnimal: Handler<Animal> = (animal) => console.log(`Handling animal: ${animal.name}`);
let handleBird: Handler<Bird> = (bird) => console.log(`Handling bird: ${bird.name}, wingspan: ${bird.wingspan}`);

// Bivariance allows both of these (unsafe) assignments if strictFunctionTypes is false:
handleBird = handleAnimal; // UNSAFE! handleBird now expects a Bird, but handleAnimal can only process generic Animal properties
// If handleBird is later called with a Bird, handleAnimal is invoked, and it won't crash,
// but if handleAnimal was expecting specific Bird properties, it would be an issue.

handleAnimal = handleBird; // UNSAFE! handleAnimal now expects any Animal, but handleBird expects a Bird.
// If handleAnimal is later called with a Dog, handleBird is invoked on a Dog, which doesn't have `wingspan`, leading to runtime error.

interface Animal { name: string; }
interface Bird extends Animal { wingspan: number; }
interface Dog extends Animal { bark(): void; }

let birds: Bird[] = [
    { name: "Eagle", wingspan: 200 }
];

let animals: Animal[] = [
    { name: "Lion" }
];

// Invariance for mutable arrays:
// birds = animals; // Error: Type 'Animal[]' is not assignable to type 'Bird[]'.
                   // An array of Animals could contain non-Birds (e.g., Dogs).

// animals = birds; // Error: Type 'Bird[]' is not assignable to type 'Animal[]'.
                   // This one is actually allowed in TypeScript by default (Array is covariant for read access)
                   // but pushing a Dog to 'animals' would then make 'birds' contain a Dog, which is unsound for writing.
                   // For true invariance (blocking both ways), you'd need a more complex type or `ReadonlyArray`.

// TypeScript's `ReadonlyArray<T>` is covariant, meaning `ReadonlyArray<Bird>` IS assignable to `ReadonlyArray<Animal>`.
// This is safe because you can only read from it, never write.
let readonlyBirds: ReadonlyArray<Bird> = [
    { name: "Falcon", wingspan: 110 }
];

let readonlyAnimals: ReadonlyArray<Animal> = readonlyBirds; // OK: ReadonlyArray is covariant

// readonlyAnimals[0].wingspan; // Error: Property 'wingspan' does not exist on type 'Animal'