use core::cmp::{self, Ord, PartialEq};
use core::iter::{Iterator, IteratorExt};
use core::iter::{range, range_step, MultiplicativeIterator};
- use core::kinds::Sized;
+ use core::marker::Sized;
use core::mem::size_of;
use core::mem;
-use core::ops::{FnMut, SliceMut};
+use core::ops::{FnMut, FullRange, Index, IndexMut};
use core::option::Option::{self, Some, None};
use core::ptr::PtrExt;
use core::ptr;
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use fmt;
- use kinds::Copy;
+ use marker::Copy;
-use ops::Deref;
+use ops::{Deref, FullRange, Index};
use option::Option;
// macro for implementing n-ary tuple functions and operations
use clone::Clone;
use cmp::PartialEq;
use default::Default;
- use kinds::{Copy, Send};
-use fmt;
+ use marker::{Copy, Send};
use ops::{Deref, DerefMut, Drop};
use option::Option;
use option::Option::{None, Some};
#![allow(unused_variables)]
use any;
-use cell::{Cell, Ref, RefMut};
+use cell::{Cell, RefCell, Ref, RefMut};
+use char::CharExt;
use iter::{Iterator, IteratorExt, range};
- use kinds::{Copy, Sized};
+ use marker::{Copy, Sized};
use mem;
use option::Option;
use option::Option::{Some, None};
use cmp::{PartialOrd, Ord};
use intrinsics;
use iter::IteratorExt;
- use kinds::Copy;
+ use marker::Copy;
use mem::size_of;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
-use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
+use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index};
use option::Option;
use option::Option::{Some, None};
use str::{FromStr, StrExt};
//! ```
// Reexported core operators
- pub use kinds::{Copy, Send, Sized, Sync};
+ pub use marker::{Copy, Send, Sized, Sync};
-pub use ops::{Drop, Fn, FnMut, FnOnce};
+pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
// Reexported functions
pub use iter::range;
use cmp;
use default::Default;
use iter::*;
- use kinds::Copy;
+ use marker::Copy;
use num::Int;
-use ops::{FnMut, self};
+use ops::{FnMut, self, Index};
use option::Option;
use option::Option::{None, Some};
use result::Result;
use iter::range;
use iter::ExactSizeIterator;
use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
- use kinds::Sized;
+ use marker::Sized;
use mem;
use num::Int;
-use ops::{Fn, FnMut};
+use ops::{Fn, FnMut, Index};
use option::Option::{self, None, Some};
use ptr::PtrExt;
use raw::{Repr, Slice};
use core::fmt::Show;
use core::num::{NumCast, cast};
use core::ops::{Add, Sub, Mul, Div, Rem};
- use core::kinds::Copy;
+ use core::marker::Copy;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod int_macros;
mod i8;
use fmt;
use int;
use iter::{Iterator, IteratorExt};
- use kinds::Sized;
+ use marker::Sized;
use mem::transmute;
-use ops::FnOnce;
+use ops::{FnOnce, Index};
use option::Option;
use option::Option::{Some, None};
use os;
use io::Writer;
use iter::{AdditiveIterator, Extend};
use iter::{Iterator, IteratorExt, Map};
- use prelude::v1::Index;
- use kinds::Sized;
++use ops::Index;
+ use marker::Sized;
use option::Option::{self, Some, None};
use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
use str::{self, FromStr, StrExt};
#![stable]
// Reexported core operators
- #[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync};
+ #[stable] #[doc(no_inline)] pub use marker::{Copy, Send, Sized, Sync};
-#[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
+#[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
- #[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut};
// Reexported functions
#[stable] #[doc(no_inline)] pub use mem::drop;
trait Foo<T> : Sized { fn take(self, x: &T) { } } // Note: T is sized
- impl Foo<[isize]> for uint { }
- //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[isize]`
-impl Foo<[int]> for uint { }
-//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[int]`
++impl Foo<[isize]> for usize { }
++//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[isize]`
-impl Foo<int> for [uint] { }
-//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[uint]`
+impl Foo<isize> for [usize] { }
- //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[usize]`
++//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
pub fn main() { }
let x = foo(Port(Rc::new(())));
Thread::spawn(move|| {
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
let y = x;
- println!("{}", y);
+ println!("{:?}", y);
});
}