diff --git a/text/0000-ppv.md b/text/0000-ppv.md
index 53da42a2281..6da8c1209ee 100644
--- a/text/0000-ppv.md
+++ b/text/0000-ppv.md
@@ -174,9 +174,10 @@ Operations on vector types can be either:
   `false` for each of the vector lanes. Most vertical operations are binary operations (they take two input vectors). These operations are typically very fast on most architectures and they are the most widely used in practice.
   
 * **horizontal**: that is, along a single vector - they are unary operations.
-  For example, `a.sum()` adds the elements of a vector together while
-  `a.hmax()` returns the largest element in a vector. These operations
-  (typically) translate to a sequence of multiple SIMD instructions on most architectures and are therefore slower. In many cases, they are, however,  necessary.
+  For example, `a.sum()` adds the elements of a vector together while `a.hmax()`
+  returns the largest element in a vector. These operations (typically)
+  translate to a sequence of multiple SIMD instructions on most architectures
+  and are therefore slower. In many cases, they are, however, necessary.
   
 ## Example: Average
 
@@ -617,13 +618,13 @@ All signed and unsigned integer vectors implement the following methods:
 ```rust
 impl {element_type}{lane_width}x{number_of_lanes} {
 /// Horizontal bitwise `and` of the vector elements.
-pub fn horizontal_and(self) -> element_type;
+pub fn and(self) -> element_type;
 
 /// Horizontal bitwise `or` of the vector elements.
-pub fn horizontal_or(self) -> element_type;
+pub fn or(self) -> element_type;
 
 /// Horizontal bitwise `xor` of the vector elements.
-pub fn horizontal_xor(self) -> element_type;
+pub fn xor(self) -> element_type;
 }
 ```