I might as well put this in an answer although it doesn’t look like it will meet your needs. TypeScript currently has neither generic values, higher kinded types, nor typeof on arbitrary expressions. Generics in TypeScript are sort of “shallow” that way. So as far as I know there’s unfortunately no way to describe a … Read more
Here’s why it doesn’t work: Typescript does control-flow type narrowing on regular variables, but not on type variables like your T. The type guard typeof x === “string” can be used to narrow the variable x to type string, but it cannot narrow T to be string, and does not try. This makes sense, because … Read more
As you may be aware, object types in TypeScript are matched via structural subtyping and are thus open and extendible. If Base is an object type and Sub extends Base, then a Sub is a kind of Base, and you should be allowed to use a Sub wherever a Base is required: const sub: Sub … Read more
I believe this is because objects are contravariant in their key types. For more information see this answer. Likewise, multiple candidates for the same type variable in contra-variant positions causes an intersection type to be inferred. const paths = [‘a’, ‘b’] as const type Path = typeof paths[number] type PathMap = { [path in Path]: … Read more
type Structure = { foo: { a: 1, b: 2, } bar: { c: 3, d: 4, } } type Values<T> = T[keyof T] type Elem = string; type Acc = Record<string, any> /** * Just like Array.prototype.reduce predicate/callback * Receives accumulator and current element * – if element extends one of accumulators keys -> … Read more
No, this is not possible in TypeScript as of TS4.1. There are two issues I see; one might be overcome with a change to the TypeScript standard library typings for Array.prototype.map(), but the other would require a fairly large change to the type system to work in general and cannot currently be handled in a … Read more
I would not say it is stupid. It just safe. C0nsider this example: function fn3<T extends “a”>(): T { return “a” // error } const result = fn3<‘a’ & { tag: 2 }>().tag // 2 It means that T extends a but not equal ‘a’. In above example, result is 2 but in runtime it … Read more
Here’s a solution, but beware when using this as a return type for Object.entries; it is not always safe to do that (see below). When you want to pair each key with something dependent on that key’s type, use a mapped type: type Entries<T> = { [K in keyof T]: [K, T[K]]; }[keyof T][]; type … Read more
It’s important to pay attention to where the generic type parameters are declared and what scope they have. The type type FuncGenericReturn = <T>() => T; is a concrete type referring to a generic function. <T>() => T means: “a function whose caller specifies a type T and which returns a value of type T.” … Read more
The difference is that Extract is a distributive conditional type, while your CustomExtract is not. In order for a conditional type of the form X extends Y ? A : B to be distributive, the checked type X must be a “naked type parameter”; that is, a type parameter like T in interface Foo<T> {…}, … Read more