So I am working on a react-native project. I was hoping if one could infer Generic types from implementation.
type itemType<T> = { item: T };
const someItem = {
item: 'Some String'
};
type someItemType = typeof someItem;
// So Here someItemType will be {item: string}, i want it to be itemType<string> and
// in this example i have implemented itemType but in real use case i want to infer
//it from the actual implementation
Partial inference on variables is not supported at present in typescript. Your only option is to use the inference behavior of function:
type itemType<T> = { item: T };
const createItemType = <T>(o: itemType<T>) => o;
const someItem = createItemType({ //someItem is typed as itemType<string>
item: 'Some String'
})
Just one note, it might not matter that in your original example someItem is typed as {item: string}, it will still be assignable to itemType<string> because typescript uses structural compatibility to determine assignability. So if the structure is compatible all is ok:
type itemType<T> = { item: T };
const someItem ={
item: 'Some String'
}
const someOtherItem: itemType<string> = someItem // ok
someItem is, al least with regard to future assignability to itemType<string>. There might be benefit in ensuring the object conforms to the itemType<T> interface at declaration site, rather than on future usage, I'd expect the perf impact of the identity function used to not be too high in most scenarios.const someItem = (<T>(o: itemType<T>) => o)({ item: 'Some String' }) I will understand then in 6 months.. not sure anybody else understands them right now :)It doesn't matter whether the type is defined as { item: string } or itemType<string> as TypeScript uses structural typing. That means the two are the same, because they have identical structures.
For example, you can assign values of either type to each other type:
type itemType<T> = { item: T };
const someItem = {
item: 'Some String'
};
type someItemType = typeof someItem;
const a: itemType<string> = { item: 'exmaple a' };
const b: someItemType = { item: 'exmaple b' };
let c: itemType<string>;
c = a;
c = b;
let d: someItemType;
d = a;
d = b;
itemType<T>.