Вы не можете изменить тип значения на месте в безопасном Rust. Нет гарантии, что два типа будут иметь одинаковый размер или одинаковую семантику.

Это относится как к одиночному значению (T -> U), так и к агрегированным значениям (Vec<T> -> Vec<U>, HashMap<K1, V1> -> HashMap<K2, V2>). Обратите внимание, что агрегированные значения на самом деле являются лишь частным случаем «одиночных» значений.

Лучше всего создать новый вектор:

let buffer2 = buffer.into_iter().map(Foo).collect();

Вы также можете настроить do_something_using_foo, чтобы он принимал общий универсальный тип, который реализуется как Foo, так и u32:

use std::borrow::{Borrow, BorrowMut};

#[derive(Debug, Clone)]
struct Foo(u32);

impl Borrow<u32> for Foo {
    fn borrow(&self) -> &u32 {
        &self.0
    }
}

impl BorrowMut<u32> for Foo {
    fn borrow_mut(&mut self) -> &mut u32 {
        &mut self.0
    }
}

fn do_something_using_foo<T>(buffer: &mut [T])
where
    T: BorrowMut<u32>,
{
}

fn main() {
    let mut buffer_u32 = vec![0u32; 100];
    let mut buffer_foo = vec![Foo(0); 100];

    do_something_using_foo(&mut buffer_u32);
    do_something_using_foo(&mut buffer_foo);
}

В небезопасном Rust это технически возможно - можно сколько угодно прострелить себе ногу.

Вы можете использовать что-то вроде std::mem::transmute, если знаете, что вы делает.

Однако неопределенное поведение - использовать transmute с Vec, поскольку представление Vec не определено. Вместо этого см. ответ Свена Марнака.

Смотрите также:

• Использование карты с векторами
• Преобразование Vec ‹u32› в Vec ‹u8› на месте и с минимальными накладными расходами

Согласно документации std::mem::transmute() при использовании Vec::from_raw_parts в сочетании с ManuallyDrop лучший вариант, начиная с Rust 1.38:

let v_from_raw = unsafe {
    // Ensure the original vector is not dropped.
    let mut v_clone = std::mem::ManuallyDrop::new(v_orig);
    Vec::from_raw_parts(v_clone.as_mut_ptr() as *mut U,
                        v_clone.len(),
                        v_clone.capacity())
};

Предпосылкой для этого является то, что T и U имеют одинаковый размер, одинаковое минимальное выравнивание и что все битовые комбинации, действительные для T, также действительны для U. Если вы определите T и U как в своем вопросе, у вас нет гарантии на это.

struct U(T) определяет структуру кортежа, и расположение памяти такой структуры полностью не определено. Однако можно заставить представления памяти быть идентичными, используя transparent представление:

#[repr(transparent)]
struct U(T);

Будущие возможности

Nightly Rust имеет Vec::into_raw_parts, который уменьшает количество кода и мест, где можно пойти не так:

#![feature(vec_into_raw_parts)]

fn convert_using_into_raw_parts(v: Vec<T>) -> Vec<U> {
    let (ptr, len, cap) = v.into_raw_parts();
    unsafe { Vec::from_raw_parts(ptr as *mut U, len, cap) }
}

Также существует открытый документ RFC Collection Transmute # 2756, в котором предлагается добавить метод Vec::transmute.