Início / coding / Perguntas / 78369598
Accepted
thefrollickingnerd
Asked: 2024-04-23 10:14:20 +0800 CST

Passe o valor do iterador sem parar a iteração

  • 772

Eu tenho uma função que analisa uma string de entrada:

fn parse_input(s: &str) -> ((usize, usize), BTreeMap<(usize, usize), Tile>){
 let mut start: (usize, usize) = (0,0);
 let grid = s.split("\n").enumerate().flat_map(|(r,l)| {
     l.chars().enumerate().map(move |(col, c)| {
         let t = classify_tile(c);
         match t {
             Tile::Start => {
                  *start = (r, col);
                  ((r,col), t)
                 },
             _ => ((r,col), t) 
         }
     })
 }).collect::<BTreeMap<(usize, usize), Tile>>();
 (start, grid)
}

Basicamente, quero capturar o valor r e col do bloco inicial (que é único, apenas uma ocorrência). Mas atualmente, se eu tentar modificar a tupla dentro do iterador, presumo que devido a motivos de empréstimo e escopo, o valor não será modificado fora do iterador. É importante que o iterador termine.

Uma solução alternativa seria procurar o bloco inicial no btreemap posteriormente, mas espero uma solução mais eficiente.

Devo apenas fazer isso como loops for aninhados? A iteração é realmente significativamente mais eficiente aqui?

editar: a função classify_tile retorna o tipo enum. Iniciar, Solo ou Tubo. A seção *start = (r,col) é a parte que não funciona. Essa foi minha tentativa de resolver isso. Todo o resto funciona.

dictionary

1 respostas

  1. Best Answer

    Você pode fazer o que quiser, se reestruturar um pouco seu iterador.

    Mas vamos primeiro abordar qual é o problema.

    Como exemplo mais simples, vamos contar todas as letras maiúsculas (de uma forma boba):

    let text = "Hello World";

let mut count = 0;

text.split_whitespace()
   .flat_map(|s| {
        s.chars().map(|c| {
            if c.is_uppercase() {
                count += 1;
            }
        })
    })
    .for_each(|_| {});

assert_eq!(count, 2);

    Se tentarmos compilar isso, teremos o mesmo problema que você está tendo:

    error: captured variable cannot escape `FnMut` closure body
  --> src\main.rs:85:13
   |
80 |       let mut count = 0;
   |           --------- variable defined here
...
84 |           .flat_map(|s| {
   |                       - inferred to be a `FnMut` closure
85 | /             s.chars().map(|c| {
86 | |                 if c.is_uppercase() {
87 | |                     count += 1;
   | |                     ----- variable captured here
88 | |                 }
89 | |             })
   | |______________^ returns a closure that contains a reference to a captured variable, which then escapes the closure body
   |
   = note: `FnMut` closures only have access to their captured variables while they are executing...
   = note: ...therefore, they cannot allow references to captured variables to escape

    Por que é que?

    O fechamento dado map()requer empréstimos mutáveis count, o que por si só é perfeitamente aceitável.

    O problema surge quando entramos flat_map()na mistura. Uma vez que flat_map()produz potencialmente vários iteradores. Cada um desses iteradores produzidos requer empréstimos mutáveis count. É claro que isso não é permitido, uma vez que não podemos pedir emprestado nada mais de uma vez.

    No geral, isso é fácil de resolver, basta reestruturar o iterador:

    text.split_whitespace()
    .flat_map(|s| s.chars())
    .map(|c| {
        if c.is_uppercase() {
            count += 1;
        }
    })
    .for_each(|_| {});

    ou

    text.split_whitespace()
    .map(|s| s.chars())
    .flatten()
    .map(|c| {
        if c.is_uppercase() {
            count += 1;
        }
    })
    .for_each(|_| {});

    Resolver isso para o seu iterador poderia ser algo assim:

    let grid = s
    .split("\n")
    .enumerate()
    .flat_map(|(r, l)| {
        l.chars().enumerate().map(move |(col, c)| {
            let t = classify_tile(c);
            match t {
                Tile::Start => ((r, col), t),
                _ => ((r, col), t),
            }
        })
    })
    .inspect(|((r, col), t)| match t {
        Tile::Start => {
            start = (*r, *col);
        }
        _ => {}
    })
    .collect::<BTreeMap<(usize, usize), Tile>>();

    ou

    let grid = s
    .split("\n")
    .enumerate()
    .flat_map(|(r, l)| l.chars().enumerate().map(move |(col, c)| ((r, col), c)))
    .map(|((r, col), c)| {
        let t = classify_tile(c);
        match t {
            Tile::Start => {
                start = (r, col);
                ((r, col), t)
            }
            _ => ((r, col), t),
        }
    })
    .collect::<BTreeMap<(usize, usize), Tile>>();

    Pode ser escrito de várias maneiras.

    • 1

relate perguntas