# Struct std::thread::ScopedKey [−] [src]

    pub struct ScopedKey<T: 'static> {
        // some fields omitted
    }

Unstable (`scoped_tls` #27715)

: scoped TLS has yet to have wide enough use to fully consider stabilizing its interface

Type representing a thread local storage key corresponding to a reference to the type parameter `T`.

Keys are statically allocated and can contain a reference to an instance of type `T` scoped to a particular lifetime. Keys provides two methods, `set` and `with`, both of which currently use closures to control the scope of their contents.

## Methods

### `impl<T> ScopedKey<T>`

#### `fn set<R, F>(&'static self, t: &T, cb: F) -> R where F: FnOnce() -> R`

Unstable (`scoped_tls` #27715)

: scoped TLS has yet to have wide enough use to fully consider stabilizing its interface

Inserts a value into this scoped thread local storage slot for a duration of a closure.

While `cb` is running, the value `t` will be returned by `get` unless this function is called recursively inside of `cb`.

Upon return, this function will restore the previous value, if any was available.

# Examples

#![feature(scoped_tls)] fn main() { scoped_thread_local!(static FOO: u32); FOO.set(&100, || { let val = FOO.with(|v| *v); assert_eq!(val, 100); // set can be called recursively FOO.set(&101, || { // ... }); // Recursive calls restore the previous value. let val = FOO.with(|v| *v); assert_eq!(val, 100); }); }

    #![feature(scoped_tls)]

    scoped_thread_local!(static FOO: u32);

    FOO.set(&100, || {
        let val = FOO.with(|v| *v);
        assert_eq!(val, 100);

        // set can be called recursively
        FOO.set(&101, || {
            // ...
        });

        // Recursive calls restore the previous value.
        let val = FOO.with(|v| *v);
        assert_eq!(val, 100);
    });

#### `fn with<R, F>(&'static self, cb: F) -> R where F: FnOnce(&T) -> R`

Unstable (`scoped_tls` #27715)

: scoped TLS has yet to have wide enough use to fully consider stabilizing its interface

Gets a value out of this scoped variable.

This function takes a closure which receives the value of this variable.

# Panics

This function will panic if `set` has not previously been called.

# Examples

#![feature(scoped_tls)] fn main() { scoped_thread_local!(static FOO: u32); FOO.with(|slot| { // work with `slot` }); }

    #![feature(scoped_tls)]

    scoped_thread_local!(static FOO: u32);

    FOO.with(|slot| {
        // work with `slot`
    });

#### `fn is_set(&'static self) -> bool`

Unstable (`scoped_tls` #27715)

: scoped TLS has yet to have wide enough use to fully consider stabilizing its interface

Test whether this TLS key has been `set` for the current thread.

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