markers -> marker

Author: nrc

src/liballoc/arc.rs

@@ -74,7 +74,7 @@ use core::clone::Clone;
 use core::fmt::{self, Show};
 use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering};
 use core::default::Default;
-use core::markers::{Sync, Send};
+use core::marker::{Sync, Send};
 use core::mem::{min_align_of, size_of, drop};
 use core::mem;
 use core::nonzero::NonZero;

src/liballoc/boxed.rs

@@ -18,7 +18,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::markers::Sized;
+use core::marker::Sized;
 use core::mem;
 use core::option::Option;
 use core::ptr::Unique;

src/liballoc/rc.rs

@@ -148,7 +148,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::markers;
+use core::marker;
 use core::mem::{transmute, min_align_of, size_of, forget};
 use core::nonzero::NonZero;
 use core::ops::{Deref, Drop};
@@ -175,8 +175,8 @@ pub struct Rc<T> {
     // FIXME #12808: strange names to try to avoid interfering with field accesses of the contained
     // type via Deref
     _ptr: NonZero<*mut RcBox<T>>,
-    _nosend: markers::NoSend,
-    _noshare: markers::NoSync
+    _nosend: marker::NoSend,
+    _noshare: marker::NoSync
 }
 
 impl<T> Rc<T> {
@@ -201,8 +201,8 @@ impl<T> Rc<T> {
                     strong: Cell::new(1),
                     weak: Cell::new(1)
                 })),
-                _nosend: markers::NoSend,
-                _noshare: markers::NoSync
+                _nosend: marker::NoSend,
+                _noshare: marker::NoSync
             }
         }
     }
@@ -223,8 +223,8 @@ impl<T> Rc<T> {
         self.inc_weak();
         Weak {
             _ptr: self._ptr,
-            _nosend: markers::NoSend,
-            _noshare: markers::NoSync
+            _nosend: marker::NoSend,
+            _noshare: marker::NoSync
         }
     }
 }
@@ -431,7 +431,7 @@ impl<T> Clone for Rc<T> {
     #[inline]
     fn clone(&self) -> Rc<T> {
         self.inc_strong();
-        Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync }
+        Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync }
     }
 }
 
@@ -622,8 +622,8 @@ pub struct Weak<T> {
     // FIXME #12808: strange names to try to avoid interfering with
     // field accesses of the contained type via Deref
     _ptr: NonZero<*mut RcBox<T>>,
-    _nosend: markers::NoSend,
-    _noshare: markers::NoSync
+    _nosend: marker::NoSend,
+    _noshare: marker::NoSync
 }
 
 #[experimental = "Weak pointers may not belong in this module."]
@@ -650,7 +650,7 @@ impl<T> Weak<T> {
             None
         } else {
             self.inc_strong();
-            Some(Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync })
+            Some(Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync })
         }
     }
 }
@@ -717,7 +717,7 @@ impl<T> Clone for Weak<T> {
     #[inline]
     fn clone(&self) -> Weak<T> {
         self.inc_weak();
-        Weak { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync }
+        Weak { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync }
     }
 }
 

src/libcollections/btree/map.rs

