src/libcore/marker.rs

   1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Primitive traits and marker types representing basic 'kinds' of types.
  12 //!
  13 //! Rust types can be classified in various useful ways according to
  14 //! intrinsic properties of the type. These classifications, often called
  15 //! 'kinds', are represented as traits.
  16
  17 #![stable(feature = "rust1", since = "1.0.0")]
  18
  19 use clone::Clone;
  20 use cmp;
  21 use option::Option;
  22 use hash::Hash;
  23 use hash::Hasher;
  24
  25 /// Types able to be transferred across thread boundaries.
  26 #[stable(feature = "rust1", since = "1.0.0")]
  27 #[lang = "send"]
  28 #[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
  29 pub unsafe trait Send {
  30     // empty.
  31 }
  32
  33 unsafe impl Send for .. { }
  34
  35 impl<T> !Send for *const T { }
  36 impl<T> !Send for *mut T { }
  37
  38 /// Types with a constant size known at compile-time.
  39 #[stable(feature = "rust1", since = "1.0.0")]
  40 #[lang = "sized"]
  41 #[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
  42 #[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
  43 pub trait Sized {
  44     // Empty.
  45 }
  46
  47 /// Types that can be "unsized" to a dynamically sized type.
  48 #[unstable(feature = "unsize", issue = "27732")]
  49 #[lang="unsize"]
  50 pub trait Unsize<T: ?Sized> {
  51     // Empty.
  52 }
  53
  54 /// Types that can be copied by simply copying bits (i.e. `memcpy`).
  55 ///
  56 /// By default, variable bindings have 'move semantics.' In other
  57 /// words:
  58 ///
  59 /// ```
  60 /// #[derive(Debug)]
  61 /// struct Foo;
  62 ///
  63 /// let x = Foo;
  64 ///
  65 /// let y = x;
  66 ///
  67 /// // `x` has moved into `y`, and so cannot be used
  68 ///
  69 /// // println!("{:?}", x); // error: use of moved value
  70 /// ```
  71 ///
  72 /// However, if a type implements `Copy`, it instead has 'copy semantics':
  73 ///
  74 /// ```
  75 /// // we can just derive a `Copy` implementation
  76 /// #[derive(Debug, Copy, Clone)]
  77 /// struct Foo;
  78 ///
  79 /// let x = Foo;
  80 ///
  81 /// let y = x;
  82 ///
  83 /// // `y` is a copy of `x`
  84 ///
  85 /// println!("{:?}", x); // A-OK!
  86 /// ```
  87 ///
  88 /// It's important to note that in these two examples, the only difference is if you are allowed to
  89 /// access `x` after the assignment: a move is also a bitwise copy under the hood.
  90 ///
  91 /// ## When can my type be `Copy`?
  92 ///
  93 /// A type can implement `Copy` if all of its components implement `Copy`. For example, this
  94 /// `struct` can be `Copy`:
  95 ///
  96 /// ```
  97 /// struct Point {
  98 ///    x: i32,
  99 ///    y: i32,
 100 /// }
 101 /// ```
 102 ///
 103 /// A `struct` can be `Copy`, and `i32` is `Copy`, so therefore, `Point` is eligible to be `Copy`.
 104 ///
 105 /// ```
 106 /// # struct Point;
 107 /// struct PointList {
 108 ///     points: Vec<Point>,
 109 /// }
 110 /// ```
 111 ///
 112 /// The `PointList` `struct` cannot implement `Copy`, because `Vec<T>` is not `Copy`. If we
 113 /// attempt to derive a `Copy` implementation, we'll get an error:
 114 ///
 115 /// ```text
 116 /// the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`
 117 /// ```
 118 ///
 119 /// ## How can I implement `Copy`?
 120 ///
 121 /// There are two ways to implement `Copy` on your type:
 122 ///
 123 /// ```
 124 /// #[derive(Copy, Clone)]
 125 /// struct MyStruct;
 126 /// ```
 127 ///
 128 /// and
 129 ///
 130 /// ```
 131 /// struct MyStruct;
 132 /// impl Copy for MyStruct {}
 133 /// impl Clone for MyStruct { fn clone(&self) -> MyStruct { *self } }
 134 /// ```
 135 ///
 136 /// There is a small difference between the two: the `derive` strategy will also place a `Copy`
 137 /// bound on type parameters, which isn't always desired.
 138 ///
 139 /// ## When can my type _not_ be `Copy`?
 140 ///
 141 /// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
 142 /// mutable reference, and copying `String` would result in two attempts to free the same buffer.
 143 ///
 144 /// Generalizing the latter case, any type implementing `Drop` can't be `Copy`, because it's
 145 /// managing some resource besides its own `size_of::<T>()` bytes.
 146 ///
 147 /// ## When should my type be `Copy`?
 148 ///
 149 /// Generally speaking, if your type _can_ implement `Copy`, it should. There's one important thing
 150 /// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
 151 /// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
 152 /// change: that second example would fail to compile if we made `Foo` non-`Copy`.
 153 #[stable(feature = "rust1", since = "1.0.0")]
 154 #[lang = "copy"]
 155 pub trait Copy : Clone {
 156     // Empty.
 157 }
 158
 159 /// Types that can be safely shared between threads when aliased.
 160 ///
 161 /// The precise definition is: a type `T` is `Sync` if `&T` is
 162 /// thread-safe. In other words, there is no possibility of data races
 163 /// when passing `&T` references between threads.
 164 ///
 165 /// As one would expect, primitive types like `u8` and `f64` are all
 166 /// `Sync`, and so are simple aggregate types containing them (like
 167 /// tuples, structs and enums). More instances of basic `Sync` types
 168 /// include "immutable" types like `&T` and those with simple
 169 /// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
 170 /// collection types. (Generic parameters need to be `Sync` for their
 171 /// container to be `Sync`.)
 172 ///
 173 /// A somewhat surprising consequence of the definition is `&mut T` is
 174 /// `Sync` (if `T` is `Sync`) even though it seems that it might
 175 /// provide unsynchronized mutation. The trick is a mutable reference
 176 /// stored in an aliasable reference (that is, `& &mut T`) becomes
 177 /// read-only, as if it were a `& &T`, hence there is no risk of a data
 178 /// race.
 179 ///
 180 /// Types that are not `Sync` are those that have "interior
 181 /// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
 182 /// in `std::cell`. These types allow for mutation of their contents
 183 /// even when in an immutable, aliasable slot, e.g. the contents of
 184 /// `&Cell<T>` can be `.set`, and do not ensure data races are
 185 /// impossible, hence they cannot be `Sync`. A higher level example
 186 /// of a non-`Sync` type is the reference counted pointer
 187 /// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
 188 /// reference, which modifies the reference counts in a non-atomic
 189 /// way.
 190 ///
 191 /// For cases when one does need thread-safe interior mutability,
 192 /// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
 193 /// the `sync` crate do ensure that any mutation cannot cause data
 194 /// races.  Hence these types are `Sync`.
 195 ///
 196 /// Any types with interior mutability must also use the `std::cell::UnsafeCell`
 197 /// wrapper around the value(s) which can be mutated when behind a `&`
 198 /// reference; not doing this is undefined behavior (for example,
 199 /// `transmute`-ing from `&T` to `&mut T` is invalid).
 200 #[stable(feature = "rust1", since = "1.0.0")]
 201 #[lang = "sync"]
 202 #[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
 203 pub unsafe trait Sync {
 204     // Empty
 205 }
 206
 207 unsafe impl Sync for .. { }
 208
 209 impl<T> !Sync for *const T { }
 210 impl<T> !Sync for *mut T { }
 211
 212 macro_rules! impls{
 213     ($t: ident) => (
 214         impl<T:?Sized> Hash for $t<T> {
 215             #[inline]
 216             fn hash<H: Hasher>(&self, _: &mut H) {
 217             }
 218         }
 219
 220         impl<T:?Sized> cmp::PartialEq for $t<T> {
 221             fn eq(&self, _other: &$t<T>) -> bool {
 222                 true
 223             }
 224         }
 225
 226         impl<T:?Sized> cmp::Eq for $t<T> {
 227         }
 228
 229         impl<T:?Sized> cmp::PartialOrd for $t<T> {
 230             fn partial_cmp(&self, _other: &$t<T>) -> Option<cmp::Ordering> {
 231                 Option::Some(cmp::Ordering::Equal)
 232             }
 233         }
 234
 235         impl<T:?Sized> cmp::Ord for $t<T> {
 236             fn cmp(&self, _other: &$t<T>) -> cmp::Ordering {
 237                 cmp::Ordering::Equal
 238             }
 239         }
 240
 241         impl<T:?Sized> Copy for $t<T> { }
 242
 243         impl<T:?Sized> Clone for $t<T> {
 244             fn clone(&self) -> $t<T> {
 245                 $t
 246             }
 247         }
 248         )
 249 }
 250
 251 /// `PhantomData<T>` allows you to describe that a type acts as if it stores a value of type `T`,
 252 /// even though it does not. This allows you to inform the compiler about certain safety properties
 253 /// of your code.
 254 ///
 255 /// # A ghastly note 👻👻👻
 256 ///
 257 /// Though they both have scary names, `PhantomData<T>` and 'phantom types' are related, but not
 258 /// identical. Phantom types are a more general concept that don't require `PhantomData<T>` to
 259 /// implement, but `PhantomData<T>` is the most common way to implement them in a correct manner.
 260 ///
 261 /// # Examples
 262 ///
 263 /// ## Unused lifetime parameter
 264 ///
 265 /// Perhaps the most common time that `PhantomData` is required is
 266 /// with a struct that has an unused lifetime parameter, typically as
 267 /// part of some unsafe code. For example, here is a struct `Slice`
 268 /// that has two pointers of type `*const T`, presumably pointing into
 269 /// an array somewhere:
 270 ///
 271 /// ```ignore
 272 /// struct Slice<'a, T> {
 273 ///     start: *const T,
 274 ///     end: *const T,
 275 /// }
 276 /// ```
 277 ///
 278 /// The intention is that the underlying data is only valid for the
 279 /// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
 280 /// intent is not expressed in the code, since there are no uses of
 281 /// the lifetime `'a` and hence it is not clear what data it applies
 282 /// to. We can correct this by telling the compiler to act *as if* the
 283 /// `Slice` struct contained a borrowed reference `&'a T`:
 284 ///
 285 /// ```
 286 /// use std::marker::PhantomData;
 287 ///
 288 /// struct Slice<'a, T:'a> {
 289 ///     start: *const T,
 290 ///     end: *const T,
 291 ///     phantom: PhantomData<&'a T>
 292 /// }
 293 /// ```
 294 ///
 295 /// This also in turn requires that we annotate `T:'a`, indicating
 296 /// that `T` is a type that can be borrowed for the lifetime `'a`.
 297 ///
 298 /// ## Unused type parameters
 299 ///
 300 /// It sometimes happens that there are unused type parameters that
 301 /// indicate what type of data a struct is "tied" to, even though that
 302 /// data is not actually found in the struct itself. Here is an
 303 /// example where this arises when handling external resources over a
 304 /// foreign function interface. `PhantomData<T>` can prevent
 305 /// mismatches by enforcing types in the method implementations:
 306 ///
 307 /// ```
 308 /// # trait ResType { fn foo(&self); }
 309 /// # struct ParamType;
 310 /// # mod foreign_lib {
 311 /// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
 312 /// # pub fn do_stuff(_: *mut (), _: usize) {}
 313 /// # }
 314 /// # fn convert_params(_: ParamType) -> usize { 42 }
 315 /// use std::marker::PhantomData;
 316 /// use std::mem;
 317 ///
 318 /// struct ExternalResource<R> {
 319 ///    resource_handle: *mut (),
 320 ///    resource_type: PhantomData<R>,
 321 /// }
 322 ///
 323 /// impl<R: ResType> ExternalResource<R> {
 324 ///     fn new() -> ExternalResource<R> {
 325 ///         let size_of_res = mem::size_of::<R>();
 326 ///         ExternalResource {
 327 ///             resource_handle: foreign_lib::new(size_of_res),
 328 ///             resource_type: PhantomData,
 329 ///         }
 330 ///     }
 331 ///
 332 ///     fn do_stuff(&self, param: ParamType) {
 333 ///         let foreign_params = convert_params(param);
 334 ///         foreign_lib::do_stuff(self.resource_handle, foreign_params);
 335 ///     }
 336 /// }
 337 /// ```
 338 ///
 339 /// ## Indicating ownership
 340 ///
 341 /// Adding a field of type `PhantomData<T>` also indicates that your
 342 /// struct owns data of type `T`. This in turn implies that when your
 343 /// struct is dropped, it may in turn drop one or more instances of
 344 /// the type `T`, though that may not be apparent from the other
 345 /// structure of the type itself. This is commonly necessary if the
 346 /// structure is using a raw pointer like `*mut T` whose referent
 347 /// may be dropped when the type is dropped, as a `*mut T` is
 348 /// otherwise not treated as owned.
 349 ///
 350 /// If your struct does not in fact *own* the data of type `T`, it is
 351 /// better to use a reference type, like `PhantomData<&'a T>`
 352 /// (ideally) or `PhantomData<*const T>` (if no lifetime applies), so
 353 /// as not to indicate ownership.
 354 #[lang = "phantom_data"]
 355 #[stable(feature = "rust1", since = "1.0.0")]
 356 pub struct PhantomData<T:?Sized>;
 357
 358 impls! { PhantomData }
 359
 360 mod impls {
 361     use super::{Send, Sync, Sized};
 362
 363     unsafe impl<'a, T: Sync + ?Sized> Send for &'a T {}
 364     unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {}
 365 }
 366
 367 /// A marker trait indicates a type that can be reflected over. This
 368 /// trait is implemented for all types. Its purpose is to ensure that
 369 /// when you write a generic function that will employ reflection,
 370 /// that must be reflected (no pun intended) in the generic bounds of
 371 /// that function. Here is an example:
 372 ///
 373 /// ```
 374 /// #![feature(reflect_marker)]
 375 /// use std::marker::Reflect;
 376 /// use std::any::Any;
 377 /// fn foo<T:Reflect+'static>(x: &T) {
 378 ///     let any: &Any = x;
 379 ///     if any.is::<u32>() { println!("u32"); }
 380 /// }
 381 /// ```
 382 ///
 383 /// Without the declaration `T:Reflect`, `foo` would not type check
 384 /// (note: as a matter of style, it would be preferable to write
 385 /// `T:Any`, because `T:Any` implies `T:Reflect` and `T:'static`, but
 386 /// we use `Reflect` here to show how it works). The `Reflect` bound
 387 /// thus serves to alert `foo`'s caller to the fact that `foo` may
 388 /// behave differently depending on whether `T=u32` or not. In
 389 /// particular, thanks to the `Reflect` bound, callers know that a
 390 /// function declared like `fn bar<T>(...)` will always act in
 391 /// precisely the same way no matter what type `T` is supplied,
 392 /// because there are no bounds declared on `T`. (The ability for a
 393 /// caller to reason about what a function may do based solely on what
 394 /// generic bounds are declared is often called the ["parametricity
 395 /// property"][1].)
 396 ///
 397 /// [1]: http://en.wikipedia.org/wiki/Parametricity
 398 #[rustc_reflect_like]
 399 #[unstable(feature = "reflect_marker",
 400            reason = "requires RFC and more experience",
 401            issue = "27749")]
 402 #[rustc_on_unimplemented = "`{Self}` does not implement `Any`; \
 403                             ensure all type parameters are bounded by `Any`"]
 404 pub trait Reflect {}
 405
 406 impl Reflect for .. { }