readonly unknown[] doesn't accept proper type | TypeScript Community | Page 1

last wharfBOT Sep 30, 2023, 1:53 PM

#

onkeltem#0

Playground Link

Preview:```ts
type Client1 = {}
type Client2 = {}
type Clients = Client1 | Client2

type TupleIndices<T extends readonly unknown[]> =
Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

function asd<T>(
clients: [
...(T extends readonly Clients[] ? T : never)
]
) {
...```

ruby barn Sep 30, 2023, 1:53 PM

#

Can anybody tell what is going in here?

#

Type 'T' does not satisfy the constraint 'readonly unknown[]'.(2344)

#

How comes? it's the same type

#

Another variant, w/o readonly:

last wharfBOT Sep 30, 2023, 1:54 PM

#

onkeltem#0

Playground Link

Preview:```ts
type Client1 = {}
type Client2 = {}
type Clients = Client1 | Client2

type TupleIndices<T extends unknown[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

function asd<T>(
clients: [...(T extends Clients[] ? T : never)]
) {
...```

ruby barn Sep 30, 2023, 1:55 PM

#

This one is even more confusing:

Type 'T' does not satisfy the constraint 'unknown[]'.(2344)

#

oops

#

wait

last wharfBOT Sep 30, 2023, 1:56 PM

#

onkeltem#0

Playground Link

Preview:```ts
type Client1 = {}
type Client2 = {}
type Clients = Client1 | Client2

type TupleIndices<T extends any[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

function asd<T>(
clients: T extends Clients[] ? [...T] : never
) {
...```

ruby barn Sep 30, 2023, 1:57 PM

#

the same...

#

If T extends Clients[] and it's a tuple [...T] then why it's not bloody any[]?

astral inlet Sep 30, 2023, 1:58 PM

#

It still allows calling with any other generic type (but no args)

astral inlet Sep 30, 2023, 1:59 PM

#

ruby barn If `T extends Clients[]` and it's a tuple `[...T]` then why it's not bloody `a...

only gets recognised as a tuple inside the condition/args
Anywhere else it doesn't

ruby barn Sep 30, 2023, 2:00 PM

#

Ah, I see

#

I should have used: type A = TupleIndices<typeof clients>

astral inlet Sep 30, 2023, 2:00 PM

#

Doubt that works

#

Why not asd<T extends readonly Clients[]> ?

ruby barn Sep 30, 2023, 2:05 PM

#

I don't know, I will try @astral inlet

#

I think it won't work later on

#

Consider an example:

#

class Foo<T extends Clients[]> {
  clients: T
  constructor(clients: [...T]) {
    this.clients = clients
  }
}

#

Here clients will be tuple of just array?

#

I think they're gonna be just an array

#

So basically, T extends Clients[] constrain is not enough then.

#

But this one would make it a true tuple, right?

class Foo<T> {
  clients: T extends Clients[] ? [...T] : never
  constructor(clients: T extends Clients[] ? [...T] : never) {
    this.clients = clients
  }
}

astral inlet Sep 30, 2023, 2:11 PM

#

tuples are always readonly arrays btw

ruby barn Sep 30, 2023, 2:12 PM

#

But they should know about their elements, I suppose

#

arrays don't

last wharfBOT Sep 30, 2023, 2:12 PM

#

jakoxb#0

Playground Link

Preview:```ts
type Client1 = {}
type Client2 = {}
type Clients = Client1 | Client2

