Deferred | Work with values | Reactive Programming library

Are you sure it fails because it attempts to call the creteFinalObject function? Because when reading your code, I think that should be impossible (of course, never say never :D). The creteFinalObject function can only be called if both object1.await() and object2.await() return successfully.

I think something else is going on. Because you're doing 2 separate async tasks (getting object 1 and getting object 2), I suspect that the ordering of these 2 tasks would result in either a success or a failure.

Running your code locally, I notice that it sometimes fails at this line:

verify(atMost = 1) { bringObject2FromSomewhere() }

And I think there is your error. If bringObject1FromSomewhere() is called before bringObject2FromSomewhere(), the exception is thrown and the second function invocation never happens, causing the test to fail. The other way around (2 before 1) would make the test succeed. The Dispatchers.Default uses an internal work queue, where jobs that are cancelled before they are even started will never start at all. And the first task can fail fast enough for the second task to not being able to start at all.

I thought the fix would be to use verify(atLeast = 0, atMost = 1) { bringObject2FromSomewhere() } instead, but as I see on the MockK GitHub issues page, this is not supported (yet): https://github.com/mockk/mockk/issues/806

So even though you specify that bringObject2FromSomewhere() should be called at most 1 time, it still tries to verify it is also called at least 1 time, which is not the case.

You can verify this by adding a delay to the async call to get the first object:

# Global singleton provides a data set, i.e.

If you already have an autoload (singleton), I would put there the information you want to give the other scene, and have the other scene read it.

I understand that change_scene() is "deferred" so we cant just straight away call a "setter" function for this scene, or can we?

Correct, you can't. For the instant where the new scene is loaded the current one is already unloaded, so it can't really call a method on the new one.

Unless you take control of the process. See Change scenes manually.

I prediction the exact speed difference between them. if is faster. But for legibility reasons, where is the most commonly used route. You can understand where like a sql query. Here, it filters some data from the data collection and reveals the ones that are suitable for you. Looks like T-Sql.

The problem is that you can only destructure the Pair this way, but not the Deferred itself.

You could first assign the deferred value to a single variable, and later await it so you get a Pair that you can destructure:

In some sense, the mess you experience is a consequence of Kotlin coroutines having been an early success, before they became stable. In their experimental days, one thing they lacked was structured concurrency, and a ton of web material got written about them in that state (such as your link 1 from 2017). Some of the then-valid preconceptions remained with people even after their maturation, and got perpetuated in even more recent posts.

The actual situation is quite clear — all you have to understand is coroutine hierarchy, which is mediated through the Job objects. It doesn't matter whether it's a launch or an async, or any further coroutine builder — they all behave uniformly.

With this in mind, let's go through your examples:

Replace async with this@coroutineScope.async.

There must be some other function in your scope called async that has a higher priority resolution than CoroutineScope.async inside your coroutineScope lambda. The coroutineScope lambda is passed a CoroutineScope as the receiver, so this@coroutineScope.async will clarify that you specifically mean to call CoroutineScope.async on the receiver of the lambda and not some other async function.

I'm not familiar with Spring so I don't have any guesses what the other async function is. You might be able to change your imports in this file such that async will resolve to CoroutineScope.async without you having to prefix it with this@coroutineScope. If you want to find out what other function it is resolving to, remove the prefix and Ctrl+Click the function name async and the IDE will take you to the source code for it.

You seem to be using Windows cmd to run the command, and hence you are getting the error.

The command:

The fiddle

Terms to review:

• aggregate function
• functional dependence

Given GROUP BY name, this generates a result containing one row for each distinct name value found. So if there were 2 professors each with a different name (example: 'prof1' and 'prof2'), GROUP BY name would generate a result for each of those groups, and your subsequent COUNT(DISTINCT prof_id) expression would just find one professor in each group, the id of 'prof1' in group 1 and the id of 'prof2' in group 2.

Basically, you didn't want to include FirstName or LastName in your GROUP BY terms, since that causes each professor with a different name to form a separate group in your results. You wanted to just do something like this, over all professors in the chosen Semester:

async/await might not be the proper paradigm if you want cancellation. The reason is that the new structured concurrency support in Swift allows you to write code that looks single-threaded/synchronous, but it fact it's multi-threaded.

Take for example a naive synchronous code: