How can I specify a typed object literal in TypeScript?

Question

Is there a way to make a typed object literal directly?

By directly I mean without having to assign it to a variable which is type annotated.

For example, I know I can do it like this:

export interface BaseInfo { value: number; }  export interface MyInfo extends BaseInfo { name: string; }  function testA(): BaseInfo = {    const result: MyInfo = { value: 1, name: 'Hey!' };    return result; } 

I also can do it like this:

function testB(): BaseInfo = {    return { value: 1, name: 'Hey!' }; } 

But what I need is something like:

function testC(): BaseInfo = {    return { value: 1, name: 'Hey!' }: MyInfo; // <--- doesn't work } 

Or like this:

function testD(): BaseInfo = {    return MyInfo: { value: 1, name: 'Hey!' }; // <--- doesn't work } 

Answer 1

Intellisense for members of object literals is provided by the contextual type (see section 4.19 of the spec) of the expression.

You can acquire a contextual type in a variety of ways. Some of the most common places where a contextual type is applied are:

• The initializer of a variable with a type annotation
• The expression in a return statement in a function or getter with a return type annotation
• The expression in a type assertion expression (<T>expr)

In your example, you can use a type assertion to force your object literal to have a contextual type:

function testB() {    return <IMyInfo>{ name: 'Hey!' }; } 

Answer 2

Answer is to use the identity function:

function to<T>(value: T): T { return value; } const instance = to<MyInfo>({     value: 1,     name: 'Hey!', }); 

the to function is going to be optimized away by the JIT compiler, so there is no performance impact of calling a function