Estoy jugando con Rust , y estoy tratando de acceder al primer argumento de línea de comando con este código: use std::env; fn main() { let args: Vec = env::args().collect(); let dir = args[1]; } Y obtengo este error: error[E0507]: cannot move out of indexed content –> src/main.rs:5:15 | 5 | let dir = args[1]; […]
Me gustaría desestructurar una tupla y asignar parte del resultado a una nueva variable y asignar otra parte del resultado a una existente. El siguiente código ilustra la intención (es un ejemplo tonto que da como resultado una impresión de bucle infinito [0] ): fn main() { let mut list = &[0, 1, 2, 3][..]; […]
Hace unos días, había una pregunta en la que alguien tenía un problema con las vidas vinculadas de una referencia mutable a un tipo que contenía datos prestados. El problema era proporcionar una referencia al tipo con un préstamo de la misma duración que los datos prestados dentro del tipo. Traté de recrear el problema: […]
Si tiene una estructura de directorios como esta: src/main.rs src/module1/blah.rs src/module1/blah2.rs src/utils/logging.rs ¿Cómo se usan las funciones de otros archivos? Desde el tutorial de Rust, parece que debería poder hacer esto: main.rs mod utils { pub mod logging; } mod module1 { pub mod blah; } fn main() { utils::logging::trace(“Logging works”); module1::blah::doit(); } logging.rs pub […]
Tengo un error de comstackción que implica una macro: :6:19: 6:50 error: cannot move out of captured outer variable in an `FnMut` closure :6 bind ( $ e , move | $ p | mdo ! { $ ( $ t ) * } ) ) ; ( ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :1:1: 14:36 note: in expansion of […]
Estoy usando un HashMap para almacenar una enumeración. Me gustaría obtener un valor de HashMap y si el valor es una variante de enumeración específica, me gustaría insertar una copia modificada del valor en el HashMap . El código que se me ocurrió es así: if let Node::LeafNode(mut leaf_node) = *(self.pages.get(&page).unwrap()) { let mut leaf_node […]
Este progtwig muere debido a la recursión infinita: use std::any::Any; trait Foo { fn get(&self, index: usize) -> Option; } impl Foo for Vec { fn get(&self, index: usize) -> Option { Vec::get(self, index).map(|v| v as &Any) } } fn main() { let v: Vec = vec![1, 2, 4]; println!(“Results: {:?}”, v.get(0)) } El comstackdor […]
Intenté implementar fizzbuzz en Rust y fallé con un error arcano: fn main() { let mut i = 1; while i < 100 { println!( "{}{}{}", if i % 3 == 0 { "Fizz" }, if i % 5 == 0 { "Buzz" }, if !(i % 3 == 0 || i % 5 == […]
Estoy trabajando con ejemplos en Rust por ejemplo . #[derive(Debug)] struct Point { x: f64, y: f64, } #[derive(Debug)] struct Rectangle { p1: Point, p2: Point, } fn main() { let mut point: Point = Point { x: 0.3, y: 0.4 }; println!(“point coordinates: ({}, {})”, point.x, point.y); let rectangle = Rectangle { p1: Point […]
Tengo una enumeración con la siguiente estructura: enum Expression { Add(Add), Mul(Mul), Var(Var), Coeff(Coeff) } donde los ‘miembros’ de cada variante son estructuras. Ahora quiero comparar si dos enumeraciones tienen la misma variante. Entonces si tengo let a = Expression::Add({something}); let b = Expression::Add({somethingelse}); cmpvariant(a, b) debe ser true . Puedo imaginar un código de […]