在某个连续容器上迭代大小为 N 的切片

Question

假设我们有一个点向量，写成一个扁平的整数序列。向量的大小是精确的，我们希望将其转换为 Point 结构的向量。所以我的转换目前看起来是这样的。

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}
impl Point {
    fn new(x: i32, y : i32) -> Point {
        Point{x,y}
    }
}
impl From<Point> for String {
    fn from(point: Point) -> String {
        format!("({},{})", point.x, point.y)
    }
}

fn main() {
    let vec = vec![2,1,4,3,6,5]; // We want convert that
    let even = vec.iter().step_by(2);
    let odd = vec.iter().skip(1).step_by(2);
    let points: Vec<Point> 
                = even.zip(odd)
                .map(|(x,y)|Point::new(*x,*y))
                .collect();

    println!("{:?}", points);
}

像一个魅力一样工作，直到我们想要添加z 组件，并在每个循环中查看三个元素。我还没有从docs 找到任何合适的方法。那么，是否已经有一种通用的方法可以在向量上迭代一定大小的切片并将其解压缩到我的结构中，或者没有这种方法，我应该自己实现这样的迭代器？使用像serde 这样更重的机器是不是一个信号。

Answer 1

在 std 中使用 chunks_exact 很容易实现切片。

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
    z: i32,
}
impl Point {
    fn new(x: i32, y : i32, z: i32) -> Point {
        Point{x,y, z}
    }
}

fn main() {
    let vec = vec![2,1,4,3,6,5];
    let points: Vec<Point> 
                = vec.chunks_exact(3)
                .map(|chunk|Point::new(chunk[0], chunk[1], chunk[2]))
                .collect();

    println!("{:?}", points);
}

Answer 2

我认为没有预先完成的方法，但您可以轻松编写可以快速调整的代码以包含第三个 z 组件，类似于此 (Playground)：

#[derive(Debug, Default)]
struct PointBuilder {
    x: Option<i32>,
    y: Option<i32>,
    // add a z here
}

impl PointBuilder {
    fn add(&mut self, value: i32) {
        if self.x.is_none() {
            self.x = Some(value);
        } else if self.y.is_none() {
            self.y = Some(value);
        }
        // add a z here
    }

    fn try_build(&self) -> Option<Point> {
        // and one last z in this match expression
        match (self.x, self.y) {
            (Some(x), Some(y)) => Some(Point::new(x, y)),
            _ => None,
        }
    }
}

fn convert_to_points(data: impl IntoIterator<Item = i32>) -> Vec<Point> {
    data.into_iter()
        .fold((PointBuilder::default(), Vec::<Point>::new()), |(mut builder, mut points), value| {
                builder.add(value);
                if let Some(point) = builder.try_build() {
                    points.push(point);
                    (PointBuilder::default(), points)
                } else {
                    (builder, points)
                }
        })
        .1
}

fn main() {
    let vec = vec![2, 1, 4, 3, 6, 5]; // We want convert that
    let points = convert_to_points(vec);

    println!("{:?}", points);
}

这当然可以作为一个 proc-macro-derive 代码生成器来完成，如果你需要它来处理几十个结构，但我不知道有任何库已经实现了这个，所以这取决于你的用例如果这是值得的。