将泛型类型约束为文字类型

Question

My question is two-fold:

1. I would like to know if there is a way in TypeScript to constrain a generic to be a literal type of some kind. What I mean by this is something like function foo<T is a string literal>(...) . The closest I have come to this behaviour is function foo<T extends string> , but this allows unions of string literals and the type "string" itself as values for T.
2. If this is not possible in TypeScript 2.1, would it make sense from a design perspective to implement such a feature?

My use-case is to define a curried function prop like this:

function prop<K extends string, U>(name: K): <T extends { [P in K]: U  }>(obj: T) => T[K] {
    return (obj) => obj[name];
}

prop<'name', number>("name")({
    name: 3
})

This example works as expected if K is a string literal, but the typechecking of the function kind of breaks down K is string .

I know it's a bit contrived; please not my goal is not to solve a practical problem (although it would) but more to experiment with TypeScript's type system.

Thank you!

Answer 1

I think the problem here is that you're putting the cart before the horse in terms of your generic constraints: there is no sense in trying to constrain the allowed keys before you know the object.

Here's an example that does what I think you're trying to accomplish:

function propGetter<O>(o: O): <K extends keyof O>(key: K) => O[K] {
    return k => o[k];
}

let prop = propGetter({
    id: 10,
    firstName: "Dununuh Hunudunuh"
});

let id = prop("id");               // number
let firstName = prop("firstName"); // string
let foo = prop("foo");             // Type error