title: Difference between CoroutineScope and coroutineScope in Kotlin
body: <p>Can anyone give clarity between functions <code>CoroutineScope()</code> and <code>coroutineScope()</code>?</p>
  
  <p>When I tried to check in source, I found that both of them are functions of <code>CoroutineScope.kt</code>.  Additionally, <code>coroutineScope()</code> is <code>suspend</code> function while other one is <code>normal</code> function</p>
  
  <p>Below is documentation I could find : </p>
  
  <pre><code>/**
   * Creates a [CoroutineScope] that wraps the given coroutine [context].
   *
   * If the given [context] does not contain a [Job] element, then a default `Job()` is created.
   * This way, cancellation or failure or any child coroutine in this scope cancels all the other children,
   * just like inside [coroutineScope] block.
   */
  @Suppress("FunctionName")
  public fun CoroutineScope(context: CoroutineContext): CoroutineScope =
      ContextScope(if (context[Job] != null) context else context + Job())
  </code></pre>
  
  <p>And</p>
  
  <pre><code>/**
   * Creates a [CoroutineScope] and calls the specified suspend block with this scope.
   * The provided scope inherits its [coroutineContext][CoroutineScope.coroutineContext] from the outer scope, but overrides
   * the context's [Job].
   *
   * This function is designed for _parallel decomposition_ of work. When any child coroutine in this scope fails,
   * this scope fails and all the rest of the children are cancelled (for a different behavior see [supervisorScope]).
   * This function returns as soon as the given block and all its children coroutines are completed.
   * A usage example of a scope looks like this:
   *
   * ```
   * suspend fun showSomeData() = coroutineScope {
   *
   *   val data = async(Dispatchers.IO) { // &lt;- extension on current scope
   *      ... load some UI data for the Main thread ...
   *   }
   *
   *   withContext(Dispatchers.Main) {
   *     doSomeWork()
   *     val result = data.await()
   *     display(result)
   *   }
   * }
   * ```
   *
   * The scope in this example has the following semantics:
   * 1) `showSomeData` returns as soon as the data is loaded and displayed in the UI.
   * 2) If `doSomeWork` throws an exception, then the `async` task is cancelled and `showSomeData` rethrows that exception.
   * 3) If the outer scope of `showSomeData` is cancelled, both started `async` and `withContext` blocks are cancelled.
   * 4) If the `async` block fails, `withContext` will be cancelled.
   *
   * The method may throw a [CancellationException] if the current job was cancelled externally
   * or may throw a corresponding unhandled [Throwable] if there is any unhandled exception in this scope
   * (for example, from a crashed coroutine that was started with [launch][CoroutineScope.launch] in this scope).
   */
  public suspend fun &lt;R&gt; coroutineScope(block: suspend CoroutineScope.() -&gt; R): R =
      suspendCoroutineUninterceptedOrReturn { uCont -&gt;
          val coroutine = ScopeCoroutine(uCont.context, uCont)
          coroutine.startUndispatchedOrReturn(coroutine, block)
      }
  </code></pre>
  
  <p>I want to get clear difference between them. If anyone can answer when to use which one, it would be helpful.</p>