# Function ethcore_util::standard::mem::drop 1.0.0 [−] [src]

    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.

This function is not magic; it is literally defined as

    pub fn drop<T>(_x: T) { }

Because `_x` is moved into the function, it is automatically dropped before the function returns.

# Examples

Basic usage:

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

    drop(v); // explicitly drop the vector

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

    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:

    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 release a `RefCell` 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`.

    #[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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)