# [−][src]Struct rayon::Scope

    pub struct Scope<'scope> { /* fields omitted */ }

Represents a fork-join scope which can be used to spawn any number of tasks. See `scope()` for more information.

## Methods

### `impl<'scope> Scope<'scope>`[src]

#### `pub fn spawn<BODY>(&self, body: BODY) where
BODY: FnOnce(&Scope<'scope>) + Send + 'scope,` [src]

Spawns a job into the fork-join scope `self`. This job will execute sometime before the fork-join scope completes. The job is specified as a closure, and this closure receives its own reference to the scope `self` as argument. This can be used to inject new jobs into `self`.

# Returns

Nothing. The spawned closures cannot pass back values to the caller directly, though they can write to local variables on the stack (if those variables outlive the scope) or communicate through shared channels.

(The intention is to eventualy integrate with Rust futures to support spawns of functions that compute a value.)

# Examples

    let mut value_a = None;
    let mut value_b = None;
    let mut value_c = None;
    rayon::scope(|s| {
        s.spawn(|s1| {
              // ^ this is the same scope as `s`; this handle `s1`
              //   is intended for use by the spawned task,
              //   since scope handles cannot cross thread boundaries.

            value_a = Some(22);

            // the scope `s` will not end until all these tasks are done
            s1.spawn(|_| {
                value_b = Some(44);
            });
        });

        s.spawn(|_| {
            value_c = Some(66);
        });
    });
    assert_eq!(value_a, Some(22));
    assert_eq!(value_b, Some(44));
    assert_eq!(value_c, Some(66));

# See also

The `scope` function has more extensive documentation about task spawning.

## Trait Implementations

### `impl<'scope> Debug for Scope<'scope>`[src]

#### `fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl<'scope> Send for Scope<'scope>`

### `impl<'scope> Unpin for Scope<'scope>`

### `impl<'scope> Sync for Scope<'scope>`

### `impl<'scope> !UnwindSafe for Scope<'scope>`

### `impl<'scope> !RefUnwindSafe for Scope<'scope>`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

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