=doc Fix indefinite articles typos in docs (#20924)

akka-docs/rst/intro/getting-started.rst

@@ -212,12 +212,12 @@ For snapshot versions, the snapshot repository needs to be added as well:
 Using Akka with Eclipse
 -----------------------
 
-Setup SBT project and then use `sbteclipse <https://github.com/typesafehub/sbteclipse>`_ to generate a Eclipse project.
+Setup SBT project and then use `sbteclipse <https://github.com/typesafehub/sbteclipse>`_ to generate an Eclipse project.
 
 Using Akka with IntelliJ IDEA
 -----------------------------
 
-Setup SBT project and then use `sbt-idea <https://github.com/mpeltonen/sbt-idea>`_ to generate a IntelliJ IDEA project.
+Setup SBT project and then use `sbt-idea <https://github.com/mpeltonen/sbt-idea>`_ to generate an IntelliJ IDEA project.
 
 Using Akka with NetBeans
 ------------------------

akka-docs/rst/java/camel.rst

@@ -281,7 +281,7 @@ Actors may also use a Camel `ProducerTemplate`_ for producing messages to endpoi
 
 .. includecode:: code/docs/camel/MyActor.java#ProducerTemplate
 
-For initiating a a two-way message exchange, one of the
+For initiating a two-way message exchange, one of the
 ``ProducerTemplate.request*`` methods must be used.
 
 .. includecode:: code/docs/camel/RequestBodyActor.java#RequestProducerTemplate

akka-docs/rst/java/http/routing-dsl/marshalling.rst

@@ -13,7 +13,7 @@ of an HTTP request or response (depending on whether used on the client or serve
 Marshalling
 -----------
 
-On the server-side marshalling is used to convert a application-domain object to a response (entity). Requests can
+On the server-side marshalling is used to convert an application-domain object to a response (entity). Requests can
 contain an ``Accept`` header that lists acceptable content types for the client. A marshaller contains the logic to
 negotiate the result content types based on the ``Accept`` and the ``AcceptCharset`` headers.
 
@@ -30,7 +30,7 @@ These marshallers are provided by akka-http:
 Unmarshalling
 -------------
 
-On the server-side unmarshalling is used to convert a request (entity) to a application-domain object. This is done
+On the server-side unmarshalling is used to convert a request (entity) to an application-domain object. This is done
 in the ``MarshallingDirectives.request`` or ``MarshallingDirectives.entity`` directive. There are several unmarshallers
 provided by akka-http: 
 

akka-docs/rst/java/stream/stream-customize.rst

@@ -138,7 +138,7 @@ Finally, there are two methods available for convenience to complete the stage a
 
 
 In some cases it is inconvenient and error prone to react on the regular state machine events with the
-signal based API described above. For those cases there is a API which allows for a more declarative sequencing
+signal based API described above. For those cases there is an API which allows for a more declarative sequencing
 of actions which will greatly simplify some use cases at the cost of some extra allocations. The difference
 between the two APIs could be described as that the first one is signal driven from the outside, while this API
 is more active and drives its surroundings.

akka-docs/rst/java/stream/stream-integrations.rst

@@ -15,7 +15,7 @@ For more advanced use cases the :class:`ActorPublisher` and :class:`ActorSubscri
 provided to support implementing Reactive Streams :class:`Publisher` and :class:`Subscriber` with
 an :class:`Actor`.
 
-These can be consumed by other Reactive Stream libraries or used as a
+These can be consumed by other Reactive Stream libraries or used as an
 Akka Streams :class:`Source` or :class:`Sink`.
 
 .. warning::

akka-docs/rst/project/migration-guide-2.3.x-2.4.x.rst

@@ -125,10 +125,10 @@ FSM notifies on same state transitions
 When changing states in an Finite-State-Machine Actor (``FSM``), state transition events are emitted and can be handled by the user
 either by registering ``onTransition`` handlers or by subscribing to these events by sending it an ``SubscribeTransitionCallBack`` message.
 
-Previously in ``2.3.x`` when an ``FSM`` was in state ``A`` and performed an ``goto(A)`` transition, no state transition notification would be sent.
+Previously in ``2.3.x`` when an ``FSM`` was in state ``A`` and performed a ``goto(A)`` transition, no state transition notification would be sent.
 This is because it would effectively stay in the same state, and was deemed to be semantically equivalent to calling ``stay()``.
 
-In ``2.4.x`` when an ``FSM`` performs a any ``goto(X)`` transition, it will always trigger state transition events.
+In ``2.4.x`` when an ``FSM`` performs an any ``goto(X)`` transition, it will always trigger state transition events.
 Which turns out to be useful in many systems where same-state transitions actually should have an effect.
 
 In case you do *not* want to trigger a state transition event when effectively performing an ``X->X`` transition, use ``stay()`` instead.

akka-docs/rst/scala/camel.rst

@@ -277,7 +277,7 @@ messages to endpoints.
 
 .. includecode:: code/docs/camel/Producers.scala#ProducerTemplate
 
-For initiating a a two-way message exchange, one of the
+For initiating a two-way message exchange, one of the
 ``ProducerTemplate.request*`` methods must be used.
 
 .. includecode:: code/docs/camel/Producers.scala#RequestProducerTemplate

akka-docs/rst/scala/http/routing-dsl/directives/future-directives/completeOrRecoverWith.rst

@@ -14,7 +14,7 @@ Description
 If the ``Future[T]`` succeeds the request is completed using the value's marshaller (this directive therefore
 requires a marshaller for the future's parameter type to be implicitly available). The execution of the inner
 route passed to this directive is only executed if the given future completed with a failure,
-exposing the reason of failure as a extraction of type ``Throwable``.
+exposing the reason of failure as an extraction of type ``Throwable``.
 
 To handle the successful case manually as well, use the :ref:`-onComplete-` directive, instead.
 

akka-docs/rst/scala/stream/stream-customize.rst

@@ -141,7 +141,7 @@ Finally, there are two methods available for convenience to complete the stage a
 
 
 In some cases it is inconvenient and error prone to react on the regular state machine events with the
-signal based API described above. For those cases there is a API which allows for a more declarative sequencing
+signal based API described above. For those cases there is an API which allows for a more declarative sequencing
 of actions which will greatly simplify some use cases at the cost of some extra allocations. The difference
 between the two APIs could be described as that the first one is signal driven from the outside, while this API
 is more active and drives its surroundings.

akka-docs/rst/scala/stream/stream-integrations.rst

@@ -15,7 +15,7 @@ For more advanced use cases the :class:`ActorPublisher` and :class:`ActorSubscri
 provided to support implementing Reactive Streams :class:`Publisher` and :class:`Subscriber` with
 an :class:`Actor`.
 
-These can be consumed by other Reactive Stream libraries or used as a
+These can be consumed by other Reactive Stream libraries or used as an
 Akka Streams :class:`Source` or :class:`Sink`.
 
 .. warning::