For-in loop converting TypeScript types to intersection?

Question

Edit: Updated, minimal example (hopefully):

Paring it all down, I guess at the heart of my curiosity is why this won't work, and causes the two errors below:

interface Implicit {
  someNumber?: number | { value: number }
  someString?: string | { value: string }
}

interface Explicit {
  someNumber?: { value: number }
  someString?: { value: string }
}

const impl:Implicit = {
  someNumber: 123,
  someString: { value: 'impl' }
}

function convert (obj: Implicit) {
  const expl:Explicit = {}
  let k: keyof typeof obj;
  for (k in obj) {
    const objk = obj[k] // also, why does this alter behavior?
    if (typeof objk === 'object') {
      expl[k] = objk // Error {value:string}|{value:number} not assignable to {value:string}&{value:number}
    } else {
      expl[k] = { value: objk } // Error string|number is not assignable to never
    }
  }
}

Is TS not able to determine whether k is someNumber or someString each loop, so it's creating an intersection enforcing the result to be both?

Updated TS playground

Previous question:

I'm trying to create a versatile function that accepts a shorthand, implicit notation { someParameter: 123 } or an explicit version: { someParameter: { value: 123, min: 0, max: 200 }}, and converts and returns the explicit version:

interface ImplicitValues {
  color: number | string | ExplicitValueColor;
  position: number | ExplicitValuePosition;
}

interface ExplicitOptions {
  min?: number
  max?: number
}

interface ExplicitValueColor extends ExplicitOptions {
  value: number | string
}
interface ExplicitValuePosition extends ExplicitOptions{
  value: number,
}

There are other ImplicitValue types as well (not listed for brevity), so I'd like to create a generic type, that converts to the explicit type automatically:

type MakeExplicit<T> = {
    [K in keyof T]?: Extract<T[K], { value: any }>
}

This seems to work, as when we use mouse over the type using @jcalz awesome Expand utility, it is correct:

However, when we try to loop through the ImplicitValues array, and make them explicit, we get the following error:

const someObject:ImplicitValues = {
  color: 0xff0000,
  position: {
    value: 123,
    min: 0,
    max: 200
  }
}

function isExplicit <T>(param: any): param is MakeExplicit<T> {
  if (typeof param === 'object') return 'value' in param;
  return false;
}

function convertToExplicit(obj:ImplicitValues) {
  let explicitValues:MakeExplicit<ImplicitValues> = {};

  let key:keyof typeof obj
  for (key in obj) {
    if (isExplicit(obj[key])) {
      explicitValues[key] = obj[key]
      // ERROR: Type 'string | number | ExplicitValueColor | ExplicitValuePosition' is
      // not assignable to type 'ExplicitValueColor & ExplicitValuePosition'.
    } else {
      explicitValues[key] = { value: obj[key] }
      // ERROR: Type 'string | number | ExplicitValueColor | ExplicitValuePosition' is
      // not assignable to type 'number'.
    }
  }
  return explicitValues
}

Setting these values manually works fine, but not dynamically in a loop. Do I cast explicitValues[key] = (obj as any)[key] and get it over with, or is there a better way to do this?

Link to TS playground, if that's helpful.

There's quite a bit going on in this code not directly related to your question; your isExplicit() type guard function doesn't seem to have a place from which to infer T, so it becomes unknown. You are testing obj[key] and then hoping it will be narrowed afterward, but that doesn't work in TS (see github.com/microsoft/TypeScript/issues/10530). The "unexpected intersection" is arguably due to github.com/microsoft/TypeScript/issues/30581, but there's so much other stuff going on right now. Could you pare down to a minimal reproducible example that doesn't have these other issues? — jcalz
– jcalz, Commented May 18, 2022 at 2:28
The refactoring necessary to put all this in a way the compiler can see is (mostly) type safe looks like this. I'd be happy to write up an explanation for some of it, but there are a lot of moving parts that are essentially digressions from your question (writing a generic ExplicitValue<T>, making isExplicit() work, dealing with Partial, etc). If you could cut all of that out of the question so the answer doesn't have to either explain it or ignore it, that would be ideal. — jcalz
– jcalz, Commented May 18, 2022 at 2:46
Okay I'll write up an answer when I get a chance; might not be until tomorrow though — jcalz
– jcalz, Commented May 19, 2022 at 2:34
I'm going to remove the optional modifier on the props of Implicit and turn back on --strictNullChecks, unless your question actually depends on these — jcalz
– jcalz, Commented May 19, 2022 at 14:30

jcalz · Accepted Answer · 2022-05-19 18:22:37Z

The primary issue here is that since k is of a union type, then the compiler sees obj[k] as having a union type too:

const objk = obj[k];
/*  string | number | { value: number; } | { value: string; } */