@@ -480,7 +480,7 @@ enum Continuation<A, B> {
 /// boilerplate gets cut out.
 mod stack {
     use core::prelude::*;
-    use core::markers;
+    use core::marker;
     use core::mem;
     use core::ops::{Deref, DerefMut};
     use super::BTreeMap;
@@ -494,7 +494,7 @@ mod stack {
     /// where `&'static` can be used in any function expecting any lifetime reference.
     pub struct IdRef<'id, T: 'id> {
         inner: &'id mut T,
-        marker: markers::InvariantLifetime<'id>
+        marker: marker::InvariantLifetime<'id>
     }
 
     impl<'id, T> Deref for IdRef<'id, T> {
@@ -536,7 +536,7 @@ mod stack {
     pub struct Pusher<'id, 'a, K:'a, V:'a> {
         map: &'a mut BTreeMap<K, V>,
         stack: Stack<K, V>,
-        marker: markers::InvariantLifetime<'id>
+        marker: marker::InvariantLifetime<'id>
     }
 
     impl<'a, K, V> PartialSearchStack<'a, K, V> {
@@ -571,11 +571,11 @@ mod stack {
             let pusher = Pusher {
                 map: self.map,
                 stack: self.stack,
-                marker: markers::InvariantLifetime
+                marker: marker::InvariantLifetime
             };
             let node = IdRef {
                 inner: unsafe { &mut *self.next },
-                marker: markers::InvariantLifetime
+                marker: marker::InvariantLifetime
             };
 
             closure(pusher, node)

src/libcollections/lib.rs

@@ -124,8 +124,8 @@ mod std {
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
     #[cfg(stage0)]
-    pub use core::markers as kinds;
-    pub use core::markers;  // deriving(Copy)
+    pub use core::marker as kinds;
+    pub use core::marker;  // deriving(Copy)
     pub use core::hash;     // deriving(Hash)
 }
 
@@ -140,7 +140,7 @@ mod prelude {
     pub use core::iter::{FromIterator, Extend, IteratorExt};
     pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator};
     pub use core::iter::{ExactSizeIterator};
-    pub use core::markers::{Copy, Send, Sized, Sync};
+    pub use core::marker::{Copy, Send, Sized, Sync};
     pub use core::mem::drop;
     pub use core::ops::{Drop, Fn, FnMut, FnOnce};
     pub use core::option::Option;

src/libcollections/ring_buf.rs

@@ -20,7 +20,7 @@ use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
 use core::iter::{self, repeat, FromIterator, RandomAccessIterator};
-use core::markers;
+use core::marker;
 use core::mem;
 use core::num::{Int, UnsignedInt};
 use core::ops::{Index, IndexMut};
@@ -534,7 +534,7 @@ impl<T> RingBuf<T> {
             head: self.head,
             cap: self.cap,
             ptr: self.ptr,
-            marker: markers::ContravariantLifetime::<'a>,
+            marker: marker::ContravariantLifetime::<'a>,
         }
     }
 
@@ -1414,7 +1414,7 @@ pub struct IterMut<'a, T:'a> {
     tail: uint,
     head: uint,
     cap: uint,
-    marker: markers::ContravariantLifetime<'a>,
+    marker: marker::ContravariantLifetime<'a>,
 }
 
 #[stable]

src/libcollections/slice.rs

@@ -95,7 +95,7 @@ use core::cmp::Ordering::{self, Greater, Less};
 use core::cmp::{self, Ord, PartialEq};
 use core::iter::{Iterator, IteratorExt};
 use core::iter::{range, range_step, MultiplicativeIterator};
-use core::markers::Sized;
+use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
 use core::ops::{FnMut, SliceMut};

src/libcollections/vec.rs

@@ -55,7 +55,7 @@ use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
 use core::iter::{repeat, FromIterator};
-use core::markers::{ContravariantLifetime, InvariantType};
+use core::marker::{ContravariantLifetime, InvariantType};
 use core::mem;
 use core::nonzero::NonZero;
 use core::num::{Int, UnsignedInt};

src/libcore/array.rs

@@ -17,7 +17,7 @@
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use fmt;
-use markers::Copy;
+use marker::Copy;
 use ops::Deref;
 use option::Option;
 

src/libcore/atomic.rs

@@ -72,7 +72,7 @@
 
 use self::Ordering::*;
 
-use markers::Sync;
+use marker::Sync;
 
 use intrinsics;
 use cell::UnsafeCell;

src/libcore/borrow.rs

@@ -47,7 +47,7 @@
 use clone::Clone;
 use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
 use fmt;
-use markers::Sized;
+use marker::Sized;
 use ops::Deref;
 use option::Option;
 use self::Cow::*;

src/libcore/cell.rs

@@ -161,7 +161,7 @@ use clone::Clone;
 use cmp::PartialEq;
 use default::Default;
 use fmt;
-use markers::{Copy, Send};
+use marker::{Copy, Send};
 use ops::{Deref, DerefMut, Drop};
 use option::Option;
 use option::Option::{None, Some};
@@ -520,11 +520,11 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
 ///
 /// ```rust
 /// use std::cell::UnsafeCell;
-/// use std::markers;
+/// use std::marker;
 ///
 /// struct NotThreadSafe<T> {
 ///     value: UnsafeCell<T>,
-///     marker: markers::NoSync
+///     marker: marker::NoSync
 /// }
 /// ```
 ///

src/libcore/clone.rs

@@ -21,7 +21,7 @@
 
 #![stable]
 
-use markers::Sized;
+use marker::Sized;
 
 /// A common trait for cloning an object.
 #[stable]

src/libcore/cmp.rs

@@ -43,7 +43,7 @@
 
 use self::Ordering::*;
 
-use markers::Sized;
+use marker::Sized;
 use option::Option::{self, Some, None};
 
 /// Trait for equality comparisons which are [partial equivalence relations](
@@ -316,7 +316,7 @@ pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 mod impls {
     use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering};
     use cmp::Ordering::{Less, Greater, Equal};
-    use markers::Sized;
+    use marker::Sized;
     use option::Option;
     use option::Option::{Some, None};
 

src/libcore/fmt/mod.rs

@@ -15,7 +15,7 @@
 use any;
 use cell::{Cell, Ref, RefMut};
 use iter::{Iterator, IteratorExt, range};
-use markers::{Copy, Sized};
+use marker::{Copy, Sized};
 use mem;
 use option::Option;
 use option::Option::{Some, None};

src/libcore/iter.rs

@@ -67,7 +67,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use std::markers::Sized;
+use std::marker::Sized;
 use uint;
 
 /// An interface for dealing with "external iterators". These types of iterators

src/libcore/lib.rs

@@ -111,7 +111,7 @@ pub mod ptr;
 
 /* Core language traits */
 
-pub mod markers;
+pub mod marker;
 pub mod ops;
 pub mod cmp;
 pub mod clone;
@@ -151,8 +151,8 @@ mod std {
     pub use clone;
     pub use cmp;
     #[cfg(stage0)]
-    pub use markers as kinds;
-    pub use markers;
+    pub use marker as kinds;
+    pub use marker;
     pub use option;
     pub use fmt;
     pub use hash;

src/libcore/markers.rs renamed to src/libcore/marker.rs

@@ -87,7 +87,7 @@ pub trait Copy {
 ///
 /// Users writing their own types with interior mutability (or anything
 /// else that is not thread-safe) should use the `NoSync` marker type
-/// (from `std::markers`) to ensure that the compiler doesn't
+/// (from `std::marker`) to ensure that the compiler doesn't
 /// consider the user-defined type to be `Sync`.  Any types with
 /// interior mutability must also use the `std::cell::UnsafeCell` wrapper
 /// around the value(s) which can be mutated when behind a `&`
@@ -140,10 +140,10 @@ pub unsafe trait Sync {
 #[unstable = "likely to change with new variance strategy"]
 #[lang="covariant_type"]
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
-pub struct CovariantType<Sized? T>;
+pub struct CovariantType<T: ?Sized>;
 
-impl<Sized? T> Copy for CovariantType<T> {}
-impl<Sized? T> Clone for CovariantType<T> {
+impl<T: ?Sized> Copy for CovariantType<T> {}
+impl<T: ?Sized> Clone for CovariantType<T> {
     fn clone(&self) -> CovariantType<T> { *self }
 }
 

src/libcore/mem.rs

@@ -15,7 +15,7 @@
 
 #![stable]
 
-use markers::Sized;
+use marker::Sized;
 use intrinsics;
 use ptr;
 

src/libcore/num/mod.rs

@@ -21,7 +21,7 @@ use cmp::{PartialEq, Eq};
 use cmp::{PartialOrd, Ord};
 use intrinsics;
 use iter::IteratorExt;
-use markers::Copy;
+use marker::Copy;
 use mem::size_of;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
@@ -992,7 +992,7 @@ impl_to_primitive_float! { f64 }
 
 /// A generic trait for converting a number to a value.
 #[experimental = "trait is likely to be removed"]
-pub trait FromPrimitive : ::markers::Sized {
+pub trait FromPrimitive : ::marker::Sized {
     /// Convert an `int` to return an optional value of this type. If the
     /// value cannot be represented by this value, the `None` is returned.
     #[inline]

src/libcore/ops.rs

@@ -63,7 +63,7 @@
 
 use clone::Clone;
 use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
-use markers::Sized;
+use marker::Sized;
 use option::Option::{self, Some, None};
 
 /// The `Drop` trait is used to run some code when a value goes out of scope. This

src/libcore/prelude.rs

@@ -29,7 +29,7 @@
 //! ```
 
 // Reexported core operators
-pub use markers::{Copy, Send, Sized, Sync};
+pub use marker::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions

src/libcore/ptr.rs

@@ -92,7 +92,7 @@ use mem;
 use clone::Clone;
 use intrinsics;
 use option::Option::{self, Some, None};
-use markers::{Send, Sized, Sync};
+use marker::{Send, Sized, Sync};
 
 use cmp::{PartialEq, Eq, Ord, PartialOrd};
 use cmp::Ordering::{self, Less, Equal, Greater};