---

yaml
---
r: 39827
b: refs/heads/incoming
c: 6441d61
h: refs/heads/master
i:
  39825: 5b53780
  39823: 33e755e
v: v3

Author: tychosci

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: d5dc66ad3181ab4fa5fc3ccd806b25f3e5ddbe8f
+refs/heads/incoming: 6441d619ba8984f469ecbd5e46358e982366b678
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/tutorial-macros.md

@@ -115,7 +115,7 @@ to transcribe into the macro expansion; its type need not be repeated.
 The right-hand side must be enclosed by delimiters, which are ignored by the
 transcriber (therefore `() => ((1,2,3))` is a macro that expands to a tuple
 expression, `() => (let $x=$val)` is a macro that expands to a statement, and
-`() => (1,2,3)` is a macro that expands to a syntax error).
+`() => (1,2,3)` is a macro that expands to a syntax errror).
 
 Except for permissibility of `$name` (and `$(...)*`, discussed below), the
 right-hand side of a macro definition is ordinary Rust syntax. In particular,

branches/incoming/src/libcore/char.rs

@@ -64,7 +64,6 @@ 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);
 }
@@ -73,7 +72,6 @@ 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);
 }
@@ -83,7 +81,6 @@ 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)
@@ -96,7 +93,6 @@ 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) ||
@@ -105,13 +101,11 @@ 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) ||
@@ -128,7 +122,6 @@ 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),
@@ -197,7 +190,6 @@ 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 }

branches/incoming/src/libcore/clone.rs

@@ -16,6 +16,5 @@ pub trait Clone {
 }
 
 impl (): Clone {
-    #[inline(always)]
     fn clone(&self) -> () { () }
 }

branches/incoming/src/libcore/cmp.rs

@@ -30,10 +30,7 @@ and `Eq` to overload the `==` and `!=` operators.
 *
 * Eventually this may be simplified to only require
 * an `eq` method, with the other generated from
-* a default implementation. However it should
-* remain possible to implement `ne` separately, for
-* compatibility with floating-point NaN semantics
-* (cf. IEEE 754-2008 section 5.11).
+* a default implementation.
 */
 #[lang="eq"]
 pub trait Eq {
@@ -46,10 +43,7 @@ pub trait Eq {
 *
 * Eventually this may be simplified to only require
 * an `le` method, with the others generated from
-* default implementations. However it should remain
-* possible to implement the others separately, for
-* compatibility with floating-point NaN semantics
-* (cf. IEEE 754-2008 section 5.11).
+* default implementations.
 */
 #[lang="ord"]
 pub trait Ord {
@@ -59,32 +53,26 @@ 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>(v1: &T, v2: &T) -> bool {
-    (*v1).le(v2)
+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)
 }

branches/incoming/src/libcore/either.rs

@@ -28,7 +28,6 @@ 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 {
     /*!
@@ -91,7 +90,6 @@ 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
 
@@ -101,7 +99,6 @@ 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> {
     /*!
@@ -117,21 +114,18 @@ 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.
 
@@ -140,7 +134,6 @@ 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.
 

branches/incoming/src/libcore/f32.rs

@@ -105,52 +105,38 @@ 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; }
 
@@ -159,7 +145,6 @@ 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;
 }
@@ -169,25 +154,21 @@ 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));
 }
@@ -238,63 +219,45 @@ 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 }
 }