Why does my conditional return type always have undefined or unknown values? | TypeScript Community | Page 1

glad violet Sep 21, 2023, 2:03 AM

#

// sanity checks
type unknownExtendsUnknown = unknown extends unknown ? true : false;
//   ^?
type undefinedExtendsUnknown = undefined extends unknown ? true : false;
//   ^?
type unknownExtendsUndefined = unknown extends undefined ? true : false;
//   ^?

export const keyValueTypes = <T extends PropertyDescriptorMap>(
  obj: T
): // prettier-ignore
{
  [Key in keyof T]: 
  /* if */ unknown extends T[Key]['value'] ? /* then return */ T[Key]['value'] : 
  /* else if */ T[Key]['get'] extends (...any: any[]) => any ? /* then return */ ReturnType<T[Key]['get']> :
  /* else if */ T[Key]['set'] extends (...any: any[]) => any ? /* then return */ Parameters<T[Key]['set']>[0] : 
  /* else return */ undefined
} => {
  return {} as any;
};

const fn = () => 'hi';
const fn2 = (val: string) => {};
const x = keyValueTypes( {
  //  ^?
  // WHY undefined and unknowns only????
  v: { value: fn },
  v2: { value: 5 },
  getFn: { get: fn },
  getFn2: { get: fn, set: fn2 },
});

#

I don't know what I'm doing wrong here. I've simplified it to the point where looks straightforward to me. Why is this returning unknowns and undefined values?

#

!pg

#

!pg

chilly orbitBOT Sep 21, 2023, 2:10 AM

#

View in Playground

glad violet Sep 21, 2023, 2:21 AM

#

Facepalm

#

This works perfectly: I don't understand!

#

// sanity checks
type unknownExtendsUnknown = unknown extends unknown ? true : false;
//   ^?
type undefinedExtendsUnknown = undefined extends unknown ? true : false;
//   ^?
type unknownExtendsUndefined = unknown extends undefined ? true : false;
//   ^?
type stringExtendsUndefined = string extends undefined ? true : false;
//   ^?
type stringExtendsUnknown = string extends unknown ? true : false;
//   ^?
type unknownExtendsString = unknown extends string ? true : false;
//   ^?

export const keyValueTypes = <T extends PropertyDescriptorMap>(
  obj: T
): // prettier-ignore
{
  [Key in keyof T]: 
  /* if */ T[Key]['get'] extends (...any: any[]) => any ? /* then return */ ReturnType<T[Key]['get']> :
  /* else if */ T[Key]['set'] extends (...any: any[]) => any ? /* then return */ Parameters<T[Key]['set']>[0] : 
  /* else return */ T[Key]['value']
} => {
  return {} as any;
};

const fn = () => 'hi';
const fn2 = (val: string) => {};
const x = keyValueTypes( {
  //  ^?
  v: { value: fn },
  v2: { value: 5 },
  getFn: { get: fn },
  getFn2: { get: fn, set: fn2 },
});

#

!pg

chilly orbitBOT Sep 21, 2023, 2:23 AM

#

View in Playground

glad violet Sep 21, 2023, 2:23 AM

#

all I did was move the first condition to the bottom

solemn thicket Sep 21, 2023, 12:58 PM

#

Your first condition is unknown extends T[Key]['value']

#

This can never be true unless T[Key]['value'] is unknown.

#

So v and v2 both fails the check, and fails the subsequent getter and setter checks, ending in undefined.

#

For getFn and getFn2, they don't have value so T[Key]['value'] is unknown (you can verify this by changing the map type to always return T[Key]['value']), so they satisfy the first check and immediately return T[Key]['value'], which is unknown.

glad violet Sep 21, 2023, 5:35 PM

#

solemn thicket For `getFn` and `getFn2`, they don't have `value` so `T[Key]['value']` is `unkno...

if that's true, how do I write a condition that says, "if this property has a value?"

#

oh, maybe that doesn't make sense? These are type conditions, not value conditions?

solemn thicket Sep 21, 2023, 5:40 PM

#

Eh yeah you are operating on the type level.

#

The definition is:

interface PropertyDescriptor {
    configurable?: boolean;
    enumerable?: boolean;
    value?: any;
    writable?: boolean;
    get?(): any;
    set?(v: any): void;
}

interface PropertyDescriptorMap {
    [key: PropertyKey]: PropertyDescriptor;
}

#

So I guess there's no way to distinguish missing value vs value is just unknown, since both cases they return unknown.

#

You second solution makes sense though.

glad violet Sep 21, 2023, 5:43 PM

#

I went through an iteration that made absolutely no sense to me but seemed to work. Let me see if I can find it

