if !healed {
		h.scannedItemsMap[healType]++
	} else {
		h.healedItemsMap[healType]++
	}

	h.lastHealActivity = UTCNow()
}

// isQuitting - determines if the heal sequence is quitting (due to an
// external signal)
func (h *healSequence) isQuitting() bool {
	select {
	case <-h.ctx.Done():
		return true
	default:
		return false
	}
}

// check if the heal sequence has ended

      one from the check_success function.
    resolve_symlinks: (Bool) Translate symbolic links into the real filepath.
    n_ask_attempts: (Integer) Number of times to query for valid input before
      raising an error and quitting.

  Returns:
    [String] The value of var_name after querying for input.

  Raises:
    UserInputError: if a query has been attempted n_ask_attempts times without

This platform provides specific support for Swift, C++ and C.

### Cross-cutting architecture modules

There are some additional cross-cutting architecture modules that aren't themselves platforms:

#### Enterprise integration

Provides cross-cutting integration with Gradle's commercial product.

#### IDE integration

Provides cross-cutting integration with IDEs and other tooling.

#### Build infrastructure

This platform provides specific support for Swift, C++ and C.

## Cross-cutting architecture modules

There are some additional cross-cutting architecture modules that aren't platforms:

### Enterprise integration

Provides cross-cutting integration with Gradle's commercial product.

### IDE integration

Provides cross-cutting integration with IDEs and other tooling.

### Build infrastructure

Deploying a **FastAPI** application is relatively easy.

## What Does Deployment Mean

To **deploy** an application means to perform the necessary steps to make it **available to the users**.

For a **web API**, it normally involves putting it in a **remote machine**, with a **server program** that provides good performance, stability, etc, so that your **users** can **access** the application efficiently and without interruptions or problems.

 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is
 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the

## Future

By this point, it's already clear that **FastAPI** with its ideas is being useful for many people.

It is being chosen over previous alternatives for suiting many use cases better.

Many developers and teams already depend on **FastAPI** for their projects (including me and my team).

But still, there are many improvements and features to come.

While you are waiting, you go with your crush and pick a table, you sit and talk with your crush for a long time (as your burgers are very fancy and take some time to prepare).

As you are sitting at the table with your crush, while you wait for the burgers, you can spend that time admiring how awesome, cute and smart your crush is ✨😍✨.

<img src="/img/async/concurrent-burgers/concurrent-burgers-05.png" class="illustration">

    }

    throw unknownHostException
  }

  private fun getCacheOnlyResponse(request: Request): Response? {
    if (client.cache != null) {
      try {
        // Use the cache without hitting the network first
        // 504 code indicates that the Cache is stale
        val onlyIfCached =
          CacheControl.Builder()
            .onlyIfCached()
            .build()

                if (receiverExpression !is KtDotQualifiedExpression) {
                    // If the receiver is not a KtDotQualifiedExpression, it means we are hitting the end of nested receivers. In other
                    // words, this receiver expression should be pointing at an unqualified name of a class, whose class ID is
                    // `outerClassId`.