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