      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107

    /// Used to run some code when a value goes out of scope.
    /// This is sometimes called a 'destructor'.
    ///
    /// When a value goes out of scope, it will have its `drop` method called if
    /// its type implements `Drop`. Then, any fields the value contains will also
    /// be dropped recursively.
    ///
    /// Because of this recursive dropping, you do not need to implement this trait
    /// unless your type needs its own destructor logic.
    ///
    /// Refer to [the chapter on `Drop` in *The Rust Programming Language*][book]
    /// for some more elaboration.
    ///
    /// [book]: ../../book/ch15-03-drop.html
    ///
    /// # Examples
    ///
    /// ## Implementing `Drop`
    ///
    /// The `drop` method is called when `_x` goes out of scope, and therefore
    /// `main` prints `Dropping!`.
    ///
    /// ```
    /// struct HasDrop;
    ///
    /// impl Drop for HasDrop {
    ///     fn drop(&mut self) {
    ///         println!("Dropping!");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     let _x = HasDrop;
    /// }
    /// ```
    ///
    /// ## Dropping is done recursively
    ///
    /// When `outer` goes out of scope, the `drop` method will be called first for
    /// `Outer`, then for `Inner`. Therefore, `main` prints `Dropping Outer!` and
    /// then `Dropping Inner!`.
    ///
    /// ```
    /// struct Inner;
    /// struct Outer(Inner);
    ///
    /// impl Drop for Inner {
    ///     fn drop(&mut self) {
    ///         println!("Dropping Inner!");
    ///     }
    /// }
    ///
    /// impl Drop for Outer {
    ///     fn drop(&mut self) {
    ///         println!("Dropping Outer!");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     let _x = Outer(Inner);
    /// }
    /// ```
    ///
    /// ## Variables are dropped in reverse order of declaration
    ///
    /// `_first` is declared first and `_second` is declared second, so `main` will
    /// print `Declared second!` and then `Declared first!`.
    ///
    /// ```
    /// struct PrintOnDrop(&'static str);
    ///
    /// impl Drop for PrintOnDrop {
    ///     fn drop(&mut self) {
    ///         println!("{}", self.0);
    ///     }
    /// }
    ///
    /// fn main() {
    ///     let _first = PrintOnDrop("Declared first!");
    ///     let _second = PrintOnDrop("Declared second!");
    /// }
    /// ```
    #[lang = "drop"]
    #[stable(feature = "rust1", since = "1.0.0")]
    pub trait Drop {
        /// Executes the destructor for this type.
        ///
        /// This method is called implicitly when the value goes out of scope,
        /// and cannot be called explicitly (this is compiler error [E0040]).
        /// However, the [`std::mem::drop`] function in the prelude can be
        /// used to call the argument's `Drop` implementation.
        ///
        /// When this method has been called, `self` has not yet been deallocated.
        /// That only happens after the method is over.
        /// If this wasn't the case, `self` would be a dangling reference.
        ///
        /// # Panics
        ///
        /// Given that a [`panic!`] will call `drop` as it unwinds, any [`panic!`]
        /// in a `drop` implementation will likely abort.
        ///
        /// [E0040]: ../../error-index.html#E0040
        /// [`panic!`]: ../macro.panic.html
        /// [`std::mem::drop`]: ../../std/mem/fn.drop.html
        #[stable(feature = "rust1", since = "1.0.0")]
        fn drop(&mut self);
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse 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`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)