bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rollup merge of #20014: kballard/unsized-marker-type-params

Browse source 
Tweak CovariantType, ContravariantType, and InvariantType to allow their
type parameter to be unsized.
This commit is contained in:
Alex Crichton 2014-12-21 00:04:09 -08:00
commit de7abcf6d3
1 changed files with 20 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/libcore/kinds.rs
View file

@ -91,7 +91,8 @@ pub trait Sync for Sized? {
/// implemented using unsafe code. In that case, you may want to embed /// implemented using unsafe code. In that case, you may want to embed
/// some of the marker types below into your type. /// some of the marker types below into your type.
pub mod marker { pub mod marker {
use super::Copy; use super::{Copy,Sized};
use clone::Clone;
/// A marker type whose type parameter `T` is considered to be /// A marker type whose type parameter `T` is considered to be
/// covariant with respect to the type itself. This is (typically) /// covariant with respect to the type itself. This is (typically)
@ -131,10 +132,13 @@ pub mod marker {
/// (for example, `S<&'static int>` is a subtype of `S<&'a int>` /// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
/// for some lifetime `'a`, but not the other way around). /// for some lifetime `'a`, but not the other way around).
#[lang="covariant_type"] #[lang="covariant_type"]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)] #[deriving(PartialEq, Eq, PartialOrd, Ord)]
pub struct CovariantType<T>; pub struct CovariantType<Sized? T>;
impl<T> Copy for CovariantType<T> {} impl<Sized? T> Copy for CovariantType<T> {}
impl<Sized? T> Clone for CovariantType<T> {
fn clone(&self) -> CovariantType<T> { *self }
}
/// A marker type whose type parameter `T` is considered to be /// A marker type whose type parameter `T` is considered to be
/// contravariant with respect to the type itself. This is (typically) /// contravariant with respect to the type itself. This is (typically)
@ -176,10 +180,13 @@ pub mod marker {
/// function requires arguments of type `T`, it must also accept /// function requires arguments of type `T`, it must also accept
/// arguments of type `U`, hence such a conversion is safe. /// arguments of type `U`, hence such a conversion is safe.
#[lang="contravariant_type"] #[lang="contravariant_type"]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)] #[deriving(PartialEq, Eq, PartialOrd, Ord)]
pub struct ContravariantType<T>; pub struct ContravariantType<Sized? T>;
impl<T> Copy for ContravariantType<T> {} impl<Sized? T> Copy for ContravariantType<T> {}
impl<Sized? T> Clone for ContravariantType<T> {
fn clone(&self) -> ContravariantType<T> { *self }
}
/// A marker type whose type parameter `T` is considered to be /// A marker type whose type parameter `T` is considered to be
/// invariant with respect to the type itself. This is (typically) /// invariant with respect to the type itself. This is (typically)
@ -203,10 +210,13 @@ pub mod marker {
/// never written, but in fact `Cell` uses unsafe code to achieve /// never written, but in fact `Cell` uses unsafe code to achieve
/// interior mutability. /// interior mutability.
#[lang="invariant_type"] #[lang="invariant_type"]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)] #[deriving(PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantType<T>; pub struct InvariantType<Sized? T>;
impl<T> Copy for InvariantType<T> {} impl<Sized? T> Copy for InvariantType<T> {}
impl<Sized? T> Clone for InvariantType<T> {
fn clone(&self) -> InvariantType<T> { *self }
}
/// As `CovariantType`, but for lifetime parameters. Using /// As `CovariantType`, but for lifetime parameters. Using
/// `CovariantLifetime<'a>` indicates that it is ok to substitute /// `CovariantLifetime<'a>` indicates that it is ok to substitute