Creating a Type in TypeScript to Express “Any Subtype of T”

Question

How can I define a type in TypeScript that expresses “any subtype of T”, where T is the formal type parameter of a generic type? Additionally, I need to ensure strict subtyping, meaning that instances of type T are not to be allowed.

Answer

Defining a type that expresses “any subtype of T” in TypeScript can be challenging due to the language’s type system limitations. However, with some creativity, we can achieve the desired behavior.

Detailed Explanation

The problem at hand is to define a type AnySubtypeOf<T> that represents any subtype of T but not T itself. This is a common scenario in class hierarchies where you want to enforce that certain arrays or collections only contain instances of subclasses.

Example Use Case

Let’s consider the following classes:

ssssclass A {
  // properties and methods
}

class B extends A {
  // properties and methods
}

class C extends A {
  // properties and methods
}

class D {
  // properties and methods
}

We want to enforce that an instance of Parent<A> can have children that are instances of B or C, but not A or any unrelated class like D.

Step-by-Step Solution

1. Defining AnySubtypeOf<T>: We need a type that represents strict subtypes of T. We can achieve this by creating a conditional type that excludes T itself from the possible subtypes.
2. Utilizing Conditional Types: TypeScript’s conditional types can help us define AnySubtypeOf<T> by excluding T itself.

Here’s the implementation:

type AnySubtypeOf<T> = T extends infer U ? U extends T ? (T extends U ? never : U) : never : never;

class Parent<T> {
  content: T;
  children: AnySubtypeOf<T>[];

  constructor(parent: Parent<T>) {
    this.content = parent.content;
    this.children = parent.children;
  }
}

// Usage example
const a = new A();
const b = new B();
const c = new C();
const d = new D();

new Parent<A>({ content: a, children: [b, c] }); // ✅ Valid
new Parent<A>({ content: a, children: [b, d] }); // ❌ Invalid - d is not a subclass of A
new Parent<A>({ content: a, children: [b, a] }); // ❌ Invalid - a is not a strict subclass of A

Explanation

• AnySubtypeOf<T>: This type uses conditional types and type inference to exclude T itself. The key part is (T extends U ? never : U), which ensures that if U is exactly T, it evaluates to never, effectively excluding T from the possible types.
• Parent<T> Class: This class has a content of type T and children of type AnySubtypeOf<T>[]. The constructor initializes these properties.

Conclusion

Defining AnySubtypeOf<T> in TypeScript enhances type safety by ensuring that collections of type T only contain strict subtypes. This approach leverages TypeScript’s advanced type system features, such as conditional types and type inference, to achieve the desired behavior.

Useful Links

• TypeScript Handbook: Conditional Types
• TypeScript Handbook: Generics
• TypeScript: Exclude Utility Type