How do I implement an iterator over a custom in place tuple? | Rust Programming Language Community | Page 1

quaint pecan Jul 25, 2022, 6:51 AM

#

How would I rewrite this function, so the iterator can also return the x and y location of the slice?

pub fn expose_paginated_elements(&self) -> impl Iterator<Item = &Element> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .flat_map(move |slice| &slice[start_y..end_y])
        .map(|(_, elem)| elem)
}

This would be the idea:

pub fn expose_paginated_elements(&self) -> impl Iterator<Item = (usize, usize, &Element)> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .enumerate()
        .flat_map(move |(x, slice)| &slice[start_y..end_y])
        .enumerate()
        .map(|(y, (_, elem))| (x, y, elem))
}

#

This doesn't work for obvious reasons

#

So I was looking at my could and I could make the value here

#

store x and y values

#

but, i want to avoid that

#

lol

#

because it would cause data redundancy

weary flower Jul 25, 2022, 6:59 AM

#

self.cells[start_x..end_x]
  .iter()
  .enumerate()
  .flat_map(move |(x, cells)| {
    iter::repeat(x).zip(cells[start_y..end_y].iter().enumerate())
  })
  .map(|(x, (y, cell))| (x, y, cell))

#

You need to apply the enumerate to get the y to the inner iterator. To pair every element of it to the same x, you can just repeat the x forever and zip it up

quaint pecan Jul 25, 2022, 7:03 AM

#

error[E0271]: type mismatch resolving `<[closure@src/ui/elements/grid.rs:185:26: 185:55] as FnOnce<((usize, (usize, &Vec<(elements::grid::Cell, elements::Element)>)),)>>::Output == (usize, usize, &elements::Element)`
   --> src/ui/elements/grid.rs:173:10
    |
173 |     ) -> impl Iterator<Item = (usize, usize, &Element)> {
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Vec`, found enum `elements::Element`
    |
    = note: expected tuple `(_, _, &Vec<(elements::grid::Cell, elements::Element)>)`
               found tuple `(_, _, &elements::Element)`
    = note: required because of the requirements on the impl of `Iterator` for `std::iter::Map<Zip<std::iter::Repeat<usize>, Enumerate<std::slice::Iter<'_, Vec<(elements::grid::Cell, elements::Element)>>>>, [closure@src/ui/elements/grid.rs:185:26: 185:55]>`

#

This is what it looks like:

pub fn expose_paginated_elements_with_coords(
    &self,
) -> impl Iterator<Item = (usize, usize, &Element)> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .enumerate()
        .flat_map(move |(x, slice)| {
            iter::repeat(x)
                .zip(self.cells[start_y..end_y].iter().enumerate())
                .map(|(y, (_, elem))| (x, y, elem))
        })
}

weary flower Jul 25, 2022, 7:08 AM

#

quaint pecan This is what it looks like: ```rust pub fn expose_paginated_elements_with_coords...

Put the map after the flat_map

quaint pecan Jul 25, 2022, 7:08 AM

#

ok

#

pub fn expose_paginated_elements_with_coords(
    &self,
) -> impl Iterator<Item = (usize, usize, &Element)> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .enumerate()
        .flat_map(move |(x, slice)| {
            iter::repeat(x).zip(self.cells[start_y..end_y].iter().enumerate())
        })
        .map(|(x, (y, vec))| (x, y, vec))
}

#

   Compiling quest_hearth v0.1.0 (/home/dogunbound/QuestHearth/QuestHearth)
error[E0271]: type mismatch resolving `<[closure@src/ui/elements/grid.rs:185:18: 185:45] as FnOnce<((usize, (usize, &Vec<(elements::grid::Cell, elements::Element)>)),)>>::Output == (usize, usize, &elements::Element)`
   --> src/ui/elements/grid.rs:173:10
    |
173 |     ) -> impl Iterator<Item = (usize, usize, &Element)> {
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Vec`, found enum `elements::Element`
    |
    = note: expected tuple `(_, _, &Vec<(elements::grid::Cell, elements::Element)>)`
               found tuple `(_, _, &elements::Element)`
    = note: required because of the requirements on the impl of `Iterator` for `std::iter::Map<FlatMap<Enumerate<std::slice::Iter<'_, Vec<(elements::grid::Cell, elements::Element)>>>, Zip<std::iter::Repeat<usize>, Enumerate<std::slice::Iter<'_, Vec<(elements::grid::Cell, elements::Element)>>>>, [closure@src/ui/elements/grid.rs:182:23: 184:14]>, [closure@src/ui/elements/grid.rs:185:18: 185:45]>`

For more information about this error, try `rustc --explain E0271`.
error: could not compile `quest_hearth` due to previous error
[dogunbound@archlinux QuestHearth]$

weary flower Jul 25, 2022, 7:09 AM

#

Let's see

quaint pecan Jul 25, 2022, 7:09 AM

#

It's cuz of vec

#

pub fn expose_paginated_elements_with_coords(
    &self,
) -> impl Iterator<Item = (usize, usize, &Element)> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .enumerate()
        .flat_map(move |(x, slice)| {
            iter::repeat(x).zip(self.cells[start_y..end_y].iter().enumerate())
        })
        .map(|(x, (y, vec))| (x, y, vec)) // you put cell, but it returns a vec
}```

weary flower Jul 25, 2022, 7:10 AM

#

quaint pecan ```rust pub fn expose_paginated_elements_with_coords( &self, ) -> impl Itera...

The inner zip isn't over self.cells again

#

I realize I reused the name, but I also shadowed the outer one

#

self.cells[start_x..end_x]
  .iter()
  .enumerate()
  .flat_map(move |(x, cells)| { //cells is declared here
    iter::repeat(x).zip(cells[start_y..end_y].iter().enumerate())
  })
  .map(|(x, (y, cell))| (x, y, cell))

quaint pecan Jul 25, 2022, 7:10 AM

#

yea yea

#

that was my fault

#

pub fn expose_paginated_elements_with_coords(
    &self,
) -> impl Iterator<Item = (usize, usize, &Element)> {
    let start_x = self.from.x as usize;
    let start_y = self.from.y as usize;
    let end_x = start_x + self.pagination_size.x as usize;
    let end_y = start_y + self.pagination_size.y as usize;

    self.cells[start_x..end_x]
        .iter()
        .enumerate()
        .flat_map(move |(x, slice)| {
            iter::repeat(x).zip(slice[start_y..end_y].iter().enumerate())
        })
        .map(|(x, (y, (_, ele)))| (x, y, ele))
}

#

this ocmpiles

weary flower Jul 25, 2022, 7:11 AM

#

👍

quaint pecan Jul 25, 2022, 7:11 AM

#

thanks

#

I honestly don't understand this code

#

maybe someday I will

#How do I implement an iterator over a custom in place tuple?