Add impls for primitive types in libstd

These impls are mostly currently blank, but they will get filled out in the
future with implementations as we remove satellite traits in favor of inherent
methods on primitives.

Author: alexcrichton

src/libextra/uuid.rs

@@ -58,7 +58,6 @@ Examples of string representations:
 use std::str;
 use std::vec;
 use std::num::FromStrRadix;
-use std::char::Char;
 use std::container::Container;
 use std::to_str::ToStr;
 use std::rand;

src/libstd/bool.rs

@@ -66,8 +66,13 @@ pub fn all_values(blk: |v: bool|) {
 // Methods on `bool`
 /////////////////////////////////////////////////////////////////////////////
 
-/// Extension methods on a `bool`
-pub trait Bool {
+#[cfg(not(stage0), not(test))]
+#[lang = "bool_impl"]
+/// The boolean primitive for Rust.
+///
+/// This primitive can have two values, `true` and `false`, and is type type
+/// that is used to conditions in `if` statements and `while` loops.
+impl bool {
     /// Conjunction of two boolean values.
     ///
     /// # Examples
@@ -78,7 +83,7 @@ pub trait Bool {
     /// assert_eq!(false.and(true), false);
     /// assert_eq!(false.and(false), false);
     /// ```
-    fn and(self, b: bool) -> bool;
+    pub fn and(self, b: bool) -> bool { self && b }
 
     /// Disjunction of two boolean values.
     ///
@@ -90,7 +95,8 @@ pub trait Bool {
     /// assert_eq!(false.or(true), true);
     /// assert_eq!(false.or(false), false);
     /// ```
-    fn or(self, b: bool) -> bool;
+    #[inline]
+    pub fn or(self, b: bool) -> bool { self || b }
 
     /// An 'exclusive or' of two boolean values.
     ///
@@ -104,7 +110,8 @@ pub trait Bool {
     /// assert_eq!(false.xor(true), true);
     /// assert_eq!(false.xor(false), false);
     /// ```
-    fn xor(self, b: bool) -> bool;
+    #[inline]
+    pub fn xor(self, b: bool) -> bool { self ^ b }
 
     /// Implication between two boolean values.
     ///
@@ -120,7 +127,8 @@ pub trait Bool {
     /// assert_eq!(false.implies(true), true);
     /// assert_eq!(false.implies(false), true);
     /// ```
-    fn implies(self, b: bool) -> bool;
+    #[inline]
+    pub fn implies(self, b: bool) -> bool { !self || b }
 
     /// Convert a `bool` to a `u8`.
     ///
@@ -130,9 +138,24 @@ pub trait Bool {
     /// assert_eq!(true.to_bit::<u8>(), 1u8);
     /// assert_eq!(false.to_bit::<u8>(), 0u8);
     /// ```
+    #[inline]
+    pub fn to_bit<N: FromPrimitive>(self) -> N {
+        if self { FromPrimitive::from_u8(1).unwrap() }
+        else    { FromPrimitive::from_u8(0).unwrap() }
+    }
+}
+
+#[cfg(stage0)]
+#[allow(missing_doc)]
+pub trait Bool {
+    fn and(self, b: bool) -> bool;
+    fn or(self, b: bool) -> bool;
+    fn xor(self, b: bool) -> bool;
+    fn implies(self, b: bool) -> bool;
     fn to_bit<N: FromPrimitive>(self) -> N;
 }
 
+#[cfg(stage0)]
 impl Bool for bool {
     #[inline]
     fn and(self, b: bool) -> bool { self && b }

src/libstd/char.rs

@@ -350,7 +350,61 @@ impl ToStr for char {
     }
 }
 
+#[cfg(not(stage0), not(test))]
+#[lang = "char_impl"]
 #[allow(missing_doc)]
+/// The character primitive type in Rust.
+///
+/// A `char` represents a unicode codepoint, and is represented as a 32-bit
+/// value on all architectures. This type is not equivalent with the C `char`
+/// type because it is used to represent more than just ASCII.
+impl char {
+    pub fn is_alphabetic(&self) -> bool { is_alphabetic(*self) }
+    pub fn is_XID_start(&self) -> bool { is_XID_start(*self) }
+    pub fn is_XID_continue(&self) -> bool { is_XID_continue(*self) }
+    pub fn is_lowercase(&self) -> bool { is_lowercase(*self) }
+    pub fn is_uppercase(&self) -> bool { is_uppercase(*self) }
+    pub fn is_whitespace(&self) -> bool { is_whitespace(*self) }
+    pub fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) }
+    pub fn is_control(&self) -> bool { is_control(*self) }
+    pub fn is_digit(&self) -> bool { is_digit(*self) }
+    pub fn is_digit_radix(&self, radix: uint) -> bool { is_digit_radix(*self, radix) }
+    pub fn to_digit(&self, radix: uint) -> Option<uint> { to_digit(*self, radix) }
+    pub fn from_digit(num: uint, radix: uint) -> Option<char> { from_digit(num, radix) }
+    pub fn escape_unicode(&self, f: |char|) { escape_unicode(*self, f) }
+    pub fn escape_default(&self, f: |char|) { escape_default(*self, f) }
+    pub fn len_utf8_bytes(&self) -> uint { len_utf8_bytes(*self) }
+
+    /// Encodes this character as utf-8 into the provided byte-buffer. The
+    /// buffer must be at least 4 bytes long or a runtime failure will occur.
+    ///
+    /// This will then return the number of characters written to the slice.
+    pub fn encode_utf8<'a>(&self, dst: &'a mut [u8]) -> uint {
+        let code = *self as uint;
+        if code < MAX_ONE_B {
+            dst[0] = code as u8;
+            return 1;
+        } else if code < MAX_TWO_B {
+            dst[0] = (code >> 6u & 31u | TAG_TWO_B) as u8;
+            dst[1] = (code & 63u | TAG_CONT) as u8;
+            return 2;
+        } else if code < MAX_THREE_B {
+            dst[0] = (code >> 12u & 15u | TAG_THREE_B) as u8;
+            dst[1] = (code >> 6u & 63u | TAG_CONT) as u8;
+            dst[2] = (code & 63u | TAG_CONT) as u8;
+            return 3;
+        } else {
+            dst[0] = (code >> 18u & 7u | TAG_FOUR_B) as u8;
+            dst[1] = (code >> 12u & 63u | TAG_CONT) as u8;
+            dst[2] = (code >> 6u & 63u | TAG_CONT) as u8;
+            dst[3] = (code & 63u | TAG_CONT) as u8;
+            return 4;
+        }
+    }
+}
+
+#[allow(missing_doc)]
+#[cfg(stage0)]
 pub trait Char {
     fn is_alphabetic(&self) -> bool;
     fn is_XID_start(&self) -> bool;
@@ -367,14 +421,10 @@ pub trait Char {
     fn escape_unicode(&self, f: |char|);
     fn escape_default(&self, f: |char|);
     fn len_utf8_bytes(&self) -> uint;
-
-    /// Encodes this character as utf-8 into the provided byte-buffer. The
-    /// buffer must be at least 4 bytes long or a runtime failure will occur.
-    ///
-    /// This will then return the number of characters written to the slice.
     fn encode_utf8(&self, dst: &mut [u8]) -> uint;
 }
 
+#[cfg(stage0)]
 impl Char for char {
     fn is_alphabetic(&self) -> bool { is_alphabetic(*self) }
 

src/libstd/fmt/mod.rs

@@ -471,7 +471,7 @@ will look like `"\\{"`.
 use prelude::*;
 
 use cast;
-use char::Char;
+#[cfg(stage0)] use char::Char;
 use io::MemWriter;
 use io;
 use str;

src/libstd/io/mod.rs

@@ -289,7 +289,7 @@ Out of scope
 #[allow(missing_doc)];
 
 use cast;
-use char::Char;
+#[cfg(stage0)] use char::Char;
 use condition::Guard;
 use container::Container;
 use int;

src/libstd/num/f32.rs

@@ -169,6 +169,13 @@ pub mod consts {
     pub static LN_10: f32 = 2.30258509299404568401799145468436421_f32;
 }
 
+#[cfg(not(stage0), not(test))]
+#[lang = "f32_impl"]
+/// The `f32` primitive is an 32-bit floating point type. This is generally
+/// equivalent to the C `float` type.
+impl f32 {
+}
+
 impl Num for f32 {}
 
 #[cfg(not(test))]

src/libstd/num/f64.rs

@@ -176,6 +176,13 @@ pub mod consts {
     pub static LN_10: f64 = 2.30258509299404568401799145468436421_f64;
 }
 
+#[cfg(not(stage0), not(test))]
+#[lang = "f64_impl"]
+/// The `f64` primitive is an 32-bit floating point type. This is generally
+/// equivalent to the C `double` type.
+impl f64 {
+}
+
 impl Num for f64 {}
 
 #[cfg(not(test))]

src/libstd/num/i16.rs

@@ -24,6 +24,12 @@ use unstable::intrinsics;
 
 int_module!(i16, 16)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "i16_impl"]
+/// The `i16` primitive is a signed 16-bit integer type.
+impl i16 {
+}
+
 impl Bitwise for i16 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]

src/libstd/num/i32.rs

@@ -24,6 +24,12 @@ use unstable::intrinsics;
 
 int_module!(i32, 32)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "i32_impl"]
+/// The `i32` primitive is a signed 32-bit integer type.
+impl i32 {
+}
+
 impl Bitwise for i32 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]

src/libstd/num/i64.rs

@@ -26,6 +26,12 @@ use unstable::intrinsics;
 
 int_module!(i64, 64)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "i64_impl"]
+/// The `i64` primitive is a signed 64-bit integer type.
+impl i64 {
+}
+
 impl Bitwise for i64 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]

