Change "create new" to "create a"

Author: Inego

RELEASE.md

@@ -50,7 +50,7 @@ To release new `<version>` of `kotlinx-coroutines`:
    * Run "Deploy (Configure, RUN THIS ONE)" configuration with the corresponding new version.    
 
 2. In [GitHub](https://github.com/kotlin/kotlinx.coroutines) interface:
-   * Create new release named as `<version>`. 
+   * Create a release named `<version>`. 
    * Cut & paste lines from [`CHANGES.md`](CHANGES.md) into description.    
 
 3. Build and publish documentation for web-site: <br>

docs/basics.md

@@ -250,7 +250,7 @@ World!
 
 ### Scope builder
 In addition to the coroutine scope provided by different builders, it is possible to declare your own scope using
-[coroutineScope] builder. It creates new coroutine scope and does not complete until all launched children
+[coroutineScope] builder. It creates a coroutine scope and does not complete until all launched children
 complete. The main difference between [runBlocking] and [coroutineScope] is that the latter does not block the current thread 
 while waiting for all children to complete.
 

docs/exception-handling.md

@@ -48,7 +48,7 @@ while the latter are relying on the user to consume the final
 exception, for example via [await][Deferred.await] or [receive][ReceiveChannel.receive] 
 ([produce] and [receive][ReceiveChannel.receive] are covered later in [Channels](https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/channels.md) section).
 
-It can be demonstrated by a simple example that creates new coroutines in [GlobalScope]:
+It can be demonstrated by a simple example that creates coroutines in the [GlobalScope]:
 
 <div class="sample" markdown="1" theme="idea" data-highlight-only>
 

kotlinx-coroutines-core/common/README.md

@@ -18,8 +18,8 @@ Coroutine dispatchers implementing [CoroutineDispatcher]:
 | --------------------------- | ---------------
 | [Dispatchers.Default]       | Confines coroutine execution to a shared pool of background threads
 | [Dispatchers.Unconfined]    | Does not confine coroutine execution in any way
-| [newSingleThreadContext]    | Create new single-threaded coroutine context
-| [newFixedThreadPoolContext] | Creates new thread pool of a fixed size 
+| [newSingleThreadContext]    | Creates a single-threaded coroutine context
+| [newFixedThreadPoolContext] | Creates a thread pool of a fixed size 
 | [Executor.asCoroutineDispatcher][java.util.concurrent.Executor.asCoroutineDispatcher] | Extension to convert any executor
 
 More context elements:

kotlinx-coroutines-core/common/src/Builders.common.kt

@@ -58,7 +58,7 @@ public fun CoroutineScope.launch(
 // --------------- async ---------------
 
 /**
- * Creates new coroutine and returns its future result as an implementation of [Deferred].
+ * Creates a coroutine and returns its future result as an implementation of [Deferred].
  * The running coroutine is cancelled when the resulting deferred is [cancelled][Job.cancel].
  *
  * Coroutine context is inherited from a [CoroutineScope], additional context elements can be specified with [context] argument.

kotlinx-coroutines-core/common/src/CoroutineExceptionHandler.kt

@@ -41,7 +41,7 @@ internal fun handlerException(originalException: Throwable, thrownException: Thr
 }
 
 /**
- * Creates new [CoroutineExceptionHandler] instance.
+ * Creates a [CoroutineExceptionHandler] instance.
  * @param handler a function which handles exception thrown by a coroutine
  */
 @Suppress("FunctionName")

kotlinx-coroutines-core/common/src/Supervisor.kt

@@ -38,7 +38,7 @@ public fun SupervisorJob(parent: Job? = null) : CompletableJob = SupervisorJobIm
 public fun SupervisorJob0(parent: Job? = null) : Job = SupervisorJob(parent)
 
 /**
- * Creates new [CoroutineScope] with [SupervisorJob] and calls the specified suspend block with this scope.
+ * Creates a [CoroutineScope] with [SupervisorJob] and calls the specified suspend block with this scope.
  * The provided scope inherits its [coroutineContext][CoroutineScope.coroutineContext] from the outer scope, but overrides
  * context's [Job] with [SupervisorJob].
  *

kotlinx-coroutines-core/common/src/sync/Mutex.kt

@@ -88,7 +88,7 @@ public interface Mutex {
 }
 
 /**
- * Creates new [Mutex] instance.
+ * Creates a [Mutex] instance.
  * The mutex created is fair: lock is granted in first come, first served order.
  *
  * @param locked initial state of the mutex.

kotlinx-coroutines-core/jvm/src/ThreadPoolDispatcher.kt

@@ -31,7 +31,7 @@ fun newSingleThreadContext(name: String): ExecutorCoroutineDispatcher =
     newFixedThreadPoolContext(1, name)
 
 /**
- * Creates new coroutine execution context with the fixed-size thread-pool and built-in [yield] support.
+ * Creates a coroutine execution context with the fixed-size thread-pool and built-in [yield] support.
  * **NOTE: The resulting [ExecutorCoroutineDispatcher] owns native resources (its threads).
  * Resources are reclaimed by [ExecutorCoroutineDispatcher.close].**
  *

kotlinx-coroutines-core/jvm/src/internal/StackTraceRecovery.kt

@@ -50,7 +50,7 @@ private fun <E : Throwable> recoverFromStackFrame(exception: E, continuation: Co
     */
     val (cause, recoveredStacktrace) = exception.causeAndStacktrace()
 
-    // Try to create new exception of the same type and get stacktrace from continuation
+    // Try to create an exception of the same type and get stacktrace from continuation
     val newException = tryCopyException(cause) ?: return exception
     val stacktrace = createStackTrace(continuation)
     if (stacktrace.isEmpty()) return exception

kotlinx-coroutines-core/jvm/src/scheduling/Dispatcher.kt

@@ -77,7 +77,7 @@ open class ExperimentalCoroutineDispatcher(
     }
 
     /**
-     * Creates new coroutine execution context with limited parallelism to execute tasks which may potentially block.
+     * Creates a coroutine execution context with limited parallelism to execute tasks which may potentially block.
      * Resulting [CoroutineDispatcher] doesn't own any resources (its threads) and provides a view of the original [ExperimentalCoroutineDispatcher],
      * giving it additional hints to adjust its behaviour.
      *
@@ -89,7 +89,7 @@ open class ExperimentalCoroutineDispatcher(
     }
 
     /**
-     * Creates new coroutine execution context with limited parallelism to execute CPU-intensive tasks.
+     * Creates a coroutine execution context with limited parallelism to execute CPU-intensive tasks.
      * Resulting [CoroutineDispatcher] doesn't own any resources (its threads) and provides a view of the original [ExperimentalCoroutineDispatcher],
      * giving it additional hints to adjust its behaviour.
      *

kotlinx-coroutines-core/jvm/test/scheduling/BlockingCoroutineDispatcherStressTest.kt

@@ -50,7 +50,7 @@ class BlockingCoroutineDispatcherStressTest : SchedulerTestBase() {
         val iterations = 1000 * stressTestMultiplier
 
         repeat(iterations) {
-            // Create new dispatcher every iteration to increase probability of race
+            // Create a dispatcher every iteration to increase probability of race
             val dispatcher = ExperimentalCoroutineDispatcher(CORES_COUNT)
             val blockingDispatcher = dispatcher.blocking(100)