TypeScript Intersection: Why is a function & string not never?

In TypeScript, the intersection of a function type and a string type is not never because intersections can be non-empty sets of types, and the type system in TypeScript allows for certain combinations that may seem counterintuitive at first.

When you intersect a function type with a string type, the resulting type includes all properties and methods from both types. Here's an example to illustrate this behavior:

typescriptCopy code
type MyFunction = () => void;

const myFunction: MyFunction = () => {
  console.log('This is a function.');
};

type MyString = string;

const myString: MyString = 'This is a string.';

type IntersectionType = MyFunction & MyString;

const myIntersection: IntersectionType = {
  // The function properties
  (): void => {
    console.log('This is a function from the intersection.');
  },
  length: 0, // The string property
};

In this example, we define a MyFunction type representing a function that takes no arguments and returns void, and a MyString type representing a string. Then, we intersect these two types into IntersectionType, which combines all the properties of both types. The resulting IntersectionType includes both the function properties and the string property.

As a result, the intersection type is not never, but rather a type that represents the combination of both the function and string types. However, keep in mind that this type may not be particularly useful in practical scenarios, and it's essential to understand how intersections work to avoid unintended behavior in your code.

If you want to check if a type is an intersection of a function and a string (or any other types), you can use TypeScript's & operator to create a conditional type that checks for intersections:

typescriptCopy code
type IsIntersection<T> = T extends any ? (T & any) extends T ? true : false : false;

// Usage
type MyFunction = () => void;
type MyString = string;

const isFunctionAndString = IsIntersection<MyFunction & MyString>; // true
const isNumberAndString = IsIntersection<number & MyString>; // false

With this conditional type IsIntersection, you can check if a type is an intersection of any two types, including a function type and a string type.