From e25b75a28ed075ade6999e3e63906766f9caa13e Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Tue, 9 Jul 2019 18:02:23 +0700
Subject: [PATCH] Fix typos.

---
 src/buf/buf.rs        | 6 +++---
 src/buf/buf_mut.rs    | 4 ++--
 src/buf/chain.rs      | 2 +-
 src/bytes.rs          | 4 ++--
 src/lib.rs            | 2 +-
 tests/test_buf_mut.rs | 2 +-
 6 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/buf/buf.rs b/src/buf/buf.rs
index c064b51..bd468d9 100644
--- a/src/buf/buf.rs
+++ b/src/buf/buf.rs
@@ -16,7 +16,7 @@ macro_rules! buf_get_impl {
             }
         };
         if let Some(ret) = ret {
-             // if the direct convertion was possible, advance and return
+             // if the direct conversion was possible, advance and return
             $this.advance($size);
             return ret;
         } else {
@@ -792,7 +792,7 @@ pub trait Buf {
     /// Transforms a `Buf` into a concrete buffer.
     ///
     /// `collect()` can operate on any value that implements `Buf`, and turn it
-    /// into the relevent concrete buffer type.
+    /// into the relevant concrete buffer type.
     ///
     /// # Examples
     ///
@@ -997,6 +997,6 @@ impl Buf for Option<[u8; 1]> {
     }
 }
 
-// The existance of this function makes the compiler catch if the Buf
+// The existence of this function makes the compiler catch if the Buf
 // trait is "object-safe" or not.
 fn _assert_trait_object(_b: &dyn Buf) {}
diff --git a/src/buf/buf_mut.rs b/src/buf/buf_mut.rs
index 63aece8..e7935d9 100644
--- a/src/buf/buf_mut.rs
+++ b/src/buf/buf_mut.rs
@@ -942,7 +942,7 @@ pub trait BufMut {
     ///     // Adapt reference to `std::io::Write`.
     ///     let mut writer = reference.writer();
     ///
-    ///     // Use the buffer as a writter
+    ///     // Use the buffer as a writer
     ///     io::Write::write(&mut writer, &b"hello world"[..]).unwrap();
     /// } // drop our &mut reference so that we can use `buf` again
     ///
@@ -1069,6 +1069,6 @@ impl BufMut for Vec<u8> {
     }
 }
 
-// The existance of this function makes the compiler catch if the BufMut
+// The existence of this function makes the compiler catch if the BufMut
 // trait is "object-safe" or not.
 fn _assert_trait_object(_b: &dyn BufMut) {}
diff --git a/src/buf/chain.rs b/src/buf/chain.rs
index 4d46a5d..b6f1c76 100644
--- a/src/buf/chain.rs
+++ b/src/buf/chain.rs
@@ -5,7 +5,7 @@ use std::io::{IoSlice, IoSliceMut};
 /// A `Chain` sequences two buffers.
 ///
 /// `Chain` is an adapter that links two underlying buffers and provides a
-/// continous view across both buffers. It is able to sequence either immutable
+/// continuous view across both buffers. It is able to sequence either immutable
 /// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
 ///
 /// This struct is generally created by calling [`Buf::chain`]. Please see that
diff --git a/src/bytes.rs b/src/bytes.rs
index 0f03a34..3312371 100644
--- a/src/bytes.rs
+++ b/src/bytes.rs
@@ -722,7 +722,7 @@ impl Bytes {
     ///
     /// This will only succeed if there are no other outstanding references to
     /// the underlying chunk of memory. `Bytes` handles that contain inlined
-    /// bytes will always be convertable to `BytesMut`.
+    /// bytes will always be convertible to `BytesMut`.
     ///
     /// # Examples
     ///
@@ -2505,7 +2505,7 @@ impl Inner {
         // bits, so even without any explicit atomic operations, reading the
         // flag will be correct.
         //
-        // This is undefind behavior due to a data race, but experimental
+        // This is undefined behavior due to a data race, but experimental
         // evidence shows that it works in practice (discussion:
         // https://internals.rust-lang.org/t/bit-wise-reasoning-for-atomic-accesses/8853).
         //
diff --git a/src/lib.rs b/src/lib.rs
index d9a347c..9dd1492 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,7 +9,7 @@
 //!
 //! # `Bytes`
 //!
-//! `Bytes` is an efficient container for storing and operating on continguous
+//! `Bytes` is an efficient container for storing and operating on contiguous
 //! slices of memory. It is intended for use primarily in networking code, but
 //! could have applications elsewhere as well.
 //!
diff --git a/tests/test_buf_mut.rs b/tests/test_buf_mut.rs
index acc6af6..b0af550 100644
--- a/tests/test_buf_mut.rs
+++ b/tests/test_buf_mut.rs
@@ -65,7 +65,7 @@ fn test_clone() {
     buf.write_str("this is a test").unwrap();
     let buf2 = buf.clone();
 
-    buf.write_str(" of our emergecy broadcast system").unwrap();
+    buf.write_str(" of our emergency broadcast system").unwrap();
     assert!(buf != buf2);
 }
 
-- 
GitLab