Perguntas[rust](coding)

Aqui está o código:

fn main() {
    let foo: Foo<i32> = Foo(42);
    let bar: Foo<i64> = foo.map_ref(|x| *x as i64); // OK
    let baz: Foo<&i32> = foo.map_ref(|x| x); // Error
}

struct Foo<T>(T);

impl<T> Foo<T> {
    fn map_ref<U, F>(&self, f: F) -> Foo<U>
    where
        F: Fn(&T) -> U,
    {
        Foo(f(&self.0))
    }
}

Falha ao compilar quando Ué referência:

error: lifetime may not live long enough
 --> src\main.rs:4:48
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
  |                                          -   - ^ returning this value requires that `'1` must outlive `'2`
  |                                          |   |
  |                                          |   return type of closure is &'2 i32
  |                                          let's call the lifetime of this reference `'1`
  |
help: dereference the return value
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| *x); // Error
  |                                                +

Tentei introduzir um tempo de vida genérico 'ae Foo::map_refnão tenho ideia do que fazer a seguir.

Eu tenho um código como este:

use std::fmt::Write;

fn main() {
    let mut side_str = String::new();
    write!(&mut side_str, "world").unwrap();

    println!(
        "hello_{:?}_",
        format!("{:?}", side_str),
        );
}

Estou obtendo citações na saída. Como escrevo de forma concisa para não ter aspas?

Estou tentando implementar a marcação vitalícia como demonstrada neste playground, mas me perdi em algum lugar e não consigo descobrir o que fiz de errado.

Aqui está o erro que estou recebendo. Ele só aparece se a v.pup(...)linha estiver lá.

error[E0597]: `arena` does not live long enough
  --> src/lib.rs:65:5
   |
64 |       let arena = goop::Parent;
   |           ----- binding `arena` declared here
65 |       arena.scope(|child, context| {
   |       -^^^^
   |       |
   |  _____borrowed value does not live long enough
   | |
66 | |         let mut v = Foo::new(child);
67 | |         v.pup(context);
68 | |     });
   | |______- argument requires that `arena` is borrowed for `'static`
69 |   }
   |   - `arena` dropped here while still borrowed

Aqui está meu código, o mais minimalista que consegui fazer:

#![no_std]

mod goop {
    use core::marker::PhantomData;

    // Cell<T> is invariant in T; so Cell<&'id _> makes `id` invariant.
    // This means that the inference engine is not allowed to shrink or
    // grow 'id to solve the borrow system. 
    type Id<'id> = PhantomData<::core::cell::Cell<&'id mut ()>>;
    
    #[derive(Clone, Copy)]
    pub struct Child<'id> {
        _id: Id<'id>,
    }
    
    pub struct Parent;
    
    #[derive(Clone, Copy)]
    pub struct Context<'id, 'p> {
        _id: Id<'id>,
        parent: &'p Parent,
    }
    
    impl Parent {
        pub fn scope<'p, F>(&'p self, _f: F)
        where
            F: for<'id> FnOnce(Child<'id>, Context<'id, 'p>)
        {}
        
        fn internal_something(&self) {}
    }
    
    pub trait Gator<C> {
        fn gate(&self, c: C);
    }
    
    impl<'p, 'id> Gator<Context<'p, 'id>> for Child<'id> {
        fn gate(&self, c: Context<'p, 'id>) {
            c.parent.internal_something();
        }
    }
}

use core::marker::PhantomData;

struct Foo<C, G> {
    _c: PhantomData<C>,
    g: G,
}
impl<C, G: goop::Gator<C>> Foo<C, G> {
    fn new(g: G) -> Self {
        Self {
            _c: PhantomData,
            g,
        }
    }
    
    fn pup(&mut self, c: C) {
        self.g.gate(c)
    }
}

fn _check() {
    let arena = goop::Parent;
    arena.scope(|child, context| {
        let mut v = Foo::new(child);
        v.pup(context);
    });
}

parque infantil

Estou tentando usar crate docx_rustpara mesclar uma lista de documentos do Word em um. Eu tento isso, mas estou tendo um problema de vida docporque ele é descartado no final do forloop.

use docx_rust::{Docx, DocxFile};

