Name conflict inside a class when there's multiple inheritance of interfaces containing the same method name, but different return types

I have two interfaces, A and B, and they both have a function named myFunction. Interface A's function has a return type of void and interface B's function has a return type of string.

When Class C implements both A and B (multiple inheritance), there is a conflict in class C since we can’t have to implement two functions named myFunction with different return types. What is the correct approach to implement/avoid such patterns?

interface A {
  myFunction: () => void;
}

interface B {
  myFunction: () => string;
}

class C implements A, B {
  myFunction() {
    console.log('asd');
  }
  myFunction() {
    return 'asd';
  }
}

new C().myFunction();

You only just do logic in one function for all abstract method that inheritance from interface and use function overload at here. Read more Function overload

interface A {
  myFunction: (val: string) => void;
  otherFunc: (val: string, options: string) => void;
}

interface B {
  myFunction: (val: number) => string;
  otherFunc: (val: string, options: string, otherParam: any[]) => string;
}

class C implements A, B {
  otherFunc(val: string, options: string): void;
  otherFunc(val: string, options: string, otherParam: any[]): string;
  otherFunc(...args: any[]): void | string {
    // args may be is [val, options] or [val, options, otherParam];
    // business logic depend on args and check args[2] (otherParam) for doing more thing.
    if (args[2] && args[2].length > 1) {
      // implement business logic for interface B
    }
    return '';
  }

  myFunction(val: string): void;
  myFunction(val: number): string;
  myFunction(val: string | number): void | string {
    // business logic depend on val
    return val ? console.log(val) : val.toString();
  }
}

In the scenario you described, when implementing multiple interfaces (A and B) with conflicting function signatures (different return types), there is no direct way to resolve the conflict. Having two functions with the same name but different return types is not allowed in most programming languages.

To overcome this issue, you can consider the following approaches:

Rename the functions: Rename one or both of the functions in interfaces A and B to have distinct names. This way, there will be no conflict in the implementation.

JavaScript:

  interface A {
  myFunctionA: () => void;
}

interface B {
  myFunctionB: () => string;
}

class C implements A, B {
  myFunctionA() {
	console.log('asd');
  }
  myFunctionB() {
	return 'asd';
  }
}

new C().myFunctionA();
new C().myFunctionB();

Use composition instead of inheritance: Instead of implementing both interfaces directly in class C, you can create separate classes that implement each interface and then use composition to combine them.

TypeScript:

interface A {
  myFunction: () => void;
}

interface B {
  myFunction: () => string;
}

class AImplementation implements A {
  myFunction() {
	console.log('asd');
  }
}

class BImplementation implements B {
  myFunction() {
	return 'asd';
  }
}

class C {
  private aImplementation: AImplementation;
  private bImplementation: BImplementation;

  constructor() {
	this.aImplementation = new AImplementation();
	this.bImplementation = new BImplementation();
  }

  myFunctionA() {
	this.aImplementation.myFunction();
  }

  myFunctionB() {
	return this.bImplementation.myFunction();
  }
}

new C().myFunctionA();
new C().myFunctionB();

By using composition, you can separate the implementation of each interface into distinct classes and delegate the function calls accordingly within the class C.

Choose the approach that best suits your needs based on the specific requirements of your application.