Indexer with type parameter

[jbondc]

type MapThing<T> = {
    [x: string]: T; // Property 'length' of type 'number' is not assignable to string index type 'T'.
    length: number;
}
let a: MapThing<number>;
let b: MapThing<string>;

interface MapThingi<T> {
    [x: string]: T; // Property 'length' of type 'number' is not assignable to string index type 'T'.
    length: number;
}
let c: MapThingi<number>;
let d: MapThingi<string>;

A type parameter on an indexer is checked eagerly, should happen on instantiation.

[DanielRosenwasser]

Perhaps, but alternatively, you could type MapThing as:

interface MapThing<T> {
    [x: string]: T | number;
    length: number;
}

or just omit the type parameter if you know you're only going to be using number for T:

interface MapThing {
    [x: string]: number;
    length: number;
}

[weswigham]

I would like to think that this:

interface Map<T> {
    [x: string]: T;
}

type MapThing<T> = Map<T> & { length: number; };

Would be the best way to represent that at present. There's no compromises in genericness, signatures, or completion assistance when represented this way.

[jbondc]

👍

You both got me thinking about:

type MapThingConflict<T> = Map<T> & { length: number; } & { length: string; } & { length: boolean; } ; 

Should be an error or a combined/merged type as something like this?

interface MapThingConflict<T> {
    [x: string]: T;
    length: boolean
}

[RyanCavanaugh]

I think the behavior here is effectively calcified