Why do setters use Args extends unknown[] and ...args: Args for their types when you only pass one value?

[AriaFallah]

I'm really confused because the types are currently written as

jotai/src/vanilla/atom.ts

Lines 3 to 10 in 7a68a12

	type Setter = <Value, Args extends unknown[], Result>(
	atom: WritableAtom<Value, Args, Result>,
	...args: Args
	) => Result
	type SetAtom<Args extends unknown[], Result> = <A extends Args>(
	...args: A
	) => Result

But why is the value after atom ...args: Args? I cannot find a single example of set called with more than one argument. Why is it not instead something like newValue: Value | ((oldValue: Value) => Value)?

[dai-shi]

Because we support multiple arguments. This is a huge improvement in Jotai v2.
Yeah, we may not have any examples in docs. Would you mind adding one?

For primitive atoms we set the type like this:

jotai/src/vanilla/atom.ts

Lines 59 to 65 in 7a68a12

	type SetStateAction<Value> = Value | ((prev: Value) => Value)
	export type PrimitiveAtom<Value> = WritableAtom<
	Value,
	[SetStateAction<Value>],
	void
	>

[AriaFallah]

Btw you wrote

Because we support multiple arguments. This is a huge improvement in Jotai v2.

What's the improvement and usecase? I'm having difficulty imagining it to be honest. If I ever wanted multiple arguments, I would either pass an array or an object. How's varargs offer an advantage over this?

[dai-shi]

Well, it's just not for you. People had seemed it's a huge limitation in v1. That's why I said a huge improvement, but it's not something widely used. I only used it once or twice. Don't remember where. Passing an array works and I suggested so in v1.

[dai-shi]

This also supports zero arguments, which wasn't possible in v1. Types are cleaner in this sense too, compared to v1.

[AriaFallah]

Well, it's just not for you

Haha of course. Hope I'm not coming off that way. I'm mostly just curious about the design decisions and what informed them as I learn the library. Varargs APIs make things way way more complex, and wanted to understand the tradeoff that led to that.

[dai-shi]

There's no drawback with ...args except for the types are harder to read. (but it also avoids some hacks, so actually it makes it easier to read for some cases.)