src/libstd/num/i8.rs

@@ -24,6 +24,12 @@ use unstable::intrinsics;
 
 int_module!(i8, 8)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "i8_impl"]
+/// The `i8` primitive is a signed 8-bit integer type.
+impl i8 {
+}
+
 impl Bitwise for i8 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]

src/libstd/num/int.rs

@@ -25,6 +25,15 @@ use unstable::intrinsics;
 #[cfg(target_word_size = "32")] int_module!(int, 32)
 #[cfg(target_word_size = "64")] int_module!(int, 64)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "int_impl"]
+/// The `int` primitive type is an architecture-sized signed integer.
+///
+/// The size of a `int` is equivalent to the size of a `pointer` on the
+/// particular architecture in question.
+impl int {
+}
+
 #[cfg(target_word_size = "32")]
 impl Bitwise for int {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.

src/libstd/num/mod.rs

@@ -147,6 +147,7 @@ pub trait Unsigned: Num {}
 /// ten.times(|| { accum += 1; })
 /// ```
 ///
+#[cfg(stage0)]
 pub trait Times {
     fn times(&self, it: ||);
 }

src/libstd/num/u16.rs

@@ -25,6 +25,12 @@ use unstable::intrinsics;
 
 uint_module!(u16, i16, 16)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "u16_impl"]
