1

I have learned about such feature in TypeScript as "Construct Signatures"

It allows to declare types such as:

type PointCreator = {
  new (x: number, y: number): {x: number, y: number},
  test(test:number): number,
  (foo:number): number,
}

How would I go about creating an object of this type?

When I am trying to declare an object of this type: I am getting an error "Type 'typeof PointCreation' is not assignable to type 'PointCreator'. Type 'typeof PointCreation' provides no match for the signature '(foo: number): number'.

const PointCreation: PointCreator = class { 
  constructor(public x: number, public y: number) {}
  static test = (test:number) => {return test;};
  bloo = (foo:number) => {return foo;};
}

Also, I do not understand why function test() is required to be static. If I to remove static keyword another compiler error appears: Property 'test' is missing in type 'typeof PointCreation' but required in type 'PointCreator'.

When trying to declare a type with either a constructor, or a bunch of functions, it is very easy to write a corresponding object.

Evgeny Vinnik
  • 1,235
  • 2
  • 16
  • 27
  • `test` is declared on the constructor level (PointCreator is a newable/constructor). That's why it should be static. Also, you try to mix up newable and callable on the same type PointCreator. It is not prohibited by TS. But it is hard to make class definition callable/function and vise versa. What you try to achieve? Maybe an abstract class will be suitable here. – Alexander Alexandrov Jul 12 '21 at 07:39
  • I doubt I will ever use such type anywhere in practice, was just exploring TypeScript capabilities. – Evgeny Vinnik Jul 12 '21 at 16:48

2 Answers2

2

Why it is possible to create such type ?

Because of javascript. For instance Date object. TS allows creating ConstructOrCall type because of backcompatibility.

Let's say you have some legacy code:


export const PointCreator = function (x,y) {
  if (new.target) {
    // If this function was called with new keyword
    this.x = x
    this.y = y
  } else {
    // if function was called as a regular function
    return 42
  }

}

// static test method
PointCreator.test = function (a) {

}

const x = new PointCreator(1, 2)

And you want to write typings for it. Then, this type will be ok

declare module 'legacy' {
  export type PointCreator = {
    new(x: number, y: number): { x: number, y: number },
    test(test: number): number,
    (foo: number): number,
  }
}

But, you can't create such value in pure typescript.

Also, I do not understand why function test() is required to be static

Because PointCreator is a constructor type and test method defined directly as constructor property. In order to use it as an instance method you should update your type:

type PointCreator = {
  new(x: number, y: number): { x: number, y: number, test: (arg: number) => number },
}

const PointCreation: PointCreator = class {
  constructor(public x: number, public y: number) { }
  test = (arg: number) => 42 // ok
}
captain-yossarian from Ukraine
  • 31,174
  • 3
  • 30
  • 62
  • How typical is to use constructor types in the production code? What would be a valid use case for this? Is `newable` an another name for the `constructor type`? Why would I go with a newable type vs creating an interface? – Evgeny Vinnik Jul 12 '21 at 17:02
  • Here, https://catchts.com/oop-style , in my blog you can find some examples of constructable types. It would be easier for me to answer if you provide some examples – captain-yossarian from Ukraine Jul 12 '21 at 20:14
1

Because the type that you declared is a function type. It describes a function, not a class.

  1. new (x: number, y: number): {x: number, y: number} - describes that you can create an object {x: number, y: number} if you call your function with new word like that new PointCreator(1, 2)

  2. test(test:number): number describes that our function (not an object which was created using the function) can have a static method test. Static is because it is accessible for function but not for an object.

  3. (foo:number): number describes that we can use call the function like that const result = PointCreator(1);

To create an object (not function) type, you should not use call definitions like new () and () in the type.

Anatolii Vasilev
  • 76
  • 3