Use fetcher on serialized key

[Sangkwun]

As everyone knows, useSWR caches fetcher results based on the key.
I used a custom fetcher to handle asynchronous requests.
The key is passed to the argument of the fetcher.

There is some inconvenience in this process.

If using the same arguments, you will use the same key.
Using the same arguments will use the same cache even if the fetcher is different.
Even if the keys are the same, if the fetcher is different, I think the cached data should be separated.

In my opinion, there is no reason why the results should be the same if the fetcher is different.
To fix it, what do you think about using the fetcher on serializing the key?

[shuding]

I think the key is the identifier of the resource, but fetcher is just a way to get that resource. So using the same key but different fetchers doesn't make sense to me, maybe you can add an extra argument to mark them as different:

useSWR([arg, 'type1'], fetcher1)
useSWR([arg, 'type2'], fetcher2)

[Sangkwun]

@shuding
I also solved like your suggestion but using key arguments.

useSWR({
 arg,
 key: 'type1'
}, fetcher1)
useSWR({
 arg,
 key: 'type2'
}, fetcher2)

I was wondering if it was right to give additional information while the information about the fetcher was already given.
In case only the URL is a key, there will be no problem with other fetchers.
If Fetcher is an async function, situations can occur with the same arguments caching.
In this situation, it is questionable whether it is practical to share the same cache when the keys are the same and the fetcher is different.

[shuding]

when the keys are the same and the fetcher is different

I think that to make the caching modal consistent and safe, you should not do this. "Fetcher" is just a way to retrieve the data for the given key from the source of truth. The cache should be the same no matter how you implement the fetcher.

Like add(1, 1) should always return 2, it doesn't depend on how you implement the add function. add should be pure.

[Sangkwun]

I totally agree with the key's role.
And I understood the opinions about fetcher and key well.

From a different perspective, I thought it would be okay to look at the key differently like arguments.
we can use [1,1] for arguments for add function.
and result of substract with [1,1] is different.

I agree it's against swr's caching strategy.
I was curious about other people's opinions.