What is preventing the TypeScript program below from generating a type error?

Question

What is preventing the TypeScript program below from generating a type error?

interface Eq<A> {
  eq(this: A, that: A): boolean;
};

class Pair<A> implements Eq<Pair<A>> {
  constructor(public x: A, public y: A) {}

  eq(this: Pair<A>, that: Pair<A>): boolean {
    return this.x === that.x && this.y === that.y;
  }
}

class Triple<A> implements Eq<Triple<A>> {
  constructor(public x: A, public y: A, public z: A) {}

  eq(this: Triple<A>, that: Triple<A>): boolean {
    return this.x === that.x && this.y === that.y && this.z === that.z;
  }
}

const eq = <A extends Eq<A>>(x: A, y: A): boolean => x.eq(y);

console.log(eq(new Pair(1, 2), new Triple(1, 2, 3)));
console.log(eq(new Triple(1, 2, 3), new Pair(1, 2)));

I find it surprising that there are no type errors thrown by the TypeScript compiler in the last two lines of code. In theory, applying the eq function to different types should result in an error. The actual output from the program is a mix of true and false.

What might be causing the TypeScript compiler to overlook these type errors in the given program? Is there a way to configure it to detect and flag such discrepancies?

typescript generics interface typeerror type-safety

Answer 1

Answer №1

The code successfully compiles thanks to the utilization of structural subtyping in TypeScript, a concept that differs from nominal subtyping found in many other programming languages.

It's important to note that the Triple class can be assigned to a variable of type Pair:

const p: Pair<number> = new Triple(1, 2, 3);

In the provided example:

console.log(eq(new Pair(1, 2), new Triple(1, 2, 3)));
console.log(eq(new Triple(1, 2, 3), new Pair(1, 2)));

The type of eq is automatically inferred as:

const eq: <Pair<number>>(x: Pair<number>, y: Pair<number>) => boolean

This demonstrates that Triple is an acceptable argument for a parameter of type Pair, ensuring smooth compilation.

To mimic nominal subtyping, you could introduce a different private field in your classes. In this specific instance, you have two potential options:

Include an additional marker field
Privatize x, y, and z, then provide getters

For more insights on enforcing nominal typing in TypeScript, refer to Can I force the TypeScript compiler to use nominal typing?

Answer 2

The code successfully compiles thanks to the utilization of structural subtyping in TypeScript, a concept that differs from nominal subtyping found in many other programming languages.

It's important to note that the Triple class can be assigned to a variable of type Pair:

const p: Pair<number> = new Triple(1, 2, 3);

In the provided example:

console.log(eq(new Pair(1, 2), new Triple(1, 2, 3)));
console.log(eq(new Triple(1, 2, 3), new Pair(1, 2)));

The type of eq is automatically inferred as:

const eq: <Pair<number>>(x: Pair<number>, y: Pair<number>) => boolean

This demonstrates that Triple is an acceptable argument for a parameter of type Pair, ensuring smooth compilation.

To mimic nominal subtyping, you could introduce a different private field in your classes. In this specific instance, you have two potential options:

Include an additional marker field
Privatize x, y, and z, then provide getters

For more insights on enforcing nominal typing in TypeScript, refer to Can I force the TypeScript compiler to use nominal typing?

Answer 3

Answer №2

Initially, my vote goes to appreciating @VLAZ for the insightful comments.

It seems that both Pair and Triple are implementing Eq, which could explain why there isn't a compilation error.

In addition, according to @VLAZ's comment, it appears that TS does not provide support for higher kinded types.

Given the usage of F-bounded polymorphism, it might be beneficial to offer TS a hint regarding the second argument.

interface Eq<A> {
  eq(this: A, that: A): boolean;
};

class Pair<A> implements Eq<Pair<A>> {
  constructor(public x: A, public y: A) { }

  eq(this: Pair<A>, that: Pair<A>): boolean {
    return this.x === that.x && this.y === that.y;
  }
}

class Triple<A> implements Eq<Triple<A>> {
  constructor(public x: A, public y: A, public z: A) { }

  eq(this: Triple<A>, that: Triple<A>): boolean {
    return this.x === that.x && this.y === that.y && this.z === that.z;
  }
}

// hint is here :D
const eq = <Fst extends Eq<Fst>, Scd extends Eq<Scd> & Fst>(x: Fst, y: Scd): boolean => x.eq(y);

const x = eq(new Pair(1, 2), new Triple(1, 2, 3)); // ok
const y = eq(new Triple(1, 2, 3), new Pair(1, 2)); // error

This may not be a comprehensive solution but I hope it provides some useful pointers.

Answer 4

Initially, my vote goes to appreciating @VLAZ for the insightful comments.

It seems that both Pair and Triple are implementing Eq, which could explain why there isn't a compilation error.

In addition, according to @VLAZ's comment, it appears that TS does not provide support for higher kinded types.

Given the usage of F-bounded polymorphism, it might be beneficial to offer TS a hint regarding the second argument.

interface Eq<A> {
  eq(this: A, that: A): boolean;
};

class Pair<A> implements Eq<Pair<A>> {
  constructor(public x: A, public y: A) { }

  eq(this: Pair<A>, that: Pair<A>): boolean {
    return this.x === that.x && this.y === that.y;
  }
}

class Triple<A> implements Eq<Triple<A>> {
  constructor(public x: A, public y: A, public z: A) { }

  eq(this: Triple<A>, that: Triple<A>): boolean {
    return this.x === that.x && this.y === that.y && this.z === that.z;
  }
}

// hint is here :D
const eq = <Fst extends Eq<Fst>, Scd extends Eq<Scd> & Fst>(x: Fst, y: Scd): boolean => x.eq(y);

const x = eq(new Pair(1, 2), new Triple(1, 2, 3)); // ok
const y = eq(new Triple(1, 2, 3), new Pair(1, 2)); // error

This may not be a comprehensive solution but I hope it provides some useful pointers.

What is preventing the TypeScript program below from generating a type error?

Answer №1

Answer №2

Similar questions

Dynamically change or reassign object types in TypeScript

Can I include `ChangeDetectorRef` in an Angular 4 service constructor?

send mouse event to component when clicked

Enforce numerical input in input field by implementing a custom validator in Angular 2

Angular is failing to detect a change in the initial element of an array

Tips for minimizing a collection of objects?

Comparing Static Factory Methods and Constructors

Why is it that in reactive forms of Angular, the parameter being passed in formControlName is passed as a string?

What is the reason for TypeScript's prioritization of arguments over assignment in generic inference?

Updating Angular 8 Component and invoking ngOninit

A guide on effectively utilizing BehaviorSubject for removing items from an array

Gain insights on Stripe Webhooks with Firebase Functions and Node.js

quickest method for retrieving a property by name, regardless of its location within the object hierarchy

Unlocking the power of asynchronous methods within the useEffect() hook

Clicking on an element- how can I find the nearest element?

Typescript error in React: The element is implicitly of type any because a string expression cannot be used to index type {}

How can we make sure that a specific type member is present in an object in TypeScript?

I keep encountering the issue where nothing seems to be accessible

What is the solution for correcting a glitch in smooth scrolling behavior that occurs following the page's initial rendering?

The Javascript IIFE prohibits accessing a variable before it has been initialized