coroutine | A asymmetric coroutine library for C | Android library

You can just call it this way as it recommends in the docs here

Example from the docs:

MainCoroutineRule and runBlocking are seemingly similar but there are clear differences.

Defenition of MainCoroutineRule:

MainCoroutineRule installs a TestCoroutineDispatcher for Disptachers.Main. Since it extends TestCoroutineScope, you can directly launch coroutines on the MainCoroutineRule as a [CoroutineScope]...

Defenition of runBlocking:

Runs a new coroutine and blocks the current thread interruptibly until its completion. This function should not be used from a coroutine. It is designed to bridge regular blocking code to libraries that are written in suspending style, to be used in main functions and in tests. ...

In terms of definition, runBlocking is used for the sole purpose of synchronous execution in coroutines. It is not only used in tests but also used in UI management, Data Management, and several other areas in Android Development.

Whereas runBlocking is used more generally, MainCoroutineRule is used only in tests and it has the same synchronous execution behavior found in runBlocking. However, MainCoroutineRule has more specialized testing features not found in runBlocking such as control flow management. In addition, using MainCoroutineRule will significantly make your testing code cleaner.

In a much more detailed manner, MainCoroutineRule is directly related to JUnit Rule. If you have used JUnit before, you might remember filling out @Before @After to provide a testing environment for the test cases. If you have multiple test cases, you would eventually have to write multiple @Before @After to provide multiple testing environments, which could possibly lead to redundant boilerplate code. Now, this is where MainCoroutineRule shines! With MainCoroutineRule you can declare a testing environment once and reuse them for multiple test cases.

Compare two sample codes below:

Test case without using MainCoroutineRule

Your problem isn't with how you call gather. It's with how you define main. The clue is with the error message

Your code works, the issue why you are not able to create res successfully is because the code does not raise just the normal Exception class. Since the task fails it ends up calling asyncio.exceptions.CancelledError which if we take a look in the documentation inherits from BaseException not Exception. This change is new as of Python 3.8 and since you are using Python 3.9 that change is live. Changing your code slightly to the following yields:

One idea could be to return the Job in method1 like the following:

I don't think MutableState is designed to be used in the ViewModel layer, since it's an observable integrated with the compose runtime. You could create a MutableStateFlow instead and use collectAsState() from the view layer.

In your case the issue is probably, because of the state is captured in a coroutine invoked outside composition.

Most likely everything you are doing is working as intended. The one mistake would be unexpected behavior with TryAdd, where the value added can be null.

Inside of your OnTriggerEnter2D function, add a check to determine what you collided with to only check for spells. The easiest way to do this is check the tag of the object. For all of your spells, add a tag that you can check against, then change your collision code to look something like

the question is, what is its type?

That question is settled in the same way as any variable declaration with initialization: by the type of what's on the right-hand side of the equal sign.

For example, if you have a method that returns a String (let's name it getMyString), then when you say

lua_yield is a C function, and C does not have a mechanism to magically jump back into a function that has halted. lua_yield uses the C standard library longjmp function to arbitrarily jump out of the function that called it. But it can't come back.

So what happens is that your C function yields, exiting the function and returning control to the Lua code that called coroutine.resume. The resume was successful, so true is printed. You then resume the coroutine again, which begins execution at the site in Lua code that called the C function that yielded. That code then exits the coroutine normally. Since the resume was also successful, true is printed again.

But the coroutine is now exhausted and therefore cannot be resumed.

C functions don't have a clean way to be "resumed". Indeed, the Lua 5.1 documentation explicitly states:

This function should only be called as the return expression of a C function, as follows: