2015-01-05 19:03:46 -06:00
|
|
|
// Copyright 2012-2015 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.
|
|
|
|
|
|
|
|
//! Primitive traits and marker types representing basic 'kinds' of types.
|
|
|
|
//!
|
|
|
|
//! Rust types can be classified in various useful ways according to
|
|
|
|
//! intrinsic properties of the type. These classifications, often called
|
|
|
|
//! 'kinds', are represented as traits.
|
|
|
|
//!
|
|
|
|
//! They cannot be implemented by user code, but are instead implemented
|
|
|
|
//! by the compiler automatically for the types to which they apply.
|
|
|
|
//!
|
|
|
|
//! Marker types are special types that are used with unsafe code to
|
|
|
|
//! inform the compiler of special constraints. Marker types should
|
|
|
|
//! only be needed when you are creating an abstraction that is
|
|
|
|
//! implemented using unsafe code. In that case, you may want to embed
|
|
|
|
//! some of the marker types below into your type.
|
|
|
|
|
2015-01-23 23:48:20 -06:00
|
|
|
#![stable(feature = "rust1", since = "1.0.0")]
|
2015-01-05 19:03:46 -06:00
|
|
|
|
|
|
|
use clone::Clone;
|
2015-02-12 04:16:02 -06:00
|
|
|
use cmp;
|
|
|
|
use option::Option;
|
|
|
|
use hash::Hash;
|
|
|
|
use hash::Hasher;
|
2015-01-05 19:03:46 -06:00
|
|
|
|
2015-02-12 22:15:05 -06:00
|
|
|
/// Types able to be transferred across thread boundaries.
|
2015-02-18 16:30:14 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-02-12 22:15:05 -06:00
|
|
|
#[lang="send"]
|
|
|
|
#[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub unsafe trait Send : MarkerTrait {
|
2015-02-12 22:15:05 -06:00
|
|
|
// empty.
|
|
|
|
}
|
2015-01-05 19:03:46 -06:00
|
|
|
|
2015-03-11 18:53:55 -05:00
|
|
|
unsafe impl Send for .. { }
|
2015-03-08 22:02:57 -05:00
|
|
|
|
2015-01-26 14:30:56 -06:00
|
|
|
impl<T> !Send for *const T { }
|
|
|
|
impl<T> !Send for *mut T { }
|
2015-01-26 16:10:24 -06:00
|
|
|
impl !Send for Managed { }
|
2015-01-26 14:30:56 -06:00
|
|
|
|
2015-01-05 19:03:46 -06:00
|
|
|
/// Types with a constant size known at compile-time.
|
2015-01-23 23:48:20 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-01-05 19:03:46 -06:00
|
|
|
#[lang="sized"]
|
2015-01-20 16:04:17 -06:00
|
|
|
#[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub trait Sized : MarkerTrait {
|
2015-01-05 19:03:46 -06:00
|
|
|
// Empty.
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Types that can be copied by simply copying bits (i.e. `memcpy`).
|
2015-01-16 15:21:06 -06:00
|
|
|
///
|
|
|
|
/// By default, variable bindings have 'move semantics.' In other
|
|
|
|
/// words:
|
|
|
|
///
|
|
|
|
/// ```
|
2015-01-28 07:34:18 -06:00
|
|
|
/// #[derive(Debug)]
|
2015-01-16 15:21:06 -06:00
|
|
|
/// struct Foo;
|
|
|
|
///
|
|
|
|
/// let x = Foo;
|
|
|
|
///
|
|
|
|
/// let y = x;
|
|
|
|
///
|
|
|
|
/// // `x` has moved into `y`, and so cannot be used
|
|
|
|
///
|
|
|
|
/// // println!("{:?}", x); // error: use of moved value
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// However, if a type implements `Copy`, it instead has 'copy semantics':
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// // we can just derive a `Copy` implementation
|
2015-01-28 07:34:18 -06:00
|
|
|
/// #[derive(Debug, Copy)]
|
2015-01-16 15:21:06 -06:00
|
|
|
/// struct Foo;
|
|
|
|
///
|
|
|
|
/// let x = Foo;
|
|
|
|
///
|
|
|
|
/// let y = x;
|
|
|
|
///
|
|
|
|
/// // `y` is a copy of `x`
|
|
|
|
///
|
|
|
|
/// println!("{:?}", x); // A-OK!
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// It's important to note that in these two examples, the only difference is if you are allowed to
|
|
|
|
/// access `x` after the assignment: a move is also a bitwise copy under the hood.
|
|
|
|
///
|
|
|
|
/// ## When can my type be `Copy`?
|
|
|
|
///
|
|
|
|
/// A type can implement `Copy` if all of its components implement `Copy`. For example, this
|
|
|
|
/// `struct` can be `Copy`:
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct Point {
|
|
|
|
/// x: i32,
|
|
|
|
/// y: i32,
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// A `struct` can be `Copy`, and `i32` is `Copy`, so therefore, `Point` is eligible to be `Copy`.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # struct Point;
|
|
|
|
/// struct PointList {
|
|
|
|
/// points: Vec<Point>,
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// The `PointList` `struct` cannot implement `Copy`, because `Vec<T>` is not `Copy`. If we
|
|
|
|
/// attempt to derive a `Copy` implementation, we'll get an error.
|
|
|
|
///
|
|
|
|
/// ```text
|
|
|
|
/// error: the trait `Copy` may not be implemented for this type; field `points` does not implement
|
|
|
|
/// `Copy`
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// ## How can I implement `Copy`?
|
|
|
|
///
|
|
|
|
/// There are two ways to implement `Copy` on your type:
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// #[derive(Copy)]
|
|
|
|
/// struct MyStruct;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// and
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct MyStruct;
|
|
|
|
/// impl Copy for MyStruct {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// There is a small difference between the two: the `derive` strategy will also place a `Copy`
|
|
|
|
/// bound on type parameters, which isn't always desired.
|
|
|
|
///
|
|
|
|
/// ## When can my type _not_ be `Copy`?
|
|
|
|
///
|
|
|
|
/// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
|
|
|
|
/// mutable reference, and copying `String` would result in two attempts to free the same buffer.
|
|
|
|
///
|
|
|
|
/// Generalizing the latter case, any type implementing `Drop` can't be `Copy`, because it's
|
|
|
|
/// managing some resource besides its own `size_of::<T>()` bytes.
|
|
|
|
///
|
|
|
|
/// ## When should my type be `Copy`?
|
|
|
|
///
|
|
|
|
/// Generally speaking, if your type _can_ implement `Copy`, it should. There's one important thing
|
|
|
|
/// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
|
|
|
|
/// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
|
|
|
|
/// change: that second example would fail to compile if we made `Foo` non-`Copy`.
|
2015-01-23 23:48:20 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-01-05 19:03:46 -06:00
|
|
|
#[lang="copy"]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub trait Copy : MarkerTrait {
|
2015-01-05 19:03:46 -06:00
|
|
|
// Empty.
|
|
|
|
}
|
|
|
|
|
2015-01-22 03:22:16 -06:00
|
|
|
/// Types that can be safely shared between threads when aliased.
|
2015-01-05 19:03:46 -06:00
|
|
|
///
|
|
|
|
/// The precise definition is: a type `T` is `Sync` if `&T` is
|
|
|
|
/// thread-safe. In other words, there is no possibility of data races
|
2015-01-22 03:22:16 -06:00
|
|
|
/// when passing `&T` references between threads.
|
2015-01-05 19:03:46 -06:00
|
|
|
///
|
|
|
|
/// As one would expect, primitive types like `u8` and `f64` are all
|
|
|
|
/// `Sync`, and so are simple aggregate types containing them (like
|
|
|
|
/// tuples, structs and enums). More instances of basic `Sync` types
|
|
|
|
/// include "immutable" types like `&T` and those with simple
|
|
|
|
/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
|
|
|
|
/// collection types. (Generic parameters need to be `Sync` for their
|
|
|
|
/// container to be `Sync`.)
|
|
|
|
///
|
|
|
|
/// A somewhat surprising consequence of the definition is `&mut T` is
|
|
|
|
/// `Sync` (if `T` is `Sync`) even though it seems that it might
|
|
|
|
/// provide unsynchronised mutation. The trick is a mutable reference
|
|
|
|
/// stored in an aliasable reference (that is, `& &mut T`) becomes
|
|
|
|
/// read-only, as if it were a `& &T`, hence there is no risk of a data
|
|
|
|
/// race.
|
|
|
|
///
|
|
|
|
/// Types that are not `Sync` are those that have "interior
|
|
|
|
/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
|
|
|
|
/// in `std::cell`. These types allow for mutation of their contents
|
|
|
|
/// even when in an immutable, aliasable slot, e.g. the contents of
|
|
|
|
/// `&Cell<T>` can be `.set`, and do not ensure data races are
|
|
|
|
/// impossible, hence they cannot be `Sync`. A higher level example
|
|
|
|
/// of a non-`Sync` type is the reference counted pointer
|
|
|
|
/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
|
|
|
|
/// reference, which modifies the reference counts in a non-atomic
|
|
|
|
/// way.
|
|
|
|
///
|
|
|
|
/// For cases when one does need thread-safe interior mutability,
|
|
|
|
/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
|
|
|
|
/// the `sync` crate do ensure that any mutation cannot cause data
|
|
|
|
/// races. Hence these types are `Sync`.
|
|
|
|
///
|
2015-03-08 08:32:18 -05:00
|
|
|
/// Any types with interior mutability must also use the `std::cell::UnsafeCell` wrapper around the
|
|
|
|
/// value(s) which can be mutated when behind a `&` reference; not doing this is undefined
|
|
|
|
/// behaviour (for example, `transmute`-ing from `&T` to `&mut T` is illegal).
|
2015-02-18 16:30:14 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-01-05 19:03:46 -06:00
|
|
|
#[lang="sync"]
|
2015-01-20 16:04:17 -06:00
|
|
|
#[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub unsafe trait Sync : MarkerTrait {
|
2015-01-05 19:03:46 -06:00
|
|
|
// Empty
|
|
|
|
}
|
|
|
|
|
2015-03-11 18:53:55 -05:00
|
|
|
unsafe impl Sync for .. { }
|
2015-03-08 22:02:57 -05:00
|
|
|
|
2015-01-26 14:30:56 -06:00
|
|
|
impl<T> !Sync for *const T { }
|
|
|
|
impl<T> !Sync for *mut T { }
|
2015-01-26 16:10:24 -06:00
|
|
|
impl !Sync for Managed { }
|
2015-01-26 14:30:56 -06:00
|
|
|
|
2015-01-05 19:03:46 -06:00
|
|
|
/// A type which is considered "not POD", meaning that it is not
|
|
|
|
/// implicitly copyable. This is typically embedded in other types to
|
|
|
|
/// ensure that they are never copied, even if they lack a destructor.
|
2015-01-22 20:22:03 -06:00
|
|
|
#[unstable(feature = "core",
|
2015-01-12 20:40:19 -06:00
|
|
|
reason = "likely to change with new variance strategy")]
|
2015-01-05 19:03:46 -06:00
|
|
|
#[lang="no_copy_bound"]
|
|
|
|
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
|
|
pub struct NoCopy;
|
|
|
|
|
|
|
|
/// A type which is considered managed by the GC. This is typically
|
|
|
|
/// embedded in other types.
|
2015-01-22 20:22:03 -06:00
|
|
|
#[unstable(feature = "core",
|
2015-01-12 20:40:19 -06:00
|
|
|
reason = "likely to change with new variance strategy")]
|
2015-01-05 19:03:46 -06:00
|
|
|
#[lang="managed_bound"]
|
|
|
|
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
|
|
pub struct Managed;
|
2015-02-13 07:07:48 -06:00
|
|
|
|
2015-02-12 04:16:02 -06:00
|
|
|
macro_rules! impls{
|
|
|
|
($t: ident) => (
|
2015-02-18 17:58:07 -06:00
|
|
|
impl<T:?Sized> Hash for $t<T> {
|
|
|
|
#[inline]
|
|
|
|
fn hash<H: Hasher>(&self, _: &mut H) {
|
|
|
|
}
|
|
|
|
}
|
2015-02-12 04:16:02 -06:00
|
|
|
|
|
|
|
impl<T:?Sized> cmp::PartialEq for $t<T> {
|
|
|
|
fn eq(&self, _other: &$t<T>) -> bool {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T:?Sized> cmp::Eq for $t<T> {
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T:?Sized> cmp::PartialOrd for $t<T> {
|
|
|
|
fn partial_cmp(&self, _other: &$t<T>) -> Option<cmp::Ordering> {
|
|
|
|
Option::Some(cmp::Ordering::Equal)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T:?Sized> cmp::Ord for $t<T> {
|
|
|
|
fn cmp(&self, _other: &$t<T>) -> cmp::Ordering {
|
|
|
|
cmp::Ordering::Equal
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T:?Sized> Copy for $t<T> { }
|
|
|
|
|
|
|
|
impl<T:?Sized> Clone for $t<T> {
|
|
|
|
fn clone(&self) -> $t<T> {
|
|
|
|
$t
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// `MarkerTrait` is intended to be used as the supertrait for traits
|
|
|
|
/// that don't have any methods but instead serve just to designate
|
|
|
|
/// categories of types. An example would be the `Send` trait, which
|
|
|
|
/// indicates types that are sendable: `Send` does not itself offer
|
|
|
|
/// any methods, but instead is used to gate access to data.
|
|
|
|
///
|
|
|
|
/// FIXME. Better documentation needed here!
|
2015-03-18 13:43:46 -05:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-02-25 11:21:15 -06:00
|
|
|
pub trait MarkerTrait : PhantomFn<Self,Self> { }
|
|
|
|
// ~~~~~ <-- FIXME(#22806)?
|
|
|
|
//
|
|
|
|
// Marker trait has been made invariant so as to avoid inf recursion,
|
|
|
|
// but we should ideally solve the underlying problem. That's a bit
|
|
|
|
// complicated.
|
|
|
|
|
2015-02-12 04:16:02 -06:00
|
|
|
impl<T:?Sized> MarkerTrait for T { }
|
|
|
|
|
2015-02-18 15:38:39 -06:00
|
|
|
/// `PhantomFn` is a marker trait for use with traits that contain
|
|
|
|
/// type or lifetime parameters that do not appear in any of their
|
|
|
|
/// methods. In that case, you can either remove those parameters, or
|
|
|
|
/// add a `PhantomFn` supertrait that reflects the signature of
|
|
|
|
/// methods that compiler should "pretend" exists. This most commonly
|
|
|
|
/// occurs for traits with no methods: in that particular case, you
|
|
|
|
/// can extend `MarkerTrait`, which is equivalent to
|
|
|
|
/// `PhantomFn<Self>`.
|
|
|
|
///
|
2015-03-11 20:11:40 -05:00
|
|
|
/// # Examples
|
2015-02-18 15:38:39 -06:00
|
|
|
///
|
|
|
|
/// As an example, consider a trait with no methods like `Even`, meant
|
|
|
|
/// to represent types that are "even":
|
|
|
|
///
|
2015-02-18 18:39:32 -06:00
|
|
|
/// ```rust,ignore
|
2015-02-18 15:38:39 -06:00
|
|
|
/// trait Even { }
|
|
|
|
/// ```
|
2015-02-12 04:16:02 -06:00
|
|
|
///
|
2015-02-18 15:38:39 -06:00
|
|
|
/// In this case, because the implicit parameter `Self` is unused, the
|
|
|
|
/// compiler will issue an error. The only purpose of this trait is to
|
|
|
|
/// categorize types (and hence instances of those types) as "even" or
|
|
|
|
/// not, so if we *were* going to have a method, it might look like:
|
|
|
|
///
|
2015-02-18 18:39:32 -06:00
|
|
|
/// ```rust,ignore
|
2015-02-18 15:38:39 -06:00
|
|
|
/// trait Even {
|
|
|
|
/// fn is_even(self) -> bool { true }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Therefore, we can model a method like this as follows:
|
|
|
|
///
|
2015-03-12 21:42:38 -05:00
|
|
|
/// ```
|
2015-02-18 18:39:32 -06:00
|
|
|
/// use std::marker::PhantomFn;
|
2015-02-18 15:38:39 -06:00
|
|
|
/// trait Even : PhantomFn<Self> { }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Another equivalent, but clearer, option would be to use
|
|
|
|
/// `MarkerTrait`:
|
|
|
|
///
|
2015-03-12 21:42:38 -05:00
|
|
|
/// ```
|
2015-03-13 17:28:35 -05:00
|
|
|
/// # #![feature(core)]
|
2015-02-18 15:38:39 -06:00
|
|
|
/// use std::marker::MarkerTrait;
|
|
|
|
/// trait Even : MarkerTrait { }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// # Parameters
|
|
|
|
///
|
|
|
|
/// - `A` represents the type of the method's argument. You can use a
|
|
|
|
/// tuple to represent "multiple" arguments. Any types appearing here
|
|
|
|
/// will be considered "contravariant".
|
|
|
|
/// - `R`, if supplied, represents the method's return type. This defaults
|
|
|
|
/// to `()` as it is rarely needed.
|
|
|
|
///
|
|
|
|
/// # Additional reading
|
|
|
|
///
|
|
|
|
/// More details and background can be found in [RFC 738][738].
|
|
|
|
///
|
|
|
|
/// [738]: https://github.com/rust-lang/rfcs/blob/master/text/0738-variance.md
|
2015-02-12 04:16:02 -06:00
|
|
|
#[lang="phantom_fn"]
|
2015-02-18 15:38:39 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub trait PhantomFn<A:?Sized,R:?Sized=()> { }
|
|
|
|
|
|
|
|
/// `PhantomData` is a way to tell the compiler about fake fields.
|
2015-02-18 15:38:39 -06:00
|
|
|
/// Phantom data is required whenever type parameters are not used.
|
2015-02-12 04:16:02 -06:00
|
|
|
/// The idea is that if the compiler encounters a `PhantomData<T>`
|
|
|
|
/// instance, it will behave *as if* an instance of the type `T` were
|
|
|
|
/// present for the purpose of various automatic analyses.
|
|
|
|
///
|
2015-03-01 22:14:45 -06:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// When handling external resources over a foreign function interface, `PhantomData<T>` can
|
|
|
|
/// prevent mismatches by enforcing types in the method implementations, although the struct
|
|
|
|
/// doesn't actually contain values of the resource type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # trait ResType { fn foo(&self); };
|
|
|
|
/// # struct ParamType;
|
|
|
|
/// # mod foreign_lib {
|
|
|
|
/// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
|
|
|
|
/// # pub fn do_stuff(_: *mut (), _: usize) {}
|
|
|
|
/// # }
|
|
|
|
/// # fn convert_params(_: ParamType) -> usize { 42 }
|
|
|
|
/// use std::marker::PhantomData;
|
|
|
|
/// use std::mem;
|
|
|
|
///
|
|
|
|
/// struct ExternalResource<R> {
|
|
|
|
/// resource_handle: *mut (),
|
|
|
|
/// resource_type: PhantomData<R>,
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// impl<R: ResType> ExternalResource<R> {
|
|
|
|
/// fn new() -> ExternalResource<R> {
|
|
|
|
/// let size_of_res = mem::size_of::<R>();
|
|
|
|
/// ExternalResource {
|
|
|
|
/// resource_handle: foreign_lib::new(size_of_res),
|
|
|
|
/// resource_type: PhantomData,
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// fn do_stuff(&self, param: ParamType) {
|
|
|
|
/// let foreign_params = convert_params(param);
|
|
|
|
/// foreign_lib::do_stuff(self.resource_handle, foreign_params);
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Another example: embedding a `PhantomData<T>` will inform the compiler
|
2015-02-18 15:38:39 -06:00
|
|
|
/// that one or more instances of the type `T` could be dropped when
|
|
|
|
/// instances of the type itself is dropped, though that may not be
|
|
|
|
/// apparent from the other structure of the type itself. This is
|
|
|
|
/// commonly necessary if the structure is using an unsafe pointer
|
|
|
|
/// like `*mut T` whose referent may be dropped when the type is
|
|
|
|
/// dropped, as a `*mut T` is otherwise not treated as owned.
|
|
|
|
///
|
|
|
|
/// FIXME. Better documentation and examples of common patterns needed
|
|
|
|
/// here! For now, please see [RFC 738][738] for more information.
|
|
|
|
///
|
|
|
|
/// [738]: https://github.com/rust-lang/rfcs/blob/master/text/0738-variance.md
|
2015-02-12 04:16:02 -06:00
|
|
|
#[lang="phantom_data"]
|
2015-02-18 15:38:39 -06:00
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
2015-02-12 04:16:02 -06:00
|
|
|
pub struct PhantomData<T:?Sized>;
|
|
|
|
|
|
|
|
impls! { PhantomData }
|
|
|
|
|
2015-02-13 07:07:48 -06:00
|
|
|
mod impls {
|
|
|
|
use super::{Send, Sync, Sized};
|
|
|
|
|
|
|
|
unsafe impl<'a, T: Sync + ?Sized> Send for &'a T {}
|
|
|
|
unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {}
|
|
|
|
}
|
2015-02-18 16:14:27 -06:00
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<&'a ()>`")]
|
|
|
|
#[lang="contravariant_lifetime"]
|
|
|
|
pub struct ContravariantLifetime<'a>;
|
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<fn(&'a ())>`")]
|
|
|
|
#[lang="covariant_lifetime"]
|
|
|
|
pub struct CovariantLifetime<'a>;
|
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<Cell<&'a ()>>`")]
|
|
|
|
#[lang="invariant_lifetime"]
|
|
|
|
pub struct InvariantLifetime<'a>;
|
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<fn(T)>`")]
|
|
|
|
#[lang="contravariant_type"]
|
|
|
|
pub struct ContravariantType<T>;
|
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<T>`")]
|
|
|
|
#[lang="covariant_type"]
|
|
|
|
pub struct CovariantType<T>;
|
|
|
|
|
|
|
|
/// Old-style marker trait. Deprecated.
|
|
|
|
#[unstable(feature = "core", reason = "deprecated")]
|
|
|
|
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<Cell<T>>`")]
|
|
|
|
#[lang="invariant_type"]
|
|
|
|
pub struct InvariantType<T>;
|
2015-03-24 14:55:29 -05:00
|
|
|
|
|
|
|
/// A marker trait indicates a type that can be reflected over. This
|
|
|
|
/// trait is implemented for all types. Its purpose is to ensure that
|
|
|
|
/// when you write a generic function that will employ reflection,
|
|
|
|
/// that must be reflected (no pun intended) in the generic bounds of
|
|
|
|
/// that function. Here is an example:
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use std::marker::Reflect;
|
|
|
|
/// use std::any::Any;
|
|
|
|
/// fn foo<T:Reflect+'static>(x: &T) {
|
|
|
|
/// let any: &Any = x;
|
|
|
|
/// if any.is::<u32>() { println!("u32"); }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Without the declaration `T:Reflect`, `foo` would not type check
|
|
|
|
/// (note: as a matter of style, it would be preferable to to write
|
|
|
|
/// `T:Any`, because `T:Any` implies `T:Reflect` and `T:'static`, but
|
|
|
|
/// we use `Reflect` here to show how it works). The `Reflect` bound
|
|
|
|
/// thus serves to alert `foo`'s caller to the fact that `foo` may
|
|
|
|
/// behave differently depending on whether `T=u32` or not. In
|
|
|
|
/// particular, thanks to the `Reflect` bound, callers know that a
|
|
|
|
/// function declared like `fn bar<T>(...)` will always act in
|
|
|
|
/// precisely the same way no matter what type `T` is supplied,
|
|
|
|
/// beacuse there are no bounds declared on `T`. (The ability for a
|
|
|
|
/// caller to reason about what a function may do based solely on what
|
|
|
|
/// generic bounds are declared is often called the ["parametricity
|
|
|
|
/// property"][1].)
|
|
|
|
///
|
|
|
|
/// [1]: http://en.wikipedia.org/wiki/Parametricity
|
|
|
|
#[rustc_reflect_like]
|
|
|
|
#[unstable(feature = "core", reason = "requires RFC and more experience")]
|
|
|
|
pub trait Reflect : MarkerTrait {
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(stage0)]
|
|
|
|
impl<T> Reflect for T { }
|
|
|
|
|
|
|
|
#[cfg(not(stage0))]
|
|
|
|
impl Reflect for .. { }
|
|
|
|
|