Type 'X<false>' is not assignable to type 'X<boolean>'.

[tomhanax]

Bug Report

Since 4.6 TS is complaining about that false is not assignable to boolean, when it is "wrapped by interface".

🔎 Search Terms

4.6 type

🕗 Version & Regression Information

• This is a compile problem
• This changed between versions 4.5.5 and 4.6

⏯ Playground Link

Playground Link

💻 Code

interface Observable<T>
{
  (): T;
  (value: T): any;
}

function observable<T>(value: T): Observable<T>
{
  return undefined as any;  // the implementation is not important
}

const x: Observable<boolean> = observable(false);

🙁 Actual behavior

Type 'Observable<false>' is not assignable to type 'Observable<boolean>'.
  Types of parameters 'value' and 'value' are incompatible.
    Type 'boolean' is not assignable to type 'false'.

🙂 Expected behavior

No compiler problem as in previous versions.

[whzx5byb]

I believe this is a correct error which was not handled properly in old versions.
The generic parameter T is invariant as it is used in both a covariant position () => T and a contravariant position (value: T) => any.

[tomhanax]

@whzx5byb Suppose this is correct behavior, can you suggest how to continue to use the sketched concept? The interface in fact represents the core concept of Knockout.js library.

To set value to x - use x(val).
To read value from x - use x().

If x is defined to operate on boolean, It is very illogical that I can not set true or false as val. Of course I can cast to boolean, but is it the correct way? And is it the only way?

[whzx5byb]

If x is defined to operate on boolean, It is very illogical that I can not set true or false as val. Of course I can cast to boolean, but is it the correct way? And is it the only way?

A way to make your example work:

function observable<T>(value: T extends infer U ? U: never): Observable<T>
{
  return undefined as any;  // the implementation is not important
}

const x: Observable<boolean> = observable(false); // no error

[tomhanax]

@whzx5byb Just perfect, thanks!
I do not know if it is appropriate here, but if you want, you could post this as answer on https://stackoverflow.com/questions/71319489/type-observablefalse-is-not-assignable-to-type-observableboolean (there is a small bounty if you care). Or I could do it using the code you proposed if you have no interest. Please give me the info, I will close this bug then.

[bennieswart]

@tomhanax perhaps this should be referred to the knockout project so that the necessary changes can be made there.

[tomhanax]

@tomhanax perhaps this should be referred to the knockout project so that the necessary changes can be made there.
Done: knockout/knockout#2589, hope that somebody there will pick that up, because the project seem to go to winter sleep for good.

[whzx5byb]

@tomhanax I don't care, you could post it yourself.

[fatcerberus]

For the record, the reason for the type error:

const oFalse: Observable<false> = observable(false);
const oBool: Observable<boolean> = oFalse;
oBool(true);
// now Observable<false> has value true

[whzx5byb]

@tomhanax

The answer in #48150 (comment) is not perfect, as it will produce unknown without a type annotation.

const bad = observable(false);
//     ^ unknown, which should be Observable<boolean>

The issue here is the inference T extends infer U ? U : never infers U from the LHS of assignment. But when there is none, the default constraint type unknown will be used.

Here is an alternative workaround which will produce the same behavior without a type annotation, but a bit more verbose. I have to introduce two type parameter. T is for the refered type which is from LHS. U is for the "raw" widening type, which will be used only when T is unknown.

declare function observable<T, U>(value: T extends infer R ? R : U): unknown extends T ? Observable<U> : Observable<T>;

I'm not sure if there is a better solution. If you find some please let me know.

[maskmaster]

Cross-posting here, just for the record. Make sure that also both these lines are valid with any new proposal.

const x = observable<false | undefined>(false);
const y = observable(false);

[mbest]

@tomhanax I think this should be fixed in TypeScript. The "fixes" for the Knockout code don't make much sense.

Consider that this code has the correct result:

const a = observable(false);    // Observable<boolean>

But this one errors:

const a: Observable<boolean> = observable(false);

Also that this works:

const a: Observable<string> = observable('cash'); 

But not this:

const a: Observable<'cash' | 'card'> = observable('cash'); 

Playground Link

[tomhanax]

@mbest, the "most updated" playground (see also knockout/tko#168 (comment)) contains many examples and seems OK, of course anybody can check and correct if needed, I am no expert in this.

Playground Link

I am not saying anything about what "should" be fixed, I am no expert at all. Simply trying to help to solve existing issue, because now we are forced to remain on TS 4.5 until this is solved.