TypeScript doesn't understand fromEntries #43332

Activity

1. Ryan Cavanaugh (RyanCavanaugh)

   added

   Design LimitationConstraints of the existing architecture prevent this from being fixedConstraints of the existing architecture prevent this from being fixed

   on Mar 22, 2021
2. RyanCavanaugh commented on Mar 22, 2021

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Mar 22, 2021

   Member

   More actions

   We don't have any type constructors that could do this, so the definition is written as well as it can be.
3. nmain commented on Mar 23, 2021

   

   Nicholai Main (nmain)

   on Mar 23, 2021

   More actions

   If you refactor the Object.fromEntries(Object.keys(..... code into a helper function that takes a value selector predicate, you can usually put a type on the helper function that lets you have strong typing when calling that function using mapped types. The types for lodash may have some inspiration in them.

   👍React with 👍1Reacted by Valentin Degenne
4. yw662 commented on Jul 7, 2021

   

   yw662 (yw662)

   on Jul 7, 2021

   More actions

   It is a Object.fromEntries issue but also a Object.keys issue before that.
   You may right your own version for Object.fromEntries to workaround that issue.
   like this:
   https://www.typescriptlang.org/play?target=99&jsx=0#code/MYewdgzgLgBApmKAnAlnCMC8AoGeYA8AKgHwAUcAXDEQJRYm754DyARgFZzBQB0CyNBAr0AhhgDeTZngDaAaRgowMANZwAniABmNALrUFAGhoK9e6fgC+s9Vt1E9si9lCRY2pCAC2AUUSo6FgwTASKcAAeUAgAJhjQqGAA5iYAauQCgRCG8kapTnr0mCQhzOxcPLyePv6C6BQBQmKSlnJ2SiryBjCpllbYruDQ8BHAABaiyUGYMFJ4qkii6mDUYHAA7jDl3FBGTGzKk8BUMGub2zx7eCBQY3BI2acbW5w72P3YMdwANqJIcDAoBoAA4AgCCADdRChfmxvnBfKMJlMMDM7DpASC4BjIuNJkl0ABuAZfYC-f6Y0EwADqom+8KgEAAIqIoKJgnMYLZNB0YJDobD4Yi8Sjus53gNBu4YEikrUsoZ0bogaCcUj8egTM4CsFMkIKOqUbReN5RMCyGRbCZCsUrVzzLQBm5hus6QzHrT6XBGSy2cFqn5GvVZfKmkA
5. lmmarsano commented on Mar 21, 2022

   

   Luis Marsano (lmmarsano)

   on Mar 21, 2022

   Last edited by lmmarsano

   More actions

   The type system is powerful enough to do better than this.
   I often override the built-in type definitions if it's bad enough.

   type UnionToIntersection<Union>
     = (
       Union extends unknown
       ? (distributedUnion: Union) => void
       : never
     ) extends ((mergedIntersection: infer Intersection) => void)
     ? Intersection
     : never
   type Entry<T, K = keyof T>
     = K extends keyof T
     ? [K, T[K]]
     : never
   type _FromEntry<T extends readonly [PropertyKey, unknown]>
     = T extends unknown
     ? { [k in T[0]]: T[1] }
     : never
   type FromEntry<T extends readonly [PropertyKey, unknown]> = UnionToIntersection<_FromEntry<T>>
   
   interface ObjectConstructor {
     entries<T>(o: T): Entry<T>[]
     fromEntries<T extends readonly [PropertyKey, unknown]>(entries: Iterable<T>): FromEntry<T>
     keys<T>(o: T): (keyof T)[]
   }

   Some type definitions at first glance seem unnecessary: they're written that way to take advantage of distributive conditional types.
   Distributivity in Entry produces a union of ordered-pairs instead of a single ordered-pair of unions.
   UnionToIntersection takes advantage of covariance in function parameters & distributivity to infer an intersection.
   FromEntry distributively maps each ordered-pair of a union to a singleton key/value mapping, then intersects that union to merge all those mappings.

   With these definitions, your code (lightly modified to explicitly type ordered pairs) passes type check.

   👍React with 👍1Reacted by Raul Macarie
6. mxdvl commented on Jul 6, 2022

   

   Max Duval (mxdvl)

   on Jul 6, 2022

   More actions

   I believe this is a duplicate of #35745. As mentioned there:

   It's not correct to use the input type to determine the output type, because knowing what might be in an array is not the same as knowing what's actually in it. This program is legal per the above definitions but unsound:

   const arr: Array<["A", 1] | ["B", 2]> = [];
   let o = fromEntries(arr);
   let m: number = o.A;

   RyanCavanaugh

   👍React with 👍2Reacted by Ryan Cavanaugh and Jack Shunn
7. Ryan Cavanaugh (RyanCavanaugh)

   closed this as not plannedon Jul 6, 2022