     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

    use std::ops::{Deref, DerefMut};

    /// Macro to create a `Guard` (without any owned value).
    ///
    /// The macro takes one expression `$e`, which is the body of a closure
    /// that will run when the scope is exited. The expression can
    /// be a whole block.
    #[macro_export]
    macro_rules! defer {
        ($e:expr) => {
            let _guard = $crate::guard((), |_| $e);
        }
    }

    /// `Guard` is a scope guard that may own a protected value.
    ///
    /// If you place a guard value in a local variable, its destructor will
    /// run regardless how you leave the function — regular return or panic
    /// (barring abnormal incidents like aborts; so as long as destructors run).
    ///
    /// The guard's closure will be called with a mut ref to the held value
    /// in the destructor. It's called only once.
    ///
    /// The `Guard` implements `Deref` so that you can access the inner value.
    pub struct Guard<T, F>
        where F: FnMut(&mut T)
    {
        __dropfn: F,
        __value: T,
    }

    /// Create a new `Guard` owning `v` and with deferred closure `dropfn`.
    pub fn guard<T, F>(v: T, dropfn: F) -> Guard<T, F>
        where F: FnMut(&mut T)
    {
        Guard{__value: v, __dropfn: dropfn}
    }

    impl<T, F> Deref for Guard<T, F>
        where F: FnMut(&mut T)
    {
        type Target = T;
        fn deref(&self) -> &T
        {
            &self.__value
        }

    }

    impl<T, F> DerefMut for Guard<T, F>
        where F: FnMut(&mut T)
    {
        fn deref_mut(&mut self) -> &mut T
        {
            &mut self.__value
        }
    }

    impl<T, F> Drop for Guard<T, F>
        where F: FnMut(&mut T)
    {
        fn drop(&mut self) {
            (self.__dropfn)(&mut self.__value)
        }
    }

    #[test]
    fn test_defer() {
        use std::cell::Cell;

        let drops = Cell::new(0);
        defer!(drops.set(1000));
        assert_eq!(drops.get(), 0);
    }

# 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

## 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`)