fn merge_docs<'a>(file_paths: &[&str], output_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut merged_doc = Docx::default();

    for path in file_paths {
        let doc = DocxFile::from_file(Path::new(path))?;  // No Rc here initially
        let mut p_doc = doc.parse().unwrap();
        merged_doc.document.body.content.extend(p_doc.document.body.content.drain(..));
    }

    merged_doc.write_file(Path::new(output_path))?;

    Ok(())
}

Tentei empurrar cada documento aberto para um vetor, mas isso não estende o tempo de vida. Tentei armazená-los em um Rc::new(), mas não funcionou.

Aceitarei qualquer solução!

Esta questão está relacionada à pergunta feita aqui: Como declarar uma variável, mas não atribuí-la?

Meu problema é um pouco diferente. MRE:

let var: MyGenericType;
for value in vec_of_values_of_my_generic_type {
    // one of the values is mathematically guaranteed to meet this condition because the vector is special
    if <value meets a certain condition> {
        var = value;
    }
}

<use var>

Erro:

error[E0381]: used binding `var` is possibly-uninitialized
   --> example/src/lib.rs:127:23
    |
120 |             let var: MyGenericType;
    |                 -- binding declared here but left uninitialized
...
123 |                     var = value;
    |                     -- binding initialized here in some conditions
...
127 |             foo(var);
    |                       ^^ `var` used here but it is possibly-uninitialized

Como posso corrigir isso?

fn dangle() {
    fn get_str<'a>(s: *const String) -> &'a str {
        unsafe { &*s }
    }
    
    let s = String::from("hello");
    let dangling = get_str(&s);
    drop(s);
    println!("Invalid str: {}", dangling);
}

#[test]
fn test() {
    dangle();  // it should panic, but does not
}

fn main() {
    dangle();  // panics
}

A main()função entra em pânico, como eu esperava. Mas por que a test()função roda com sucesso?

Eu tenho o seguinte código Rust

use std::error::Error;

#[derive(Debug)]
enum MyEnum {
    First,
    Second,
}

fn do_something(index: usize, m: &MyEnum) {
    eprintln!("do_something: {} {:?}", index, m);
}

async fn test() -> Result<(), Box<dyn Error>> {
    let myvec = vec![MyEnum::First, MyEnum::Second];
    let c = String::from("cap");

    let futures = myvec.iter().enumerate().map(|(index, el)| async {
        eprintln!("Element: {}", &c);
        do_something(index, el);
    });

    futures::future::join_all(futures).await;
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    test().await?;
    Ok(())
}

O compilador reclama que:

error[E0373]: async block may outlive the current function, but it borrows `index`, which is owned by the current function
  --> src/main.rs:17:62
   |
