Make overProp function interface with one param

by

TypeScript doesn’t currently support partial type parameter inference; if a type has two type parameters, you either have to specify both of them or the compiler will infer both of them. (Well, there are type parameter defaults but that doesn’t count as inference either).

There are two workarounds I know of for this. The first is currying, where instead of having a single generic function of multiple type parameters, you have a generic function which returns another generic function. On one of them you specify the type parameter, and the other you let the compiler infer it:

const overPropCurried = <T>() => <P extends keyof T>(
  p: P,
  over: (val: T[P]) => T[P]
) => {
  return (obj: T) => ({
    [p]: over(obj[p]),
    ...obj
  });
};

const overPropObj = overPropCurried<Obj>();
overPropObj("a", a => a); // no error
overPropObj("a", a => "a"); // no error
overPropObj("b", b => 1); // no error
overPropObj("c", c => 2); // error, not key 'c' in Obj
overPropObj("a", a => 1); // error, type of key `a` is `string`

The other workaround is to use a single function which takes a dummy parameter corresponding to the type you’d like to specify. The actual value you pass as the dummy parameter doesn’t matter because the function implementation ignores it… in fact, as long as the compiler thinks the value is of the right type it doesn’t even have to be one at runtime:

const overPropDummy = <T, P extends keyof T>(
  dummy: T, // ignored
  p: P,
  over: (val: T[P]) => T[P]
) => {
  return (obj: T) => ({
    [p]: over(obj[p]),
    ...obj
  });
};

const dummyObj = null! as Obj; // not really an Obj but it doesn't need to be

overPropDummy(dummyObj, "a", a => a); // no error
overPropDummy(dummyObj, "a", a => "a"); // no error
overPropDummy(dummyObj, "b", b => 1); // no error
overPropDummy(dummyObj, "c", c => 2); // error, not key 'c' in Obj
overPropDummy(dummyObj, "a", a => 1); // error, type of key `a` is `string`

Either way works, and neither way is perfect. I tend to use currying myself, especially if I can use the partial result multiple times (as I’ve done above with overPropObj). Anyway, hope that helps; good luck!

Link to code

More Related Contents:

  1. *ngFor running an infinite loop in angular2
  2. get and set in TypeScript
  3. How do you emulate nominal typing in TypeScript?
  4. The property ‘value’ does not exist on value of type ‘HTMLElement’
  5. What is the question mark for in a Typescript parameter name
  6. Typescript, merge object types?
  7. TypeScript – extract interface members only – possible?
  8. Types for function that applys name of function and arguments
  9. Typescript: How can I make entries in an ES6 Map based on an object key/value type
  10. How to display json object using *ngFor
  11. How do I import other TypeScript files?
  12. How can I augment a property within a third-party TypeScript interface defined as “any”?
  13. What does the “as” keyword do?
  14. Typescript ReturnType of generic function
  15. How to get type of array items?
  16. Typescript check for the ‘any’ type
  17. Eliminate nevers to make union possible
  18. Union and Intersection of types
  19. TypeScript: Define a union type from an array of strings
  20. What is the “as syntax” pointed out by tslint?
  21. How to use enum as index key type in typescript?
  22. How to share code between TypeScript projects?
  23. How to make Typescript infer the keys of an object but define type of its value?
  24. Is there ArgumentsType like ReturnType in Typescript?
  25. Typescript: Remove entries from tuple type
  26. Check if object correctly implements interface
  27. Is it possible to narrow the types of overloaded parameters without exhaustively checking each parameter in the function body?
  28. What are the differences between the private keyword and private fields in TypeScript?
  29. TypeScript: deep partial?
  30. Is it possible to export * as foo in typescript

Leave a Comment