DOCSP-39854: Remove async-std runtime support (#119)

Author: norareidy

source/fundamentals/runtimes.txt

@@ -14,50 +14,54 @@ Overview
 --------
 
 In this guide, you can learn about the {+driver-short+}'s :ref:`asynchronous <rust-runtimes-configure-async>`
-and :ref:`synchronous <rust-runtimes-configure-sync>` APIs.
-This guide explains how to enable the available APIs and structure your code to use each.
+and :ref:`synchronous <rust-runtimes-configure-sync>` APIs. This guide explains how to enable the available APIs
+and structure your code to use each.
 
-The {+driver-short+} supports ``tokio`` and ``async-std``, two popular asynchronous runtime crates.
-By default, the driver uses the ``tokio`` asynchronous runtime, but you can select a specific runtime
-by adding feature flags to the ``mongodb`` dependency in your ``Cargo.toml`` file.
+The {+driver-short+} supports the ``tokio`` asynchronous runtime crate, which is the default
+runtime.
 
-The driver also includes a synchronous API for use cases that require blocking, or when parallelism is not necessary.
-You can select the synchronous API by adding feature flags to the ``mongodb`` dependency in your ``Cargo.toml`` file.
+.. important::
 
-.. _rust-runtimes-configure-async:
+   Beginning in {+driver-short+} v3.0, the ``tokio`` runtime is the only asynchronous runtime crate that
+   the driver supports. Previous versions of the driver also support the ``async-std`` runtime crate.
+   If your application uses the ``async-std`` runtime, you can start a ``tokio`` runtime in the same
+   application by creating a ``Runtime`` struct instance and wrapping driver operations with the ``Runtime::spawn()``
+   method. Ensure that you use the same ``Runtime`` instance for instantiating a ``Client`` and calling
+   driver methods on that ``Client`` instance.
+   
+   For an example that instantiates a ``Runtime`` and calls the ``spawn()`` method, see the `tokio documentation
+   <https://docs.rs/tokio/latest/tokio/runtime/struct.Runtime.html#examples-2>`__.
 
-Configure the Asynchronous Runtime
-----------------------------------
+The driver also includes a synchronous API for use cases that require blocking, or when parallelism
+is not necessary. You can select the synchronous API by adding feature flags to the ``mongodb`` dependency
+in your ``Cargo.toml`` file.
 
-The driver uses the ``tokio`` runtime by default.
-You can explicitly choose a runtime by adding the ``"tokio-runtime"`` or ``"async-std-runtime"``
-feature flags to the ``mongodb`` dependency.
+This guide includes the following sections:
 
-Select from the following tabs to see how to add feature flags for each corresponding crate:
+- :ref:`rust-runtimes-configure-async` shows how to configure your application to use the
+  ``tokio`` asynchronous runtime
 
-.. tabs::
+- :ref:`rust-runtimes-configure-sync` shows how to configure your application to use the
+  ``sync`` and ``tokio-sync`` synchronous runtimes
 
-   .. tab:: tokio
-      :tabid: asynchronous-api-tokio
+- :ref:`rust-runtimes-configure-both` shows how to enable both the asynchronous and synchronous
+  runtimes APIs in your application
 
-      .. code-block:: toml
-
-         [dependencies.mongodb]
-         version = "{+version+}"
-         features = ["tokio-runtime"]
+- :ref:`rust-addtl-info-runtimes` provides links to resources and API documentation for types
+  and methods mentioned in this guide
 
-   .. tab:: async-std
-      :tabid: asynchronous-api-async-std
+.. _rust-runtimes-configure-async:
 
-      .. code-block:: toml
+Configure the Asynchronous Runtime
+----------------------------------
 
-         [dependencies.mongodb]
-         version = "{+version+}"
-         default-features = false
-         features = ["async-std"]
+The driver uses the ``tokio`` runtime by default, so you can use this runtime without specifying any
+feature flags in your project's ``Cargo.toml`` file. 
 
-For more information on installing the driver and adding feature flags,
-see the :ref:`rust-quick-start-download-and-install` step of the Quick Start.
+You can explicitly choose the ``tokio`` runtime by adding the ``"tokio-runtime"`` feature flag to
+the ``mongodb`` dependency. For more information on installing the driver and adding feature flags,
+including an example that specifies the ``"tokio-runtime"`` feature flag, see the
+:ref:`rust-quick-start-download-and-install` step of the Quick Start.
 
 Tokio Runtime Example
 ~~~~~~~~~~~~~~~~~~~~~
@@ -113,6 +117,8 @@ When the ``insert_one`` method runs inside the ``for`` loop, the driver waits fo
    :language: rust
    :dedent:
 
+.. _rust-runtimes-configure-both:
+
 Use Both Asynchronous and Synchronous APIs
 ------------------------------------------
 
@@ -130,6 +136,8 @@ For example, to enable both ``tokio`` runtimes, you can add the ``tokio`` depend
    version = "{+version+}"
    features = ["tokio-sync"]
 
+.. _rust-addtl-info-runtimes:
+
 Additional Information
 ----------------------