lifetime

Here is emulation of my problem, when a borrow ends too late use std::collections::HashMap; struct Item { capacity: u64 } struct Petrol { name: String, fuel: HashMap<&'static str, Item> } fn buy_gaz(p: &mut Petrol) { match p.fuel.get("gaz") { Some(gaz) => { fire_petrol(p); } None => () } } fn fire_petrol(p: &mut Petrol) { println!("Boom!"); p.fuel.remove("gaz"); p.fuel.remove("benzin"); } fn main() { let mut bt = Petrol { name: "Britii Petrovich".to_string(), fuel: HashMap::new() }; bt.fuel.insert("gaz", Item { capacity: 1000 }); bt.fuel.insert("benzin", Item { capacity: 5000 }); buy_gaz(&mut

I'm new at Rust and still struggling with the borrow checker and getting lifetimes right. Here's a simple struct I've started to build - it stores collections of command-line argument like things (which can be represented by a --string or a -c or both): struct OptionMap<'a, T: 'a> { name: HashMap<String, &'a T>, short_name: HashMap<char, &'a T>, options: Vec<T> } impl<'a, T: 'a> OptionMap<'a, T> { pub fn new() -> OptionMap<'a, T> { OptionMap { name: HashMap::new(), short_name: HashMap::new(), options: Vec::new() } } pub fn register(&mut self, name: &OptionName, option: T) { if name.name.is

This is the minimal code: struct Node<T> { item: T, next: Link<T>, } type Link<T> = Option<Box<Node<T>>>; pub struct IterMut<'a, T>(&'a mut Link<T>); impl<'a, T> Iterator for IterMut<'a, T> { type Item = &'a mut T; fn next(&mut self) -> Option<Self::Item> { self.0.as_mut().map(|boxed_node| { self.0 = &mut boxed_node.next; &mut boxed_node.item }) } } As far as I understand, there should be no problem. I have done a lot of searching, but no way. error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements --> src/lib.rs:13:16 | 13 | self.0.as_mut().map(|boxed

First of all: I am fully aware of this post: Cannot infer appropriate lifetime for autoref in Iterator impl and that the problem is probably similar to mine. However, I can't get it working with the knowledge of this thread. The code: use std::str::Chars; use super::token::*; use super::token_stream::TokenStream; pub struct Lexer<'a> { input: Chars<'a>, buffer: String, cur_char: char } impl<'a> Lexer<'a> { pub fn new(iterator: Chars<'a>) -> Lexer { let mut lexer = Lexer { input: iterator, buffer: String::new(), cur_char: '\0' }; lexer.consume_next(); lexer } pub fn new_from_str(content : &str)

I'm building a PromptSet that can ask a series of questions in a row. For testing reasons, it allows you to pass a reader and writer instead of using stdin & stdout directly. Because stdin and stdout are the common use case, I would like to create a default "constructor" that allows the user to produce a PromptSet<StdinLock, StdoutLock> without needing any parameters. Here's the code so far: use std::io::{self, BufRead, StdinLock, StdoutLock, Write}; pub struct PromptSet<R, W> where R: BufRead, W: Write, { pub reader: R, pub writer: W, } impl<R, W> PromptSet<R, W> where R: BufRead, W: Write, {

I'm implementing a parser in Rust. I have to update the index for the lookahead, but when I call self.get() after self.current() I get an error: cannot borrow *self as mutable more than once at a time It's confusing since I'm new to Rust. #[derive(Debug)] pub enum Token { Random(String), Undefined(String), } struct Point { token: Vec<Token>, look: usize, } impl Point { pub fn init(&mut self){ while let Some(token) = self.current(){ println!("{:?}", token); let _ = self.get(); } } pub fn current(&mut self) -> Option<&Token> { self.token.get(self.look) } pub fn get(&mut self) -> Option<&Token> {

A struct is defined as: struct Node { set: HashSet<usize>, // other fields omitted } I have to implement a function for a trait (compatibility issues) which needs to return all elements in the set as a slice. I am aware of something like the following function won't work: impl Node { pub fn set_slice(&self) -> &[usize] { let elems: Vec<_> = self.set.iter().cloned().collect(); &elems[..] } } The problem is: error[E0597]: `elems` does not live long enough --> src/main.rs:11:10 | 11 | &elems[..] | ^^^^^ borrowed value does not live long enough 12 | } | - borrowed value only lives until here |

I built a GTK application with gtk-rs. When I build the main window, I want to use some dynamic parameters such as window height. I created a struct which contains all such settings and want to use this as an input parameter for the function building the UI: fn main() { let application = gtk::Application::new(Some("id"), Default::default()) .expect("Initialization failed..."); let config = Config {width: 100., height: 100.}; application.connect_activate(|app| { build_ui(app, config.clone()); }); // Use config further application.run(&args().collect::<Vec<_>>()); } #[derive(Debug, Clone)] pub