Inferring types in array

Question

Given the following:

type ArrayInfer<A> = A extends (infer I)[] ? I : never;

const a = ["foo", 1, {a: "foo"}];
type inferred = ArrayInfer<typeof a>;

My type inferred resolves to:

type inferred = string | number | {
    a: string;
}

But if I change my array slightly to include an empty object literal:

const a = ["foo", 1, {}];

Then inferred no longer includes string and number in its type definition:

type inferred = {}

Why is that?

I think that {} is a common ancestor for string and number. — Paleo
– Paleo, Commented Mar 25, 2019 at 15:25
My first guess here is that the best common type is inferred to be {}, which is from a time when {} was considered a top type (nowadays you'd use unknown) and when union types didn't yet exist. Not sure if that's official enough to put in an answer, though. — jcalz
– jcalz, Commented Mar 25, 2019 at 15:28

Cerberus · Accepted Answer · 2019-03-25 15:32:13Z

2

It seems that both string and number are assignable to {}: playground (in fact, every type would be assignable to {}, except null, void and undefined). So TypeScript unifies three types to the widest one. When you had the first case, there wasn't one type to use among the three ones presented, so you've had a union.

answered Mar 25, 2019 at 15:32

Cerberus

10.6k1 gold badge35 silver badges53 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Mister Epic Over a year ago

So would it be expected that const a3 = ["foo", 1, {}, undefined]; produce anything other than type inferred3 = {}?

jcalz Over a year ago

@MisterEpic with --strictNullChecks enabled, yes (should be {} | undefined)

jo_va · Accepted Answer · 2019-03-26 08:08:51Z

1

To extend @Cerberus' answer and as suggested by @Paleo in the comments, all types in JavaScript except Object.create(null), null and undefined have Object as their top ancestors as shown by the following code snippet:

const arr = [{}, 1, 'hello', (a, b) => a+b, true, null, undefined, Object.create(null)];

function getPrototypeChain(value) {
  const ancestors = [];
  let proto = value;
  while (proto) {
    proto = Object.getPrototypeOf(proto);
    if (proto) {
      ancestors.push(proto.constructor.name);
    }
  };
  return ancestors
}

arr.forEach(x => console.log(x, '->', getPrototypeChain(x).join(' -> ')));

From the TypeScript doc (Best Common Type, suggested by @jcalz in the comments):

When a type inference is made from several expressions, the types of those expressions are used to calculate a “best common type”. [...] The best common type algorithm considers each candidate type, and picks the type that is compatible with all the other candidates.

So if you use a non-empty object, no best common type will be found in the list, and since

When no best common type is found, the resulting inference is the union array type

You get a union of all item types as the result.

However, from the moment you include a single empty object in your list and you don't have any null or undefined items, Object becomes the best common type and the output will be an empty object.

edited Mar 26, 2019 at 8:08

answered Mar 25, 2019 at 16:08

jo_va

14.1k3 gold badges25 silver badges49 bronze badges

2 Comments

Cerberus Over a year ago

Of course, there is Object.create(null), but except that - thanks for extending! It's really better then what I could construct myself.

jo_va Over a year ago

Thank you @Cerberus, I added Object.create(null) this to the list as well :)

Collectives™ on Stack Overflow

Inferring types in array

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related