style(comments): correct some typos in Rust code comments

src/client/conn.rs

@@ -36,7 +36,7 @@ where
 }
 
 // Our defaults are chosen for the "majority" case, which usually are not
-// resource contrained, and so the spec default of 64kb can be too limiting
+// resource constrained, and so the spec default of 64kb can be too limiting
 // for performance.
 const DEFAULT_HTTP2_CONN_WINDOW: u32 = 1024 * 1024 * 5; // 5mb
 const DEFAULT_HTTP2_STREAM_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
@@ -356,7 +356,7 @@ where
     ///
     /// This is useful to allow running a connection while doing an HTTP
     /// upgrade. Once the upgrade is completed, the connection would be "done",
-    /// but it is not desired to actally shutdown the IO object. Instead you
+    /// but it is not desired to actually shutdown the IO object. Instead you
     /// would take it back using `into_parts`.
     ///
     /// Use [`poll_fn`](https://docs.rs/futures/0.1.25/futures/future/fn.poll_fn.html)

src/client/connect/http.rs

@@ -775,7 +775,7 @@ mod tests {
         ];
 
         // Scenarios for IPv6 -> IPv4 fallback require that host can access IPv6 network.
-        // Otherwise, connection to "slow" IPv6 address will error-out immediatelly.
+        // Otherwise, connection to "slow" IPv6 address will error-out immediately.
         let ipv6_accessible = measure_connect(slow_ipv6_addr()).0;
 
         for &(hosts, family, timeout, needs_ipv6_access) in scenarios {

src/client/mod.rs

@@ -390,7 +390,7 @@ where
         // - Meanwhile, the pool Checkout is watching to see if any other
         //   request finishes and tries to insert an idle connection.
         // - If a new connection is started, but the Checkout wins after
-        //   (an idle connection becamse available first), the started
+        //   (an idle connection became available first), the started
         //   connection future is spawned into the runtime to complete,
         //   and then be inserted into the pool as an idle connection.
         let checkout = self.pool.checkout(pool_key.clone());
@@ -469,7 +469,7 @@ where
             // Try to take a "connecting lock".
             //
             // If the pool_key is for HTTP/2, and there is already a
-            // connection being estabalished, then this can't take a
+            // connection being established, then this can't take a
             // second lock. The "connect_to" future is Canceled.
             let connecting = match pool.connecting(&pool_key, ver) {
                 Some(lock) => lock,

src/client/pool.rs

@@ -55,7 +55,7 @@ pub(super) enum Reservation<T> {
 pub(super) type Key = Arc<String>;
 
 struct PoolInner<T> {
-    // A flag that a connection is being estabilished, and the connection
+    // A flag that a connection is being established, and the connection
     // should be shared. This prevents making multiple HTTP/2 connections
     // to the same host.
     connecting: HashSet<Key>,

src/client/tests.rs

@@ -97,7 +97,7 @@ fn conn_reset_after_write() {
         // has written the second request, and THEN disconnect.
         //
         // Not because we expect servers to be jerks, but to trigger
-        // state where we write on an assumedly good connetion, and
+        // state where we write on an assumedly good connection, and
         // only reset the close AFTER we wrote bytes.
         try_ready!(sock1.as_mut().unwrap().read(&mut [0u8; 512]));
         sock1.take();