///
/// # Examples
///
-/// A trivial implementation of `BitOr`. When `Foo | Foo` happens, it ends up
-/// calling `bitor`, and therefore, `main` prints `Bitwise Or-ing!`.
+/// In this example, the `|` operator is lifted to a trivial `Scalar` type.
///
/// ```
/// use std::ops::BitOr;
///
-/// struct Foo;
+/// #[derive(Debug, PartialEq)]
+/// struct Scalar(bool);
///
-/// impl BitOr for Foo {
-/// type Output = Foo;
+/// impl BitOr for Scalar {
+/// type Output = Self;
///
-/// fn bitor(self, _rhs: Foo) -> Foo {
-/// println!("Bitwise Or-ing!");
-/// self
+/// // rhs is the "right-hand side" of the expression `a | b`
+/// fn bitor(self, rhs: Self) -> Self {
+/// Scalar(self.0 | rhs.0)
+/// }
+/// }
+///
+/// fn main() {
+/// assert_eq!(Scalar(true) | Scalar(true), Scalar(true));
+/// assert_eq!(Scalar(true) | Scalar(false), Scalar(true));
+/// assert_eq!(Scalar(false) | Scalar(true), Scalar(true));
+/// assert_eq!(Scalar(false) | Scalar(false), Scalar(false));
+/// }
+/// ```
+///
+/// In this example, the `BitOr` trait is implemented for a `BooleanVector`
+/// struct.
+///
+/// ```
+/// use std::ops::BitOr;
+///
+/// #[derive(Debug, PartialEq)]
+/// struct BooleanVector(Vec<bool>);
+///
+/// impl BitOr for BooleanVector {
+/// type Output = Self;
+///
+/// fn bitor(self, BooleanVector(rhs): Self) -> Self {
+/// let BooleanVector(lhs) = self;
+/// assert_eq!(lhs.len(), rhs.len());
+/// BooleanVector(lhs.iter().zip(rhs.iter()).map(|(x, y)| *x || *y).collect())
/// }
/// }
///
/// fn main() {
-/// Foo | Foo;
+/// let bv1 = BooleanVector(vec![true, true, false, false]);
+/// let bv2 = BooleanVector(vec![true, false, true, false]);
+/// let expected = BooleanVector(vec![true, true, true, false]);
+/// assert_eq!(bv1 | bv2, expected);
/// }
/// ```
#[lang = "bitor"]
///
/// # Examples
///
-/// A trivial implementation of `BitXor`. When `Foo ^ Foo` happens, it ends up
-/// calling `bitxor`, and therefore, `main` prints `Bitwise Xor-ing!`.
+/// In this example, the `^` operator is lifted to a trivial `Scalar` type.
///
/// ```
/// use std::ops::BitXor;
///
-/// struct Foo;
+/// #[derive(Debug, PartialEq)]
+/// struct Scalar(bool);
///
-/// impl BitXor for Foo {
-/// type Output = Foo;
+/// impl BitXor for Scalar {
+/// type Output = Self;
///
-/// fn bitxor(self, _rhs: Foo) -> Foo {
-/// println!("Bitwise Xor-ing!");
-/// self
+/// // rhs is the "right-hand side" of the expression `a ^ b`
+/// fn bitxor(self, rhs: Self) -> Self {
+/// Scalar(self.0 ^ rhs.0)
+/// }
+/// }
+///
+/// fn main() {
+/// assert_eq!(Scalar(true) ^ Scalar(true), Scalar(false));
+/// assert_eq!(Scalar(true) ^ Scalar(false), Scalar(true));
+/// assert_eq!(Scalar(false) ^ Scalar(true), Scalar(true));
+/// assert_eq!(Scalar(false) ^ Scalar(false), Scalar(false));
+/// }
+/// ```
+///
+/// In this example, the `BitXor` trait is implemented for a `BooleanVector`
+/// struct.
+///
+/// ```
+/// use std::ops::BitXor;
+///
+/// #[derive(Debug, PartialEq)]
+/// struct BooleanVector(Vec<bool>);
+///
+/// impl BitXor for BooleanVector {
+/// type Output = Self;
+///
+/// fn bitxor(self, BooleanVector(rhs): Self) -> Self {
+/// let BooleanVector(lhs) = self;
+/// assert_eq!(lhs.len(), rhs.len());
+/// BooleanVector(lhs.iter()
+/// .zip(rhs.iter())
+/// .map(|(x, y)| (*x || *y) && !(*x && *y))
+/// .collect())
/// }
/// }
///
/// fn main() {
-/// Foo ^ Foo;
+/// let bv1 = BooleanVector(vec![true, true, false, false]);
+/// let bv2 = BooleanVector(vec![true, false, true, false]);
+/// let expected = BooleanVector(vec![false, true, true, false]);
+/// assert_eq!(bv1 ^ bv2, expected);
/// }
/// ```
#[lang = "bitxor"]