Function core::mem::drop

pub fn drop<T>(_x: T)

Disposes of a value.

While this does call the argument's implementation of Drop, it will not release any borrows, as borrows are based on lexical scope.

This effectively does nothing for types which implement Copy, e.g. integers. Such values are copied and then moved into the function, so the value persists after this function call.

Examples

Basic usage:

fn main() { let v = vec![1, 2, 3]; drop(v); // explicitly drop the vector }

let v = vec![1, 2, 3];

drop(v); // explicitly drop the vector

Borrows are based on lexical scope, so this produces an error:

fn main() { let mut v = vec![1, 2, 3]; let x = &v[0]; drop(x); // explicitly drop the reference, but the borrow still exists v.push(4); // error: cannot borrow `v` as mutable because it is also // borrowed as immutable }

let mut v = vec![1, 2, 3];
let x = &v[0];

drop(x); // explicitly drop the reference, but the borrow still exists

v.push(4); // error: cannot borrow `v` as mutable because it is also
           // borrowed as immutable

An inner scope is needed to fix this:

fn main() { let mut v = vec![1, 2, 3]; { let x = &v[0]; drop(x); // this is now redundant, as `x` is going out of scope anyway } v.push(4); // no problems }

let mut v = vec![1, 2, 3];

{
    let x = &v[0];

    drop(x); // this is now redundant, as `x` is going out of scope anyway
}

v.push(4); // no problems

Since RefCell enforces the borrow rules at runtime, drop() can seemingly release a borrow of one:

fn main() { use std::cell::RefCell; let x = RefCell::new(1); let mut mutable_borrow = x.borrow_mut(); *mutable_borrow = 1; drop(mutable_borrow); // relinquish the mutable borrow on this slot let borrow = x.borrow(); println!("{}", *borrow); }

use std::cell::RefCell;

let x = RefCell::new(1);

let mut mutable_borrow = x.borrow_mut();
*mutable_borrow = 1;

drop(mutable_borrow); // relinquish the mutable borrow on this slot

let borrow = x.borrow();
println!("{}", *borrow);

Integers and other types implementing Copy are unaffected by drop()

fn main() { #[derive(Copy, Clone)] struct Foo(u8); let x = 1; let y = Foo(2); drop(x); // a copy of `x` is moved and dropped drop(y); // a copy of `y` is moved and dropped println!("x: {}, y: {}", x, y.0); // still available }

#[derive(Copy, Clone)]
struct Foo(u8);

let x = 1;
let y = Foo(2);
drop(x); // a copy of `x` is moved and dropped
drop(y); // a copy of `y` is moved and dropped

println!("x: {}, y: {}", x, y.0); // still available