Function core::mem::drop
[−]
[src]
pub fn drop<T>(_x: T)1.0.0
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:
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()
#[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