#![feature(slicing_syntax, unboxed_closures)]
#![feature(box_syntax)]
#![feature(int_uint)]
-#![feature(unnamed_feature)]
#![deny(warnings)]
// except according to those terms.
#![allow(unknown_features)]
-#![feature(unnamed_feature)]
+#![cfg_attr(rustc, feature(rustc_private))]
+#![cfg_attr(rustdoc, feature(rustdoc))]
#[cfg(rustdoc)]
extern crate "rustdoc" as this;
/// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles
/// between `Arc` pointers.
#[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> {
// FIXME #12808: strange name to try to avoid interfering with
///
/// let weak_five = five.downgrade();
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
pub fn downgrade(&self) -> Weak<T> {
// See the clone() impl for why this is relaxed
/// Get the number of weak references to this value.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 }
/// Get the number of strong references to this value.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) }
#[stable(feature = "grandfathered", since = "1.0.0")]
/// let mut_five = five.make_unique();
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "alloc")]
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
// clone if there is an additional reference of either kind.
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Weak<T> {
/// Upgrades a weak reference to a strong reference.
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Clone for Weak<T> {
/// Makes a clone of the `Weak<T>`.
/// }
/// ```
#[lang = "exchange_heap"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "may be renamed; uncertain about custom allocator design")]
pub static HEAP: () = ();
}
/// 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 \
a direct impl on `Box<Any>` have been fixed ")]
// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're
///
/// These statistics may be inconsistent if other threads use the allocator
/// during the call.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn stats_print() {
imp::stats_print();
}
//! default global allocator. It is not compatible with the libc allocator API.
#![crate_name = "alloc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "alloc")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
#![feature(lang_items, unsafe_destructor)]
#![feature(box_syntax)]
#![feature(optin_builtin_traits)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(libc)]
#[macro_use]
extern crate core;
/// let weak_five = five.downgrade();
/// ```
#[cfg(stage0)] // NOTE remove after next snapshot
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module")]
pub fn downgrade(&self) -> Weak<T> {
self.inc_weak();
/// let weak_five = five.downgrade();
/// ```
#[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")]
pub fn downgrade(&self) -> Weak<T> {
self.inc_weak();
/// Get the number of weak references to this value.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 }
/// Get the number of strong references to this value.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
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.
/// rc::is_unique(&five);
/// ```
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn is_unique<T>(rc: &Rc<T>) -> bool {
weak_count(rc) == 0 && strong_count(rc) == 1
}
/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
/// ```
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
if is_unique(&rc) {
unsafe {
/// assert!(rc::get_mut(&mut x).is_none());
/// ```
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
if is_unique(rc) {
let inner = unsafe { &mut **rc._ptr };
/// let mut_five = five.make_unique();
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "alloc")]
pub fn make_unique(&mut self) -> &mut T {
if !is_unique(self) {
*self = Rc::new((**self).clone())
}
}
-#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")]
+#[unstable(feature = "alloc", reason = "Show is experimental.")]
impl<T: fmt::Show> fmt::Show for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Rc({:?})", **self)
/// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag]
#[cfg(stage0)] // NOTE remove impl after next snapshot
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> {
// FIXME #12808: strange names to try to avoid interfering with
///
/// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub struct 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.")]
impl<T> Weak<T> {
/// Upgrades a weak reference to a strong reference.
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
reason = "Weak pointers may not belong in this module.")]
impl<T> Clone for Weak<T> {
/// Makes a clone of the `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> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "(Weak)")
//! more complex, slower arena which can hold objects of any type.
#![crate_name = "arena"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
#![feature(unsafe_destructor)]
#![feature(unboxed_closures)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(missing_docs)]
+#![feature(alloc)]
+#![feature(core)]
extern crate alloc;
/// Clears the binary heap, returning an iterator over the removed elements.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> {
Drain { iter: self.data.drain() }
impl<T> ExactSizeIterator for IntoIter<T> {}
/// 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> {
iter: vec::Drain<'a, T>,
}
/// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
/// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "RFC 509")]
pub struct Bitv {
/// Internal representation of the bit vector
/// assert_eq!(bv[3], true);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "panic semantics are likely to change in the future")]
pub fn set(&mut self, i: uint, x: bool) {
assert!(i < self.nbits);
/// assert!(bv[3]);
/// ```
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "RFC 509")]
pub struct BitvSet {
bitv: Bitv,
}
/// 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")]
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")]
pub struct VacantEntry<'a, K:'a, V:'a> {
key: K,
}
/// An occupied Entry.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "precise API still under development")]
pub struct OccupiedEntry<'a, K:'a, V:'a> {
stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
}
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")]
/// 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>> {
impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// 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")]
pub fn insert(self, value: V) -> &'a mut V {
self.stack.insert(self.key, value)
impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// 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")]
pub fn get(&self) -> &V {
self.stack.peek()
}
/// 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")]
pub fn get_mut(&mut self) -> &mut V {
self.stack.peek_mut()
}
/// 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")]
pub fn into_mut(self) -> &'a mut V {
self.stack.into_top()
/// Sets the value of the entry with the OccupiedEntry's key,
/// 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")]
pub fn insert(&mut self, mut value: V) -> V {
mem::swap(self.stack.peek_mut(), &mut value);
}
/// 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")]
pub fn remove(self) -> V {
self.stack.remove()
/// }
/// 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")]
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, [])
/// println!("{} => {}", name, balance);
/// }
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
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> {
range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut,
/// assert_eq!(count["a"], 3u);
/// ```
/// 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")]
pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
// same basic logic of `swap` and `pop`, blended together
/// Makes a new BTreeSet with the given B.
///
/// B cannot be less than 2.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "probably want this to be on the type, eventually")]
pub fn with_b(b: uint) -> BTreeSet<T> {
BTreeSet { map: BTreeMap::with_b(b) }
/// }
/// 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")]
pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> {
fn first<A, B>((a, _): (A, B)) -> A { a }
/// }
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn insert_next(&mut self, elt: A) {
self.insert_next_node(box Node::new(elt))
/// assert_eq!(it.next().unwrap(), &2);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn peek_next(&mut self) -> Option<&mut A> {
if self.nelem == 0 {
impl<E:CLike> EnumSet<E> {
/// Returns an empty `EnumSet`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn new() -> EnumSet<E> {
EnumSet {bits: 0}
}
/// 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")]
pub fn len(&self) -> uint {
self.bits.count_ones()
}
/// Returns true if the `EnumSet` is empty.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_empty(&self) -> bool {
self.bits == 0
}
/// 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")]
pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == 0
}
/// 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")]
pub fn is_superset(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == other.bits
}
/// 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")]
pub fn is_subset(&self, other: &EnumSet<E>) -> bool {
other.is_superset(self)
}
/// 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")]
pub fn insert(&mut self, e: E) -> bool {
let result = !self.contains(&e);
}
/// Removes an enum from the EnumSet
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn remove(&mut self, e: &E) -> bool {
let result = self.contains(e);
}
/// 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")]
pub fn contains(&self, e: &E) -> bool {
(self.bits & bit(e)) != 0
}
/// Returns an iterator over an `EnumSet`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn iter(&self) -> Iter<E> {
Iter::new(self.bits)
#![crate_name = "collections"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "collections")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
#![feature(unsafe_destructor, slicing_syntax)]
#![feature(box_syntax)]
#![feature(unboxed_closures)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![no_std]
+#![feature(core)]
+#![feature(alloc)]
+#![feature(unicode)]
+#![feature(hash)]
#[macro_use]
extern crate core;
pub mod vec;
pub mod vec_map;
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "RFC 509")]
pub mod bitv {
pub use bit::{Bitv, Iter};
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "RFC 509")]
pub mod bitv_set {
pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference};
/// assert_eq!(buf.len(), 1);
/// assert_eq!(Some(&5), buf.get(0));
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
pub fn truncate(&mut self, len: uint) {
for _ in range(len, self.len()) {
/// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
unsafe {
/// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
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]) {
unsafe {
/// assert!(v.is_empty());
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> {
Drain {
/// buf.push_back(10);
/// 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")]
pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
let length = self.len();
/// buf.push_back(20i);
/// 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")]
pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
let length = self.len();
/// assert_eq!(a, b);
/// }
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len();
impl<T> ExactSizeIterator for IntoIter<T> {}
/// A draining RingBuf iterator
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub struct Drain<'a, T: 'a> {
inner: &'a mut RingBuf<T>,
/// assert_eq!(num_moved, 3);
/// assert!(a == [6i, 7, 8, 4, 5]);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "uncertain about this API approach")]
fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
/// original slice (i.e. when `end > self.len()`) or when `start > end`.
///
/// Slicing with `start` equal to `end` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice(&self, start: uint, end: uint) -> &[Self::Item];
/// Panics when `start` is strictly greater than the length of the original slice.
///
/// Slicing from `self.len()` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice_from(&self, start: uint) -> &[Self::Item];
/// Panics when `end` is strictly greater than the length of the original slice.
///
/// Slicing to `0` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice_to(&self, end: uint) -> &[Self::Item];
fn first(&self) -> Option<&Self::Item>;
/// 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];
/// 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];
/// Returns the last element of a slice, or `None` if it is empty.
/// original slice (i.e. when `end > self.len()`) or when `start > end`.
///
/// Slicing with `start` equal to `end` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
/// Panics when `start` is strictly greater than the length of the original slice.
///
/// Slicing from `self.len()` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
/// Panics when `end` is strictly greater than the length of the original slice.
///
/// Slicing to `0` yields an empty slice.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
fn first_mut(&mut self) -> Option<&mut Self::Item>;
/// Returns all but the first element of a mutable slice
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "likely to be renamed or removed")]
fn tail_mut(&mut self) -> &mut [Self::Item];
/// Returns all but the last element of a mutable slice
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "likely to be renamed or removed")]
fn init_mut(&mut self) -> &mut [Self::Item];
/// assert_eq!(Some(vec![1i, 3, 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;
/// Copies as many elements from `src` as it can into `self` (the
/// assert!(dst.clone_from_slice(&src2) == 3);
/// 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;
/// Sorts the slice, in place.
/// let b: &mut [_] = &mut [1i, 0, 2];
/// assert!(v == b);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "uncertain if this merits inclusion in std")]
fn next_permutation(&mut self) -> bool where Self::Item: Ord;
/// let b: &mut [_] = &mut [0i, 1, 2];
/// assert!(v == b);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "uncertain if this merits inclusion in std")]
fn prev_permutation(&mut self) -> bool where Self::Item: Ord;
/// 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;
/// 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;
/// Return true if the slice contains an element with the given value.
fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
/// 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>;
}
////////////////////////////////////////////////////////////////////////////////
// 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
pub trait SliceConcatExt<T: ?Sized, U> {
/// Flattens a slice of `T` into a single value `U`.
///
/// The last generated swap is always (0, 1), and it returns the
/// sequence to its initial order.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
#[derive(Clone)]
pub struct ElementSwaps {
sdir: Vec<SizeDirection>,
impl ElementSwaps {
/// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "collections")]
pub fn new(length: uint) -> ElementSwaps {
// Initialize `sdir` with a direction that position should move in
// (all negative at the beginning) and the `size` of the
// 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] {
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] {
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] {
fn to_owned(&self) -> Vec<T> { self.to_vec() }
}
/// swap applied.
///
/// Generates even and odd permutations alternately.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct Permutations<T> {
swaps: ElementSwaps,
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> {
type Item = Vec<T>;
/// External iterator for a string's decomposition's characters.
/// Use with the `std::iter` module.
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct Decompositions<'a> {
kind: DecompositionType,
iter: Chars<'a>,
/// External iterator for a string's recomposition's characters.
/// Use with the `std::iter` module.
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct Recompositions<'a> {
iter: Decompositions<'a>,
state: RecompositionState,
/// External iterator for a string's UTF16 codeunits.
/// Use with the `std::iter` module.
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct Utf16Units<'a> {
encoder: Utf16Encoder<Chars<'a>>
}
($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 {
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 {
fn to_owned(&self) -> String {
unsafe {
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait StrExt: Index<FullRange, Output = str> {
/// 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")]
fn escape_default(&self) -> String {
self.chars().flat_map(|c| c.escape_default()).collect()
}
/// 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")]
fn escape_unicode(&self) -> String {
self.chars().flat_map(|c| c.escape_unicode()).collect()
/// Returns an iterator over the string in Unicode Normalization Form D
/// (canonical decomposition).
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
/// Returns an iterator over the string in Unicode Normalization Form KD
/// (compatibility decomposition).
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
/// An Iterator over the string in Unicode Normalization Form C
/// (canonical decomposition followed by canonical composition).
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions {
/// An Iterator over the string in Unicode Normalization Form KC
/// (compatibility decomposition followed by canonical composition).
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions {
/// ```rust
/// assert!("hello".contains_char('e'));
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "might get removed in favour of a more generic contains()")]
fn contains_char<P: CharEq>(&self, pat: P) -> bool {
core_str::StrExt::contains_char(&self[], pat)
/// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect();
/// 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> {
core_str::StrExt::split_terminator(&self[], pat)
}
/// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
/// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "might have its iterator type changed")]
fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
core_str::StrExt::match_indices(&self[], pat)
/// let v: Vec<&str> = "1abcabc2".split_str("abc").collect();
/// 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()")]
fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
core_str::StrExt::split_str(&self[], pat)
/// // byte 100 is outside the string
/// // s.slice(3, 100);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
fn slice(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice(&self[], begin, end)
/// out of bounds.
///
/// See also `slice`, `slice_to` and `slice_chars`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "use slice notation [a..] instead")]
fn slice_from(&self, begin: uint) -> &str {
core_str::StrExt::slice_from(&self[], begin)
/// out of bounds.
///
/// See also `slice`, `slice_from` and `slice_chars`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "use slice notation [..a] instead")]
fn slice_to(&self, end: uint) -> &str {
core_str::StrExt::slice_to(&self[], end)
/// assert_eq!(s.slice_chars(0, 4), "Löwe");
/// assert_eq!(s.slice_chars(5, 7), "老虎");
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "may have yet to prove its worth")]
fn slice_chars(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice_chars(&self[], begin, end)
/// // third byte of `老`
/// assert!(!s.is_char_boundary(8));
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
fn is_char_boundary(&self, index: uint) -> bool {
core_str::StrExt::is_char_boundary(&self[], index)
///
/// 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.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
fn char_range_at(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at(&self[], start)
///
/// If `i` is greater than the length of the string.
/// 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")]
fn char_range_at_reverse(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at_reverse(&self[], start)
///
/// 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.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
fn char_at(&self, i: uint) -> char {
core_str::StrExt::char_at(&self[], i)
///
/// If `i` is greater than the length of the string.
/// 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")]
fn char_at_reverse(&self, i: uint) -> char {
core_str::StrExt::char_at_reverse(&self[], i)
/// assert_eq!(s.find_str("老虎 L"), Some(6));
/// 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")]
fn find_str(&self, needle: &str) -> Option<uint> {
core_str::StrExt::find_str(&self[], needle)
/// assert_eq!(c, 'ö');
/// assert_eq!(s2, "we 老虎 Léopard");
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "awaiting conventions about shifting and slices")]
fn slice_shift_char(&self) -> Option<(char, &str)> {
core_str::StrExt::slice_shift_char(&self[])
/// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
/// assert!(string.subslice_offset(lines[2]) == 4); // &"c"
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "awaiting convention about comparability of arbitrary slices")]
fn subslice_offset(&self, inner: &str) -> uint {
core_str::StrExt::subslice_offset(&self[], inner)
}
/// 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")]
fn utf16_units(&self) -> Utf16Units {
Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
/// assert_eq!("j".parse::<u32>(), None);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this method was just created")]
fn parse<F: FromStr>(&self) -> Option<F> {
core_str::StrExt::parse(&self[])
/// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
/// assert_eq!(gr2.as_slice(), b);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")]
fn graphemes(&self, is_extended: bool) -> Graphemes {
UnicodeStr::graphemes(&self[], is_extended)
/// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
/// assert_eq!(gr_inds.as_slice(), b);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")]
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
UnicodeStr::grapheme_indices(&self[], is_extended)
/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
/// recommends that these characters be treated as 1 column (i.e.,
/// `is_cjk` = `false`) if the locale is unknown.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")]
fn width(&self, is_cjk: bool) -> uint {
UnicodeStr::width(&self[], is_cjk)
/// assert_eq!(s.as_slice(), "hello");
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "needs investigation to see if to_string() can match perf")]
pub fn from_str(string: &str) -> String {
String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) }
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "waiting on Extend stabilization")]
impl Extend<char> for String {
fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) {
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "waiting on Extend stabilization")]
impl<'a> Extend<&'a str> for String {
fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) {
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 {
#[inline]
#[stable(feature = "grandfathered", since = "1.0.0")]
}
}
-#[unstable(feature = "unnamed_feature", reason = "waiting on fmt stabilization")]
+#[unstable(feature = "collections", reason = "waiting on fmt stabilization")]
impl fmt::Show for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
}
}
-#[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 {
#[inline]
fn hash(&self, hasher: &mut H) {
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "recent addition, needs more experience")]
impl<'a> Add<&'a str> for String {
type Output = String;
}
/// Wrapper type providing a `&String` reference via `Deref`.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct DerefString<'a> {
x: DerefVec<'a, u8>
}
/// let string = as_string("foo").clone();
/// string_consumer(string);
/// ```
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
DerefString { x: as_vec(x.as_bytes()) }
}
/// 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.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "may be better expressed via composition")]
pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
let mut dst = Vec::with_capacity(elts);
/// Note that this will drop any excess capacity. Calling this and
/// converting back to a vector with `into_vec()` is equivalent to calling
/// `shrink_to_fit()`.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "collections")]
pub fn into_boxed_slice(mut self) -> Box<[T]> {
self.shrink_to_fit();
unsafe {
/// assert_eq!(vec2, vec![]);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "new API, waiting for dust to settle")]
pub fn append(&mut self, other: &mut Self) {
if mem::size_of::<T>() == 0 {
/// assert!(v.is_empty());
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
unsafe {
/// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
/// 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")]
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
/// vec.resize(2, 0);
/// assert_eq!(vec, vec![1, 2]);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "matches collection reform specification; waiting for dust to settle")]
pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len();
/// assert_eq!(vec, vec![1, 2, 3, 4]);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "collections",
reason = "likely to be replaced by a more optimized extend")]
pub fn push_all(&mut self, other: &[T]) {
self.reserve(other.len());
// Common trait implementations for Vec
////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
impl<T:Clone> Clone for Vec<T> {
fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) }
}
}
-#[unstable(feature = "unnamed_feature", reason = "waiting on Index stability")]
+#[unstable(feature = "collections", reason = "waiting on Index stability")]
impl<T> Index<uint> for Vec<T> {
type Output = 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> {
#[inline]
fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) {
impl_eq_for_cowvec! { &'b [B] }
impl_eq_for_cowvec! { &'b mut [B] }
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "waiting on PartialOrd stability")]
impl<T: PartialOrd> PartialOrd for Vec<T> {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature", reason = "waiting on Eq stability")]
+#[unstable(feature = "collections", reason = "waiting on Eq stability")]
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> {
#[inline]
fn cmp(&self, other: &Vec<T>) -> Ordering {
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "recent addition, needs more experience")]
impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
type Output = 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> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(self.as_slice(), f)
// Clone-on-write
////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "unclear how valuable this alias is")]
/// A clone-on-write vector
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 {
fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
Cow::Owned(FromIterator::from_iter(it))
impl<T> IntoIter<T> {
#[inline]
/// 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> {
unsafe {
for _x in self { }
/// An iterator that drains a vector.
#[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
reason = "recently added as part of collections reform 2")]
pub struct Drain<'a, T> {
ptr: *const T,
////////////////////////////////////////////////////////////////////////////////
/// Wrapper type providing a `&Vec<T>` reference via `Deref`.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct DerefVec<'a, T> {
x: Vec<T>,
l: ContravariantLifetime<'a>
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
impl<'a, T> Deref for DerefVec<'a, T> {
type Target = Vec<T>;
}
/// 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> {
unsafe {
DerefVec {
///
/// 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")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
fn((uint, Option<V>)) -> Option<(uint, V)>>
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
pub struct Drain<'a, V> {
iter: FilterMap<
(uint, Option<V>),
fn((uint, Option<V>)) -> Option<(uint, V)>>
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
impl<'a, V> Iterator for Drain<'a, V> {
type Item = (uint, V);
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> {
fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
}
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Any: 'static {
/// Get the `TypeId` of `self`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "this method will likely be replaced by an associated static")]
fn get_type_id(&self) -> TypeId;
}
/// Returns the `TypeId` of the type this generic function has been
/// instantiated with
#[cfg(not(stage0))]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "may grow a `Reflect` bound soon via marker traits")]
pub fn of<T: ?Sized + 'static>() -> TypeId {
TypeId {
//! up to a certain length. Eventually we should able to generalize
//! to all lengths.
-#![unstable(feature = "unnamed_feature")] // not yet reviewed
+#![unstable(feature = "core")] // not yet reviewed
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "waiting for Show to stabilize")]
impl<T:fmt::Show> fmt::Show for [T; $N] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
}
}
-#[deprecated(feature = "unnamed_feature", since = "1.0.0",
+#[deprecated(feature = "core", since = "1.0.0",
reason = "renamed to AtomicIsize")]
#[allow(missing_docs)]
pub struct 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")]
#[allow(missing_docs)]
pub struct 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")]
#[allow(missing_docs, deprecated)]
pub const ATOMIC_INT_INIT: AtomicInt =
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")]
#[allow(missing_docs, deprecated)]
pub const ATOMIC_UINT_INIT: AtomicUint =
//! is desired, `to_mut` will obtain a mutable references to an owned
//! value, cloning if necessary.
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "core",
reason = "recently added as part of collections reform")]
use clone::Clone;
///
/// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value
}
/// immutable borrows can be taken out at the same time.
///
/// 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>> {
match BorrowRef::new(&self.borrow) {
Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }),
/// cannot be borrowed while this borrow is active.
///
/// 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>> {
match BorrowRefMut::new(&self.borrow) {
Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }),
///
/// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value
}
///
/// A `Clone` implementation would interfere with the widespread
/// 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")]
pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> {
Ref {
///
/// This field should not be accessed directly, it is made public for static
/// initializers.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub value: T,
}
/// Panics if given an `radix` > 36.
///
#[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> {
if radix > 36 {
panic!("from_digit: radix is too high (maximum 36)");
/// # Panics
///
/// Panics if given a radix > 36.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool;
/// # Panics
///
/// Panics if given a radix outside the range [0..36].
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint>;
#[stable(feature = "grandfathered", since = "1.0.0")]
impl CharExt for char {
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool {
self.to_digit(radix).is_some()
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint> {
if radix > 36 {
}
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away
}
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away
}
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
enum EscapeUnicodeState {
Backslash,
Type,
}
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
enum EscapeDefaultState {
Backslash(char),
Char(char),
/// but can be overridden to reuse the resources of `a` to avoid unnecessary
/// allocations.
#[inline(always)]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "this function is rarely used")]
fn clone_from(&mut self, source: &Self) {
*self = source.clone()
macro_rules! extern_fn_clone {
($($A:ident),*) => (
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "this may not be sufficient for fns with region parameters")]
impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
/// Return a copy of a function pointer
///
/// Returns the first argument if the comparison determines them to be equal.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) {
Some(Less) | Some(Equal) => Some(v1),
///
/// Returns the first argument if the comparison determines them to be equal.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) {
Some(Less) => Some(v2),
//! })
//! ```
-#![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 \
Drop on a custom type, and this module is being removed with no \
replacement. Use a custom Drop implementation to regain existing \
mod float;
pub mod rt;
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "core and I/O reconciliation may alter this definition")]
/// The type returned by formatter methods.
pub type Result = result::Result<(), 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
/// some other means.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "core and I/O reconciliation may alter this definition")]
#[derive(Copy)]
pub struct Error;
/// This trait should generally not be implemented by consumers of the standard
/// library. The `write!` macro accepts an instance of `io::Writer`, and the
/// `io::Writer` trait is favored over implementing this trait.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "waiting for core and I/O reconciliation")]
pub trait Writer {
/// Writes a slice of bytes into this writer, returning whether the write
/// 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
/// traits.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "name may change and implemented traits are also unstable")]
pub struct Formatter<'a> {
flags: uint,
/// 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
/// 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")]
#[derive(Copy)]
pub struct Argument<'a> {
/// When using the format_args!() macro, this function is used to generate the
/// Arguments structure.
#[doc(hidden)] #[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")]
pub fn new(pieces: &'a [&'a str],
args: &'a [Argument<'a>]) -> Arguments<'a> {
/// created with `argumentuint`. However, failing to do so doesn't cause
/// unsafety, but will ignore invalid .
#[doc(hidden)] #[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")]
pub fn with_placeholders(pieces: &'a [&'a str],
fmt: &'a [rt::Argument],
/// Format trait for the `:?` format. Useful for debugging, most all types
/// should implement this.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait Show {
/// Formats the value using the given formatter.
/// When a value can be semantically expressed as a String, this trait may be
/// used. It corresponds to the default format, `{}`.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait String {
/// Formats the value using the given formatter.
/// Format trait for the `o` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait Octal {
/// Formats the value using the given formatter.
}
/// Format trait for the `b` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait Binary {
/// Formats the value using the given formatter.
}
/// Format trait for the `x` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait LowerHex {
/// Formats the value using the given formatter.
}
/// Format trait for the `X` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait UpperHex {
/// Formats the value using the given formatter.
}
/// Format trait for the `p` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait Pointer {
/// Formats the value using the given formatter.
}
/// Format trait for the `e` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait LowerExp {
/// Formats the value using the given formatter.
}
/// Format trait for the `E` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "I/O and core have yet to be reconciled")]
pub trait UpperExp {
/// Formats the value using the given formatter.
///
/// * output - the buffer to write output to
/// * 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 \
implementation detail which should not otherwise be exported")]
pub fn write(output: &mut Writer, args: Arguments) -> Result {
///
/// This function will correctly account for the flags provided as well as
/// the minimum width. It will not take precision into account.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "definition may change slightly over time")]
pub fn pad_integral(&mut self,
is_positive: bool,
/// is longer than this length
///
/// Notably this function ignored the `flag` parameters
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "definition may change slightly over time")]
pub fn pad(&mut self, s: &str) -> Result {
// Make sure there's a fast path up front
/// Writes some data to the underlying buffer contained within this
/// formatter.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "reconciling core and I/O may alter this definition")]
pub fn write_str(&mut self, data: &str) -> Result {
self.buf.write_str(data)
}
/// Writes some formatted information into this instance
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "reconciling core and I/O may alter this definition")]
pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
write(self.buf, fmt)
}
/// 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")]
pub fn flags(&self) -> uint { self.flags }
/// 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 }
/// 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 }
/// 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 }
/// 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 }
}
/// 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.
#[doc(hidden)] #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")]
pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
t: &'a T) -> Argument<'a> {
/// 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.
#[doc(hidden)] #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "implementation detail of the `format_args!` macro")]
pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
Argument::from_uint(s)
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<T: Show> Show for RefCell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match self.try_borrow() {
/// A radix with in the range of `2..36`.
#[derive(Clone, Copy, PartialEq)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may be renamed or move to a different module")]
pub struct Radix {
base: u8,
}
/// A helper type for formatting radixes.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may be renamed or move to a different module")]
#[derive(Copy)]
pub struct RadixFmt<T, R>(T, R);
/// use std::fmt::radix;
/// 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")]
pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
RadixFmt(x, Radix::new(base))
//! These definitions are similar to their `ct` equivalents, but differ in that
//! 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")]
pub use self::Alignment::*;
//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
//! ```
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "hash",
reason = "module was recently redesigned")]
use prelude::*;
/// A common bound on the `Hasher` parameter to `Hash` implementations in order
/// to generically hash an aggregate.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "hash",
reason = "this trait will likely be replaced by io::Writer")]
#[allow(missing_docs)]
pub trait Writer {
//! guaranteed to happen in order. This is the standard mode for working
//! with atomic types and is equivalent to Java's `volatile`.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
#![allow(missing_docs)]
use marker::Sized;
/// }
/// }
/// ```
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
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
/// }
/// ```
///
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "uncertain about naming and semantics")]
pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
/// assert_eq!(even, vec![2, 4]);
/// assert_eq!(odd, vec![1, 3]);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added as part of collections reform")]
fn partition<B, F>(mut self, mut f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
/// let v = [1i, 1, 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
{
let (mut min, mut max) = match self.next() {
/// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")]
fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
/// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")]
fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
///
/// Loops through the entire iterator, collecting the first component of
/// 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
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
/// Creates an iterator that clones the elements it yields. Useful for converting an
/// 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
Self: Iterator<Item=D>,
D: Deref<Target=T>,
}
/// Use an iterator to reverse a container in place.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "uncertain about placement or widespread use")]
fn reverse_in_place<'a, T: 'a>(&mut self) where
Self: Iterator<Item=&'a mut T> + DoubleEndedIterator
/// Calling `next()` or `next_back()` on a `RandomAccessIterator`
/// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)`
/// after `it.next()` is called.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "not widely used, may be better decomposed into Index and ExactSizeIterator")]
pub trait RandomAccessIterator: Iterator {
/// Return the number of indexable elements. At most `std::uint::MAX`
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 {
#[inline]
fn indexable(&self) -> uint { self.iter.indexable() }
}
/// 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")]
pub trait AdditiveIterator<A> {
/// Iterates over the entire iterator, summing up all the elements
macro_rules! impl_additive {
($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 {
#[inline]
fn sum(self) -> $A {
impl_additive! { f64, 0.0 }
/// 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")]
pub trait MultiplicativeIterator<A> {
/// Iterates over the entire iterator, multiplying all the elements
macro_rules! impl_multiplicative {
($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 {
#[inline]
fn product(self) -> $A {
/// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail.
#[derive(Clone, PartialEq, Show)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "unclear whether such a fine-grained result is widely useful")]
pub enum MinMaxResult<T> {
/// Empty iterator
/// let r = MinMax(1i,2i);
/// 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)> {
match self {
NoElements => None,
}
/// 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"]
#[derive(Clone)]
pub struct Cloned<I> {
}
}
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Cycle<I> where
I: Clone + RandomAccessIterator,
{
}
}
-#[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
A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=T>,
}
}
-#[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
A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=U>,
}
}
-#[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
I: RandomAccessIterator<Item=A>,
F: FnMut(A) -> B,
}
}
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
#[inline]
fn indexable(&self) -> uint {
}
}
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
#[inline]
fn indexable(&self) -> uint {
}
}
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
#[inline]
fn indexable(&self) -> uint {
}
// 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 {
#[inline]
fn indexable(&self) -> uint {
/// 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.
#[inline]
- #[unstable(feature = "unnamed_feature", reason = "seems marginal")]
+ #[unstable(feature = "core", reason = "seems marginal")]
pub fn reset_fuse(&mut self) {
self.done = false
}
}
}
-#[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
I: RandomAccessIterator<Item=A>,
F: FnMut(&A),
/// println!("{}", i);
/// }
/// ```
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
f: F,
/// Internal state that will be passed to the closure on the next iteration
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
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
/// function" and an initial state to eventually pass to the closure
/// An infinite iterator starting at `start` and advancing by `step` with each
/// iteration
#[derive(Clone, Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may be renamed or replaced by range notation adapaters")]
pub struct Counter<A> {
/// The current state the counter is at (next value to be yielded)
/// Creates a new counter with the specified start/step
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may be renamed or replaced by range notation adapaters")]
pub fn count<A>(start: A, step: A) -> Counter<A> {
Counter{state: start, step: step}
/// An iterator over the range [start, stop)
#[derive(Clone, Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be replaced by range notation")]
pub struct Range<A> {
state: A,
/// }
/// ```
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be replaced by range notation")]
pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
Range {
}
// FIXME: #10414: Unfortunate type bound
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be replaced by range notation")]
impl<A: Int + ToPrimitive> Iterator for Range<A> {
type Item = A;
/// `Int` is required to ensure the range will be the same regardless of
/// the direction it is consumed.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be replaced by range notation")]
impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
#[inline]
/// An iterator over the range [start, stop]
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
pub struct RangeInclusive<A> {
range: Range<A>,
/// Return an iterator over the range [start, stop]
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
RangeInclusive {
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
type Item = A;
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
#[inline]
/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
pub struct RangeStep<A> {
state: A,
/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
let rev = step < Int::zero();
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")]
impl<A: Int> Iterator for RangeStep<A> {
type Item = A;
/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
pub struct RangeStepInclusive<A> {
state: A,
/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
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> {
let rev = step < Int::zero();
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int> Iterator for RangeStepInclusive<A> {
type Item = A;
/// directions. The `steps_between` function provides a way to
/// compare two Step objects (it could be provided using `step()` and `Ord`,
/// 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")]
pub trait Step: Ord {
/// Change self to the next object.
macro_rules! step_impl {
($($t:ty)*) => ($(
- #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")]
+ #[unstable(feature = "core", reason = "Trait is unstable.")]
impl Step for $t {
#[inline]
fn step(&mut self) { *self += 1; }
macro_rules! step_impl_no_between {
($($t:ty)*) => ($(
- #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")]
+ #[unstable(feature = "core", reason = "Trait is unstable.")]
impl Step for $t {
#[inline]
fn step(&mut self) { *self += 1; }
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> {
#[inline]
fn indexable(&self) -> uint { uint::MAX }
/// An iterator that repeatedly applies a given function, starting
/// 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>>;
/// Create a new iterator that produces an infinite sequence of
/// 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
T: Clone,
F: FnMut(T) -> T,
///
/// If two sequences are equal up until the point where one ends,
/// 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 {
use cmp;
use cmp::{Eq, Ord, PartialOrd, PartialEq};
// separate crate, libcoretest, to avoid bizarre issues.
#![crate_name = "core"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
/// }
/// ```
#[macro_export]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "relationship with panic is unclear")]
macro_rules! unreachable {
() => ({
/// A standardised placeholder for marking unfinished code. It panics with the
/// message `"not yet implemented"` when executed.
#[macro_export]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "relationship with panic is unclear")]
macro_rules! unimplemented {
() => (panic!("not yet implemented"))
use clone::Clone;
/// 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")]
#[lang="send"]
pub unsafe trait Send: 'static {
/// around the value(s) which can be mutated when behind a `&`
/// reference; not doing this is undefined behaviour (for example,
/// `transmute`-ing from `&T` to `&mut T` is illegal).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be overhauled with new lifetime rules; see RFC 458")]
#[lang="sync"]
pub unsafe trait Sync {
/// `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 some lifetime `'a`, but not the other way around).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="covariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// subtype of `S<U>` if `U` is a subtype of `T`; given that the
/// function requires arguments of type `T`, it must also accept
/// 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")]
#[lang="contravariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// The type system would infer that `value` is only read here and
/// never written, but in fact `Cell` uses unsafe code to achieve
/// interior mutability.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="invariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantType<T: ?Sized>;
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Copy for InvariantType<T> {}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Clone for InvariantType<T> {
fn clone(&self) -> InvariantType<T> { *self }
///
/// For more information about variance, refer to this Wikipedia
/// 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")]
#[lang="covariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
///
/// For more information about variance, refer to this Wikipedia
/// 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")]
#[lang="contravariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
/// pointer that is actually a pointer into memory with lifetime `'a`,
/// and this pointer is itself stored in an inherently mutable
/// location (such as a `Cell`).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="invariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
/// be safely sent between tasks, even if it is owned. This is
/// typically embedded in other types, such as `Gc`, to ensure that
/// their instances remain thread-local.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="no_send_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
/// A type which is considered "not POD", meaning that it is not
/// implicitly copyable. This is typically embedded in other types to
/// ensure that they are never copied, even if they lack a destructor.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="no_copy_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
/// A type which is considered "not sync", meaning that
/// its contents are not threadsafe, hence they cannot be
/// shared between tasks.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="no_sync_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
/// A type which is considered managed by the GC. This is typically
/// embedded in other types.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "likely to change with new variance strategy")]
#[lang="managed_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
/// Transforms lifetime of the second pointer to match the first.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "this function may be removed in the future due to its \
questionable utility")]
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.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "this function may be removed in the future due to its \
questionable utility")]
pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,
/// NULL or 0 that might allow certain optimizations.
#[lang="non_zero"]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub struct NonZero<T: Zeroable>(T);
impl<T: Zeroable> NonZero<T> {
use num::FpCategory as Fp;
use option::Option;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
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;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
pub const DIGITS: uint = 6u;
#[stable(feature = "grandfathered", since = "1.0.0")]
#[stable(feature = "grandfathered", since = "1.0.0")]
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;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
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;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 38;
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
/// Various useful constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "naming scheme needs to be revisited")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
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 {
#[inline]
fn nan() -> f32 { NAN }
// constants are implemented in favour of referencing the respective
// 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 MANTISSA_DIGITS: uint = 53u;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
pub const DIGITS: uint = 15u;
#[stable(feature = "grandfathered", since = "1.0.0")]
#[stable(feature = "grandfathered", since = "1.0.0")]
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;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
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;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 308;
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
/// Various useful constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "naming scheme needs to be revisited")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
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 {
#[inline]
fn nan() -> f64 { NAN }
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub const BITS : uint = $bits;
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub const BYTES : uint = ($bits / 8);
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
{
/// Returns the `0` value of this integer type.
// FIXME (#5527): Should be an associated constant
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "unsure about its place in the world")]
fn zero() -> Self;
/// Returns the `1` value of this integer type.
// FIXME (#5527): Should be an associated constant
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "unsure about its place in the world")]
fn one() -> Self;
/// Returns the smallest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "unsure about its place in the world")]
fn min_value() -> Self;
/// Returns the largest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "unsure about its place in the world")]
fn max_value() -> Self;
///
/// assert_eq!(n.count_ones(), 3);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn count_ones(self) -> uint;
///
/// assert_eq!(n.count_zeros(), 5);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
#[inline]
fn count_zeros(self) -> uint {
///
/// assert_eq!(n.leading_zeros(), 10);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn leading_zeros(self) -> uint;
///
/// assert_eq!(n.trailing_zeros(), 3);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn trailing_zeros(self) -> uint;
///
/// assert_eq!(n.rotate_left(12), m);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn rotate_left(self, n: uint) -> Self;
///
/// assert_eq!(n.rotate_right(12), m);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
fn rotate_right(self, n: uint) -> Self;
///
/// assert_eq!(2i.pow(4), 16);
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "pending integer conventions")]
#[inline]
fn pow(self, mut exp: uint) -> Self {
{
/// Computes the absolute value of `self`. `Int::min_value()` will be
/// 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;
/// Returns a number representing sign of `self`.
impl UnsignedInt for u64 {}
/// 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 {
/// Converts the value of `self` to an `int`.
#[inline]
impl_to_primitive_float! { f64 }
/// 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 {
/// Convert an `int` to return an optional value of this type. If the
/// value cannot be represented by this value, the `None` is returned.
}
/// 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> {
FromPrimitive::from_int(n)
}
/// 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> {
FromPrimitive::from_i8(n)
}
/// 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> {
FromPrimitive::from_i16(n)
}
/// 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> {
FromPrimitive::from_i32(n)
}
/// 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> {
FromPrimitive::from_i64(n)
}
/// 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> {
FromPrimitive::from_uint(n)
}
/// 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> {
FromPrimitive::from_u8(n)
}
/// 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> {
FromPrimitive::from_u16(n)
}
/// 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> {
FromPrimitive::from_u32(n)
}
/// 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> {
FromPrimitive::from_u64(n)
}
/// 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> {
FromPrimitive::from_f32(n)
}
/// 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> {
FromPrimitive::from_f64(n)
}
/// ```
///
#[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> {
NumCast::from(n)
}
/// 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 {
/// Creates a number from another value that can be converted into a primitive via the
/// `ToPrimitive` trait.
/// Used for representing the classification of floating point numbers
#[derive(Copy, PartialEq, Show)]
-#[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+#[unstable(feature = "core", reason = "may be renamed")]
pub enum FpCategory {
/// "Not a Number", often obtained by dividing by zero
Nan,
//
// FIXME(#8888): Several of these functions have a parameter named
// `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")]
pub trait Float
: Copy + Clone
}
/// 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 {
fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
}
/// 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> {
FromStrRadix::from_str_radix(str, radix)
}
macro_rules! from_str_radix_float_impl {
($T:ty) => {
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "might need to return Result")]
impl FromStr for $T {
/// Convert a string in base 10 to a float.
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "might need to return Result")]
impl FromStrRadix for $T {
/// Convert a string in a given base to a float.
macro_rules! from_str_radix_int_impl {
($T:ty) => {
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "might need to return Result")]
impl FromStr for $T {
#[inline]
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "might need to return Result")]
impl FromStrRadix for $T {
fn from_str_radix(src: &str, radix: uint) -> Option<$T> {
macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub const BITS : uint = $bits;
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub const BYTES : uint = ($bits / 8);
#[stable(feature = "grandfathered", since = "1.0.0")]
// based on "op T" where T is expected to be `Copy`able
macro_rules! forward_ref_unop {
(impl $imp:ident, $method:ident for $t:ty) => {
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")]
impl<'a> $imp for &'a $t {
type Output = <$t as $imp>::Output;
// based on "T op U" where T and U are expected to be `Copy`able
macro_rules! forward_ref_binop {
(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")]
impl<'a> $imp<$u> for &'a $t {
type Output = <$t as $imp<$u>>::Output;
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")]
impl<'a> $imp<&'a $u> for $t {
type Output = <$t as $imp<$u>>::Output;
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added, waiting for dust to settle")]
impl<'a, 'b> $imp<&'a $u> for &'b $t {
type Output = <$t as $imp<$u>>::Output;
/// An unbounded range.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="full_range"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
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 {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt("..", fmt)
/// A (half-open) range which is bounded at both ends.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
pub struct Range<Idx> {
/// The lower bound of the range (inclusive).
pub start: 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> {
type Item = 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> {
#[inline]
fn next_back(&mut self) -> Option<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> {}
-#[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> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..{:?}", self.start, self.end)
/// A range which is only bounded below.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_from"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
pub struct RangeFrom<Idx> {
/// The lower bound of the range (inclusive).
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> {
type Item = 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> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..", self.start)
/// A range which is only bounded above.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_to"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
pub struct RangeTo<Idx> {
/// The upper bound of the range (exclusive).
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> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "..{:?}", self.end)
/// A version of the call operator that takes an immutable receiver.
#[lang="fn"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait Fn<Args,Result> {
/// This is called when the call operator is used.
/// A version of the call operator that takes a mutable receiver.
#[lang="fn_mut"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnMut<Args,Result> {
/// This is called when the call operator is used.
/// A version of the call operator that takes a by-value receiver.
#[lang="fn_once"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnOnce<Args,Result> {
/// This is called when the call operator is used.
/// assert_eq!(x, Some("Dirt"));
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "waiting for mut conventions")]
pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
match *self {
/// assert_eq!(x.ok_or(0i), Err(0i));
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub fn ok_or<E>(self, err: E) -> Result<T, E> {
match self {
Some(v) => Ok(v),
/// assert_eq!(x.ok_or_else(|| 0i), Err(0i));
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
match self {
Some(v) => Ok(v),
/// assert_eq!(x.iter_mut().next(), None);
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "waiting for iterator conventions")]
pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut { inner: Item { opt: self.as_mut() } }
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.
/// 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")]
pub fn cloned(self) -> Option<T> {
self.map(|t| t.deref().clone())
// Trait implementations
/////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "waiting on the stability of the trait itself")]
impl<T> AsSlice<T> for Option<T> {
/// Convert from `Option<T>` to `&[T]` (without copying)
// 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;
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub use intrinsics::copy_memory;
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "uncertain about naming and semantics")]
pub use intrinsics::set_memory;
/// 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`.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
set_memory(dst, 0, count);
///
/// This is unsafe for the same reasons that `read` is unsafe.
#[inline(always)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
// Copy the data out from `dest`:
/// null-safety, it is important to note that this is still an unsafe
/// operation because the returned value could be pointing to invalid
/// memory.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
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")]
unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>;
///
/// As with `as_ref`, this is unsafe because it cannot verify the validity
/// of the returned pointer.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
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")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>;
}
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
}
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
type Target = T;
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
/// raw `*mut T` (which conveys no particular ownership semantics).
/// Useful for building abstractions like `Vec<T>` or `Box<T>`, which
/// 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);
/// `Unique` pointers are `Send` if `T` is `Send` because the data they
/// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the
/// `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> { }
/// `Unique` pointers are `Sync` if `T` is `Sync` because the data they
/// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the
/// `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> { }
impl<T> Unique<T> {
/// Returns a null Unique.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added to this module")]
pub fn null() -> Unique<T> {
Unique(null_mut())
}
/// Return an (unsafe) pointer into the memory owned by `self`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "recently added to this module")]
pub unsafe fn offset(self, offset: int) -> *mut T {
self.0.offset(offset)
// except according to those terms.
#![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
//! Contains struct definitions for the layout of compiler built-in types.
//!
/// assert!(x.as_mut_slice().is_empty());
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "core",
reason = "waiting for mut conventions")]
pub fn as_mut_slice(&mut self) -> &mut [T] {
match *self {
/// If an `Err` is encountered, it is immediately returned.
/// Otherwise, the folded value is returned.
#[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub fn fold<T,
V,
E,
#![allow(non_camel_case_types)]
#![allow(missing_docs)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
pub i16, pub i16, pub i16, pub i16);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i64x2(pub i64, pub i64);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
pub u16, pub u16, pub u16, pub u16);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u64x2(pub u64, pub u64);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
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] {
type Item = T;
self.repr().data
}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where
F: FnMut(&T) -> Ordering
{
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 {
self.binary_search_by(|p| p.cmp(x))
}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
fn next_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; }
true
}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
fn prev_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; }
////////////////////////////////////////////////////////////////////////////////
/// Data that is viewable as a slice.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "will be replaced by slice syntax")]
pub trait AsSlice<T> {
/// Work with `self` as a slice.
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] {
#[inline(always)]
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 {
#[inline(always)]
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 {
#[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
marker: marker::ContravariantLifetime<'a>
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
type Output = [T];
#[inline]
///
/// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub fn as_slice(&self) -> &'a [T] {
make_slice!(T => &'a [T]: self.ptr, self.end)
}
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> {
#[inline]
fn indexable(&self) -> uint {
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
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> {
type Output = [T];
#[inline]
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> {
type Output = [T];
#[inline]
self.index(&ops::FullRange).index(index)
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
type Output = [T];
#[inline]
}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
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> {
type Output = [T];
#[inline]
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> {
type Output = [T];
#[inline]
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> {
type Output = [T];
#[inline]
/// to consume the iterator. Consider using the `Slice` and
/// `SliceMut` implementations for obtaining slices with more
/// restricted lifetimes that do not consume the iterator.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
pub fn into_slice(self) -> &'a mut [T] {
make_slice!(T => &'a mut [T]: self.ptr, self.end)
}
}
}
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
#[inline]
fn indexable(&self) -> uint {
//
/// 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] {
unsafe {
transmute(RawSlice { data: s, len: 1 })
}
/// 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] {
unsafe {
let ptr: *const A = transmute(s);
/// }
/// ```
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "should be renamed to from_raw_parts")]
pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: *p, len: len })
/// not being able to provide a non-aliasing guarantee of the returned mutable
/// slice.
#[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
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] {
transmute(RawSlice { data: *p, len: len })
//
/// Operations on `[u8]`.
-#[unstable(feature = "unnamed_feature", reason = "needs review")]
+#[unstable(feature = "core", reason = "needs review")]
pub mod bytes {
use ptr;
use slice::SliceExt;
}
/// Extension methods for slices containing integers.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
pub trait IntSliceExt<U, S> {
/// Converts the slice to an immutable slice of unsigned integers with the same width.
fn as_unsigned<'a>(&'a self) -> &'a [U];
macro_rules! impl_int_slice {
($u:ty, $s:ty, $t:ty) => {
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "core")]
impl IntSliceExt<$u, $s> for [$t] {
#[inline]
fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } }
/// A trait to abstract the idea of creating a new instance of a type from a
/// string.
// 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")]
pub trait FromStr {
/// Parses a string `s` to return an optional value of this type. If the
/// Errors which can occur when attempting to interpret a byte slice as a `str`.
#[derive(Copy, Eq, PartialEq, Clone, Show)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "error enumeration recently added and definitions may be refined")]
pub enum Utf8Error {
/// An invalid byte was detected at the byte offset given.
}
/// 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")]
pub trait CharEq {
/// Determine if the splitter should split at the given character
/// An iterator over the start and end indices of the matches of a
/// substring within a larger string
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature", reason = "type may be removed")]
+#[unstable(feature = "core", reason = "type may be removed")]
pub struct MatchIndices<'a> {
// constants
haystack: &'a str,
/// An iterator over the substrings of a string separated by a given
/// search string
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature", reason = "type may be removed")]
+#[unstable(feature = "core", reason = "type may be removed")]
pub struct SplitStr<'a> {
it: MatchIndices<'a>,
last_end: uint,
/// the next `char` in a string. This can be used as a data structure
/// for iterating over the UTF-8 bytes of a string.
#[derive(Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "naming is uncertain with container conventions")]
pub struct CharRange {
/// Current `char`
}
/// 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 \
replaced with one of slicing syntax, deref coercions, or \
a more generic conversion trait")]
/// Return type of `StrExt::split_terminator`
#[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
reason = "might get removed in favour of a constructor method on Split")]
pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
#![feature(unsafe_destructor, slicing_syntax)]
#![feature(unboxed_closures)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
extern crate core;
//! [mz]: https://code.google.com/p/miniz/
#![crate_name = "flate"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![allow(unknown_features)] #![feature(int_uint)]
-#![feature(unnamed_feature)]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![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_root_url = "http://doc.rust-lang.org/nightly/")]
+#![feature(hash)]
+#![feature(core)]
+#![feature(libc)]
#[cfg(test)] #[macro_use] extern crate log;
//! generated instead.
#![crate_name = "fmt_macros"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
#![feature(slicing_syntax)]
#![allow(unknown_features)] #![feature(int_uint)]
-#![feature(unnamed_feature)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(unicode)]
pub use self::Piece::*;
pub use self::Position::*;
//! ```
#![crate_name = "getopts"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
reason = "use the crates.io `getopts` library instead")]
#![feature(staged_api)]
#![staged_api]
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
#[cfg(test)] #[macro_use] extern crate log;
//! * [DOT language](http://www.graphviz.org/doc/info/lang.html)
#![crate_name = "graphviz"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(path)]
use self::LabelText::*;
#![crate_name = "libc"]
#![crate_type = "rlib"]
#![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"), 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)]
#![no_std]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
//! one from Berkeley after the lawsuits died down and the CSRG dissolved.
#![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(not(feature = "cargo-build"))] extern crate core;
//! if logging is disabled, none of the components of the log will be executed.
#![crate_name = "log"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
reason = "use the crates.io `log` library instead")]
#![feature(staged_api)]
#![staged_api]
#![allow(unknown_features)]
#![feature(slicing_syntax)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
extern crate regex;
//! internally. The `IndependentSample` trait is for generating values
//! that do not need to record state.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
use core::prelude::*;
use core::num::{Float, Int};
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![no_std]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
#![feature(staged_api)]
#![staged_api]
+#![feature(core)]
#[macro_use]
extern crate core;
//! http://www.matroska.org/technical/specs/rfc/index.html
#![crate_name = "rbml"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
#![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(rustc_private)]
extern crate serialize;
#[macro_use] extern crate log;
#![crate_name = "regex"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
reason = "use the crates.io `regex` library instead")]
#![feature(staged_api)]
#![staged_api]
#![allow(unknown_features)]
#![feature(slicing_syntax)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(unicode)]
#[cfg(test)]
extern crate "test" as stdtest;
}
#[doc(hidden)]
- #[unstable(feature = "unnamed_feature")]
pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
match *self {
Native(ref n) => NamesIterNative(n.names.iter()),
//! This API is completely unstable and subject to change.
#![crate_name = "rustc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![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 flate;
//! build speedups.
#![crate_name = "rustc_back"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![allow(unknown_features)]
#![feature(slicing_syntax, box_syntax)]
-#![feature(unnamed_feature)]
#![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 serialize;
#![staged_api]
#![crate_type = "rlib"]
#![no_std]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
//! A typesafe bitmask flag generator.
// except according to those terms.
#![crate_name = "rustc_borrowck"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(non_camel_case_types)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
//! This API is completely unstable and subject to change.
#![crate_name = "rustc_driver"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![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 flate;
#![allow(dead_code)]
#![crate_name = "rustc_llvm"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![allow(unknown_features)]
#![feature(link_args)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(libc)]
+#![feature(path)]
+#![feature(std_misc)]
extern crate libc;
#[macro_use] #[no_link] extern crate rustc_bitflags;
// except according to those terms.
#![crate_name = "rustc_privacy"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
// except according to those terms.
#![crate_name = "rustc_resolve"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(slicing_syntax)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![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 syntax;
//! This API is completely unstable and subject to change.
#![crate_name = "rustc_trans"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![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 flate;
*/
#![crate_name = "rustc_typeck"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(box_syntax)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(non_camel_case_types)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
// except according to those terms.
#![crate_name = "rustdoc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustdoc")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
html_playground_url = "http://play.rust-lang.org/")]
#![feature(slicing_syntax)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![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 getopts;
*/
#![crate_name = "serialize"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
reason = "deprecated in favor of rustc-serialize on crates.io")]
#![feature(staged_api)]
#![staged_api]
#![feature(box_syntax)]
#![feature(old_impl_check)]
#![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
#![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
#[cfg(test)] extern crate test;
//! Operations on ASCII strings and characters
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "unsure about placement and naming")]
use iter::IteratorExt;
use vec::Vec;
/// 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")]
pub trait OwnedAsciiExt {
/// Convert the string to ASCII upper case:
}
/// 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")]
pub trait AsciiExt<T = Self> {
/// Check if within the ASCII range.
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")]
impl AsciiExt<String> for str {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")]
impl OwnedAsciiExt for String {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")]
impl AsciiExt<Vec<u8>> for [u8] {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")]
impl OwnedAsciiExt for Vec<u8> {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")]
impl AsciiExt for u8 {
#[inline]
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "would prefer to do this in a more general way")]
impl AsciiExt for char {
#[inline]
/// - Any other chars in the range [0x20,0x7e] are not escaped.
/// - Any other chars are given hex escapes.
/// - 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")]
pub fn escape_default<F>(c: u8, mut f: F) where
F: FnMut(u8),
/// map.insert(1i, 2u);
/// ```
#[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> {
HashMap {
hash_state: hash_state,
/// map.insert(1i, 2u);
/// ```
#[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)
-> HashMap<K, V, S> {
let resize_policy = DefaultResizePolicy::new();
}
/// 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")]
pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
{
/// assert!(a.is_empty());
/// ```
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<K, V> {
fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
}
/// HashMap drain iterator
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")]
pub struct Drain<'a, K: 'a, V: 'a> {
inner: iter::Map<
}
/// 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")]
pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
elem: FullBucket<K, V, &'a mut RawTable<K, V>>,
}
/// 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")]
pub struct VacantEntry<'a, K: 'a, V: 'a> {
hash: SafeHash,
}
/// 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")]
pub enum Entry<'a, K: 'a, V: 'a> {
/// An occupied Entry
#[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")]
impl<'a, K, V> Entry<'a, K, V> {
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// instances are unlikely to produce the same result for the same values.
#[derive(Clone)]
#[allow(missing_copy_implementations)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
pub struct RandomState {
k0: u64,
k1: u64,
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
impl RandomState {
/// Construct a new `RandomState` that is initialized with random keys.
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
impl HashState for RandomState {
type Hasher = Hasher;
}
}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "hashing an hash maps may be altered")]
impl Default for RandomState {
#[inline]
/// set.insert(2u);
/// ```
#[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> {
HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state)
}
/// set.insert(1i);
/// ```
#[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)
-> HashSet<T, S> {
HashSet {
/// Clears the set, returning all elements in an iterator.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> {
fn first<A, B>((a, _): (A, B)) -> A { a }
/// Experimental support for providing custom hash algorithms to a HashMap and
/// HashSet.
-#[unstable(feature = "unnamed_feature", reason = "module was recently added")]
+#[unstable(feature = "std_misc", reason = "module was recently added")]
pub mod hash_state {
pub use super::hash::state::*;
}
//!
//! A simple wrapper over the platform's dynamic library facilities
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
#![allow(missing_docs)]
use prelude::v1::*;
use string::{FromUtf8Error, FromUtf16Error};
/// Base functionality for all errors in Rust.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "the exact API of this trait may change")]
pub trait Error {
/// A short description of the error; usually a static string.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use prelude::v1::*;
//! Utilities related to FFI bindings.
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "module just underwent fairly large reorganization and the dust \
still needs to settle")]
//! them with the same character. For example, the `{` character is escaped with
//! `{{` and the `}` character is escaped with `}}`.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use string;
/// let s = fmt::format(format_args!("Hello, {}!", "world"));
/// 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 \
be called directly")]
pub fn format(args: Arguments) -> string::String {
//! concerned with error handling; instead its caller is responsible for
//! responding to errors that may occur while attempting to read the numbers.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "io")]
#![deny(unused_must_use)]
pub use self::SeekStyle::*;
///
/// Usage of this field is discouraged, but if access is desired then the
/// fields are located here.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub unstable: UnstableFileStat,
}
/// returned from a `stat` syscall which is not contained in the `FileStat`
/// structure. This information is not necessarily platform independent, and may
/// have different meanings or no meaning at all on some platforms.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "io")]
#[derive(Copy, Hash)]
pub struct UnstableFileStat {
/// The ID of the device containing the file.
///
/// If a `timeout` with zero or negative duration is specified then
/// 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")]
pub fn connect_timeout<P>(path: P, timeout: Duration)
-> IoResult<UnixStream>
/// Sets the read/write timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms)
/// Sets the read timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms)
/// Sets the write timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms)
/// When using this method, it is likely necessary to reset the timeout as
/// appropriate, the timeout specified is specific to this object, not
/// specific to the next request.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the name and arguments to this function are likely \
to change")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
///
/// This function has the same semantics as `TcpAcceptor::close_accept`, and
/// more information can be found in that documentation.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn close_accept(&mut self) -> IoResult<()> {
self.inner.close_accept()
}
///
/// If a `timeout` with zero or negative duration is specified then
/// 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")]
pub fn connect_timeout<A: ToSocketAddr>(addr: A,
timeout: Duration) -> IoResult<TcpStream> {
}
/// 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<()> {
self.inner.set_nodelay(nodelay)
}
/// If the value specified is `None`, then the keepalive flag is cleared on
/// this connection. Otherwise, the keepalive timeout will be set to the
/// specified time, in seconds.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> {
self.inner.set_keepalive(delay_in_seconds)
}
///
/// For clarification on the semantics of interrupting a read and a write,
/// 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")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms)
/// action is taken. Otherwise, the read operation will be scheduled to
/// promptly return. If a timeout error is returned, then no data was read
/// during the timeout period.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms)
/// 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
/// 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")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms)
/// a.set_timeout(None);
/// let socket = a.accept();
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the type of the argument and name of this function are \
subject to change")]
pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); }
/// // Signal our accept loop to exit
/// assert!(a.close_accept().is_ok());
/// ```
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn close_accept(&mut self) -> IoResult<()> {
self.inner.close_accept()
}
}
/// 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<()> {
self.inner.join_multicast(multi)
}
/// 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<()> {
self.inner.leave_multicast(multi)
}
/// Set the multicast loop flag to the specified value
///
/// 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<()> {
self.inner.set_multicast_loop(on)
}
/// Sets the multicast TTL
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> {
self.inner.multicast_time_to_live(ttl)
}
/// Sets this socket's TTL
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> {
self.inner.time_to_live(ttl)
}
/// Sets the broadcast flag on or off
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "io")]
pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> {
self.inner.set_broadcast(broadcast)
}
/// Sets the read/write timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_timeout(timeout_ms)
/// Sets the read timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_read_timeout(timeout_ms)
/// Sets the write timeout for this socket.
///
/// For more information, see `TcpStream::set_timeout`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the timeout argument may change in type and value")]
pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
self.inner.set_write_timeout(timeout_ms)
/// p.wait()
/// }
/// ```
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "io",
reason = "the type of the timeout is likely to change")]
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0);
#![feature(optin_builtin_traits)]
#![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.
#![no_std]
//! library. Each macro is available for use when linking against the standard
//! library.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
/// The entry point for panic of Rust tasks.
///
///
/// For more information about select, see the `std::sync::mpsc::Select` structure.
#[macro_export]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
macro_rules! select {
(
$($name:pat = $rx:ident.$meth:ident() => $code:expr),+
///
/// * num - The float value
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigAll, ExpNone, false);
///
/// * num - The float value
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 16u, true, SignNeg, DigAll, ExpNone, false);
/// * num - The float value
/// * radix - The base to use
#[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) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
/// * num - The float value
/// * digits - The number of significant digits
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
/// * num - The float value
/// * digits - The number of significant digits
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
/// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
/// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
///
/// * num - The float value
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigAll, ExpNone, false);
///
/// * num - The float value
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 16u, true, SignNeg, DigAll, ExpNone, false);
/// * num - The float value
/// * radix - The base to use
#[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) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
/// * num - The float value
/// * digits - The number of significant digits
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
/// * num - The float value
/// * digits - The number of significant digits
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
/// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
/// * digits - The number of digits after the decimal point
/// * upper - Use `E` instead of `e` for the exponent sign
#[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 {
let (r, _) = strconv::float_to_str_common(
num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
#![doc(hidden)]
macro_rules! assert_approx_eq {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
#![doc(hidden)]
macro_rules! int_module { ($T:ty) => (
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;
/// Mathematical operations on primitive floating point numbers.
{
// inlined methods from `num::Float`
/// Returns the NaN value.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn nan() -> Self;
/// Returns the infinite value.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn infinity() -> Self;
/// Returns the negative infinite value.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn neg_infinity() -> Self;
/// Returns the `0` value.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn zero() -> Self;
/// Returns -0.0.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn neg_zero() -> Self;
/// Returns the `1` value.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn one() -> Self;
fn max_10_exp(unused_self: Option<Self>) -> int;
/// 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")]
fn min_value() -> Self;
/// 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")]
fn min_pos_value(unused_self: Option<Self>) -> Self;
/// 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")]
fn max_value() -> Self;
/// 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;
/// Returns true if this value is positive infinity or negative infinity and
/// false otherwise.
- #[unstable(feature = "unnamed_feature", reason = "position is undecided")]
+ #[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_infinite(self) -> bool;
/// 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;
/// 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;
/// Returns the category that this number falls into.
#[stable(feature = "grandfathered", since = "1.0.0")]
fn classify(self) -> FpCategory;
/// 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);
/// Return the largest integer less than or equal to a number.
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
/// error. This produces a more accurate result with better performance than
/// a separate multiplication operation followed by an add.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn mul_add(self, a: Self, b: Self) -> Self;
/// 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")]
fn recip(self) -> Self;
#[stable(feature = "grandfathered", since = "1.0.0")]
fn sqrt(self) -> Self;
/// 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")]
fn rsqrt(self) -> Self;
fn log10(self) -> Self;
/// 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;
/// 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;
/// Constructs a floating point number created by multiplying `x` by 2
/// raised to the power of `exp`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "pending integer conventions")]
fn ldexp(x: Self, exp: int) -> Self;
/// Breaks the number into a normalized fraction and a base-2 exponent,
/// * `self = x * pow(2, exp)`
///
/// * `0.5 <= abs(x) < 1.0`
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "pending integer conventions")]
fn frexp(self) -> (Self, int);
/// Returns the next representable floating-point value in the direction of
/// `other`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn next_after(self, other: Self) -> Self;
/// The positive difference of two numbers. Returns `0.0` if the number is
/// less than or equal to `other`, otherwise the difference between`self`
/// 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;
/// 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;
/// Calculate the length of the hypotenuse of a right-angle triangle given
/// legs of length `x` and `y`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
fn hypot(self, other: Self) -> Self;
/// Returns the exponential of the number, minus 1, in a way that is
/// 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;
/// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more
/// 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;
/// Hyperbolic sine function.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
#![doc(hidden)]
#![allow(unsigned_negation)]
//! so we will not _hide_ the facts of which OS the user is on -- they should be given the
//! opportunity to write OS-ignorant code by default.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "os")]
#![allow(missing_docs)]
#![allow(non_snake_case)]
//! println!("path exists: {}", path.exists());
//! ```
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "path")]
use core::marker::Sized;
use ffi::CString;
#[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
// TEMPORARY
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
#[doc(no_inline)] pub use ops::FullRange;
// Reexported functions
//! }
//! ```
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
use cell::RefCell;
use clone::Clone;
//! and should be considered as private implementation details for the
//! time being.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
// FIXME: this should not be here.
#![allow(missing_docs)]
/// Only a limited number of callbacks can be registered, and this function
/// returns whether the callback was successfully registered or not. It is not
/// currently possible to unregister a callback once it has been registered.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
pub unsafe fn register(f: Callback) -> bool {
match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) {
// The invocation code has knowledge of this window where the count has
//! the standard library This varies per-platform, but these libraries are
//! necessary for running libstd.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
// All platforms need to link to rustrt
#[cfg(not(test))]
///
/// static CVAR: StaticCondvar = CONDVAR_INIT;
/// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub struct StaticCondvar {
inner: sys::Condvar,
unsafe impl Sync for StaticCondvar {}
/// Constant initializer for a statically allocated condition variable.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub const CONDVAR_INIT: StaticCondvar = StaticCondvar {
inner: sys::CONDVAR_INIT,
///
/// Like `wait`, the lock specified will be re-acquired when this function
/// returns, regardless of whether the timeout elapsed or not.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "std_misc")]
pub fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>, dur: Duration)
-> LockResult<(MutexGuard<'a, T>, bool)> {
unsafe {
/// The semantics of this function are equivalent to `wait_timeout` except
/// that the implementation will repeatedly wait while the duration has not
/// passed and the provided function returns `false`.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "std_misc")]
pub fn wait_timeout_with<'a, T, F>(&self,
guard: MutexGuard<'a, T>,
dur: Duration,
/// notification.
///
/// See `Condvar::wait`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub fn wait<'a, T>(&'static self, guard: MutexGuard<'a, T>)
-> LockResult<MutexGuard<'a, T>> {
/// specified duration.
///
/// See `Condvar::wait_timeout`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub fn wait_timeout<'a, T>(&'static self, guard: MutexGuard<'a, T>, dur: Duration)
-> LockResult<(MutexGuard<'a, T>, bool)> {
/// passed and the function returns `false`.
///
/// See `Condvar::wait_timeout_with`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub fn wait_timeout_with<'a, T, F>(&'static self,
guard: MutexGuard<'a, T>,
/// Wake up one blocked thread on this condvar.
///
/// See `Condvar::notify_one`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub fn notify_one(&'static self) { unsafe { self.inner.notify_one() } }
/// Wake up all blocked threads on this condvar.
///
/// See `Condvar::notify_all`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub fn notify_all(&'static self) { unsafe { self.inner.notify_all() } }
/// active users of the condvar, and this also doesn't prevent any future
/// users of the condvar. This method is required to be called to not leak
/// memory on all platforms.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Condvar in the future")]
pub unsafe fn destroy(&'static self) {
self.inner.destroy()
//! ```
#![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "futures as-is have yet to be deeply reevaluated with recent \
core changes to Rust's synchronization story, and will likely \
become stable in the future but are unstable until that time")]
//! method, and see the method for more information about it. Due to this
//! caveat, this queue may not be appropriate for all use-cases.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
// http://www.1024cores.net/home/lock-free-algorithms
// /queues/non-intrusive-mpsc-node-based-queue
//! ```
#![allow(dead_code)]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "This implementation, while likely sufficient, is unsafe and \
likely to be error prone. At some point in the future this \
module will likely be replaced, and it is currently \
//! concurrently between two tasks. This data structure is safe to use and
//! enforces the semantics that there is one pusher and one popper.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use core::prelude::*;
/// }
/// // lock is unlocked here.
/// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with Mutex in the future")]
pub struct StaticMutex {
lock: sys::Mutex,
/// Static initialization of a mutex. This constant can be used to initialize
/// other mutex constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with Mutex in the future")]
pub const MUTEX_INIT: StaticMutex = StaticMutex {
lock: sys::MUTEX_INIT,
impl StaticMutex {
/// Acquires this lock, see `Mutex::lock`
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Mutex in the future")]
pub fn lock(&'static self) -> LockResult<MutexGuard<()>> {
unsafe { self.lock.lock() }
/// Attempts to grab this lock, see `Mutex::try_lock`
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Mutex in the future")]
pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> {
if unsafe { self.lock.try_lock() } {
/// *all* platforms. It may be the case that some platforms do not leak
/// memory if this method is not called, but this is not guaranteed to be
/// true on all platforms.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with Mutex in the future")]
pub unsafe fn destroy(&'static self) {
self.lock.destroy()
/// Consumes this error indicating that a lock is poisoned, returning the
/// underlying guard to allow access regardless.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "std_misc")]
pub fn into_inner(self) -> T { self.guard }
/// Reaches into this error indicating that a lock is poisoned, returning a
/// reference to the underlying guard to allow access regardless.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "std_misc")]
pub fn get_ref(&self) -> &T { &self.guard }
/// Reaches into this error indicating that a lock is poisoned, returning a
/// mutable reference to the underlying guard to allow access regardless.
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "std_misc")]
pub fn get_mut(&mut self) -> &mut T { &mut self.guard }
}
/// }
/// unsafe { LOCK.destroy() } // free all resources
/// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub struct StaticRwLock {
lock: sys::RWLock,
unsafe impl Sync for StaticRwLock {}
/// Constant initialization for a statically-initialized rwlock.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock {
lock: sys::RWLOCK_INIT,
///
/// See `RwLock::read`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub fn read(&'static self) -> LockResult<RwLockReadGuard<'static, ()>> {
unsafe { self.lock.read() }
///
/// See `RwLock::try_read`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub fn try_read(&'static self)
-> TryLockResult<RwLockReadGuard<'static, ()>> {
///
/// See `RwLock::write`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub fn write(&'static self) -> LockResult<RwLockWriteGuard<'static, ()>> {
unsafe { self.lock.write() }
///
/// See `RwLock::try_write`.
#[inline]
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub fn try_write(&'static self)
-> TryLockResult<RwLockWriteGuard<'static, ()>> {
/// active users of the lock, and this also doesn't prevent any future users
/// of this lock. This method is required to be called to not leak memory on
/// all platforms.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may be merged with RwLock in the future")]
pub unsafe fn destroy(&'static self) {
self.lock.destroy()
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "the interaction between semaphores and the acquisition/release \
of resources is currently unclear")]
//! Abstraction of a thread pool for basic parallelism.
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "the semantics of a failing task and whether a thread is \
re-attached to a thread pool are somewhat unclear, and the \
utility of this type in `std::sync` is questionable with \
//! }
//! ```
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use sys_common::AsInner;
use libc;
//! descriptors, and sockets, but its functionality will grow over
//! time.
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use sys_common::AsInner;
use libc;
}
/// Redirect thread-local stdout.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "Will likely go away after proc removal")]
pub fn stdout(mut self, stdout: Box<Writer + Send>) -> Builder {
self.stdout = Some(stdout);
}
/// Redirect thread-local stderr.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "Will likely go away after proc removal")]
pub fn stderr(mut self, stderr: Box<Writer + Send>) -> Builder {
self.stderr = Some(stderr);
/// Spawn a new detached thread, and return a handle to it.
///
/// See `Thead::spawn` and the module doc for more details.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may change with specifics of new Send semantics")]
pub fn spawn<F>(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static {
let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {}));
/// scope, and return a `JoinGuard`.
///
/// See `Thead::scoped` and the module doc for more details.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may change with specifics of new Send semantics")]
pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where
T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
/// main thread; the whole process is terminated when the main thread
/// finishes.) The thread handle can be used for low-level
/// synchronization. See the module documentation for additional details.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may change with specifics of new Send semantics")]
pub fn spawn<F>(f: F) -> Thread where F: FnOnce(), F: Send + 'static {
Builder::new().spawn(f)
/// current thread's stack (hence the "scoped" name), it cannot be detached;
/// it *must* be joined before the relevant stack frame is popped. See the
/// module documentation for additional details.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "may change with specifics of new Send semantics")]
pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where
T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
}
/// Cooperatively give up a timeslice to the OS scheduler.
- #[unstable(feature = "unnamed_feature", reason = "name may change")]
+ #[unstable(feature = "std_misc", reason = "name may change")]
pub fn yield_now() {
unsafe { imp::yield_now() }
}
// future, this will be implemented in a more efficient way, perhaps along the lines of
// http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp
// or futuxes, and in either case may allow spurious wakeups.
- #[unstable(feature = "unnamed_feature", reason = "recently introduced")]
+ #[unstable(feature = "std_misc", reason = "recently introduced")]
pub fn park() {
let thread = Thread::current();
let mut guard = thread.inner.lock.lock().unwrap();
/// Atomically makes the handle's token available if it is not already.
///
/// See the module doc for more detail.
- #[unstable(feature = "unnamed_feature", reason = "recently introduced")]
+ #[unstable(feature = "std_misc", reason = "recently introduced")]
pub fn unpark(&self) {
let mut guard = self.inner.lock.lock().unwrap();
if !*guard {
///
/// The type `T` is the return type for the thread's main function.
#[must_use]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "may change with specifics of new Send semantics")]
pub struct JoinGuard<'a, T: 'a> {
native: imp::rust_thread,
impl<T: Send> JoinGuard<'static, T> {
/// Detaches the child thread, allowing it to outlive its parent.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "unsure whether this API imposes limitations elsewhere")]
pub fn detach(mut self) {
unsafe { imp::detach(self.native) };
}
/// Indicator of the state of a thread local storage key.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
reason = "state querying was recently added")]
#[derive(Eq, PartialEq, Copy)]
pub enum State {
/// initialization does not panic. Keys in the `Valid` state are guaranteed
/// to be able to be accessed. Keys in the `Destroyed` state will panic on
/// any call to `with`.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "std_misc",
reason = "state querying was recently added")]
pub fn state(&'static self) -> State {
unsafe {
//! });
//! ```
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
reason = "scoped TLS has yet to have wide enough use to fully consider \
stabilizing its interface")]
// Because this module is temporary...
#![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use alloc::boxed::Box;
use core::marker::Send;
//! Temporal quantification
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
use {fmt, i64};
use ops::{Add, Sub, Mul, Div, Neg, FnOnce};
//! This API is completely unstable and subject to change.
#![crate_name = "syntax"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "dylib"]
#![feature(slicing_syntax)]
#![feature(box_syntax)]
#![feature(quote, unsafe_destructor)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
extern crate arena;
extern crate fmt_macros;
//! [ti]: https://en.wikipedia.org/wiki/Terminfo
#![crate_name = "term"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
reason = "use the crates.io `term` library instead")]
#![feature(staged_api)]
#![staged_api]
#![allow(unknown_features)]
#![feature(slicing_syntax)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
#![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
#[macro_use] extern crate log;
// build off of.
#![crate_name = "test"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
#![allow(unknown_features)]
#![feature(asm, slicing_syntax)]
#![feature(box_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
extern crate getopts;
extern crate regex;
//! (yet) aim to provide a full set of Unicode tables.
#![crate_name = "unicode"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "unicode")]
#![feature(staged_api)]
#![staged_api]
#![crate_type = "rlib"]
html_playground_url = "http://play.rust-lang.org/")]
#![no_std]
#![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(core)]
extern crate core;
/// # Panics
///
/// Panics if given a radix > 36.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool;
/// # Panics
///
/// Panics if given a radix outside the range [0..36].
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint>;
///
/// If the buffer is not large enough, nothing will be written into it
/// and a `None` will be returned.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint>;
///
/// If the buffer is not large enough, nothing will be written into it
/// and a `None` will be returned.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint>;
/// 'XID_Start' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to ID_Start but modified for closure under NFKx.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_start(self) -> bool;
/// 'XID_Continue' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to 'ID_Continue' but modified for closure under NFKx.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_continue(self) -> bool;
///
/// Returns the lowercase equivalent of the character, or the character
/// itself if no conversion is possible.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending case transformation decisions")]
fn to_lowercase(self) -> char;
/// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
///
/// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending case transformation decisions")]
fn to_uppercase(self) -> char;
/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
/// recommends that these characters be treated as 1 column (i.e.,
/// `is_cjk` = `false`) if the context cannot be reliably determined.
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "needs expert opinion. is_cjk flag stands out as ugly")]
fn width(self, is_cjk: bool) -> Option<uint>;
}
#[stable(feature = "grandfathered", since = "1.0.0")]
impl CharExt for char {
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool { C::is_digit(self, radix) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint> { C::to_digit(self, radix) }
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf8(self) -> uint { C::len_utf8(self) }
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf16(self) -> uint { C::len_utf16(self) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { C::encode_utf8(self, dst) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { C::encode_utf16(self, dst) }
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
}
}
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending case transformation decisions")]
fn to_lowercase(self) -> char { conversions::to_lower(self) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "pending case transformation decisions")]
fn to_uppercase(self) -> char { conversions::to_upper(self) }
- #[unstable(feature = "unnamed_feature",
+ #[unstable(feature = "unicode",
reason = "needs expert opinion. is_cjk flag stands out as ugly")]
fn width(self, is_cjk: bool) -> Option<uint> { charwidth::width(self, is_cjk) }
}
// except according to those terms.
#![feature(slicing_syntax, box_syntax)]
-#![feature(unnamed_feature)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(rustdoc)]
extern crate regex;
// except according to those terms.
#![crate_name="inherited_stability"]
#![crate_type = "lib"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test_feature")]
#![feature(staged_api)]
#![staged_api]
pub fn stable() {}
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub mod unstable_mod {
- #[deprecated(feature = "unnamed_feature", since = "1.0.0")]
+ #[deprecated(feature = "test_feature", since = "1.0.0")]
pub fn deprecated() {}
pub fn unstable() {}
#![crate_type = "lib"]
#![feature(staged_api)]
#![staged_api]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test_feature")]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub fn foo() -> uint {
20
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub fn bar() -> uint {
40
}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub fn baz() -> uint {
30
}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
pub fn deprecated_text() {}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub fn unstable() {}
-#[unstable(feature = "unnamed_feature", reason = "text")]
+#[unstable(feature = "test_feature", reason = "text")]
pub fn unstable_text() {}
pub fn unmarked() {}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
pub fn method_deprecated_text(&self) {}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub fn method_unstable(&self) {}
- #[unstable(feature = "unnamed_feature", reason = "text")]
+ #[unstable(feature = "test_feature", reason = "text")]
pub fn method_unstable_text(&self) {}
pub fn method_unmarked(&self) {}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
fn trait_deprecated_text(&self) {}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
fn trait_unstable(&self) {}
- #[unstable(feature = "unnamed_feature", reason = "text")]
+ #[unstable(feature = "test_feature", reason = "text")]
fn trait_unstable_text(&self) {}
fn trait_unmarked(&self) {}
impl Trait for MethodTester {}
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub trait UnstableTrait {}
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedStruct { pub i: int }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub struct UnstableStruct { pub i: int }
pub struct UnmarkedStruct { pub i: int }
#[stable(feature = "grandfathered", since = "1.0.0")]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedUnitStruct;
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub struct UnstableUnitStruct;
pub struct UnmarkedUnitStruct;
#[stable(feature = "grandfathered", since = "1.0.0")]
pub enum Enum {
#[deprecated(feature = "oldstuff", since = "1.0.0")]
DeprecatedVariant,
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
UnstableVariant,
UnmarkedVariant,
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedTupleStruct(pub int);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
pub struct UnstableTupleStruct(pub int);
pub struct UnmarkedTupleStruct(pub int);
#[stable(feature = "grandfathered", since = "1.0.0")]
// except according to those terms.
#![cfg_attr(foo, experimental)]
-#![cfg_attr(not(foo), stable(feature = "unnamed_feature", since = "1.0.0"))]
+#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))]
#![feature(staged_api)]
#![staged_api]
// compile-flags:--cfg foo
-#![cfg_attr(foo, unstable(feature = "unnamed_feature"))]
-#![cfg_attr(not(foo), stable(feature = "unnamed_feature", since = "1.0.0"))]
+#![cfg_attr(foo, unstable(feature = "test_feature"))]
+#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))]
#![feature(staged_api)]
#![staged_api]
// aux-build:stability_cfg2.rs
-#![feature(unnamed_feature)]
+#![feature(test_feature)]
#![deny(non_snake_case)] // To trigger a hard error
// Shouldn't generate a warning about unstable features
#![deny(dead_code)]
#![allow(unreachable_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
#[macro_use] extern crate core;
// except according to those terms.
#![deny(unused_variables)]
-#![feature(unnamed_feature)]
+#![feature(core)]
fn main() {
for _ in range(1is, 101) {
// except according to those terms.
#![deny(improper_ctypes)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
extern crate libc;
#![allow(non_upper_case_globals)]
#![allow(missing_copy_implementations)]
#![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
#![crate_type="lib"]
#![allow(unused_variables)]
#![allow(non_camel_case_types)]
#![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
#![crate_type="lib"]
#![allow(unused_variables)]
#![allow(non_camel_case_types)]
#![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
+#![feature(core)]
+#![feature(collections)]
extern crate libc;
#![deny(exceeding_bitshifts)]
#![allow(unused_variables)]
#![allow(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
fn main() {
let n = 1u8 << 7;
foo.method_unstable(); //~ WARNING use of unstable library feature
foo.trait_unstable(); //~ WARNING use of unstable library feature
- unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
- foo.method_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
- foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+ unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
+ foo.method_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
+ foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
unmarked(); //~ ERROR use of unmarked library feature
foo.method_unmarked(); //~ ERROR use of unmarked library feature
foo.trait_deprecated(); //~ ERROR use of deprecated item
foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
foo.trait_unstable(); //~ WARNING use of unstable library feature
- foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+ foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
foo.trait_unmarked(); //~ ERROR use of unmarked library feature
foo.trait_stable();
}
foo.trait_deprecated(); //~ ERROR use of deprecated item
foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
foo.trait_unstable(); //~ WARNING use of unstable library feature
- foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+ foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
foo.trait_unmarked(); //~ ERROR use of unmarked library feature
foo.trait_stable();
}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
pub fn deprecated_text() {}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub fn unstable() {}
- #[unstable(feature = "unnamed_feature", reason = "text")]
+ #[unstable(feature = "test_feature", reason = "text")]
pub fn unstable_text() {}
pub fn unmarked() {}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
pub fn method_deprecated_text(&self) {}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub fn method_unstable(&self) {}
- #[unstable(feature = "unnamed_feature", reason = "text")]
+ #[unstable(feature = "test_feature", reason = "text")]
pub fn method_unstable_text(&self) {}
pub fn method_unmarked(&self) {}
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
fn trait_deprecated_text(&self) {}
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
fn trait_unstable(&self) {}
- #[unstable(feature = "unnamed_feature", reason = "text")]
+ #[unstable(feature = "test_feature", reason = "text")]
fn trait_unstable_text(&self) {}
fn trait_unmarked(&self) {}
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedStruct { i: isize }
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub struct UnstableStruct { i: isize }
pub struct UnmarkedStruct { i: isize }
#[stable(feature = "grandfathered", since = "1.0.0")]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedUnitStruct;
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub struct UnstableUnitStruct;
pub struct UnmarkedUnitStruct;
#[stable(feature = "grandfathered", since = "1.0.0")]
pub enum Enum {
#[deprecated(feature = "oldstuff", since = "1.0.0")]
DeprecatedVariant,
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
UnstableVariant,
UnmarkedVariant,
#[deprecated(feature = "oldstuff", since = "1.0.0")]
pub struct DeprecatedTupleStruct(isize);
- #[unstable(feature = "unnamed_feature")]
+ #[unstable(feature = "test_feature")]
pub struct UnstableTupleStruct(isize);
pub struct UnmarkedTupleStruct(isize);
#[stable(feature = "grandfathered", since = "1.0.0")]
#![deny(unused_extern_crates)]
#![allow(unused_variables)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
+#![feature(collections)]
+#![feature(rand)]
extern crate libc; //~ ERROR: unused extern crate
#![allow(dead_code)]
#![deny(non_snake_case)]
-#![feature(unnamed_feature)]
+#![feature(path)]
+#![feature(io)]
use std::io::File;
use std::io::IoError;
#![deny(unused_variables)]
#![deny(unused_assignments)]
#![allow(dead_code, non_camel_case_types)]
-#![feature(unnamed_feature)]
+#![feature(core)]
+#![feature(os)]
fn f1(x: isize) {
//~^ ERROR unused variable: `x`
// except according to those terms.
#![deny(unused_attributes)]
#![allow(dead_code, unused_imports)]
-#![feature(unnamed_feature)]
+#![feature(core)]
#![foo] //~ ERROR unused attribute
projects / rust.git / commitdiff