Fix typos (mostly article usage)

Author: Inego

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

@@ -32,11 +32,11 @@ import kotlin.jvm.*
  * the coroutine [Job] is created in _new_ state. It can be explicitly started with [start][Job.start] function
  * and will be started implicitly on the first invocation of [join][Job.join].
  *
- * Uncaught exceptions in this coroutine cancel parent job in the context by default
+ * Uncaught exceptions in this coroutine cancel the parent job in the context by default
  * (unless [CoroutineExceptionHandler] is explicitly specified), which means that when `launch` is used with
- * the context of another coroutine, then any uncaught exception leads to the cancellation of parent coroutine.
+ * the context of another coroutine, then any uncaught exception leads to the cancellation of the parent coroutine.
  *
- * See [newCoroutineContext] for a description of debugging facilities that are available for newly created coroutine.
+ * See [newCoroutineContext] for a description of debugging facilities that are available for a newly created coroutine.
  *
  * @param context additional to [CoroutineScope.coroutineContext] context of the coroutine.
  * @param start coroutine start option. The default value is [CoroutineStart.DEFAULT].

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

@@ -20,25 +20,25 @@ import kotlin.coroutines.*
  */
 public enum class CoroutineStart {
     /**
-     * Default -- immediately schedules coroutine for execution according to its context.
+     * Default -- immediately schedules the coroutine for execution according to its context.
      *
      * If the [CoroutineDispatcher] of the coroutine context returns `true` from [CoroutineDispatcher.isDispatchNeeded]
      * function as most dispatchers do, then the coroutine code is dispatched for execution later, while the code that
      * invoked the coroutine builder continues execution.
      *
      * Note that [Dispatchers.Unconfined] always returns `false` from its [CoroutineDispatcher.isDispatchNeeded]
-     * function, so starting coroutine with [Dispatchers.Unconfined] by [DEFAULT] is the same as using [UNDISPATCHED].
+     * function, so starting a coroutine with [Dispatchers.Unconfined] by [DEFAULT] is the same as using [UNDISPATCHED].
      *
      * If coroutine [Job] is cancelled before it even had a chance to start executing, then it will not start its
      * execution at all, but will complete with an exception.
      *
-     * Cancellability of coroutine at suspension points depends on the particular implementation details of
+     * Cancellability of a coroutine at suspension points depends on the particular implementation details of
      * suspending functions. Use [suspendCancellableCoroutine] to implement cancellable suspending functions.
      */
     DEFAULT,
 
     /**
-     * Starts coroutine lazily, only when it is needed.
+     * Starts the coroutine lazily, only when it is needed.
      *
      * See the documentation for the corresponding coroutine builders for details
      * (like [launch][CoroutineScope.launch] and [async][CoroutineScope.async]).
@@ -49,7 +49,7 @@ public enum class CoroutineStart {
     LAZY,
 
     /**
-     * Atomically (i.e., in a non-cancellable way) schedules coroutine for execution according to its context.
+     * Atomically (i.e., in a non-cancellable way) schedules the coroutine for execution according to its context.
      * This is similar to [DEFAULT], but the coroutine cannot be cancelled before it starts executing.
      *
      * Cancellability of coroutine at suspension points depends on the particular implementation details of
@@ -59,7 +59,7 @@ public enum class CoroutineStart {
     ATOMIC,
 
     /**
-     * Immediately executes coroutine until its first suspension point _in the current thread_ as if the
+     * Immediately executes the coroutine until its first suspension point _in the current thread_ as if the
      * coroutine was started using [Dispatchers.Unconfined]. However, when coroutine is resumed from suspension
      * it is dispatched according to the [CoroutineDispatcher] in its context.
      *
@@ -75,7 +75,7 @@ public enum class CoroutineStart {
     UNDISPATCHED;
 
     /**
-     * Starts the corresponding block as a coroutine with this coroutine start strategy.
+     * Starts the corresponding block as a coroutine with this coroutine's start strategy.
      *
      * * [DEFAULT] uses [startCoroutineCancellable].
      * * [ATOMIC] uses [startCoroutine].

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

@@ -24,7 +24,7 @@ import kotlin.jvm.*
  * can [cancel] its own children (including all their children recursively) without cancelling itself.
  *
  * The most basic instances of [Job] are created with [launch][CoroutineScope.launch] coroutine builder or with a
- * `Job()` factory function. By default, a failure of any of the job's children leads to an immediately failure
+ * `Job()` factory function. By default, a failure of any of the job's children leads to an immediate failure
  * of its parent and cancellation of the rest of its children. This behavior can be customized using [SupervisorJob].
  *
  * Conceptually, an execution of the job does not produce a result value. Jobs are launched solely for their
@@ -46,8 +46,8 @@ import kotlin.jvm.*
  * [CoroutineStart.LAZY]. Such a job can be made _active_ by invoking [start] or [join].
  *
  * A job is _active_ while the coroutine is working. Failure of the job with exception makes it _cancelling_.
- * A job can be cancelled it at any time with [cancel] function that forces it to transition to
- * _cancelling_ state immediately. The job becomes _cancelled_  when it finishes executing it work.
+ * A job can be cancelled at any time with [cancel] function that forces it to transition to
+ * _cancelling_ state immediately. The job becomes _cancelled_  when it finishes executing its work.
  *
  * ```
  *                                       wait children