Slice | simplifies Sling/AEM development | Dependency Injection library

Let me preface this by: generally, you probably shouldn't.

RTK-Query is a full cache solution - so you should usually not copy state out of it in most solutions, but let RTK-Query keep control over that data.
If you want to change it, temporarily copy it over into local component state (this goes for all kind of form states by the way, you should not edit a form in-place in redux, but temporarily move it over to local component state), use a mutation to save it back to the server and then let RTKQ re-fetch that data to update the cache. Wherever you need that data, just call useGetPostsQuery() and you're good - if that data is not yet fetched, it will get fetched, otherwise you will just get the value from cache.

Oh, bonus: you should not create an extra api per resource. You should have one single createApi call in your application in almost all cases - you can still split it up over multiple files using Code Splitting.

All that said, of course you can copy that data over into a slice if you have a good use case for it - but be aware that this way you now are responsible for keeping that data up-to-date and cleaning it up if you don't need it any more. Usually, RTKQ would do that for you.

Here is an example on how to clone data from a query over into a slice, taken from the RTKQ examples page:

Edit: see blackgreen's answer, which I also found later on my own while scanning through the same documentation they linked. I was going to edit this answer to update based on that, but now I don't have to. :-)

There is probably a better way—this one seems a bit clumsy—but I was able to work around this with reflect:

The issue you're hitting is that -0 is the same as 0, and x[0:0] is an empty slice.

I'd suggest:

I've passed your code through gotip that uses a more evolved implementation of the proposal and it does not complain about that part of the code, so I would assume that the problem is with the go2go initial implementation.

Please note that your implementation will not work since you can definitely use parametric interfaces in type assertion expressions, but you can't use interfaces with type lists as you are doing in testDifference[intOrString]

As far as I understood, here's a dplyr suggestion:

With dict[str:int] the hint you are passing is dict whose keys are slices, because x:y is a slice in python.

The dict[str, int] passes the correct key and value hints, previously there also was a typing.Dict but it has been deprecated.

This will produce an immutable slice of an Option:

Both historical and logical reasons.

Back in the days, before impl [T], sort first used cmp() instead of lt(). That changed about 5 years ago for optimization reasons. At that point, the constraint could have been changed from Ord to PartialOrd. And truly, it sparked another discussion about PartialOrd and Ord.

However, there's a logical reason too: for any two indices i and j within [0..values.len()] and i <= j, you expect the following to hold if values has been sorted: