How to "take" the first part of a slice borrowed in a function?

Background

I'm fairly new to Rust, and I'm trying to write a packet parser. It's in a #[no_std] environment with no heap.

The input to the parser is a mutable reference to a slice of bytes (&mut [u8]), and the output is a heapless::Vec of packet header structs (really each is just a struct with a reference to its slice and some functions to obtain the header fields).

Problem

I'm struggling to split the initial provided slice into the smaller slices required for the individual packet headers. Borrowing the slice in a function and using slice.take_mut() to get the first piece seems to not return permissions for the rest of the slice, so a second call to the function doesn't compile.

I've also tried an implementation using slice.split_at_mut() with similar problems.

It doesn't help that I'm struggling to understand lifetimes and how they fit into all of this.

Example

I've tried to reduce my code to a minimal example, but I might've missed out on some important context in doing so.

#![feature(slice_take)]

fn main() {
    let mut bytes: [u8; 30] = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    ];
    let mut s1 = MyStruct::from_bytes(&mut bytes).unwrap();
    let mut s2 = MyStruct::from_bytes(&mut bytes).unwrap();
    println!("{:?}", s1);
    println!("{:?}", s2);
    println!("{:?}", bytes);
}

#[derive(Debug)]
struct MyStruct<'a> {
    data: &'a mut [u8],  // This should be a 10-byte slice.
}

impl<'a> MyStruct<'a> {
    fn from_bytes(mut data: &'a mut [u8]) -> Result<MyStruct<'a>, &'static str> {
        if data.len() < 10 {
            return Err("Need 10 bytes.");
        }
        let struct_data = data.take_mut(..10).unwrap();
        Ok(MyStruct{data: struct_data})
    }
}

What I was expecting:

MyStruct { data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] }
MyStruct { data: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20] }
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30]

What actually happens:

error[E0499]: cannot borrow `bytes` as mutable more than once at a time
  --> src\main.rs:10:39
   |
9  |     let mut s1 = MyStruct::from_bytes(&mut bytes).unwrap();
   |                                       ---------- first mutable borrow occurs here
10 |     let mut s2 = MyStruct::from_bytes(&mut bytes).unwrap();
   |                                       ^^^^^^^^^^ second mutable borrow occurs here
11 |     println!("{:?}", s1);
   |                      -- first borrow later used here

You are close here, but you've got two problems.

The first is that from_bytes needs to take a mutable reference to a mutable slice. This allows it to set the caller-provided slice to a subregion.

The second is that you are passing in &mut bytes instead of a slice -- you need to pass in a mutable reference to a slice so that from_bytes can adjust that slice to point to a subregion.

Fixing both of these issues:

#![feature(slice_take)]

fn main() {
    let mut bytes: [u8; 30] = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    ];
    let mut b = &mut bytes[..];
    let s1 = MyStruct::from_bytes(&mut b).unwrap();
    let s2 = MyStruct::from_bytes(&mut b).unwrap();
    println!("{:?}", s1);
    println!("{:?}", s2);
    println!("{:?}", b);
}

#[derive(Debug)]
struct MyStruct<'a> {
    data: &'a mut [u8],  // This should be a 10-byte slice.
}

impl<'a> MyStruct<'a> {
    fn from_bytes(data: &mut &'a mut [u8]) -> Result<MyStruct<'a>, &'static str> {
        if data.len() < 10 {
            return Err("Need 10 bytes.");
        }
        let struct_data = data.take_mut(..10).unwrap();
        Ok(MyStruct{data: struct_data})
    }
}

(Playground)

Note that you can make this work on stable Rust by using split_at_mut instead. This requires a bit of gymnastics involving std::mem::take() -- in fact, this is exactly how take_mut is implemented under the hood!

fn main() {
    let mut bytes: [u8; 30] = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    ];
    let mut b = &mut bytes[..];
    let s1 = MyStruct::from_bytes(&mut b).unwrap();
    let s2 = MyStruct::from_bytes(&mut b).unwrap();
    println!("{:?}", s1);
    println!("{:?}", s2);
    println!("{:?}", b);
}

#[derive(Debug)]
struct MyStruct<'a> {
    data: &'a mut [u8],  // This should be a 10-byte slice.
}

impl<'a> MyStruct<'a> {
    fn from_bytes(data: &mut &'a mut [u8]) -> Result<MyStruct<'a>, &'static str> {
        if data.len() < 10 {
            return Err("Need 10 bytes.");
        }
        let (struct_data, tail) = std::mem::take(data).split_at_mut(10);
        *data = tail;
        Ok(MyStruct{data: struct_data})
    }
}

(Playground)

I don't fully understand the implications of being in a no_std environment, but maybe it would be useful to encapsulate the disunion logic in another structure.

#[derive(Debug)]
struct Parts<'a> {
    parts: Vec<MyStruct<'a>>,
    remain: Option<&'a mut [u8]>,
}

impl<'a> From<&'a mut [u8]> for Parts<'a> {
    fn from(mut value: &'a mut [u8]) -> Self {
        let mut parts = Parts {
            parts: Vec::new(),
            remain: None,
        };
        
        while !(value.len() < 10) {
            let struct_data = MyStruct{
                data: value.take_mut(..10).unwrap(),
            };
            parts.parts.push(struct_data);
        };
        
        if value.len() > 0 {
            parts.remain = value.take_mut(..value.len());
        }

        parts
    }
}

playground