add more vector masks explanations to the guide-level explanation

Author: gnzlbg

text/0000-ppv.md

@@ -165,13 +165,33 @@ vector with four `f32` lanes. Here:
 
 * **lane width**: the bit width of a vector lane, that is, the bit width of
   the objects stored in the vector. For example, the type `f32` is 32-bits wide.
+  
+That is, the `m8x4` type is a 32-bit wide vector mask with 4 lanes containing an
+8-bit wide mask each. Vector masks are mainly used to select the lanes on which
+vector operations are performed. When a lane has all of its bits set to `true`,
+that lane is "selected", and when a lane has all of its bits set to `false`,
+that lane is "not selected". The following bit pattern is thus a valid
+bit-pattern for the `m8x4` mask:
+
+> 00000000_11111111_00000000_11111111
+
+and it select two eight-bit wide lanes from a 32-bit wide vector type with four
+lanes. The following bit-pattern is not, however, a valid value of the same mask
+type:
+
+> 00000000_11111111_00000000_11110111
+
+because it does not satisfies the invariant that all bits of a lane must be
+either set or cleared.
 
 Operations on vector types can be either:
 
 * **vertical**: that is, lane-wise. For example, `a + b` adds each lane of `a`
   with the corresponding lane of `b`, while `a.lt(b)` returns a boolean mask
   that indicates whether the less-than (`<`, `lt`) comparison returned `true` or
-  `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.
+  `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
@@ -268,7 +288,9 @@ even elements of a vector with a scalar:
 
 ```rust
 fn mul_even(a: f32, x: f32x4) -> f32x4 {
-    // Create a mask for the even elements 0 and 2:
+    // Create a vector mask for the even elements 0 and 2.
+    // The vector mask API uses `bool`s to set or clear 
+    // all bits of a lane:
     let m = m32x4::new(true, false, true, false);
 
     // Perform a full multiplication