///
/// # Examples
///
-/// A trivial implementation of `Shl`. When `Foo << Foo` happens, it ends up
-/// calling `shl`, and therefore, `main` prints `Shifting left!`.
+/// An implementation of `Shl` that lifts the `<<` operation on integers to a
+/// `Scalar` struct.
///
/// ```
/// use std::ops::Shl;
///
-/// struct Foo;
+/// #[derive(PartialEq, Debug)]
+/// struct Scalar(usize);
///
-/// impl Shl<Foo> for Foo {
-/// type Output = Foo;
+/// impl Shl<Scalar> for Scalar {
+/// type Output = Self;
///
-/// fn shl(self, _rhs: Foo) -> Foo {
-/// println!("Shifting left!");
-/// self
+/// fn shl(self, Scalar(rhs): Self) -> Scalar {
+/// let Scalar(lhs) = self;
+/// Scalar(lhs << rhs)
+/// }
+/// }
+/// fn main() {
+/// assert_eq!(Scalar(4) << Scalar(2), Scalar(16));
+/// }
+/// ```
+///
+/// An implementation of `Shl` that spins a vector leftward by a given amount.
+///
+/// ```
+/// use std::ops::Shl;
+///
+/// #[derive(PartialEq, Debug)]
+/// struct SpinVector<T: Clone> {
+/// vec: Vec<T>,
+/// }
+///
+/// impl<T: Clone> Shl<usize> for SpinVector<T> {
+/// type Output = Self;
+///
+/// fn shl(self, rhs: usize) -> SpinVector<T> {
+/// // rotate the vector by `rhs` places
+/// let (a, b) = self.vec.split_at(rhs);
+/// let mut spun_vector: Vec<T> = vec![];
+/// spun_vector.extend_from_slice(b);
+/// spun_vector.extend_from_slice(a);
+/// SpinVector { vec: spun_vector }
/// }
/// }
///
/// fn main() {
-/// Foo << Foo;
+/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } << 2,
+/// SpinVector { vec: vec![2, 3, 4, 0, 1] });
/// }
/// ```
#[lang = "shl"]
///
/// # Examples
///
-/// A trivial implementation of `Shr`. When `Foo >> Foo` happens, it ends up
-/// calling `shr`, and therefore, `main` prints `Shifting right!`.
+/// An implementation of `Shr` that lifts the `>>` operation on integers to a
+/// `Scalar` struct.
///
/// ```
/// use std::ops::Shr;
///
-/// struct Foo;
+/// #[derive(PartialEq, Debug)]
+/// struct Scalar(usize);
///
-/// impl Shr<Foo> for Foo {
-/// type Output = Foo;
+/// impl Shr<Scalar> for Scalar {
+/// type Output = Self;
///
-/// fn shr(self, _rhs: Foo) -> Foo {
-/// println!("Shifting right!");
-/// self
+/// fn shr(self, Scalar(rhs): Self) -> Scalar {
+/// let Scalar(lhs) = self;
+/// Scalar(lhs >> rhs)
+/// }
+/// }
+/// fn main() {
+/// assert_eq!(Scalar(16) >> Scalar(2), Scalar(4));
+/// }
+/// ```
+///
+/// An implementation of `Shr` that spins a vector rightward by a given amount.
+///
+/// ```
+/// use std::ops::Shr;
+///
+/// #[derive(PartialEq, Debug)]
+/// struct SpinVector<T: Clone> {
+/// vec: Vec<T>,
+/// }
+///
+/// impl<T: Clone> Shr<usize> for SpinVector<T> {
+/// type Output = Self;
+///
+/// fn shr(self, rhs: usize) -> SpinVector<T> {
+/// // rotate the vector by `rhs` places
+/// let (a, b) = self.vec.split_at(self.vec.len() - rhs);
+/// let mut spun_vector: Vec<T> = vec![];
+/// spun_vector.extend_from_slice(b);
+/// spun_vector.extend_from_slice(a);
+/// SpinVector { vec: spun_vector }
/// }
/// }
///
/// fn main() {
-/// Foo >> Foo;
+/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } >> 2,
+/// SpinVector { vec: vec![3, 4, 0, 1, 2] });
/// }
/// ```
#[lang = "shr"]