Is it possible to implement a function interface in TypeScript?

Perhaps you are thinking of something like this?

interface FunctionInterface {
    (s: string): boolean;
}

const f: FunctionInterface = s => true;
const b: boolean = f('someString');

There is no default apply concept in TypeScript, but there are ways of creating typed objects that are also functions.

interface MyCallable {
    (param1: string, param2: number): string;

    prop1: string;
    prop2: number;
    extraMethod: (param1: boolean) => boolean;
}

function makeMyCallable(prop1: string, prop2: number): MyCallable {
    let that = ((param1: string, param2: number) => param1 + param2) as MyCallable;

    that.prop1 = prop1;
    that.prop2 = prop2;
    that.extraMethod = (param1: boolean) => !param1;

    return that;
}

let mc = makeMyCallable("3", 4);

mc("3", 4);
mc.prop1 = "string";
mc.prop2 = 5;
mc.extraMethod(false);

If all you want is a simple function to accept a string and return a boolean, you don't need to use a class for this.

const myFunc = (s: string): boolean => {
  return s !== "";  //whatever logic is needed here
};

But, yes you can extend classes in TypeScript

class MyBaseClass {
  constructor() { }

  public doThing = (s: string): boolean => {
    return s !== "";  //whatever logic is needed here
  }
}

class MyFunc extends MyBaseClass {
  constructor() {
    super();
  }
}

const f = new MyFunc();
const b = f.doThing("hi"); //returns a boolean

Updated for response to comment

As mentioned below in another answer, you cannot really new up a class, assign that instance to a variable and then call it as a function. You could do that on the creation though, like this:

class MyBaseClass {
  constructor() { }

  public doThing = (s: string): boolean => {
    return s !== "";  //whatever logic is needed here
  }
}

class MyFunc extends MyBaseClass {
  constructor(private s: string) {
    super();
    this.doThing(this.s);
  }
}

const f = new MyFunc("hi"); //returns a boolean

You can play with the above code on the Typescript playground here

Depends on use case. Here several ways. https://typescriptlang.org/play/...

Somehow we imported

• as interface @ https://stackoverflow.com/a/42841742/9412937
• as function type

type fInterface = (...params: fArgs) => fRet

• as separate types

type fArgs = [number, string]
type fRet = boolean

No matter - they are interchangeable with Parameters and ReturnType

And we have function implemented wrong

function nop() {}

1. Manually pick parameters type

function isEqual0(x: fArgs[0], y: fArgs[1]): fRet {
  //return x == y //TS-ERROR: This condition will always return 'false' since the types 'number' and 'string' have no overlap.ts(2367)
  return `${x}` == y
}

2. With destructing

function isEqual1(...args: fArgs): fRet {
  const [x, y] = args
  return `${x}` == y
}

3. With overload. Strict usage but during implementation all parameters are any.

function isEqual2(...args: Parameters<fInterface>): ReturnType<fInterface>
function isEqual2(x: any, y: any) {
  return x == y
}

4. After all we can validate by re-typing (like typing-the-function). Also there will be type validation in parent module in any case.

function isEqual3(x: any, y: any) {
  const valid: typeof  isEqual3 extends fInterface ? true : never = true
  if (!valid)
    throw Error()
  return x == y
}

const _exports = {
  isEqual0, isEqual1, isEqual2, isEqual3, nop
}
, _exportCheck = _exports as  Record<keyof typeof _exports, fInterface> //TS-ERROR The types returned by 'nop(...)' are incompatible between these types.

module.exports = _exportCheck
export default _exportCheck
export {
  isEqual0, isEqual1, isEqual2, nop
}

So many ways to achieve TS-Error if something was wrong.

If you only have this function in your interface, you can define it like

type FuncType = (s: string) => boolean;

to use it like

const myFunc: FuncType;
function getFunction(): FuncType {}