Add support Interfaces to define static methods

[Serginho]

TypeScript Version: 2.0.3

Code

interface Foo {
public static myStaticMethod(param1: any);
}

Expected behavior:
No errors
Actual behavior:
Unsupported

[mhegazy]

What do you wan to achieve with this? can you elaborate on the scenario?

[rozzzly]

I imagine abstract classes are what you're looking for.

[Serginho]

@mhegazy
Example:

interface JsonSerializable {
      public static fromJson(obj: any);
      public toJson(): string;
}

@rozzzly In this example, abstract class is not valid.

I think this would be pretty cool! Java added this functionality in the last version.

[aluanhaddad]

@Serginho
I think you may find this interesting:

interface JsonSerializableStatic<C extends new (...args) => JsonSerializable<C>> {
  fromJson(json: string): JsonSerializable<C>;
}

interface JsonSerializable<C extends new (...args) => any> {
  toJson: () => string;
  constructor: C;
}

interface A extends JsonSerializable<typeof A> { }
class A implements JsonSerializable<typeof A> {

  constructor(readonly id: number, readonly name: string) { }
  toJson() { return JSON.stringify(this); }

  static fromJson(json: string): A {
    const obj = JSON.parse(json);
    return new A(obj.id, obj.name);
  }
}

const a = new A(1, 'Charlize');

const json = a.toJson();

const y = A.fromJson(json);
console.info(a, json, y);
console.info(new a.constructor(1, 'Theron'));
const m = new A.prototype.constructor(1, 'Charlize Theron');
console.info(m);

[Serginho]

@aluanhaddad I find your code a workaround of something which is obvious.

interface JsonSerializable {
      public static fromJson(obj: any);
      public toJson(): string;
}

Which do you see more clearly?

[aluanhaddad]

@aluanhaddad I find your code a workaround of something which is obvious.

interface JsonSerializable {
public static fromJson(obj: any);
public toJson(): string;
}
Which do you see more clearly?

Indeed, but mine is not a workaround, it is a justification for your usecase. Having static deserialization and instance serialization implemented on a class by class basis and thereby encapsulated and typesafe.
Your declaration:

interface JsonSerializable {
     public static fromJson(obj: any);
     public toJson(): string;
}

is irrelevant as it basically re-declares the interface of the JSON object. That absolutely does not require static interface methods in any way.

[Serginho]

You are loosing the concept of Interface. class A implements JsonSerializable should make me implementing both methods. But actually makes me to implement:

toJson: () => string;
constructor: new (...args) => JsonSerializableStatic<C>;

It's not a clear solution.

There is no technical reason for not allowing to define static methods on interfaces.

[aluanhaddad]

@Serginho I am not arguing that the situation is ideal. I was just trying to illustrate that it can be expressed.

[Serginho]

@aluanhaddad Come on! Open your mind. Do you think typescript should allow static methods in Interfaces? this was implemented in Java 8 in the last version, so I think I'm not talking nonsense.

[gcnew]

@Serginho I don't think it's a particularly good fit for TypeScript. Interfaces should define the functionality an object provides. This functionality should be overridable and interchangeable (that's why interface methods are virtual). Statics are a parallel concept to dynamic behaviour/virtual methods. Interweaving the two doesn't feel right from a design point to me.

As @aluanhaddad already wrote, TypeScript actually already has a mechanism to express what you desire. The big difference is that in this case you treat the class as an object, which continues to be logically consistent. From my perspective, the approach you propose is not particularly well suited to TypeScript (and JavaScript development) as classes are kind of a hack/second class citizens. The currently prevailing patterns count on ducktyping/shape programming, not on rigid classes.

I guess, you may open your mind as well and try different styles of programming. The world neither starts nor ends with OOP. You may find programming with functions, plain objects and (and to some degree) prototypes pleasurable and even better. Such a style is much more in line with what JavaScript was initially designed for. On a side note, I agree JS is slowly shifting towards OOP-esque patterns (at least on the committee level), but that's because of the huge push of people not being comfortable with different programming paradigms and development techniques. For me it's a deeply saddening and disappointing thing.

[andy-hanson]

As @gcnew said, an interface describes the shape of an individual object, not its class. But there's no reason we can't use an interface to describe the shape of the class itself, since classes are objects too.

import assert = require("assert");

interface JsonSerializableStatic<JsonType, InstanceType extends JsonSerializable<JsonType>> {
    fromJson(obj: JsonType): InstanceType;
}
interface JsonSerializable<JsonType> {
    toJson(): JsonType;
}

interface PointJson { x: number; y: number; }
class Point /*static implements JsonSerializableStatic<PointJson, Point>*/ {
    static fromJson(obj: PointJson): Point {
        return new Point(obj.x, obj.y)
    }

    constructor(readonly x: number, readonly y: number) {}

    toJson(): PointJson {
        return { x: this.x, y: this.y };
    }
}
// Hack for 'static implements'
const _: JsonSerializableStatic<PointJson, Point> = Point;

function testSerialization<JsonType, InstanceType extends JsonSerializable<JsonType>>(cls: JsonSerializableStatic<JsonType, InstanceType>, json: JsonType) {
    const instance: InstanceType = cls.fromJson(json);
    const outJson: JsonType = instance.toJson();
    assert.deepEqual(json, outJson);
}
testSerialization(Point, { x: 1, y: 2 });

Failing to meet the signature of either toJson or fromJson results in a compile error. (Unfortunately, the error is at const _ rather than at the method.)

Probably related (since it deals with typing static methods): #5863.

---

@aluanhaddad: Your example has a mistake: JsonSerializable's constructor member would actually refer to an instance property called constructor, which when invoked with new would return a JsonSerializableStatic. What that would mean is that (new ((new X()).constructor)).fromJson({}) would have to work. The reason it compiles successfully is that interface A extends JsonSerializable<typeof A> declares the implementation to be valid without actually checking it. For example, this compiles without error:

interface I { m(): void; }
interface A extends I { }
// No compile error
class A implements I { em() {} }

@Serginho Not a Java user, but it doesn't look like the language allows you to define an interface for the static side of a class (meaning classes implementing the interface would have to implement a static method to conform). Java allows you to define a static method with a body in an interface, the TypeScript equivalent of which would be:

interface I { ... }
namespace I {
   export function interfaceStaticMethod() {}
}

[RLovelett]

What if you were trying to make a generic factory?

interface Factorizable {
  static factory<U>(str: string): U
}

class Foo {
  private data: string[] = []
  bar<T extends Factorizable>(): T[] {
    return this.data.map(T.factory);
  }
}

class Bar implements Factorizable {
  static factory(str: string): Bar {
    // ...
  }
}

// Usage
var x = new Foo();
var y: Bar[] = x.bar();

I'm not sure about the interface syntax I'm proposing here but I know the "usage" syntax is what I'm trying to achieve. This is a pattern I use frequently in Swift (using protocols) and I think it would be really nice in TypeScript. Though not being a language designer or compiler implementor I'm not sure if it fits the intended direction of TypeScript or is realistic to be implemented.