2012-12-03 16:48:01 -08:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2016-03-04 17:37:11 -05:00
|
|
|
//! Overloadable operators.
|
2014-11-25 21:17:11 -05:00
|
|
|
//!
|
2016-08-15 15:34:02 -04:00
|
|
|
//! Implementing these traits allows you to overload certain operators.
|
2014-11-25 21:17:11 -05:00
|
|
|
//!
|
2015-01-16 08:31:01 +01:00
|
|
|
//! Some of these traits are imported by the prelude, so they are available in
|
2016-08-15 15:34:02 -04:00
|
|
|
//! every Rust program. Only operators backed by traits can be overloaded. For
|
2016-09-28 22:02:19 +02:00
|
|
|
//! example, the addition operator (`+`) can be overloaded through the [`Add`]
|
2016-08-15 15:34:02 -04:00
|
|
|
//! trait, but since the assignment operator (`=`) has no backing trait, there
|
|
|
|
//! is no way of overloading its semantics. Additionally, this module does not
|
|
|
|
//! provide any mechanism to create new operators. If traitless overloading or
|
|
|
|
//! custom operators are required, you should look toward macros or compiler
|
|
|
|
//! plugins to extend Rust's syntax.
|
2014-11-25 21:17:11 -05:00
|
|
|
//!
|
2016-08-25 15:29:19 -04:00
|
|
|
//! Note that the `&&` and `||` operators short-circuit, i.e. they only
|
|
|
|
//! evaluate their second operand if it contributes to the result. Since this
|
|
|
|
//! behavior is not enforceable by traits, `&&` and `||` are not supported as
|
|
|
|
//! overloadable operators.
|
|
|
|
//!
|
2015-01-16 08:31:01 +01:00
|
|
|
//! Many of the operators take their operands by value. In non-generic
|
|
|
|
//! contexts involving built-in types, this is usually not a problem.
|
|
|
|
//! However, using these operators in generic code, requires some
|
|
|
|
//! attention if values have to be reused as opposed to letting the operators
|
2017-03-12 14:04:52 -04:00
|
|
|
//! consume them. One option is to occasionally use [`clone`].
|
2015-01-16 08:31:01 +01:00
|
|
|
//! Another option is to rely on the types involved providing additional
|
|
|
|
//! operator implementations for references. For example, for a user-defined
|
|
|
|
//! type `T` which is supposed to support addition, it is probably a good
|
2016-09-28 22:02:19 +02:00
|
|
|
//! idea to have both `T` and `&T` implement the traits [`Add<T>`][`Add`] and
|
|
|
|
//! [`Add<&T>`][`Add`] so that generic code can be written without unnecessary
|
|
|
|
//! cloning.
|
2015-01-16 08:31:01 +01:00
|
|
|
//!
|
2015-03-11 21:11:40 -04:00
|
|
|
//! # Examples
|
2014-11-25 21:17:11 -05:00
|
|
|
//!
|
2016-09-28 22:02:19 +02:00
|
|
|
//! This example creates a `Point` struct that implements [`Add`] and [`Sub`],
|
|
|
|
//! and then demonstrates adding and subtracting two `Point`s.
|
2014-11-25 21:17:11 -05:00
|
|
|
//!
|
|
|
|
//! ```rust
|
2014-12-22 09:04:23 -08:00
|
|
|
//! use std::ops::{Add, Sub};
|
|
|
|
//!
|
2015-01-28 08:34:18 -05:00
|
|
|
//! #[derive(Debug)]
|
2014-11-25 21:17:11 -05:00
|
|
|
//! struct Point {
|
2015-02-15 10:22:43 -05:00
|
|
|
//! x: i32,
|
2016-01-04 22:37:06 +02:00
|
|
|
//! y: i32,
|
2014-11-25 21:17:11 -05:00
|
|
|
//! }
|
|
|
|
//!
|
2014-12-31 15:45:13 -05:00
|
|
|
//! impl Add for Point {
|
|
|
|
//! type Output = Point;
|
|
|
|
//!
|
2014-12-01 19:10:12 -05:00
|
|
|
//! fn add(self, other: Point) -> Point {
|
2014-11-25 21:17:11 -05:00
|
|
|
//! Point {x: self.x + other.x, y: self.y + other.y}
|
|
|
|
//! }
|
|
|
|
//! }
|
|
|
|
//!
|
2014-12-31 15:45:13 -05:00
|
|
|
//! impl Sub for Point {
|
|
|
|
//! type Output = Point;
|
|
|
|
//!
|
2014-12-01 19:10:12 -05:00
|
|
|
//! fn sub(self, other: Point) -> Point {
|
2014-11-25 21:17:11 -05:00
|
|
|
//! Point {x: self.x - other.x, y: self.y - other.y}
|
|
|
|
//! }
|
|
|
|
//! }
|
|
|
|
//! fn main() {
|
2015-01-06 16:16:35 -08:00
|
|
|
//! println!("{:?}", Point {x: 1, y: 0} + Point {x: 2, y: 3});
|
|
|
|
//! println!("{:?}", Point {x: 1, y: 0} - Point {x: 2, y: 3});
|
2014-11-25 21:17:11 -05:00
|
|
|
//! }
|
|
|
|
//! ```
|
|
|
|
//!
|
2016-08-16 04:11:48 -04:00
|
|
|
//! See the documentation for each trait for an example implementation.
|
2016-08-18 17:46:34 -04:00
|
|
|
//!
|
|
|
|
//! The [`Fn`], [`FnMut`], and [`FnOnce`] traits are implemented by types that can be
|
2016-09-28 22:02:19 +02:00
|
|
|
//! invoked like functions. Note that [`Fn`] takes `&self`, [`FnMut`] takes `&mut
|
|
|
|
//! self` and [`FnOnce`] takes `self`. These correspond to the three kinds of
|
2016-08-18 17:46:34 -04:00
|
|
|
//! methods that can be invoked on an instance: call-by-reference,
|
|
|
|
//! call-by-mutable-reference, and call-by-value. The most common use of these
|
|
|
|
//! traits is to act as bounds to higher-level functions that take functions or
|
|
|
|
//! closures as arguments.
|
|
|
|
//!
|
2016-09-28 22:02:19 +02:00
|
|
|
//! Taking a [`Fn`] as a parameter:
|
2016-08-18 17:46:34 -04:00
|
|
|
//!
|
|
|
|
//! ```rust
|
|
|
|
//! fn call_with_one<F>(func: F) -> usize
|
|
|
|
//! where F: Fn(usize) -> usize
|
|
|
|
//! {
|
|
|
|
//! func(1)
|
|
|
|
//! }
|
|
|
|
//!
|
|
|
|
//! let double = |x| x * 2;
|
|
|
|
//! assert_eq!(call_with_one(double), 2);
|
|
|
|
//! ```
|
|
|
|
//!
|
2016-09-28 22:02:19 +02:00
|
|
|
//! Taking a [`FnMut`] as a parameter:
|
2016-08-18 17:46:34 -04:00
|
|
|
//!
|
|
|
|
//! ```rust
|
|
|
|
//! fn do_twice<F>(mut func: F)
|
|
|
|
//! where F: FnMut()
|
|
|
|
//! {
|
|
|
|
//! func();
|
|
|
|
//! func();
|
|
|
|
//! }
|
|
|
|
//!
|
|
|
|
//! let mut x: usize = 1;
|
|
|
|
//! {
|
|
|
|
//! let add_two_to_x = || x += 2;
|
|
|
|
//! do_twice(add_two_to_x);
|
|
|
|
//! }
|
|
|
|
//!
|
|
|
|
//! assert_eq!(x, 5);
|
|
|
|
//! ```
|
|
|
|
//!
|
2016-09-28 22:02:19 +02:00
|
|
|
//! Taking a [`FnOnce`] as a parameter:
|
2016-08-18 17:46:34 -04:00
|
|
|
//!
|
|
|
|
//! ```rust
|
|
|
|
//! fn consume_with_relish<F>(func: F)
|
|
|
|
//! where F: FnOnce() -> String
|
|
|
|
//! {
|
|
|
|
//! // `func` consumes its captured variables, so it cannot be run more
|
|
|
|
//! // than once
|
|
|
|
//! println!("Consumed: {}", func());
|
|
|
|
//!
|
|
|
|
//! println!("Delicious!");
|
|
|
|
//!
|
|
|
|
//! // Attempting to invoke `func()` again will throw a `use of moved
|
|
|
|
//! // value` error for `func`
|
|
|
|
//! }
|
|
|
|
//!
|
|
|
|
//! let x = String::from("x");
|
|
|
|
//! let consume_and_return_x = move || x;
|
|
|
|
//! consume_with_relish(consume_and_return_x);
|
|
|
|
//!
|
|
|
|
//! // `consume_and_return_x` can no longer be invoked at this point
|
|
|
|
//! ```
|
2016-09-28 22:02:19 +02:00
|
|
|
//!
|
|
|
|
//! [`Fn`]: trait.Fn.html
|
|
|
|
//! [`FnMut`]: trait.FnMut.html
|
|
|
|
//! [`FnOnce`]: trait.FnOnce.html
|
|
|
|
//! [`Add`]: trait.Add.html
|
|
|
|
//! [`Sub`]: trait.Sub.html
|
2017-03-12 14:04:52 -04:00
|
|
|
//! [`clone`]: ../clone/trait.Clone.html#tymethod.clone
|
2013-09-26 05:54:48 -07:00
|
|
|
|
2015-01-23 21:48:20 -08:00
|
|
|
#![stable(feature = "rust1", since = "1.0.0")]
|
2015-01-04 15:42:51 -08:00
|
|
|
|
2017-06-07 22:04:46 -04:00
|
|
|
mod arith;
|
2017-06-07 22:08:14 -04:00
|
|
|
mod bit;
|
2017-06-07 22:13:31 -04:00
|
|
|
mod deref;
|
2017-06-07 21:59:57 -04:00
|
|
|
mod function;
|
2017-06-07 22:14:13 -04:00
|
|
|
mod index;
|
2017-06-07 22:10:21 -04:00
|
|
|
mod place;
|
2017-06-07 21:44:03 -04:00
|
|
|
mod range;
|
2017-06-07 22:12:18 -04:00
|
|
|
mod try;
|
2017-06-07 21:44:03 -04:00
|
|
|
|
2017-06-07 22:04:46 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::arith::{Add, Sub, Mul, Div, Rem, Neg};
|
|
|
|
#[stable(feature = "op_assign_traits", since = "1.8.0")]
|
|
|
|
pub use self::arith::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign};
|
|
|
|
|
2017-06-07 22:08:14 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::bit::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
|
|
|
|
#[stable(feature = "op_assign_traits", since = "1.8.0")]
|
|
|
|
pub use self::bit::{BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign};
|
|
|
|
|
2017-06-07 22:13:31 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::deref::{Deref, DerefMut};
|
|
|
|
|
2017-06-07 21:59:57 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::function::{Fn, FnMut, FnOnce};
|
|
|
|
|
2017-06-07 22:14:13 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::index::{Index, IndexMut};
|
|
|
|
|
2017-06-07 21:44:03 -04:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
|
|
|
|
|
|
|
|
#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
|
|
|
|
pub use self::range::{RangeInclusive, RangeToInclusive};
|
|
|
|
|
2017-06-07 22:12:18 -04:00
|
|
|
#[unstable(feature = "question_mark_carrier", issue = "31436")]
|
|
|
|
#[cfg(stage0)]
|
|
|
|
pub use self::try::Carrier;
|
|
|
|
#[unstable(feature = "try_trait", issue = "42327")]
|
|
|
|
pub use self::try::Try;
|
|
|
|
|
2017-06-07 22:10:21 -04:00
|
|
|
#[unstable(feature = "placement_new_protocol", issue = "27779")]
|
|
|
|
pub use self::place::{Place, Placer, InPlace, Boxed, BoxPlace};
|
|
|
|
|
2016-08-22 10:02:28 +00:00
|
|
|
use marker::Unsize;
|
2014-09-05 17:10:32 +12:00
|
|
|
|
2015-06-09 11:18:03 -07:00
|
|
|
/// The `Drop` trait is used to run some code when a value goes out of scope.
|
|
|
|
/// This is sometimes called a 'destructor'.
|
2014-11-24 20:06:06 -05:00
|
|
|
///
|
2017-05-22 15:59:00 -07:00
|
|
|
/// When a value goes out of scope, if it implements this trait, it will have
|
|
|
|
/// its `drop` method called. Then any fields the value contains will also
|
|
|
|
/// be dropped recursively.
|
|
|
|
///
|
2017-05-22 23:49:35 -07:00
|
|
|
/// Because of the recursive dropping, you do not need to implement this trait
|
|
|
|
/// unless your type needs its own destructor logic.
|
2017-05-22 15:06:25 -07:00
|
|
|
///
|
2015-03-11 21:11:40 -04:00
|
|
|
/// # Examples
|
2014-11-24 20:06:06 -05:00
|
|
|
///
|
2015-06-09 11:18:03 -07:00
|
|
|
/// A trivial implementation of `Drop`. The `drop` method is called when `_x`
|
|
|
|
/// goes out of scope, and therefore `main` prints `Dropping!`.
|
2014-11-24 20:06:06 -05:00
|
|
|
///
|
2015-03-12 22:42:38 -04:00
|
|
|
/// ```
|
2014-11-24 20:06:06 -05:00
|
|
|
/// struct HasDrop;
|
|
|
|
///
|
|
|
|
/// impl Drop for HasDrop {
|
2014-12-22 09:04:23 -08:00
|
|
|
/// fn drop(&mut self) {
|
|
|
|
/// println!("Dropping!");
|
|
|
|
/// }
|
2014-11-24 20:06:06 -05:00
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// fn main() {
|
2014-12-22 09:04:23 -08:00
|
|
|
/// let _x = HasDrop;
|
2014-11-24 20:06:06 -05:00
|
|
|
/// }
|
|
|
|
/// ```
|
2017-05-22 15:06:25 -07:00
|
|
|
///
|
|
|
|
/// Showing the recursive nature of `Drop`. When `outer` goes out of scope, the
|
2017-05-22 23:49:35 -07:00
|
|
|
/// `drop` method will be called first for `Outer`, then for `Inner`. Therefore
|
|
|
|
/// `main` prints `Dropping Outer!` and then `Dropping Inner!`.
|
2017-05-22 16:33:55 -07:00
|
|
|
///
|
2017-05-22 15:06:25 -07:00
|
|
|
/// ```
|
|
|
|
/// struct Inner;
|
|
|
|
/// struct Outer(Inner);
|
|
|
|
///
|
|
|
|
/// impl Drop for Inner {
|
|
|
|
/// fn drop(&mut self) {
|
|
|
|
/// println!("Dropping Inner!");
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// impl Drop for Outer {
|
|
|
|
/// fn drop(&mut self) {
|
|
|
|
/// println!("Dropping Outer!");
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// fn main() {
|
|
|
|
/// let _x = Outer(Inner);
|
|
|
|
/// }
|
|
|
|
/// ```
|
2017-05-22 15:15:04 -07:00
|
|
|
///
|
|
|
|
/// Because variables are dropped in the reverse order they are declared,
|
|
|
|
/// `main` will print `Declared second!` and then `Declared first!`.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct PrintOnDrop(&'static str);
|
2017-05-22 16:33:55 -07:00
|
|
|
///
|
2017-05-22 15:15:04 -07:00
|
|
|
/// fn main() {
|
|
|
|
/// let _first = PrintOnDrop("Declared first!");
|
|
|
|
/// let _second = PrintOnDrop("Declared second!");
|
|
|
|
/// }
|
|
|
|
/// ```
|
2015-05-09 14:50:28 -05:00
|
|
|
#[lang = "drop"]
|
2015-01-23 21:48:20 -08:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2012-11-05 17:50:01 -08:00
|
|
|
pub trait Drop {
|
2015-09-17 21:46:46 +02:00
|
|
|
/// A method called when the value goes out of scope.
|
2016-01-04 12:19:48 -05:00
|
|
|
///
|
|
|
|
/// When this method has been called, `self` has not yet been deallocated.
|
|
|
|
/// If it were, `self` would be a dangling reference.
|
|
|
|
///
|
|
|
|
/// After this function is over, the memory of `self` will be deallocated.
|
|
|
|
///
|
2016-08-16 04:33:59 -04:00
|
|
|
/// This function cannot be called explicitly. This is compiler error
|
2016-10-21 00:49:47 +01:00
|
|
|
/// [E0040]. However, the [`std::mem::drop`] function in the prelude can be
|
2016-08-16 04:33:59 -04:00
|
|
|
/// used to call the argument's `Drop` implementation.
|
|
|
|
///
|
2016-10-21 00:49:47 +01:00
|
|
|
/// [E0040]: ../../error-index.html#E0040
|
|
|
|
/// [`std::mem::drop`]: ../../std/mem/fn.drop.html
|
2016-08-16 04:33:59 -04:00
|
|
|
///
|
2016-01-04 12:19:48 -05:00
|
|
|
/// # Panics
|
|
|
|
///
|
|
|
|
/// Given that a `panic!` will call `drop()` as it unwinds, any `panic!` in
|
|
|
|
/// a `drop()` implementation will likely abort.
|
2015-01-23 21:48:20 -08:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2013-09-16 21:18:07 -04:00
|
|
|
fn drop(&mut self);
|
2012-11-05 17:50:01 -08:00
|
|
|
}
|
|
|
|
|
2015-04-15 11:57:29 +12:00
|
|
|
/// Trait that indicates that this is a pointer or a wrapper for one,
|
|
|
|
/// where unsizing can be performed on the pointee.
|
2017-01-03 22:29:15 -08:00
|
|
|
///
|
|
|
|
/// See the [DST coercion RfC][dst-coerce] and [the nomicon entry on coercion][nomicon-coerce]
|
|
|
|
/// for more details.
|
|
|
|
///
|
|
|
|
/// For builtin pointer types, pointers to `T` will coerce to pointers to `U` if `T: Unsize<U>`
|
|
|
|
/// by converting from a thin pointer to a fat pointer.
|
|
|
|
///
|
|
|
|
/// For custom types, the coercion here works by coercing `Foo<T>` to `Foo<U>`
|
|
|
|
/// provided an impl of `CoerceUnsized<Foo<U>> for Foo<T>` exists.
|
|
|
|
/// Such an impl can only be written if `Foo<T>` has only a single non-phantomdata
|
|
|
|
/// field involving `T`. If the type of that field is `Bar<T>`, an implementation
|
|
|
|
/// of `CoerceUnsized<Bar<U>> for Bar<T>` must exist. The coercion will work by
|
|
|
|
/// by coercing the `Bar<T>` field into `Bar<U>` and filling in the rest of the fields
|
|
|
|
/// from `Foo<T>` to create a `Foo<U>`. This will effectively drill down to a pointer
|
|
|
|
/// field and coerce that.
|
|
|
|
///
|
|
|
|
/// Generally, for smart pointers you will implement
|
|
|
|
/// `CoerceUnsized<Ptr<U>> for Ptr<T> where T: Unsize<U>, U: ?Sized`, with an
|
|
|
|
/// optional `?Sized` bound on `T` itself. For wrapper types that directly embed `T`
|
|
|
|
/// like `Cell<T>` and `RefCell<T>`, you
|
|
|
|
/// can directly implement `CoerceUnsized<Wrap<U>> for Wrap<T> where T: CoerceUnsized<U>`.
|
|
|
|
/// This will let coercions of types like `Cell<Box<T>>` work.
|
|
|
|
///
|
|
|
|
/// [`Unsize`][unsize] is used to mark types which can be coerced to DSTs if behind
|
|
|
|
/// pointers. It is implemented automatically by the compiler.
|
|
|
|
///
|
|
|
|
/// [dst-coerce]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
|
|
|
|
/// [unsize]: ../marker/trait.Unsize.html
|
|
|
|
/// [nomicon-coerce]: ../../nomicon/coercions.html
|
2015-08-12 17:23:48 -07:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
#[lang="coerce_unsized"]
|
|
|
|
pub trait CoerceUnsized<T> {
|
|
|
|
// Empty.
|
|
|
|
}
|
|
|
|
|
2015-05-12 14:41:08 +12:00
|
|
|
// &mut T -> &mut U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {}
|
2015-05-12 14:41:08 +12:00
|
|
|
// &mut T -> &U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, 'b: 'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {}
|
2015-05-12 14:41:08 +12:00
|
|
|
// &mut T -> *mut U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {}
|
2015-05-12 14:41:08 +12:00
|
|
|
// &mut T -> *const U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {}
|
|
|
|
|
2015-05-12 14:41:08 +12:00
|
|
|
// &T -> &U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, 'b: 'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
|
2015-05-12 14:41:08 +12:00
|
|
|
// &T -> *const U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<'a, T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a T {}
|
|
|
|
|
2015-05-12 14:41:08 +12:00
|
|
|
// *mut T -> *mut U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
|
2015-05-12 14:41:08 +12:00
|
|
|
// *mut T -> *const U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *mut T {}
|
|
|
|
|
2015-05-12 14:41:08 +12:00
|
|
|
// *const T -> *const U
|
2015-11-16 19:54:28 +03:00
|
|
|
#[unstable(feature = "coerce_unsized", issue = "27732")]
|
2015-04-15 11:57:29 +12:00
|
|
|
impl<T: ?Sized+Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
|