solemn thicket Sep 21, 2023, 5:44 PM

#

Oh

#

Duh, you can do this:

T[Key] extends { value: infer P } ? P : never

chilly orbitBOT Sep 21, 2023, 5:45 PM

#

bawdyinkslinger#0

Playground Link

Preview:ts // sanity checks type unknownExtendsUnknown = unknown extends unknown ? true : false; // ^? type undefinedExtendsUnknown = undefined extends unknown ? true : false; // ^? type unknownExtendsUndefined = unknown extends undefined ? true : false; // ^? type stringExtendsUndefined = string extends undefined ? true : false; ...

glad violet Sep 21, 2023, 5:45 PM

#

solemn thicket Duh, you can do this: ```ts T[Key] extends { value: infer P } ? P : never ```

ah, I was wondering if there was some way I could use infer here.

#

that type doesn't error locally, may be a tsconfig setting

solemn thicket Sep 21, 2023, 5:46 PM

#

Yeah that ensures value actually exists, and infer is just to pull out the value type.

#

You could also write it as:

T[Key] extends { value: unknown } ? T[Key]['value'] : never

But there's no point in avoiding infer.

glad violet Sep 21, 2023, 5:47 PM

#

solemn thicket Yeah that ensures `value` actually exists, and `infer` is just to pull out the v...

right

glad violet Sep 21, 2023, 5:49 PM

#

chilly orbit

so why does this appear to work? The longer I look at it, the more it feels like I need to negate the conditions

solemn thicket Sep 21, 2023, 5:53 PM

#

solemn thicket Your first condition is `unknown extends T[Key]['value']`

See this

#

This can never be true unless T[Key]['value'] is unknown, in the cases of value is missing (or is actually unknown), it is true so it proceeds to the branches that check for getter and setter.

#

And that also highlights an issue with it, that it cannot properly handle value of unknown.

glad violet Sep 21, 2023, 5:54 PM

#

solemn thicket This can never be true unless `T[Key]['value']` is `unknown`, in the cases of `v...

right, but why does it work correctly then?

solemn thicket Sep 21, 2023, 5:54 PM

#

It doesn't.

#

Try changing to v2: { value: 5 as unknown }.

glad violet Sep 21, 2023, 5:55 PM

#

#

ok

#

ah

solemn thicket Sep 21, 2023, 5:56 PM

#

When value is missing, it gives back unknown, so unknown extends T[Key]['value'] passes, and your code goes on to check for getter and setter.

#

But "value is missing -> gives unknown" is not something you should rely on.

glad violet Sep 21, 2023, 5:57 PM

#

solemn thicket When `value` is missing, it gives back `unknown`, so `unknown extends T[Key]['va...

btw, to me that seems unintuitive

solemn thicket Sep 21, 2023, 5:58 PM

#

Which part?

#

The "value is missing -> gives unknown" part?

glad violet Sep 21, 2023, 5:59 PM

#

yeah

solemn thicket Sep 21, 2023, 5:59 PM

#

Yeah I didn't know about it either 🤷

#

Best to not use it.

glad violet Sep 21, 2023, 6:01 PM

#

solemn thicket Yeah I didn't know about it either 🤷

how did you learn that? How can I figure that out on my own?

#

you always returned T[Key]['value']?

#

no conditional?

solemn thicket Sep 21, 2023, 6:03 PM

#

Yeah just some basic debugging

#

If you don't know why unknown extends T[Key]['value'] is passing when it shouldn't, easiest is to just change it to T[Key]['value'] and see what they are.

#

And by doing that you will find out missing value is treated as unknown.

glad violet Sep 21, 2023, 6:07 PM

#

solemn thicket Yeah just some basic debugging

knowing how to do that debugging is the hardest part for me in these situations

solemn thicket Sep 21, 2023, 6:13 PM

#

Yeah, easiest think about how you would console.log things, and just do it on the type level.

glad violet Sep 21, 2023, 7:04 PM

#

solemn thicket Yeah, easiest think about how you would `console.log` things, and just do it on ...

Yeah maybe it just takes experience, because sometimes I try to use that mentality and it prints typeof ComplexInterface which is rarely helpful. To be honest, I think typescript is severely lacking when it comes to providing feedback on complex types. I'm curious if you disagree

solemn thicket Sep 21, 2023, 7:05 PM

#

Definitely don't disagree, debugging types is not the nicest thing.

#

Especially hover information sometimes is very unhelpful.

glad violet Sep 21, 2023, 9:29 PM

#

Thank you, @solemn thicket

#Why does my conditional return type always have undefined or unknown values?