bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Set unstable feature names appropriately

Browse source 
* `core` - for the core crate
* `hash` - hashing
* `io` - io
* `path` - path
* `alloc` - alloc crate
* `rand` - rand crate
* `collections` - collections crate
* `std_misc` - other parts of std
* `test` - test crate
* `rustc_private` - everything else
This commit is contained in:
Brian Anderson 2015-01-22 18:22:03 -08:00
parent f86bcc1543
commit cd6d9eab5d
148 changed files with 864 additions and 741 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/compiletest/compiletest.rs
View file

@ -13,7 +13,6 @@
#![feature(slicing_syntax, unboxed_closures)] #![feature(slicing_syntax, unboxed_closures)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(int_uint)] #![feature(int_uint)]
#![feature(unnamed_feature)]
#![deny(warnings)] #![deny(warnings)]

3
src/driver/driver.rs
View file

@ -9,7 +9,8 @@
// except according to those terms. // except according to those terms.
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(unnamed_feature)] #![cfg_attr(rustc, feature(rustc_private))]
#![cfg_attr(rustdoc, feature(rustdoc))]
#[cfg(rustdoc)] #[cfg(rustdoc)]
extern crate "rustdoc" as this; extern crate "rustdoc" as this;

14
src/liballoc/arc.rs
View file

