# 1.0.0[−][src]Trait core::ops::Deref

    #[lang = "deref"]pub trait Deref {
        type Target: ?Sized;
    #[must_use]    fn deref(&self) -> &Self::Target;
    }

Used for immutable dereferencing operations, like `*v`.

In addition to being used for explicit dereferencing operations with the (unary) `*` operator in immutable contexts, `Deref` is also used implicitly by the compiler in many circumstances. This mechanism is called '`Deref` coercion'. In mutable contexts, `DerefMut` is used.

Implementing `Deref` for smart pointers makes accessing the data behind them convenient, which is why they implement `Deref`. On the other hand, the rules regarding `Deref` and `DerefMut` were designed specifically to accommodate smart pointers. Because of this, `Deref` should only be implemented for smart pointers to avoid confusion.

For similar reasons, this trait should never fail. Failure during dereferencing can be extremely confusing when `Deref` is invoked implicitly.

# More on `Deref` coercion

If `T` implements `Deref<Target = U>`, and `x` is a value of type `T`, then:

- In immutable contexts, `*x` (where `T` is neither a reference nor a raw pointer) is equivalent to `*Deref::deref(&x)`.
- Values of type `&T` are coerced to values of type `&U`
- `T` implicitly implements all the (immutable) methods of the type `U`.

For more details, visit the chapter in The Rust Programming Language as well as the reference sections on the dereference operator, method resolution and type coercions.

# Examples

A struct with a single field which is accessible by dereferencing the struct.

    use std::ops::Deref;

    struct DerefExample<T> {
        value: T
    }

    impl<T> Deref for DerefExample<T> {
        type Target = T;

        fn deref(&self) -> &Self::Target {
            &self.value
        }
    }

    let x = DerefExample { value: 'a' };
    assert_eq!('a', *x);

Run

## Associated Types

### `type Target: ?Sized`

The resulting type after dereferencing.

Loading content...

## Required methods

### `#[must_use]fn deref(&self) -> &Self::Target`

Dereferences the value.

Loading content...

## Implementors

### `impl<'_, T: ?Sized> Deref for &'_ T`[src]

#### `type Target = T`

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

### `impl<'_, T: ?Sized> Deref for &'_ mut T`[src]

#### `type Target = T`

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

### `impl<'_, T: ?Sized> Deref for Ref<'_, T>`[src]

#### `type Target = T`

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

### `impl<'_, T: ?Sized> Deref for RefMut<'_, T>`[src]

#### `type Target = T`

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

### `impl<'a, 'f: 'a> Deref for VaList<'a, 'f>`[src]

#### `type Target = VaListImpl<'f>`

#### `fn deref(&self) -> &VaListImpl<'f>`[src]

### `impl<P: Deref> Deref for Pin<P>`[src]

#### `type Target = P::Target`

#### `fn deref(&self) -> &P::Target`[src]

### `impl<T: ?Sized> Deref for ManuallyDrop<T>`[src]

#### `type Target = T`

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

Loading content...