Mimick | A KISS , cross-platform C mocking library | Mock library

When one performs the split, the elements in the list are named. It is possible to extract that list of names and assign it to the results of the pairwise statement.

Would names(p) <- names(Listdf) work for you.

Your RestartSink is restarting (and not in the process restarting anything else): if it wasn't, you would never have gotten 4 sink as output right after 3 Exception. For some reason it's not logging, but that might be due to stream attributes (there's also been some behavioral changes around logging in the stream restarts in recent months, so logging may differ depending on what version you're running).

From the docs for RestartSink:

The restart process is inherently lossy, since there is no coordination between cancelling and the sending of messages. When the wrapped Sink does cancel, this Sink will backpressure, however any elements already sent may have been lost.

This is fundamentally because in the general case stream stages are memoryless. In your Sink.fold example, it will restart with clean state (viz. ""). This does, in my experience, make the RestartSink and RestartFlow somewhat less useful than the RestartSource.

For the use-case you describe, I would tend to use a mapAsync stage with akka.pattern.RetrySupport to send HTTP requests via a Future-based API and retry requests on failures:

I think a simple way to do this is using the lag function from dplyr package. I used case_when to check if the id changed. If it didn't change, you add the extra term, otherwise you add 0.

The second task is not waiting for the first task, which runs on a separate thread, to finish. This can be illustrated if you do something time consuming in the first task and you will see the second task is not waiting at all.

Using Task { … } is more akin to DispatchQueue.global().async { … } than to DispatchQueue.main.async { … }. It starts first on a separate thread. This introduces a race between first and second and you have no assurances as which order they will run. (In my tests, it runs second before first most of the time, but it can still occasionally run first before second.)

So, the question is, do you really care which order these two tasks start? If so, you can eliminate the race by (obviously) putting the Task { await first() } after the call to second. Or do you simply want to ensure that second won’t wait for first to finish? In that case, this already is the behavior and no change to your code is required.

You asked:

What if await first() needs to be run on the same queue as second() but asynchronously. … I am just thinking [that if it runs on background thread that it] would mean crashes due to updates of UI not from the main thread.

You can mark the routine to update the UI with @MainActor, which will cause it to run on the main thread. But note, do not use this qualifier with the time-consuming task, itself (because you do not want to block the main thread), but rather decouple the time-consuming operation from the UI update, and just mark the latter as @MainActor.

E.g., here is an example that manually calculates π asynchronously, and updates the UI when it is done:

You need to set retain_graph=True if you want to make multiple backward passes over the same computational graph, making use of the intermediate results from a single forward pass. This would have been the case, for instance, if you called loss.backward() multiple times after computing loss once, or if you had multiple losses from different parts of the graph to backpropagate from (a good explanation can be found here).

In your case, for each forward pass, you backpropagate exactly once. So you don't need to store the intermediate results from the computational graph once the gradients are computed.

In short:

• Intermediate outputs in the graph are cleared after a backward pass, unless explicitly preserved using retain_graph=True.
• Gradients accumulate by default, unless explicitly cleared using zero_grad.

You need to obtain the format token of duration and use it as pattern in your request body.

To do that:

1. Highlight any cell and change its cell format to Duration
2. In the same cell, Navigate to Number -> More formats -> Custom number format.
3. Copy the existing format token. For duration it should be [h]:mm:ss.
4. Replace the value of pattern in your request body with [h]:mm:ss
5. Replace the value of type to DATE_TIME

Your request body should look like this:

This came down to rejected headers. Short version: any rejected header in API Gateway will cause a 404. This is a working curl:

If you have duplicate inputs for a given output, then assuming you don't care to count them or treat them any differently, then all methods below work by replacing df with unique(df). (One can also use dplyr::distinct if preferred.)

Once you've resolved uniqueness, then ... this is "just" reshaping/pivoting from long to wide.

stats::reshape is a little hard to work with, and it requires some things that are not uniquely present. For example, it requires idvar and the v.names variables to be unique columns (so we duplicate Input):

The documentation says:

The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

So if your process has open file descriptors 0, 1, and 2, but not 3, it will return 3.

If your process has open file descriptors 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, and 25, but not 26, it will return 26.

This is how file descriptors are usually assigned in Linux.