Suggestion: callable class

[fdecampredon]

class MyCallableClass {
   property: string;
   constructor() {
     //constructor body
   }
   (): MyCallableClass { // could be 'string' or any other type
     // call signature body
     return new MyCallableClass();
   }
}

would emit :

function MyClass() {
  if (this instanceof MyClass) {
    //constructor body
  } else {
    // call signature body
    return new MyCallableClass();
  }
}

[fnky]

+1 For this, as most libraries use this convention to omit the new operator

I had this in mind

static class Foo {
  constructor() {
    // constructor
  }
}

and the output would be

function Foo() {
  if(!(this instanceof Foo)) return new Foo();
  // constructor
}

[Igorbek]

Vote, could be useful.

[omidkrad]

Interesting ability, but I believe this can lead to bad design and confusing API. I like it how it is now, that I have to use the new keyword when I mean a new object created, or use methods when I mean a method call. In this case using named static methods.

[basarat]

For this, as most libraries use this convention to omit the new operator

and I hate those libraries. new all things

[RyanCavanaugh]

+Needs Proposal (see https://github.com/Microsoft/TypeScript/wiki/Writing-Good-Design-Proposals)

This might be right out due to not aligning with ES6 class syntax. We'd rather not add any more to that than we have to.

A potential problem is that you would probably want to be able to call super() from a derived class method, but that would mean super() would mean two completely different things in constructors vs methods.

[RyanCavanaugh]

Note: comments from Anders on #619

[rjamesnw]

A potential problem is that you would probably want to be able to call super() from a derived class method, but that would mean super() would mean two completely different things in constructors vs methods.

I'm not sure I agree. How that is handled is up to the developer. When I call "super()" I always expect to call a base function (always, as would normally happen in most JS implementations). There are ways to work around it, like moving the initialization to another method, or implementing the "instanceof" checks that some have mentioned. I don't see this changing at all. One of the main reasons for this is for object pools for game engines. If there's an available object in such an engine, I never call "super()" (which may create sub objects - and if I did need to, I should be able to just do "super.call(newObj, ....)"), but instead I would call 'oldObj.Reset()' (Construct 2 does something similar). If there isn't any new objects, then I'd simply return a "new ThisType()", which then would call "super()" as normal (as expected).

[jpolo]

+1 for this feature

For this, as most libraries use this convention to omit the new operator

The shortcut for a new object is not the best example actually. Usually in JS, applying 'call' on a constructor means the 'coerce' operator.

In my opinion this is a stronger usecase :

class MyCallableClass {
   property: string;
   constructor() { }
   (o: any): MyCallableClass {
     if (o instanceof MyCallableClass)  return o
     if ('toMyCallableClass' in o) return o.toMyCallableClass()
     return new MyCallableClass(o);//or throw or return null
   }
}

[saschanaz]

Just a note: This is being discussed for ES7 - https://gist.github.com/ericelliott/1c6f451b2ed1b634c2f2#file-es7-new-fix-js

[Tragetaschen]

I'm currently missing something like this, but not particularly for a new replacement. I'm trying to implement a scale in d3, where the resulting object has

• function call semantics: scale(3) scales the value 3 from the input domain to the output range
• several functions like getting/setting the scale.domain() or scale.invert()ing the above

I haven't found any way to implement this interface in TypeScript without resorting to some hefty <any> casting.