+/// The `u16` primitive is an unsigned 8-bit integer type.
+impl u16 {
+}
+
 impl CheckedAdd for u16 {
     #[inline]
     fn checked_add(&self, v: &u16) -> Option<u16> {

src/libstd/num/u32.rs

@@ -25,6 +25,12 @@ use unstable::intrinsics;
 
 uint_module!(u32, i32, 32)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "u32_impl"]
+/// The `u32` primitive is an unsigned 32-bit integer type.
+impl u32 {
+}
+
 impl CheckedAdd for u32 {
     #[inline]
     fn checked_add(&self, v: &u32) -> Option<u32> {

src/libstd/num/u64.rs

@@ -27,6 +27,12 @@ use unstable::intrinsics;
 
 uint_module!(u64, i64, 64)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "u64_impl"]
+/// The `u64` primitive is an unsigned 64-bit integer type.
+impl u64 {
+}
+
 impl CheckedAdd for u64 {
     #[inline]
     fn checked_add(&self, v: &u64) -> Option<u64> {

src/libstd/num/u8.rs

@@ -25,6 +25,12 @@ use unstable::intrinsics;
 
 uint_module!(u8, i8, 8)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "u8_impl"]
+/// The `u8` primitive is an unsigned 8-bit integer type.
+impl u8 {
+}
+
 impl CheckedAdd for u8 {
     #[inline]
     fn checked_add(&self, v: &u8) -> Option<u8> {

src/libstd/num/uint.rs

@@ -20,13 +20,40 @@ use num::{Bitwise, Bounded};
 use num::{CheckedAdd, CheckedSub, CheckedMul};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
-use num;
+#[cfg(stage0)] use num;
 use option::{Option, Some, None};
 use str;
 use unstable::intrinsics;
 
 uint_module!(uint, int, ::int::bits)
 
+#[cfg(not(stage0), not(test))]
+#[lang = "uint_impl"]
+/// The `uint` primitive type is an architecture-sized unsigned integer.
+///
+/// The size of a `uint` is equivalent to the size of a `pointer` on the
+/// particular architecture in question.
+impl uint {
+    ///
+    /// A convenience form for basic repetition. Given a uint `x`,
+    /// `x.times(|| { ... })` executes the given block x times.
+    ///
+    /// Equivalent to `for uint::range(0, x) |_| { ... }`.
+    ///
+    /// Not defined on all integer types to permit unambiguous
+    /// use with integer literals of inferred integer-type as
+    /// the self-value (eg. `100.times(|| { ... })`).
+    ///
+    #[inline]
+    pub fn times(&self, it: ||) {
+        let mut i = *self;
+        while i > 0 {
+            it();
+            i -= 1;
+        }
+    }
+}
+
 ///
 /// Divide two numbers, return the result, rounded up.
 ///
@@ -80,8 +107,8 @@ pub fn div_round(x: uint, y: uint) -> uint {
 ///
 pub fn div_floor(x: uint, y: uint) -> uint { return x / y; }
 
+#[cfg(stage0)]
 impl num::Times for uint {
-    #[inline]
     ///
     /// A convenience form for basic repetition. Given a uint `x`,
     /// `x.times(|| { ... })` executes the given block x times.
@@ -92,6 +119,7 @@ impl num::Times for uint {
     /// use with integer literals of inferred integer-type as
     /// the self-value (eg. `100.times(|| { ... })`).
     ///
+    #[inline]
     fn times(&self, it: ||) {
         let mut i = *self;
         while i > 0 {