user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Set unstable feature names appropriately

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

4
src/libcore/any.rs
View file

@ -89,7 +89,7 @@ use intrinsics;
#[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;
}
@ -177,7 +177,7 @@ impl 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 {

4
src/libcore/array.rs
View file

@ -12,7 +12,7 @@
//! 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};
@ -39,7 +39,7 @@ macro_rules! array_impls {
}
}
#[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 {

8
src/libcore/atomic.rs
View file

@ -1036,7 +1036,7 @@ pub fn fence(order: Ordering) {
}
}
#[deprecated(feature = "unnamed_feature", since = "1.0.0",
#[deprecated(feature = "core", since = "1.0.0",
reason = "renamed to AtomicIsize")]
#[allow(missing_docs)]
pub struct AtomicInt {
@ -1045,7 +1045,7 @@ 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 {
@ -1054,12 +1054,12 @@ 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 =

2
src/libcore/borrow.rs
View file

@ -42,7 +42,7 @@
//! 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;

12
src/libcore/cell.rs
View file

@ -201,7 +201,7 @@ impl<T:Copy> Cell<T> {
///
/// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline]
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value
}
@ -271,7 +271,7 @@ impl<T> RefCell<T> {
/// 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 }),
@ -301,7 +301,7 @@ impl<T> RefCell<T> {
/// 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 }),
@ -331,7 +331,7 @@ impl<T> RefCell<T> {
///
/// 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
}
@ -423,7 +423,7 @@ impl<'b, T> Deref for Ref<'b, T> {
///
/// 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 {
@ -528,7 +528,7 @@ pub struct UnsafeCell<T> {
///
/// This field should not be accessed directly, it is made public for static
/// initializers.
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
pub value: T,
}

18
src/libcore/char.rs
View file

@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> {
/// Panics if given an `radix` > 36.
///
#[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)");
@ -126,7 +126,7 @@ pub trait CharExt {
/// # 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;
@ -141,7 +141,7 @@ pub trait CharExt {
/// # 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>;
@ -198,13 +198,13 @@ pub trait CharExt {
#[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 {
@ -260,7 +260,7 @@ impl CharExt for char {
}
#[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
@ -289,7 +289,7 @@ impl CharExt for char {
}
#[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
@ -320,7 +320,7 @@ pub struct EscapeUnicode {
}
#[derive(Clone)]
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
enum EscapeUnicodeState {
Backslash,
Type,
@ -382,7 +382,7 @@ pub struct EscapeDefault {
}
#[derive(Clone)]
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
enum EscapeDefaultState {
Backslash(char),
Char(char),

4
src/libcore/clone.rs
View file

@ -36,7 +36,7 @@ pub trait Clone : Sized {
/// but can be overridden to reuse the resources of `a` to avoid unnecessary
/// 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()
@ -82,7 +82,7 @@ clone_impl! { char }
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

4
src/libcore/cmp.rs
View file

@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
///
/// Returns the first argument if the comparison determines them to be equal.
#[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),
@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
///
/// Returns the first argument if the comparison determines them to be equal.
#[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),

2
src/libcore/finally.rs
View file

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

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

@ -36,7 +36,7 @@ mod num;
mod float;
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>;
@ -46,7 +46,7 @@ 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;
@ -60,7 +60,7 @@ 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
@ -104,7 +104,7 @@ pub trait Writer {
/// 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,
@ -127,7 +127,7 @@ enum Void {}
/// 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> {
@ -167,7 +167,7 @@ impl<'a> Arguments<'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> {
@ -185,7 +185,7 @@ impl<'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],
@ -236,7 +236,7 @@ impl<'a> String for Arguments<'a> {
/// 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.
@ -245,7 +245,7 @@ pub trait Show {
/// 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.
@ -254,7 +254,7 @@ pub trait String {
/// 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.
@ -262,7 +262,7 @@ pub trait Octal {
}
/// 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.
@ -270,7 +270,7 @@ pub trait Binary {
}
/// 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.
@ -278,7 +278,7 @@ pub trait LowerHex {
}
/// 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.
@ -286,7 +286,7 @@ pub trait UpperHex {
}
/// 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.
@ -294,7 +294,7 @@ pub trait Pointer {
}
/// 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.
@ -302,7 +302,7 @@ pub trait LowerExp {
}
/// 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.
@ -317,7 +317,7 @@ pub trait UpperExp {
///
/// * 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 {
@ -415,7 +415,7 @@ impl<'a> Formatter<'a> {
///
/// 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,
@ -492,7 +492,7 @@ impl<'a> Formatter<'a> {
/// 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
@ -570,38 +570,38 @@ impl<'a> Formatter<'a> {
/// 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 }
}
@ -614,7 +614,7 @@ impl Show for Error {
/// 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> {
@ -624,7 +624,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
/// When the compiler determines that the type of an argument *must* be a uint
/// (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)
@ -879,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> {
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<T: Show> Show for RefCell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match self.try_borrow() {

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

@ -111,7 +111,7 @@ radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x,
/// A radix with in the range of `2..36`.
#[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,
@ -136,7 +136,7 @@ impl GenericRadix for Radix {
}
/// 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);
@ -149,7 +149,7 @@ 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))

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

@ -14,7 +14,7 @@
//! These definitions are similar to their `ct` equivalents, but differ in that
//! these 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::*;

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

@ -56,7 +56,7 @@
//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
//! ```
#![unstable(feature = "unnamed_feature",
#![unstable(feature = "hash",
reason = "module was recently redesigned")]
use prelude::*;
@ -96,7 +96,7 @@ pub trait Hasher {
/// 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 {

8
src/libcore/intrinsics.rs
View file

@ -39,7 +39,7 @@
//! 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;
@ -303,7 +303,7 @@ extern "rust-intrinsic" {
/// }
/// }
/// ```
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
@ -333,12 +333,12 @@ extern "rust-intrinsic" {
/// }
/// ```
///
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
/// 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);

102
src/libcore/iter.rs
View file

@ -564,7 +564,7 @@ pub trait IteratorExt: Iterator + Sized {
/// 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>,
@ -760,7 +760,7 @@ pub trait IteratorExt: Iterator + Sized {
/// 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() {
@ -817,7 +817,7 @@ pub trait IteratorExt: Iterator + Sized {
/// 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,
@ -847,7 +847,7 @@ pub trait IteratorExt: Iterator + Sized {
/// 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,
@ -887,7 +887,7 @@ pub trait IteratorExt: Iterator + Sized {
///
/// 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>,
@ -920,7 +920,7 @@ pub trait IteratorExt: Iterator + Sized {
/// 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>,
@ -948,7 +948,7 @@ pub trait IteratorExt: Iterator + Sized {
}
/// 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
@ -982,7 +982,7 @@ pub trait DoubleEndedIterator: Iterator {
/// 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`
@ -1058,7 +1058,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
}
#[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() }
@ -1093,7 +1093,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat
}
/// A trait for iterators over elements which can be added together
#[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
@ -1112,7 +1112,7 @@ pub trait AdditiveIterator<A> {
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 {
@ -1135,7 +1135,7 @@ impl_additive! { f32, 0.0 }
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
@ -1157,7 +1157,7 @@ pub trait MultiplicativeIterator<A> {
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 {
@ -1181,7 +1181,7 @@ impl_multiplicative! { f64, 1.0 }
/// `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
@ -1214,7 +1214,7 @@ impl<T: Clone> MinMaxResult<T> {
/// 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,
@ -1225,7 +1225,7 @@ impl<T: Clone> MinMaxResult<T> {
}
/// 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> {
@ -1299,7 +1299,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Cycle<I> where
I: Clone + RandomAccessIterator,
{
@ -1384,7 +1384,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<T, A, B> RandomAccessIterator for Chain<A, B> where
A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=T>,
@ -1476,7 +1476,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
A: RandomAccessIterator<Item=T>,
B: RandomAccessIterator<Item=U>,
@ -1558,7 +1558,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
I: RandomAccessIterator<Item=A>,
F: FnMut(A) -> B,
@ -1747,7 +1747,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
#[inline]
fn indexable(&self) -> uint {
@ -1973,7 +1973,7 @@ impl<I> Iterator for Skip<I> where I: Iterator {
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
#[inline]
fn indexable(&self) -> uint {
@ -2028,7 +2028,7 @@ impl<I> Iterator for Take<I> where I: Iterator{
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
#[inline]
fn indexable(&self) -> uint {
@ -2241,7 +2241,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
}
// Allow RandomAccessIterators to be fused without affecting random-access behavior
#[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 {
@ -2258,7 +2258,7 @@ impl<I> Fuse<I> {
/// 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
}
@ -2327,7 +2327,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
I: RandomAccessIterator<Item=A>,
F: FnMut(&A),
@ -2376,7 +2376,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
/// 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
@ -2397,7 +2397,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
/// Creates a new iterator with the specified closure as the "iterator
/// function" and an initial state to eventually pass to the closure
@ -2429,7 +2429,7 @@ impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A
/// An infinite iterator starting at `start` and advancing by `step` with each
/// 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)
@ -2440,7 +2440,7 @@ pub struct Counter<A> {
/// 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}
@ -2465,7 +2465,7 @@ impl<A: Add<Output=A> + Clone> Iterator for Counter<A> {
/// 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,
@ -2487,7 +2487,7 @@ pub struct Range<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 {
@ -2498,7 +2498,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
}
// 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;
@ -2549,7 +2549,7 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> {
/// `Int` is required to ensure the range will be the same regardless of
/// 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]
@ -2565,7 +2565,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
/// 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>,
@ -2574,7 +2574,7 @@ pub struct RangeInclusive<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 {
@ -2583,7 +2583,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
}
}
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
type Item = A;
@ -2619,7 +2619,7 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
}
}
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
#[inline]
@ -2639,7 +2639,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[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,
@ -2650,14 +2650,14 @@ pub struct RangeStep<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;
@ -2679,7 +2679,7 @@ impl<A: Int> Iterator for RangeStep<A> {
/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[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,
@ -2691,7 +2691,7 @@ pub struct RangeStepInclusive<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();
@ -2704,7 +2704,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl
}
}
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
impl<A: Int> Iterator for RangeStepInclusive<A> {
type Item = A;
@ -2730,7 +2730,7 @@ impl<A: Int> Iterator for RangeStepInclusive<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.
@ -2746,7 +2746,7 @@ pub trait Step: Ord {
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; }
@ -2763,7 +2763,7 @@ macro_rules! step_impl {
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; }
@ -2807,7 +2807,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> {
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 }
@ -2819,12 +2819,12 @@ type IterateState<T, F> = (F, Option<T>, bool);
/// 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,
@ -2867,7 +2867,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
///
/// If two sequences are equal up until the point where one ends,
/// 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};

2
src/libcore/lib.rs
View file

@ -48,7 +48,7 @@
// 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"]

4
src/libcore/macros.rs
View file

@ -235,7 +235,7 @@ macro_rules! writeln {
/// }
/// ```
#[macro_export]
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "relationship with panic is unclear")]
macro_rules! unreachable {
() => ({
@ -252,7 +252,7 @@ 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"))

28
src/libcore/marker.rs
View file

@ -28,7 +28,7 @@
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 {
@ -192,7 +192,7 @@ pub trait Copy {
/// 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 {
@ -237,7 +237,7 @@ 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)]
@ -287,7 +287,7 @@ impl<T: ?Sized> Clone for CovariantType<T> {
/// subtype of `S<U>` if `U` is a subtype of `T`; given that the
/// 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)]
@ -318,16 +318,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> {
/// 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 }
@ -349,7 +349,7 @@ impl<T: ?Sized> Clone for InvariantType<T> {
///
/// 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)]
@ -367,7 +367,7 @@ pub struct CovariantLifetime<'a>;
///
/// 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)]
@ -380,7 +380,7 @@ pub struct ContravariantLifetime<'a>;
/// 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)]
@ -390,7 +390,7 @@ pub struct InvariantLifetime<'a>;
/// 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)]
@ -400,7 +400,7 @@ pub struct NoSend;
/// 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)]
@ -410,7 +410,7 @@ pub struct NoCopy;
/// 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)]
@ -419,7 +419,7 @@ pub struct NoSync;
/// 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)]

4
src/libcore/mem.rs
View file

@ -318,7 +318,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
/// Transforms lifetime of the second pointer to match the first.
#[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,
@ -328,7 +328,7 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
/// Transforms lifetime of the second mutable pointer to match the first.
#[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,

2
src/libcore/nonzero.rs
View file

@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {}
/// 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> {

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

@ -22,12 +22,12 @@ use num::Float;
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")]
@ -43,14 +43,14 @@ pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32;
#[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")]
@ -61,7 +61,7 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32;
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
/// 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.
@ -118,7 +118,7 @@ pub mod consts {
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 }

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

@ -26,11 +26,11 @@ use option::Option;
// 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")]
@ -46,14 +46,14 @@ pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64;
#[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")]
@ -64,7 +64,7 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64;
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
/// 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.
@ -125,7 +125,7 @@ pub mod consts {
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 }

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

@ -14,11 +14,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => (
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// 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

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

@ -50,25 +50,25 @@ pub trait Int
{
/// 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;
@ -83,7 +83,7 @@ pub trait Int
///
/// assert_eq!(n.count_ones(), 3);
/// ```
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "pending integer conventions")]
fn count_ones(self) -> uint;
@ -98,7 +98,7 @@ pub trait Int
///
/// assert_eq!(n.count_zeros(), 5);
/// ```
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "pending integer conventions")]
#[inline]
fn count_zeros(self) -> uint {
@ -117,7 +117,7 @@ pub trait Int
///
/// assert_eq!(n.leading_zeros(), 10);
/// ```
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "pending integer conventions")]
fn leading_zeros(self) -> uint;
@ -133,7 +133,7 @@ pub trait Int
///
/// assert_eq!(n.trailing_zeros(), 3);
/// ```
#[unstable(feature = "unnamed_feature",
#[unstable(feature = "core",
reason = "pending integer conventions")]
fn trailing_zeros(self) -> uint;
@ -150,7 +150,7 @@ pub trait Int
///
/// 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;
@ -167,7 +167,7 @@ pub trait Int
///
/// 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;
@ -368,7 +368,7 @@ pub trait Int
///
/// 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 {
@ -632,7 +632,7 @@ pub trait SignedInt
{
/// 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`.
@ -737,7 +737,7 @@ impl UnsignedInt for u32 {}
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]
@ -1002,7 +1002,7 @@ impl_to_primitive_float! { f32 }
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.
@ -1084,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized {
}
/// 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)
}
@ -1201,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 }
/// ```
///
#[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.
@ -1242,7 +1242,7 @@ impl_num_cast! { f64, to_f64 }
/// 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,
@ -1262,7 +1262,7 @@ pub enum FpCategory {
//
// 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
@ -1418,20 +1418,20 @@ pub trait Float
}
/// 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.
@ -1465,7 +1465,7 @@ macro_rules! from_str_radix_float_impl {
}
}
#[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.
@ -1630,7 +1630,7 @@ from_str_radix_float_impl! { f64 }
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]
@ -1639,7 +1639,7 @@ macro_rules! from_str_radix_int_impl {
}
}
#[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> {

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

@ -12,9 +12,9 @@
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")]

38
src/libcore/ops.rs
View file

@ -108,7 +108,7 @@ pub trait Drop {
// based on "op T" where T is expected to be `Copy`able
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;
@ -125,7 +125,7 @@ macro_rules! forward_ref_unop {
// 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;
@ -136,7 +136,7 @@ macro_rules! forward_ref_binop {
}
}
#[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;
@ -147,7 +147,7 @@ macro_rules! forward_ref_binop {
}
}
#[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;
@ -974,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> {
/// 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)
@ -987,7 +987,7 @@ impl fmt::Show for FullRange {
/// 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,
@ -995,7 +995,7 @@ pub struct Range<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;
@ -1020,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> {
}
}
#[unstable(feature = "unnamed_feature", reason = "API still in development")]
#[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
#[inline]
fn next_back(&mut self) -> Option<Idx> {
@ -1033,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
}
}
#[unstable(feature = "unnamed_feature", reason = "API still in development")]
#[unstable(feature = "core", reason = "API still in development")]
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
#[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)
@ -1046,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
/// 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;
@ -1065,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
}
}
#[unstable(feature = "unnamed_feature", reason = "API still in development")]
#[unstable(feature = "core", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..", self.start)
@ -1075,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
/// 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)
@ -1196,7 +1196,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T {
/// 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.
@ -1205,7 +1205,7 @@ pub trait Fn<Args,Result> {
/// 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.
@ -1214,7 +1214,7 @@ pub trait FnMut<Args,Result> {
/// 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.

12
src/libcore/option.rs
View file

@ -285,7 +285,7 @@ impl<T> Option<T> {
/// 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 {
@ -477,7 +477,7 @@ impl<T> Option<T> {
/// 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),
@ -498,7 +498,7 @@ impl<T> Option<T> {
/// 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),
@ -543,7 +543,7 @@ impl<T> Option<T> {
/// 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() } }
@ -704,7 +704,7 @@ impl<T> Option<T> {
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())
@ -748,7 +748,7 @@ impl<T: Default> Option<T> {
// 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)

30
src/libcore/ptr.rs
View file

@ -99,13 +99,13 @@ use cmp::Ordering::{self, Less, Equal, Greater};
// FIXME #19649: intrinsic docs don't render, so these have no docs :(
#[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;
@ -146,7 +146,7 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T }
/// Beyond accepting a raw pointer, this is unsafe because it will not drop the
/// 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);
@ -215,7 +215,7 @@ pub unsafe fn read<T>(src: *const T) -> T {
///
/// 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`:
@ -262,7 +262,7 @@ pub trait PtrExt: Sized {
/// 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>;
@ -291,7 +291,7 @@ pub trait MutPtrExt {
///
/// 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>;
@ -312,7 +312,7 @@ impl<T> PtrExt for *const 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> {
@ -339,7 +339,7 @@ impl<T> PtrExt for *mut 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> {
@ -356,7 +356,7 @@ impl<T> MutPtrExt for *mut 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> {
@ -521,33 +521,33 @@ impl<T> PartialOrd for *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)

2
src/libcore/raw.rs
View file

@ -9,7 +9,7 @@
// 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.
//!

4
src/libcore/result.rs
View file

@ -417,7 +417,7 @@ impl<T, E> Result<T, E> {
/// 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 {
@ -950,7 +950,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
/// If an `Err` is encountered, it is immediately returned.
/// Otherwise, the folded value is returned.
#[inline]
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
pub fn fold<T,
V,
E,

20
src/libcore/simd.rs
View file

@ -36,7 +36,7 @@
#![allow(non_camel_case_types)]
#![allow(missing_docs)]
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
@ -45,26 +45,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8);
#[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)]
@ -73,32 +73,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8);
#[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)]

64
src/libcore/slice.rs
View file

@ -131,7 +131,7 @@ pub trait SliceExt {
fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<T> SliceExt for [T] {
type Item = T;
@ -258,7 +258,7 @@ impl<T> SliceExt for [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
{
@ -452,12 +452,12 @@ impl<T> SliceExt for [T] {
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; }
@ -488,7 +488,7 @@ impl<T> SliceExt for [T] {
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; }
@ -630,26 +630,26 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] {
////////////////////////////////////////////////////////////////////////////////
/// 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) }
@ -755,7 +755,7 @@ pub struct Iter<'a, T: 'a> {
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]
@ -764,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -773,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -782,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -796,7 +796,7 @@ impl<'a, T> Iter<'a, T> {
///
/// 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)
}
@ -814,7 +814,7 @@ impl<'a, T> Clone for Iter<'a, T> {
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 {
@ -848,7 +848,7 @@ pub struct IterMut<'a, T: 'a> {
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -856,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
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]
@ -864,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
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]
@ -872,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
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]
@ -881,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -889,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -897,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -905,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable(feature = "unnamed_feature")]
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -922,7 +922,7 @@ impl<'a, T> IterMut<'a, T> {
/// 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)
}
@ -1270,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
}
}
#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
#[unstable(feature = "core", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
#[inline]
fn indexable(&self) -> uint {
@ -1354,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
//
/// Converts a pointer to A into a slice of length 1 (without copying).
#[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 })
@ -1362,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
}
/// Converts a pointer to A into a slice of length 1 (without copying).
#[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);
@ -1396,7 +1396,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
/// }
/// ```
#[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 })
@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
/// not being able to provide a non-aliasing guarantee of the returned mutable
/// 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 })
@ -1420,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
//
/// Operations on `[u8]`.
#[unstable(feature = "unnamed_feature", reason = "needs review")]
#[unstable(feature = "core", reason = "needs review")]
pub mod bytes {
use ptr;
use slice::SliceExt;
@ -1508,7 +1508,7 @@ impl<T: PartialOrd> PartialOrd for [T] {
}
/// 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];
@ -1523,7 +1523,7 @@ pub trait IntSliceExt<U, S> {
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) } }

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

@ -108,7 +108,7 @@ macro_rules! delegate_iter {
/// A trait to abstract the idea of creating a new instance of a type from a
/// 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
@ -144,7 +144,7 @@ Section: Creating a string
/// 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.
@ -208,7 +208,7 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str {
}
/// Something that can be used to compare against a character
#[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
@ -861,7 +861,7 @@ impl Searcher {
/// 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,
@ -872,7 +872,7 @@ pub struct MatchIndices<'a> {
/// 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,
@ -1056,7 +1056,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
/// 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`
@ -1151,7 +1151,7 @@ mod traits {
}
/// 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")]
@ -1178,7 +1178,7 @@ delegate_iter!{pattern &'a str : Split<'a, P>}
/// 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>}