diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 8403c621608..b656879e7a4 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -64,6 +64,7 @@ pub use is_XID_continue = unicode::derived_property::XID_Continue;
* Indicates whether a character is in lower case, defined
* in terms of the Unicode General Category 'Ll'
*/
+#[inline(always)]
pub pure fn is_lowercase(c: char) -> bool {
return unicode::general_category::Ll(c);
}
@@ -72,6 +73,7 @@ pub pure fn is_lowercase(c: char) -> bool {
* Indicates whether a character is in upper case, defined
* in terms of the Unicode General Category 'Lu'.
*/
+#[inline(always)]
pub pure fn is_uppercase(c: char) -> bool {
return unicode::general_category::Lu(c);
}
@@ -81,6 +83,7 @@ pub pure fn is_uppercase(c: char) -> bool {
* terms of the Unicode General Categories 'Zs', 'Zl', 'Zp'
* additional 'Cc'-category control codes in the range [0x09, 0x0d]
*/
+#[inline(always)]
pub pure fn is_whitespace(c: char) -> bool {
return ('\x09' <= c && c <= '\x0d')
|| unicode::general_category::Zs(c)
@@ -93,6 +96,7 @@ pub pure fn is_whitespace(c: char) -> bool {
* defined in terms of the Unicode General Categories 'Nd', 'Nl', 'No'
* and the Derived Core Property 'Alphabetic'.
*/
+#[inline(always)]
pub pure fn is_alphanumeric(c: char) -> bool {
return unicode::derived_property::Alphabetic(c) ||
unicode::general_category::Nd(c) ||
@@ -101,11 +105,13 @@ pub pure fn is_alphanumeric(c: char) -> bool {
}
/// Indicates whether the character is an ASCII character
+#[inline(always)]
pub pure fn is_ascii(c: char) -> bool {
c - ('\x7F' & c) == '\x00'
}
/// Indicates whether the character is numeric (Nd, Nl, or No)
+#[inline(always)]
pub pure fn is_digit(c: char) -> bool {
return unicode::general_category::Nd(c) ||
unicode::general_category::Nl(c) ||
@@ -122,6 +128,7 @@ pub pure fn is_digit(c: char) -> bool {
* 'b' or 'B', 11, etc. Returns none if the char does not
* refer to a digit in the given radix.
*/
+#[inline]
pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
let val = match c {
'0' .. '9' => c as uint - ('0' as uint),
@@ -190,6 +197,7 @@ pub pure fn escape_default(c: char) -> ~str {
*
* -1 if a < b, 0 if a == b, +1 if a > b
*/
+#[inline(always)]
pub pure fn cmp(a: char, b: char) -> int {
return if b > a { -1 }
else if b < a { 1 }
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index a0569348b2e..6fbcf2df454 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -16,5 +16,6 @@ pub trait Clone {
}
impl (): Clone {
+ #[inline(always)]
fn clone(&self) -> () { () }
}
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 0f9e12058ba..141b6f19ab4 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -53,26 +53,32 @@ pub trait Ord {
pure fn gt(&self, other: &self) -> bool;
}
+#[inline(always)]
pub pure fn lt<T: Ord>(v1: &T, v2: &T) -> bool {
(*v1).lt(v2)
}
+#[inline(always)]
pub pure fn le<T: Ord Eq>(v1: &T, v2: &T) -> bool {
(*v1).lt(v2) || (*v1).eq(v2)
}
+#[inline(always)]
pub pure fn eq<T: Eq>(v1: &T, v2: &T) -> bool {
(*v1).eq(v2)
}
+#[inline(always)]
pub pure fn ne<T: Eq>(v1: &T, v2: &T) -> bool {
(*v1).ne(v2)
}
+#[inline(always)]
pub pure fn ge<T: Ord>(v1: &T, v2: &T) -> bool {
(*v1).ge(v2)
}
+#[inline(always)]
pub pure fn gt<T: Ord>(v1: &T, v2: &T) -> bool {
(*v1).gt(v2)
}
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index 4902edcedb1..c4f07db6621 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -28,6 +28,7 @@ pub enum Either<T, U> {
Right(U)
}
+#[inline(always)]
pub fn either<T, U, V>(f_left: fn(&T) -> V,
f_right: fn(&U) -> V, value: &Either<T, U>) -> V {
/*!
@@ -90,6 +91,7 @@ pub fn partition<T, U>(eithers: ~[Either<T, U>])
return (move lefts, move rights);
}
+#[inline(always)]
pub pure fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
//! Flips between left and right of a given either
@@ -99,6 +101,7 @@ pub pure fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
}
}
+#[inline(always)]
pub pure fn to_result<T, U>(eith: Either<T, U>)
-> Result<U, T> {
/*!
@@ -114,18 +117,21 @@ pub pure fn to_result<T, U>(eith: Either<T, U>)
}
}
+#[inline(always)]
pub pure fn is_left<T, U>(eith: &Either<T, U>) -> bool {
//! Checks whether the given value is a left
match *eith { Left(_) => true, _ => false }
}
+#[inline(always)]
pub pure fn is_right<T, U>(eith: &Either<T, U>) -> bool {
//! Checks whether the given value is a right
match *eith { Right(_) => true, _ => false }
}
+#[inline(always)]
pub pure fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
//! Retrieves the value in the left branch. Fails if the either is Right.
@@ -134,6 +140,7 @@ pub pure fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
}
}
+#[inline(always)]
pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
//! Retrieves the value in the right branch. Fails if the either is Left.
diff --git a/src/libcore/f32.rs b/src/libcore/f32.rs
index 734cfc11080..4c1cc890de9 100644
--- a/src/libcore/f32.rs
+++ b/src/libcore/f32.rs
@@ -105,38 +105,52 @@ pub const infinity: f32 = 1.0_f32/0.0_f32;
pub const neg_infinity: f32 = -1.0_f32/0.0_f32;
+#[inline(always)]
pub pure fn is_NaN(f: f32) -> bool { f != f }
+#[inline(always)]
pub pure fn add(x: f32, y: f32) -> f32 { return x + y; }
+#[inline(always)]
pub pure fn sub(x: f32, y: f32) -> f32 { return x - y; }
+#[inline(always)]
pub pure fn mul(x: f32, y: f32) -> f32 { return x * y; }
+#[inline(always)]
pub pure fn div(x: f32, y: f32) -> f32 { return x / y; }
+#[inline(always)]
pub pure fn rem(x: f32, y: f32) -> f32 { return x % y; }
+#[inline(always)]
pub pure fn lt(x: f32, y: f32) -> bool { return x < y; }
+#[inline(always)]
pub pure fn le(x: f32, y: f32) -> bool { return x <= y; }
+#[inline(always)]
pub pure fn eq(x: f32, y: f32) -> bool { return x == y; }
+#[inline(always)]
pub pure fn ne(x: f32, y: f32) -> bool { return x != y; }
+#[inline(always)]
pub pure fn ge(x: f32, y: f32) -> bool { return x >= y; }
+#[inline(always)]
pub pure fn gt(x: f32, y: f32) -> bool { return x > y; }
// FIXME (#1999): replace the predicates below with llvm intrinsics or
// calls to the libmath macros in the rust runtime for performance.
/// Returns true if `x` is a positive number, including +0.0f320 and +Infinity
+#[inline(always)]
pub pure fn is_positive(x: f32) -> bool
{ return x > 0.0f32 || (1.0f32/x) == infinity; }
/// Returns true if `x` is a negative number, including -0.0f320 and -Infinity
+#[inline(always)]
pub pure fn is_negative(x: f32) -> bool
{ return x < 0.0f32 || (1.0f32/x) == neg_infinity; }
@@ -145,6 +159,7 @@ pub pure fn is_negative(x: f32) -> bool
*
* This is the same as `f32::is_negative`.
*/
+#[inline(always)]
pub pure fn is_nonpositive(x: f32) -> bool {
return x < 0.0f32 || (1.0f32/x) == neg_infinity;
}
@@ -154,21 +169,25 @@ pub pure fn is_nonpositive(x: f32) -> bool {
*
* This is the same as `f32::is_positive`.)
*/
+#[inline(always)]
pub pure fn is_nonnegative(x: f32) -> bool {
return x > 0.0f32 || (1.0f32/x) == infinity;
}
/// Returns true if `x` is a zero number (positive or negative zero)
+#[inline(always)]
pub pure fn is_zero(x: f32) -> bool {
return x == 0.0f32 || x == -0.0f32;
}
/// Returns true if `x`is an infinite number
+#[inline(always)]
pub pure fn is_infinite(x: f32) -> bool {
return x == infinity || x == neg_infinity;
}
/// Returns true if `x`is a finite number
+#[inline(always)]
pub pure fn is_finite(x: f32) -> bool {
return !(is_NaN(x) || is_infinite(x));
}
@@ -219,45 +238,63 @@ pub mod consts {
pub const ln_10: f32 = 2.30258509299404568401799145468436421_f32;
}
+#[inline(always)]
pub pure fn signbit(x: f32) -> int {
if is_negative(x) { return 1; } else { return 0; }
}
+#[inline(always)]
pub pure fn logarithm(n: f32, b: f32) -> f32 {
return log2(n) / log2(b);
}
#[cfg(notest)]
impl f32 : cmp::Eq {
+ #[inline(always)]
pure fn eq(&self, other: &f32) -> bool { (*self) == (*other) }
+ #[inline(always)]
pure fn ne(&self, other: &f32) -> bool { (*self) != (*other) }
}
#[cfg(notest)]
impl f32 : cmp::Ord {
+ #[inline(always)]
pure fn lt(&self, other: &f32) -> bool { (*self) < (*other) }
+ #[inline(always)]
pure fn le(&self, other: &f32) -> bool { (*self) <= (*other) }
+ #[inline(always)]
pure fn ge(&self, other: &f32) -> bool { (*self) >= (*other) }
+ #[inline(always)]
pure fn gt(&self, other: &f32) -> bool { (*self) > (*other) }
}
impl f32: num::Num {
+ #[inline(always)]
pure fn add(&self, other: &f32) -> f32 { return *self + *other; }
+ #[inline(always)]
pure fn sub(&self, other: &f32) -> f32 { return *self - *other; }
+ #[inline(always)]
pure fn mul(&self, other: &f32) -> f32 { return *self * *other; }
+ #[inline(always)]
pure fn div(&self, other: &f32) -> f32 { return *self / *other; }
+ #[inline(always)]
pure fn modulo(&self, other: &f32) -> f32 { return *self % *other; }
+ #[inline(always)]
pure fn neg(&self) -> f32 { return -*self; }
+ #[inline(always)]
pure fn to_int(&self) -> int { return *self as int; }
+ #[inline(always)]
static pure fn from_int(n: int) -> f32 { return n as f32; }
}
impl f32: num::Zero {
+ #[inline(always)]
static pure fn zero() -> f32 { 0.0 }
}
impl f32: num::One {
+ #[inline(always)]
static pure fn one() -> f32 { 1.0 }
}
diff --git a/src/libcore/f64.rs b/src/libcore/f64.rs
index e0c47b509f1..cbcdc2e81e6 100644
--- a/src/libcore/f64.rs
+++ b/src/libcore/f64.rs
@@ -132,35 +132,49 @@ pub const infinity: f64 = 1.0_f64/0.0_f64;
pub const neg_infinity: f64 = -1.0_f64/0.0_f64;
+#[inline(always)]
pub pure fn is_NaN(f: f64) -> bool { f != f }
+#[inline(always)]
pub pure fn add(x: f64, y: f64) -> f64 { return x + y; }
+#[inline(always)]
pub pure fn sub(x: f64, y: f64) -> f64 { return x - y; }
+#[inline(always)]
pub pure fn mul(x: f64, y: f64) -> f64 { return x * y; }
+#[inline(always)]
pub pure fn div(x: f64, y: f64) -> f64 { return x / y; }
+#[inline(always)]
pub pure fn rem(x: f64, y: f64) -> f64 { return x % y; }
+#[inline(always)]
pub pure fn lt(x: f64, y: f64) -> bool { return x < y; }
+#[inline(always)]
pub pure fn le(x: f64, y: f64) -> bool { return x <= y; }
+#[inline(always)]
pub pure fn eq(x: f64, y: f64) -> bool { return x == y; }
+#[inline(always)]
pub pure fn ne(x: f64, y: f64) -> bool { return x != y; }
+#[inline(always)]
pub pure fn ge(x: f64, y: f64) -> bool { return x >= y; }
+#[inline(always)]
pub pure fn gt(x: f64, y: f64) -> bool { return x > y; }
/// Returns true if `x` is a positive number, including +0.0f640 and +Infinity
+#[inline(always)]
pub pure fn is_positive(x: f64) -> bool
{ return x > 0.0f64 || (1.0f64/x) == infinity; }
/// Returns true if `x` is a negative number, including -0.0f640 and -Infinity
+#[inline(always)]
pub pure fn is_negative(x: f64) -> bool
{ return x < 0.0f64 || (1.0f64/x) == neg_infinity; }
@@ -169,6 +183,7 @@ pub pure fn is_negative(x: f64) -> bool
*
* This is the same as `f64::is_negative`.
*/
+#[inline(always)]
pub pure fn is_nonpositive(x: f64) -> bool {
return x < 0.0f64 || (1.0f64/x) == neg_infinity;
}
@@ -178,21 +193,25 @@ pub pure fn is_nonpositive(x: f64) -> bool {
*
* This is the same as `f64::positive`.
*/
+#[inline(always)]
pub pure fn is_nonnegative(x: f64) -> bool {
return x > 0.0f64 || (1.0f64/x) == infinity;
}
/// Returns true if `x` is a zero number (positive or negative zero)
+#[inline(always)]
pub pure fn is_zero(x: f64) -> bool {
return x == 0.0f64 || x == -0.0f64;
}
/// Returns true if `x`is an infinite number
+#[inline(always)]
pub pure fn is_infinite(x: f64) -> bool {
return x == infinity || x == neg_infinity;
}
/// Returns true if `x`is a finite number
+#[inline(always)]
pub pure fn is_finite(x: f64) -> bool {
return !(is_NaN(x) || is_infinite(x));
}
@@ -243,45 +262,63 @@ pub mod consts {
pub const ln_10: f64 = 2.30258509299404568401799145468436421_f64;
}
+#[inline(always)]
pub pure fn signbit(x: f64) -> int {
if is_negative(x) { return 1; } else { return 0; }
}
+#[inline(always)]
pub pure fn logarithm(n: f64, b: f64) -> f64 {
return log2(n) / log2(b);
}
#[cfg(notest)]
impl f64 : cmp::Eq {
+ #[inline(always)]
pure fn eq(&self, other: &f64) -> bool { (*self) == (*other) }
+ #[inline(always)]
pure fn ne(&self, other: &f64) -> bool { (*self) != (*other) }
}
#[cfg(notest)]
impl f64 : cmp::Ord {
+ #[inline(always)]
pure fn lt(&self, other: &f64) -> bool { (*self) < (*other) }
+ #[inline(always)]
pure fn le(&self, other: &f64) -> bool { (*self) <= (*other) }
+ #[inline(always)]
pure fn ge(&self, other: &f64) -> bool { (*self) >= (*other) }
+ #[inline(always)]
pure fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
}
impl f64: num::Num {
+ #[inline(always)]
pure fn add(&self, other: &f64) -> f64 { return *self + *other; }
+ #[inline(always)]
pure fn sub(&self, other: &f64) -> f64 { return *self - *other; }
+ #[inline(always)]
pure fn mul(&self, other: &f64) -> f64 { return *self * *other; }
+ #[inline(always)]
pure fn div(&self, other: &f64) -> f64 { return *self / *other; }
+ #[inline(always)]
pure fn modulo(&self, other: &f64) -> f64 { return *self % *other; }
+ #[inline(always)]
pure fn neg(&self) -> f64 { return -*self; }
+ #[inline(always)]
pure fn to_int(&self) -> int { return *self as int; }
+ #[inline(always)]
static pure fn from_int(n: int) -> f64 { return n as f64; }
}
impl f64: num::Zero {
+ #[inline(always)]
static pure fn zero() -> f64 { 0.0 }
}
impl f64: num::One {
+ #[inline(always)]
static pure fn one() -> f64 { 1.0 }
}
diff --git a/src/libcore/float.rs b/src/libcore/float.rs
index 92efe9c4981..4c79069ad09 100644
--- a/src/libcore/float.rs
+++ b/src/libcore/float.rs
@@ -195,6 +195,7 @@ pub pure fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
* * num - The float value
* * digits - The number of significant digits
*/
+#[inline(always)]
pub pure fn to_str_exact(num: float, digits: uint) -> ~str {
to_str_common(num, digits, true)
}
@@ -215,6 +216,7 @@ pub fn test_to_str_exact_do_decimal() {
* * num - The float value
* * digits - The number of significant digits
*/
+#[inline(always)]
pub pure fn to_str(num: float, digits: uint) -> ~str {
to_str_common(num, digits, false)
}
@@ -400,30 +402,44 @@ pub pure fn pow_with_uint(base: uint, pow: uint) -> float {
return total;
}
+#[inline(always)]
pub pure fn is_positive(x: float) -> bool { f64::is_positive(x as f64) }
+#[inline(always)]
pub pure fn is_negative(x: float) -> bool { f64::is_negative(x as f64) }
+#[inline(always)]
pub pure fn is_nonpositive(x: float) -> bool { f64::is_nonpositive(x as f64) }
+#[inline(always)]
pub pure fn is_nonnegative(x: float) -> bool { f64::is_nonnegative(x as f64) }
+#[inline(always)]
pub pure fn is_zero(x: float) -> bool { f64::is_zero(x as f64) }
+#[inline(always)]
pub pure fn is_infinite(x: float) -> bool { f64::is_infinite(x as f64) }
+#[inline(always)]
pub pure fn is_finite(x: float) -> bool { f64::is_finite(x as f64) }
+#[inline(always)]
pub pure fn is_NaN(x: float) -> bool { f64::is_NaN(x as f64) }
+#[inline(always)]
pub pure fn abs(x: float) -> float {
unsafe { f64::abs(x as f64) as float }
}
+#[inline(always)]
pub pure fn sqrt(x: float) -> float {
unsafe { f64::sqrt(x as f64) as float }
}
+#[inline(always)]
pub pure fn atan(x: float) -> float {
unsafe { f64::atan(x as f64) as float }
}
+#[inline(always)]
pub pure fn sin(x: float) -> float {
unsafe { f64::sin(x as f64) as float }
}
+#[inline(always)]
pub pure fn cos(x: float) -> float {
unsafe { f64::cos(x as f64) as float }
}
+#[inline(always)]
pub pure fn tan(x: float) -> float {
unsafe { f64::tan(x as f64) as float }
}
@@ -463,10 +479,12 @@ impl float: num::Num {
}
impl float: num::Zero {
+ #[inline(always)]
static pure fn zero() -> float { 0.0 }
}
impl float: num::One {
+ #[inline(always)]
static pure fn one() -> float { 1.0 }
}
diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs
index 4946a0997c1..a04610d1995 100644
--- a/src/libcore/int-template.rs
+++ b/src/libcore/int-template.rs
@@ -32,25 +32,42 @@ pub const bytes : uint = (inst::bits / 8);
pub const min_value: T = (-1 as T) << (bits - 1);
pub const max_value: T = min_value - 1 as T;
+#[inline(always)]
pub pure fn min(x: T, y: T) -> T { if x < y { x } else { y } }
+#[inline(always)]
pub pure fn max(x: T, y: T) -> T { if x > y { x } else { y } }
+#[inline(always)]
pub pure fn add(x: T, y: T) -> T { x + y }
+#[inline(always)]
pub pure fn sub(x: T, y: T) -> T { x - y }
+#[inline(always)]
pub pure fn mul(x: T, y: T) -> T { x * y }
+#[inline(always)]
pub pure fn div(x: T, y: T) -> T { x / y }
+#[inline(always)]
pub pure fn rem(x: T, y: T) -> T { x % y }
+#[inline(always)]
pub pure fn lt(x: T, y: T) -> bool { x < y }
+#[inline(always)]
pub pure fn le(x: T, y: T) -> bool { x <= y }
+#[inline(always)]
pub pure fn eq(x: T, y: T) -> bool { x == y }
+#[inline(always)]
pub pure fn ne(x: T, y: T) -> bool { x != y }
+#[inline(always)]
pub pure fn ge(x: T, y: T) -> bool { x >= y }
+#[inline(always)]
pub pure fn gt(x: T, y: T) -> bool { x > y }
+#[inline(always)]
pub pure fn is_positive(x: T) -> bool { x > 0 as T }
+#[inline(always)]
pub pure fn is_negative(x: T) -> bool { x < 0 as T }
+#[inline(always)]
pub pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
+#[inline(always)]
pub pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
#[inline(always)]
@@ -64,46 +81,64 @@ pub fn range(lo: T, hi: T, it: fn(T) -> bool) {
}
/// Computes the bitwise complement
+#[inline(always)]
pub pure fn compl(i: T) -> T {
-1 as T ^ i
}
/// Computes the absolute value
+#[inline(always)]
pub pure fn abs(i: T) -> T {
if is_negative(i) { -i } else { i }
}
#[cfg(notest)]
impl T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); }
+ #[inline(always)]
pure fn le(&self, other: &T) -> bool { return (*self) <= (*other); }
+ #[inline(always)]
pure fn ge(&self, other: &T) -> bool { return (*self) >= (*other); }
+ #[inline(always)]
pure fn gt(&self, other: &T) -> bool { return (*self) > (*other); }
}
#[cfg(notest)]
impl T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
+ #[inline(always)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}
impl T: num::Num {
+ #[inline(always)]
pure fn add(&self, other: &T) -> T { return *self + *other; }
+ #[inline(always)]
pure fn sub(&self, other: &T) -> T { return *self - *other; }
+ #[inline(always)]
pure fn mul(&self, other: &T) -> T { return *self * *other; }
+ #[inline(always)]
pure fn div(&self, other: &T) -> T { return *self / *other; }
+ #[inline(always)]
pure fn modulo(&self, other: &T) -> T { return *self % *other; }
+ #[inline(always)]
pure fn neg(&self) -> T { return -*self; }
+ #[inline(always)]
pure fn to_int(&self) -> int { return *self as int; }
+ #[inline(always)]
static pure fn from_int(n: int) -> T { return n as T; }
}
impl T: num::Zero {
+ #[inline(always)]
static pure fn zero() -> T { 0 }
}
impl T: num::One {
+ #[inline(always)]
static pure fn one() -> T { 1 }
}
@@ -158,16 +193,19 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
}
/// Parse a string to an int
+#[inline(always)]
pub pure fn from_str(s: &str) -> Option<T>
{
parse_bytes(str::to_bytes(s), 10u)
}
impl T : FromStr {
+ #[inline(always)]
static pure fn from_str(s: &str) -> Option<T> { from_str(s) }
}
/// Convert to a string in a given base
+#[inline(always)]
pub pure fn to_str(n: T, radix: uint) -> ~str {
do to_str_bytes(n, radix) |slice| {
do vec::as_imm_buf(slice) |p, len| {
@@ -176,6 +214,7 @@ pub pure fn to_str(n: T, radix: uint) -> ~str {
}
}
+#[inline(always)]
pub pure fn to_str_bytes<U>(n: T, radix: uint, f: fn(v: &[u8]) -> U) -> U {
if n < 0 as T {
uint::to_str_bytes(true, -n as uint, radix, f)
@@ -185,6 +224,7 @@ pub pure fn to_str_bytes<U>(n: T, radix: uint, f: fn(v: &[u8]) -> U) -> U {
}
/// Convert to a string
+#[inline(always)]
pub pure fn str(i: T) -> ~str { return to_str(i, 10u); }
#[test]
diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index a139daddcef..942db1c5f29 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -24,29 +24,38 @@ use option::Option;
use self::inst::{IMPL_T, EACH, SIZE_HINT};
impl<A> IMPL_T<A>: iter::BaseIter<A> {
+ #[inline(always)]
pure fn each(&self, blk: fn(v: &A) -> bool) { EACH(self, blk) }
+ #[inline(always)]
pure fn size_hint(&self) -> Option<uint> { SIZE_HINT(self) }
}
impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
+ #[inline(always)]
pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
iter::eachi(self, blk)
}
+ #[inline(always)]
pure fn all(&self, blk: fn(&A) -> bool) -> bool {
iter::all(self, blk)
}
+ #[inline(always)]
pure fn any(&self, blk: fn(&A) -> bool) -> bool {
iter::any(self, blk)
}
+ #[inline(always)]
pure fn foldl<B>(&self, b0: B, blk: fn(&B, &A) -> B) -> B {
iter::foldl(self, move b0, blk)
}
+ #[inline(always)]
pure fn position(&self, f: fn(&A) -> bool) -> Option<uint> {
iter::position(self, f)
}
+ #[inline(always)]
pure fn map_to_vec<B>(&self, op: fn(&A) -> B) -> ~[B] {
iter::map_to_vec(self, op)
}
+ #[inline(always)]
pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: fn(&A) -> IB)
-> ~[B] {
iter::flat_map_to_vec(self, op)
@@ -55,22 +64,29 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
}
impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
+ #[inline(always)]
pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
+ #[inline(always)]
pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
}
impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
+ #[inline(always)]
pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
iter::filter_to_vec(self, pred)
}
+ #[inline(always)]
pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) }
+ #[inline(always)]
pure fn find(&self, f: fn(&A) -> bool) -> Option<A> {
iter::find(self, f)
}
}
impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {
+ #[inline(always)]
pure fn min(&self) -> A { iter::min(self) }
+ #[inline(always)]
pure fn max(&self) -> A { iter::max(self) }
}
diff --git a/src/libcore/iter-trait/dlist.rs b/src/libcore/iter-trait/dlist.rs
index eb395c57ae8..754b8f8b72f 100644
--- a/src/libcore/iter-trait/dlist.rs
+++ b/src/libcore/iter-trait/dlist.rs
@@ -47,6 +47,7 @@ mod inst {
}
}
+ #[inline(always)]
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len())
}
diff --git a/src/libcore/iter-trait/dvec.rs b/src/libcore/iter-trait/dvec.rs
index 28d1cf03d46..af788989e9c 100644
--- a/src/libcore/iter-trait/dvec.rs
+++ b/src/libcore/iter-trait/dvec.rs
@@ -20,6 +20,7 @@ mod inst {
*
* Attempts to access this dvec during iteration will fail.
*/
+ #[inline(always)]
pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
unsafe {
do self.swap |v| {
@@ -29,6 +30,7 @@ mod inst {
}
}
+ #[inline(always)]
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len())
}
diff --git a/src/libcore/iter-trait/option.rs b/src/libcore/iter-trait/option.rs
index 2240db82f29..986dbf7f3d1 100644
--- a/src/libcore/iter-trait/option.rs
+++ b/src/libcore/iter-trait/option.rs
@@ -14,6 +14,7 @@ mod inst {
#[allow(non_camel_case_types)]
pub type IMPL_T<A> = Option<A>;
+ #[inline(always)]
pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
match *self {
None => (),
@@ -21,6 +22,7 @@ mod inst {
}
}
+ #[inline(always)]
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
match *self {
None => Some(0),
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 1e56b0f14af..4ea845543d1 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -88,6 +88,7 @@ pub trait Buildable<A> {
builder: fn(push: pure fn(A))) -> self;
}
+#[inline(always)]
pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA,
blk: fn(uint, &A) -> bool) {
let mut i = 0;
@@ -97,6 +98,7 @@ pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA,
}
}
+#[inline(always)]
pub pure fn all<A,IA:BaseIter<A>>(self: &IA,
blk: fn(&A) -> bool) -> bool {
for self.each |a| {
@@ -105,6 +107,7 @@ pub pure fn all<A,IA:BaseIter<A>>(self: &IA,
return true;
}
+#[inline(always)]
pub pure fn any<A,IA:BaseIter<A>>(self: &IA,
blk: fn(&A) -> bool) -> bool {
for self.each |a| {
@@ -113,6 +116,7 @@ pub pure fn any<A,IA:BaseIter<A>>(self: &IA,
return false;
}
+#[inline(always)]
pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
self: &IA, prd: fn(&A) -> bool) -> ~[A] {
do vec::build_sized_opt(self.size_hint()) |push| {
@@ -122,6 +126,7 @@ pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
}
}
+#[inline(always)]
pub pure fn map_to_vec<A,B,IA:BaseIter<A>>(self: &IA,
op: fn(&A) -> B)
-> ~[B] {
@@ -132,6 +137,7 @@ pub pure fn map_to_vec<A,B,IA:BaseIter<A>>(self: &IA,
}
}
+#[inline(always)]
pub pure fn flat_map_to_vec<A,B,IA:BaseIter<A>,IB:BaseIter<B>>(
self: &IA, op: fn(&A) -> IB) -> ~[B] {
do vec::build |push| {
@@ -143,6 +149,7 @@ pub pure fn flat_map_to_vec<A,B,IA:BaseIter<A>,IB:BaseIter<B>>(
}
}
+#[inline(always)]
pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B,
blk: fn(&B, &A) -> B)
-> B {
@@ -153,10 +160,12 @@ pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B,
move b
}
+#[inline(always)]
pub pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] {
foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy (*r), ~[*a]))
}
+#[inline(always)]
pub pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool {
for self.each |a| {
if *a == *x { return true; }
@@ -164,6 +173,7 @@ pub pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool {
return false;
}
+#[inline(always)]
pub pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
do foldl(self, 0) |count, value| {
if *value == *x {
@@ -174,6 +184,7 @@ pub pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
}
}
+#[inline(always)]
pub pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
-> Option<uint>
{
@@ -189,6 +200,7 @@ pub pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
// iter interface, such as would provide "reach" in addition to "each". as is,
// it would have to be implemented with foldr, which is too inefficient.
+#[inline(always)]
pub pure fn repeat(times: uint, blk: fn() -> bool) {
let mut i = 0;
while i < times {
@@ -197,6 +209,7 @@ pub pure fn repeat(times: uint, blk: fn() -> bool) {
}
}
+#[inline(always)]
pub pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
match a {
@@ -211,6 +224,7 @@ pub pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
}
}
+#[inline(always)]
pub pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
match a {
@@ -225,6 +239,7 @@ pub pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
}
}
+#[inline(always)]
pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
f: fn(&A) -> bool) -> Option<A> {
for self.each |i| {
@@ -275,6 +290,7 @@ pub pure fn build_sized_opt<A,B: Buildable<A>>(
// Functions that combine iteration and building
/// Apply a function to each element of an iterable and return the results
+#[inline(always)]
pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U)
-> BU {
do build_sized_opt(v.size_hint()) |push| {
@@ -290,6 +306,7 @@ pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U)
* Creates a generic sequence of size `n_elts` and initializes the elements
* to the value returned by the function `op`.
*/
+#[inline(always)]
pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
op: InitOp<T>) -> BT {
do Buildable::build_sized(n_elts) |push| {
@@ -304,6 +321,7 @@ pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
* Creates an immutable vector of size `n_elts` and initializes the elements
* to the value `t`.
*/
+#[inline(always)]
pub pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint,
t: T) -> BT {
do Buildable::build_sized(n_elts) |push| {
diff --git a/src/libcore/managed.rs b/src/libcore/managed.rs
index b334d246743..8395526276c 100644
--- a/src/libcore/managed.rs
+++ b/src/libcore/managed.rs
@@ -35,6 +35,7 @@ pub mod raw {
}
+#[inline(always)]
pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
//! Determine if two shared boxes point to the same object
unsafe { ptr::addr_of(&(*a)) == ptr::addr_of(&(*b)) }
@@ -42,15 +43,21 @@ pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
#[cfg(notest)]
impl<T:Eq> @const T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
+ #[inline(always)]
pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
}
#[cfg(notest)]
impl<T:Ord> @const T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
+ #[inline(always)]
pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
+ #[inline(always)]
pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
+ #[inline(always)]
pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
}
diff --git a/src/libcore/nil.rs b/src/libcore/nil.rs
index 5e306d4b57d..f3eb62a3a3a 100644
--- a/src/libcore/nil.rs
+++ b/src/libcore/nil.rs
@@ -22,15 +22,21 @@ use cmp::{Eq, Ord};
#[cfg(notest)]
impl () : Eq {
+ #[inline(always)]
pure fn eq(&self, _other: &()) -> bool { true }
+ #[inline(always)]
pure fn ne(&self, _other: &()) -> bool { false }
}
#[cfg(notest)]
impl () : Ord {
+ #[inline(always)]
pure fn lt(&self, _other: &()) -> bool { false }
+ #[inline(always)]
pure fn le(&self, _other: &()) -> bool { true }
+ #[inline(always)]
pure fn ge(&self, _other: &()) -> bool { true }
+ #[inline(always)]
pure fn gt(&self, _other: &()) -> bool { false }
}
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 49ba10dfffb..414027bb77e 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -59,6 +59,7 @@ pub enum Option<T> {
Some(T),
}
+#[inline(always)]
pub pure fn get<T: Copy>(opt: Option<T>) -> T {
/*!
Gets the value out of an option
@@ -81,6 +82,7 @@ pub pure fn get<T: Copy>(opt: Option<T>) -> T {
}
}
+#[inline(always)]
pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
/*!
Gets an immutable reference to the value inside an option.
@@ -102,12 +104,14 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
}
}
+#[inline(always)]
pub pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
//! Maps a `some` value by reference from one type to another
match *opt { Some(ref x) => Some(f(x)), None => None }
}
+#[inline(always)]
pub pure fn map_consume<T, U>(opt: Option<T>,
f: fn(v: T) -> U) -> Option<U> {
/*!
@@ -117,6 +121,7 @@ pub pure fn map_consume<T, U>(opt: Option<T>,
if opt.is_some() { Some(f(option::unwrap(move opt))) } else { None }
}
+#[inline(always)]
pub pure fn chain<T, U>(opt: Option<T>,
f: fn(t: T) -> Option<U>) -> Option<U> {
/*!
@@ -130,6 +135,7 @@ pub pure fn chain<T, U>(opt: Option<T>,
}
}
+#[inline(always)]
pub pure fn chain_ref<T, U>(opt: &Option<T>,
f: fn(x: &T) -> Option<U>) -> Option<U> {
/*!
@@ -140,6 +146,7 @@ pub pure fn chain_ref<T, U>(opt: &Option<T>,
match *opt { Some(ref x) => f(x), None => None }
}
+#[inline(always)]
pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
/*!
* Returns the leftmost some() value, or none if both are none.
@@ -160,30 +167,35 @@ pub pure fn while_some<T>(x: Option<T>, blk: fn(v: T) -> Option<T>) {
}
}
+#[inline(always)]
pub pure fn is_none<T>(opt: &Option<T>) -> bool {
//! Returns true if the option equals `none`
match *opt { None => true, Some(_) => false }
}
+#[inline(always)]
pub pure fn is_some<T>(opt: &Option<T>) -> bool {
//! Returns true if the option contains some value
!is_none(opt)
}
+#[inline(always)]
pub pure fn get_or_zero<T: Copy Zero>(opt: Option<T>) -> T {
//! Returns the contained value or zero (for this type)
match opt { Some(copy x) => x, None => Zero::zero() }
}
+#[inline(always)]
pub pure fn get_or_default<T: Copy>(opt: Option<T>, def: T) -> T {
//! Returns the contained value or a default
match opt { Some(copy x) => x, None => def }
}
+#[inline(always)]
pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
f: fn(x: &T) -> U) -> U {
//! Applies a function to the contained value or returns a default
@@ -191,6 +203,7 @@ pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
match *opt { None => move def, Some(ref t) => f(t) }
}
+#[inline(always)]
pub pure fn iter<T>(opt: &Option<T>, f: fn(x: &T)) {
//! Performs an operation on the contained value by reference
match *opt { None => (), Some(ref t) => f(t) }
@@ -234,6 +247,7 @@ pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T {
unwrap(util::replace(opt, None))
}
+#[inline(always)]
pub pure fn expect<T>(opt: Option<T>, reason: &str) -> T {
//! As unwrap, but with a specified failure message.
match move opt {
diff --git a/src/libcore/owned.rs b/src/libcore/owned.rs
index 2f369e18fd1..fb14820113e 100644
--- a/src/libcore/owned.rs
+++ b/src/libcore/owned.rs
@@ -18,15 +18,21 @@ use cmp::{Eq, Ord};
#[cfg(notest)]
impl<T:Eq> ~const T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
+ #[inline(always)]
pure fn ne(&self, other: &~const T) -> bool { *(*self) != *(*other) }
}
#[cfg(notest)]
impl<T:Ord> ~const T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
+ #[inline(always)]
pure fn le(&self, other: &~const T) -> bool { *(*self) <= *(*other) }
+ #[inline(always)]
pure fn ge(&self, other: &~const T) -> bool { *(*self) >= *(*other) }
+ #[inline(always)]
pure fn gt(&self, other: &~const T) -> bool { *(*self) > *(*other) }
}
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index d8c3c74ba2e..33770d727f9 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -108,9 +108,11 @@ pub pure fn null<T>() -> *T { unsafe { cast::reinterpret_cast(&0u) } }
pub pure fn mut_null<T>() -> *mut T { unsafe { cast::reinterpret_cast(&0u) } }
/// Returns true if the pointer is equal to the null pointer.
+#[inline(always)]
pub pure fn is_null<T>(ptr: *const T) -> bool { ptr == null() }
/// Returns true if the pointer is not equal to the null pointer.
+#[inline(always)]
pub pure fn is_not_null<T>(ptr: *const T) -> bool { !is_null(ptr) }
/**
@@ -231,32 +233,38 @@ impl<T> *mut T: Ptr<T> {
// Equality for pointers
#[cfg(notest)]
impl<T> *const T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a == b;
}
+ #[inline(always)]
pure fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) }
}
// Comparison for pointers
#[cfg(notest)]
impl<T> *const T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a < b;
}
+ #[inline(always)]
pure fn le(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a <= b;
}
+ #[inline(always)]
pure fn ge(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a >= b;
}
+ #[inline(always)]
pure fn gt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
@@ -267,9 +275,11 @@ impl<T> *const T : Ord {
// Equality for region pointers
#[cfg(notest)]
impl<T:Eq> &const T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: & &self/const T) -> bool {
return *(*self) == *(*other);
}
+ #[inline(always)]
pure fn ne(&self, other: & &self/const T) -> bool {
return *(*self) != *(*other);
}
@@ -278,15 +288,19 @@ impl<T:Eq> &const T : Eq {
// Comparison for region pointers
#[cfg(notest)]
impl<T:Ord> &const T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: & &self/const T) -> bool {
*(*self) < *(*other)
}
+ #[inline(always)]
pure fn le(&self, other: & &self/const T) -> bool {
*(*self) <= *(*other)
}
+ #[inline(always)]
pure fn ge(&self, other: & &self/const T) -> bool {
*(*self) >= *(*other)
}
+ #[inline(always)]
pure fn gt(&self, other: & &self/const T) -> bool {
*(*self) > *(*other)
}
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 91f51908be8..9a09f1901ff 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -39,6 +39,7 @@ pub enum Result<T, U> {
*
* If the result is an error
*/
+#[inline(always)]
pub pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
match *res {
Ok(copy t) => t,
@@ -55,6 +56,7 @@ pub pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
*
* If the result is an error
*/
+#[inline(always)]
pub pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
match *res {
Ok(ref t) => t,
@@ -71,6 +73,7 @@ pub pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
*
* If the result is not an error
*/
+#[inline(always)]
pub pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
match *res {
Err(copy u) => u,
@@ -79,6 +82,7 @@ pub pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
}
/// Returns true if the result is `ok`
+#[inline(always)]
pub pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
match *res {
Ok(_) => true,
@@ -87,6 +91,7 @@ pub pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
}
/// Returns true if the result is `err`
+#[inline(always)]
pub pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
!is_ok(res)
}
@@ -97,6 +102,7 @@ pub pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
* `ok` result variants are converted to `either::right` variants, `err`
* result variants are converted to `either::left`.
*/
+#[inline(always)]
pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
-> Either<T, U> {
match *res {
@@ -119,6 +125,7 @@ pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
* ok(parse_bytes(buf))
* }
*/
+#[inline(always)]
pub pure fn chain<T, U, V>(res: Result<T, V>, op: fn(T)
-> Result<U, V>) -> Result<U, V> {
match move res {
@@ -135,6 +142,7 @@ pub pure fn chain<T, U, V>(res: Result<T, V>, op: fn(T)
* immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
+#[inline(always)]
pub pure fn chain_err<T, U, V>(
res: Result<T, V>,
op: fn(t: V) -> Result<T, U>)
@@ -159,6 +167,7 @@ pub pure fn chain_err<T, U, V>(
* print_buf(buf)
* }
*/
+#[inline(always)]
pub pure fn iter<T, E>(res: &Result<T, E>, f: fn(&T)) {
match *res {
Ok(ref t) => f(t),
@@ -174,6 +183,7 @@ pub pure fn iter<T, E>(res: &Result<T, E>, f: fn(&T)) {
* This function can be used to pass through a successful result while
* handling an error.
*/
+#[inline(always)]
pub pure fn iter_err<T, E>(res: &Result<T, E>, f: fn(&E)) {
match *res {
Ok(_) => (),
@@ -195,6 +205,7 @@ pub pure fn iter_err<T, E>(res: &Result<T, E>, f: fn(&E)) {
* parse_bytes(buf)
* }
*/
+#[inline(always)]
pub pure fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn(&T) -> U)
-> Result<U, E> {
match *res {
@@ -211,6 +222,7 @@ pub pure fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn(&T) -> U)
* is immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
+#[inline(always)]
pub pure fn map_err<T: Copy, E, F: Copy>(res: &Result<T, E>, op: fn(&E) -> F)
-> Result<T, F> {
match *res {
@@ -289,6 +301,7 @@ impl<T, E: Copy> Result<T, E> {
* assert incd == ~[2u, 3u, 4u];
* }
*/
+#[inline(always)]
pub fn map_vec<T,U:Copy,V:Copy>(
ts: &[T], op: fn(&T) -> Result<V,U>) -> Result<~[V],U> {
@@ -302,6 +315,7 @@ pub fn map_vec<T,U:Copy,V:Copy>(
return Ok(move vs);
}
+#[inline(always)]
pub fn map_opt<T,U:Copy,V:Copy>(
o_t: &Option<T>, op: fn(&T) -> Result<V,U>) -> Result<Option<V>,U> {
@@ -323,6 +337,7 @@ pub fn map_opt<T,U:Copy,V:Copy>(
* used in 'careful' code contexts where it is both appropriate and easy
* to accommodate an error like the vectors being of different lengths.
*/
+#[inline(always)]
pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
op: fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
@@ -345,6 +360,7 @@ pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
* error. This could be implemented using `map2()` but it is more efficient
* on its own as no result vector is built.
*/
+#[inline(always)]
pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
op: fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs
index fb4ea48ca95..22e187d7768 100644
--- a/src/libcore/to_str.rs
+++ b/src/libcore/to_str.rs
@@ -25,67 +25,87 @@ use vec;
pub trait ToStr { pub pure fn to_str() -> ~str; }
impl int: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::int::str(self) }
}
impl i8: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::i8::str(self) }
}
impl i16: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::i16::str(self) }
}
impl i32: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::i32::str(self) }
}
impl i64: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::i64::str(self) }
}
impl uint: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::uint::str(self) }
}
impl u8: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::u8::str(self) }
}
impl u16: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::u16::str(self) }
}
impl u32: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::u32::str(self) }
}
impl u64: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::u64::str(self) }
}
impl float: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::float::to_str(self, 4u) }
}
impl f32: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::float::to_str(self as float, 4u) }
}
impl f64: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::float::to_str(self as float, 4u) }
}
impl bool: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::bool::to_str(self) }
}
impl (): ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ~"()" }
}
impl ~str: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { copy self }
}
impl &str: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::str::from_slice(self) }
}
impl @str: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ::str::from_slice(self) }
}
impl<A: ToStr Copy, B: ToStr Copy> (A, B): ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str {
let (a, b) = self;
~"(" + a.to_str() + ~", " + b.to_str() + ~")"
}
}
impl<A: ToStr Copy, B: ToStr Copy, C: ToStr Copy> (A, B, C): ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str {
let (a, b, c) = self;
~"(" + a.to_str() + ~", " + b.to_str() + ~", " + c.to_str() + ~")"
@@ -93,6 +113,7 @@ impl<A: ToStr Copy, B: ToStr Copy, C: ToStr Copy> (A, B, C): ToStr {
}
impl<A: ToStr> ~[A]: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str unsafe {
// Bleh -- not really unsafe
// push_str and push_char
@@ -108,9 +129,11 @@ impl<A: ToStr> ~[A]: ToStr {
}
impl<A: ToStr> @A: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ~"@" + (*self).to_str() }
}
impl<A: ToStr> ~A: ToStr {
+ #[inline(always)]
pure fn to_str() -> ~str { ~"~" + (*self).to_str() }
}
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index 6ac7a1a04a3..c497a2f3c7f 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -27,18 +27,21 @@ pub trait CopyableTuple<T, U> {
impl<T: Copy, U: Copy> (T, U): CopyableTuple<T, U> {
/// Return the first element of self
+ #[inline(always)]
pure fn first() -> T {
let (t, _) = self;
return t;
}
/// Return the second element of self
+ #[inline(always)]
pure fn second() -> U {
let (_, u) = self;
return u;
}
/// Return the results of swapping the two elements of self
+ #[inline(always)]
pure fn swap() -> (U, T) {
let (t, u) = self;
return (u, t);
@@ -52,11 +55,13 @@ pub trait ImmutableTuple<T, U> {
}
impl<T, U> (T, U): ImmutableTuple<T, U> {
+ #[inline(always)]
pure fn first_ref(&self) -> &self/T {
match *self {
(ref t, _) => t,
}
}
+ #[inline(always)]
pure fn second_ref(&self) -> &self/U {
match *self {
(_, ref u) => u,
@@ -70,6 +75,7 @@ pub trait ExtendedTupleOps<A,B> {
}
impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
+ #[inline(always)]
fn zip(&self) -> ~[(A, B)] {
match *self {
(ref a, ref b) => {
@@ -78,6 +84,7 @@ impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
}
}
+ #[inline(always)]
fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
match *self {
(ref a, ref b) => {
@@ -89,6 +96,7 @@ impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
+ #[inline(always)]
fn zip(&self) -> ~[(A, B)] {
match *self {
(ref a, ref b) => {
@@ -97,6 +105,7 @@ impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
}
}
+ #[inline(always)]
fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
match *self {
(ref a, ref b) => {
@@ -108,6 +117,7 @@ impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
#[cfg(notest)]
impl<A: Eq, B: Eq> (A, B) : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => match other {
@@ -117,11 +127,13 @@ impl<A: Eq, B: Eq> (A, B) : Eq {
}
}
}
+ #[inline(always)]
pure fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) }
}
#[cfg(notest)]
impl<A: Ord, B: Ord> (A, B) : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => {
@@ -136,13 +148,17 @@ impl<A: Ord, B: Ord> (A, B) : Ord {
}
}
}
+ #[inline(always)]
pure fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) }
+ #[inline(always)]
pure fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) }
+ #[inline(always)]
pure fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self)) }
}
#[cfg(notest)]
impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => match other {
@@ -153,11 +169,13 @@ impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
}
}
}
+ #[inline(always)]
pure fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) }
}
#[cfg(notest)]
impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => {
@@ -174,8 +192,11 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
}
}
}
+ #[inline(always)]
pure fn le(&self, other: &(A, B, C)) -> bool { !(*other).lt(&(*self)) }
+ #[inline(always)]
pure fn ge(&self, other: &(A, B, C)) -> bool { !(*self).lt(other) }
+ #[inline(always)]
pure fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self)) }
}
diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
index ad6f73e56c0..a7eb2f80725 100644
--- a/src/libcore/uint-template.rs
+++ b/src/libcore/uint-template.rs
@@ -30,25 +30,42 @@ pub const bytes : uint = (inst::bits / 8);
pub const min_value: T = 0 as T;
pub const max_value: T = 0 as T - 1 as T;
+#[inline(always)]
pub pure fn min(x: T, y: T) -> T { if x < y { x } else { y } }
+#[inline(always)]
pub pure fn max(x: T, y: T) -> T { if x > y { x } else { y } }
+#[inline(always)]
pub pure fn add(x: T, y: T) -> T { x + y }
+#[inline(always)]
pub pure fn sub(x: T, y: T) -> T { x - y }
+#[inline(always)]
pub pure fn mul(x: T, y: T) -> T { x * y }
+#[inline(always)]
pub pure fn div(x: T, y: T) -> T { x / y }
+#[inline(always)]
pub pure fn rem(x: T, y: T) -> T { x % y }
+#[inline(always)]
pub pure fn lt(x: T, y: T) -> bool { x < y }
+#[inline(always)]
pub pure fn le(x: T, y: T) -> bool { x <= y }
+#[inline(always)]
pub pure fn eq(x: T, y: T) -> bool { x == y }
+#[inline(always)]
pub pure fn ne(x: T, y: T) -> bool { x != y }
+#[inline(always)]
pub pure fn ge(x: T, y: T) -> bool { x >= y }
+#[inline(always)]
pub pure fn gt(x: T, y: T) -> bool { x > y }
+#[inline(always)]
pub pure fn is_positive(x: T) -> bool { x > 0 as T }
+#[inline(always)]
pub pure fn is_negative(x: T) -> bool { x < 0 as T }
+#[inline(always)]
pub pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
+#[inline(always)]
pub pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
#[inline(always)]
@@ -62,41 +79,58 @@ pub pure fn range(lo: T, hi: T, it: fn(T) -> bool) {
}
/// Computes the bitwise complement
+#[inline(always)]
pub pure fn compl(i: T) -> T {
max_value ^ i
}
#[cfg(notest)]
impl T : Ord {
+ #[inline(always)]
pure fn lt(&self, other: &T) -> bool { (*self) < (*other) }
+ #[inline(always)]
pure fn le(&self, other: &T) -> bool { (*self) <= (*other) }
+ #[inline(always)]
pure fn ge(&self, other: &T) -> bool { (*self) >= (*other) }
+ #[inline(always)]
pure fn gt(&self, other: &T) -> bool { (*self) > (*other) }
}
#[cfg(notest)]
impl T : Eq {
+ #[inline(always)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
+ #[inline(always)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}
impl T: num::Num {
+ #[inline(always)]
pure fn add(&self, other: &T) -> T { return *self + *other; }
+ #[inline(always)]
pure fn sub(&self, other: &T) -> T { return *self - *other; }
+ #[inline(always)]
pure fn mul(&self, other: &T) -> T { return *self * *other; }
+ #[inline(always)]
pure fn div(&self, other: &T) -> T { return *self / *other; }
+ #[inline(always)]
pure fn modulo(&self, other: &T) -> T { return *self % *other; }
+ #[inline(always)]
pure fn neg(&self) -> T { return -*self; }
+ #[inline(always)]
pure fn to_int(&self) -> int { return *self as int; }
+ #[inline(always)]
static pure fn from_int(n: int) -> T { return n as T; }
}
impl T: num::Zero {
+ #[inline(always)]
static pure fn zero() -> T { 0 }
}
impl T: num::One {
+ #[inline(always)]
static pure fn one() -> T { 1 }
}
@@ -145,12 +179,14 @@ pub pure fn parse_bytes(buf: &[const u8], radix: uint) -> Option<T> {
}
/// Parse a string to an int
+#[inline(always)]
pub pure fn from_str(s: &str) -> Option<T>
{
parse_bytes(str::to_bytes(s), 10u)
}
impl T : FromStr {
+ #[inline(always)]
static pure fn from_str(s: &str) -> Option<T> { from_str(s) }
}
@@ -177,6 +213,7 @@ pub fn from_str_radix(buf: &str, radix: u64) -> Option<u64> {
*
* Fails if `radix` < 2 or `radix` > 16
*/
+#[inline(always)]
pub pure fn to_str(num: T, radix: uint) -> ~str {
do to_str_bytes(false, num, radix) |slice| {
do vec::as_imm_buf(slice) |p, len| {
@@ -230,6 +267,7 @@ pub pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
}
/// Convert to a string
+#[inline(always)]
pub pure fn str(i: T) -> ~str { return to_str(i, 10u); }
#[test]