@ -126,7 +126,7 @@ unsafe impl<T: Sync + Send> Sync for Arc<T> { }
/// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles /// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles
/// between `Arc` pointers. /// between `Arc` pointers.
#[unsafe_no_drop_flag] #[unsafe_no_drop_flag]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> { pub struct Weak<T> {
// FIXME #12808: strange name to try to avoid interfering with // FIXME #12808: strange name to try to avoid interfering with
@ -180,7 +180,7 @@ impl<T> Arc<T> {
/// ///
/// let weak_five = five.downgrade(); /// let weak_five = five.downgrade();
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
pub fn downgrade(&self) -> Weak<T> { pub fn downgrade(&self) -> Weak<T> {
// See the clone() impl for why this is relaxed // See the clone() impl for why this is relaxed
@ -202,12 +202,12 @@ impl<T> Arc<T> {
/// Get the number of weak references to this value. /// Get the number of weak references to this value.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 } pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 }
/// Get the number of strong references to this value. /// Get the number of strong references to this value.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) } pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) }
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -273,7 +273,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
/// let mut_five = five.make_unique(); /// let mut_five = five.make_unique();
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn make_unique(&mut self) -> &mut T { pub fn make_unique(&mut self) -> &mut T {
// Note that we hold a strong reference, which also counts as a weak reference, so we only // Note that we hold a strong reference, which also counts as a weak reference, so we only
// clone if there is an additional reference of either kind. // clone if there is an additional reference of either kind.
@ -357,7 +357,7 @@ impl<T: Sync + Send> Drop for Arc<T> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Weak<T> { impl<T: Sync + Send> Weak<T> {
/// Upgrades a weak reference to a strong reference. /// Upgrades a weak reference to a strong reference.
@ -396,7 +396,7 @@ impl<T: Sync + Send> Weak<T> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Clone for Weak<T> { impl<T: Sync + Send> Clone for Weak<T> {
/// Makes a clone of the `Weak<T>`. /// Makes a clone of the `Weak<T>`.

4
src/liballoc/boxed.rs
View file

@ -44,7 +44,7 @@ use core::ops::{Deref, DerefMut};
/// } /// }
/// ``` /// ```
#[lang = "exchange_heap"] #[lang = "exchange_heap"]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "may be renamed; uncertain about custom allocator design")] reason = "may be renamed; uncertain about custom allocator design")]
pub static HEAP: () = (); pub static HEAP: () = ();
@ -126,7 +126,7 @@ impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
} }
/// Extension methods for an owning `Any` trait object. /// Extension methods for an owning `Any` trait object.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "this trait will likely disappear once compiler bugs blocking \ reason = "this trait will likely disappear once compiler bugs blocking \
a direct impl on `Box<Any>` have been fixed ")] a direct impl on `Box<Any>` have been fixed ")]
// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're // FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're

2
src/liballoc/heap.rs
View file

@ -80,7 +80,7 @@ pub fn usable_size(size: uint, align: uint) -> uint {
/// ///
/// These statistics may be inconsistent if other threads use the allocator /// These statistics may be inconsistent if other threads use the allocator
/// during the call. /// during the call.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn stats_print() { pub fn stats_print() {
imp::stats_print(); imp::stats_print();
} }

6
src/liballoc/lib.rs
View file

@ -57,7 +57,7 @@
//! default global allocator. It is not compatible with the libc allocator API. //! default global allocator. It is not compatible with the libc allocator API.
#![crate_name = "alloc"] #![crate_name = "alloc"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "alloc")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -70,8 +70,10 @@
#![feature(lang_items, unsafe_destructor)] #![feature(lang_items, unsafe_destructor)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(optin_builtin_traits)] #![feature(optin_builtin_traits)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(core)]
#![feature(hash)]
#![feature(libc)]
#[macro_use] #[macro_use]
extern crate core; extern crate core;

28
src/liballoc/rc.rs
View file

@ -268,7 +268,7 @@ impl<T> Rc<T> {
/// let weak_five = five.downgrade(); /// let weak_five = five.downgrade();
/// ``` /// ```
#[cfg(stage0)] // NOTE remove after next snapshot #[cfg(stage0)] // NOTE remove after next snapshot
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module")] reason = "Weak pointers may not belong in this module")]
pub fn downgrade(&self) -> Weak<T> { pub fn downgrade(&self) -> Weak<T> {
self.inc_weak(); self.inc_weak();
@ -291,7 +291,7 @@ impl<T> Rc<T> {
/// let weak_five = five.downgrade(); /// let weak_five = five.downgrade();
/// ``` /// ```
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot #[cfg(not(stage0))] // NOTE remove cfg after next snapshot
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module")] reason = "Weak pointers may not belong in this module")]
pub fn downgrade(&self) -> Weak<T> { pub fn downgrade(&self) -> Weak<T> {
self.inc_weak(); self.inc_weak();
@ -301,12 +301,12 @@ impl<T> Rc<T> {
/// Get the number of weak references to this value. /// Get the number of weak references to this value.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 } pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 }
/// Get the number of strong references to this value. /// Get the number of strong references to this value.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
/// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value. /// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value.
@ -322,7 +322,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
/// rc::is_unique(&five); /// rc::is_unique(&five);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn is_unique<T>(rc: &Rc<T>) -> bool { pub fn is_unique<T>(rc: &Rc<T>) -> bool {
weak_count(rc) == 0 && strong_count(rc) == 1 weak_count(rc) == 0 && strong_count(rc) == 1
} }
@ -344,7 +344,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool {
/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u))); /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
if is_unique(&rc) { if is_unique(&rc) {
unsafe { unsafe {
@ -378,7 +378,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
/// assert!(rc::get_mut(&mut x).is_none()); /// assert!(rc::get_mut(&mut x).is_none());
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> { pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
if is_unique(rc) { if is_unique(rc) {
let inner = unsafe { &mut **rc._ptr }; let inner = unsafe { &mut **rc._ptr };
@ -404,7 +404,7 @@ impl<T: Clone> Rc<T> {
/// let mut_five = five.make_unique(); /// let mut_five = five.make_unique();
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "alloc")]
pub fn make_unique(&mut self) -> &mut T { pub fn make_unique(&mut self) -> &mut T {
if !is_unique(self) { if !is_unique(self) {
*self = Rc::new((**self).clone()) *self = Rc::new((**self).clone())
@ -695,7 +695,7 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")] #[unstable(feature = "alloc", reason = "Show is experimental.")]
impl<T: fmt::Show> fmt::Show for Rc<T> { impl<T: fmt::Show> fmt::Show for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Rc({:?})", **self) write!(f, "Rc({:?})", **self)
@ -716,7 +716,7 @@ impl<T: fmt::String> fmt::String for Rc<T> {
/// See the [module level documentation](../index.html) for more. /// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag] #[unsafe_no_drop_flag]
#[cfg(stage0)] // NOTE remove impl after next snapshot #[cfg(stage0)] // NOTE remove impl after next snapshot
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> { pub struct Weak<T> {
// FIXME #12808: strange names to try to avoid interfering with // FIXME #12808: strange names to try to avoid interfering with
@ -732,7 +732,7 @@ pub struct Weak<T> {
/// ///
/// See the [module level documentation](../index.html) for more. /// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag] #[unsafe_no_drop_flag]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot #[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub struct Weak<T> { pub struct Weak<T> {
@ -748,7 +748,7 @@ impl<T> !marker::Send for Weak<T> {}
impl<T> !marker::Sync for Weak<T> {} impl<T> !marker::Sync for Weak<T> {}
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
impl<T> Weak<T> { impl<T> Weak<T> {
/// Upgrades a weak reference to a strong reference. /// Upgrades a weak reference to a strong reference.
@ -850,7 +850,7 @@ impl<T> Drop for Weak<T> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")] reason = "Weak pointers may not belong in this module.")]
impl<T> Clone for Weak<T> { impl<T> Clone for Weak<T> {
/// Makes a clone of the `Weak<T>`. /// Makes a clone of the `Weak<T>`.
@ -894,7 +894,7 @@ impl<T> Clone for Weak<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")] #[unstable(feature = "alloc", reason = "Show is experimental.")]
impl<T: fmt::Show> fmt::Show for Weak<T> { impl<T: fmt::Show> fmt::Show for Weak<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "(Weak)") write!(f, "(Weak)")

5
src/libarena/lib.rs
View file

@ -20,7 +20,7 @@
//! more complex, slower arena which can hold objects of any type. //! more complex, slower arena which can hold objects of any type.
#![crate_name = "arena"] #![crate_name = "arena"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -33,9 +33,10 @@
#![feature(unsafe_destructor)] #![feature(unsafe_destructor)]
#![feature(unboxed_closures)] #![feature(unboxed_closures)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![allow(missing_docs)] #![allow(missing_docs)]
#![feature(alloc)]
#![feature(core)]
extern crate alloc; extern crate alloc;

4
src/libcollections/binary_heap.rs
View file

@ -551,7 +551,7 @@ impl<T: Ord> BinaryHeap<T> {
/// Clears the binary heap, returning an iterator over the removed elements. /// Clears the binary heap, returning an iterator over the removed elements.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> { pub fn drain(&mut self) -> Drain<T> {
Drain { iter: self.data.drain() } Drain { iter: self.data.drain() }
@ -623,7 +623,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
impl<T> ExactSizeIterator for IntoIter<T> {} impl<T> ExactSizeIterator for IntoIter<T> {}
/// An iterator that drains a `BinaryHeap`. /// An iterator that drains a `BinaryHeap`.
#[unstable(feature = "unnamed_feature", reason = "recent addition")] #[unstable(feature = "collections", reason = "recent addition")]
pub struct Drain<'a, T: 'a> { pub struct Drain<'a, T: 'a> {
iter: vec::Drain<'a, T>, iter: vec::Drain<'a, T>,
} }

6
src/libcollections/bit.rs
View file

@ -156,7 +156,7 @@ static FALSE: bool = false;
/// println!("{:?}", bv); /// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "RFC 509")] reason = "RFC 509")]
pub struct Bitv { pub struct Bitv {
/// Internal representation of the bit vector /// Internal representation of the bit vector
@ -403,7 +403,7 @@ impl Bitv {
/// assert_eq!(bv[3], true); /// assert_eq!(bv[3], true);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "panic semantics are likely to change in the future")] reason = "panic semantics are likely to change in the future")]
pub fn set(&mut self, i: uint, x: bool) { pub fn set(&mut self, i: uint, x: bool) {
assert!(i < self.nbits); assert!(i < self.nbits);
@ -1109,7 +1109,7 @@ impl<'a> RandomAccessIterator for Iter<'a> {
/// assert!(bv[3]); /// assert!(bv[3]);
/// ``` /// ```
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "RFC 509")] reason = "RFC 509")]
pub struct BitvSet { pub struct BitvSet {
bitv: Bitv, bitv: Bitv,

26
src/libcollections/btree/map.rs
View file

@ -136,7 +136,7 @@ pub struct RangeMut<'a, K: 'a, V: 'a> {
} }
/// A view into a single entry in a map, which may either be vacant or occupied. /// A view into a single entry in a map, which may either be vacant or occupied.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "precise API still under development")] reason = "precise API still under development")]
pub enum Entry<'a, K:'a, V:'a> { pub enum Entry<'a, K:'a, V:'a> {
/// A vacant Entry /// A vacant Entry
@ -146,7 +146,7 @@ pub enum Entry<'a, K:'a, V:'a> {
} }
/// A vacant Entry. /// A vacant Entry.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "precise API still under development")] reason = "precise API still under development")]
pub struct VacantEntry<'a, K:'a, V:'a> { pub struct VacantEntry<'a, K:'a, V:'a> {
key: K, key: K,
@ -154,7 +154,7 @@ pub struct VacantEntry<'a, K:'a, V:'a> {
} }
/// An occupied Entry. /// An occupied Entry.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "precise API still under development")] reason = "precise API still under development")]
pub struct OccupiedEntry<'a, K:'a, V:'a> { pub struct OccupiedEntry<'a, K:'a, V:'a> {
stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>, stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
@ -1099,7 +1099,7 @@ impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {
} }
impl<'a, K: Ord, V> Entry<'a, K, V> { impl<'a, K: Ord, V> Entry<'a, K, V> {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> { pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
@ -1113,7 +1113,7 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
impl<'a, K: Ord, V> VacantEntry<'a, K, V> { impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key, /// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it. /// and returns a mutable reference to it.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn insert(self, value: V) -> &'a mut V { pub fn insert(self, value: V) -> &'a mut V {
self.stack.insert(self.key, value) self.stack.insert(self.key, value)
@ -1122,21 +1122,21 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry. /// Gets a reference to the value in the entry.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn get(&self) -> &V { pub fn get(&self) -> &V {
self.stack.peek() self.stack.peek()
} }
/// Gets a mutable reference to the value in the entry. /// Gets a mutable reference to the value in the entry.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn get_mut(&mut self) -> &mut V { pub fn get_mut(&mut self) -> &mut V {
self.stack.peek_mut() self.stack.peek_mut()
} }
/// Converts the entry into a mutable reference to its value. /// Converts the entry into a mutable reference to its value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn into_mut(self) -> &'a mut V { pub fn into_mut(self) -> &'a mut V {
self.stack.into_top() self.stack.into_top()
@ -1144,7 +1144,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Sets the value of the entry with the OccupiedEntry's key, /// Sets the value of the entry with the OccupiedEntry's key,
/// and returns the entry's old value. /// and returns the entry's old value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn insert(&mut self, mut value: V) -> V { pub fn insert(&mut self, mut value: V) -> V {
mem::swap(self.stack.peek_mut(), &mut value); mem::swap(self.stack.peek_mut(), &mut value);
@ -1152,7 +1152,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
} }
/// Takes the value of the entry out of the map, and returns it. /// Takes the value of the entry out of the map, and returns it.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn remove(self) -> V { pub fn remove(self) -> V {
self.stack.remove() self.stack.remove()
@ -1480,7 +1480,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// } /// }
/// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next()); /// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range<'a>(&'a self, min: Bound<&K>, max: Bound<&K>) -> Range<'a, K, V> { pub fn range<'a>(&'a self, min: Bound<&K>, max: Bound<&K>) -> Range<'a, K, V> {
range_impl!(&self.root, min, max, as_slices_internal, iter, Range, edges, []) range_impl!(&self.root, min, max, as_slices_internal, iter, Range, edges, [])
@ -1507,7 +1507,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// println!("{} => {}", name, balance); /// println!("{} => {}", name, balance);
/// } /// }
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range_mut<'a>(&'a mut self, min: Bound<&K>, max: Bound<&K>) -> RangeMut<'a, K, V> { pub fn range_mut<'a>(&'a mut self, min: Bound<&K>, max: Bound<&K>) -> RangeMut<'a, K, V> {
range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut, range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut,
@ -1540,7 +1540,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(count["a"], 3u); /// assert_eq!(count["a"], 3u);
/// ``` /// ```
/// The key must have the same ordering before or after `.to_owned()` is called. /// The key must have the same ordering before or after `.to_owned()` is called.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "precise API still under development")] reason = "precise API still under development")]
pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> { pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
// same basic logic of `swap` and `pop`, blended together // same basic logic of `swap` and `pop`, blended together

4
src/libcollections/btree/set.rs
View file

@ -102,7 +102,7 @@ impl<T: Ord> BTreeSet<T> {
/// Makes a new BTreeSet with the given B. /// Makes a new BTreeSet with the given B.
/// ///
/// B cannot be less than 2. /// B cannot be less than 2.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "probably want this to be on the type, eventually")] reason = "probably want this to be on the type, eventually")]
pub fn with_b(b: uint) -> BTreeSet<T> { pub fn with_b(b: uint) -> BTreeSet<T> {
BTreeSet { map: BTreeMap::with_b(b) } BTreeSet { map: BTreeMap::with_b(b) }
@ -173,7 +173,7 @@ impl<T: Ord> BTreeSet<T> {
/// } /// }
/// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next()); /// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> { pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> {
fn first<A, B>((a, _): (A, B)) -> A { a } fn first<A, B>((a, _): (A, B)) -> A { a }

4
src/libcollections/dlist.rs
View file

@ -770,7 +770,7 @@ impl<'a, A> IterMut<'a, A> {
/// } /// }
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this is probably better handled by a cursor type -- we'll see")] reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn insert_next(&mut self, elt: A) { pub fn insert_next(&mut self, elt: A) {
self.insert_next_node(box Node::new(elt)) self.insert_next_node(box Node::new(elt))
@ -792,7 +792,7 @@ impl<'a, A> IterMut<'a, A> {
/// assert_eq!(it.next().unwrap(), &2); /// assert_eq!(it.next().unwrap(), &2);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this is probably better handled by a cursor type -- we'll see")] reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn peek_next(&mut self) -> Option<&mut A> { pub fn peek_next(&mut self) -> Option<&mut A> {
if self.nelem == 0 { if self.nelem == 0 {

20
src/libcollections/enum_set.rs
View file

@ -82,21 +82,21 @@ fn bit<E:CLike>(e: &E) -> uint {
impl<E:CLike> EnumSet<E> { impl<E:CLike> EnumSet<E> {
/// Returns an empty `EnumSet`. /// Returns an empty `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn new() -> EnumSet<E> { pub fn new() -> EnumSet<E> {
EnumSet {bits: 0} EnumSet {bits: 0}
} }
/// Returns the number of elements in the given `EnumSet`. /// Returns the number of elements in the given `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn len(&self) -> uint { pub fn len(&self) -> uint {
self.bits.count_ones() self.bits.count_ones()
} }
/// Returns true if the `EnumSet` is empty. /// Returns true if the `EnumSet` is empty.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.bits == 0 self.bits == 0
@ -107,21 +107,21 @@ impl<E:CLike> EnumSet<E> {
} }
/// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`. /// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool { pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == 0 (self.bits & other.bits) == 0
} }
/// Returns `true` if a given `EnumSet` is included in this `EnumSet`. /// Returns `true` if a given `EnumSet` is included in this `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_superset(&self, other: &EnumSet<E>) -> bool { pub fn is_superset(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == other.bits (self.bits & other.bits) == other.bits
} }
/// Returns `true` if this `EnumSet` is included in the given `EnumSet`. /// Returns `true` if this `EnumSet` is included in the given `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_subset(&self, other: &EnumSet<E>) -> bool { pub fn is_subset(&self, other: &EnumSet<E>) -> bool {
other.is_superset(self) other.is_superset(self)
@ -138,7 +138,7 @@ impl<E:CLike> EnumSet<E> {
} }
/// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn insert(&mut self, e: E) -> bool { pub fn insert(&mut self, e: E) -> bool {
let result = !self.contains(&e); let result = !self.contains(&e);
@ -147,7 +147,7 @@ impl<E:CLike> EnumSet<E> {
} }
/// Removes an enum from the EnumSet /// Removes an enum from the EnumSet
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn remove(&mut self, e: &E) -> bool { pub fn remove(&mut self, e: &E) -> bool {
let result = self.contains(e); let result = self.contains(e);
@ -156,14 +156,14 @@ impl<E:CLike> EnumSet<E> {
} }
/// Returns `true` if an `EnumSet` contains a given enum. /// Returns `true` if an `EnumSet` contains a given enum.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn contains(&self, e: &E) -> bool { pub fn contains(&self, e: &E) -> bool {
(self.bits & bit(e)) != 0 (self.bits & bit(e)) != 0
} }
/// Returns an iterator over an `EnumSet`. /// Returns an iterator over an `EnumSet`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn iter(&self) -> Iter<E> { pub fn iter(&self) -> Iter<E> {
Iter::new(self.bits) Iter::new(self.bits)

11
src/libcollections/lib.rs
View file

@ -14,7 +14,7 @@
#![crate_name = "collections"] #![crate_name = "collections"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "collections")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -27,9 +27,12 @@
#![feature(unsafe_destructor, slicing_syntax)] #![feature(unsafe_destructor, slicing_syntax)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unboxed_closures)] #![feature(unboxed_closures)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![no_std] #![no_std]
#![feature(core)]
#![feature(alloc)]
#![feature(unicode)]
#![feature(hash)]
#[macro_use] #[macro_use]
extern crate core; extern crate core;
@ -71,13 +74,13 @@ pub mod string;
pub mod vec; pub mod vec;
pub mod vec_map; pub mod vec_map;
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "RFC 509")] reason = "RFC 509")]
pub mod bitv { pub mod bitv {
pub use bit::{Bitv, Iter}; pub use bit::{Bitv, Iter};
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "RFC 509")] reason = "RFC 509")]
pub mod bitv_set { pub mod bitv_set {
pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference}; pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference};

16
src/libcollections/ring_buf.rs
View file

@ -480,7 +480,7 @@ impl<T> RingBuf<T> {
/// assert_eq!(buf.len(), 1); /// assert_eq!(buf.len(), 1);
/// assert_eq!(Some(&5), buf.get(0)); /// assert_eq!(Some(&5), buf.get(0));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")] reason = "matches collection reform specification; waiting on panic semantics")]
pub fn truncate(&mut self, len: uint) { pub fn truncate(&mut self, len: uint) {
for _ in range(len, self.len()) { for _ in range(len, self.len()) {
@ -550,7 +550,7 @@ impl<T> RingBuf<T> {
/// Returns a pair of slices which contain, in order, the contents of the /// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`. /// `RingBuf`.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) { pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
unsafe { unsafe {
@ -570,7 +570,7 @@ impl<T> RingBuf<T> {
/// Returns a pair of slices which contain, in order, the contents of the /// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`. /// `RingBuf`.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) { pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
unsafe { unsafe {
@ -635,7 +635,7 @@ impl<T> RingBuf<T> {
/// assert!(v.is_empty()); /// assert!(v.is_empty());
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> { pub fn drain(&mut self) -> Drain<T> {
Drain { Drain {
@ -876,7 +876,7 @@ impl<T> RingBuf<T> {
/// buf.push_back(10); /// buf.push_back(10);
/// assert_eq!(buf.swap_back_remove(1), Some(99)); /// assert_eq!(buf.swap_back_remove(1), Some(99));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "the naming of this function may be altered")] reason = "the naming of this function may be altered")]
pub fn swap_back_remove(&mut self, index: uint) -> Option<T> { pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
let length = self.len(); let length = self.len();
@ -909,7 +909,7 @@ impl<T> RingBuf<T> {
/// buf.push_back(20i); /// buf.push_back(20i);
/// assert_eq!(buf.swap_front_remove(3), Some(99)); /// assert_eq!(buf.swap_front_remove(3), Some(99));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "the naming of this function may be altered")] reason = "the naming of this function may be altered")]
pub fn swap_front_remove(&mut self, index: uint) -> Option<T> { pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
let length = self.len(); let length = self.len();
@ -1310,7 +1310,7 @@ impl<T: Clone> RingBuf<T> {
/// assert_eq!(a, b); /// assert_eq!(a, b);
/// } /// }
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")] reason = "matches collection reform specification; waiting on panic semantics")]
pub fn resize(&mut self, new_len: uint, value: T) { pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len(); let len = self.len();
@ -1500,7 +1500,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
impl<T> ExactSizeIterator for IntoIter<T> {} impl<T> ExactSizeIterator for IntoIter<T> {}
/// A draining RingBuf iterator /// A draining RingBuf iterator
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub struct Drain<'a, T: 'a> { pub struct Drain<'a, T: 'a> {
inner: &'a mut RingBuf<T>, inner: &'a mut RingBuf<T>,

52
src/libcollections/slice.rs
View file

@ -166,7 +166,7 @@ pub trait SliceExt {
/// assert_eq!(num_moved, 3); /// assert_eq!(num_moved, 3);
/// assert!(a == [6i, 7, 8, 4, 5]); /// assert!(a == [6i, 7, 8, 4, 5]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "uncertain about this API approach")] reason = "uncertain about this API approach")]
fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint; fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
@ -176,7 +176,7 @@ pub trait SliceExt {
/// original slice (i.e. when `end > self.len()`) or when `start > end`. /// original slice (i.e. when `end > self.len()`) or when `start > end`.
/// ///
/// Slicing with `start` equal to `end` yields an empty slice. /// Slicing with `start` equal to `end` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice(&self, start: uint, end: uint) -> &[Self::Item]; fn slice(&self, start: uint, end: uint) -> &[Self::Item];
@ -185,7 +185,7 @@ pub trait SliceExt {
/// Panics when `start` is strictly greater than the length of the original slice. /// Panics when `start` is strictly greater than the length of the original slice.
/// ///
/// Slicing from `self.len()` yields an empty slice. /// Slicing from `self.len()` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice_from(&self, start: uint) -> &[Self::Item]; fn slice_from(&self, start: uint) -> &[Self::Item];
@ -194,7 +194,7 @@ pub trait SliceExt {
/// Panics when `end` is strictly greater than the length of the original slice. /// Panics when `end` is strictly greater than the length of the original slice.
/// ///
/// Slicing to `0` yields an empty slice. /// Slicing to `0` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice_to(&self, end: uint) -> &[Self::Item]; fn slice_to(&self, end: uint) -> &[Self::Item];
@ -288,11 +288,11 @@ pub trait SliceExt {
fn first(&self) -> Option<&Self::Item>; fn first(&self) -> Option<&Self::Item>;
/// Returns all but the first element of a slice. /// Returns all but the first element of a slice.
#[unstable(feature = "unnamed_feature", reason = "likely to be renamed")] #[unstable(feature = "collections", reason = "likely to be renamed")]
fn tail(&self) -> &[Self::Item]; fn tail(&self) -> &[Self::Item];
/// Returns all but the last element of a slice. /// Returns all but the last element of a slice.
#[unstable(feature = "unnamed_feature", reason = "likely to be renamed")] #[unstable(feature = "collections", reason = "likely to be renamed")]
fn init(&self) -> &[Self::Item]; fn init(&self) -> &[Self::Item];
/// Returns the last element of a slice, or `None` if it is empty. /// Returns the last element of a slice, or `None` if it is empty.
@ -388,7 +388,7 @@ pub trait SliceExt {
/// original slice (i.e. when `end > self.len()`) or when `start > end`. /// original slice (i.e. when `end > self.len()`) or when `start > end`.
/// ///
/// Slicing with `start` equal to `end` yields an empty slice. /// Slicing with `start` equal to `end` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item]; fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
@ -397,7 +397,7 @@ pub trait SliceExt {
/// Panics when `start` is strictly greater than the length of the original slice. /// Panics when `start` is strictly greater than the length of the original slice.
/// ///
/// Slicing from `self.len()` yields an empty slice. /// Slicing from `self.len()` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item]; fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
@ -406,7 +406,7 @@ pub trait SliceExt {
/// Panics when `end` is strictly greater than the length of the original slice. /// Panics when `end` is strictly greater than the length of the original slice.
/// ///
/// Slicing to `0` yields an empty slice. /// Slicing to `0` yields an empty slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item]; fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
@ -419,12 +419,12 @@ pub trait SliceExt {
fn first_mut(&mut self) -> Option<&mut Self::Item>; fn first_mut(&mut self) -> Option<&mut Self::Item>;
/// Returns all but the first element of a mutable slice /// Returns all but the first element of a mutable slice
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "likely to be renamed or removed")] reason = "likely to be renamed or removed")]
fn tail_mut(&mut self) -> &mut [Self::Item]; fn tail_mut(&mut self) -> &mut [Self::Item];
/// Returns all but the last element of a mutable slice /// Returns all but the last element of a mutable slice
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "likely to be renamed or removed")] reason = "likely to be renamed or removed")]
fn init_mut(&mut self) -> &mut [Self::Item]; fn init_mut(&mut self) -> &mut [Self::Item];
@ -577,7 +577,7 @@ pub trait SliceExt {
/// assert_eq!(Some(vec![1i, 3, 2]), perms.next()); /// assert_eq!(Some(vec![1i, 3, 2]), perms.next());
/// assert_eq!(Some(vec![3i, 1, 2]), perms.next()); /// assert_eq!(Some(vec![3i, 1, 2]), perms.next());
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone; fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone;
/// Copies as many elements from `src` as it can into `self` (the /// Copies as many elements from `src` as it can into `self` (the
@ -597,7 +597,7 @@ pub trait SliceExt {
/// assert!(dst.clone_from_slice(&src2) == 3); /// assert!(dst.clone_from_slice(&src2) == 3);
/// assert!(dst == [3i, 4, 5]); /// assert!(dst == [3i, 4, 5]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
/// Sorts the slice, in place. /// Sorts the slice, in place.
@ -663,7 +663,7 @@ pub trait SliceExt {
/// let b: &mut [_] = &mut [1i, 0, 2]; /// let b: &mut [_] = &mut [1i, 0, 2];
/// assert!(v == b); /// assert!(v == b);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "uncertain if this merits inclusion in std")] reason = "uncertain if this merits inclusion in std")]
fn next_permutation(&mut self) -> bool where Self::Item: Ord; fn next_permutation(&mut self) -> bool where Self::Item: Ord;
@ -683,16 +683,16 @@ pub trait SliceExt {
/// let b: &mut [_] = &mut [0i, 1, 2]; /// let b: &mut [_] = &mut [0i, 1, 2];
/// assert!(v == b); /// assert!(v == b);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "uncertain if this merits inclusion in std")] reason = "uncertain if this merits inclusion in std")]
fn prev_permutation(&mut self) -> bool where Self::Item: Ord; fn prev_permutation(&mut self) -> bool where Self::Item: Ord;
/// Find the first index containing a matching value. /// Find the first index containing a matching value.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
/// Find the last index containing a matching value. /// Find the last index containing a matching value.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
/// Return true if the slice contains an element with the given value. /// Return true if the slice contains an element with the given value.
@ -708,7 +708,7 @@ pub trait SliceExt {
fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq; fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
/// Convert `self` into a vector without clones or allocation. /// Convert `self` into a vector without clones or allocation.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
fn into_vec(self: Box<Self>) -> Vec<Self::Item>; fn into_vec(self: Box<Self>) -> Vec<Self::Item>;
} }
@ -1000,7 +1000,7 @@ impl<T> SliceExt for [T] {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Extension traits for slices over specific kinds of data // Extension traits for slices over specific kinds of data
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[unstable(feature = "unnamed_feature", reason = "U should be an associated type")] #[unstable(feature = "collections", reason = "U should be an associated type")]
/// An extension trait for concatenating slices /// An extension trait for concatenating slices
pub trait SliceConcatExt<T: ?Sized, U> { pub trait SliceConcatExt<T: ?Sized, U> {
/// Flattens a slice of `T` into a single value `U`. /// Flattens a slice of `T` into a single value `U`.
@ -1045,7 +1045,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
/// ///
/// The last generated swap is always (0, 1), and it returns the /// The last generated swap is always (0, 1), and it returns the
/// sequence to its initial order. /// sequence to its initial order.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
#[derive(Clone)] #[derive(Clone)]
pub struct ElementSwaps { pub struct ElementSwaps {
sdir: Vec<SizeDirection>, sdir: Vec<SizeDirection>,
@ -1057,7 +1057,7 @@ pub struct ElementSwaps {
impl ElementSwaps { impl ElementSwaps {
/// Creates an `ElementSwaps` iterator for a sequence of `length` elements. /// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub fn new(length: uint) -> ElementSwaps { pub fn new(length: uint) -> ElementSwaps {
// Initialize `sdir` with a direction that position should move in // Initialize `sdir` with a direction that position should move in
// (all negative at the beginning) and the `size` of the // (all negative at the beginning) and the `size` of the
@ -1074,17 +1074,17 @@ impl ElementSwaps {
// Standard trait implementations for slices // Standard trait implementations for slices
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl<T> BorrowFrom<Vec<T>> for [T] { impl<T> BorrowFrom<Vec<T>> for [T] {
fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] } fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl<T> BorrowFromMut<Vec<T>> for [T] { impl<T> BorrowFromMut<Vec<T>> for [T] {
fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] } fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl<T: Clone> ToOwned<Vec<T>> for [T] { impl<T: Clone> ToOwned<Vec<T>> for [T] {
fn to_owned(&self) -> Vec<T> { self.to_vec() } fn to_owned(&self) -> Vec<T> { self.to_vec() }
} }
@ -1166,13 +1166,13 @@ impl Iterator for ElementSwaps {
/// swap applied. /// swap applied.
/// ///
/// Generates even and odd permutations alternately. /// Generates even and odd permutations alternately.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct Permutations<T> { pub struct Permutations<T> {
swaps: ElementSwaps, swaps: ElementSwaps,
v: Vec<T>, v: Vec<T>,
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl<T: Clone> Iterator for Permutations<T> { impl<T: Clone> Iterator for Permutations<T> {
type Item = Vec<T>; type Item = Vec<T>;

64
src/libcollections/str.rs
View file

@ -165,7 +165,7 @@ enum DecompositionType {
/// External iterator for a string's decomposition's characters. /// External iterator for a string's decomposition's characters.
/// Use with the `std::iter` module. /// Use with the `std::iter` module.
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct Decompositions<'a> { pub struct Decompositions<'a> {
kind: DecompositionType, kind: DecompositionType,
iter: Chars<'a>, iter: Chars<'a>,
@ -255,7 +255,7 @@ enum RecompositionState {
/// External iterator for a string's recomposition's characters. /// External iterator for a string's recomposition's characters.
/// Use with the `std::iter` module. /// Use with the `std::iter` module.
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct Recompositions<'a> { pub struct Recompositions<'a> {
iter: Decompositions<'a>, iter: Decompositions<'a>,
state: RecompositionState, state: RecompositionState,
@ -352,7 +352,7 @@ impl<'a> Iterator for Recompositions<'a> {
/// External iterator for a string's UTF16 codeunits. /// External iterator for a string's UTF16 codeunits.
/// Use with the `std::iter` module. /// Use with the `std::iter` module.
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct Utf16Units<'a> { pub struct Utf16Units<'a> {
encoder: Utf16Encoder<Chars<'a>> encoder: Utf16Encoder<Chars<'a>>
} }
@ -384,12 +384,12 @@ macro_rules! utf8_acc_cont_byte {
($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32) ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32)
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl BorrowFrom<String> for str { impl BorrowFrom<String> for str {
fn borrow_from(owned: &String) -> &str { &owned[] } fn borrow_from(owned: &String) -> &str { &owned[] }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "collections", reason = "trait is unstable")]
impl ToOwned<String> for str { impl ToOwned<String> for str {
fn to_owned(&self) -> String { fn to_owned(&self) -> String {
unsafe { unsafe {
@ -410,14 +410,14 @@ Section: Trait implementations
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
pub trait StrExt: Index<FullRange, Output = str> { pub trait StrExt: Index<FullRange, Output = str> {
/// Escapes each char in `s` with `char::escape_default`. /// Escapes each char in `s` with `char::escape_default`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "return type may change to be an iterator")] reason = "return type may change to be an iterator")]
fn escape_default(&self) -> String { fn escape_default(&self) -> String {
self.chars().flat_map(|c| c.escape_default()).collect() self.chars().flat_map(|c| c.escape_default()).collect()
} }
/// Escapes each char in `s` with `char::escape_unicode`. /// Escapes each char in `s` with `char::escape_unicode`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "return type may change to be an iterator")] reason = "return type may change to be an iterator")]
fn escape_unicode(&self) -> String { fn escape_unicode(&self) -> String {
self.chars().flat_map(|c| c.escape_unicode()).collect() self.chars().flat_map(|c| c.escape_unicode()).collect()
@ -463,7 +463,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// Returns an iterator over the string in Unicode Normalization Form D /// Returns an iterator over the string in Unicode Normalization Form D
/// (canonical decomposition). /// (canonical decomposition).
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")] reason = "this functionality may be moved to libunicode")]
fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions { Decompositions {
@ -477,7 +477,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// Returns an iterator over the string in Unicode Normalization Form KD /// Returns an iterator over the string in Unicode Normalization Form KD
/// (compatibility decomposition). /// (compatibility decomposition).
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")] reason = "this functionality may be moved to libunicode")]
fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions { Decompositions {
@ -491,7 +491,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// An Iterator over the string in Unicode Normalization Form C /// An Iterator over the string in Unicode Normalization Form C
/// (canonical decomposition followed by canonical composition). /// (canonical decomposition followed by canonical composition).
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")] reason = "this functionality may be moved to libunicode")]
fn nfc_chars<'a>(&'a self) -> Recompositions<'a> { fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions { Recompositions {
@ -506,7 +506,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// An Iterator over the string in Unicode Normalization Form KC /// An Iterator over the string in Unicode Normalization Form KC
/// (compatibility decomposition followed by canonical composition). /// (compatibility decomposition followed by canonical composition).
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")] reason = "this functionality may be moved to libunicode")]
fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> { fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions { Recompositions {
@ -545,7 +545,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust /// ```rust
/// assert!("hello".contains_char('e')); /// assert!("hello".contains_char('e'));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "might get removed in favour of a more generic contains()")] reason = "might get removed in favour of a more generic contains()")]
fn contains_char<P: CharEq>(&self, pat: P) -> bool { fn contains_char<P: CharEq>(&self, pat: P) -> bool {
core_str::StrExt::contains_char(&self[], pat) core_str::StrExt::contains_char(&self[], pat)
@ -658,7 +658,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect(); /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect();
/// assert_eq!(v, vec!["leopard", "tiger", "", "lion"]); /// assert_eq!(v, vec!["leopard", "tiger", "", "lion"]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", reason = "might get removed")] #[unstable(feature = "collections", reason = "might get removed")]
fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> { fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
core_str::StrExt::split_terminator(&self[], pat) core_str::StrExt::split_terminator(&self[], pat)
} }
@ -704,7 +704,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect(); /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
/// assert_eq!(v, vec![(0, 3)]); // only the first `aba` /// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "might have its iterator type changed")] reason = "might have its iterator type changed")]
fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> { fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
core_str::StrExt::match_indices(&self[], pat) core_str::StrExt::match_indices(&self[], pat)
@ -721,7 +721,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect();
/// assert_eq!(v, vec!["1", "", "2"]); /// assert_eq!(v, vec!["1", "", "2"]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "might get removed in the future in favor of a more generic split()")] reason = "might get removed in the future in favor of a more generic split()")]
fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> { fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
core_str::StrExt::split_str(&self[], pat) core_str::StrExt::split_str(&self[], pat)
@ -789,7 +789,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// // byte 100 is outside the string /// // byte 100 is outside the string
/// // s.slice(3, 100); /// // s.slice(3, 100);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")] reason = "use slice notation [a..b] instead")]
fn slice(&self, begin: uint, end: uint) -> &str { fn slice(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice(&self[], begin, end) core_str::StrExt::slice(&self[], begin, end)
@ -803,7 +803,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// out of bounds. /// out of bounds.
/// ///
/// See also `slice`, `slice_to` and `slice_chars`. /// See also `slice`, `slice_to` and `slice_chars`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "use slice notation [a..] instead")] reason = "use slice notation [a..] instead")]
fn slice_from(&self, begin: uint) -> &str { fn slice_from(&self, begin: uint) -> &str {
core_str::StrExt::slice_from(&self[], begin) core_str::StrExt::slice_from(&self[], begin)
@ -818,7 +818,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// out of bounds. /// out of bounds.
/// ///
/// See also `slice`, `slice_from` and `slice_chars`. /// See also `slice`, `slice_from` and `slice_chars`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "use slice notation [..a] instead")] reason = "use slice notation [..a] instead")]
fn slice_to(&self, end: uint) -> &str { fn slice_to(&self, end: uint) -> &str {
core_str::StrExt::slice_to(&self[], end) core_str::StrExt::slice_to(&self[], end)
@ -847,7 +847,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(s.slice_chars(0, 4), "Löwe"); /// assert_eq!(s.slice_chars(0, 4), "Löwe");
/// assert_eq!(s.slice_chars(5, 7), "老虎"); /// assert_eq!(s.slice_chars(5, 7), "老虎");
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "may have yet to prove its worth")] reason = "may have yet to prove its worth")]
fn slice_chars(&self, begin: uint, end: uint) -> &str { fn slice_chars(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice_chars(&self[], begin, end) core_str::StrExt::slice_chars(&self[], begin, end)
@ -971,7 +971,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// // third byte of `老` /// // third byte of `老`
/// assert!(!s.is_char_boundary(8)); /// assert!(!s.is_char_boundary(8));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
fn is_char_boundary(&self, index: uint) -> bool { fn is_char_boundary(&self, index: uint) -> bool {
core_str::StrExt::is_char_boundary(&self[], index) core_str::StrExt::is_char_boundary(&self[], index)
@ -1030,7 +1030,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ///
/// If `i` is greater than or equal to the length of the string. /// If `i` is greater than or equal to the length of the string.
/// If `i` is not the index of the beginning of a valid UTF-8 character. /// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
fn char_range_at(&self, start: uint) -> CharRange { fn char_range_at(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at(&self[], start) core_str::StrExt::char_range_at(&self[], start)
@ -1046,7 +1046,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ///
/// If `i` is greater than the length of the string. /// If `i` is greater than the length of the string.
/// If `i` is not an index following a valid UTF-8 character. /// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
fn char_range_at_reverse(&self, start: uint) -> CharRange { fn char_range_at_reverse(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at_reverse(&self[], start) core_str::StrExt::char_range_at_reverse(&self[], start)
@ -1067,7 +1067,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ///
/// If `i` is greater than or equal to the length of the string. /// If `i` is greater than or equal to the length of the string.
/// If `i` is not the index of the beginning of a valid UTF-8 character. /// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
fn char_at(&self, i: uint) -> char { fn char_at(&self, i: uint) -> char {
core_str::StrExt::char_at(&self[], i) core_str::StrExt::char_at(&self[], i)
@ -1079,7 +1079,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ///
/// If `i` is greater than the length of the string. /// If `i` is greater than the length of the string.
/// If `i` is not an index following a valid UTF-8 character. /// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
fn char_at_reverse(&self, i: uint) -> char { fn char_at_reverse(&self, i: uint) -> char {
core_str::StrExt::char_at_reverse(&self[], i) core_str::StrExt::char_at_reverse(&self[], i)
@ -1172,7 +1172,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(s.find_str("老虎 L"), Some(6)); /// assert_eq!(s.find_str("老虎 L"), Some(6));
/// assert_eq!(s.find_str("muffin man"), None); /// assert_eq!(s.find_str("muffin man"), None);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "might get removed in favor of a more generic find in the future")] reason = "might get removed in favor of a more generic find in the future")]
fn find_str(&self, needle: &str) -> Option<uint> { fn find_str(&self, needle: &str) -> Option<uint> {
core_str::StrExt::find_str(&self[], needle) core_str::StrExt::find_str(&self[], needle)
@ -1196,7 +1196,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(c, 'ö'); /// assert_eq!(c, 'ö');
/// assert_eq!(s2, "we 老虎 Léopard"); /// assert_eq!(s2, "we 老虎 Léopard");
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "awaiting conventions about shifting and slices")] reason = "awaiting conventions about shifting and slices")]
fn slice_shift_char(&self) -> Option<(char, &str)> { fn slice_shift_char(&self) -> Option<(char, &str)> {
core_str::StrExt::slice_shift_char(&self[]) core_str::StrExt::slice_shift_char(&self[])
@ -1216,7 +1216,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert!(string.subslice_offset(lines[1]) == 2); // &"b" /// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
/// assert!(string.subslice_offset(lines[2]) == 4); // &"c" /// assert!(string.subslice_offset(lines[2]) == 4); // &"c"
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "awaiting convention about comparability of arbitrary slices")] reason = "awaiting convention about comparability of arbitrary slices")]
fn subslice_offset(&self, inner: &str) -> uint { fn subslice_offset(&self, inner: &str) -> uint {
core_str::StrExt::subslice_offset(&self[], inner) core_str::StrExt::subslice_offset(&self[], inner)
@ -1234,7 +1234,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
} }
/// Return an iterator of `u16` over the string encoded as UTF-16. /// Return an iterator of `u16` over the string encoded as UTF-16.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")] reason = "this functionality may only be provided by libunicode")]
fn utf16_units(&self) -> Utf16Units { fn utf16_units(&self) -> Utf16Units {
Utf16Units { encoder: Utf16Encoder::new(self[].chars()) } Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
@ -1276,7 +1276,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("j".parse::<u32>(), None); /// assert_eq!("j".parse::<u32>(), None);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this method was just created")] reason = "this method was just created")]
fn parse<F: FromStr>(&self) -> Option<F> { fn parse<F: FromStr>(&self) -> Option<F> {
core_str::StrExt::parse(&self[]) core_str::StrExt::parse(&self[])
@ -1301,7 +1301,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
/// assert_eq!(gr2.as_slice(), b); /// assert_eq!(gr2.as_slice(), b);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")] reason = "this functionality may only be provided by libunicode")]
fn graphemes(&self, is_extended: bool) -> Graphemes { fn graphemes(&self, is_extended: bool) -> Graphemes {
UnicodeStr::graphemes(&self[], is_extended) UnicodeStr::graphemes(&self[], is_extended)
@ -1317,7 +1317,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
/// assert_eq!(gr_inds.as_slice(), b); /// assert_eq!(gr_inds.as_slice(), b);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")] reason = "this functionality may only be provided by libunicode")]
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
UnicodeStr::grapheme_indices(&self[], is_extended) UnicodeStr::grapheme_indices(&self[], is_extended)
@ -1348,7 +1348,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
/// recommends that these characters be treated as 1 column (i.e., /// recommends that these characters be treated as 1 column (i.e.,
/// `is_cjk` = `false`) if the locale is unknown. /// `is_cjk` = `false`) if the locale is unknown.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")] reason = "this functionality may only be provided by libunicode")]
fn width(&self, is_cjk: bool) -> uint { fn width(&self, is_cjk: bool) -> uint {
UnicodeStr::width(&self[], is_cjk) UnicodeStr::width(&self[], is_cjk)

18
src/libcollections/string.rs
View file

@ -92,7 +92,7 @@ impl String {
/// assert_eq!(s.as_slice(), "hello"); /// assert_eq!(s.as_slice(), "hello");
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "needs investigation to see if to_string() can match perf")] reason = "needs investigation to see if to_string() can match perf")]
pub fn from_str(string: &str) -> String { pub fn from_str(string: &str) -> String {
String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) } String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) }
@ -725,7 +725,7 @@ impl<'a> FromIterator<&'a str> for String {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "waiting on Extend stabilization")] reason = "waiting on Extend stabilization")]
impl Extend<char> for String { impl Extend<char> for String {
fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) { fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) {
@ -737,7 +737,7 @@ impl Extend<char> for String {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "waiting on Extend stabilization")] reason = "waiting on Extend stabilization")]
impl<'a> Extend<&'a str> for String { impl<'a> Extend<&'a str> for String {
fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) { fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) {
@ -798,7 +798,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) } fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Str stabilization")] #[unstable(feature = "collections", reason = "waiting on Str stabilization")]
impl Str for String { impl Str for String {
#[inline] #[inline]
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -824,7 +824,7 @@ impl fmt::String for String {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on fmt stabilization")] #[unstable(feature = "collections", reason = "waiting on fmt stabilization")]
impl fmt::Show for String { impl fmt::Show for String {
#[inline] #[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -832,7 +832,7 @@ impl fmt::Show for String {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Hash stabilization")] #[unstable(feature = "collections", reason = "waiting on Hash stabilization")]
impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
#[inline] #[inline]
fn hash(&self, hasher: &mut H) { fn hash(&self, hasher: &mut H) {
@ -840,7 +840,7 @@ impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "recent addition, needs more experience")] reason = "recent addition, needs more experience")]
impl<'a> Add<&'a str> for String { impl<'a> Add<&'a str> for String {
type Output = String; type Output = String;
@ -892,7 +892,7 @@ impl ops::Deref for String {
} }
/// Wrapper type providing a `&String` reference via `Deref`. /// Wrapper type providing a `&String` reference via `Deref`.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct DerefString<'a> { pub struct DerefString<'a> {
x: DerefVec<'a, u8> x: DerefVec<'a, u8>
} }
@ -920,7 +920,7 @@ impl<'a> Deref for DerefString<'a> {
/// let string = as_string("foo").clone(); /// let string = as_string("foo").clone();
/// string_consumer(string); /// string_consumer(string);
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub fn as_string<'a>(x: &'a str) -> DerefString<'a> { pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
DerefString { x: as_vec(x.as_bytes()) } DerefString { x: as_vec(x.as_bytes()) }
} }

44
src/libcollections/vec.rs
View file

@ -255,7 +255,7 @@ impl<T> Vec<T> {
/// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector
/// without cloning, as if `ptr::read()` were called on them. /// without cloning, as if `ptr::read()` were called on them.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "may be better expressed via composition")] reason = "may be better expressed via composition")]
pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> { pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
let mut dst = Vec::with_capacity(elts); let mut dst = Vec::with_capacity(elts);
@ -377,7 +377,7 @@ impl<T> Vec<T> {
/// Note that this will drop any excess capacity. Calling this and /// Note that this will drop any excess capacity. Calling this and
/// converting back to a vector with `into_vec()` is equivalent to calling /// converting back to a vector with `into_vec()` is equivalent to calling
/// `shrink_to_fit()`. /// `shrink_to_fit()`.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub fn into_boxed_slice(mut self) -> Box<[T]> { pub fn into_boxed_slice(mut self) -> Box<[T]> {
self.shrink_to_fit(); self.shrink_to_fit();
unsafe { unsafe {
@ -697,7 +697,7 @@ impl<T> Vec<T> {
/// assert_eq!(vec2, vec![]); /// assert_eq!(vec2, vec![]);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "new API, waiting for dust to settle")] reason = "new API, waiting for dust to settle")]
pub fn append(&mut self, other: &mut Self) { pub fn append(&mut self, other: &mut Self) {
if mem::size_of::<T>() == 0 { if mem::size_of::<T>() == 0 {
@ -734,7 +734,7 @@ impl<T> Vec<T> {
/// assert!(v.is_empty()); /// assert!(v.is_empty());
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, T> { pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
unsafe { unsafe {
@ -817,7 +817,7 @@ impl<T> Vec<T> {
/// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x)); /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
/// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice()); /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "API may change to provide stronger guarantees")] reason = "API may change to provide stronger guarantees")]
pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U { pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U {
// FIXME: Assert statically that the types `T` and `U` have the same // FIXME: Assert statically that the types `T` and `U` have the same
@ -1012,7 +1012,7 @@ impl<T: Clone> Vec<T> {
/// vec.resize(2, 0); /// vec.resize(2, 0);
/// assert_eq!(vec, vec![1, 2]); /// assert_eq!(vec, vec![1, 2]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting for dust to settle")] reason = "matches collection reform specification; waiting for dust to settle")]
pub fn resize(&mut self, new_len: uint, value: T) { pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len(); let len = self.len();
@ -1037,7 +1037,7 @@ impl<T: Clone> Vec<T> {
/// assert_eq!(vec, vec![1, 2, 3, 4]); /// assert_eq!(vec, vec![1, 2, 3, 4]);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "likely to be replaced by a more optimized extend")] reason = "likely to be replaced by a more optimized extend")]
pub fn push_all(&mut self, other: &[T]) { pub fn push_all(&mut self, other: &[T]) {
self.reserve(other.len()); self.reserve(other.len());
@ -1206,7 +1206,7 @@ unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
// Common trait implementations for Vec // Common trait implementations for Vec
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
impl<T:Clone> Clone for Vec<T> { impl<T:Clone> Clone for Vec<T> {
fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) } fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) }
@ -1235,7 +1235,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Index stability")] #[unstable(feature = "collections", reason = "waiting on Index stability")]
impl<T> Index<uint> for Vec<T> { impl<T> Index<uint> for Vec<T> {
type Output = T; type Output = T;
@ -1339,7 +1339,7 @@ impl<T> FromIterator<T> for Vec<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Extend stability")] #[unstable(feature = "collections", reason = "waiting on Extend stability")]
impl<T> Extend<T> for Vec<T> { impl<T> Extend<T> for Vec<T> {
#[inline] #[inline]
fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) { fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) {
@ -1414,7 +1414,7 @@ macro_rules! impl_eq_for_cowvec {
impl_eq_for_cowvec! { &'b [B] } impl_eq_for_cowvec! { &'b [B] }
impl_eq_for_cowvec! { &'b mut [B] } impl_eq_for_cowvec! { &'b mut [B] }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "waiting on PartialOrd stability")] reason = "waiting on PartialOrd stability")]
impl<T: PartialOrd> PartialOrd for Vec<T> { impl<T: PartialOrd> PartialOrd for Vec<T> {
#[inline] #[inline]
@ -1423,10 +1423,10 @@ impl<T: PartialOrd> PartialOrd for Vec<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Eq stability")] #[unstable(feature = "collections", reason = "waiting on Eq stability")]
impl<T: Eq> Eq for Vec<T> {} impl<T: Eq> Eq for Vec<T> {}
#[unstable(feature = "unnamed_feature", reason = "waiting on Ord stability")] #[unstable(feature = "collections", reason = "waiting on Ord stability")]
impl<T: Ord> Ord for Vec<T> { impl<T: Ord> Ord for Vec<T> {
#[inline] #[inline]
fn cmp(&self, other: &Vec<T>) -> Ordering { fn cmp(&self, other: &Vec<T>) -> Ordering {
@ -1457,7 +1457,7 @@ impl<T> AsSlice<T> for Vec<T> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "recent addition, needs more experience")] reason = "recent addition, needs more experience")]
impl<'a, T: Clone> Add<&'a [T]> for Vec<T> { impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
type Output = Vec<T>; type Output = Vec<T>;
@ -1494,7 +1494,7 @@ impl<T> Default for Vec<T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "waiting on Show stability")] #[unstable(feature = "collections", reason = "waiting on Show stability")]
impl<T: fmt::Show> fmt::Show for Vec<T> { impl<T: fmt::Show> fmt::Show for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(self.as_slice(), f) fmt::Show::fmt(self.as_slice(), f)
@ -1512,12 +1512,12 @@ impl<'a> fmt::Writer for Vec<u8> {
// Clone-on-write // Clone-on-write
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "unclear how valuable this alias is")] reason = "unclear how valuable this alias is")]
/// A clone-on-write vector /// A clone-on-write vector
pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>; pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>;
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone { impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> { fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
Cow::Owned(FromIterator::from_iter(it)) Cow::Owned(FromIterator::from_iter(it))
@ -1555,7 +1555,7 @@ unsafe impl<T: Sync> Sync for IntoIter<T> { }
impl<T> IntoIter<T> { impl<T> IntoIter<T> {
#[inline] #[inline]
/// Drops all items that have not yet been moved and returns the empty vector. /// Drops all items that have not yet been moved and returns the empty vector.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub fn into_inner(mut self) -> Vec<T> { pub fn into_inner(mut self) -> Vec<T> {
unsafe { unsafe {
for _x in self { } for _x in self { }
@ -1646,7 +1646,7 @@ impl<T> Drop for IntoIter<T> {
/// An iterator that drains a vector. /// An iterator that drains a vector.
#[unsafe_no_drop_flag] #[unsafe_no_drop_flag]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "recently added as part of collections reform 2")] reason = "recently added as part of collections reform 2")]
pub struct Drain<'a, T> { pub struct Drain<'a, T> {
ptr: *const T, ptr: *const T,
@ -1735,13 +1735,13 @@ impl<'a, T> Drop for Drain<'a, T> {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// Wrapper type providing a `&Vec<T>` reference via `Deref`. /// Wrapper type providing a `&Vec<T>` reference via `Deref`.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct DerefVec<'a, T> { pub struct DerefVec<'a, T> {
x: Vec<T>, x: Vec<T>,
l: ContravariantLifetime<'a> l: ContravariantLifetime<'a>
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
impl<'a, T> Deref for DerefVec<'a, T> { impl<'a, T> Deref for DerefVec<'a, T> {
type Target = Vec<T>; type Target = Vec<T>;
@ -1761,7 +1761,7 @@ impl<'a, T> Drop for DerefVec<'a, T> {
} }
/// Convert a slice to a wrapper type providing a `&Vec<T>` reference. /// Convert a slice to a wrapper type providing a `&Vec<T>` reference.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> {
unsafe { unsafe {
DerefVec { DerefVec {

8
src/libcollections/vec_map.rs
View file

@ -310,7 +310,7 @@ impl<V> VecMap<V> {
/// ///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, V> { pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> { fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
@ -700,7 +700,7 @@ pub struct IntoIter<V> {
fn((uint, Option<V>)) -> Option<(uint, V)>> fn((uint, Option<V>)) -> Option<(uint, V)>>
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
pub struct Drain<'a, V> { pub struct Drain<'a, V> {
iter: FilterMap< iter: FilterMap<
(uint, Option<V>), (uint, Option<V>),
@ -709,7 +709,7 @@ pub struct Drain<'a, V> {
fn((uint, Option<V>)) -> Option<(uint, V)>> fn((uint, Option<V>)) -> Option<(uint, V)>>
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
impl<'a, V> Iterator for Drain<'a, V> { impl<'a, V> Iterator for Drain<'a, V> {
type Item = (uint, V); type Item = (uint, V);
@ -717,7 +717,7 @@ impl<'a, V> Iterator for Drain<'a, V> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() } fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "collections")]
impl<'a, V> DoubleEndedIterator for Drain<'a, V> { impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() } fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
} }

4
src/libcore/any.rs
View file

@ -89,7 +89,7 @@ use intrinsics;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Any: 'static { pub trait Any: 'static {
/// Get the `TypeId` of `self` /// Get the `TypeId` of `self`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "this method will likely be replaced by an associated static")] reason = "this method will likely be replaced by an associated static")]
fn get_type_id(&self) -> TypeId; fn get_type_id(&self) -> TypeId;
} }
@ -177,7 +177,7 @@ impl TypeId {
/// Returns the `TypeId` of the type this generic function has been /// Returns the `TypeId` of the type this generic function has been
/// instantiated with /// instantiated with
#[cfg(not(stage0))] #[cfg(not(stage0))]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may grow a `Reflect` bound soon via marker traits")] reason = "may grow a `Reflect` bound soon via marker traits")]
pub fn of<T: ?Sized + 'static>() -> TypeId { pub fn of<T: ?Sized + 'static>() -> TypeId {
TypeId { TypeId {

4
src/libcore/array.rs
View file

@ -12,7 +12,7 @@
//! up to a certain length. Eventually we should able to generalize //! up to a certain length. Eventually we should able to generalize
//! to all lengths. //! to all lengths.
#![unstable(feature = "unnamed_feature")] // not yet reviewed #![unstable(feature = "core")] // not yet reviewed
use clone::Clone; use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
@ -39,7 +39,7 @@ macro_rules! array_impls {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting for Show to stabilize")] reason = "waiting for Show to stabilize")]
impl<T:fmt::Show> fmt::Show for [T; $N] { impl<T:fmt::Show> fmt::Show for [T; $N] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

8
src/libcore/atomic.rs
View file

@ -1036,7 +1036,7 @@ pub fn fence(order: Ordering) {
} }
} }
#[deprecated(feature = "unnamed_feature", since = "1.0.0", #[deprecated(feature = "core", since = "1.0.0",
reason = "renamed to AtomicIsize")] reason = "renamed to AtomicIsize")]
#[allow(missing_docs)] #[allow(missing_docs)]
pub struct AtomicInt { pub struct AtomicInt {
@ -1045,7 +1045,7 @@ pub struct AtomicInt {
unsafe impl Sync for AtomicInt {} unsafe impl Sync for AtomicInt {}
#[deprecated(feature = "unnamed_feature", since = "1.0.0", #[deprecated(feature = "core", since = "1.0.0",
reason = "renamed to AtomicUsize")] reason = "renamed to AtomicUsize")]
#[allow(missing_docs)] #[allow(missing_docs)]
pub struct AtomicUint { pub struct AtomicUint {
@ -1054,12 +1054,12 @@ pub struct AtomicUint {
unsafe impl Sync for AtomicUint {} unsafe impl Sync for AtomicUint {}
#[deprecated(feature = "unnamed_feature", since = "1.0.0", #[deprecated(feature = "core", since = "1.0.0",
reason = "use ATOMIC_ISIZE_INIT instead")] reason = "use ATOMIC_ISIZE_INIT instead")]
#[allow(missing_docs, deprecated)] #[allow(missing_docs, deprecated)]
pub const ATOMIC_INT_INIT: AtomicInt = pub const ATOMIC_INT_INIT: AtomicInt =
AtomicInt { v: UnsafeCell { value: 0 } }; AtomicInt { v: UnsafeCell { value: 0 } };
#[deprecated(feature = "unnamed_feature", since = "1.0.0", #[deprecated(feature = "core", since = "1.0.0",
reason = "use ATOMIC_USIZE_INIT instead")] reason = "use ATOMIC_USIZE_INIT instead")]
#[allow(missing_docs, deprecated)] #[allow(missing_docs, deprecated)]
pub const ATOMIC_UINT_INIT: AtomicUint = pub const ATOMIC_UINT_INIT: AtomicUint =

2
src/libcore/borrow.rs
View file

@ -42,7 +42,7 @@
//! is desired, `to_mut` will obtain a mutable references to an owned //! is desired, `to_mut` will obtain a mutable references to an owned
//! value, cloning if necessary. //! value, cloning if necessary.
#![unstable(feature = "unnamed_feature", #![unstable(feature = "core",
reason = "recently added as part of collections reform")] reason = "recently added as part of collections reform")]
use clone::Clone; use clone::Clone;

12
src/libcore/cell.rs
View file

@ -201,7 +201,7 @@ impl<T:Copy> Cell<T> {
/// ///
/// This function is `unsafe` because `UnsafeCell`'s field is public. /// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value &self.value
} }
@ -271,7 +271,7 @@ impl<T> RefCell<T> {
/// immutable borrows can be taken out at the same time. /// immutable borrows can be taken out at the same time.
/// ///
/// Returns `None` if the value is currently mutably borrowed. /// Returns `None` if the value is currently mutably borrowed.
#[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] #[unstable(feature = "core", reason = "may be renamed or removed")]
pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> { pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> {
match BorrowRef::new(&self.borrow) { match BorrowRef::new(&self.borrow) {
Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }), Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }),
@ -301,7 +301,7 @@ impl<T> RefCell<T> {
/// cannot be borrowed while this borrow is active. /// cannot be borrowed while this borrow is active.
/// ///
/// Returns `None` if the value is currently borrowed. /// Returns `None` if the value is currently borrowed.
#[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] #[unstable(feature = "core", reason = "may be renamed or removed")]
pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> { pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> {
match BorrowRefMut::new(&self.borrow) { match BorrowRefMut::new(&self.borrow) {
Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }), Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }),
@ -331,7 +331,7 @@ impl<T> RefCell<T> {
/// ///
/// This function is `unsafe` because `UnsafeCell`'s field is public. /// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value &self.value
} }
@ -423,7 +423,7 @@ impl<'b, T> Deref for Ref<'b, T> {
/// ///
/// A `Clone` implementation would interfere with the widespread /// A `Clone` implementation would interfere with the widespread
/// use of `r.borrow().clone()` to clone the contents of a `RefCell`. /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be moved to a method, pending language changes")] reason = "likely to be moved to a method, pending language changes")]
pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> { pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> {
Ref { Ref {
@ -528,7 +528,7 @@ pub struct UnsafeCell<T> {
/// ///
/// This field should not be accessed directly, it is made public for static /// This field should not be accessed directly, it is made public for static
/// initializers. /// initializers.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub value: T, pub value: T,
} }

18
src/libcore/char.rs
View file

@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> {
/// Panics if given an `radix` > 36. /// Panics if given an `radix` > 36.
/// ///
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub fn from_digit(num: uint, radix: uint) -> Option<char> { pub fn from_digit(num: uint, radix: uint) -> Option<char> {
if radix > 36 { if radix > 36 {
panic!("from_digit: radix is too high (maximum 36)"); panic!("from_digit: radix is too high (maximum 36)");
@ -126,7 +126,7 @@ pub trait CharExt {
/// # Panics /// # Panics
/// ///
/// Panics if given a radix > 36. /// Panics if given a radix > 36.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool; fn is_digit(self, radix: uint) -> bool;
@ -141,7 +141,7 @@ pub trait CharExt {
/// # Panics /// # Panics
/// ///
/// Panics if given a radix outside the range [0..36]. /// Panics if given a radix outside the range [0..36].
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint>; fn to_digit(self, radix: uint) -> Option<uint>;
@ -198,13 +198,13 @@ pub trait CharExt {
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
impl CharExt for char { impl CharExt for char {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool { fn is_digit(self, radix: uint) -> bool {
self.to_digit(radix).is_some() self.to_digit(radix).is_some()
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint> { fn to_digit(self, radix: uint) -> Option<uint> {
if radix > 36 { if radix > 36 {
@ -260,7 +260,7 @@ impl CharExt for char {
} }
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending decision about Iterator/Writer/Reader")] reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away // Marked #[inline] to allow llvm optimizing it away
@ -289,7 +289,7 @@ impl CharExt for char {
} }
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending decision about Iterator/Writer/Reader")] reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away // Marked #[inline] to allow llvm optimizing it away
@ -320,7 +320,7 @@ pub struct EscapeUnicode {
} }
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
enum EscapeUnicodeState { enum EscapeUnicodeState {
Backslash, Backslash,
Type, Type,
@ -382,7 +382,7 @@ pub struct EscapeDefault {
} }
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
enum EscapeDefaultState { enum EscapeDefaultState {
Backslash(char), Backslash(char),
Char(char), Char(char),

4
src/libcore/clone.rs
View file

@ -36,7 +36,7 @@ pub trait Clone : Sized {
/// but can be overridden to reuse the resources of `a` to avoid unnecessary /// but can be overridden to reuse the resources of `a` to avoid unnecessary
/// allocations. /// allocations.
#[inline(always)] #[inline(always)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "this function is rarely used")] reason = "this function is rarely used")]
fn clone_from(&mut self, source: &Self) { fn clone_from(&mut self, source: &Self) {
*self = source.clone() *self = source.clone()
@ -82,7 +82,7 @@ clone_impl! { char }
macro_rules! extern_fn_clone { macro_rules! extern_fn_clone {
($($A:ident),*) => ( ($($A:ident),*) => (
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "this may not be sufficient for fns with region parameters")] reason = "this may not be sufficient for fns with region parameters")]
impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType { impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
/// Return a copy of a function pointer /// Return a copy of a function pointer

4
src/libcore/cmp.rs
View file

@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
/// ///
/// Returns the first argument if the comparison determines them to be equal. /// Returns the first argument if the comparison determines them to be equal.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) { match v1.partial_cmp(&v2) {
Some(Less) | Some(Equal) => Some(v1), Some(Less) | Some(Equal) => Some(v1),
@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
/// ///
/// Returns the first argument if the comparison determines them to be equal. /// Returns the first argument if the comparison determines them to be equal.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> { pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) { match v1.partial_cmp(&v2) {
Some(Less) => Some(v2), Some(Less) => Some(v2),

2
src/libcore/finally.rs
View file

@ -30,7 +30,7 @@
//! }) //! })
//! ``` //! ```
#![deprecated(feature = "unnamed_feature", since = "1.0.0", #![deprecated(feature = "core", since = "1.0.0",
reason = "It is unclear if this module is more robust than implementing \ reason = "It is unclear if this module is more robust than implementing \
Drop on a custom type, and this module is being removed with no \ Drop on a custom type, and this module is being removed with no \
replacement. Use a custom Drop implementation to regain existing \ replacement. Use a custom Drop implementation to regain existing \

58
src/libcore/fmt/mod.rs
View file

@ -36,7 +36,7 @@ mod num;
mod float; mod float;
pub mod rt; pub mod rt;
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "core and I/O reconciliation may alter this definition")] reason = "core and I/O reconciliation may alter this definition")]
/// The type returned by formatter methods. /// The type returned by formatter methods.
pub type Result = result::Result<(), Error>; pub type Result = result::Result<(), Error>;
@ -46,7 +46,7 @@ pub type Result = result::Result<(), Error>;
/// This type does not support transmission of an error other than that an error /// This type does not support transmission of an error other than that an error
/// occurred. Any extra information must be arranged to be transmitted through /// occurred. Any extra information must be arranged to be transmitted through
/// some other means. /// some other means.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "core and I/O reconciliation may alter this definition")] reason = "core and I/O reconciliation may alter this definition")]
#[derive(Copy)] #[derive(Copy)]
pub struct Error; pub struct Error;
@ -60,7 +60,7 @@ pub struct Error;
/// This trait should generally not be implemented by consumers of the standard /// This trait should generally not be implemented by consumers of the standard
/// library. The `write!` macro accepts an instance of `io::Writer`, and the /// library. The `write!` macro accepts an instance of `io::Writer`, and the
/// `io::Writer` trait is favored over implementing this trait. /// `io::Writer` trait is favored over implementing this trait.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting for core and I/O reconciliation")] reason = "waiting for core and I/O reconciliation")]
pub trait Writer { pub trait Writer {
/// Writes a slice of bytes into this writer, returning whether the write /// Writes a slice of bytes into this writer, returning whether the write
@ -104,7 +104,7 @@ pub trait Writer {
/// A struct to represent both where to emit formatting strings to and how they /// A struct to represent both where to emit formatting strings to and how they
/// should be formatted. A mutable version of this is passed to all formatting /// should be formatted. A mutable version of this is passed to all formatting
/// traits. /// traits.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "name may change and implemented traits are also unstable")] reason = "name may change and implemented traits are also unstable")]
pub struct Formatter<'a> { pub struct Formatter<'a> {
flags: uint, flags: uint,
@ -127,7 +127,7 @@ enum Void {}
/// family of functions. It contains a function to format the given value. At /// family of functions. It contains a function to format the given value. At
/// compile time it is ensured that the function and the value have the correct /// compile time it is ensured that the function and the value have the correct
/// types, and then this struct is used to canonicalize arguments to one type. /// types, and then this struct is used to canonicalize arguments to one type.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
#[derive(Copy)] #[derive(Copy)]
pub struct Argument<'a> { pub struct Argument<'a> {
@ -167,7 +167,7 @@ impl<'a> Arguments<'a> {
/// When using the format_args!() macro, this function is used to generate the /// When using the format_args!() macro, this function is used to generate the
/// Arguments structure. /// Arguments structure.
#[doc(hidden)] #[inline] #[doc(hidden)] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
pub fn new(pieces: &'a [&'a str], pub fn new(pieces: &'a [&'a str],
args: &'a [Argument<'a>]) -> Arguments<'a> { args: &'a [Argument<'a>]) -> Arguments<'a> {
@ -185,7 +185,7 @@ impl<'a> Arguments<'a> {
/// created with `argumentuint`. However, failing to do so doesn't cause /// created with `argumentuint`. However, failing to do so doesn't cause
/// unsafety, but will ignore invalid . /// unsafety, but will ignore invalid .
#[doc(hidden)] #[inline] #[doc(hidden)] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
pub fn with_placeholders(pieces: &'a [&'a str], pub fn with_placeholders(pieces: &'a [&'a str],
fmt: &'a [rt::Argument], fmt: &'a [rt::Argument],
@ -236,7 +236,7 @@ impl<'a> String for Arguments<'a> {
/// Format trait for the `:?` format. Useful for debugging, most all types /// Format trait for the `:?` format. Useful for debugging, most all types
/// should implement this. /// should implement this.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait Show { pub trait Show {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -245,7 +245,7 @@ pub trait Show {
/// When a value can be semantically expressed as a String, this trait may be /// When a value can be semantically expressed as a String, this trait may be
/// used. It corresponds to the default format, `{}`. /// used. It corresponds to the default format, `{}`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait String { pub trait String {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -254,7 +254,7 @@ pub trait String {
/// Format trait for the `o` character /// Format trait for the `o` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait Octal { pub trait Octal {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -262,7 +262,7 @@ pub trait Octal {
} }
/// Format trait for the `b` character /// Format trait for the `b` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait Binary { pub trait Binary {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -270,7 +270,7 @@ pub trait Binary {
} }
/// Format trait for the `x` character /// Format trait for the `x` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait LowerHex { pub trait LowerHex {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -278,7 +278,7 @@ pub trait LowerHex {
} }
/// Format trait for the `X` character /// Format trait for the `X` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait UpperHex { pub trait UpperHex {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -286,7 +286,7 @@ pub trait UpperHex {
} }
/// Format trait for the `p` character /// Format trait for the `p` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait Pointer { pub trait Pointer {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -294,7 +294,7 @@ pub trait Pointer {
} }
/// Format trait for the `e` character /// Format trait for the `e` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait LowerExp { pub trait LowerExp {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -302,7 +302,7 @@ pub trait LowerExp {
} }
/// Format trait for the `E` character /// Format trait for the `E` character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")] reason = "I/O and core have yet to be reconciled")]
pub trait UpperExp { pub trait UpperExp {
/// Formats the value using the given formatter. /// Formats the value using the given formatter.
@ -317,7 +317,7 @@ pub trait UpperExp {
/// ///
/// * output - the buffer to write output to /// * output - the buffer to write output to
/// * args - the precompiled arguments generated by `format_args!` /// * args - the precompiled arguments generated by `format_args!`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "libcore and I/O have yet to be reconciled, and this is an \ reason = "libcore and I/O have yet to be reconciled, and this is an \
implementation detail which should not otherwise be exported")] implementation detail which should not otherwise be exported")]
pub fn write(output: &mut Writer, args: Arguments) -> Result { pub fn write(output: &mut Writer, args: Arguments) -> Result {
@ -415,7 +415,7 @@ impl<'a> Formatter<'a> {
/// ///
/// This function will correctly account for the flags provided as well as /// This function will correctly account for the flags provided as well as
/// the minimum width. It will not take precision into account. /// the minimum width. It will not take precision into account.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "definition may change slightly over time")] reason = "definition may change slightly over time")]
pub fn pad_integral(&mut self, pub fn pad_integral(&mut self,
is_positive: bool, is_positive: bool,
@ -492,7 +492,7 @@ impl<'a> Formatter<'a> {
/// is longer than this length /// is longer than this length
/// ///
/// Notably this function ignored the `flag` parameters /// Notably this function ignored the `flag` parameters
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "definition may change slightly over time")] reason = "definition may change slightly over time")]
pub fn pad(&mut self, s: &str) -> Result { pub fn pad(&mut self, s: &str) -> Result {
// Make sure there's a fast path up front // Make sure there's a fast path up front
@ -570,38 +570,38 @@ impl<'a> Formatter<'a> {
/// Writes some data to the underlying buffer contained within this /// Writes some data to the underlying buffer contained within this
/// formatter. /// formatter.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "reconciling core and I/O may alter this definition")] reason = "reconciling core and I/O may alter this definition")]
pub fn write_str(&mut self, data: &str) -> Result { pub fn write_str(&mut self, data: &str) -> Result {
self.buf.write_str(data) self.buf.write_str(data)
} }
/// Writes some formatted information into this instance /// Writes some formatted information into this instance
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "reconciling core and I/O may alter this definition")] reason = "reconciling core and I/O may alter this definition")]
pub fn write_fmt(&mut self, fmt: Arguments) -> Result { pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
write(self.buf, fmt) write(self.buf, fmt)
} }
/// Flags for formatting (packed version of rt::Flag) /// Flags for formatting (packed version of rt::Flag)
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "return type may change and method was just created")] reason = "return type may change and method was just created")]
pub fn flags(&self) -> uint { self.flags } pub fn flags(&self) -> uint { self.flags }
/// Character used as 'fill' whenever there is alignment /// Character used as 'fill' whenever there is alignment
#[unstable(feature = "unnamed_feature", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn fill(&self) -> char { self.fill } pub fn fill(&self) -> char { self.fill }
/// Flag indicating what form of alignment was requested /// Flag indicating what form of alignment was requested
#[unstable(feature = "unnamed_feature", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn align(&self) -> rt::Alignment { self.align } pub fn align(&self) -> rt::Alignment { self.align }
/// Optionally specified integer width that the output should be /// Optionally specified integer width that the output should be
#[unstable(feature = "unnamed_feature", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn width(&self) -> Option<uint> { self.width } pub fn width(&self) -> Option<uint> { self.width }
/// Optionally specified precision for numeric types /// Optionally specified precision for numeric types
#[unstable(feature = "unnamed_feature", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn precision(&self) -> Option<uint> { self.precision } pub fn precision(&self) -> Option<uint> { self.precision }
} }
@ -614,7 +614,7 @@ impl Show for Error {
/// This is a function which calls are emitted to by the compiler itself to /// This is a function which calls are emitted to by the compiler itself to
/// create the Argument structures that are passed into the `format` function. /// create the Argument structures that are passed into the `format` function.
#[doc(hidden)] #[inline] #[doc(hidden)] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
t: &'a T) -> Argument<'a> { t: &'a T) -> Argument<'a> {
@ -624,7 +624,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
/// When the compiler determines that the type of an argument *must* be a uint /// When the compiler determines that the type of an argument *must* be a uint
/// (such as for width and precision), then it invokes this method. /// (such as for width and precision), then it invokes this method.
#[doc(hidden)] #[inline] #[doc(hidden)] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
Argument::from_uint(s) Argument::from_uint(s)
@ -879,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> {
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<T: Show> Show for RefCell<T> { impl<T: Show> Show for RefCell<T> {
fn fmt(&self, f: &mut Formatter) -> Result { fn fmt(&self, f: &mut Formatter) -> Result {
match self.try_borrow() { match self.try_borrow() {

6
src/libcore/fmt/num.rs
View file

@ -111,7 +111,7 @@ radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x,
/// A radix with in the range of `2..36`. /// A radix with in the range of `2..36`.
#[derive(Clone, Copy, PartialEq)] #[derive(Clone, Copy, PartialEq)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may be renamed or move to a different module")] reason = "may be renamed or move to a different module")]
pub struct Radix { pub struct Radix {
base: u8, base: u8,
@ -136,7 +136,7 @@ impl GenericRadix for Radix {
} }
/// A helper type for formatting radixes. /// A helper type for formatting radixes.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may be renamed or move to a different module")] reason = "may be renamed or move to a different module")]
#[derive(Copy)] #[derive(Copy)]
pub struct RadixFmt<T, R>(T, R); pub struct RadixFmt<T, R>(T, R);
@ -149,7 +149,7 @@ pub struct RadixFmt<T, R>(T, R);
/// use std::fmt::radix; /// use std::fmt::radix;
/// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string()); /// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may be renamed or move to a different module")] reason = "may be renamed or move to a different module")]
pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> { pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
RadixFmt(x, Radix::new(base)) RadixFmt(x, Radix::new(base))

2
src/libcore/fmt/rt.rs
View file

@ -14,7 +14,7 @@
//! These definitions are similar to their `ct` equivalents, but differ in that //! These definitions are similar to their `ct` equivalents, but differ in that
//! these can be statically allocated and are slightly optimized for the runtime //! these can be statically allocated and are slightly optimized for the runtime
#![unstable(feature = "unnamed_feature", #![unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")] reason = "implementation detail of the `format_args!` macro")]
pub use self::Alignment::*; pub use self::Alignment::*;

4
src/libcore/hash/mod.rs
View file

@ -56,7 +56,7 @@
//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2)); //! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
//! ``` //! ```
#![unstable(feature = "unnamed_feature", #![unstable(feature = "hash",
reason = "module was recently redesigned")] reason = "module was recently redesigned")]
use prelude::*; use prelude::*;
@ -96,7 +96,7 @@ pub trait Hasher {
/// A common bound on the `Hasher` parameter to `Hash` implementations in order /// A common bound on the `Hasher` parameter to `Hash` implementations in order
/// to generically hash an aggregate. /// to generically hash an aggregate.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "hash",
reason = "this trait will likely be replaced by io::Writer")] reason = "this trait will likely be replaced by io::Writer")]
#[allow(missing_docs)] #[allow(missing_docs)]
pub trait Writer { pub trait Writer {

8
src/libcore/intrinsics.rs
View file

@ -39,7 +39,7 @@
//! guaranteed to happen in order. This is the standard mode for working //! guaranteed to happen in order. This is the standard mode for working
//! with atomic types and is equivalent to Java's `volatile`. //! with atomic types and is equivalent to Java's `volatile`.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "core")]
#![allow(missing_docs)] #![allow(missing_docs)]
use marker::Sized; use marker::Sized;
@ -303,7 +303,7 @@ extern "rust-intrinsic" {
/// } /// }
/// } /// }
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint); pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
@ -333,12 +333,12 @@ extern "rust-intrinsic" {
/// } /// }
/// ``` /// ```
/// ///
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint); pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()` /// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`. /// bytes of memory starting at `dst` to `c`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about naming and semantics")] reason = "uncertain about naming and semantics")]
pub fn set_memory<T>(dst: *mut T, val: u8, count: uint); pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);

102
src/libcore/iter.rs
View file

@ -564,7 +564,7 @@ pub trait IteratorExt: Iterator + Sized {
/// assert_eq!(even, vec![2, 4]); /// assert_eq!(even, vec![2, 4]);
/// assert_eq!(odd, vec![1, 3]); /// assert_eq!(odd, vec![1, 3]);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added as part of collections reform")] reason = "recently added as part of collections reform")]
fn partition<B, F>(mut self, mut f: F) -> (B, B) where fn partition<B, F>(mut self, mut f: F) -> (B, B) where
B: Default + Extend<Self::Item>, B: Default + Extend<Self::Item>,
@ -760,7 +760,7 @@ pub trait IteratorExt: Iterator + Sized {
/// let v = [1i, 1, 1, 1]; /// let v = [1i, 1, 1, 1];
/// assert!(v.iter().min_max() == MinMax(&1, &1)); /// assert!(v.iter().min_max() == MinMax(&1, &1));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", reason = "return type may change")] #[unstable(feature = "core", reason = "return type may change")]
fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord
{ {
let (mut min, mut max) = match self.next() { let (mut min, mut max) = match self.next() {
@ -817,7 +817,7 @@ pub trait IteratorExt: Iterator + Sized {
/// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")] reason = "may want to produce an Ordering directly; see #15311")]
fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B, F: FnMut(&Self::Item) -> B,
@ -847,7 +847,7 @@ pub trait IteratorExt: Iterator + Sized {
/// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")] reason = "may want to produce an Ordering directly; see #15311")]
fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B, F: FnMut(&Self::Item) -> B,
@ -887,7 +887,7 @@ pub trait IteratorExt: Iterator + Sized {
/// ///
/// Loops through the entire iterator, collecting the first component of /// Loops through the entire iterator, collecting the first component of
/// each item into one new container, and the second component into another. /// each item into one new container, and the second component into another.
#[unstable(feature = "unnamed_feature", reason = "recent addition")] #[unstable(feature = "core", reason = "recent addition")]
fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where
FromA: Default + Extend<A>, FromA: Default + Extend<A>,
FromB: Default + Extend<B>, FromB: Default + Extend<B>,
@ -920,7 +920,7 @@ pub trait IteratorExt: Iterator + Sized {
/// Creates an iterator that clones the elements it yields. Useful for converting an /// Creates an iterator that clones the elements it yields. Useful for converting an
/// Iterator<&T> to an Iterator<T>. /// Iterator<&T> to an Iterator<T>.
#[unstable(feature = "unnamed_feature", reason = "recent addition")] #[unstable(feature = "core", reason = "recent addition")]
fn cloned<T, D>(self) -> Cloned<Self> where fn cloned<T, D>(self) -> Cloned<Self> where
Self: Iterator<Item=D>, Self: Iterator<Item=D>,
D: Deref<Target=T>, D: Deref<Target=T>,
@ -948,7 +948,7 @@ pub trait IteratorExt: Iterator + Sized {
} }
/// Use an iterator to reverse a container in place. /// Use an iterator to reverse a container in place.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about placement or widespread use")] reason = "uncertain about placement or widespread use")]
fn reverse_in_place<'a, T: 'a>(&mut self) where fn reverse_in_place<'a, T: 'a>(&mut self) where
Self: Iterator<Item=&'a mut T> + DoubleEndedIterator Self: Iterator<Item=&'a mut T> + DoubleEndedIterator
@ -982,7 +982,7 @@ pub trait DoubleEndedIterator: Iterator {
/// Calling `next()` or `next_back()` on a `RandomAccessIterator` /// Calling `next()` or `next_back()` on a `RandomAccessIterator`
/// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)` /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)`
/// after `it.next()` is called. /// after `it.next()` is called.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "not widely used, may be better decomposed into Index and ExactSizeIterator")] reason = "not widely used, may be better decomposed into Index and ExactSizeIterator")]
pub trait RandomAccessIterator: Iterator { pub trait RandomAccessIterator: Iterator {
/// Return the number of indexable elements. At most `std::uint::MAX` /// Return the number of indexable elements. At most `std::uint::MAX`
@ -1058,7 +1058,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() } fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator { impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator {
#[inline] #[inline]
fn indexable(&self) -> uint { self.iter.indexable() } fn indexable(&self) -> uint { self.iter.indexable() }
@ -1093,7 +1093,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat
} }
/// A trait for iterators over elements which can be added together /// A trait for iterators over elements which can be added together
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "needs to be re-evaluated as part of numerics reform")] reason = "needs to be re-evaluated as part of numerics reform")]
pub trait AdditiveIterator<A> { pub trait AdditiveIterator<A> {
/// Iterates over the entire iterator, summing up all the elements /// Iterates over the entire iterator, summing up all the elements
@ -1112,7 +1112,7 @@ pub trait AdditiveIterator<A> {
macro_rules! impl_additive { macro_rules! impl_additive {
($A:ty, $init:expr) => { ($A:ty, $init:expr) => {
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T { impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T {
#[inline] #[inline]
fn sum(self) -> $A { fn sum(self) -> $A {
@ -1135,7 +1135,7 @@ impl_additive! { f32, 0.0 }
impl_additive! { f64, 0.0 } impl_additive! { f64, 0.0 }
/// A trait for iterators over elements which can be multiplied together. /// A trait for iterators over elements which can be multiplied together.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "needs to be re-evaluated as part of numerics reform")] reason = "needs to be re-evaluated as part of numerics reform")]
pub trait MultiplicativeIterator<A> { pub trait MultiplicativeIterator<A> {
/// Iterates over the entire iterator, multiplying all the elements /// Iterates over the entire iterator, multiplying all the elements
@ -1157,7 +1157,7 @@ pub trait MultiplicativeIterator<A> {
macro_rules! impl_multiplicative { macro_rules! impl_multiplicative {
($A:ty, $init:expr) => { ($A:ty, $init:expr) => {
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T { impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T {
#[inline] #[inline]
fn product(self) -> $A { fn product(self) -> $A {
@ -1181,7 +1181,7 @@ impl_multiplicative! { f64, 1.0 }
/// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail. /// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail.
#[derive(Clone, PartialEq, Show)] #[derive(Clone, PartialEq, Show)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "unclear whether such a fine-grained result is widely useful")] reason = "unclear whether such a fine-grained result is widely useful")]
pub enum MinMaxResult<T> { pub enum MinMaxResult<T> {
/// Empty iterator /// Empty iterator
@ -1214,7 +1214,7 @@ impl<T: Clone> MinMaxResult<T> {
/// let r = MinMax(1i,2i); /// let r = MinMax(1i,2i);
/// assert_eq!(r.into_option(), Some((1,2))); /// assert_eq!(r.into_option(), Some((1,2)));
/// ``` /// ```
#[unstable(feature = "unnamed_feature", reason = "type is unstable")] #[unstable(feature = "core", reason = "type is unstable")]
pub fn into_option(self) -> Option<(T,T)> { pub fn into_option(self) -> Option<(T,T)> {
match self { match self {
NoElements => None, NoElements => None,
@ -1225,7 +1225,7 @@ impl<T: Clone> MinMaxResult<T> {
} }
/// An iterator that clones the elements of an underlying iterator /// An iterator that clones the elements of an underlying iterator
#[unstable(feature = "unnamed_feature", reason = "recent addition")] #[unstable(feature = "core", reason = "recent addition")]
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[derive(Clone)] #[derive(Clone)]
pub struct Cloned<I> { pub struct Cloned<I> {
@ -1299,7 +1299,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Cycle<I> where impl<I> RandomAccessIterator for Cycle<I> where
I: Clone + RandomAccessIterator, I: Clone + RandomAccessIterator,
{ {
@ -1384,7 +1384,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<T, A, B> RandomAccessIterator for Chain<A, B> where impl<T, A, B> RandomAccessIterator for Chain<A, B> where
A: RandomAccessIterator<Item=T>, A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=T>,
@ -1476,7 +1476,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
A: RandomAccessIterator<Item=T>, A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=U>, B: RandomAccessIterator<Item=U>,
@ -1558,7 +1558,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
I: RandomAccessIterator<Item=A>, I: RandomAccessIterator<Item=A>,
F: FnMut(A) -> B, F: FnMut(A) -> B,
@ -1747,7 +1747,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator { impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -1973,7 +1973,7 @@ impl<I> Iterator for Skip<I> where I: Iterator {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{ impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -2028,7 +2028,7 @@ impl<I> Iterator for Take<I> where I: Iterator{
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{ impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -2241,7 +2241,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
} }
// Allow RandomAccessIterators to be fused without affecting random-access behavior // Allow RandomAccessIterators to be fused without affecting random-access behavior
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator { impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator {
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -2258,7 +2258,7 @@ impl<I> Fuse<I> {
/// Resets the fuse such that the next call to .next() or .next_back() will /// Resets the fuse such that the next call to .next() or .next_back() will
/// call the underlying iterator again even if it previously returned None. /// call the underlying iterator again even if it previously returned None.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "seems marginal")] #[unstable(feature = "core", reason = "seems marginal")]
pub fn reset_fuse(&mut self) { pub fn reset_fuse(&mut self) {
self.done = false self.done = false
} }
@ -2327,7 +2327,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
I: RandomAccessIterator<Item=A>, I: RandomAccessIterator<Item=A>,
F: FnMut(&A), F: FnMut(&A),
@ -2376,7 +2376,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
/// println!("{}", i); /// println!("{}", i);
/// } /// }
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
f: F, f: F,
/// Internal state that will be passed to the closure on the next iteration /// Internal state that will be passed to the closure on the next iteration
@ -2397,7 +2397,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
/// Creates a new iterator with the specified closure as the "iterator /// Creates a new iterator with the specified closure as the "iterator
/// function" and an initial state to eventually pass to the closure /// function" and an initial state to eventually pass to the closure
@ -2429,7 +2429,7 @@ impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A
/// An infinite iterator starting at `start` and advancing by `step` with each /// An infinite iterator starting at `start` and advancing by `step` with each
/// iteration /// iteration
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may be renamed or replaced by range notation adapaters")] reason = "may be renamed or replaced by range notation adapaters")]
pub struct Counter<A> { pub struct Counter<A> {
/// The current state the counter is at (next value to be yielded) /// The current state the counter is at (next value to be yielded)
@ -2440,7 +2440,7 @@ pub struct Counter<A> {
/// Creates a new counter with the specified start/step /// Creates a new counter with the specified start/step
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may be renamed or replaced by range notation adapaters")] reason = "may be renamed or replaced by range notation adapaters")]
pub fn count<A>(start: A, step: A) -> Counter<A> { pub fn count<A>(start: A, step: A) -> Counter<A> {
Counter{state: start, step: step} Counter{state: start, step: step}
@ -2465,7 +2465,7 @@ impl<A: Add<Output=A> + Clone> Iterator for Counter<A> {
/// An iterator over the range [start, stop) /// An iterator over the range [start, stop)
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be replaced by range notation")] reason = "will be replaced by range notation")]
pub struct Range<A> { pub struct Range<A> {
state: A, state: A,
@ -2487,7 +2487,7 @@ pub struct Range<A> {
/// } /// }
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be replaced by range notation")] reason = "will be replaced by range notation")]
pub fn range<A: Int>(start: A, stop: A) -> Range<A> { pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
Range { Range {
@ -2498,7 +2498,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
} }
// FIXME: #10414: Unfortunate type bound // FIXME: #10414: Unfortunate type bound
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be replaced by range notation")] reason = "will be replaced by range notation")]
impl<A: Int + ToPrimitive> Iterator for Range<A> { impl<A: Int + ToPrimitive> Iterator for Range<A> {
type Item = A; type Item = A;
@ -2549,7 +2549,7 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> {
/// `Int` is required to ensure the range will be the same regardless of /// `Int` is required to ensure the range will be the same regardless of
/// the direction it is consumed. /// the direction it is consumed.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be replaced by range notation")] reason = "will be replaced by range notation")]
impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> { impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
#[inline] #[inline]
@ -2565,7 +2565,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
/// An iterator over the range [start, stop] /// An iterator over the range [start, stop]
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub struct RangeInclusive<A> { pub struct RangeInclusive<A> {
range: Range<A>, range: Range<A>,
@ -2574,7 +2574,7 @@ pub struct RangeInclusive<A> {
/// Return an iterator over the range [start, stop] /// Return an iterator over the range [start, stop]
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
RangeInclusive { RangeInclusive {
@ -2583,7 +2583,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> { impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
type Item = A; type Item = A;
@ -2619,7 +2619,7 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> { impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
#[inline] #[inline]
@ -2639,7 +2639,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub struct RangeStep<A> { pub struct RangeStep<A> {
state: A, state: A,
@ -2650,14 +2650,14 @@ pub struct RangeStep<A> {
/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping. /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> { pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
let rev = step < Int::zero(); let rev = step < Int::zero();
RangeStep{state: start, stop: stop, step: step, rev: rev} RangeStep{state: start, stop: stop, step: step, rev: rev}
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
impl<A: Int> Iterator for RangeStep<A> { impl<A: Int> Iterator for RangeStep<A> {
type Item = A; type Item = A;
@ -2679,7 +2679,7 @@ impl<A: Int> Iterator for RangeStep<A> {
/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping. /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub struct RangeStepInclusive<A> { pub struct RangeStepInclusive<A> {
state: A, state: A,
@ -2691,7 +2691,7 @@ pub struct RangeStepInclusive<A> {
/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping. /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> {
let rev = step < Int::zero(); let rev = step < Int::zero();
@ -2704,7 +2704,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")] reason = "likely to be replaced by range notation and adapters")]
impl<A: Int> Iterator for RangeStepInclusive<A> { impl<A: Int> Iterator for RangeStepInclusive<A> {
type Item = A; type Item = A;
@ -2730,7 +2730,7 @@ impl<A: Int> Iterator for RangeStepInclusive<A> {
/// directions. The `steps_between` function provides a way to /// directions. The `steps_between` function provides a way to
/// compare two Step objects (it could be provided using `step()` and `Ord`, /// compare two Step objects (it could be provided using `step()` and `Ord`,
/// but the implementation would be so inefficient as to be useless). /// but the implementation would be so inefficient as to be useless).
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "design of range notation/iteration is in flux")] reason = "design of range notation/iteration is in flux")]
pub trait Step: Ord { pub trait Step: Ord {
/// Change self to the next object. /// Change self to the next object.
@ -2746,7 +2746,7 @@ pub trait Step: Ord {
macro_rules! step_impl { macro_rules! step_impl {
($($t:ty)*) => ($( ($($t:ty)*) => ($(
#[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] #[unstable(feature = "core", reason = "Trait is unstable.")]
impl Step for $t { impl Step for $t {
#[inline] #[inline]
fn step(&mut self) { *self += 1; } fn step(&mut self) { *self += 1; }
@ -2763,7 +2763,7 @@ macro_rules! step_impl {
macro_rules! step_impl_no_between { macro_rules! step_impl_no_between {
($($t:ty)*) => ($( ($($t:ty)*) => ($(
#[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] #[unstable(feature = "core", reason = "Trait is unstable.")]
impl Step for $t { impl Step for $t {
#[inline] #[inline]
fn step(&mut self) { *self += 1; } fn step(&mut self) { *self += 1; }
@ -2807,7 +2807,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> {
fn next_back(&mut self) -> Option<A> { self.idx(0) } fn next_back(&mut self) -> Option<A> { self.idx(0) }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<A: Clone> RandomAccessIterator for Repeat<A> { impl<A: Clone> RandomAccessIterator for Repeat<A> {
#[inline] #[inline]
fn indexable(&self) -> uint { uint::MAX } fn indexable(&self) -> uint { uint::MAX }
@ -2819,12 +2819,12 @@ type IterateState<T, F> = (F, Option<T>, bool);
/// An iterator that repeatedly applies a given function, starting /// An iterator that repeatedly applies a given function, starting
/// from a given seed value. /// from a given seed value.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>; pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
/// Create a new iterator that produces an infinite sequence of /// Create a new iterator that produces an infinite sequence of
/// repeated applications of the given function `f`. /// repeated applications of the given function `f`.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
T: Clone, T: Clone,
F: FnMut(T) -> T, F: FnMut(T) -> T,
@ -2867,7 +2867,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
/// ///
/// If two sequences are equal up until the point where one ends, /// If two sequences are equal up until the point where one ends,
/// the shorter sequence compares less. /// the shorter sequence compares less.
#[unstable(feature = "unnamed_feature", reason = "needs review and revision")] #[unstable(feature = "core", reason = "needs review and revision")]
pub mod order { pub mod order {
use cmp; use cmp;
use cmp::{Eq, Ord, PartialOrd, PartialEq}; use cmp::{Eq, Ord, PartialOrd, PartialEq};

2
src/libcore/lib.rs
View file

@ -48,7 +48,7 @@
// separate crate, libcoretest, to avoid bizarre issues. // separate crate, libcoretest, to avoid bizarre issues.
#![crate_name = "core"] #![crate_name = "core"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "core")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]

4
src/libcore/macros.rs
View file

@ -235,7 +235,7 @@ macro_rules! writeln {
/// } /// }
/// ``` /// ```
#[macro_export] #[macro_export]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "relationship with panic is unclear")] reason = "relationship with panic is unclear")]
macro_rules! unreachable { macro_rules! unreachable {
() => ({ () => ({
@ -252,7 +252,7 @@ macro_rules! unreachable {
/// A standardised placeholder for marking unfinished code. It panics with the /// A standardised placeholder for marking unfinished code. It panics with the
/// message `"not yet implemented"` when executed. /// message `"not yet implemented"` when executed.
#[macro_export] #[macro_export]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "relationship with panic is unclear")] reason = "relationship with panic is unclear")]
macro_rules! unimplemented { macro_rules! unimplemented {
() => (panic!("not yet implemented")) () => (panic!("not yet implemented"))

28
src/libcore/marker.rs
View file

@ -28,7 +28,7 @@
use clone::Clone; use clone::Clone;
/// Types able to be transferred across task boundaries. /// Types able to be transferred across task boundaries.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be overhauled with new lifetime rules; see RFC 458")] reason = "will be overhauled with new lifetime rules; see RFC 458")]
#[lang="send"] #[lang="send"]
pub unsafe trait Send: 'static { pub unsafe trait Send: 'static {
@ -192,7 +192,7 @@ pub trait Copy {
/// around the value(s) which can be mutated when behind a `&` /// around the value(s) which can be mutated when behind a `&`
/// reference; not doing this is undefined behaviour (for example, /// reference; not doing this is undefined behaviour (for example,
/// `transmute`-ing from `&T` to `&mut T` is illegal). /// `transmute`-ing from `&T` to `&mut T` is illegal).
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be overhauled with new lifetime rules; see RFC 458")] reason = "will be overhauled with new lifetime rules; see RFC 458")]
#[lang="sync"] #[lang="sync"]
pub unsafe trait Sync { pub unsafe trait Sync {
@ -237,7 +237,7 @@ pub unsafe trait Sync {
/// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U` /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
/// (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).
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="covariant_type"] #[lang="covariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
@ -287,7 +287,7 @@ impl<T: ?Sized> Clone for CovariantType<T> {
/// subtype of `S<U>` if `U` is a subtype of `T`; given that the /// subtype of `S<U>` if `U` is a subtype of `T`; given that the
/// 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.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="contravariant_type"] #[lang="contravariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
@ -318,16 +318,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> {
/// The type system would infer that `value` is only read here and /// The type system would infer that `value` is only read here and
/// 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.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="invariant_type"] #[lang="invariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantType<T: ?Sized>; pub struct InvariantType<T: ?Sized>;
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Copy for InvariantType<T> {} impl<T: ?Sized> Copy for InvariantType<T> {}
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Clone for InvariantType<T> { impl<T: ?Sized> Clone for InvariantType<T> {
fn clone(&self) -> InvariantType<T> { *self } fn clone(&self) -> InvariantType<T> { *self }
@ -349,7 +349,7 @@ impl<T: ?Sized> Clone for InvariantType<T> {
/// ///
/// For more information about variance, refer to this Wikipedia /// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="covariant_lifetime"] #[lang="covariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@ -367,7 +367,7 @@ pub struct CovariantLifetime<'a>;
/// ///
/// For more information about variance, refer to this Wikipedia /// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="contravariant_lifetime"] #[lang="contravariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@ -380,7 +380,7 @@ pub struct ContravariantLifetime<'a>;
/// pointer that is actually a pointer into memory with lifetime `'a`, /// pointer that is actually a pointer into memory with lifetime `'a`,
/// and this pointer is itself stored in an inherently mutable /// and this pointer is itself stored in an inherently mutable
/// location (such as a `Cell`). /// location (such as a `Cell`).
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="invariant_lifetime"] #[lang="invariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@ -390,7 +390,7 @@ pub struct InvariantLifetime<'a>;
/// be safely sent between tasks, even if it is owned. This is /// be safely sent between tasks, even if it is owned. This is
/// typically embedded in other types, such as `Gc`, to ensure that /// typically embedded in other types, such as `Gc`, to ensure that
/// their instances remain thread-local. /// their instances remain thread-local.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="no_send_bound"] #[lang="no_send_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@ -400,7 +400,7 @@ pub struct NoSend;
/// A type which is considered "not POD", meaning that it is not /// A type which is considered "not POD", meaning that it is not
/// implicitly copyable. This is typically embedded in other types to /// implicitly copyable. This is typically embedded in other types to
/// ensure that they are never copied, even if they lack a destructor. /// ensure that they are never copied, even if they lack a destructor.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="no_copy_bound"] #[lang="no_copy_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
@ -410,7 +410,7 @@ pub struct NoCopy;
/// A type which is considered "not sync", meaning that /// A type which is considered "not sync", meaning that
/// its contents are not threadsafe, hence they cannot be /// its contents are not threadsafe, hence they cannot be
/// shared between tasks. /// shared between tasks.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="no_sync_bound"] #[lang="no_sync_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@ -419,7 +419,7 @@ pub struct NoSync;
/// A type which is considered managed by the GC. This is typically /// A type which is considered managed by the GC. This is typically
/// embedded in other types. /// embedded in other types.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "likely to change with new variance strategy")] reason = "likely to change with new variance strategy")]
#[lang="managed_bound"] #[lang="managed_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]

4
src/libcore/mem.rs
View file

@ -318,7 +318,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
/// Transforms lifetime of the second pointer to match the first. /// Transforms lifetime of the second pointer to match the first.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "this function may be removed in the future due to its \ reason = "this function may be removed in the future due to its \
questionable utility")] questionable utility")]
pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
@ -328,7 +328,7 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
/// Transforms lifetime of the second mutable pointer to match the first. /// Transforms lifetime of the second mutable pointer to match the first.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "this function may be removed in the future due to its \ reason = "this function may be removed in the future due to its \
questionable utility")] questionable utility")]
pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S, pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,

2
src/libcore/nonzero.rs
View file

@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {}
/// NULL or 0 that might allow certain optimizations. /// NULL or 0 that might allow certain optimizations.
#[lang="non_zero"] #[lang="non_zero"]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)] #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub struct NonZero<T: Zeroable>(T); pub struct NonZero<T: Zeroable>(T);
impl<T: Zeroable> NonZero<T> { impl<T: Zeroable> NonZero<T> {

18
src/libcore/num/f32.rs
View file

@ -22,12 +22,12 @@ use num::Float;
use num::FpCategory as Fp; use num::FpCategory as Fp;
use option::Option; use option::Option;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const RADIX: uint = 2u; pub const RADIX: uint = 2u;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MANTISSA_DIGITS: uint = 24u; pub const MANTISSA_DIGITS: uint = 24u;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const DIGITS: uint = 6u; pub const DIGITS: uint = 6u;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -43,14 +43,14 @@ pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX_VALUE: f32 = 3.40282347e+38_f32; pub const MAX_VALUE: f32 = 3.40282347e+38_f32;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MIN_EXP: int = -125; pub const MIN_EXP: int = -125;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_EXP: int = 128; pub const MAX_EXP: int = 128;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MIN_10_EXP: int = -37; pub const MIN_10_EXP: int = -37;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 38; pub const MAX_10_EXP: int = 38;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -61,7 +61,7 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32;
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32; pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
/// Various useful constants. /// Various useful constants.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "naming scheme needs to be revisited")] reason = "naming scheme needs to be revisited")]
pub mod consts { pub mod consts {
// FIXME: replace with mathematical constants from cmath. // FIXME: replace with mathematical constants from cmath.
@ -118,7 +118,7 @@ pub mod consts {
pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "core", reason = "trait is unstable")]
impl Float for f32 { impl Float for f32 {
#[inline] #[inline]
fn nan() -> f32 { NAN } fn nan() -> f32 { NAN }

16
src/libcore/num/f64.rs
View file

@ -26,11 +26,11 @@ use option::Option;
// constants are implemented in favour of referencing the respective // constants are implemented in favour of referencing the respective
// members of `Bounded` and `Float`. // members of `Bounded` and `Float`.
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const RADIX: uint = 2u; pub const RADIX: uint = 2u;
pub const MANTISSA_DIGITS: uint = 53u; pub const MANTISSA_DIGITS: uint = 53u;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const DIGITS: uint = 15u; pub const DIGITS: uint = 15u;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -46,14 +46,14 @@ pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64; pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MIN_EXP: int = -1021; pub const MIN_EXP: int = -1021;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_EXP: int = 1024; pub const MAX_EXP: int = 1024;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MIN_10_EXP: int = -307; pub const MIN_10_EXP: int = -307;
#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 308; pub const MAX_10_EXP: int = 308;
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
@ -64,7 +64,7 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64;
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64; pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
/// Various useful constants. /// Various useful constants.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "naming scheme needs to be revisited")] reason = "naming scheme needs to be revisited")]
pub mod consts { pub mod consts {
// FIXME: replace with mathematical constants from cmath. // FIXME: replace with mathematical constants from cmath.
@ -125,7 +125,7 @@ pub mod consts {
pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
} }
#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] #[unstable(feature = "core", reason = "trait is unstable")]
impl Float for f64 { impl Float for f64 {
#[inline] #[inline]
fn nan() -> f64 { NAN } fn nan() -> f64 { NAN }

4
src/libcore/num/int_macros.rs
View file

@ -14,11 +14,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => (
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function. // calling the `mem::size_of` function.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub const BITS : uint = $bits; pub const BITS : uint = $bits;
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function. // calling the `mem::size_of` function.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub const BYTES : uint = ($bits / 8); pub const BYTES : uint = ($bits / 8);
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of

72
src/libcore/num/mod.rs
View file

@ -50,25 +50,25 @@ pub trait Int
{ {
/// Returns the `0` value of this integer type. /// Returns the `0` value of this integer type.
// FIXME (#5527): Should be an associated constant // FIXME (#5527): Should be an associated constant
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn zero() -> Self; fn zero() -> Self;
/// Returns the `1` value of this integer type. /// Returns the `1` value of this integer type.
// FIXME (#5527): Should be an associated constant // FIXME (#5527): Should be an associated constant
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn one() -> Self; fn one() -> Self;
/// Returns the smallest value that can be represented by this integer type. /// Returns the smallest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant // FIXME (#5527): Should be and associated constant
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn min_value() -> Self; fn min_value() -> Self;
/// Returns the largest value that can be represented by this integer type. /// Returns the largest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant // FIXME (#5527): Should be and associated constant
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn max_value() -> Self; fn max_value() -> Self;
@ -83,7 +83,7 @@ pub trait Int
/// ///
/// assert_eq!(n.count_ones(), 3); /// assert_eq!(n.count_ones(), 3);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn count_ones(self) -> uint; fn count_ones(self) -> uint;
@ -98,7 +98,7 @@ pub trait Int
/// ///
/// assert_eq!(n.count_zeros(), 5); /// assert_eq!(n.count_zeros(), 5);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
#[inline] #[inline]
fn count_zeros(self) -> uint { fn count_zeros(self) -> uint {
@ -117,7 +117,7 @@ pub trait Int
/// ///
/// assert_eq!(n.leading_zeros(), 10); /// assert_eq!(n.leading_zeros(), 10);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn leading_zeros(self) -> uint; fn leading_zeros(self) -> uint;
@ -133,7 +133,7 @@ pub trait Int
/// ///
/// assert_eq!(n.trailing_zeros(), 3); /// assert_eq!(n.trailing_zeros(), 3);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn trailing_zeros(self) -> uint; fn trailing_zeros(self) -> uint;
@ -150,7 +150,7 @@ pub trait Int
/// ///
/// assert_eq!(n.rotate_left(12), m); /// assert_eq!(n.rotate_left(12), m);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn rotate_left(self, n: uint) -> Self; fn rotate_left(self, n: uint) -> Self;
@ -167,7 +167,7 @@ pub trait Int
/// ///
/// assert_eq!(n.rotate_right(12), m); /// assert_eq!(n.rotate_right(12), m);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn rotate_right(self, n: uint) -> Self; fn rotate_right(self, n: uint) -> Self;
@ -368,7 +368,7 @@ pub trait Int
/// ///
/// assert_eq!(2i.pow(4), 16); /// assert_eq!(2i.pow(4), 16);
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "pending integer conventions")] reason = "pending integer conventions")]
#[inline] #[inline]
fn pow(self, mut exp: uint) -> Self { fn pow(self, mut exp: uint) -> Self {
@ -632,7 +632,7 @@ pub trait SignedInt
{ {
/// Computes the absolute value of `self`. `Int::min_value()` will be /// Computes the absolute value of `self`. `Int::min_value()` will be
/// returned if the number is `Int::min_value()`. /// returned if the number is `Int::min_value()`.
#[unstable(feature = "unnamed_feature", reason = "overflow in debug builds?")] #[unstable(feature = "core", reason = "overflow in debug builds?")]
fn abs(self) -> Self; fn abs(self) -> Self;
/// Returns a number representing sign of `self`. /// Returns a number representing sign of `self`.
@ -737,7 +737,7 @@ impl UnsignedInt for u32 {}
impl UnsignedInt for u64 {} impl UnsignedInt for u64 {}
/// A generic trait for converting a value to a number. /// A generic trait for converting a value to a number.
#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] #[unstable(feature = "core", reason = "trait is likely to be removed")]
pub trait ToPrimitive { pub trait ToPrimitive {
/// Converts the value of `self` to an `int`. /// Converts the value of `self` to an `int`.
#[inline] #[inline]
@ -1002,7 +1002,7 @@ impl_to_primitive_float! { f32 }
impl_to_primitive_float! { f64 } impl_to_primitive_float! { f64 }
/// A generic trait for converting a number to a value. /// A generic trait for converting a number to a value.
#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] #[unstable(feature = "core", reason = "trait is likely to be removed")]
pub trait FromPrimitive : ::marker::Sized { pub trait FromPrimitive : ::marker::Sized {
/// Convert an `int` to return an optional value of this type. If the /// Convert an `int` to return an optional value of this type. If the
/// value cannot be represented by this value, the `None` is returned. /// value cannot be represented by this value, the `None` is returned.
@ -1084,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized {
} }
/// A utility function that just calls `FromPrimitive::from_int`. /// A utility function that just calls `FromPrimitive::from_int`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> { pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> {
FromPrimitive::from_int(n) FromPrimitive::from_int(n)
} }
/// A utility function that just calls `FromPrimitive::from_i8`. /// A utility function that just calls `FromPrimitive::from_i8`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> { pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> {
FromPrimitive::from_i8(n) FromPrimitive::from_i8(n)
} }
/// A utility function that just calls `FromPrimitive::from_i16`. /// A utility function that just calls `FromPrimitive::from_i16`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> { pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> {
FromPrimitive::from_i16(n) FromPrimitive::from_i16(n)
} }
/// A utility function that just calls `FromPrimitive::from_i32`. /// A utility function that just calls `FromPrimitive::from_i32`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> { pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> {
FromPrimitive::from_i32(n) FromPrimitive::from_i32(n)
} }
/// A utility function that just calls `FromPrimitive::from_i64`. /// A utility function that just calls `FromPrimitive::from_i64`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> { pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> {
FromPrimitive::from_i64(n) FromPrimitive::from_i64(n)
} }
/// A utility function that just calls `FromPrimitive::from_uint`. /// A utility function that just calls `FromPrimitive::from_uint`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> { pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> {
FromPrimitive::from_uint(n) FromPrimitive::from_uint(n)
} }
/// A utility function that just calls `FromPrimitive::from_u8`. /// A utility function that just calls `FromPrimitive::from_u8`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> { pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> {
FromPrimitive::from_u8(n) FromPrimitive::from_u8(n)
} }
/// A utility function that just calls `FromPrimitive::from_u16`. /// A utility function that just calls `FromPrimitive::from_u16`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> { pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> {
FromPrimitive::from_u16(n) FromPrimitive::from_u16(n)
} }
/// A utility function that just calls `FromPrimitive::from_u32`. /// A utility function that just calls `FromPrimitive::from_u32`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> { pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> {
FromPrimitive::from_u32(n) FromPrimitive::from_u32(n)
} }
/// A utility function that just calls `FromPrimitive::from_u64`. /// A utility function that just calls `FromPrimitive::from_u64`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> { pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> {
FromPrimitive::from_u64(n) FromPrimitive::from_u64(n)
} }
/// A utility function that just calls `FromPrimitive::from_f32`. /// A utility function that just calls `FromPrimitive::from_f32`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> { pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> {
FromPrimitive::from_f32(n) FromPrimitive::from_f32(n)
} }
/// A utility function that just calls `FromPrimitive::from_f64`. /// A utility function that just calls `FromPrimitive::from_f64`.
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> { pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> {
FromPrimitive::from_f64(n) FromPrimitive::from_f64(n)
} }
@ -1201,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 }
/// ``` /// ```
/// ///
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] #[unstable(feature = "core", reason = "likely to be removed")]
pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> { pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> {
NumCast::from(n) NumCast::from(n)
} }
/// An interface for casting between machine scalars. /// An interface for casting between machine scalars.
#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] #[unstable(feature = "core", reason = "trait is likely to be removed")]
pub trait NumCast: ToPrimitive { pub trait NumCast: ToPrimitive {
/// Creates a number from another value that can be converted into a primitive via the /// Creates a number from another value that can be converted into a primitive via the
/// `ToPrimitive` trait. /// `ToPrimitive` trait.
@ -1242,7 +1242,7 @@ impl_num_cast! { f64, to_f64 }
/// Used for representing the classification of floating point numbers /// Used for representing the classification of floating point numbers
#[derive(Copy, PartialEq, Show)] #[derive(Copy, PartialEq, Show)]
#[unstable(feature = "unnamed_feature", reason = "may be renamed")] #[unstable(feature = "core", reason = "may be renamed")]
pub enum FpCategory { pub enum FpCategory {
/// "Not a Number", often obtained by dividing by zero /// "Not a Number", often obtained by dividing by zero
Nan, Nan,
@ -1262,7 +1262,7 @@ pub enum FpCategory {
// //
// FIXME(#8888): Several of these functions have a parameter named // FIXME(#8888): Several of these functions have a parameter named
// `unused_self`. Removing it requires #8888 to be fixed. // `unused_self`. Removing it requires #8888 to be fixed.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "distribution of methods between core/std is unclear")] reason = "distribution of methods between core/std is unclear")]
pub trait Float pub trait Float
: Copy + Clone : Copy + Clone
@ -1418,20 +1418,20 @@ pub trait Float
} }
/// A generic trait for converting a string with a radix (base) to a value /// A generic trait for converting a string with a radix (base) to a value
#[unstable(feature = "unnamed_feature", reason = "might need to return Result")] #[unstable(feature = "core", reason = "might need to return Result")]
pub trait FromStrRadix { pub trait FromStrRadix {
fn from_str_radix(str: &str, radix: uint) -> Option<Self>; fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
} }
/// A utility function that just calls FromStrRadix::from_str_radix. /// A utility function that just calls FromStrRadix::from_str_radix.
#[unstable(feature = "unnamed_feature", reason = "might need to return Result")] #[unstable(feature = "core", reason = "might need to return Result")]
pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> { pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
FromStrRadix::from_str_radix(str, radix) FromStrRadix::from_str_radix(str, radix)
} }
macro_rules! from_str_radix_float_impl { macro_rules! from_str_radix_float_impl {
($T:ty) => { ($T:ty) => {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "might need to return Result")] reason = "might need to return Result")]
impl FromStr for $T { impl FromStr for $T {
/// Convert a string in base 10 to a float. /// Convert a string in base 10 to a float.
@ -1465,7 +1465,7 @@ macro_rules! from_str_radix_float_impl {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "might need to return Result")] reason = "might need to return Result")]
impl FromStrRadix for $T { impl FromStrRadix for $T {
/// Convert a string in a given base to a float. /// Convert a string in a given base to a float.
@ -1630,7 +1630,7 @@ from_str_radix_float_impl! { f64 }
macro_rules! from_str_radix_int_impl { macro_rules! from_str_radix_int_impl {
($T:ty) => { ($T:ty) => {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "might need to return Result")] reason = "might need to return Result")]
impl FromStr for $T { impl FromStr for $T {
#[inline] #[inline]
@ -1639,7 +1639,7 @@ macro_rules! from_str_radix_int_impl {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "might need to return Result")] reason = "might need to return Result")]
impl FromStrRadix for $T { impl FromStrRadix for $T {
fn from_str_radix(src: &str, radix: uint) -> Option<$T> { fn from_str_radix(src: &str, radix: uint) -> Option<$T> {

4
src/libcore/num/uint_macros.rs
View file

@ -12,9 +12,9 @@
macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => ( macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub const BITS : uint = $bits; pub const BITS : uint = $bits;
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub const BYTES : uint = ($bits / 8); pub const BYTES : uint = ($bits / 8);
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]

38
src/libcore/ops.rs
View file

@ -108,7 +108,7 @@ pub trait Drop {
// based on "op T" where T is expected to be `Copy`able // based on "op T" where T is expected to be `Copy`able
macro_rules! forward_ref_unop { macro_rules! forward_ref_unop {
(impl $imp:ident, $method:ident for $t:ty) => { (impl $imp:ident, $method:ident for $t:ty) => {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")] reason = "recently added, waiting for dust to settle")]
impl<'a> $imp for &'a $t { impl<'a> $imp for &'a $t {
type Output = <$t as $imp>::Output; type Output = <$t as $imp>::Output;
@ -125,7 +125,7 @@ macro_rules! forward_ref_unop {
// based on "T op U" where T and U are expected to be `Copy`able // based on "T op U" where T and U are expected to be `Copy`able
macro_rules! forward_ref_binop { macro_rules! forward_ref_binop {
(impl $imp:ident, $method:ident for $t:ty, $u:ty) => { (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")] reason = "recently added, waiting for dust to settle")]
impl<'a> $imp<$u> for &'a $t { impl<'a> $imp<$u> for &'a $t {
type Output = <$t as $imp<$u>>::Output; type Output = <$t as $imp<$u>>::Output;
@ -136,7 +136,7 @@ macro_rules! forward_ref_binop {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")] reason = "recently added, waiting for dust to settle")]
impl<'a> $imp<&'a $u> for $t { impl<'a> $imp<&'a $u> for $t {
type Output = <$t as $imp<$u>>::Output; type Output = <$t as $imp<$u>>::Output;
@ -147,7 +147,7 @@ macro_rules! forward_ref_binop {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")] reason = "recently added, waiting for dust to settle")]
impl<'a, 'b> $imp<&'a $u> for &'b $t { impl<'a, 'b> $imp<&'a $u> for &'b $t {
type Output = <$t as $imp<$u>>::Output; type Output = <$t as $imp<$u>>::Output;
@ -974,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> {
/// An unbounded range. /// An unbounded range.
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
#[lang="full_range"] #[lang="full_range"]
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
pub struct FullRange; pub struct FullRange;
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl fmt::Show for FullRange { impl fmt::Show for FullRange {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt("..", fmt) fmt::Show::fmt("..", fmt)
@ -987,7 +987,7 @@ impl fmt::Show for FullRange {
/// A (half-open) range which is bounded at both ends. /// A (half-open) range which is bounded at both ends.
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range"] #[lang="range"]
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
pub struct Range<Idx> { pub struct Range<Idx> {
/// The lower bound of the range (inclusive). /// The lower bound of the range (inclusive).
pub start: Idx, pub start: Idx,
@ -995,7 +995,7 @@ pub struct Range<Idx> {
pub end: Idx, pub end: Idx,
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> Iterator for Range<Idx> { impl<Idx: Clone + Step> Iterator for Range<Idx> {
type Item = Idx; type Item = Idx;
@ -1020,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
#[inline] #[inline]
fn next_back(&mut self) -> Option<Idx> { fn next_back(&mut self) -> Option<Idx> {
@ -1033,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {} impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for Range<Idx> { impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..{:?}", self.start, self.end) write!(fmt, "{:?}..{:?}", self.start, self.end)
@ -1046,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
/// A range which is only bounded below. /// A range which is only bounded below.
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_from"] #[lang="range_from"]
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
pub struct RangeFrom<Idx> { pub struct RangeFrom<Idx> {
/// The lower bound of the range (inclusive). /// The lower bound of the range (inclusive).
pub start: Idx, pub start: Idx,
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
type Item = Idx; type Item = Idx;
@ -1065,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..", self.start) write!(fmt, "{:?}..", self.start)
@ -1075,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
/// A range which is only bounded above. /// A range which is only bounded above.
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_to"] #[lang="range_to"]
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
pub struct RangeTo<Idx> { pub struct RangeTo<Idx> {
/// The upper bound of the range (exclusive). /// The upper bound of the range (exclusive).
pub end: Idx, pub end: Idx,
} }
#[unstable(feature = "unnamed_feature", reason = "API still in development")] #[unstable(feature = "core", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> { impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "..{:?}", self.end) write!(fmt, "..{:?}", self.end)
@ -1196,7 +1196,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T {
/// A version of the call operator that takes an immutable receiver. /// A version of the call operator that takes an immutable receiver.
#[lang="fn"] #[lang="fn"]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")] reason = "uncertain about variadic generics, input versus associated types")]
pub trait Fn<Args,Result> { pub trait Fn<Args,Result> {
/// This is called when the call operator is used. /// This is called when the call operator is used.
@ -1205,7 +1205,7 @@ pub trait Fn<Args,Result> {
/// A version of the call operator that takes a mutable receiver. /// A version of the call operator that takes a mutable receiver.
#[lang="fn_mut"] #[lang="fn_mut"]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")] reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnMut<Args,Result> { pub trait FnMut<Args,Result> {
/// This is called when the call operator is used. /// This is called when the call operator is used.
@ -1214,7 +1214,7 @@ pub trait FnMut<Args,Result> {
/// A version of the call operator that takes a by-value receiver. /// A version of the call operator that takes a by-value receiver.
#[lang="fn_once"] #[lang="fn_once"]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")] reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnOnce<Args,Result> { pub trait FnOnce<Args,Result> {
/// This is called when the call operator is used. /// This is called when the call operator is used.

12
src/libcore/option.rs
View file

@ -285,7 +285,7 @@ impl<T> Option<T> {
/// assert_eq!(x, Some("Dirt")); /// assert_eq!(x, Some("Dirt"));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting for mut conventions")] reason = "waiting for mut conventions")]
pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] { pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
match *self { match *self {
@ -477,7 +477,7 @@ impl<T> Option<T> {
/// assert_eq!(x.ok_or(0i), Err(0i)); /// assert_eq!(x.ok_or(0i), Err(0i));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn ok_or<E>(self, err: E) -> Result<T, E> { pub fn ok_or<E>(self, err: E) -> Result<T, E> {
match self { match self {
Some(v) => Ok(v), Some(v) => Ok(v),
@ -498,7 +498,7 @@ impl<T> Option<T> {
/// assert_eq!(x.ok_or_else(|| 0i), Err(0i)); /// assert_eq!(x.ok_or_else(|| 0i), Err(0i));
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> { pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
match self { match self {
Some(v) => Ok(v), Some(v) => Ok(v),
@ -543,7 +543,7 @@ impl<T> Option<T> {
/// assert_eq!(x.iter_mut().next(), None); /// assert_eq!(x.iter_mut().next(), None);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting for iterator conventions")] reason = "waiting for iterator conventions")]
pub fn iter_mut(&mut self) -> IterMut<T> { pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut { inner: Item { opt: self.as_mut() } } IterMut { inner: Item { opt: self.as_mut() } }
@ -704,7 +704,7 @@ impl<T> Option<T> {
impl<'a, T: Clone, D: Deref<Target=T>> Option<D> { impl<'a, T: Clone, D: Deref<Target=T>> Option<D> {
/// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option. /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option.
/// Useful for converting an Option<&T> to an Option<T>. /// Useful for converting an Option<&T> to an Option<T>.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added as part of collections reform")] reason = "recently added as part of collections reform")]
pub fn cloned(self) -> Option<T> { pub fn cloned(self) -> Option<T> {
self.map(|t| t.deref().clone()) self.map(|t| t.deref().clone())
@ -748,7 +748,7 @@ impl<T: Default> Option<T> {
// Trait implementations // Trait implementations
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting on the stability of the trait itself")] reason = "waiting on the stability of the trait itself")]
impl<T> AsSlice<T> for Option<T> { impl<T> AsSlice<T> for Option<T> {
/// Convert from `Option<T>` to `&[T]` (without copying) /// Convert from `Option<T>` to `&[T]` (without copying)

30
src/libcore/ptr.rs
View file

@ -99,13 +99,13 @@ use cmp::Ordering::{self, Less, Equal, Greater};
// FIXME #19649: intrinsic docs don't render, so these have no docs :( // FIXME #19649: intrinsic docs don't render, so these have no docs :(
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub use intrinsics::copy_nonoverlapping_memory; pub use intrinsics::copy_nonoverlapping_memory;
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub use intrinsics::copy_memory; pub use intrinsics::copy_memory;
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "uncertain about naming and semantics")] reason = "uncertain about naming and semantics")]
pub use intrinsics::set_memory; pub use intrinsics::set_memory;
@ -146,7 +146,7 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T }
/// Beyond accepting a raw pointer, this is unsafe because it will not drop the /// Beyond accepting a raw pointer, this is unsafe because it will not drop the
/// contents of `dst`, and may be used to create invalid instances of `T`. /// contents of `dst`, and may be used to create invalid instances of `T`.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may play a larger role in std::ptr future extensions")] reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) { pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
set_memory(dst, 0, count); set_memory(dst, 0, count);
@ -215,7 +215,7 @@ pub unsafe fn read<T>(src: *const T) -> T {
/// ///
/// This is unsafe for the same reasons that `read` is unsafe. /// This is unsafe for the same reasons that `read` is unsafe.
#[inline(always)] #[inline(always)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "may play a larger role in std::ptr future extensions")] reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn read_and_zero<T>(dest: *mut T) -> T { pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
// Copy the data out from `dest`: // Copy the data out from `dest`:
@ -262,7 +262,7 @@ pub trait PtrExt: Sized {
/// null-safety, it is important to note that this is still an unsafe /// null-safety, it is important to note that this is still an unsafe
/// operation because the returned value could be pointing to invalid /// operation because the returned value could be pointing to invalid
/// memory. /// memory.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "Option is not clearly the right return type, and we may want \ reason = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer")] to tie the return lifetime to a borrow of the raw pointer")]
unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>; unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>;
@ -291,7 +291,7 @@ pub trait MutPtrExt {
/// ///
/// As with `as_ref`, this is unsafe because it cannot verify the validity /// As with `as_ref`, this is unsafe because it cannot verify the validity
/// of the returned pointer. /// of the returned pointer.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "Option is not clearly the right return type, and we may want \ reason = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer")] to tie the return lifetime to a borrow of the raw pointer")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>; unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>;
@ -312,7 +312,7 @@ impl<T> PtrExt for *const T {
} }
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \ reason = "return value does not necessarily convey all possible \
information")] information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> { unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
@ -339,7 +339,7 @@ impl<T> PtrExt for *mut T {
} }
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \ reason = "return value does not necessarily convey all possible \
information")] information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> { unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
@ -356,7 +356,7 @@ impl<T> MutPtrExt for *mut T {
type Target = T; type Target = T;
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \ reason = "return value does not necessarily convey all possible \
information")] information")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> { unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
@ -521,33 +521,33 @@ impl<T> PartialOrd for *mut T {
/// raw `*mut T` (which conveys no particular ownership semantics). /// raw `*mut T` (which conveys no particular ownership semantics).
/// Useful for building abstractions like `Vec<T>` or `Box<T>`, which /// Useful for building abstractions like `Vec<T>` or `Box<T>`, which
/// internally use raw pointers to manage the memory that they own. /// internally use raw pointers to manage the memory that they own.
#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] #[unstable(feature = "core", reason = "recently added to this module")]
pub struct Unique<T>(pub *mut T); pub struct Unique<T>(pub *mut T);
/// `Unique` pointers are `Send` if `T` is `Send` because the data they /// `Unique` pointers are `Send` if `T` is `Send` because the data they
/// reference is unaliased. Note that this aliasing invariant is /// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the /// unenforced by the type system; the abstraction using the
/// `Unique` must enforce it. /// `Unique` must enforce it.
#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] #[unstable(feature = "core", reason = "recently added to this module")]
unsafe impl<T:Send> Send for Unique<T> { } unsafe impl<T:Send> Send for Unique<T> { }
/// `Unique` pointers are `Sync` if `T` is `Sync` because the data they /// `Unique` pointers are `Sync` if `T` is `Sync` because the data they
/// reference is unaliased. Note that this aliasing invariant is /// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the /// unenforced by the type system; the abstraction using the
/// `Unique` must enforce it. /// `Unique` must enforce it.
#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] #[unstable(feature = "core", reason = "recently added to this module")]
unsafe impl<T:Sync> Sync for Unique<T> { } unsafe impl<T:Sync> Sync for Unique<T> { }
impl<T> Unique<T> { impl<T> Unique<T> {
/// Returns a null Unique. /// Returns a null Unique.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added to this module")] reason = "recently added to this module")]
pub fn null() -> Unique<T> { pub fn null() -> Unique<T> {
Unique(null_mut()) Unique(null_mut())
} }
/// Return an (unsafe) pointer into the memory owned by `self`. /// Return an (unsafe) pointer into the memory owned by `self`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "recently added to this module")] reason = "recently added to this module")]
pub unsafe fn offset(self, offset: int) -> *mut T { pub unsafe fn offset(self, offset: int) -> *mut T {
self.0.offset(offset) self.0.offset(offset)

2
src/libcore/raw.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
#![allow(missing_docs)] #![allow(missing_docs)]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "core")]
//! Contains struct definitions for the layout of compiler built-in types. //! Contains struct definitions for the layout of compiler built-in types.
//! //!

4
src/libcore/result.rs
View file

@ -417,7 +417,7 @@ impl<T, E> Result<T, E> {
/// assert!(x.as_mut_slice().is_empty()); /// assert!(x.as_mut_slice().is_empty());
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "waiting for mut conventions")] reason = "waiting for mut conventions")]
pub fn as_mut_slice(&mut self) -> &mut [T] { pub fn as_mut_slice(&mut self) -> &mut [T] {
match *self { match *self {
@ -950,7 +950,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
/// If an `Err` is encountered, it is immediately returned. /// If an `Err` is encountered, it is immediately returned.
/// Otherwise, the folded value is returned. /// Otherwise, the folded value is returned.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn fold<T, pub fn fold<T,
V, V,
E, E,

20
src/libcore/simd.rs
View file

@ -36,7 +36,7 @@
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
#![allow(missing_docs)] #![allow(missing_docs)]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
@ -45,26 +45,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8); pub i8, pub i8, pub i8, pub i8);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct i16x8(pub i16, pub i16, pub i16, pub i16, pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
pub i16, pub i16, pub i16, pub i16); pub i16, pub i16, pub i16, pub i16);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct i32x4(pub i32, pub i32, pub i32, pub i32); pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct i64x2(pub i64, pub i64); pub struct i64x2(pub i64, pub i64);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
@ -73,32 +73,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8); pub u8, pub u8, pub u8, pub u8);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct u16x8(pub u16, pub u16, pub u16, pub u16, pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
pub u16, pub u16, pub u16, pub u16); pub u16, pub u16, pub u16, pub u16);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct u32x4(pub u32, pub u32, pub u32, pub u32); pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct u64x2(pub u64, pub u64); pub struct u64x2(pub u64, pub u64);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]
pub struct f32x4(pub f32, pub f32, pub f32, pub f32); pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
#[simd] #[simd]
#[derive(Copy, Show)] #[derive(Copy, Show)]
#[repr(C)] #[repr(C)]

64
src/libcore/slice.rs
View file

@ -131,7 +131,7 @@ pub trait SliceExt {
fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<T> SliceExt for [T] { impl<T> SliceExt for [T] {
type Item = T; type Item = T;
@ -258,7 +258,7 @@ impl<T> SliceExt for [T] {
self.repr().data self.repr().data
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where
F: FnMut(&T) -> Ordering F: FnMut(&T) -> Ordering
{ {
@ -452,12 +452,12 @@ impl<T> SliceExt for [T] {
m >= n && needle == &self[(m-n)..] m >= n && needle == &self[(m-n)..]
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord { fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
self.binary_search_by(|p| p.cmp(x)) self.binary_search_by(|p| p.cmp(x))
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
fn next_permutation(&mut self) -> bool where T: Ord { fn next_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything. // These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; } if self.len() < 2 { return false; }
@ -488,7 +488,7 @@ impl<T> SliceExt for [T] {
true true
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
fn prev_permutation(&mut self) -> bool where T: Ord { fn prev_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything. // These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; } if self.len() < 2 { return false; }
@ -630,26 +630,26 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// Data that is viewable as a slice. /// Data that is viewable as a slice.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will be replaced by slice syntax")] reason = "will be replaced by slice syntax")]
pub trait AsSlice<T> { pub trait AsSlice<T> {
/// Work with `self` as a slice. /// Work with `self` as a slice.
fn as_slice<'a>(&'a self) -> &'a [T]; fn as_slice<'a>(&'a self) -> &'a [T];
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<T> AsSlice<T> for [T] { impl<T> AsSlice<T> for [T] {
#[inline(always)] #[inline(always)]
fn as_slice<'a>(&'a self) -> &'a [T] { self } fn as_slice<'a>(&'a self) -> &'a [T] { self }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U { impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U {
#[inline(always)] #[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U { impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U {
#[inline(always)] #[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
@ -755,7 +755,7 @@ pub struct Iter<'a, T: 'a> {
marker: marker::ContravariantLifetime<'a> marker: marker::ContravariantLifetime<'a>
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -764,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -773,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -782,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> { impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -796,7 +796,7 @@ impl<'a, T> Iter<'a, T> {
/// ///
/// This has the same lifetime as the original slice, and so the /// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists. /// iterator can continue to be used while this exists.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn as_slice(&self) -> &'a [T] { pub fn as_slice(&self) -> &'a [T] {
make_slice!(T => &'a [T]: self.ptr, self.end) make_slice!(T => &'a [T]: self.ptr, self.end)
} }
@ -814,7 +814,7 @@ impl<'a, T> Clone for Iter<'a, T> {
fn clone(&self) -> Iter<'a, T> { *self } fn clone(&self) -> Iter<'a, T> { *self }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Iter<'a, T> { impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -848,7 +848,7 @@ pub struct IterMut<'a, T: 'a> {
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -856,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index) self.index(&ops::FullRange).index(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -864,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index) self.index(&ops::FullRange).index(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -872,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index) self.index(&ops::FullRange).index(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -881,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -889,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index) self.index_mut(&ops::FullRange).index_mut(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -897,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index) self.index_mut(&ops::FullRange).index_mut(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -905,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index) self.index_mut(&ops::FullRange).index_mut(index)
} }
} }
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> { impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -922,7 +922,7 @@ impl<'a, T> IterMut<'a, T> {
/// to consume the iterator. Consider using the `Slice` and /// to consume the iterator. Consider using the `Slice` and
/// `SliceMut` implementations for obtaining slices with more /// `SliceMut` implementations for obtaining slices with more
/// restricted lifetimes that do not consume the iterator. /// restricted lifetimes that do not consume the iterator.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn into_slice(self) -> &'a mut [T] { pub fn into_slice(self) -> &'a mut [T] {
make_slice!(T => &'a mut [T]: self.ptr, self.end) make_slice!(T => &'a mut [T]: self.ptr, self.end)
} }
@ -1270,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
} }
} }
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] #[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Chunks<'a, T> { impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
#[inline] #[inline]
fn indexable(&self) -> uint { fn indexable(&self) -> uint {
@ -1354,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
// //
/// Converts a pointer to A into a slice of length 1 (without copying). /// Converts a pointer to A into a slice of length 1 (without copying).
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
unsafe { unsafe {
transmute(RawSlice { data: s, len: 1 }) transmute(RawSlice { data: s, len: 1 })
@ -1362,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
} }
/// Converts a pointer to A into a slice of length 1 (without copying). /// Converts a pointer to A into a slice of length 1 (without copying).
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
unsafe { unsafe {
let ptr: *const A = transmute(s); let ptr: *const A = transmute(s);
@ -1396,7 +1396,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
/// } /// }
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "should be renamed to from_raw_parts")] reason = "should be renamed to from_raw_parts")]
pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: *p, len: len }) transmute(RawSlice { data: *p, len: len })
@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
/// not being able to provide a non-aliasing guarantee of the returned mutable /// not being able to provide a non-aliasing guarantee of the returned mutable
/// slice. /// slice.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "should be renamed to from_raw_parts_mut")] reason = "should be renamed to from_raw_parts_mut")]
pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
transmute(RawSlice { data: *p, len: len }) transmute(RawSlice { data: *p, len: len })
@ -1420,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
// //
/// Operations on `[u8]`. /// Operations on `[u8]`.
#[unstable(feature = "unnamed_feature", reason = "needs review")] #[unstable(feature = "core", reason = "needs review")]
pub mod bytes { pub mod bytes {
use ptr; use ptr;
use slice::SliceExt; use slice::SliceExt;
@ -1508,7 +1508,7 @@ impl<T: PartialOrd> PartialOrd for [T] {
} }
/// Extension methods for slices containing integers. /// Extension methods for slices containing integers.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
pub trait IntSliceExt<U, S> { pub trait IntSliceExt<U, S> {
/// Converts the slice to an immutable slice of unsigned integers with the same width. /// Converts the slice to an immutable slice of unsigned integers with the same width.
fn as_unsigned<'a>(&'a self) -> &'a [U]; fn as_unsigned<'a>(&'a self) -> &'a [U];
@ -1523,7 +1523,7 @@ pub trait IntSliceExt<U, S> {
macro_rules! impl_int_slice { macro_rules! impl_int_slice {
($u:ty, $s:ty, $t:ty) => { ($u:ty, $s:ty, $t:ty) => {
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "core")]
impl IntSliceExt<$u, $s> for [$t] { impl IntSliceExt<$u, $s> for [$t] {
#[inline] #[inline]
fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } } fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } }

16
src/libcore/str/mod.rs
View file

@ -108,7 +108,7 @@ macro_rules! delegate_iter {
/// A trait to abstract the idea of creating a new instance of a type from a /// A trait to abstract the idea of creating a new instance of a type from a
/// string. /// string.
// FIXME(#17307): there should be an `E` associated type for a `Result` return // FIXME(#17307): there should be an `E` associated type for a `Result` return
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "will return a Result once associated types are working")] reason = "will return a Result once associated types are working")]
pub trait FromStr { pub trait FromStr {
/// Parses a string `s` to return an optional value of this type. If the /// Parses a string `s` to return an optional value of this type. If the
@ -144,7 +144,7 @@ Section: Creating a string
/// Errors which can occur when attempting to interpret a byte slice as a `str`. /// Errors which can occur when attempting to interpret a byte slice as a `str`.
#[derive(Copy, Eq, PartialEq, Clone, Show)] #[derive(Copy, Eq, PartialEq, Clone, Show)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "error enumeration recently added and definitions may be refined")] reason = "error enumeration recently added and definitions may be refined")]
pub enum Utf8Error { pub enum Utf8Error {
/// An invalid byte was detected at the byte offset given. /// An invalid byte was detected at the byte offset given.
@ -208,7 +208,7 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str {
} }
/// Something that can be used to compare against a character /// Something that can be used to compare against a character
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "definition may change as pattern-related methods are stabilized")] reason = "definition may change as pattern-related methods are stabilized")]
pub trait CharEq { pub trait CharEq {
/// Determine if the splitter should split at the given character /// Determine if the splitter should split at the given character
@ -861,7 +861,7 @@ impl Searcher {
/// An iterator over the start and end indices of the matches of a /// An iterator over the start and end indices of the matches of a
/// substring within a larger string /// substring within a larger string
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", reason = "type may be removed")] #[unstable(feature = "core", reason = "type may be removed")]
pub struct MatchIndices<'a> { pub struct MatchIndices<'a> {
// constants // constants
haystack: &'a str, haystack: &'a str,
@ -872,7 +872,7 @@ pub struct MatchIndices<'a> {
/// An iterator over the substrings of a string separated by a given /// An iterator over the substrings of a string separated by a given
/// search string /// search string
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", reason = "type may be removed")] #[unstable(feature = "core", reason = "type may be removed")]
pub struct SplitStr<'a> { pub struct SplitStr<'a> {
it: MatchIndices<'a>, it: MatchIndices<'a>,
last_end: uint, last_end: uint,
@ -1056,7 +1056,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
/// the next `char` in a string. This can be used as a data structure /// the next `char` in a string. This can be used as a data structure
/// for iterating over the UTF-8 bytes of a string. /// for iterating over the UTF-8 bytes of a string.
#[derive(Copy)] #[derive(Copy)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "naming is uncertain with container conventions")] reason = "naming is uncertain with container conventions")]
pub struct CharRange { pub struct CharRange {
/// Current `char` /// Current `char`
@ -1151,7 +1151,7 @@ mod traits {
} }
/// Any string that can be represented as a slice /// Any string that can be represented as a slice
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "Instead of taking this bound generically, this trait will be \ reason = "Instead of taking this bound generically, this trait will be \
replaced with one of slicing syntax, deref coercions, or \ replaced with one of slicing syntax, deref coercions, or \
a more generic conversion trait")] a more generic conversion trait")]
@ -1178,7 +1178,7 @@ delegate_iter!{pattern &'a str : Split<'a, P>}
/// Return type of `StrExt::split_terminator` /// Return type of `StrExt::split_terminator`
#[derive(Clone)] #[derive(Clone)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "core",
reason = "might get removed in favour of a constructor method on Split")] reason = "might get removed in favour of a constructor method on Split")]
pub struct SplitTerminator<'a, P>(CharSplits<'a, P>); pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
delegate_iter!{pattern &'a str : SplitTerminator<'a, P>} delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}

1
src/libcoretest/lib.rs
View file

@ -11,7 +11,6 @@
#![feature(unsafe_destructor, slicing_syntax)] #![feature(unsafe_destructor, slicing_syntax)]
#![feature(unboxed_closures)] #![feature(unboxed_closures)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
extern crate core; extern crate core;

6
src/libflate/lib.rs
View file

@ -15,16 +15,18 @@
//! [mz]: https://code.google.com/p/miniz/ //! [mz]: https://code.google.com/p/miniz/
#![crate_name = "flate"] #![crate_name = "flate"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(unnamed_feature)]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![crate_type = "dylib"] #![crate_type = "dylib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")] html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(hash)]
#![feature(core)]
#![feature(libc)]
#[cfg(test)] #[macro_use] extern crate log; #[cfg(test)] #[macro_use] extern crate log;

6
src/libfmt_macros/lib.rs
View file

@ -15,7 +15,7 @@
//! generated instead. //! generated instead.
#![crate_name = "fmt_macros"] #![crate_name = "fmt_macros"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -27,7 +27,9 @@
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(unnamed_feature)] #![feature(collections)]
#![feature(core)]
#![feature(unicode)]
pub use self::Piece::*; pub use self::Piece::*;
pub use self::Position::*; pub use self::Position::*;

5
src/libgetopts/lib.rs
View file

@ -78,7 +78,7 @@
//! ``` //! ```
#![crate_name = "getopts"] #![crate_name = "getopts"]
#![unstable(feature = "unnamed_feature", #![unstable(feature = "rustc_private",
reason = "use the crates.io `getopts` library instead")] reason = "use the crates.io `getopts` library instead")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
@ -89,9 +89,10 @@
html_root_url = "http://doc.rust-lang.org/nightly/", html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)] #![deny(missing_docs)]
#![feature(collections)]
#![feature(core)]
#[cfg(test)] #[macro_use] extern crate log; #[cfg(test)] #[macro_use] extern crate log;

7
src/libgraphviz/lib.rs
View file

@ -265,7 +265,7 @@
//! * [DOT language](http://www.graphviz.org/doc/info/lang.html) //! * [DOT language](http://www.graphviz.org/doc/info/lang.html)
#![crate_name = "graphviz"] #![crate_name = "graphviz"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -274,8 +274,11 @@
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")] html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(path)]
use self::LabelText::*; use self::LabelText::*;

5
src/liblibc/lib.rs
View file

@ -11,10 +11,10 @@
#![crate_name = "libc"] #![crate_name = "libc"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![cfg_attr(not(feature = "cargo-build"), #![cfg_attr(not(feature = "cargo-build"),
unstable(feature = "unnamed_feature"))] unstable(feature = "libc"))]
#![cfg_attr(not(feature = "cargo-build"), feature(staged_api))] #![cfg_attr(not(feature = "cargo-build"), feature(staged_api))]
#![cfg_attr(not(feature = "cargo-build"), staged_api)] #![cfg_attr(not(feature = "cargo-build"), staged_api)]
#![cfg_attr(not(feature = "cargo-build"), feature(unnamed_feature))] #![cfg_attr(not(feature = "cargo-build"), feature(core))]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![no_std] #![no_std]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@ -75,7 +75,6 @@
//! one from Berkeley after the lawsuits died down and the CSRG dissolved. //! one from Berkeley after the lawsuits died down and the CSRG dissolved.
#![allow(bad_style, raw_pointer_derive)] #![allow(bad_style, raw_pointer_derive)]
#![cfg_attr(not(feature = "cargo-build"), feature(unnamed_feature))]
#[cfg(feature = "cargo-build")] extern crate "std" as core; #[cfg(feature = "cargo-build")] extern crate "std" as core;
#[cfg(not(feature = "cargo-build"))] extern crate core; #[cfg(not(feature = "cargo-build"))] extern crate core;

9
src/liblog/lib.rs
View file

@ -156,7 +156,7 @@
//! if logging is disabled, none of the components of the log will be executed. //! if logging is disabled, none of the components of the log will be executed.
#![crate_name = "log"] #![crate_name = "log"]
#![unstable(feature = "unnamed_feature", #![unstable(feature = "rustc_private",
reason = "use the crates.io `log` library instead")] reason = "use the crates.io `log` library instead")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
@ -170,9 +170,14 @@
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)] #![deny(missing_docs)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(os)]
#![feature(rustc_private)]
#![feature(std_misc)]
extern crate regex; extern crate regex;

2
src/librand/distributions/mod.rs
View file

@ -17,7 +17,7 @@
//! internally. The `IndependentSample` trait is for generating values //! internally. The `IndependentSample` trait is for generating values
//! that do not need to record state. //! that do not need to record state.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rand")]
use core::prelude::*; use core::prelude::*;
use core::num::{Float, Int}; use core::num::{Float, Int};

4
src/librand/lib.rs
View file

@ -22,12 +22,12 @@
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/", html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![no_std] #![no_std]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rand")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![feature(core)]
#[macro_use] #[macro_use]
extern crate core; extern crate core;

7
src/librbml/lib.rs
View file

@ -16,7 +16,7 @@
//! http://www.matroska.org/technical/specs/rfc/index.html //! http://www.matroska.org/technical/specs/rfc/index.html
#![crate_name = "rbml"] #![crate_name = "rbml"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
@ -27,8 +27,11 @@
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(rustc_private)]
extern crate serialize; extern crate serialize;
#[macro_use] extern crate log; #[macro_use] extern crate log;

6
src/libregex/lib.rs
View file

@ -16,7 +16,7 @@
#![crate_name = "regex"] #![crate_name = "regex"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![crate_type = "dylib"] #![crate_type = "dylib"]
#![unstable(feature = "unnamed_feature", #![unstable(feature = "rustc_private",
reason = "use the crates.io `regex` library instead")] reason = "use the crates.io `regex` library instead")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
@ -28,9 +28,11 @@
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)] #![deny(missing_docs)]
#![feature(collections)]
#![feature(core)]
#![feature(unicode)]
#[cfg(test)] #[cfg(test)]
extern crate "test" as stdtest; extern crate "test" as stdtest;

1
src/libregex/re.rs
View file

@ -255,7 +255,6 @@ impl Regex {
} }
#[doc(hidden)] #[doc(hidden)]
#[unstable(feature = "unnamed_feature")]
pub fn names_iter<'a>(&'a self) -> NamesIter<'a> { pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
match *self { match *self {
Native(ref n) => NamesIterNative(n.names.iter()), Native(ref n) => NamesIterNative(n.names.iter()),

13
src/librustc/lib.rs
View file

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change. //! This API is completely unstable and subject to change.
#![crate_name = "rustc"] #![crate_name = "rustc"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -28,9 +28,18 @@
#![feature(quote)] #![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)] #![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(libc)]
#![feature(os)]
#![feature(path)]
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(unicode)]
#![feature(hash)]
extern crate arena; extern crate arena;
extern crate flate; extern crate flate;

10
src/librustc_back/lib.rs
View file

@ -22,7 +22,7 @@
//! build speedups. //! build speedups.
#![crate_name = "rustc_back"] #![crate_name = "rustc_back"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -32,8 +32,14 @@
html_root_url = "http://doc.rust-lang.org/nightly/")] html_root_url = "http://doc.rust-lang.org/nightly/")]
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(slicing_syntax, box_syntax)] #![feature(slicing_syntax, box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(hash)]
#![feature(io)]
#![feature(os)]
#![feature(path)]
#![feature(rustc_private)]
extern crate syntax; extern crate syntax;
extern crate serialize; extern crate serialize;

2
src/librustc_bitflags/lib.rs
View file

@ -14,7 +14,7 @@
#![staged_api] #![staged_api]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![no_std] #![no_std]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
//! A typesafe bitmask flag generator. //! A typesafe bitmask flag generator.

6
src/librustc_borrowck/lib.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
#![crate_name = "rustc_borrowck"] #![crate_name = "rustc_borrowck"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -22,9 +22,11 @@
#![feature(quote)] #![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)] #![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
#![feature(collections)]
#![feature(core)]
#![feature(rustc_private)]
#[macro_use] extern crate log; #[macro_use] extern crate log;
#[macro_use] extern crate syntax; #[macro_use] extern crate syntax;

12
src/librustc_driver/lib.rs
View file

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change. //! This API is completely unstable and subject to change.
#![crate_name = "rustc_driver"] #![crate_name = "rustc_driver"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -29,8 +29,16 @@
#![feature(slicing_syntax, unsafe_destructor)] #![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(libc)]
#![feature(os)]
#![feature(path)]
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(unicode)]
extern crate arena; extern crate arena;
extern crate flate; extern crate flate;

8
src/librustc_llvm/lib.rs
View file

@ -14,7 +14,7 @@
#![allow(dead_code)] #![allow(dead_code)]
#![crate_name = "rustc_llvm"] #![crate_name = "rustc_llvm"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -26,8 +26,12 @@
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(link_args)] #![feature(link_args)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(libc)]
#![feature(path)]
#![feature(std_misc)]
extern crate libc; extern crate libc;
#[macro_use] #[no_link] extern crate rustc_bitflags; #[macro_use] #[no_link] extern crate rustc_bitflags;

6
src/librustc_privacy/lib.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
#![crate_name = "rustc_privacy"] #![crate_name = "rustc_privacy"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -19,8 +19,10 @@
html_root_url = "http://doc.rust-lang.org/nightly/")] html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(rustc_private)]
#[macro_use] extern crate log; #[macro_use] extern crate log;
#[macro_use] extern crate syntax; #[macro_use] extern crate syntax;

8
src/librustc_resolve/lib.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
#![crate_name = "rustc_resolve"] #![crate_name = "rustc_resolve"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -20,8 +20,12 @@
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(alloc)]
#![feature(collections)]
#![feature(core)]
#![feature(rustc_private)]
#![feature(std_misc)]
#[macro_use] extern crate log; #[macro_use] extern crate log;
#[macro_use] extern crate syntax; #[macro_use] extern crate syntax;

13
src/librustc_trans/lib.rs
View file

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change. //! This API is completely unstable and subject to change.
#![crate_name = "rustc_trans"] #![crate_name = "rustc_trans"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -29,8 +29,17 @@
#![feature(slicing_syntax, unsafe_destructor)] #![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(alloc)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(libc)]
#![feature(os)]
#![feature(path)]
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(unicode)]
extern crate arena; extern crate arena;
extern crate flate; extern crate flate;

7
src/librustc_typeck/lib.rs
View file

@ -64,7 +64,7 @@ This API is completely unstable and subject to change.
*/ */
#![crate_name = "rustc_typeck"] #![crate_name = "rustc_typeck"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustc_private")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -78,9 +78,12 @@ This API is completely unstable and subject to change.
#![feature(slicing_syntax, unsafe_destructor)] #![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
#![feature(collections)]
#![feature(core)]
#![feature(rustc_private)]
#![feature(std_misc)]
#[macro_use] extern crate log; #[macro_use] extern crate log;
#[macro_use] extern crate syntax; #[macro_use] extern crate syntax;

13
src/librustdoc/lib.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
#![crate_name = "rustdoc"] #![crate_name = "rustdoc"]
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "rustdoc")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
#![crate_type = "dylib"] #![crate_type = "dylib"]
@ -20,8 +20,17 @@
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(libc)]
#![feature(os)]
#![feature(path)]
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(test)]
#![feature(unicode)]
extern crate arena; extern crate arena;
extern crate getopts; extern crate getopts;

10
src/libserialize/lib.rs
View file

@ -15,7 +15,7 @@ Core encoding and decoding interfaces.
*/ */
#![crate_name = "serialize"] #![crate_name = "serialize"]
#![unstable(feature = "unnamed_feature", #![unstable(feature = "rustc_private",
reason = "deprecated in favor of rustc-serialize on crates.io")] reason = "deprecated in favor of rustc-serialize on crates.io")]
#![feature(staged_api)] #![feature(staged_api)]
#![staged_api] #![staged_api]
@ -29,8 +29,14 @@ Core encoding and decoding interfaces.
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(old_impl_check)] #![feature(old_impl_check)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)] #![allow(unknown_features)] #![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(io)]
#![feature(path)]
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(unicode)]
// test harness access // test harness access
#[cfg(test)] extern crate test; #[cfg(test)] extern crate test;

20
src/libstd/ascii.rs
View file

@ -12,7 +12,7 @@
//! Operations on ASCII strings and characters //! Operations on ASCII strings and characters
#![unstable(feature = "unnamed_feature", #![unstable(feature = "std_misc",
reason = "unsure about placement and naming")] reason = "unsure about placement and naming")]
use iter::IteratorExt; use iter::IteratorExt;
@ -23,7 +23,7 @@ use string::String;
use vec::Vec; use vec::Vec;
/// Extension methods for ASCII-subset only operations on owned strings /// Extension methods for ASCII-subset only operations on owned strings
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
pub trait OwnedAsciiExt { pub trait OwnedAsciiExt {
/// Convert the string to ASCII upper case: /// Convert the string to ASCII upper case:
@ -38,7 +38,7 @@ pub trait OwnedAsciiExt {
} }
/// Extension methods for ASCII-subset only operations on string slices /// Extension methods for ASCII-subset only operations on string slices
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
pub trait AsciiExt<T = Self> { pub trait AsciiExt<T = Self> {
/// Check if within the ASCII range. /// Check if within the ASCII range.
@ -60,7 +60,7 @@ pub trait AsciiExt<T = Self> {
fn eq_ignore_ascii_case(&self, other: &Self) -> bool; fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl AsciiExt<String> for str { impl AsciiExt<String> for str {
#[inline] #[inline]
@ -86,7 +86,7 @@ impl AsciiExt<String> for str {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl OwnedAsciiExt for String { impl OwnedAsciiExt for String {
#[inline] #[inline]
@ -102,7 +102,7 @@ impl OwnedAsciiExt for String {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl AsciiExt<Vec<u8>> for [u8] { impl AsciiExt<Vec<u8>> for [u8] {
#[inline] #[inline]
@ -129,7 +129,7 @@ impl AsciiExt<Vec<u8>> for [u8] {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl OwnedAsciiExt for Vec<u8> { impl OwnedAsciiExt for Vec<u8> {
#[inline] #[inline]
@ -149,7 +149,7 @@ impl OwnedAsciiExt for Vec<u8> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl AsciiExt for u8 { impl AsciiExt for u8 {
#[inline] #[inline]
@ -173,7 +173,7 @@ impl AsciiExt for u8 {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")] reason = "would prefer to do this in a more general way")]
impl AsciiExt for char { impl AsciiExt for char {
#[inline] #[inline]
@ -216,7 +216,7 @@ impl AsciiExt for char {
/// - Any other chars in the range [0x20,0x7e] are not escaped. /// - Any other chars in the range [0x20,0x7e] are not escaped.
/// - Any other chars are given hex escapes. /// - Any other chars are given hex escapes.
/// - Unicode escapes are never generated by this function. /// - Unicode escapes are never generated by this function.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "needs to be updated to use an iterator")] reason = "needs to be updated to use an iterator")]
pub fn escape_default<F>(c: u8, mut f: F) where pub fn escape_default<F>(c: u8, mut f: F) where
F: FnMut(u8), F: FnMut(u8),

30
src/libstd/collections/hash/map.rs
View file

@ -539,7 +539,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// map.insert(1i, 2u); /// map.insert(1i, 2u);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> { pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> {
HashMap { HashMap {
hash_state: hash_state, hash_state: hash_state,
@ -567,7 +567,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// map.insert(1i, 2u); /// map.insert(1i, 2u);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
-> HashMap<K, V, S> { -> HashMap<K, V, S> {
let resize_policy = DefaultResizePolicy::new(); let resize_policy = DefaultResizePolicy::new();
@ -928,7 +928,7 @@ impl<K, V, S, H> HashMap<K, V, S>
} }
/// Gets the given key's corresponding entry in the map for in-place manipulation. /// Gets the given key's corresponding entry in the map for in-place manipulation.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "precise API still being fleshed out")] reason = "precise API still being fleshed out")]
pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
{ {
@ -990,7 +990,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// assert!(a.is_empty()); /// assert!(a.is_empty());
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<K, V> { pub fn drain(&mut self) -> Drain<K, V> {
fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) } fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
@ -1339,7 +1339,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> {
} }
/// HashMap drain iterator /// HashMap drain iterator
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub struct Drain<'a, K: 'a, V: 'a> { pub struct Drain<'a, K: 'a, V: 'a> {
inner: iter::Map< inner: iter::Map<
@ -1351,14 +1351,14 @@ pub struct Drain<'a, K: 'a, V: 'a> {
} }
/// A view into a single occupied location in a HashMap /// A view into a single occupied location in a HashMap
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "precise API still being fleshed out")] reason = "precise API still being fleshed out")]
pub struct OccupiedEntry<'a, K: 'a, V: 'a> { pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
elem: FullBucket<K, V, &'a mut RawTable<K, V>>, elem: FullBucket<K, V, &'a mut RawTable<K, V>>,
} }
/// A view into a single empty location in a HashMap /// A view into a single empty location in a HashMap
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "precise API still being fleshed out")] reason = "precise API still being fleshed out")]
pub struct VacantEntry<'a, K: 'a, V: 'a> { pub struct VacantEntry<'a, K: 'a, V: 'a> {
hash: SafeHash, hash: SafeHash,
@ -1367,7 +1367,7 @@ pub struct VacantEntry<'a, K: 'a, V: 'a> {
} }
/// A view into a single location in a map, which may be vacant or occupied /// A view into a single location in a map, which may be vacant or occupied
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "precise API still being fleshed out")] reason = "precise API still being fleshed out")]
pub enum Entry<'a, K: 'a, V: 'a> { pub enum Entry<'a, K: 'a, V: 'a> {
/// An occupied Entry /// An occupied Entry
@ -1457,7 +1457,7 @@ impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
#[inline] fn len(&self) -> usize { self.inner.len() } #[inline] fn len(&self) -> usize { self.inner.len() }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K, V> Entry<'a, K, V> { impl<'a, K, V> Entry<'a, K, V> {
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
@ -1469,7 +1469,7 @@ impl<'a, K, V> Entry<'a, K, V> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K, V> OccupiedEntry<'a, K, V> { impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry /// Gets a reference to the value in the entry
@ -1501,7 +1501,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform v2 specification, waiting for dust to settle")] reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key, /// Sets the value of the entry with the VacantEntry's key,
@ -1554,14 +1554,14 @@ impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S>
/// instances are unlikely to produce the same result for the same values. /// instances are unlikely to produce the same result for the same values.
#[derive(Clone)] #[derive(Clone)]
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")] reason = "hashing an hash maps may be altered")]
pub struct RandomState { pub struct RandomState {
k0: u64, k0: u64,
k1: u64, k1: u64,
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")] reason = "hashing an hash maps may be altered")]
impl RandomState { impl RandomState {
/// Construct a new `RandomState` that is initialized with random keys. /// Construct a new `RandomState` that is initialized with random keys.
@ -1572,7 +1572,7 @@ impl RandomState {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")] reason = "hashing an hash maps may be altered")]
impl HashState for RandomState { impl HashState for RandomState {
type Hasher = Hasher; type Hasher = Hasher;
@ -1581,7 +1581,7 @@ impl HashState for RandomState {
} }
} }
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")] reason = "hashing an hash maps may be altered")]
impl Default for RandomState { impl Default for RandomState {
#[inline] #[inline]

6
src/libstd/collections/hash/set.rs
View file

@ -147,7 +147,7 @@ impl<T, S, H> HashSet<T, S>
/// set.insert(2u); /// set.insert(2u);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
pub fn with_hash_state(hash_state: S) -> HashSet<T, S> { pub fn with_hash_state(hash_state: S) -> HashSet<T, S> {
HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state) HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state)
} }
@ -171,7 +171,7 @@ impl<T, S, H> HashSet<T, S>
/// set.insert(1i); /// set.insert(1i);
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
-> HashSet<T, S> { -> HashSet<T, S> {
HashSet { HashSet {
@ -419,7 +419,7 @@ impl<T, S, H> HashSet<T, S>
/// Clears the set, returning all elements in an iterator. /// Clears the set, returning all elements in an iterator.
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")] reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> { pub fn drain(&mut self) -> Drain<T> {
fn first<A, B>((a, _): (A, B)) -> A { a } fn first<A, B>((a, _): (A, B)) -> A { a }

2
src/libstd/collections/mod.rs
View file

@ -337,7 +337,7 @@ pub mod hash_set {
/// Experimental support for providing custom hash algorithms to a HashMap and /// Experimental support for providing custom hash algorithms to a HashMap and
/// HashSet. /// HashSet.
#[unstable(feature = "unnamed_feature", reason = "module was recently added")] #[unstable(feature = "std_misc", reason = "module was recently added")]
pub mod hash_state { pub mod hash_state {
pub use super::hash::state::*; pub use super::hash::state::*;
} }

2
src/libstd/dynamic_lib.rs
View file

@ -12,7 +12,7 @@
//! //!
//! A simple wrapper over the platform's dynamic library facilities //! A simple wrapper over the platform's dynamic library facilities
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
#![allow(missing_docs)] #![allow(missing_docs)]
use prelude::v1::*; use prelude::v1::*;

2
src/libstd/error.rs
View file

@ -86,7 +86,7 @@ use str::Utf8Error;
use string::{FromUtf8Error, FromUtf16Error}; use string::{FromUtf8Error, FromUtf16Error};
/// Base functionality for all errors in Rust. /// Base functionality for all errors in Rust.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "the exact API of this trait may change")] reason = "the exact API of this trait may change")]
pub trait Error { pub trait Error {
/// A short description of the error; usually a static string. /// A short description of the error; usually a static string.

2
src/libstd/failure.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
use prelude::v1::*; use prelude::v1::*;

2
src/libstd/ffi/mod.rs
View file

@ -10,7 +10,7 @@
//! Utilities related to FFI bindings. //! Utilities related to FFI bindings.
#![unstable(feature = "unnamed_feature", #![unstable(feature = "std_misc",
reason = "module just underwent fairly large reorganization and the dust \ reason = "module just underwent fairly large reorganization and the dust \
still needs to settle")] still needs to settle")]

4
src/libstd/fmt.rs
View file

@ -403,7 +403,7 @@
//! them with the same character. For example, the `{` character is escaped with //! them with the same character. For example, the `{` character is escaped with
//! `{{` and the `}` character is escaped with `}}`. //! `{{` and the `}` character is escaped with `}}`.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
use string; use string;
@ -432,7 +432,7 @@ pub use core::fmt::{argument, argumentuint};
/// let s = fmt::format(format_args!("Hello, {}!", "world")); /// let s = fmt::format(format_args!("Hello, {}!", "world"));
/// assert_eq!(s, "Hello, world!".to_string()); /// assert_eq!(s, "Hello, world!".to_string());
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "this is an implementation detail of format! and should not \ reason = "this is an implementation detail of format! and should not \
be called directly")] be called directly")]
pub fn format(args: Arguments) -> string::String { pub fn format(args: Arguments) -> string::String {

6
src/libstd/io/mod.rs
View file

@ -219,7 +219,7 @@
//! concerned with error handling; instead its caller is responsible for //! concerned with error handling; instead its caller is responsible for
//! responding to errors that may occur while attempting to read the numbers. //! responding to errors that may occur while attempting to read the numbers.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "io")]
#![deny(unused_must_use)] #![deny(unused_must_use)]
pub use self::SeekStyle::*; pub use self::SeekStyle::*;
@ -1743,7 +1743,7 @@ pub struct FileStat {
/// ///
/// Usage of this field is discouraged, but if access is desired then the /// Usage of this field is discouraged, but if access is desired then the
/// fields are located here. /// fields are located here.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub unstable: UnstableFileStat, pub unstable: UnstableFileStat,
} }
@ -1751,7 +1751,7 @@ pub struct FileStat {
/// returned from a `stat` syscall which is not contained in the `FileStat` /// returned from a `stat` syscall which is not contained in the `FileStat`
/// structure. This information is not necessarily platform independent, and may /// structure. This information is not necessarily platform independent, and may
/// have different meanings or no meaning at all on some platforms. /// have different meanings or no meaning at all on some platforms.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
#[derive(Copy, Hash)] #[derive(Copy, Hash)]
pub struct UnstableFileStat { pub struct UnstableFileStat {
/// The ID of the device containing the file. /// The ID of the device containing the file.

12
src/libstd/io/net/pipe.rs
View file

@ -68,7 +68,7 @@ impl UnixStream {
/// ///
/// If a `timeout` with zero or negative duration is specified then /// If a `timeout` with zero or negative duration is specified then
/// the function returns `Err`, with the error kind set to `TimedOut`. /// the function returns `Err`, with the error kind set to `TimedOut`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument is likely to change types")] reason = "the timeout argument is likely to change types")]
pub fn connect_timeout<P>(path: P, timeout: Duration) pub fn connect_timeout<P>(path: P, timeout: Duration)
-> IoResult<UnixStream> -> IoResult<UnixStream>
@ -108,7 +108,7 @@ impl UnixStream {
/// Sets the read/write timeout for this socket. /// Sets the read/write timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms) self.inner.set_timeout(timeout_ms)
@ -117,7 +117,7 @@ impl UnixStream {
/// Sets the read timeout for this socket. /// Sets the read timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms) self.inner.set_read_timeout(timeout_ms)
@ -126,7 +126,7 @@ impl UnixStream {
/// Sets the write timeout for this socket. /// Sets the write timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms) self.inner.set_write_timeout(timeout_ms)
@ -221,7 +221,7 @@ impl UnixAcceptor {
/// When using this method, it is likely necessary to reset the timeout as /// When using this method, it is likely necessary to reset the timeout as
/// appropriate, the timeout specified is specific to this object, not /// appropriate, the timeout specified is specific to this object, not
/// specific to the next request. /// specific to the next request.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the name and arguments to this function are likely \ reason = "the name and arguments to this function are likely \
to change")] to change")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
@ -232,7 +232,7 @@ impl UnixAcceptor {
/// ///
/// This function has the same semantics as `TcpAcceptor::close_accept`, and /// This function has the same semantics as `TcpAcceptor::close_accept`, and
/// more information can be found in that documentation. /// more information can be found in that documentation.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn close_accept(&mut self) -> IoResult<()> { pub fn close_accept(&mut self) -> IoResult<()> {
self.inner.close_accept() self.inner.close_accept()
} }

16
src/libstd/io/net/tcp.rs
View file

@ -85,7 +85,7 @@ impl TcpStream {
/// ///
/// If a `timeout` with zero or negative duration is specified then /// If a `timeout` with zero or negative duration is specified then
/// the function returns `Err`, with the error kind set to `TimedOut`. /// the function returns `Err`, with the error kind set to `TimedOut`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may eventually change types")] reason = "the timeout argument may eventually change types")]
pub fn connect_timeout<A: ToSocketAddr>(addr: A, pub fn connect_timeout<A: ToSocketAddr>(addr: A,
timeout: Duration) -> IoResult<TcpStream> { timeout: Duration) -> IoResult<TcpStream> {
@ -110,7 +110,7 @@ impl TcpStream {
} }
/// Sets the nodelay flag on this connection to the boolean specified /// Sets the nodelay flag on this connection to the boolean specified
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> { pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> {
self.inner.set_nodelay(nodelay) self.inner.set_nodelay(nodelay)
} }
@ -120,7 +120,7 @@ impl TcpStream {
/// If the value specified is `None`, then the keepalive flag is cleared on /// If the value specified is `None`, then the keepalive flag is cleared on
/// this connection. Otherwise, the keepalive timeout will be set to the /// this connection. Otherwise, the keepalive timeout will be set to the
/// specified time, in seconds. /// specified time, in seconds.
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> { pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> {
self.inner.set_keepalive(delay_in_seconds) self.inner.set_keepalive(delay_in_seconds)
} }
@ -188,7 +188,7 @@ impl TcpStream {
/// ///
/// For clarification on the semantics of interrupting a read and a write, /// For clarification on the semantics of interrupting a read and a write,
/// take a look at `set_read_timeout` and `set_write_timeout`. /// take a look at `set_read_timeout` and `set_write_timeout`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms) self.inner.set_timeout(timeout_ms)
@ -206,7 +206,7 @@ impl TcpStream {
/// action is taken. Otherwise, the read operation will be scheduled to /// action is taken. Otherwise, the read operation will be scheduled to
/// promptly return. If a timeout error is returned, then no data was read /// promptly return. If a timeout error is returned, then no data was read
/// during the timeout period. /// during the timeout period.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms) self.inner.set_read_timeout(timeout_ms)
@ -234,7 +234,7 @@ impl TcpStream {
/// does not know how many bytes were written as part of the timeout /// does not know how many bytes were written as part of the timeout
/// operation. It may be the case that bytes continue to be written in an /// operation. It may be the case that bytes continue to be written in an
/// asynchronous fashion after the call to write returns. /// asynchronous fashion after the call to write returns.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms) self.inner.set_write_timeout(timeout_ms)
@ -398,7 +398,7 @@ impl TcpAcceptor {
/// a.set_timeout(None); /// a.set_timeout(None);
/// let socket = a.accept(); /// let socket = a.accept();
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the type of the argument and name of this function are \ reason = "the type of the argument and name of this function are \
subject to change")] subject to change")]
pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); } pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); }
@ -445,7 +445,7 @@ impl TcpAcceptor {
/// // Signal our accept loop to exit /// // Signal our accept loop to exit
/// assert!(a.close_accept().is_ok()); /// assert!(a.close_accept().is_ok());
/// ``` /// ```
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn close_accept(&mut self) -> IoResult<()> { pub fn close_accept(&mut self) -> IoResult<()> {
self.inner.close_accept() self.inner.close_accept()
} }

18
src/libstd/io/net/udp.rs
View file

@ -92,13 +92,13 @@ impl UdpSocket {
} }
/// Joins a multicast IP address (becomes a member of it) /// Joins a multicast IP address (becomes a member of it)
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> {
self.inner.join_multicast(multi) self.inner.join_multicast(multi)
} }
/// Leaves a multicast IP address (drops membership from it) /// Leaves a multicast IP address (drops membership from it)
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn leave_multicast(&mut self, multi: IpAddr) -> IoResult<()> { pub fn leave_multicast(&mut self, multi: IpAddr) -> IoResult<()> {
self.inner.leave_multicast(multi) self.inner.leave_multicast(multi)
} }
@ -106,25 +106,25 @@ impl UdpSocket {
/// Set the multicast loop flag to the specified value /// Set the multicast loop flag to the specified value
/// ///
/// This lets multicast packets loop back to local sockets (if enabled) /// This lets multicast packets loop back to local sockets (if enabled)
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> { pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> {
self.inner.set_multicast_loop(on) self.inner.set_multicast_loop(on)
} }
/// Sets the multicast TTL /// Sets the multicast TTL
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> { pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> {
self.inner.multicast_time_to_live(ttl) self.inner.multicast_time_to_live(ttl)
} }
/// Sets this socket's TTL /// Sets this socket's TTL
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> { pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> {
self.inner.time_to_live(ttl) self.inner.time_to_live(ttl)
} }
/// Sets the broadcast flag on or off /// Sets the broadcast flag on or off
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "io")]
pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> { pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> {
self.inner.set_broadcast(broadcast) self.inner.set_broadcast(broadcast)
} }
@ -132,7 +132,7 @@ impl UdpSocket {
/// Sets the read/write timeout for this socket. /// Sets the read/write timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms) self.inner.set_timeout(timeout_ms)
@ -141,7 +141,7 @@ impl UdpSocket {
/// Sets the read timeout for this socket. /// Sets the read timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms) self.inner.set_read_timeout(timeout_ms)
@ -150,7 +150,7 @@ impl UdpSocket {
/// Sets the write timeout for this socket. /// Sets the write timeout for this socket.
/// ///
/// For more information, see `TcpStream::set_timeout` /// For more information, see `TcpStream::set_timeout`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")] reason = "the timeout argument may change in type and value")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms) self.inner.set_write_timeout(timeout_ms)

2
src/libstd/io/process.rs
View file

@ -689,7 +689,7 @@ impl Process {
/// p.wait() /// p.wait()
/// } /// }
/// ``` /// ```
#[unstable(feature = "unnamed_feature", #[unstable(feature = "io",
reason = "the type of the timeout is likely to change")] reason = "the type of the timeout is likely to change")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0); self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0);

8
src/libstd/lib.rs
View file

@ -114,7 +114,13 @@
#![feature(optin_builtin_traits)] #![feature(optin_builtin_traits)]
#![feature(int_uint)] #![feature(int_uint)]
#![feature(int_uint)] #![feature(int_uint)]
#![feature(unnamed_feature)] #![feature(core)]
#![feature(libc)]
#![feature(alloc)]
#![feature(unicode)]
#![feature(collections)]
#![feature(rand)]
#![feature(hash)]
// Don't link to std. We are std. // Don't link to std. We are std.
#![no_std] #![no_std]

4
src/libstd/macros.rs
View file

@ -14,7 +14,7 @@
//! library. Each macro is available for use when linking against the standard //! library. Each macro is available for use when linking against the standard
//! library. //! library.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
/// The entry point for panic of Rust tasks. /// The entry point for panic of Rust tasks.
/// ///
@ -148,7 +148,7 @@ macro_rules! try {
/// ///
/// For more information about select, see the `std::sync::mpsc::Select` structure. /// For more information about select, see the `std::sync::mpsc::Select` structure.
#[macro_export] #[macro_export]
#[unstable(feature = "unnamed_feature")] #[unstable(feature = "std_misc")]
macro_rules! select { macro_rules! select {
( (
$($name:pat = $rx:ident.$meth:ident() => $code:expr),+ $($name:pat = $rx:ident.$meth:ident() => $code:expr),+

14
src/libstd/num/f32.rs
View file

@ -366,7 +366,7 @@ impl Float for f32 {
/// ///
/// * num - The float value /// * num - The float value
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_string(num: f32) -> String { pub fn to_string(num: f32) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigAll, ExpNone, false); num, 10u, true, SignNeg, DigAll, ExpNone, false);
@ -379,7 +379,7 @@ pub fn to_string(num: f32) -> String {
/// ///
/// * num - The float value /// * num - The float value
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_hex(num: f32) -> String { pub fn to_str_hex(num: f32) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 16u, true, SignNeg, DigAll, ExpNone, false); num, 16u, true, SignNeg, DigAll, ExpNone, false);
@ -394,7 +394,7 @@ pub fn to_str_hex(num: f32) -> String {
/// * num - The float value /// * num - The float value
/// * radix - The base to use /// * radix - The base to use
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) { pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
} }
@ -407,7 +407,7 @@ pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) {
/// * num - The float value /// * num - The float value
/// * digits - The number of significant digits /// * digits - The number of significant digits
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exact(num: f32, dig: uint) -> String { pub fn to_str_exact(num: f32, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
@ -422,7 +422,7 @@ pub fn to_str_exact(num: f32, dig: uint) -> String {
/// * num - The float value /// * num - The float value
/// * digits - The number of significant digits /// * digits - The number of significant digits
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_digits(num: f32, dig: uint) -> String { pub fn to_str_digits(num: f32, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
@ -438,7 +438,7 @@ pub fn to_str_digits(num: f32, dig: uint) -> String {
/// * digits - The number of digits after the decimal point /// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign /// * upper - Use `E` instead of `e` for the exponent sign
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String { pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
@ -454,7 +454,7 @@ pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
/// * digits - The number of digits after the decimal point /// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign /// * upper - Use `E` instead of `e` for the exponent sign
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String { pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);

14
src/libstd/num/f64.rs
View file

@ -375,7 +375,7 @@ impl Float for f64 {
/// ///
/// * num - The float value /// * num - The float value
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_string(num: f64) -> String { pub fn to_string(num: f64) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigAll, ExpNone, false); num, 10u, true, SignNeg, DigAll, ExpNone, false);
@ -388,7 +388,7 @@ pub fn to_string(num: f64) -> String {
/// ///
/// * num - The float value /// * num - The float value
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_hex(num: f64) -> String { pub fn to_str_hex(num: f64) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 16u, true, SignNeg, DigAll, ExpNone, false); num, 16u, true, SignNeg, DigAll, ExpNone, false);
@ -403,7 +403,7 @@ pub fn to_str_hex(num: f64) -> String {
/// * num - The float value /// * num - The float value
/// * radix - The base to use /// * radix - The base to use
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) { pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
} }
@ -416,7 +416,7 @@ pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) {
/// * num - The float value /// * num - The float value
/// * digits - The number of significant digits /// * digits - The number of significant digits
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exact(num: f64, dig: uint) -> String { pub fn to_str_exact(num: f64, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
@ -431,7 +431,7 @@ pub fn to_str_exact(num: f64, dig: uint) -> String {
/// * num - The float value /// * num - The float value
/// * digits - The number of significant digits /// * digits - The number of significant digits
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_digits(num: f64, dig: uint) -> String { pub fn to_str_digits(num: f64, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
@ -447,7 +447,7 @@ pub fn to_str_digits(num: f64, dig: uint) -> String {
/// * digits - The number of digits after the decimal point /// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign /// * upper - Use `E` instead of `e` for the exponent sign
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String { pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
@ -463,7 +463,7 @@ pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
/// * digits - The number of digits after the decimal point /// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign /// * upper - Use `E` instead of `e` for the exponent sign
#[inline] #[inline]
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String { pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common( let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);

2
src/libstd/num/float_macros.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
#![doc(hidden)] #![doc(hidden)]
macro_rules! assert_approx_eq { macro_rules! assert_approx_eq {

2
src/libstd/num/int_macros.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
#![doc(hidden)] #![doc(hidden)]
macro_rules! int_module { ($T:ty) => ( macro_rules! int_module { ($T:ty) => (

56
src/libstd/num/mod.rs
View file

@ -33,7 +33,7 @@ pub use core::num::{FpCategory};
use option::Option; use option::Option;
#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] #[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub mod strconv; pub mod strconv;
/// Mathematical operations on primitive floating point numbers. /// Mathematical operations on primitive floating point numbers.
@ -52,27 +52,27 @@ pub trait Float
{ {
// inlined methods from `num::Float` // inlined methods from `num::Float`
/// Returns the NaN value. /// Returns the NaN value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn nan() -> Self; fn nan() -> Self;
/// Returns the infinite value. /// Returns the infinite value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn infinity() -> Self; fn infinity() -> Self;
/// Returns the negative infinite value. /// Returns the negative infinite value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn neg_infinity() -> Self; fn neg_infinity() -> Self;
/// Returns the `0` value. /// Returns the `0` value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn zero() -> Self; fn zero() -> Self;
/// Returns -0.0. /// Returns -0.0.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn neg_zero() -> Self; fn neg_zero() -> Self;
/// Returns the `1` value. /// Returns the `1` value.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn one() -> Self; fn one() -> Self;
@ -109,37 +109,37 @@ pub trait Float
fn max_10_exp(unused_self: Option<Self>) -> int; fn max_10_exp(unused_self: Option<Self>) -> int;
/// Returns the smallest finite value that this type can represent. /// Returns the smallest finite value that this type can represent.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn min_value() -> Self; fn min_value() -> Self;
/// Returns the smallest normalized positive number that this type can represent. /// Returns the smallest normalized positive number that this type can represent.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn min_pos_value(unused_self: Option<Self>) -> Self; fn min_pos_value(unused_self: Option<Self>) -> Self;
/// Returns the largest finite value that this type can represent. /// Returns the largest finite value that this type can represent.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn max_value() -> Self; fn max_value() -> Self;
/// Returns true if this value is NaN and false otherwise. /// Returns true if this value is NaN and false otherwise.
#[unstable(feature = "unnamed_feature", reason = "position is undecided")] #[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_nan(self) -> bool; fn is_nan(self) -> bool;
/// Returns true if this value is positive infinity or negative infinity and /// Returns true if this value is positive infinity or negative infinity and
/// false otherwise. /// false otherwise.
#[unstable(feature = "unnamed_feature", reason = "position is undecided")] #[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_infinite(self) -> bool; fn is_infinite(self) -> bool;
/// Returns true if this number is neither infinite nor NaN. /// Returns true if this number is neither infinite nor NaN.
#[unstable(feature = "unnamed_feature", reason = "position is undecided")] #[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_finite(self) -> bool; fn is_finite(self) -> bool;
/// Returns true if this number is neither zero, infinite, denormal, or NaN. /// Returns true if this number is neither zero, infinite, denormal, or NaN.
#[unstable(feature = "unnamed_feature", reason = "position is undecided")] #[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_normal(self) -> bool; fn is_normal(self) -> bool;
/// Returns the category that this number falls into. /// Returns the category that this number falls into.
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
fn classify(self) -> FpCategory; fn classify(self) -> FpCategory;
/// Returns the mantissa, exponent and sign as integers, respectively. /// Returns the mantissa, exponent and sign as integers, respectively.
#[unstable(feature = "unnamed_feature", reason = "signature is undecided")] #[unstable(feature = "std_misc", reason = "signature is undecided")]
fn integer_decode(self) -> (u64, i16, i8); fn integer_decode(self) -> (u64, i16, i8);
/// Return the largest integer less than or equal to a number. /// Return the largest integer less than or equal to a number.
@ -182,11 +182,11 @@ pub trait Float
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
/// error. This produces a more accurate result with better performance than /// error. This produces a more accurate result with better performance than
/// a separate multiplication operation followed by an add. /// a separate multiplication operation followed by an add.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn mul_add(self, a: Self, b: Self) -> Self; fn mul_add(self, a: Self, b: Self) -> Self;
/// Take the reciprocal (inverse) of a number, `1/x`. /// Take the reciprocal (inverse) of a number, `1/x`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn recip(self) -> Self; fn recip(self) -> Self;
@ -205,7 +205,7 @@ pub trait Float
#[stable(feature = "grandfathered", since = "1.0.0")] #[stable(feature = "grandfathered", since = "1.0.0")]
fn sqrt(self) -> Self; fn sqrt(self) -> Self;
/// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn rsqrt(self) -> Self; fn rsqrt(self) -> Self;
@ -229,15 +229,15 @@ pub trait Float
fn log10(self) -> Self; fn log10(self) -> Self;
/// Convert radians to degrees. /// Convert radians to degrees.
#[unstable(feature = "unnamed_feature", reason = "desirability is unclear")] #[unstable(feature = "std_misc", reason = "desirability is unclear")]
fn to_degrees(self) -> Self; fn to_degrees(self) -> Self;
/// Convert degrees to radians. /// Convert degrees to radians.
#[unstable(feature = "unnamed_feature", reason = "desirability is unclear")] #[unstable(feature = "std_misc", reason = "desirability is unclear")]
fn to_radians(self) -> Self; fn to_radians(self) -> Self;
/// Constructs a floating point number created by multiplying `x` by 2 /// Constructs a floating point number created by multiplying `x` by 2
/// raised to the power of `exp`. /// raised to the power of `exp`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn ldexp(x: Self, exp: int) -> Self; fn ldexp(x: Self, exp: int) -> Self;
/// Breaks the number into a normalized fraction and a base-2 exponent, /// Breaks the number into a normalized fraction and a base-2 exponent,
@ -246,13 +246,13 @@ pub trait Float
/// * `self = x * pow(2, exp)` /// * `self = x * pow(2, exp)`
/// ///
/// * `0.5 <= abs(x) < 1.0` /// * `0.5 <= abs(x) < 1.0`
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "pending integer conventions")] reason = "pending integer conventions")]
fn frexp(self) -> (Self, int); fn frexp(self) -> (Self, int);
/// Returns the next representable floating-point value in the direction of /// Returns the next representable floating-point value in the direction of
/// `other`. /// `other`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn next_after(self, other: Self) -> Self; fn next_after(self, other: Self) -> Self;
@ -266,15 +266,15 @@ pub trait Float
/// The positive difference of two numbers. Returns `0.0` if the number is /// The positive difference of two numbers. Returns `0.0` if the number is
/// less than or equal to `other`, otherwise the difference between`self` /// less than or equal to `other`, otherwise the difference between`self`
/// and `other` is returned. /// and `other` is returned.
#[unstable(feature = "unnamed_feature", reason = "may be renamed")] #[unstable(feature = "std_misc", reason = "may be renamed")]
fn abs_sub(self, other: Self) -> Self; fn abs_sub(self, other: Self) -> Self;
/// Take the cubic root of a number. /// Take the cubic root of a number.
#[unstable(feature = "unnamed_feature", reason = "may be renamed")] #[unstable(feature = "std_misc", reason = "may be renamed")]
fn cbrt(self) -> Self; fn cbrt(self) -> Self;
/// Calculate the length of the hypotenuse of a right-angle triangle given /// Calculate the length of the hypotenuse of a right-angle triangle given
/// legs of length `x` and `y`. /// legs of length `x` and `y`.
#[unstable(feature = "unnamed_feature", #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")] reason = "unsure about its place in the world")]
fn hypot(self, other: Self) -> Self; fn hypot(self, other: Self) -> Self;
@ -313,11 +313,11 @@ pub trait Float
/// Returns the exponential of the number, minus 1, in a way that is /// Returns the exponential of the number, minus 1, in a way that is
/// accurate even if the number is close to zero. /// accurate even if the number is close to zero.
#[unstable(feature = "unnamed_feature", reason = "may be renamed")] #[unstable(feature = "std_misc", reason = "may be renamed")]
fn exp_m1(self) -> Self; fn exp_m1(self) -> Self;
/// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more /// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more
/// accurately than if the operations were performed separately. /// accurately than if the operations were performed separately.
#[unstable(feature = "unnamed_feature", reason = "may be renamed")] #[unstable(feature = "std_misc", reason = "may be renamed")]
fn ln_1p(self) -> Self; fn ln_1p(self) -> Self;
/// Hyperbolic sine function. /// Hyperbolic sine function.

2
src/libstd/num/uint_macros.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![unstable(feature = "unnamed_feature")] #![unstable(feature = "std_misc")]
#![doc(hidden)] #![doc(hidden)]
#![allow(unsigned_negation)] #![allow(unsigned_negation)]

Some files were not shown because too many files have changed in this diff Show more