i need some help with understanding of rust basics and memory basics at all. I think this will be helpful for those who come across this after me. memory adress (1) Here i create a function thats return pointer to a vector. Why there is two different adresses if there must be the same pointer?… Read More Memory management basics of Rust lang

The code: pub struct Scope<‘a> { pub parent: Option<Box<Scope<‘a>>>, pub vars: HashMap<&’a str, Value>, } impl<‘a> Scope<‘a> { pub fn get(&self, name: &str) -> Result<&Value, String> { if let Some(v) = self.vars.get(name) { Ok(v) } else if let Some(parent) = self.parent { // <- error here parent.get(name) // <- and here } else { Err(format!("{}… Read More How to handle `<Option<Box<_>>>` in Rust?

I am working on a little Rust project where many functions take an optional mutable reference to a struct. For simplicity, let’s say that this struct is a String. So the functions look something like this: fn append_to_string(maybe_string: Option<&mut String>) { if let Some(s) = maybe_string { s.push(‘1’); } } My main function has ownership… Read More Given an optional mutable reference, can I pass it to another function without moving it?

In my efforts to learn Rusts’ notorious borrow checker I’m hopelessly stuck. I’ve constructed a tree structure that loosely represents a file system. As soon as I’m trying to borrow a enum value and try to mutate the underlying value, I get an error that I don’t understand. Pretend that cache_files actually has some elements… Read More Rust cannot move out of enum variant

I have the following code: struct MyStruct<‘a>{ data: &’a str, } fn get<‘a>(S: &’a MyStruct<‘a>) -> &’a str{ S.data } fn set<‘a>(S: &’a mut MyStruct<‘a>, x: &’a str){ S.data = x; } fn main(){ let mut S = MyStruct{data: "hello"}; let foo: &str = get(&S); set(&mut S, "goodbye"); dbg!(foo); } This fails to compile because… Read More Rust: why does borrowing a reference inside struct borrow the whole struct?

In attempting to refactor a Rust application that was working fine, I tried to separate out the contents of a loop into a new function. However, in this newly refactored out function, I needed to pass an argument that had to be mutable, and passed by reference. Suddenly the code that absolutely worked inline, broke… Read More Why do Rust lifetimes break mutable references in loops?

I am trying to do the following // Just removes redundant white space while also splitting the string // with a whitespace. fn split_whitespace(string: &str) -> Vec<&str> { let words: Vec<&str> = string .split_whitespace() .filter(|&word| word != "") .collect(); words } pub fn get_websites_from_hosts(hosts_path: &Path) -> Result<Vec<Website>, std::io::Error> { let hosts_string = read_to_string(hosts_path)?; let result:… Read More How to return a struct whose property has a type of &str from a function in rust?

I want to be able to store a mutable borrow &mut Foo<‘a> inside an enum variant. I can work with the mutable borrow directly just fine, but not with an enum containing the mutable borrow. Extract of simplified code below (‘full’ playground version with ‘broken’ code commented out here). #[derive(Debug)] struct Foo<‘a> { shared_ref: &’a… Read More How to store a mutable borrow with a specified lifetime in an enum?

The problem I want to create a function (chain) that takes a function f: Fn(i32) -> i32, number n and returns a new function g: Fn(i32) -> i32 that applys f to it’s input n times. For example: chain(3, f) should return a function eqvivalent to: |x| f(f(f(x))). Here is my attempt at achieving this… Read More Rust: Apply function n times

I have a collection containing elements wrapped in RefCell that I borrow. I have a wrapper struct to make the api usable like so: pub struct RefWrapper<‘a, T> { inner: RefMut<‘a, T>, } impl<T> Deref for RefWrapper<T> { type Target = T; fn deref(&self) -> &T { &self.inner } } impl<T> DerefMut for RefWrapper<T> {… Read More How can I reinterpret a RefMut<T> as a RefMut<U>