You can easily do this with the TryInto trait (which was stabilized in Rust 1.34):

// Before Rust 2021, you need to import the trait:
// use std::convert::TryInto;

fn pop(barry: &[u8]) -> [u8; 3] {
    barry.try_into().expect("slice should have length 3")
}

But even better: there is no need to clone/copy your elements! It is actually possible to get a &[u8; 3] from a &[u8]:

fn pop(barry: &[u8]) -> &[u8; 3] {
    barry.try_into().expect("slice should have length 3")
}

As mentioned in the other answers, you probably don't want to panic if the length of barry is not 3, but instead handle this error gracefully.

This works thanks to these impls of the related trait TryFrom (before Rust 1.47, these only existed for arrays up to length 32):

impl<'_, T, const N: usize> TryFrom<&'_ [T]> for [T; N]
where
    T: Copy, 

impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]

impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]

The documentation for Vec covers this in the section titled "slicing".

You can create a slice of a Vec or array by indexing it with a Range (or RangeInclusive, RangeFrom, RangeTo, RangeToInclusive, or RangeFull), for example:

fn main() {
    let a = vec![1, 2, 3, 4, 5];

    // With a start and an end
    println!("{:?}", &a[1..4]);

    // With a start and an end, inclusive
    println!("{:?}", &a[1..=3]);

    // With just a start
    println!("{:?}", &a[2..]);

    // With just an end
    println!("{:?}", &a[..3]);

    // With just an end, inclusive
    println!("{:?}", &a[..=2]);

    // All elements
    println!("{:?}", &a[..]);
}

The best way is calling <[T]>::as_ptr() or <[T]>::as_mut_ptr().

You can also do that the way those functions implement it, by first casting the slice into a pointer to slice and then casting the resulting pointer into a thin pointer to the element type:

let slice: &[T];
slice as *const [T] as *const T;

However, those functions are provided in std exactly for you to don't do that.

If all you want is to compare addresses, you can call std::ptr::eq() directly with the slices.