struct Container {
    items: Vec<i32>,
}

fn loop_items(&mut self) {
    for i in self.items.iter_mut() {
        self.do_something(i)
    }
}
fn do_something(&self, i: &i32) {}

 |         for i in self.items.iter_mut() {
 |                  ---------------------
 |                  |
 |                  mutable borrow occurs here
 |                  mutable borrow later used here
 |             self.do_something(i)
 |             ^^^^^^^^^^^^^^^^^^^^ immutable borrow occurs here

struct Container {
    items: RefCell<Vec<i32>>,
}

fn loop_items(&self) {
    for i in self.items.borrow_mut().iter_mut() {
        self.do_something(i)
    }
}

fn do_something(&self, i: &i32) { }

fn foo(s: &str, some_condition: bool) -> &str {
    if some_condition {
        &s.replace("foo", "bar")
    } else {
        s
    }
}

   |         &s.replace("foo", "bar")
   |         ^-----------------------
   |         ||
   |         |temporary value created here
   |         returns a reference to data owned by the current function

fn foo(s: &str, some_condition: bool) -> Cow<str> {
    if some_condition {
        Cow::from(s.replace("foo", "bar"))
    } else {
        Cow::from(s)
    }
}

cargo build --timings

//  syscall
int brk(void *addr);

void *mmap(void addr, size_t length, int prot, int flags,
           int fd, off_t offset);

// glibc
void *malloc( size_t size );
void free( void *ptr );

struct Pool<T> {
    items: Vec<T>
}

fn pull(&mut self) -> T;
fn attach(&mut self, T);