type TupleIndices<T extends readonly any[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

function asd<T extends readonly Clients[]>(
...clients: T
) {
...```

ruby barn Sep 30, 2023, 2:31 PM

#

Not sure if it's the same problem or not, but here is another snippet.
It's a big example, I tried to make it as simple as it's possible.
I think I could dissect it even more.

last wharfBOT Sep 30, 2023, 2:31 PM

#

onkeltem#0

Playground Link

Preview:```ts
type Client1 = {run(options: {id: number}): void}
type Client2 = {run(options: {uuid: string}): void}
type Clients = Client1 | Client2

type TupleIndices<T extends readonly any[]> = Extract<
keyof T,
${number}

extends `${infer N extends number}
...```

ruby barn Sep 30, 2023, 2:33 PM

#

The problem is:

Argument of type 'GetOptionsType<TClients[TClientId]> | undefined' is not assignable to parameter of type '{ id: number; } & { uuid: string; }'.
  Type 'undefined' is not assignable to type '{ id: number; } & { uuid: string; }'.
    Type 'undefined' is not assignable to type '{ id: number; }'.

in options in the 26th line

#

I thought that it's because of the tuple/array difference

#

The type turns into { id: number; } & { uuid: string; }

#

I suspect GetOptionsType is the culprit

#

Yeah:

type C1orC2 = GetOptionsType<Clients>;

gives: { id: number; } & { uuid: string; } 😕

#

Darn, I continue meticulously hit the same wall with my head with TypeScritp

#

Every time, just the same

#

I almost expect it to be "impossible"

#

I pass an index of the tuple. So it should know what it is. Then I ask it to take that index, apply it on the tuple, and get the function

#

as any seems to the most reasonable solution

spring monolith Sep 30, 2023, 2:49 PM

#

ruby barn The problem is: ``` Argument of type 'GetOptionsType<TClients[TClientId]> | unde...

well that's just because options is optional

#

you get the actual issue if you make it required

#

i think the issue here is that TClientId could be a union, so clientId might not actually align with options

#

that's an issue of the interface

#

it can't be made typesafe

ruby barn Sep 30, 2023, 2:55 PM

#

spring monolith that's an issue of the interface

Is there a workaround?

#

No error here:

#

But it's not the same I suppose...

#

GetProps is not needed 🙂

last wharfBOT Sep 30, 2023, 2:56 PM

#

onkeltem#0

Playground Link

Preview:```ts
type A = {id: number}
type B = {uuid: string}

type TupleIndices<T extends readonly any[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

class Foo<T extends readonly (A | B)[]> {
constructor(public items: [...T]) {}

foo<K ex
...```

spring monolith Sep 30, 2023, 2:58 PM

#

that.. seems unsound

ruby barn Sep 30, 2023, 2:58 PM

#

here is a shorter one

#

with function

#

Sorry, again..

last wharfBOT Sep 30, 2023, 2:59 PM

#

onkeltem#0

Playground Link

Preview:```ts
type A = {run: (options: {id: number}) => void}
type B = {run: (options: {uuid: string}) => void}

type TupleIndices<T extends readonly any[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

type GetOptionsType<T extends A | B> =
T["run"] extends (options: infer K) => any
? K
: never
...```

ruby barn Sep 30, 2023, 2:59 PM

#

I guess this one is the minimal test case I can come up with

last wharfBOT Sep 30, 2023, 3:01 PM

#

that_guy977#0

Playground Link

Preview:ts ... const x = new Foo([{ id: 0 }, { uuid: "" }]); // ^? x.foo<0 | 1>(0, { uuid: "" }); console.log(x); // Foo: { "items": [{ "uuid": "" }, { "uuid": "" }] } // mismatch to type argument const wrong = x.items[0] // ^? console.log(wrong); // mismatch to type console.log(wrong.id.toString()); // runtime error ...

spring monolith Sep 30, 2023, 3:01 PM

#

last wharf

ts not erroring here is a false negative

ruby barn Sep 30, 2023, 3:03 PM

#

Omg, I see!

#

So how to do it in TS anyway? The task is obviously a real one. That TS extends K to allow for a union seems to be an issue of TS

#

Obviously I don't want it, and that's not what I was intended to do, right?

#

It should be possible to do this: x.foo<0 | 1>(0, { uuid: "" });

#

It must be either 0, or 1, but not at the same time

spring monolith Sep 30, 2023, 3:08 PM

#

ruby barn So how to do it in TS anyway? The task is obviously a real one. That TS extends ...

it's part of ts' design

#

this kind of interface just doesn't work well in ts

ruby barn Sep 30, 2023, 3:09 PM

#

What interface, key parameter in a generic?

spring monolith Sep 30, 2023, 3:10 PM

#

"interface" as in "way to interact with thing"

#

having a method that takes 2 parameters that need to align in a key-value kind of way doesn't work well in ts

ruby barn Sep 30, 2023, 3:12 PM

#

It also affects nested functions I guess

#

What would be a lesser evil in this case?
I can think about as any:

last wharfBOT Sep 30, 2023, 3:13 PM

#

onkeltem#0

Playground Link

Preview:```ts
type A = {run: (options: {id: number}) => void}
type B = {run: (options: {uuid: string}) => void}

type TupleIndices<T extends readonly any[]> = Extract<
keyof T,
${number}

extends ${infer N extends number}
? N
: never

type GetOptionsType<T extends A | B> =
T["run"] extends (options: infer K) => any
? K
: never
...```

ruby barn Sep 30, 2023, 3:14 PM

#

  this.items[index].run(options as any)

spring monolith Sep 30, 2023, 3:17 PM

#

any is absolutely the greater evil

ruby barn Sep 30, 2023, 3:17 PM

#

Meh

spring monolith Sep 30, 2023, 3:17 PM

#

imo, redesign the interface

ruby barn Sep 30, 2023, 3:18 PM

#

How? I pass a class a set of clients, it stores them. Then when I call run it should run one by index

#

It's btw an internal method, there will be another one, which calls it, it runs all of them

last wharfBOT Sep 30, 2023, 3:20 PM

#

that_guy977#0

Playground Link

Preview:```ts
...
class Foo<T extends readonly (A | B)[]> {
constructor(public items: [...T]) {}

foo<K extends TupleIndices<T>>(index: K): T[K] {
return this.items[index]
}
}
...```

spring monolith Sep 30, 2023, 3:20 PM

#

something like this would work

#

and since items is public, you don't even need foo

#

wait a minute.

#

oh nvm

ruby barn Sep 30, 2023, 3:24 PM

#

Thanks @spring monolith I got it. But I've just realized another thing: I can't use options. As simple as that

#

Because how the heck I was going to runAll(), if they all takes different options

#

So all the options I should keep in the items, when they're being created

#

something like:

type A = { options: {id: number}, run: () => void };
type B = { options: {uuid: string}, run: () => void };

#

so they're free to use them, because they will belong to them then

spring monolith Sep 30, 2023, 3:27 PM

#

ruby barn Because how the heck I was going to `runAll()`, if they all takes different opti...

i mean, if you don't need different options, you could pass an object that fulfills every object's options. which would be an intersection of the options types, like you saw in the error before

#readonly unknown[] doesn't accept proper type