# Struct failure::SyncFailure [−] [src]

    pub struct SyncFailure<T> { /* fields omitted */ }

Wrapper for `std` errors to make them `Sync`.

This exists to coerce existing types that are only `Error + Send + 'static` into a `Fail`-compatible representation, most notably for types generated by `error-chain`.

Unfortunately, this requires wrapping the error in a `Mutex`, which must be locked for every `Debug`/`Display`. Therefore, this should be something of a last resort in making the error work with `failure`.

## Methods

### `impl<E: Error + Send + 'static> SyncFailure<E>`
[src]

#### `pub fn new(err: E) -> Self`
[src]

Wraps a non-`Sync` `Error` in order to make it implement `Fail`.

# Example

    extern crate failure;

    use failure::{Error, SyncFailure};
    use std::cell::RefCell;

    #[derive(Debug)]
    struct NonSyncError {
        // RefCells are non-Sync, so structs containing them will be
        // non-Sync as well.
        count: RefCell<usize>,
    }

    // implement Display/Error for NonSyncError...

    fn returns_error() -> Result<(), NonSyncError> {
        // Do stuff
    }

    fn my_function() -> Result<(), Error> {
        // without the map_err here, we end up with a compile error
        // complaining that NonSyncError doesn't implement Sync.
        returns_error().map_err(SyncFailure::new)?;
        // Do more stuff
    }

## Trait Implementations

### `impl<T> Display for SyncFailure<T> where
T: Display,`
[src]

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

Formats the value using the given formatter. Read more

### `impl<T> Debug for SyncFailure<T> where
T: Debug,`
[src]

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

Formats the value using the given formatter. Read more

### `impl<E: Error + Send + 'static> Fail for SyncFailure<E>`
[src]

#### `fn cause(&self) -> Option<&Fail>`
[src]

Returns a reference to the underlying cause of this failure, if it is an error that wraps other errors. Read more

#### `fn backtrace(&self) -> Option<&Backtrace>`
[src]

Returns a reference to the `Backtrace` carried by this failure, if it carries one. Read more

#### `fn context<D>(self, context: D) -> Context<D> where
D: Display + Send + Sync + 'static,
Self: Sized,`
[src]

Provides context for this failure. Read more

#### `fn compat(self) -> Compat<Self> where
Self: Sized,`
[src]

Wraps this failure in a compatibility wrapper that implements `std::error::Error`. Read more

####
ⓘImportant traits for Causes<'f>

### Important traits for Causes<'f>

`impl<'f> Iterator for Causes<'f> type Item = &'f Fail;`
`fn causes(&self) -> Causes where
Self: Sized,`
[src]

Returns a iterator over the causes of this `Fail` with itself as the first item and the `root_cause` as the final item. Read more

#### `fn root_cause(&self) -> &Fail where
Self: Sized,`
[src]

Returns the "root cause" of this `Fail` - the last value in the cause chain which does not return an underlying `cause`. 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`)