17 |     let futures = myvec.iter().enumerate().map(|(index, el)| async {
   |                                                              ^^^^^ may outlive borrowed value `index`
18 |         eprintln!("Element: {}", &c);
19 |         do_something(index, el);
   |                      ----- `index` is borrowed here
   |

Por que não está reclamando da elvariável?

E como consertar esse código? Eu gostaria de continuar usando o iterador e não foro loop. Eu posso mudar outras partes do código, por exemplo, do_something()posso ter protótipos diferentes.

Coloquei a cvariável aqui para proibir a solução fácil com async move {...}. A string cnão deve ser movida.

Sem enumerate()(e sem index) funciona. Eu esperaria que index(que tem usizetipo) fosse facilmente copiável.

Estou tentando gerar um objeto json como abaixo

// final json output expected
{
    "j1": {
        "1981": {
            "income": 215
        },
        "1982": {
            "income": 350
        },
    },
    "j2": {
        "1981": {
            "income": 100
        },
        "1982": {
            "income": 215
        },
    }
}

Eu tenho o seguinte código

use serde_json::{Value, Map};

struct s {
    name: String,
    year: i32,
    income: i64
}

fn main() {
    let rows :Vec<s> = vec!(
        s { name: "j1".to_string(), year: 1981, income: 100},
        s { name: "j1".to_string(), year: 1981, income: 115},
        s { name: "j1".to_string(), year: 1982, income: 120},
        s { name: "j1".to_string(), year: 1982, income: 100},
        s { name: "j1".to_string(), year: 1982, income: 130},
        s { name: "j2".to_string(), year: 1981, income: 100},
        s { name: "j2".to_string(), year: 1982, income: 120},
        s { name: "j2".to_string(), year: 1982, income: 130}
    );
    
    let mut data_map: Map<String, Value> = Map::new();
    for row in rows {
        let  mut name: &Map<String, Value> = match data_map.get(&row.name) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let mut year:  &Map<String, Value> = match data_map.get(&row.year.to_string()) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let income: i64 = year.get("income").unwrap_or(&Value::Number(0i64.into())).as_i64().unwrap() + row.income;
        year.insert("income".to_string(), Value::Number(income.into()));
    }
}

Criei este código para fazer a pergunta. Também consultei o deepseek e tal

A mensagem de erro que estou recebendo é

error[E0596]: cannot borrow `*year` as mutable, as it is behind a `&` reference
  --> src\main.rs:32:9
   |
32 |         year.insert("income".to_string(), Value::Number(income.into()));
   |         ^^^^ `year` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider changing this binding's type
   |
27 |         let mut year: &mut serde_json::Map<std::string::String, Value> = match data_map.get(&row.year.to_string()) {
   |                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Claramente tenho deficiência em entender referência e empréstimo. Qualquer ajuda seria apreciada.

No código abaixo, estou tendo um problema relacionado ao verificador de empréstimo se eu comentar a println!declaração após a expressão de correspondência. E para corrigir esse problema, o compilador está me pedindo para colocar um ponto e vírgula no final da matchexpressão, o que resolve o problema, mas não consegui entender a necessidade disso.

use std::sync::{Arc, Mutex};

#[derive(Default)]
struct A {
    b: Arc<Mutex<B>>,
}

#[derive(Default)]
struct B {
    c: Arc<Mutex<C>>,
}

#[derive(Default)]
struct C {
    d: i32,
}

fn main() {
    let a = A::default();
    
    match a.b.lock().unwrap().c.lock().unwrap().d {
        0 => println!("zero"),
        _ => println!("non-zero"),
    }
    // uncommenting the below line makes borrow checker happy
    // println!("{}", a.b.lock().unwrap().c.lock().unwrap().d);
}

Erro

error[E0597]: `a.b` does not live long enough
  --> src/main.rs:21:11
   |
19 |     let a = A::default();
   |         - binding `a` declared here
20 |     
21 |     match a.b.lock().unwrap().c.lock().unwrap().d {
   |           ^^^----------------
   |           |
   |           borrowed value does not live long enough
   |           a temporary with access to the borrow is created here ...
...
27 | }
   | -
   | |
   | `a.b` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `MutexGuard`
   |
help: consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped
   |
24 |     };
   |      +

For more information about this error, try `rustc --explain E0597`.

Estou tentando especificar um runner personalizado para cargo, mas ele simplesmente se recusa a usá-lo. Tentei usar meu próprio target triple after personalizado target.e tentei usar a opção cfg que você vê abaixo:

[target.'cfg(all(target_os = "none"))']
runner = "qemu-system-riscv64 -machine virt -kernel "

mas em ambos os casos, ele diz que tenho uma chave de manifesto não utilizada ao compilar:

warning: unused manifest key: target.cfg(all(target_os = "none")).runner

Ao usá-lo, cargo runele sempre executa o binário normal em vez do meu executor personalizado.

Meu caso é especial, pois estou usando o config.tomlarquivo na .cargopasta para especificar meu triplo alvo personalizado:

[unstable]
build-std-features = ["compiler-builtins-mem"]
build-std = ["core", "compiler_builtins"]

[build]
target = "compilation_targets/riscv-unknown-kadrix.json"

Como este é um kernel, ele tem algumas coisas especiais:

• Não usa a biblioteca padrão
• Não usa uma função principal, seu ponto de entrada é_start
• .startUsa uma seção personalizada para a _startfunção em vez de.text
• Usa uma estrutura de teste personalizada

Não tenho certeza se algum desses pontos é relevante, mas é melhor prevenir do que remediar. O código está aqui se você quiser inspecionar mais.