Conditional Types - Checking extends never only works sometimes

[dsherret]

TypeScript Version: 2.9.0-dev.20180405

Search Terms: "extends never"

Code

I am writing a function for testing conditional types and I'd like to write it like this:

function assert<T extends true>(expectTrue: T extends never ? false : true) {
}

// or even
function assert<T extends true>(expectTrue: T extends true ? true : false) {
}

That way I can write:

type IsNullableType<T> = T extends null | undefined ? true : never;

const result = functionUnderTest(someParam);

assert<IsNullableType<typeof result>>(true);
// or
assert<IsNullableType<typeof result>>(false);

So given this:

assert<IsNullableType<string>>(false);

Expected behavior:

• The type of the parameter resolves to false.
• No error.

Actual behavior:

• The type of the parameter resolves to never.
• false is not assignable to never.

Example where extends never works:

type IsNonNullableType<T> = IsNullableType<T> extends never ? true : never;
assert<IsNonNullableType<string>>(true); // no compile error, works fine

// this doesn't cause a compile error in playground, but it correctly throws a compile error in the latest version
assert<IsNonNullableType<string | undefined>>(true); // compile error, as expected

Playground Link: Link.

Basically, an IsNeverType check does not work: type IsNeverType<T> = T extends never ? true : never;

---

Edit: By the way, this is probably a better way to do my check:

export type IsNullableType<T> = Extract<T, null | undefined> extends never ? false : true;

[dsherret]

I'm just thinking this might be expected behaviour. So when a type is passed never (as T) and there's an expression like T extends ... ? ... : ..., then it will resolve that entire T extends ... ? ... : ... to never?

Anyway, I resolved my issue by making everything work with true or false, which is what I probably should have been doing from the start anyway... just couldn't figure out the right way to do it, but Extract helped.

[jack-williams]

IsNeverType needs to be implemented like:

type IsNeverType<T> = [T] extends [never] ? true : never;

to stop it being distributive.

[RyanCavanaugh]

Seems like a bug to me?

// Actual instantiation of 'T' shouldn't matter - conditional returns 'number' either way
function assert<T>(expectTrue: T extends never ? number : number) { }
// OK
assert<boolean>(0);
assert<string>(0);
assert<true>(0);
// Error; argument of type '0' not assignable to 'never'
assert<never>(0);

[jack-williams]

As far as my understanding goes the conditional doesn't always return number, it can also return never because it may distribute over nothing.

// Ensure conditional is always `number`.
function assert<T>(expectTrue: [T] extends [never] ? number : number) { }
// OK
assert<boolean>(0);
assert<string>(0);
assert<true>(0);
assert<never>(0);

[RyanCavanaugh]

After reading the code I agree with @jack-williams 's assessment. In this case never behaves as the empty union, so it distributes over the conditional and produces another empty union (which is just never again)

[dsherret]

@RyanCavanaugh good to know! Thanks for looking into this and explaining the behaviour.

@jack-williams thanks a lot for that trick! Very helpful! 😄

[jcalz]

Holy cow, this just bit me. The empty union!

[pie6k]

I've created simple helper type

type NeverAlternative<T, P, N> = [T] extends [never] ? P : N;

// and then
type VariableLengthArray<A, B = never, C = never> =
  //
  NeverAlternative<
    C,
    NeverAlternative<B, [A], [A, B]>,
    NeverAlternative<
      B,
      [A, C],
      [A, B, C]
    >
  >;

type Foo = VariableLengthArray<1,2> // type [1, 2]
type Bar = VariableLengthArray<1,2,3> // type [1, 2, 3]

[loynoir]

@jack-williams WOW! Awesome! Thanks a lot!

Is it safe to change return never to return false?

// type IsNeverType<T> = [T] extends [never] ? true : never;
type IsNeverType<T> = [T] extends [never] ? true : false;

[SyMind]

After reading the code I agree with @jack-williams 's assessment. In this case never behaves as the empty union, so it distributes over the conditional and produces another empty union (which is just never again)

Where is the code to do these things? The TypeScript checker code is very complex. I can't find the specific code.