feature(slice_patterns)

Matching without binding

Looking at the first flavor, matching without binding, we get introduced to the .. pattern straight away:

fn f<T>(xs: &[T])
where
    T: std::fmt::Debug,
{
    match xs {
        // the slice has at least two variables.
        // we bind the first and last items of
        // the slice to `x` and `y`, respectively
        [x, .., y] => {
            println!("First and last: {:?} and {:?}.", x, y)
        }

        // the slice has a single item: `x`
        [x] => {
          println!("the slice has a single item: {:?}.", x)
        }

        // the slice is empty
        [] => {
            println!("Got an empty slice.")
        }
    }
}

Remember that .. can match any number of elements, including 0. This means that the first pattern matches anything that has at least two items. You can also use the pattern without 'delimiting' it on both ends, such as if you wanted to implement these two functions for getting the first and last element of a slice:

fn first<T>(xs: &[T]) -> Option<&T> {
    match xs {
        [x, ..] => Some(x),
        [] => None,
    }
}

fn last<T>(xs: &[T]) -> Option<&T> {
    match xs {
        [.., x] => Some(x),
        [] => None,
    }
}

Notice how both of these functions pick out a single element of the slice (first and last respectively) and ignore the rest. Because .. matches 0 or more elements, the first pattern in both functions matches slices with one or more elements.

Matching and binding a subslice

The other flavor lets you bind a subslice to a value, which takes slice patterns and cranks the power level up another notch or two. The binding is done using the @ operator.

Imagine for instance that we want to write a sum function. That could be done as such:

fn sum(xs: &[i32]) -> i32 {
    match xs {
        [] => 0,
        [x, xs @ ..] => x + sum(xs),
    }
}

In the example above, if the slice is not empty, we take the first element, x, and add it to the result of summing the rest of the list, xs. With Rust already having a sum method on iterators, this function is pretty redundant, but it makes a good example of how to bind and use subslices.

Another example would be to get the middle element of a slice if the slice has an odd number of elements. If the slice is empty or has an even number of elements, return None:

fn middle<T>(xs: &[T]) -> Option<&T> {
    match xs {
        // ignore the first and last element.
        // recurse with what's in between.
        [_, inner @ .., _] => middle(inner),

        // one element! got it!
        [x] => Some(x),

        // oops! there's nothing here.
        [] => None,
    }
}

Here we iterate through the slice from both sides, continuously picking off one element at the start and one element at the end. Whatever is left in the middle (if there are at least two elements) gets assigned to xs and used as input to another step through the function. Once we have either one or zero elements left, we have our answer.