Even if you eliminate the primitives from that, obj[k] is still of a union type:

if (typeof objk === "object") {
  objk; /* { value: number } | { value: string } */
}

So all the compiler knows is that you have a value objk of type {value: number} | {value: string} and a key k of type keyof Implicit, and you are trying to assign expl[k] = objk where expl is of type Explicit. And in general, that is not safe. As far as the compiler can see, it's possible that k will be "someNumber" while objk will be of type {value: string}:

expl[k] = objk; // error!
// Type '{ value: number; }' is not assignable to type '{ value: string; }'

(If you're curious as to why the error message involves the intersection, see microsoft/TypeScript#30769. If you have an object t of type T and a (nongeneric) key k of type K1 | K2 and you want to assign a value to t[k], then the only safe thing to assign would be something applicable to both T[K1] and T[K2], or T[K1] & T[K2]. When you read t[k] you get T[K1] | T[K2], but when you write t[k] you need T[K1] & T[K2].)

We know that's impossible, because we know that both k and objk are correlated, but the type system can't track that. Hence the error. This lack of support for correlated union types is the subject of microsoft/TypeScript#30581.

The simplest way to deal with this is just to use a type assertion. When you know more than the compiler does about the type of some expression, you can just tell the compiler this information. Or you can just tell the compiler not to worry with an any assertion:

expl[k] = obj[k] as any; // I know what I'm doing

That's fine, but it takes some of the responsibility for type safety away from the compiler and places it on you. If you wrote the wrong thing the compiler won't catch it:

expl[k] = obj["someNumber"] as any; // oops

If you want to get some more type safety guarantees from the compiler, you will need to use generics instead of unions, and in particular you need to refactor your Explicit and Implicit types to be generic and depend on a common interface, so that the assignment expl[k] = objk is seen to be an assignment where both sides are the same in terms of that interface and a generic key K.

The approach is described in microsoft/TypeScript#47109, a fix for microsoft/TypeScript#30581 (interestingly enough the refactoring here works without the changes in that pull request, as most of the mechanics were already part of the language).

If you have an object t of type T, a key k of generic key type K, and a value v of type T[K] (which will also be generic), then the compiler will allow you to write t[k] = v, even though the same assignment would fail if K were a non-generic union. (This turns out to be unsafe for the same reason, but the compiler allows it. As long as we're careful not to specify K with a union-type, it's fine.)

Here's how it looks:

interface Base {
  someNumber: number;
  someString: string;
}

type Explicit<K extends keyof Base = keyof Base> =
  { [P in K]?: { value: Base[P] } };

type Implicit<K extends keyof Base = keyof Base> =
  { [P in K]: Base[P] | { value: Base[P] } };

The Explicit and Implicit types without a type parameter evaluate to the same as your original versions, but now you can write Explicit<K> for some particular key and the compiler will know that it has a(n optional) property at that key of the corresponding shape.

Now let's write a generic assign() function that performs the assignment you're doing in your for loop:

function assign<K extends keyof Base>(
  k: K,
  expl: Explicit<K>,
  objk: Base[K] | { value: Base[K] }
) {
  if (typeof objk === 'object') {
    expl[k] = objk  // okay
  } else {
    expl[k] = { value: objk }  // okay
  }
}

This compiles without errors, because in both cases you are assigning a value of type {value: Base[K]} to a property of the same generic type. And you can see you're getting more type safety than with the type assertion, since the compiler will complain about assigning random other stuff to expl[k]:

const obj: Explicit = null!    
expl[k] = obj; // error!

Once you have assign(), you can call it inside of convert():

function convert(obj: Implicit) {
  const expl: Explicit = {};
  let k: keyof typeof obj;
  for (k in obj) {
    assign(k, expl, obj[k]); // okay
  }
}

Note that you don't need to declare a separate assign() function, but you do need a generic function somewhere. It could be a callback to a forEach(), or an inline function:

function convert(obj: Implicit) {
  const expl: Explicit = {};
  let k: keyof typeof obj;
  for (k in obj) {
    (<K extends keyof Base>(
      k: K, expl: Explicit<K>, objk: Base[K] | { value: Base[K] }
    ) => expl[k] = (typeof objk === 'object') ? objk : { value: objk })(
      k, expl, obj[k]
    );
  }
}

And there you go! This refactoring might not be worth the trouble; a type assertion is also fine if you're careful enough.

Playground link to code

Wow, amazingly clear. Thank you so much! After reading through some of those issues on github, I'm convinced you should write a book on all the little idiosyncratic behaviors of TS! Thanks again

Collectives™ on Stack Overflow

For-in loop converting TypeScript types to intersection?

Edit: Updated, minimal example (hopefully):

Previous question:

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

Edit: Updated, minimal example (hopefully):

Previous question:

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related