Optional object literal typing

[NN---]

Currently it is not possible to set a type for a key in the object literal.

interface A {
    x: number;
    y: string;
}

var a = {
    // I would assume the following syntax
    // <A>q: { ... }
    q: {
        x: 1,
        y: "a"
    }
}

However it is possible to cast a literal value but it is not the same.

interface A {
    x: number;
    y: string;
}

var a = {
    // q has type 'A', and we can write anything that compatible to that literal.
    q: <A>{
        x: 1,
        y: "a"
    }
}

[JsonFreeman]

Right, casting is not the same because it would allow an object that is not necessarily an A. But you can do this:

var a: { q: A } = {
    q: {
        x: 1,
        y: "a"
    }
}

[danquirk]

Jason's suggestion is the solution here. There's no good syntax for specifying the type on a per property basis, similar to trying to do the same inside a destructuring pattern.

[NN---]

@danquirk it solves it but it requires to describe the whole structure of the object.
i would like to see a syntax for typing the key in-place in the future .

[danquirk]

If you use normal type annotation syntax then it's extremely awkward, if not actually ambiguous in some cases. If you don't, then you're inventing a new type annotation syntax for this one corner case.

var a = {
    q: A: { x: 1, y: 'a' }
}

The vast majority of the time a cast at the property level suffices, or else you can use an annotation of the full object.

[mpawelski]

I have a question related to this one.
I just noticed that in 1.4 version this compiles fine:

interface ITest {
    foo: string;
    bar: string;
}

var test2 = <ITest>{
    foo: "foo"
}

I thought, when casting the object must this be compatible too. I remember that I used to do things like this to workaround this

var test2 = <ITest><any>{
    foo: "foo"
}

Am I wrong or it just got changed some time ago?

About the original question. I think the ability to specify type for literal and have compiler check it would be very helpful in certain situations. I have some places in code where the type is not strongly typed but for certain object literals I have information what should be their type so I would like to annotate them with certain type so compiler would produce error in this place when the type changes.

It is also strange I get Intellisense when I cast and rename refactoring works but compiler doesn't enforce that this literal match the type:

[RyanCavanaugh]

An expression of the form <T>U is valid if U is assignable to T or T is assignable to U (otherwise the type assertion operator would be useless). You're much better off with var test: ITest to put a contextual type on the initializer than by using <T>{ ... }.

[JsonFreeman]

Yes, to paraphrase @RyanCavanaugh's point, a type annotation

var test: ITest = { foo: "foo" };

means that the object has to be an ITest, which is why it will give an error if the object is missing bar. However, the cast

var test = <ITest>{foo: "foo" };

means that the object might be an ITest, and that the compiler should consider it an ITest. In this case, the compiler checks that ITest can be assigned to your object, because that is proof that the object might be an ITest. This feature should be used when you somehow know that the object will be an ITest at runtime, even though it does not look statically compatible with ITest.

[NN---]

Here the case where I need it:.

This is declaration code

interface B  {
}
declare var B: {
    prototype: B;
    f(): B;
}

And I want to define B.
I have to cast the right value instead of defining type in the left side.
'prototype:< B >null' instead of smth like '< B >prototype: null'

interface B  {
}
declare var B: {
    prototype: B;
}

var B = {
    prototype:<B>null
}

[JsonFreeman]

Ah, you are essentially splitting up the typing of B and the initialization of B into two steps. But you can also combine them:

var B: {
    prototype: B;
} = {
    prototype: null
};

[JsonFreeman]

And if you want to do it in two steps, you can also do:

var B: {
    prototype: B;
};
B = {
    prototype: null
};

[NN---]

I can but I already have a definition file that I cannot change since it comes from NuGet package.

[JsonFreeman]

Then perhaps you just want

B = {
    prototype: null
}

Note the absence of the word var. The word var was causing you to need the cast before.

This does assume that a var B is already declared in the relevant scope. But if your definition file declares var B, it is implying that the definition is indeed in scope.

[NN---]

The definition declares it but it is not defined in all environments .
Specifically I have a unit test and it runs without the variable defined, so I must define it with some stub of my own.