Why does TS allow interface multiple inheritance?

If the TypeScript supported multiple inheritance of classes, the diamond problem would be possible.

class A {
    f() {
        // Some implementation
    }
}

class B extends A {
    f() {
        // Overridden implementation of A.f()
    }
}

class C extends A {
    f() {
        // Overridden implementation of A.f()
    }
}

class D extends B, C {
    // Do not override the implementation of f()
}

let d: D = new D();
d.f(); // It is not clear which function to call (from A, B, or C).

In the case of interface inheritance, this problem does not arise.

class A {
    f() {
        // Some implementation
    }
}

class B {
    f() {
        // Some implementation
    }
}

interface C extends A, B {

}

// You CANNOT instantiate an interface!
// let c:C = new C();

// You must create an implementation of the С
class CImpl implements C {
    f(): void {
        // And you are required to implement f().
    }
}

let c:C = new CImpl();
// In this case, there is no ambiguity as in the case of class inheritance.
c.f();

In general, using inheritance is often considered a bad practice. There are several good practices that you need to remember:

• Interface segregation principle (ISP): "No code should be forced to depend on methods it does not use".

• Composition reuse principle (CRP): "Classes should favor polymorphic behavior and code reuse by their composition (by containing instances of other classes that implement the desired functionality) over inheritance from a base or parent class."

You are not allowed to use multiple inheritance to avoid the diamond problem and to encourage developers to adhere to the CRP principle. This is a design decision by the ECMAScript committee about inheritance in JavaScript.

About your question 1. You are allowed to extend multiple interfaces to comply with the ISP. For example:

interface Disposable {
  dispose: () => void;
}

interface Serializable {
  serialize: () => string;
}

class Student implements Disposable, Serializable {
    name:string = '';
    somethingElse: number = 0;
    serialize() {
      return JSON.stringify(this);
    }
    dispose() {
      // dispose logic
    }
}

If you were allowed to only implement one interface, you would encourage developers to break the ISP principle.

Using multiple interfaces means that when you implement other parts of your application, these parts don't need to be coupled with Student; they can be coupled only with the methods that they need:

function cleanUp(something: Disposable) {
  something.dispose();
}

function serialzie(something: Serializable) {
  return something.serialize();
}

In relation to your questions 2 and 3:

2. Yes, implementing multiple interfaces is common. Here is an example in the TypeScript code itself.

3. Yes, same as 2. There is only one limitation, the diamond problem:

interface Student {
    name:string;
    somethingElse: number;
}

interface Employee {
    salary:number;
    somethingElse: string;
}

// 'WorkStudy' cannot simultaneously extend types 'Student' and 'Employee'.
// Named property 'somethingElse' of types 'Student' and 'Employee' are not identical.
interface WorkStudy extends Student, Employee{
    description:string;
}

If you want to reuse code, your only option will be to use composition over inheritance:

interface IStudent {
    name:string;
}

interface IEmployee {
    salary:number;
}

class Student implements IStudent {
  constructor(public name: string) {}
}

class Employee implements IEmployee {
  constructor(public salary: number) {}
}

class WorkStudy implements IStudent, IEmployee{
  private _student: IStudent;
  private _employee: IEmployee;
  constructor(
    public description: string,
    student: IStudent,
    employee: IEmployee
  ) {
    this._employee = employee;
    this._student = student;
  }
  get salary() {
    return this._employee.salary;
  }
  get name() {
    return this._student.name;
  }
}

So, your only option is to adhere to the CRP.