diff options
212 files changed, 2517 insertions, 2553 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 8d3c8561957..29b7e35e24b 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -38,7 +38,7 @@ pub mod rustrt { /// Returns the number of elements the vector can hold without reallocating #[inline(always)] -pub pure fn capacity<T>(v: @[const T]) -> uint { +pub fn capacity<T>(v: @[const T]) -> uint { unsafe { let repr: **raw::VecRepr = ::cast::reinterpret_cast(&addr_of(&v)); @@ -59,8 +59,7 @@ pub pure fn capacity<T>(v: @[const T]) -> uint { * onto the vector being constructed. */ #[inline(always)] -pub pure fn build_sized<A>(size: uint, - builder: &fn(push: &pure fn(v: A))) -> @[A] { +pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] { let mut vec: @[const A] = @[]; unsafe { raw::reserve(&mut vec, size); } builder(|+x| unsafe { raw::push(&mut vec, x) }); @@ -78,7 +77,7 @@ pub pure fn build_sized<A>(size: uint, * onto the vector being constructed. */ #[inline(always)] -pub pure fn build<A>(builder: &fn(push: &pure fn(v: A))) -> @[A] { +pub fn build<A>(builder: &fn(push: &fn(v: A))) -> @[A] { build_sized(4, builder) } @@ -95,14 +94,15 @@ pub pure fn build<A>(builder: &fn(push: &pure fn(v: A))) -> @[A] { * onto the vector being constructed. */ #[inline(always)] -pub pure fn build_sized_opt<A>(size: Option<uint>, - builder: &fn(push: &pure fn(v: A))) -> @[A] { +pub fn build_sized_opt<A>(size: Option<uint>, + builder: &fn(push: &fn(v: A))) + -> @[A] { build_sized(size.get_or_default(4), builder) } // Appending #[inline(always)] -pub pure fn append<T:Copy>(lhs: @[T], rhs: &[const T]) -> @[T] { +pub fn append<T:Copy>(lhs: @[T], rhs: &[const T]) -> @[T] { do build_sized(lhs.len() + rhs.len()) |push| { for vec::each(lhs) |x| { push(*x); } for uint::range(0, rhs.len()) |i| { push(rhs[i]); } @@ -111,7 +111,7 @@ pub pure fn append<T:Copy>(lhs: @[T], rhs: &[const T]) -> @[T] { /// Apply a function to each element of a vector and return the results -pub pure fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] { +pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] { do build_sized(v.len()) |push| { for vec::each(v) |elem| { push(f(elem)); @@ -125,7 +125,7 @@ pub pure fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value returned by the function `op`. */ -pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] { +pub fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] { do build_sized(n_elts) |push| { let mut i: uint = 0u; while i < n_elts { push(op(i)); i += 1u; } @@ -138,7 +138,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value `t`. */ -pub pure fn from_elem<T:Copy>(n_elts: uint, t: T) -> @[T] { +pub fn from_elem<T:Copy>(n_elts: uint, t: T) -> @[T] { do build_sized(n_elts) |push| { let mut i: uint = 0u; while i < n_elts { push(copy t); i += 1u; } @@ -176,7 +176,7 @@ pub mod traits { impl<T:Copy> Add<&'self [const T],@[T]> for @[T] { #[inline(always)] - pure fn add(&self, rhs: & &'self [const T]) -> @[T] { + fn add(&self, rhs: & &'self [const T]) -> @[T] { append(*self, (*rhs)) } } diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index 512855d8f86..2b669a285b3 100644 --- a/src/libcore/bool.rs +++ b/src/libcore/bool.rs @@ -17,39 +17,39 @@ use from_str::FromStr; #[cfg(notest)] use cmp; /// Negation / inverse -pub pure fn not(v: bool) -> bool { !v } +pub fn not(v: bool) -> bool { !v } /// Conjunction -pub pure fn and(a: bool, b: bool) -> bool { a && b } +pub fn and(a: bool, b: bool) -> bool { a && b } /// Disjunction -pub pure fn or(a: bool, b: bool) -> bool { a || b } +pub fn or(a: bool, b: bool) -> bool { a || b } /** * Exclusive or * * Identical to `or(and(a, not(b)), and(not(a), b))` */ -pub pure fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) } +pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) } /// Implication in the logic, i.e. from `a` follows `b` -pub pure fn implies(a: bool, b: bool) -> bool { !a || b } +pub fn implies(a: bool, b: bool) -> bool { !a || b } /// true if truth values `a` and `b` are indistinguishable in the logic -pub pure fn eq(a: bool, b: bool) -> bool { a == b } +pub fn eq(a: bool, b: bool) -> bool { a == b } /// true if truth values `a` and `b` are distinguishable in the logic -pub pure fn ne(a: bool, b: bool) -> bool { a != b } +pub fn ne(a: bool, b: bool) -> bool { a != b } /// true if `v` represents truth in the logic -pub pure fn is_true(v: bool) -> bool { v } +pub fn is_true(v: bool) -> bool { v } /// true if `v` represents falsehood in the logic -pub pure fn is_false(v: bool) -> bool { !v } +pub fn is_false(v: bool) -> bool { !v } /// Parse logic value from `s` impl FromStr for bool { - static pure fn from_str(s: &str) -> Option<bool> { + fn from_str(s: &str) -> Option<bool> { if s == "true" { Some(true) } else if s == "false" { @@ -61,7 +61,7 @@ impl FromStr for bool { } /// Convert `v` into a string -pub pure fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } } +pub fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } } /** * Iterates over all truth values by passing them to `blk` in an unspecified @@ -73,12 +73,12 @@ pub fn all_values(blk: &fn(v: bool)) { } /// converts truth value to an 8 bit byte -pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } } +pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } } #[cfg(notest)] impl cmp::Eq for bool { - pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) } - pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) } + fn eq(&self, other: &bool) -> bool { (*self) == (*other) } + fn ne(&self, other: &bool) -> bool { (*self) != (*other) } } #[test] diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index cfd1b8dfef0..bf5f9315938 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -21,14 +21,14 @@ pub struct Cell<T> { } impl<T:cmp::Eq> cmp::Eq for Cell<T> { - pure fn eq(&self, other: &Cell<T>) -> bool { + fn eq(&self, other: &Cell<T>) -> bool { unsafe { let frozen_self: &Option<T> = transmute(&mut self.value); let frozen_other: &Option<T> = transmute(&mut other.value); frozen_self == frozen_other } } - pure fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) } + fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) } } /// Creates a new full cell with the given value. @@ -36,7 +36,7 @@ pub fn Cell<T>(value: T) -> Cell<T> { Cell { value: Some(value) } } -pub pure fn empty_cell<T>() -> Cell<T> { +pub fn empty_cell<T>() -> Cell<T> { Cell { value: None } } @@ -61,7 +61,7 @@ pub impl<T> Cell<T> { } /// Returns true if the cell is empty and false if the cell is full. - pure fn is_empty(&self) -> bool { + fn is_empty(&self) -> bool { self.value.is_none() } diff --git a/src/libcore/char.rs b/src/libcore/char.rs index f2db9ca919d..027329a2355 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -61,7 +61,7 @@ pub use is_XID_continue = unicode::derived_property::XID_Continue; * in terms of the Unicode General Category 'Ll' */ #[inline(always)] -pub pure fn is_lowercase(c: char) -> bool { +pub fn is_lowercase(c: char) -> bool { return unicode::general_category::Ll(c); } @@ -70,7 +70,7 @@ pub pure fn is_lowercase(c: char) -> bool { * in terms of the Unicode General Category 'Lu'. */ #[inline(always)] -pub pure fn is_uppercase(c: char) -> bool { +pub fn is_uppercase(c: char) -> bool { return unicode::general_category::Lu(c); } @@ -80,7 +80,7 @@ pub pure fn is_uppercase(c: char) -> bool { * additional 'Cc'-category control codes in the range [0x09, 0x0d] */ #[inline(always)] -pub pure fn is_whitespace(c: char) -> bool { +pub fn is_whitespace(c: char) -> bool { return ('\x09' <= c && c <= '\x0d') || unicode::general_category::Zs(c) || unicode::general_category::Zl(c) @@ -93,7 +93,7 @@ pub pure fn is_whitespace(c: char) -> bool { * and the Derived Core Property 'Alphabetic'. */ #[inline(always)] -pub pure fn is_alphanumeric(c: char) -> bool { +pub fn is_alphanumeric(c: char) -> bool { return unicode::derived_property::Alphabetic(c) || unicode::general_category::Nd(c) || unicode::general_category::Nl(c) || @@ -102,13 +102,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 { +pub 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 { +pub fn is_digit(c: char) -> bool { return unicode::general_category::Nd(c) || unicode::general_category::Nl(c) || unicode::general_category::No(c); @@ -127,7 +127,7 @@ pub pure fn is_digit(c: char) -> bool { * Note: This just wraps `to_digit()`. */ #[inline(always)] -pub pure fn is_digit_radix(c: char, radix: uint) -> bool { +pub fn is_digit_radix(c: char, radix: uint) -> bool { match to_digit(c, radix) { Some(_) => true, None => false @@ -148,7 +148,7 @@ pub pure fn is_digit_radix(c: char, radix: uint) -> bool { * Fails if given a `radix` outside the range `[0..36]`. */ #[inline] -pub pure fn to_digit(c: char, radix: uint) -> Option<uint> { +pub fn to_digit(c: char, radix: uint) -> Option<uint> { if radix > 36 { fail!(fmt!("to_digit: radix %? is to high (maximum 36)", radix)); } @@ -171,7 +171,7 @@ pub pure fn to_digit(c: char, radix: uint) -> Option<uint> { * Fails if given an `radix` > 36. */ #[inline] -pub pure fn from_digit(num: uint, radix: uint) -> Option<char> { +pub fn from_digit(num: uint, radix: uint) -> Option<char> { if radix > 36 { fail!(fmt!("from_digit: radix %? is to high (maximum 36)", num)); } @@ -195,7 +195,7 @@ pub pure fn from_digit(num: uint, radix: uint) -> Option<char> { * - chars in [0x100,0xffff] get 4-digit escapes: `\\uNNNN` * - chars above 0x10000 get 8-digit escapes: `\\UNNNNNNNN` */ -pub pure fn escape_unicode(c: char) -> ~str { +pub fn escape_unicode(c: char) -> ~str { let s = u32::to_str_radix(c as u32, 16u); let (c, pad) = (if c <= '\xff' { ('x', 2u) } else if c <= '\uffff' { ('u', 4u) } @@ -223,7 +223,7 @@ pub pure fn escape_unicode(c: char) -> ~str { * - Any other chars in the range [0x20,0x7e] are not escaped. * - Any other chars are given hex unicode escapes; see `escape_unicode`. */ -pub pure fn escape_default(c: char) -> ~str { +pub fn escape_default(c: char) -> ~str { match c { '\t' => ~"\\t", '\r' => ~"\\r", @@ -244,7 +244,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 { +pub fn cmp(a: char, b: char) -> int { return if b > a { -1 } else if b < a { 1 } else { 0 } @@ -252,8 +252,8 @@ pub pure fn cmp(a: char, b: char) -> int { #[cfg(notest)] impl Eq for char { - pure fn eq(&self, other: &char) -> bool { (*self) == (*other) } - pure fn ne(&self, other: &char) -> bool { (*self) != (*other) } + fn eq(&self, other: &char) -> bool { (*self) == (*other) } + fn ne(&self, other: &char) -> bool { (*self) != (*other) } } #[test] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index fc8ed5d70c3..7c45ecae632 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -33,8 +33,8 @@ and `Eq` to overload the `==` and `!=` operators. */ #[lang="eq"] pub trait Eq { - pure fn eq(&self, other: &Self) -> bool; - pure fn ne(&self, other: &Self) -> bool; + fn eq(&self, other: &Self) -> bool; + fn ne(&self, other: &Self) -> bool; } #[deriving(Eq)] @@ -42,11 +42,11 @@ pub enum Ordering { Less, Equal, Greater } /// Trait for types that form a total order pub trait TotalOrd { - pure fn cmp(&self, other: &Self) -> Ordering; + fn cmp(&self, other: &Self) -> Ordering; } #[inline(always)] -pure fn icmp<T: Ord>(a: &T, b: &T) -> Ordering { +fn icmp<T: Ord>(a: &T, b: &T) -> Ordering { if *a < *b { Less } else if *a > *b { Greater } else { Equal } @@ -54,52 +54,52 @@ pure fn icmp<T: Ord>(a: &T, b: &T) -> Ordering { impl TotalOrd for u8 { #[inline(always)] - pure fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) } } impl TotalOrd for u16 { #[inline(always)] - pure fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) } } impl TotalOrd for u32 { #[inline(always)] - pure fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) } } impl TotalOrd for u64 { #[inline(always)] - pure fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) } } impl TotalOrd for i8 { #[inline(always)] - pure fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) } } impl TotalOrd for i16 { #[inline(always)] - pure fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) } } impl TotalOrd for i32 { #[inline(always)] - pure fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) } } impl TotalOrd for i64 { #[inline(always)] - pure fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) } } impl TotalOrd for int { #[inline(always)] - pure fn cmp(&self, other: &int) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &int) -> Ordering { icmp(self, other) } } impl TotalOrd for uint { #[inline(always)] - pure fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) } + fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) } } /** @@ -114,39 +114,39 @@ impl TotalOrd for uint { */ #[lang="ord"] pub trait Ord { - pure fn lt(&self, other: &Self) -> bool; - pure fn le(&self, other: &Self) -> bool; - pure fn ge(&self, other: &Self) -> bool; - pure fn gt(&self, other: &Self) -> bool; + fn lt(&self, other: &Self) -> bool; + fn le(&self, other: &Self) -> bool; + fn ge(&self, other: &Self) -> bool; + fn gt(&self, other: &Self) -> bool; } #[inline(always)] -pub pure fn lt<T:Ord>(v1: &T, v2: &T) -> bool { +pub 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 { +pub fn le<T:Ord>(v1: &T, v2: &T) -> bool { (*v1).le(v2) } #[inline(always)] -pub pure fn eq<T:Eq>(v1: &T, v2: &T) -> bool { +pub 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 { +pub 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 { +pub 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 { +pub fn gt<T:Ord>(v1: &T, v2: &T) -> bool { (*v1).gt(v2) } @@ -155,16 +155,16 @@ pub pure fn gt<T:Ord>(v1: &T, v2: &T) -> bool { /// container types; e.g. it is often desirable to be able to use `&str` /// values to look up entries in a container with `~str` keys. pub trait Equiv<T> { - pure fn equiv(&self, other: &T) -> bool; + fn equiv(&self, other: &T) -> bool; } #[inline(always)] -pub pure fn min<T:Ord>(v1: T, v2: T) -> T { +pub fn min<T:Ord>(v1: T, v2: T) -> T { if v1 < v2 { v1 } else { v2 } } #[inline(always)] -pub pure fn max<T:Ord>(v1: T, v2: T) -> T { +pub fn max<T:Ord>(v1: T, v2: T) -> T { if v1 > v2 { v1 } else { v2 } } diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 692a7947e20..6dadca8dc57 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -50,7 +50,7 @@ pub trait GenericPort<T> { /// Ports that can `peek` pub trait Peekable<T> { /// Returns true if a message is available - pure fn peek(&self) -> bool; + fn peek(&self) -> bool; } /// Returns the index of an endpoint that is ready to receive. @@ -148,7 +148,7 @@ fn chan_try_send<T:Owned>(self: &Chan<T>, x: T) -> bool { pub impl<T: Owned> Port<T> { fn recv(&self) -> T { port_recv(self) } fn try_recv(&self) -> Option<T> { port_try_recv(self) } - pure fn peek(&self) -> bool { port_peek(self) } + fn peek(&self) -> bool { port_peek(self) } } impl<T: Owned> GenericPort<T> for Port<T> { @@ -180,11 +180,11 @@ fn port_try_recv<T:Owned>(self: &Port<T>) -> Option<T> { } impl<T: Owned> Peekable<T> for Port<T> { - pure fn peek(&self) -> bool { port_peek(self) } + fn peek(&self) -> bool { port_peek(self) } } #[inline(always)] -pure fn port_peek<T:Owned>(self: &Port<T>) -> bool { +fn port_peek<T:Owned>(self: &Port<T>) -> bool { unsafe { let mut endp = None; endp <-> self.endp; @@ -198,7 +198,7 @@ pure fn port_peek<T:Owned>(self: &Port<T>) -> bool { } impl<T: Owned> Selectable for Port<T> { - pure fn header(&self) -> *PacketHeader { + fn header(&self) -> *PacketHeader { unsafe { match self.endp { Some(ref endp) => endp.header(), @@ -223,7 +223,7 @@ pub fn PortSet<T: Owned>() -> PortSet<T>{ pub impl<T:Owned> PortSet<T> { fn recv(&self) -> T { port_set_recv(self) } fn try_recv(&self) -> Option<T> { port_set_try_recv(self) } - pure fn peek(&self) -> bool { port_set_peek(self) } + fn peek(&self) -> bool { port_set_peek(self) } } pub impl<T: Owned> PortSet<T> { @@ -272,11 +272,11 @@ fn port_set_try_recv<T:Owned>(self: &PortSet<T>) -> Option<T> { } impl<T: Owned> Peekable<T> for PortSet<T> { - pure fn peek(&self) -> bool { port_set_peek(self) } + fn peek(&self) -> bool { port_set_peek(self) } } #[inline(always)] -pure fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool { +fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool { // It'd be nice to use self.port.each, but that version isn't // pure. for uint::range(0, vec::uniq_len(&const self.ports)) |i| { diff --git a/src/libcore/container.rs b/src/libcore/container.rs index 5044b3a6c5d..1cda04ee06e 100644 --- a/src/libcore/container.rs +++ b/src/libcore/container.rs @@ -14,10 +14,10 @@ use option::Option; pub trait Container { /// Return the number of elements in the container - pure fn len(&const self) -> uint; + fn len(&const self) -> uint; /// Return true if the container contains no elements - pure fn is_empty(&const self) -> bool; + fn is_empty(&const self) -> bool; } pub trait Mutable: Container { @@ -27,19 +27,19 @@ pub trait Mutable: Container { pub trait Map<K, V>: Mutable { /// Return true if the map contains a value for the specified key - pure fn contains_key(&self, key: &K) -> bool; + fn contains_key(&self, key: &K) -> bool; /// Visit all keys - pure fn each_key(&self, f: &fn(&K) -> bool); + fn each_key(&self, f: &fn(&K) -> bool); /// Visit all values - pure fn each_value(&self, f: &fn(&V) -> bool); + fn each_value(&self, f: &fn(&V) -> bool); /// Iterate over the map and mutate the contained values fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool); /// Return the value corresponding to the key in the map - pure fn find(&self, key: &K) -> Option<&'self V>; + fn find(&self, key: &K) -> Option<&'self V>; /// Insert a key-value pair into the map. An existing value for a /// key is replaced by the new value. Return true if the key did @@ -53,7 +53,7 @@ pub trait Map<K, V>: Mutable { pub trait Set<T>: Mutable { /// Return true if the set contains a value - pure fn contains(&self, value: &T) -> bool; + fn contains(&self, value: &T) -> bool; /// Add a value to the set. Return true if the value was not already /// present in the set. @@ -65,23 +65,23 @@ pub trait Set<T>: Mutable { /// Return true if the set has no elements in common with `other`. /// This is equivalent to checking for an empty intersection. - pure fn is_disjoint(&self, other: &Self) -> bool; + fn is_disjoint(&self, other: &Self) -> bool; /// Return true if the set is a subset of another - pure fn is_subset(&self, other: &Self) -> bool; + fn is_subset(&self, other: &Self) -> bool; /// Return true if the set is a superset of another - pure fn is_superset(&self, other: &Self) -> bool; + fn is_superset(&self, other: &Self) -> bool; /// Visit the values representing the difference - pure fn difference(&self, other: &Self, f: &fn(&T) -> bool); + fn difference(&self, other: &Self, f: &fn(&T) -> bool); /// Visit the values representing the symmetric difference - pure fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool); + fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool); /// Visit the values representing the intersection - pure fn intersection(&self, other: &Self, f: &fn(&T) -> bool); + fn intersection(&self, other: &Self, f: &fn(&T) -> bool); /// Visit the values representing the union - pure fn union(&self, other: &Self, f: &fn(&T) -> bool); + fn union(&self, other: &Self, f: &fn(&T) -> bool); } diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index 5a230da877f..ff86e8d1ffc 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -42,7 +42,7 @@ pub struct DList<T> { } priv impl<T> DListNode<T> { - pure fn assert_links(@mut self) { + fn assert_links(@mut self) { match self.next { Some(neighbour) => match neighbour.prev { Some(me) => if !managed::mut_ptr_eq(self, me) { @@ -66,24 +66,24 @@ priv impl<T> DListNode<T> { pub impl<T> DListNode<T> { /// Get the next node in the list, if there is one. - pure fn next_link(@mut self) -> DListLink<T> { + fn next_link(@mut self) -> DListLink<T> { self.assert_links(); self.next } /// Get the next node in the list, failing if there isn't one. - pure fn next_node(@mut self) -> @mut DListNode<T> { + fn next_node(@mut self) -> @mut DListNode<T> { match self.next_link() { Some(nobe) => nobe, None => fail!(~"This dlist node has no next neighbour.") } } /// Get the previous node in the list, if there is one. - pure fn prev_link(@mut self) -> DListLink<T> { + fn prev_link(@mut self) -> DListLink<T> { self.assert_links(); self.prev } /// Get the previous node in the list, failing if there isn't one. - pure fn prev_node(@mut self) -> @mut DListNode<T> { + fn prev_node(@mut self) -> @mut DListNode<T> { match self.prev_link() { Some(nobe) => nobe, None => fail!(~"This dlist node has no previous neighbour.") @@ -92,17 +92,17 @@ pub impl<T> DListNode<T> { } /// Creates a new dlist node with the given data. -pub pure fn new_dlist_node<T>(data: T) -> @mut DListNode<T> { +pub fn new_dlist_node<T>(data: T) -> @mut DListNode<T> { @mut DListNode { data: data, linked: false, prev: None, next: None } } /// Creates a new, empty dlist. -pub pure fn DList<T>() -> @mut DList<T> { +pub fn DList<T>() -> @mut DList<T> { @mut DList { size: 0, hd: None, tl: None } } /// Creates a new dlist with a single element -pub pure fn from_elem<T>(data: T) -> @mut DList<T> { +pub fn from_elem<T>(data: T) -> @mut DList<T> { let list = DList(); unsafe { list.push(data); } list @@ -126,7 +126,7 @@ pub fn concat<T>(lists: @mut DList<@mut DList<T>>) -> @mut DList<T> { } priv impl<T> DList<T> { - static pure fn new_link(data: T) -> DListLink<T> { + fn new_link(data: T) -> DListLink<T> { Some(@mut DListNode { data: data, linked: true, @@ -134,7 +134,7 @@ priv impl<T> DList<T> { next: None }) } - pure fn assert_mine(@mut self, nobe: @mut DListNode<T>) { + fn assert_mine(@mut self, nobe: @mut DListNode<T>) { // These asserts could be stronger if we had node-root back-pointers, // but those wouldn't allow for O(1) append. if self.size == 0 { @@ -212,9 +212,9 @@ priv impl<T> DList<T> { pub impl<T> DList<T> { /// Get the size of the list. O(1). - pure fn len(@mut self) -> uint { self.size } + fn len(@mut self) -> uint { self.size } /// Returns true if the list is empty. O(1). - pure fn is_empty(@mut self) -> bool { self.len() == 0 } + fn is_empty(@mut self) -> bool { self.len() == 0 } /// Add data to the head of the list. O(1). fn push_head(@mut self, data: T) { @@ -316,12 +316,12 @@ pub impl<T> DList<T> { tl } /// Get the node at the list's head. O(1). - pure fn peek_n(@mut self) -> DListLink<T> { self.hd } + fn peek_n(@mut self) -> DListLink<T> { self.hd } /// Get the node at the list's tail. O(1). - pure fn peek_tail_n(@mut self) -> DListLink<T> { self.tl } + fn peek_tail_n(@mut self) -> DListLink<T> { self.tl } /// Get the node at the list's head, failing if empty. O(1). - pure fn head_n(@mut self) -> @mut DListNode<T> { + fn head_n(@mut self) -> @mut DListNode<T> { match self.hd { Some(nobe) => nobe, None => fail!( @@ -329,7 +329,7 @@ pub impl<T> DList<T> { } } /// Get the node at the list's tail, failing if empty. O(1). - pure fn tail_n(@mut self) -> @mut DListNode<T> { + fn tail_n(@mut self) -> @mut DListNode<T> { match self.tl { Some(nobe) => nobe, None => fail!( @@ -399,7 +399,7 @@ pub impl<T> DList<T> { } /// Iterate over nodes. - pure fn each_node(@mut self, f: &fn(@mut DListNode<T>) -> bool) { + fn each_node(@mut self, f: &fn(@mut DListNode<T>) -> bool) { let mut link = self.peek_n(); while link.is_some() { let nobe = link.get(); @@ -471,23 +471,23 @@ pub impl<T:Copy> DList<T> { } /// Get data at the list's head. O(1). - pure fn peek(@mut self) -> Option<T> { + fn peek(@mut self) -> Option<T> { self.peek_n().map(|nobe| nobe.data) } /// Get data at the list's tail. O(1). - pure fn peek_tail(@mut self) -> Option<T> { + fn peek_tail(@mut self) -> Option<T> { self.peek_tail_n().map (|nobe| nobe.data) } /// Get data at the list's head, failing if empty. O(1). - pure fn head(@mut self) -> T { self.head_n().data } + fn head(@mut self) -> T { self.head_n().data } /// Get data at the list's tail, failing if empty. O(1). - pure fn tail(@mut self) -> T { self.tail_n().data } + fn tail(@mut self) -> T { self.tail_n().data } /// Get the elements of the list as a vector. O(n). - pure fn to_vec(@mut self) -> ~[T] { + fn to_vec(@mut self) -> ~[T] { let mut v = vec::with_capacity(self.size); unsafe { // Take this out of the unchecked when iter's functions are pure @@ -507,7 +507,7 @@ impl<T> BaseIter<T> for @mut DList<T> { * allow for e.g. breadth-first search with in-place enqueues), but * removing the current node is forbidden. */ - pure fn each(&self, f: &fn(v: &T) -> bool) { + fn each(&self, f: &fn(v: &T) -> bool) { let mut link = self.peek_n(); while option::is_some(&link) { let nobe = option::get(link); @@ -536,7 +536,7 @@ impl<T> BaseIter<T> for @mut DList<T> { } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } #[cfg(test)] diff --git a/src/libcore/either.rs b/src/libcore/either.rs index a036c19c158..1cf2c5e1fff 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -87,7 +87,7 @@ pub fn partition<T, U>(eithers: ~[Either<T, U>]) } #[inline(always)] -pub pure fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> { +pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> { //! Flips between left and right of a given either match eith { @@ -97,7 +97,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>) +pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> { /*! * Converts either::t to a result::t @@ -113,21 +113,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 { +pub 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 { +pub 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 { +pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T { //! Retrieves the value in the left branch. Fails if the either is Right. match eith { @@ -137,7 +137,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 { +pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U { //! Retrieves the value in the right branch. Fails if the either is Left. match eith { diff --git a/src/libcore/from_str.rs b/src/libcore/from_str.rs index 166ba2252a9..ebf6d212466 100644 --- a/src/libcore/from_str.rs +++ b/src/libcore/from_str.rs @@ -13,5 +13,5 @@ use option::Option; pub trait FromStr { - static pure fn from_str(s: &str) -> Option<Self>; + fn from_str(s: &str) -> Option<Self>; } diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs index 7f2189df20e..1bfa0e9522d 100644 --- a/src/libcore/hash.rs +++ b/src/libcore/hash.rs @@ -50,17 +50,17 @@ pub trait Hash { * function and require most types to only implement the * IterBytes trait, that feeds SipHash. */ - pure fn hash_keyed(&self, k0: u64, k1: u64) -> u64; + fn hash_keyed(&self, k0: u64, k1: u64) -> u64; } // When we have default methods, won't need this. pub trait HashUtil { - pure fn hash(&self) -> u64; + fn hash(&self) -> u64; } impl<A:Hash> HashUtil for A { #[inline(always)] - pure fn hash(&self) -> u64 { self.hash_keyed(0,0) } + fn hash(&self) -> u64 { self.hash_keyed(0,0) } } /// Streaming hash-functions should implement this. @@ -75,7 +75,7 @@ pub trait Streaming { impl<A:IterBytes> Hash for A { #[inline(always)] - pure fn hash_keyed(&self, k0: u64, k1: u64) -> u64 { + fn hash_keyed(&self, k0: u64, k1: u64) -> u64 { unsafe { let s = &State(k0, k1); for self.iter_bytes(true) |bytes| { @@ -86,9 +86,8 @@ impl<A:IterBytes> Hash for A { } } -pure fn hash_keyed_2<A: IterBytes, - B: IterBytes>(a: &A, b: &B, - k0: u64, k1: u64) -> u64 { +fn hash_keyed_2<A: IterBytes, + B: IterBytes>(a: &A, b: &B, k0: u64, k1: u64) -> u64 { unsafe { let s = &State(k0, k1); for a.iter_bytes(true) |bytes| { s.input(bytes); } @@ -97,10 +96,9 @@ pure fn hash_keyed_2<A: IterBytes, } } -pure fn hash_keyed_3<A: IterBytes, - B: IterBytes, - C: IterBytes>(a: &A, b: &B, c: &C, - k0: u64, k1: u64) -> u64 { +fn hash_keyed_3<A: IterBytes, + B: IterBytes, + C: IterBytes>(a: &A, b: &B, c: &C, k0: u64, k1: u64) -> u64 { unsafe { let s = &State(k0, k1); for a.iter_bytes(true) |bytes| { s.input(bytes); } @@ -110,11 +108,11 @@ pure fn hash_keyed_3<A: IterBytes, } } -pure fn hash_keyed_4<A: IterBytes, - B: IterBytes, - C: IterBytes, - D: IterBytes>(a: &A, b: &B, c: &C, d: &D, - k0: u64, k1: u64) -> u64 { +fn hash_keyed_4<A: IterBytes, + B: IterBytes, + C: IterBytes, + D: IterBytes>(a: &A, b: &B, c: &C, d: &D, k0: u64, k1: u64) + -> u64 { unsafe { let s = &State(k0, k1); for a.iter_bytes(true) |bytes| { s.input(bytes); } @@ -125,12 +123,12 @@ pure fn hash_keyed_4<A: IterBytes, } } -pure fn hash_keyed_5<A: IterBytes, - B: IterBytes, - C: IterBytes, - D: IterBytes, - E: IterBytes>(a: &A, b: &B, c: &C, d: &D, e: &E, - k0: u64, k1: u64) -> u64 { +fn hash_keyed_5<A: IterBytes, + B: IterBytes, + C: IterBytes, + D: IterBytes, + E: IterBytes>(a: &A, b: &B, c: &C, d: &D, e: &E, + k0: u64, k1: u64) -> u64 { unsafe { let s = &State(k0, k1); for a.iter_bytes(true) |bytes| { s.input(bytes); } diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index 68a55792077..64806cd21aa 100644 --- a/src/libcore/hashmap.rs +++ b/src/libcore/hashmap.rs @@ -48,7 +48,7 @@ pub mod linear { } #[inline(always)] - pure fn resize_at(capacity: uint) -> uint { + fn resize_at(capacity: uint) -> uint { ((capacity as float) * 3. / 4.) as uint } @@ -59,7 +59,7 @@ pub mod linear { initial_capacity) } - pure fn linear_map_with_capacity_and_keys<K:Eq + Hash,V>( + fn linear_map_with_capacity_and_keys<K:Eq + Hash,V>( k0: u64, k1: u64, initial_capacity: uint) -> LinearMap<K, V> { LinearMap { @@ -72,21 +72,21 @@ pub mod linear { priv impl<K:Hash + IterBytes + Eq,V> LinearMap<K, V> { #[inline(always)] - pure fn to_bucket(&self, h: uint) -> uint { + fn to_bucket(&self, h: uint) -> uint { // A good hash function with entropy spread over all of the // bits is assumed. SipHash is more than good enough. h % self.buckets.len() } #[inline(always)] - pure fn next_bucket(&self, idx: uint, len_buckets: uint) -> uint { + fn next_bucket(&self, idx: uint, len_buckets: uint) -> uint { let n = (idx + 1) % len_buckets; debug!("next_bucket(%?, %?) = %?", idx, len_buckets, n); n } #[inline(always)] - pure fn bucket_sequence(&self, hash: uint, + fn bucket_sequence(&self, hash: uint, op: &fn(uint) -> bool) -> uint { let start_idx = self.to_bucket(hash); let len_buckets = self.buckets.len(); @@ -103,24 +103,24 @@ pub mod linear { } #[inline(always)] - pure fn bucket_for_key(&self, k: &K) -> SearchResult { + fn bucket_for_key(&self, k: &K) -> SearchResult { let hash = k.hash_keyed(self.k0, self.k1) as uint; self.bucket_for_key_with_hash(hash, k) } #[inline(always)] - pure fn bucket_for_key_equiv<Q:Hash + IterBytes + Equiv<K>>( - &self, - k: &Q) - -> SearchResult { + fn bucket_for_key_equiv<Q:Hash + IterBytes + Equiv<K>>(&self, + k: &Q) + -> SearchResult { let hash = k.hash_keyed(self.k0, self.k1) as uint; self.bucket_for_key_with_hash_equiv(hash, k) } #[inline(always)] - pure fn bucket_for_key_with_hash(&self, - hash: uint, - k: &K) -> SearchResult { + fn bucket_for_key_with_hash(&self, + hash: uint, + k: &K) + -> SearchResult { let _ = for self.bucket_sequence(hash) |i| { match self.buckets[i] { Some(ref bkt) => if bkt.hash == hash && *k == bkt.key { @@ -133,10 +133,10 @@ pub mod linear { } #[inline(always)] - pure fn bucket_for_key_with_hash_equiv<Q:Equiv<K>>(&self, - hash: uint, - k: &Q) - -> SearchResult { + fn bucket_for_key_with_hash_equiv<Q:Equiv<K>>(&self, + hash: uint, + k: &Q) + -> SearchResult { let _ = for self.bucket_sequence(hash) |i| { match self.buckets[i] { Some(ref bkt) => { @@ -185,7 +185,7 @@ pub mod linear { } #[inline(always)] - pure fn value_for_bucket(&self, idx: uint) -> &'self V { + fn value_for_bucket(&self, idx: uint) -> &'self V { match self.buckets[idx] { Some(ref bkt) => &bkt.value, None => fail!(~"LinearMap::find: internal logic error"), @@ -273,7 +273,7 @@ pub mod linear { BaseIter<(&'self K, &'self V)> for LinearMap<K, V> { /// Visit all key-value pairs - pure fn each(&self, blk: &fn(&(&'self K, &'self V)) -> bool) { + fn each(&self, blk: &fn(&(&'self K, &'self V)) -> bool) { for uint::range(0, self.buckets.len()) |i| { let mut broke = false; do self.buckets[i].map |bucket| { @@ -284,16 +284,16 @@ pub mod linear { if broke { break; } } } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<K:Hash + IterBytes + Eq,V> Container for LinearMap<K, V> { /// Return the number of elements in the map - pure fn len(&const self) -> uint { self.size } + fn len(&const self) -> uint { self.size } /// Return true if the map contains no elements - pure fn is_empty(&const self) -> bool { self.len() == 0 } + fn is_empty(&const self) -> bool { self.len() == 0 } } impl<K:Hash + IterBytes + Eq,V> Mutable for LinearMap<K, V> { @@ -308,7 +308,7 @@ pub mod linear { impl<K:Hash + IterBytes + Eq,V> Map<K, V> for LinearMap<K, V> { /// Return true if the map contains a value for the specified key - pure fn contains_key(&self, k: &K) -> bool { + fn contains_key(&self, k: &K) -> bool { match self.bucket_for_key(k) { FoundEntry(_) => {true} TableFull | FoundHole(_) => {false} @@ -316,12 +316,12 @@ pub mod linear { } /// Visit all keys - pure fn each_key(&self, blk: &fn(k: &K) -> bool) { + fn each_key(&self, blk: &fn(k: &K) -> bool) { self.each(|&(k, _)| blk(k)) } /// Visit all values - pure fn each_value(&self, blk: &fn(v: &V) -> bool) { + fn each_value(&self, blk: &fn(v: &V) -> bool) { self.each(|&(_, v)| blk(v)) } @@ -339,7 +339,7 @@ pub mod linear { } /// Return the value corresponding to the key in the map - pure fn find(&self, k: &K) -> Option<&'self V> { + fn find(&self, k: &K) -> Option<&'self V> { match self.bucket_for_key(k) { FoundEntry(idx) => Some(self.value_for_bucket(idx)), TableFull | FoundHole(_) => None, @@ -373,7 +373,7 @@ pub mod linear { pub impl<K:Hash + IterBytes + Eq,V> LinearMap<K, V> { /// Create an empty LinearMap - static fn new() -> LinearMap<K, V> { + fn new() -> LinearMap<K, V> { linear_map_with_capacity(INITIAL_CAPACITY) } @@ -487,7 +487,7 @@ pub mod linear { } } - pure fn get(&self, k: &K) -> &'self V { + fn get(&self, k: &K) -> &'self V { match self.find(k) { Some(v) => v, None => fail!(fmt!("No entry found for key: %?", k)), @@ -496,10 +496,8 @@ pub mod linear { /// Return true if the map contains a value for the specified key, /// using equivalence - pure fn contains_key_equiv<Q:Hash + IterBytes + Equiv<K>>( - &self, - key: &Q) - -> bool { + fn contains_key_equiv<Q:Hash + IterBytes + Equiv<K>>(&self, key: &Q) + -> bool { match self.bucket_for_key_equiv(key) { FoundEntry(_) => {true} TableFull | FoundHole(_) => {false} @@ -508,8 +506,8 @@ pub mod linear { /// Return the value corresponding to the key in the map, using /// equivalence - pure fn find_equiv<Q:Hash + IterBytes + Equiv<K>>(&self, k: &Q) - -> Option<&'self V> { + fn find_equiv<Q:Hash + IterBytes + Equiv<K>>(&self, k: &Q) + -> Option<&'self V> { match self.bucket_for_key_equiv(k) { FoundEntry(idx) => Some(self.value_for_bucket(idx)), TableFull | FoundHole(_) => None, @@ -518,7 +516,7 @@ pub mod linear { } impl<K:Hash + IterBytes + Eq,V:Eq> Eq for LinearMap<K, V> { - pure fn eq(&self, other: &LinearMap<K, V>) -> bool { + fn eq(&self, other: &LinearMap<K, V>) -> bool { if self.len() != other.len() { return false; } for self.each |&(key, value)| { @@ -531,7 +529,7 @@ pub mod linear { true } - pure fn ne(&self, other: &LinearMap<K, V>) -> bool { !self.eq(other) } + fn ne(&self, other: &LinearMap<K, V>) -> bool { !self.eq(other) } } pub struct LinearSet<T> { @@ -540,25 +538,21 @@ pub mod linear { impl<T:Hash + IterBytes + Eq> BaseIter<T> for LinearSet<T> { /// Visit all values in order - pure fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<T:Hash + IterBytes + Eq> Eq for LinearSet<T> { - pure fn eq(&self, other: &LinearSet<T>) -> bool { - self.map == other.map - } - pure fn ne(&self, other: &LinearSet<T>) -> bool { - self.map != other.map - } + fn eq(&self, other: &LinearSet<T>) -> bool { self.map == other.map } + fn ne(&self, other: &LinearSet<T>) -> bool { self.map != other.map } } impl<T:Hash + IterBytes + Eq> Container for LinearSet<T> { /// Return the number of elements in the set - pure fn len(&const self) -> uint { self.map.len() } + fn len(&const self) -> uint { self.map.len() } /// Return true if the set contains no elements - pure fn is_empty(&const self) -> bool { self.map.is_empty() } + fn is_empty(&const self) -> bool { self.map.is_empty() } } impl<T:Hash + IterBytes + Eq> Mutable for LinearSet<T> { @@ -568,9 +562,7 @@ pub mod linear { impl<T:Hash + IterBytes + Eq> Set<T> for LinearSet<T> { /// Return true if the set contains a value - pure fn contains(&self, value: &T) -> bool { - self.map.contains_key(value) - } + fn contains(&self, value: &T) -> bool { self.map.contains_key(value) } /// Add a value to the set. Return true if the value was not already /// present in the set. @@ -582,22 +574,22 @@ pub mod linear { /// Return true if the set has no elements in common with `other`. /// This is equivalent to checking for an empty intersection. - pure fn is_disjoint(&self, other: &LinearSet<T>) -> bool { + fn is_disjoint(&self, other: &LinearSet<T>) -> bool { iter::all(self, |v| !other.contains(v)) } /// Return true if the set is a subset of another - pure fn is_subset(&self, other: &LinearSet<T>) -> bool { + fn is_subset(&self, other: &LinearSet<T>) -> bool { iter::all(self, |v| other.contains(v)) } /// Return true if the set is a superset of another - pure fn is_superset(&self, other: &LinearSet<T>) -> bool { + fn is_superset(&self, other: &LinearSet<T>) -> bool { other.is_subset(self) } /// Visit the values representing the difference - pure fn difference(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) { + fn difference(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) { for self.each |v| { if !other.contains(v) { if !f(v) { return } @@ -606,16 +598,15 @@ pub mod linear { } /// Visit the values representing the symmetric difference - pure fn symmetric_difference(&self, other: &LinearSet<T>, - f: &fn(&T) -> bool) { + fn symmetric_difference(&self, + other: &LinearSet<T>, + f: &fn(&T) -> bool) { self.difference(other, f); other.difference(self, f); } /// Visit the values representing the intersection - pure fn intersection(&self, - other: &LinearSet<T>, - f: &fn(&T) -> bool) { + fn intersection(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) { for self.each |v| { if other.contains(v) { if !f(v) { return } @@ -624,7 +615,7 @@ pub mod linear { } /// Visit the values representing the union - pure fn union(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) { + fn union(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) { for self.each |v| { if !f(v) { return } } @@ -639,7 +630,7 @@ pub mod linear { pub impl <T:Hash + IterBytes + Eq> LinearSet<T> { /// Create an empty LinearSet - static fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} } + fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} } /// Reserve space for at least `n` elements in the hash table. fn reserve_at_least(&mut self, n: uint) { diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 833eb7d2c77..fb305560ba3 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -646,11 +646,11 @@ impl Reader for BytesReader<'self> { fn tell(&self) -> uint { self.pos } } -pub pure fn with_bytes_reader<t>(bytes: &[u8], f: &fn(@Reader) -> t) -> t { +pub fn with_bytes_reader<t>(bytes: &[u8], f: &fn(@Reader) -> t) -> t { f(@BytesReader { bytes: bytes, pos: 0u } as @Reader) } -pub pure fn with_str_reader<T>(s: &str, f: &fn(@Reader) -> T) -> T { +pub fn with_str_reader<T>(s: &str, f: &fn(@Reader) -> T) -> T { str::byte_slice(s, |bytes| with_bytes_reader(bytes, f)) } @@ -1165,18 +1165,18 @@ impl Writer for BytesWriter { fn get_type(&self) -> WriterType { File } } -pub pure fn BytesWriter() -> BytesWriter { +pub fn BytesWriter() -> BytesWriter { BytesWriter { bytes: ~[], mut pos: 0u } } -pub pure fn with_bytes_writer(f: &fn(@Writer)) -> ~[u8] { +pub fn with_bytes_writer(f: &fn(@Writer)) -> ~[u8] { let wr = @BytesWriter(); f(wr as @Writer); let @BytesWriter{bytes, _} = wr; return bytes; } -pub pure fn with_str_writer(f: &fn(@Writer)) -> ~str { +pub fn with_str_writer(f: &fn(@Writer)) -> ~str { let mut v = with_bytes_writer(f); // FIXME (#3758): This should not be needed. diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 816dc6d2255..f94c62d23ec 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -23,12 +23,12 @@ use vec; pub type InitOp<T> = &'self fn(uint) -> T; pub trait BaseIter<A> { - pure fn each(&self, blk: &fn(v: &A) -> bool); - pure fn size_hint(&self) -> Option<uint>; + fn each(&self, blk: &fn(v: &A) -> bool); + fn size_hint(&self) -> Option<uint>; } pub trait ReverseIter<A>: BaseIter<A> { - pure fn each_reverse(&self, blk: &fn(&A) -> bool); + fn each_reverse(&self, blk: &fn(&A) -> bool); } pub trait MutableIter<A>: BaseIter<A> { @@ -36,41 +36,40 @@ pub trait MutableIter<A>: BaseIter<A> { } pub trait ExtendedIter<A> { - pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool); - pure fn all(&self, blk: &fn(&A) -> bool) -> bool; - pure fn any(&self, blk: &fn(&A) -> bool) -> bool; - pure fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B; - pure fn position(&self, f: &fn(&A) -> bool) -> Option<uint>; - pure fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B]; - pure fn flat_map_to_vec<B,IB: BaseIter<B>>(&self, op: &fn(&A) -> IB) - -> ~[B]; + fn eachi(&self, blk: &fn(uint, v: &A) -> bool); + fn all(&self, blk: &fn(&A) -> bool) -> bool; + fn any(&self, blk: &fn(&A) -> bool) -> bool; + fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B; + fn position(&self, f: &fn(&A) -> bool) -> Option<uint>; + fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B]; + fn flat_map_to_vec<B,IB: BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B]; } pub trait EqIter<A:Eq> { - pure fn contains(&self, x: &A) -> bool; - pure fn count(&self, x: &A) -> uint; + fn contains(&self, x: &A) -> bool; + fn count(&self, x: &A) -> uint; } pub trait Times { - pure fn times(&self, it: &fn() -> bool); + fn times(&self, it: &fn() -> bool); } pub trait CopyableIter<A:Copy> { - pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A]; - pure fn to_vec(&self) -> ~[A]; - pure fn find(&self, p: &fn(&A) -> bool) -> Option<A>; + fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A]; + fn to_vec(&self) -> ~[A]; + fn find(&self, p: &fn(&A) -> bool) -> Option<A>; } pub trait CopyableOrderedIter<A:Copy + Ord> { - pure fn min(&self) -> A; - pure fn max(&self) -> A; + fn min(&self) -> A; + fn max(&self) -> A; } pub trait CopyableNonstrictIter<A:Copy> { // Like "each", but copies out the value. If the receiver is mutated while // iterating over it, the semantics must not be memory-unsafe but are // otherwise undefined. - pure fn each_val(&const self, f: &fn(A) -> bool); + fn each_val(&const self, f: &fn(A) -> bool); } // A trait for sequences that can be built by imperatively pushing elements @@ -89,13 +88,11 @@ pub trait Buildable<A> { * as an argument a function that will push an element * onto the sequence being constructed. */ - static pure fn build_sized(size: uint, - builder: &fn(push: &pure fn(A))) -> Self; + fn build_sized(size: uint, builder: &fn(push: &fn(A))) -> Self; } #[inline(always)] -pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA, - blk: &fn(uint, &A) -> bool) { +pub fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: &fn(uint, &A) -> bool) { let mut i = 0; for self.each |a| { if !blk(i, a) { break; } @@ -104,8 +101,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 { +pub fn all<A,IA:BaseIter<A>>(self: &IA, blk: &fn(&A) -> bool) -> bool { for self.each |a| { if !blk(a) { return false; } } @@ -113,8 +109,7 @@ pub pure fn all<A,IA:BaseIter<A>>(self: &IA, } #[inline(always)] -pub pure fn any<A,IA:BaseIter<A>>(self: &IA, - blk: &fn(&A) -> bool) -> bool { +pub fn any<A,IA:BaseIter<A>>(self: &IA, blk: &fn(&A) -> bool) -> bool { for self.each |a| { if blk(a) { return true; } } @@ -122,8 +117,9 @@ pub pure fn any<A,IA:BaseIter<A>>(self: &IA, } #[inline(always)] -pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>( - self: &IA, prd: &fn(&A) -> bool) -> ~[A] { +pub 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| { for self.each |a| { if prd(a) { push(*a); } @@ -132,9 +128,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] { +pub fn map_to_vec<A,B,IA:BaseIter<A>>(self: &IA, op: &fn(&A) -> B) -> ~[B] { do vec::build_sized_opt(self.size_hint()) |push| { for self.each |a| { push(op(a)); @@ -143,8 +137,9 @@ 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] { +pub fn flat_map_to_vec<A,B,IA:BaseIter<A>,IB:BaseIter<B>>(self: &IA, + op: &fn(&A) -> IB) + -> ~[B] { do vec::build |push| { for self.each |a| { for op(a).each |&b| { @@ -155,9 +150,8 @@ 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 { +pub fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B, blk: &fn(&B, &A) -> B) + -> B { let mut b = b0; for self.each |a| { b = blk(&b, a); @@ -166,12 +160,12 @@ pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B, } #[inline(always)] -pub pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] { +pub 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 { +pub fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool { for self.each |a| { if *a == *x { return true; } } @@ -179,7 +173,7 @@ pub pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool { } #[inline(always)] -pub pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint { +pub fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint { do foldl(self, 0) |count, value| { if *value == *x { *count + 1 @@ -190,9 +184,8 @@ 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> -{ +pub fn position<A,IA:BaseIter<A>>(self: &IA, f: &fn(&A) -> bool) + -> Option<uint> { let mut i = 0; for self.each |a| { if f(a) { return Some(i); } @@ -206,7 +199,7 @@ pub pure fn position<A,IA:BaseIter<A>>(self: &IA, f: &fn(&A) -> bool) // it would have to be implemented with foldr, which is too inefficient. #[inline(always)] -pub pure fn repeat(times: uint, blk: &fn() -> bool) { +pub fn repeat(times: uint, blk: &fn() -> bool) { let mut i = 0; while i < times { if !blk() { break } @@ -215,7 +208,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 { +pub fn min<A:Copy + Ord,IA:BaseIter<A>>(self: &IA) -> A { match do foldl::<A,Option<A>,IA>(self, None) |a, b| { match a { &Some(ref a_) if *a_ < *b => { @@ -230,7 +223,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 { +pub fn max<A:Copy + Ord,IA:BaseIter<A>>(self: &IA) -> A { match do foldl::<A,Option<A>,IA>(self, None) |a, b| { match a { &Some(ref a_) if *a_ > *b => { @@ -245,8 +238,8 @@ 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> { +pub fn find<A:Copy,IA:BaseIter<A>>(self: &IA, f: &fn(&A) -> bool) + -> Option<A> { for self.each |i| { if f(i) { return Some(*i) } } @@ -266,8 +259,7 @@ pub pure fn find<A:Copy,IA:BaseIter<A>>(self: &IA, * onto the sequence being constructed. */ #[inline(always)] -pub pure fn build<A,B: Buildable<A>>(builder: &fn(push: &pure fn(A))) - -> B { +pub fn build<A,B: Buildable<A>>(builder: &fn(push: &fn(A))) -> B { Buildable::build_sized(4, builder) } @@ -285,10 +277,8 @@ pub pure fn build<A,B: Buildable<A>>(builder: &fn(push: &pure fn(A))) * onto the sequence being constructed. */ #[inline(always)] -pub pure fn build_sized_opt<A,B: Buildable<A>>( - size: Option<uint>, - builder: &fn(push: &pure fn(A))) -> B { - +pub fn build_sized_opt<A,B: Buildable<A>>(size: Option<uint>, + builder: &fn(push: &fn(A))) -> B { Buildable::build_sized(size.get_or_default(4), builder) } @@ -312,8 +302,7 @@ pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: &fn(&T) -> U) * 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 { +pub fn from_fn<T,BT: Buildable<T>>(n_elts: uint, op: InitOp<T>) -> BT { do Buildable::build_sized(n_elts) |push| { let mut i: uint = 0u; while i < n_elts { push(op(i)); i += 1u; } @@ -327,8 +316,7 @@ pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint, * to the value `t`. */ #[inline(always)] -pub pure fn from_elem<T:Copy,BT:Buildable<T>>(n_elts: uint, - t: T) -> BT { +pub fn from_elem<T:Copy,BT:Buildable<T>>(n_elts: uint, t: T) -> BT { do Buildable::build_sized(n_elts) |push| { let mut i: uint = 0; while i < n_elts { push(t); i += 1; } @@ -337,8 +325,8 @@ pub pure fn from_elem<T:Copy,BT:Buildable<T>>(n_elts: uint, /// Appends two generic sequences. #[inline(always)] -pub pure fn append<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>( - lhs: &IT, rhs: &IT) -> BT { +pub fn append<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>(lhs: &IT, rhs: &IT) + -> BT { let size_opt = lhs.size_hint().chain_ref( |sz1| rhs.size_hint().map(|sz2| *sz1+*sz2)); do build_sized_opt(size_opt) |push| { @@ -350,8 +338,7 @@ pub pure fn append<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>( /// Copies a generic sequence, possibly converting it to a different /// type of sequence. #[inline(always)] -pub pure fn copy_seq<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>( - v: &IT) -> BT { +pub fn copy_seq<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>(v: &IT) -> BT { do build_sized_opt(v.size_hint()) |push| { for v.each |x| { push(*x); } } diff --git a/src/libcore/managed.rs b/src/libcore/managed.rs index b177dced888..30ebeda3f5c 100644 --- a/src/libcore/managed.rs +++ b/src/libcore/managed.rs @@ -37,13 +37,13 @@ pub mod raw { } #[inline(always)] -pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool { +pub 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)) } } #[inline(always)] -pub pure fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool { +pub fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool { //! Determine if two mutable shared boxes point to the same object unsafe { ptr::addr_of(&(*a)) == ptr::addr_of(&(*b)) } } @@ -51,41 +51,41 @@ pub pure fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool { #[cfg(notest)] impl<T:Eq> Eq for @T { #[inline(always)] - pure fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) } + fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) } #[inline(always)] - pure fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) } + fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) } } #[cfg(notest)] impl<T:Eq> Eq for @mut T { #[inline(always)] - pure fn eq(&self, other: &@mut T) -> bool { *(*self) == *(*other) } + fn eq(&self, other: &@mut T) -> bool { *(*self) == *(*other) } #[inline(always)] - pure fn ne(&self, other: &@mut T) -> bool { *(*self) != *(*other) } + fn ne(&self, other: &@mut T) -> bool { *(*self) != *(*other) } } #[cfg(notest)] impl<T:Ord> Ord for @T { #[inline(always)] - pure fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) } + fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) } #[inline(always)] - pure fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) } + fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) } #[inline(always)] - pure fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) } + fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) } #[inline(always)] - pure fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) } + fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) } } #[cfg(notest)] impl<T:Ord> Ord for @mut T { #[inline(always)] - pure fn lt(&self, other: &@mut T) -> bool { *(*self) < *(*other) } + fn lt(&self, other: &@mut T) -> bool { *(*self) < *(*other) } #[inline(always)] - pure fn le(&self, other: &@mut T) -> bool { *(*self) <= *(*other) } + fn le(&self, other: &@mut T) -> bool { *(*self) <= *(*other) } #[inline(always)] - pure fn ge(&self, other: &@mut T) -> bool { *(*self) >= *(*other) } + fn ge(&self, other: &@mut T) -> bool { *(*self) >= *(*other) } #[inline(always)] - pure fn gt(&self, other: &@mut T) -> bool { *(*self) > *(*other) } + fn gt(&self, other: &@mut T) -> bool { *(*self) > *(*other) } } #[test] diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs index d0aa6e050f5..fc4e52891dd 100644 --- a/src/libcore/mutable.rs +++ b/src/libcore/mutable.rs @@ -55,7 +55,7 @@ pub impl<T> Data<T> { } } - pure fn borrow_const<R>(&self, op: &fn(t: &const T) -> R) -> R { + fn borrow_const<R>(&self, op: &fn(t: &const T) -> R) -> R { op(&const self.value) } diff --git a/src/libcore/nil.rs b/src/libcore/nil.rs index 742e5a047d6..8c52ac9593a 100644 --- a/src/libcore/nil.rs +++ b/src/libcore/nil.rs @@ -20,25 +20,25 @@ use cmp::{Eq, Ord, TotalOrd, Ordering, Equal}; #[cfg(notest)] impl Eq for () { #[inline(always)] - pure fn eq(&self, _other: &()) -> bool { true } + fn eq(&self, _other: &()) -> bool { true } #[inline(always)] - pure fn ne(&self, _other: &()) -> bool { false } + fn ne(&self, _other: &()) -> bool { false } } #[cfg(notest)] impl Ord for () { #[inline(always)] - pure fn lt(&self, _other: &()) -> bool { false } + fn lt(&self, _other: &()) -> bool { false } #[inline(always)] - pure fn le(&self, _other: &()) -> bool { true } + fn le(&self, _other: &()) -> bool { true } #[inline(always)] - pure fn ge(&self, _other: &()) -> bool { true } + fn ge(&self, _other: &()) -> bool { true } #[inline(always)] - pure fn gt(&self, _other: &()) -> bool { false } + fn gt(&self, _other: &()) -> bool { false } } #[cfg(notest)] impl TotalOrd for () { #[inline(always)] - pure fn cmp(&self, _other: &()) -> Ordering { Equal } + fn cmp(&self, _other: &()) -> Ordering { Equal } } diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 54521abea9e..719e5620d02 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -33,7 +33,7 @@ macro_rules! delegate( ),* ) -> $rv:ty = $bound_name:path ) => ( - pub pure fn $name($( $arg : $arg_ty ),*) -> $rv { + pub fn $name($( $arg : $arg_ty ),*) -> $rv { unsafe { $bound_name($( $arg ),*) } @@ -109,57 +109,59 @@ 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 } +pub fn is_NaN(f: f32) -> bool { f != f } #[inline(always)] -pub pure fn add(x: f32, y: f32) -> f32 { return x + y; } +pub fn add(x: f32, y: f32) -> f32 { return x + y; } #[inline(always)] -pub pure fn sub(x: f32, y: f32) -> f32 { return x - y; } +pub fn sub(x: f32, y: f32) -> f32 { return x - y; } #[inline(always)] -pub pure fn mul(x: f32, y: f32) -> f32 { return x * y; } +pub fn mul(x: f32, y: f32) -> f32 { return x * y; } #[inline(always)] -pub pure fn div(x: f32, y: f32) -> f32 { return x / y; } +pub fn div(x: f32, y: f32) -> f32 { return x / y; } #[inline(always)] -pub pure fn rem(x: f32, y: f32) -> f32 { return x % y; } +pub fn rem(x: f32, y: f32) -> f32 { return x % y; } #[inline(always)] -pub pure fn lt(x: f32, y: f32) -> bool { return x < y; } +pub fn lt(x: f32, y: f32) -> bool { return x < y; } #[inline(always)] -pub pure fn le(x: f32, y: f32) -> bool { return x <= y; } +pub fn le(x: f32, y: f32) -> bool { return x <= y; } #[inline(always)] -pub pure fn eq(x: f32, y: f32) -> bool { return x == y; } +pub fn eq(x: f32, y: f32) -> bool { return x == y; } #[inline(always)] -pub pure fn ne(x: f32, y: f32) -> bool { return x != y; } +pub fn ne(x: f32, y: f32) -> bool { return x != y; } #[inline(always)] -pub pure fn ge(x: f32, y: f32) -> bool { return x >= y; } +pub fn ge(x: f32, y: f32) -> bool { return x >= y; } #[inline(always)] -pub pure fn gt(x: f32, y: f32) -> bool { return x > y; } +pub fn gt(x: f32, y: f32) -> bool { return x > y; } /// Returns `x` rounded down #[inline(always)] -pub pure fn floor(x: f32) -> f32 { unsafe { floorf32(x) } } +pub fn floor(x: f32) -> f32 { unsafe { floorf32(x) } } // 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; } +pub fn is_positive(x: f32) -> bool { + 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; } +pub fn is_negative(x: f32) -> bool { + x < 0.0f32 || (1.0f32/x) == neg_infinity +} /** * Returns true if `x` is a negative number, including -0.0f320 and -Infinity @@ -167,7 +169,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 { +pub fn is_nonpositive(x: f32) -> bool { return x < 0.0f32 || (1.0f32/x) == neg_infinity; } @@ -177,25 +179,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 { +pub 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 { +pub 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 { +pub 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 { +pub fn is_finite(x: f32) -> bool { return !(is_NaN(x) || is_infinite(x)); } @@ -246,43 +248,43 @@ pub mod consts { } #[inline(always)] -pub pure fn signbit(x: f32) -> int { +pub 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 { +pub fn logarithm(n: f32, b: f32) -> f32 { return log2(n) / log2(b); } #[cfg(notest)] impl cmp::Eq for f32 { #[inline(always)] - pure fn eq(&self, other: &f32) -> bool { (*self) == (*other) } + fn eq(&self, other: &f32) -> bool { (*self) == (*other) } #[inline(always)] - pure fn ne(&self, other: &f32) -> bool { (*self) != (*other) } + fn ne(&self, other: &f32) -> bool { (*self) != (*other) } } #[cfg(notest)] impl cmp::Ord for f32 { #[inline(always)] - pure fn lt(&self, other: &f32) -> bool { (*self) < (*other) } + fn lt(&self, other: &f32) -> bool { (*self) < (*other) } #[inline(always)] - pure fn le(&self, other: &f32) -> bool { (*self) <= (*other) } + fn le(&self, other: &f32) -> bool { (*self) <= (*other) } #[inline(always)] - pure fn ge(&self, other: &f32) -> bool { (*self) >= (*other) } + fn ge(&self, other: &f32) -> bool { (*self) >= (*other) } #[inline(always)] - pure fn gt(&self, other: &f32) -> bool { (*self) > (*other) } + fn gt(&self, other: &f32) -> bool { (*self) > (*other) } } impl num::Zero for f32 { #[inline(always)] - static pure fn zero() -> f32 { 0.0 } + fn zero() -> f32 { 0.0 } } impl num::One for f32 { #[inline(always)] - static pure fn one() -> f32 { 1.0 } + fn one() -> f32 { 1.0 } } impl NumCast for f32 { @@ -290,53 +292,53 @@ impl NumCast for f32 { * Cast `n` to an `f32` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> f32 { n.to_f32() } + fn from<N:NumCast>(n: N) -> f32 { n.to_f32() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[cfg(notest)] impl ops::Add<f32,f32> for f32 { - pure fn add(&self, other: &f32) -> f32 { *self + *other } + fn add(&self, other: &f32) -> f32 { *self + *other } } #[cfg(notest)] impl ops::Sub<f32,f32> for f32 { - pure fn sub(&self, other: &f32) -> f32 { *self - *other } + fn sub(&self, other: &f32) -> f32 { *self - *other } } #[cfg(notest)] impl ops::Mul<f32,f32> for f32 { - pure fn mul(&self, other: &f32) -> f32 { *self * *other } + fn mul(&self, other: &f32) -> f32 { *self * *other } } #[cfg(notest)] impl ops::Div<f32,f32> for f32 { - pure fn div(&self, other: &f32) -> f32 { *self / *other } + fn div(&self, other: &f32) -> f32 { *self / *other } } #[cfg(notest)] impl ops::Modulo<f32,f32> for f32 { - pure fn modulo(&self, other: &f32) -> f32 { *self % *other } + fn modulo(&self, other: &f32) -> f32 { *self % *other } } #[cfg(notest)] impl ops::Neg<f32> for f32 { - pure fn neg(&self) -> f32 { -*self } + fn neg(&self) -> f32 { -*self } } impl num::Round for f32 { #[inline(always)] - pure fn round(&self, mode: num::RoundMode) -> f32 { + fn round(&self, mode: num::RoundMode) -> f32 { match mode { num::RoundDown => floor(*self), num::RoundUp => ceil(*self), @@ -348,11 +350,11 @@ impl num::Round for f32 { } #[inline(always)] - pure fn floor(&self) -> f32 { floor(*self) } + fn floor(&self) -> f32 { floor(*self) } #[inline(always)] - pure fn ceil(&self) -> f32 { ceil(*self) } + fn ceil(&self) -> f32 { ceil(*self) } #[inline(always)] - pure fn fract(&self) -> f32 { + fn fract(&self) -> f32 { if is_negative(*self) { (*self) - ceil(*self) } else { @@ -373,7 +375,7 @@ impl num::Round for f32 { * * num - The float value */ #[inline(always)] -pub pure fn to_str(num: f32) -> ~str { +pub fn to_str(num: f32) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigAll); r @@ -387,7 +389,7 @@ pub pure fn to_str(num: f32) -> ~str { * * num - The float value */ #[inline(always)] -pub pure fn to_str_hex(num: f32) -> ~str { +pub fn to_str_hex(num: f32) -> ~str { let (r, _) = strconv::to_str_common( &num, 16u, true, strconv::SignNeg, strconv::DigAll); r @@ -408,7 +410,7 @@ pub pure fn to_str_hex(num: f32) -> ~str { * are expected, use `to_str_radix_special()` instead. */ #[inline(always)] -pub pure fn to_str_radix(num: f32, rdx: uint) -> ~str { +pub fn to_str_radix(num: f32, rdx: uint) -> ~str { let (r, special) = strconv::to_str_common( &num, rdx, true, strconv::SignNeg, strconv::DigAll); if special { fail!(~"number has a special value, \ @@ -426,7 +428,7 @@ pub pure fn to_str_radix(num: f32, rdx: uint) -> ~str { * * radix - The base to use */ #[inline(always)] -pub pure fn to_str_radix_special(num: f32, rdx: uint) -> (~str, bool) { +pub fn to_str_radix_special(num: f32, rdx: uint) -> (~str, bool) { strconv::to_str_common(&num, rdx, true, strconv::SignNeg, strconv::DigAll) } @@ -441,7 +443,7 @@ pub pure fn to_str_radix_special(num: f32, rdx: uint) -> (~str, bool) { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_exact(num: f32, dig: uint) -> ~str { +pub fn to_str_exact(num: f32, dig: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigExact(dig)); r @@ -457,7 +459,7 @@ pub pure fn to_str_exact(num: f32, dig: uint) -> ~str { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_digits(num: f32, dig: uint) -> ~str { +pub fn to_str_digits(num: f32, dig: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigMax(dig)); r @@ -465,12 +467,12 @@ pub pure fn to_str_digits(num: f32, dig: uint) -> ~str { impl to_str::ToStr for f32 { #[inline(always)] - pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) } + fn to_str(&self) -> ~str { to_str_digits(*self, 8) } } impl num::ToStrRadix for f32 { #[inline(always)] - pure fn to_str_radix(&self, rdx: uint) -> ~str { + fn to_str_radix(&self, rdx: uint) -> ~str { to_str_radix(*self, rdx) } } @@ -503,7 +505,7 @@ impl num::ToStrRadix for f32 { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str(num: &str) -> Option<f32> { +pub fn from_str(num: &str) -> Option<f32> { strconv::from_str_common(num, 10u, true, true, true, strconv::ExpDec, false) } @@ -536,7 +538,7 @@ pub pure fn from_str(num: &str) -> Option<f32> { * `Some(n)` where `n` is the floating-point number represented by `[num]`. */ #[inline(always)] -pub pure fn from_str_hex(num: &str) -> Option<f32> { +pub fn from_str_hex(num: &str) -> Option<f32> { strconv::from_str_common(num, 16u, true, true, true, strconv::ExpBin, false) } @@ -561,19 +563,19 @@ pub pure fn from_str_hex(num: &str) -> Option<f32> { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f32> { +pub fn from_str_radix(num: &str, rdx: uint) -> Option<f32> { strconv::from_str_common(num, rdx, true, true, false, strconv::ExpNone, false) } impl from_str::FromStr for f32 { #[inline(always)] - static pure fn from_str(val: &str) -> Option<f32> { from_str(val) } + fn from_str(val: &str) -> Option<f32> { from_str(val) } } impl num::FromStrRadix for f32 { #[inline(always)] - static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f32> { + fn from_str_radix(val: &str, rdx: uint) -> Option<f32> { from_str_radix(val, rdx) } } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index a2cf629dc9f..6a581ddfa94 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -34,7 +34,7 @@ macro_rules! delegate( ),* ) -> $rv:ty = $bound_name:path ) => ( - pub pure fn $name($( $arg : $arg_ty ),*) -> $rv { + pub fn $name($( $arg : $arg_ty ),*) -> $rv { unsafe { $bound_name($( $arg ),*) } @@ -136,49 +136,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 } +pub fn is_NaN(f: f64) -> bool { f != f } #[inline(always)] -pub pure fn add(x: f64, y: f64) -> f64 { return x + y; } +pub fn add(x: f64, y: f64) -> f64 { return x + y; } #[inline(always)] -pub pure fn sub(x: f64, y: f64) -> f64 { return x - y; } +pub fn sub(x: f64, y: f64) -> f64 { return x - y; } #[inline(always)] -pub pure fn mul(x: f64, y: f64) -> f64 { return x * y; } +pub fn mul(x: f64, y: f64) -> f64 { return x * y; } #[inline(always)] -pub pure fn div(x: f64, y: f64) -> f64 { return x / y; } +pub fn div(x: f64, y: f64) -> f64 { return x / y; } #[inline(always)] -pub pure fn rem(x: f64, y: f64) -> f64 { return x % y; } +pub fn rem(x: f64, y: f64) -> f64 { return x % y; } #[inline(always)] -pub pure fn lt(x: f64, y: f64) -> bool { return x < y; } +pub fn lt(x: f64, y: f64) -> bool { return x < y; } #[inline(always)] -pub pure fn le(x: f64, y: f64) -> bool { return x <= y; } +pub fn le(x: f64, y: f64) -> bool { return x <= y; } #[inline(always)] -pub pure fn eq(x: f64, y: f64) -> bool { return x == y; } +pub fn eq(x: f64, y: f64) -> bool { return x == y; } #[inline(always)] -pub pure fn ne(x: f64, y: f64) -> bool { return x != y; } +pub fn ne(x: f64, y: f64) -> bool { return x != y; } #[inline(always)] -pub pure fn ge(x: f64, y: f64) -> bool { return x >= y; } +pub fn ge(x: f64, y: f64) -> bool { return x >= y; } #[inline(always)] -pub pure fn gt(x: f64, y: f64) -> bool { return x > y; } +pub 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 +pub 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 +pub fn is_negative(x: f64) -> bool { return x < 0.0f64 || (1.0f64/x) == neg_infinity; } /** @@ -187,7 +187,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 { +pub fn is_nonpositive(x: f64) -> bool { return x < 0.0f64 || (1.0f64/x) == neg_infinity; } @@ -197,31 +197,31 @@ 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 { +pub 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 { +pub 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 { +pub 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 { +pub fn is_finite(x: f64) -> bool { return !(is_NaN(x) || is_infinite(x)); } /// Returns `x` rounded down #[inline(always)] -pub pure fn floor(x: f64) -> f64 { unsafe { floorf64(x) } } +pub fn floor(x: f64) -> f64 { unsafe { floorf64(x) } } // FIXME (#1999): add is_normal, is_subnormal, and fpclassify @@ -270,33 +270,33 @@ pub mod consts { } #[inline(always)] -pub pure fn signbit(x: f64) -> int { +pub 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 { +pub fn logarithm(n: f64, b: f64) -> f64 { return log2(n) / log2(b); } #[cfg(notest)] impl cmp::Eq for f64 { #[inline(always)] - pure fn eq(&self, other: &f64) -> bool { (*self) == (*other) } + fn eq(&self, other: &f64) -> bool { (*self) == (*other) } #[inline(always)] - pure fn ne(&self, other: &f64) -> bool { (*self) != (*other) } + fn ne(&self, other: &f64) -> bool { (*self) != (*other) } } #[cfg(notest)] impl cmp::Ord for f64 { #[inline(always)] - pure fn lt(&self, other: &f64) -> bool { (*self) < (*other) } + fn lt(&self, other: &f64) -> bool { (*self) < (*other) } #[inline(always)] - pure fn le(&self, other: &f64) -> bool { (*self) <= (*other) } + fn le(&self, other: &f64) -> bool { (*self) <= (*other) } #[inline(always)] - pure fn ge(&self, other: &f64) -> bool { (*self) >= (*other) } + fn ge(&self, other: &f64) -> bool { (*self) >= (*other) } #[inline(always)] - pure fn gt(&self, other: &f64) -> bool { (*self) > (*other) } + fn gt(&self, other: &f64) -> bool { (*self) > (*other) } } impl NumCast for f64 { @@ -304,63 +304,63 @@ impl NumCast for f64 { * Cast `n` to an `f64` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> f64 { n.to_f64() } + fn from<N:NumCast>(n: N) -> f64 { n.to_f64() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self } + #[inline(always)] fn to_float(&self) -> float { *self as float } } impl num::Zero for f64 { #[inline(always)] - static pure fn zero() -> f64 { 0.0 } + fn zero() -> f64 { 0.0 } } impl num::One for f64 { #[inline(always)] - static pure fn one() -> f64 { 1.0 } + fn one() -> f64 { 1.0 } } #[cfg(notest)] impl ops::Add<f64,f64> for f64 { - pure fn add(&self, other: &f64) -> f64 { *self + *other } + fn add(&self, other: &f64) -> f64 { *self + *other } } #[cfg(notest)] impl ops::Sub<f64,f64> for f64 { - pure fn sub(&self, other: &f64) -> f64 { *self - *other } + fn sub(&self, other: &f64) -> f64 { *self - *other } } #[cfg(notest)] impl ops::Mul<f64,f64> for f64 { - pure fn mul(&self, other: &f64) -> f64 { *self * *other } + fn mul(&self, other: &f64) -> f64 { *self * *other } } #[cfg(notest)] impl ops::Div<f64,f64> for f64 { - pure fn div(&self, other: &f64) -> f64 { *self / *other } + fn div(&self, other: &f64) -> f64 { *self / *other } } #[cfg(notest)] impl ops::Modulo<f64,f64> for f64 { - pure fn modulo(&self, other: &f64) -> f64 { *self % *other } + fn modulo(&self, other: &f64) -> f64 { *self % *other } } #[cfg(notest)] impl ops::Neg<f64> for f64 { - pure fn neg(&self) -> f64 { -*self } + fn neg(&self) -> f64 { -*self } } impl num::Round for f64 { #[inline(always)] - pure fn round(&self, mode: num::RoundMode) -> f64 { + fn round(&self, mode: num::RoundMode) -> f64 { match mode { num::RoundDown => floor(*self), num::RoundUp => ceil(*self), @@ -372,11 +372,11 @@ impl num::Round for f64 { } #[inline(always)] - pure fn floor(&self) -> f64 { floor(*self) } + fn floor(&self) -> f64 { floor(*self) } #[inline(always)] - pure fn ceil(&self) -> f64 { ceil(*self) } + fn ceil(&self) -> f64 { ceil(*self) } #[inline(always)] - pure fn fract(&self) -> f64 { + fn fract(&self) -> f64 { if is_negative(*self) { (*self) - ceil(*self) } else { @@ -397,7 +397,7 @@ impl num::Round for f64 { * * num - The float value */ #[inline(always)] -pub pure fn to_str(num: f64) -> ~str { +pub fn to_str(num: f64) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigAll); r @@ -411,7 +411,7 @@ pub pure fn to_str(num: f64) -> ~str { * * num - The float value */ #[inline(always)] -pub pure fn to_str_hex(num: f64) -> ~str { +pub fn to_str_hex(num: f64) -> ~str { let (r, _) = strconv::to_str_common( &num, 16u, true, strconv::SignNeg, strconv::DigAll); r @@ -432,7 +432,7 @@ pub pure fn to_str_hex(num: f64) -> ~str { * are expected, use `to_str_radix_special()` instead. */ #[inline(always)] -pub pure fn to_str_radix(num: f64, rdx: uint) -> ~str { +pub fn to_str_radix(num: f64, rdx: uint) -> ~str { let (r, special) = strconv::to_str_common( &num, rdx, true, strconv::SignNeg, strconv::DigAll); if special { fail!(~"number has a special value, \ @@ -450,7 +450,7 @@ pub pure fn to_str_radix(num: f64, rdx: uint) -> ~str { * * radix - The base to use */ #[inline(always)] -pub pure fn to_str_radix_special(num: f64, rdx: uint) -> (~str, bool) { +pub fn to_str_radix_special(num: f64, rdx: uint) -> (~str, bool) { strconv::to_str_common(&num, rdx, true, strconv::SignNeg, strconv::DigAll) } @@ -465,7 +465,7 @@ pub pure fn to_str_radix_special(num: f64, rdx: uint) -> (~str, bool) { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_exact(num: f64, dig: uint) -> ~str { +pub fn to_str_exact(num: f64, dig: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigExact(dig)); r @@ -481,7 +481,7 @@ pub pure fn to_str_exact(num: f64, dig: uint) -> ~str { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_digits(num: f64, dig: uint) -> ~str { +pub fn to_str_digits(num: f64, dig: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigMax(dig)); r @@ -489,12 +489,12 @@ pub pure fn to_str_digits(num: f64, dig: uint) -> ~str { impl to_str::ToStr for f64 { #[inline(always)] - pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) } + fn to_str(&self) -> ~str { to_str_digits(*self, 8) } } impl num::ToStrRadix for f64 { #[inline(always)] - pure fn to_str_radix(&self, rdx: uint) -> ~str { + fn to_str_radix(&self, rdx: uint) -> ~str { to_str_radix(*self, rdx) } } @@ -527,7 +527,7 @@ impl num::ToStrRadix for f64 { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str(num: &str) -> Option<f64> { +pub fn from_str(num: &str) -> Option<f64> { strconv::from_str_common(num, 10u, true, true, true, strconv::ExpDec, false) } @@ -560,7 +560,7 @@ pub pure fn from_str(num: &str) -> Option<f64> { * `Some(n)` where `n` is the floating-point number represented by `[num]`. */ #[inline(always)] -pub pure fn from_str_hex(num: &str) -> Option<f64> { +pub fn from_str_hex(num: &str) -> Option<f64> { strconv::from_str_common(num, 16u, true, true, true, strconv::ExpBin, false) } @@ -585,19 +585,19 @@ pub pure fn from_str_hex(num: &str) -> Option<f64> { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f64> { +pub fn from_str_radix(num: &str, rdx: uint) -> Option<f64> { strconv::from_str_common(num, rdx, true, true, false, strconv::ExpNone, false) } impl from_str::FromStr for f64 { #[inline(always)] - static pure fn from_str(val: &str) -> Option<f64> { from_str(val) } + fn from_str(val: &str) -> Option<f64> { from_str(val) } } impl num::FromStrRadix for f64 { #[inline(always)] - static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f64> { + fn from_str_radix(val: &str, rdx: uint) -> Option<f64> { from_str_radix(val, rdx) } } diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs index 1cceddf51a1..4e9a1b62b6e 100644 --- a/src/libcore/num/float.rs +++ b/src/libcore/num/float.rs @@ -103,7 +103,7 @@ pub mod consts { * * num - The float value */ #[inline(always)] -pub pure fn to_str(num: float) -> ~str { +pub fn to_str(num: float) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigAll); r @@ -117,7 +117,7 @@ pub pure fn to_str(num: float) -> ~str { * * num - The float value */ #[inline(always)] -pub pure fn to_str_hex(num: float) -> ~str { +pub fn to_str_hex(num: float) -> ~str { let (r, _) = strconv::to_str_common( &num, 16u, true, strconv::SignNeg, strconv::DigAll); r @@ -138,7 +138,7 @@ pub pure fn to_str_hex(num: float) -> ~str { * are expected, use `to_str_radix_special()` instead. */ #[inline(always)] -pub pure fn to_str_radix(num: float, radix: uint) -> ~str { +pub fn to_str_radix(num: float, radix: uint) -> ~str { let (r, special) = strconv::to_str_common( &num, radix, true, strconv::SignNeg, strconv::DigAll); if special { fail!(~"number has a special value, \ @@ -156,7 +156,7 @@ pub pure fn to_str_radix(num: float, radix: uint) -> ~str { * * radix - The base to use */ #[inline(always)] -pub pure fn to_str_radix_special(num: float, radix: uint) -> (~str, bool) { +pub fn to_str_radix_special(num: float, radix: uint) -> (~str, bool) { strconv::to_str_common(&num, radix, true, strconv::SignNeg, strconv::DigAll) } @@ -171,7 +171,7 @@ pub pure fn to_str_radix_special(num: float, radix: uint) -> (~str, bool) { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_exact(num: float, digits: uint) -> ~str { +pub fn to_str_exact(num: float, digits: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigExact(digits)); r @@ -193,7 +193,7 @@ pub fn test_to_str_exact_do_decimal() { * * digits - The number of significant digits */ #[inline(always)] -pub pure fn to_str_digits(num: float, digits: uint) -> ~str { +pub fn to_str_digits(num: float, digits: uint) -> ~str { let (r, _) = strconv::to_str_common( &num, 10u, true, strconv::SignNeg, strconv::DigMax(digits)); r @@ -201,12 +201,12 @@ pub pure fn to_str_digits(num: float, digits: uint) -> ~str { impl to_str::ToStr for float { #[inline(always)] - pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) } + fn to_str(&self) -> ~str { to_str_digits(*self, 8) } } impl num::ToStrRadix for float { #[inline(always)] - pure fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> ~str { to_str_radix(*self, radix) } } @@ -239,7 +239,7 @@ impl num::ToStrRadix for float { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str(num: &str) -> Option<float> { +pub fn from_str(num: &str) -> Option<float> { strconv::from_str_common(num, 10u, true, true, true, strconv::ExpDec, false) } @@ -272,7 +272,7 @@ pub pure fn from_str(num: &str) -> Option<float> { * `Some(n)` where `n` is the floating-point number represented by `[num]`. */ #[inline(always)] -pub pure fn from_str_hex(num: &str) -> Option<float> { +pub fn from_str_hex(num: &str) -> Option<float> { strconv::from_str_common(num, 16u, true, true, true, strconv::ExpBin, false) } @@ -297,19 +297,19 @@ pub pure fn from_str_hex(num: &str) -> Option<float> { * `Some(n)` where `n` is the floating-point number represented by `num`. */ #[inline(always)] -pub pure fn from_str_radix(num: &str, radix: uint) -> Option<float> { +pub fn from_str_radix(num: &str, radix: uint) -> Option<float> { strconv::from_str_common(num, radix, true, true, false, strconv::ExpNone, false) } impl from_str::FromStr for float { #[inline(always)] - static pure fn from_str(val: &str) -> Option<float> { from_str(val) } + fn from_str(val: &str) -> Option<float> { from_str(val) } } impl num::FromStrRadix for float { #[inline(always)] - static pure fn from_str_radix(val: &str, radix: uint) -> Option<float> { + fn from_str_radix(val: &str, radix: uint) -> Option<float> { from_str_radix(val, radix) } } @@ -330,7 +330,7 @@ impl num::FromStrRadix for float { * * `NaN` if both `x` and `pow` are `0u`, otherwise `x^pow` */ -pub pure fn pow_with_uint(base: uint, pow: uint) -> float { +pub fn pow_with_uint(base: uint, pow: uint) -> float { if base == 0u { if pow == 0u { return NaN as float; @@ -351,69 +351,69 @@ pub pure fn pow_with_uint(base: uint, pow: uint) -> float { } #[inline(always)] -pub pure fn is_positive(x: float) -> bool { f64::is_positive(x as f64) } +pub 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) } +pub 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) } +pub 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) } +pub 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) } +pub 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) } +pub 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) } +pub 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) } +pub fn is_NaN(x: float) -> bool { f64::is_NaN(x as f64) } #[inline(always)] -pub pure fn abs(x: float) -> float { +pub fn abs(x: float) -> float { unsafe { f64::abs(x as f64) as float } } #[inline(always)] -pub pure fn sqrt(x: float) -> float { +pub fn sqrt(x: float) -> float { unsafe { f64::sqrt(x as f64) as float } } #[inline(always)] -pub pure fn atan(x: float) -> float { +pub fn atan(x: float) -> float { unsafe { f64::atan(x as f64) as float } } #[inline(always)] -pub pure fn sin(x: float) -> float { +pub fn sin(x: float) -> float { unsafe { f64::sin(x as f64) as float } } #[inline(always)] -pub pure fn cos(x: float) -> float { +pub fn cos(x: float) -> float { unsafe { f64::cos(x as f64) as float } } #[inline(always)] -pub pure fn tan(x: float) -> float { +pub fn tan(x: float) -> float { unsafe { f64::tan(x as f64) as float } } #[cfg(notest)] impl Eq for float { - pure fn eq(&self, other: &float) -> bool { (*self) == (*other) } - pure fn ne(&self, other: &float) -> bool { (*self) != (*other) } + fn eq(&self, other: &float) -> bool { (*self) == (*other) } + fn ne(&self, other: &float) -> bool { (*self) != (*other) } } #[cfg(notest)] impl Ord for float { - pure fn lt(&self, other: &float) -> bool { (*self) < (*other) } - pure fn le(&self, other: &float) -> bool { (*self) <= (*other) } - pure fn ge(&self, other: &float) -> bool { (*self) >= (*other) } - pure fn gt(&self, other: &float) -> bool { (*self) > (*other) } + fn lt(&self, other: &float) -> bool { (*self) < (*other) } + fn le(&self, other: &float) -> bool { (*self) <= (*other) } + fn ge(&self, other: &float) -> bool { (*self) >= (*other) } + fn gt(&self, other: &float) -> bool { (*self) > (*other) } } impl num::Zero for float { #[inline(always)] - static pure fn zero() -> float { 0.0 } + fn zero() -> float { 0.0 } } impl num::One for float { #[inline(always)] - static pure fn one() -> float { 1.0 } + fn one() -> float { 1.0 } } impl NumCast for float { @@ -421,28 +421,28 @@ impl NumCast for float { * Cast `n` to a `float` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> float { n.to_float() } + fn from<N:NumCast>(n: N) -> float { n.to_float() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self } } impl num::Round for float { #[inline(always)] - pure fn round(&self, mode: num::RoundMode) -> float { + fn round(&self, mode: num::RoundMode) -> float { match mode { num::RoundDown => f64::floor(*self as f64) as float, @@ -460,11 +460,11 @@ impl num::Round for float { } #[inline(always)] - pure fn floor(&self) -> float { f64::floor(*self as f64) as float} + fn floor(&self) -> float { f64::floor(*self as f64) as float} #[inline(always)] - pure fn ceil(&self) -> float { f64::ceil(*self as f64) as float} + fn ceil(&self) -> float { f64::ceil(*self as f64) as float} #[inline(always)] - pure fn fract(&self) -> float { + fn fract(&self) -> float { if is_negative(*self) { (*self) - (f64::ceil(*self as f64) as float) } else { @@ -475,27 +475,27 @@ impl num::Round for float { #[cfg(notest)] impl ops::Add<float,float> for float { - pure fn add(&self, other: &float) -> float { *self + *other } + fn add(&self, other: &float) -> float { *self + *other } } #[cfg(notest)] impl ops::Sub<float,float> for float { - pure fn sub(&self, other: &float) -> float { *self - *other } + fn sub(&self, other: &float) -> float { *self - *other } } #[cfg(notest)] impl ops::Mul<float,float> for float { - pure fn mul(&self, other: &float) -> float { *self * *other } + fn mul(&self, other: &float) -> float { *self * *other } } #[cfg(notest)] impl ops::Div<float,float> for float { - pure fn div(&self, other: &float) -> float { *self / *other } + fn div(&self, other: &float) -> float { *self / *other } } #[cfg(notest)] impl ops::Modulo<float,float> for float { - pure fn modulo(&self, other: &float) -> float { *self % *other } + fn modulo(&self, other: &float) -> float { *self % *other } } #[cfg(notest)] impl ops::Neg<float> for float { - pure fn neg(&self) -> float { -*self } + fn neg(&self) -> float { -*self } } #[test] diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs index cef8542823a..4d5ac92311e 100644 --- a/src/libcore/num/int-template.rs +++ b/src/libcore/num/int-template.rs @@ -28,13 +28,13 @@ 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 add(x: T, y: T) -> T { x + y } +pub fn add(x: T, y: T) -> T { x + y } #[inline(always)] -pub pure fn sub(x: T, y: T) -> T { x - y } +pub fn sub(x: T, y: T) -> T { x - y } #[inline(always)] -pub pure fn mul(x: T, y: T) -> T { x * y } +pub fn mul(x: T, y: T) -> T { x * y } #[inline(always)] -pub pure fn div(x: T, y: T) -> T { x / y } +pub fn div(x: T, y: T) -> T { x / y } /** * Returns the remainder of y / x. @@ -57,29 +57,29 @@ pub pure fn div(x: T, y: T) -> T { x / y } * */ #[inline(always)] -pub pure fn rem(x: T, y: T) -> T { x % y } +pub fn rem(x: T, y: T) -> T { x % y } #[inline(always)] -pub pure fn lt(x: T, y: T) -> bool { x < y } +pub fn lt(x: T, y: T) -> bool { x < y } #[inline(always)] -pub pure fn le(x: T, y: T) -> bool { x <= y } +pub fn le(x: T, y: T) -> bool { x <= y } #[inline(always)] -pub pure fn eq(x: T, y: T) -> bool { x == y } +pub fn eq(x: T, y: T) -> bool { x == y } #[inline(always)] -pub pure fn ne(x: T, y: T) -> bool { x != y } +pub fn ne(x: T, y: T) -> bool { x != y } #[inline(always)] -pub pure fn ge(x: T, y: T) -> bool { x >= y } +pub fn ge(x: T, y: T) -> bool { x >= y } #[inline(always)] -pub pure fn gt(x: T, y: T) -> bool { x > y } +pub fn gt(x: T, y: T) -> bool { x > y } #[inline(always)] -pub pure fn is_positive(x: T) -> bool { x > 0 as T } +pub fn is_positive(x: T) -> bool { x > 0 as T } #[inline(always)] -pub pure fn is_negative(x: T) -> bool { x < 0 as T } +pub fn is_negative(x: T) -> bool { x < 0 as T } #[inline(always)] -pub pure fn is_nonpositive(x: T) -> bool { x <= 0 as T } +pub fn is_nonpositive(x: T) -> bool { x <= 0 as T } #[inline(always)] -pub pure fn is_nonnegative(x: T) -> bool { x >= 0 as T } +pub fn is_nonnegative(x: T) -> bool { x >= 0 as T } /** * Iterate over the range [`lo`..`hi`) @@ -100,7 +100,7 @@ pub pure fn is_nonnegative(x: T) -> bool { x >= 0 as T } */ #[inline(always)] /// Iterate over the range [`start`,`start`+`step`..`stop`) -pub pure fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) { +pub fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) { let mut i = start; if step == 0 { fail!(~"range_step called with step == 0"); @@ -119,116 +119,116 @@ pub pure fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) { #[inline(always)] /// Iterate over the range [`lo`..`hi`) -pub pure fn range(lo: T, hi: T, it: &fn(T) -> bool) { +pub fn range(lo: T, hi: T, it: &fn(T) -> bool) { range_step(lo, hi, 1 as T, it); } #[inline(always)] /// Iterate over the range [`hi`..`lo`) -pub pure fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) { +pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) { range_step(hi, lo, -1 as T, it); } /// Computes the bitwise complement #[inline(always)] -pub pure fn compl(i: T) -> T { +pub fn compl(i: T) -> T { -1 as T ^ i } /// Computes the absolute value #[inline(always)] -pub pure fn abs(i: T) -> T { +pub fn abs(i: T) -> T { if is_negative(i) { -i } else { i } } #[cfg(notest)] impl Ord for T { #[inline(always)] - pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); } + fn lt(&self, other: &T) -> bool { return (*self) < (*other); } #[inline(always)] - pure fn le(&self, other: &T) -> bool { return (*self) <= (*other); } + fn le(&self, other: &T) -> bool { return (*self) <= (*other); } #[inline(always)] - pure fn ge(&self, other: &T) -> bool { return (*self) >= (*other); } + fn ge(&self, other: &T) -> bool { return (*self) >= (*other); } #[inline(always)] - pure fn gt(&self, other: &T) -> bool { return (*self) > (*other); } + fn gt(&self, other: &T) -> bool { return (*self) > (*other); } } #[cfg(notest)] impl Eq for T { #[inline(always)] - pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); } + fn eq(&self, other: &T) -> bool { return (*self) == (*other); } #[inline(always)] - pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); } + fn ne(&self, other: &T) -> bool { return (*self) != (*other); } } impl num::Zero for T { #[inline(always)] - static pure fn zero() -> T { 0 } + fn zero() -> T { 0 } } impl num::One for T { #[inline(always)] - static pure fn one() -> T { 1 } + fn one() -> T { 1 } } #[cfg(notest)] impl ops::Add<T,T> for T { - pure fn add(&self, other: &T) -> T { *self + *other } + fn add(&self, other: &T) -> T { *self + *other } } #[cfg(notest)] impl ops::Sub<T,T> for T { - pure fn sub(&self, other: &T) -> T { *self - *other } + fn sub(&self, other: &T) -> T { *self - *other } } #[cfg(notest)] impl ops::Mul<T,T> for T { - pure fn mul(&self, other: &T) -> T { *self * *other } + fn mul(&self, other: &T) -> T { *self * *other } } #[cfg(notest)] impl ops::Div<T,T> for T { - pure fn div(&self, other: &T) -> T { *self / *other } + fn div(&self, other: &T) -> T { *self / *other } } #[cfg(notest)] impl ops::Modulo<T,T> for T { - pure fn modulo(&self, other: &T) -> T { *self % *other } + fn modulo(&self, other: &T) -> T { *self % *other } } #[cfg(notest)] impl ops::Neg<T> for T { - pure fn neg(&self) -> T { -*self } + fn neg(&self) -> T { -*self } } // String conversion functions and impl str -> num /// Parse a string as a number in base 10. #[inline(always)] -pub pure fn from_str(s: &str) -> Option<T> { +pub fn from_str(s: &str) -> Option<T> { strconv::from_str_common(s, 10u, true, false, false, strconv::ExpNone, false) } /// Parse a string as a number in the given base. #[inline(always)] -pub pure fn from_str_radix(s: &str, radix: uint) -> Option<T> { +pub fn from_str_radix(s: &str, radix: uint) -> Option<T> { strconv::from_str_common(s, radix, true, false, false, strconv::ExpNone, false) } /// Parse a byte slice as a number in the given base. #[inline(always)] -pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> { +pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> { strconv::from_str_bytes_common(buf, radix, true, false, false, strconv::ExpNone, false) } impl FromStr for T { #[inline(always)] - static pure fn from_str(s: &str) -> Option<T> { + fn from_str(s: &str) -> Option<T> { from_str(s) } } impl FromStrRadix for T { #[inline(always)] - static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> { + fn from_str_radix(s: &str, radix: uint) -> Option<T> { from_str_radix(s, radix) } } @@ -237,7 +237,7 @@ impl FromStrRadix for T { /// Convert to a string as a byte slice in a given base. #[inline(always)] -pub pure fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { +pub fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { let (buf, _) = strconv::to_str_bytes_common(&n, radix, false, strconv::SignNeg, strconv::DigAll); f(buf) @@ -245,7 +245,7 @@ pub pure fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { /// Convert to a string in base 10. #[inline(always)] -pub pure fn to_str(num: T) -> ~str { +pub fn to_str(num: T) -> ~str { let (buf, _) = strconv::to_str_common(&num, 10u, false, strconv::SignNeg, strconv::DigAll); buf @@ -253,7 +253,7 @@ pub pure fn to_str(num: T) -> ~str { /// Convert to a string in a given base. #[inline(always)] -pub pure fn to_str_radix(num: T, radix: uint) -> ~str { +pub fn to_str_radix(num: T, radix: uint) -> ~str { let (buf, _) = strconv::to_str_common(&num, radix, false, strconv::SignNeg, strconv::DigAll); buf @@ -261,14 +261,14 @@ pub pure fn to_str_radix(num: T, radix: uint) -> ~str { impl ToStr for T { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { to_str(*self) } } impl ToStrRadix for T { #[inline(always)] - pure fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> ~str { to_str_radix(*self, radix) } } diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs index 3c4ca532be7..9914807c98f 100644 --- a/src/libcore/num/int-template/i16.rs +++ b/src/libcore/num/int-template/i16.rs @@ -22,23 +22,23 @@ impl NumCast for i16 { * Cast `n` to a `i16` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> i16 { n.to_i16() } + fn from<N:NumCast>(n: N) -> i16 { n.to_i16() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs index 30eb4437d57..c02facd47db 100644 --- a/src/libcore/num/int-template/i32.rs +++ b/src/libcore/num/int-template/i32.rs @@ -22,23 +22,23 @@ impl NumCast for i32 { * Cast `n` to a `i32` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> i32 { n.to_i32() } + fn from<N:NumCast>(n: N) -> i32 { n.to_i32() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs index 61736cf9587..c285ba23c27 100644 --- a/src/libcore/num/int-template/i64.rs +++ b/src/libcore/num/int-template/i64.rs @@ -22,23 +22,23 @@ impl NumCast for i64 { * Cast `n` to a `i64` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> i64 { n.to_i64() } + fn from<N:NumCast>(n: N) -> i64 { n.to_i64() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs index e70811adff1..2733a064563 100644 --- a/src/libcore/num/int-template/i8.rs +++ b/src/libcore/num/int-template/i8.rs @@ -22,23 +22,23 @@ impl NumCast for i8 { * Cast `n` to a `i8` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> i8 { n.to_i8() } + fn from<N:NumCast>(n: N) -> i8 { n.to_i8() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs index f007cc5b119..29e1e52348e 100644 --- a/src/libcore/num/int-template/int.rs +++ b/src/libcore/num/int-template/int.rs @@ -19,7 +19,7 @@ mod inst { pub const bits: uint = ::uint::bits; /// Returns `base` raised to the power of `exponent` - pub pure fn pow(base: int, exponent: uint) -> int { + pub fn pow(base: int, exponent: uint) -> int { if exponent == 0u { //Not mathemtically true if ~[base == 0] return 1; @@ -63,23 +63,23 @@ impl NumCast for int { * Cast `n` to a `int` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> int { n.to_int() } + fn from<N:NumCast>(n: N) -> int { n.to_int() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/num.rs b/src/libcore/num/num.rs index a462aed8be0..32d48aac0b3 100644 --- a/src/libcore/num/num.rs +++ b/src/libcore/num/num.rs @@ -17,28 +17,28 @@ use kinds::Copy; pub mod strconv; pub trait IntConvertible { - pure fn to_int(&self) -> int; - static pure fn from_int(n: int) -> Self; + fn to_int(&self) -> int; + fn from_int(n: int) -> Self; } pub trait Zero { - static pure fn zero() -> Self; + fn zero() -> Self; } pub trait One { - static pure fn one() -> Self; + fn one() -> Self; } -pub pure fn abs<T:Ord + Zero + Neg<T>>(v: T) -> T { +pub fn abs<T:Ord + Zero + Neg<T>>(v: T) -> T { if v < Zero::zero() { v.neg() } else { v } } pub trait Round { - pure fn round(&self, mode: RoundMode) -> Self; + fn round(&self, mode: RoundMode) -> Self; - pure fn floor(&self) -> Self; - pure fn ceil(&self) -> Self; - pure fn fract(&self) -> Self; + fn floor(&self) -> Self; + fn ceil(&self) -> Self; + fn fract(&self) -> Self; } pub enum RoundMode { @@ -59,7 +59,7 @@ pub enum RoundMode { * ~~~ */ #[inline(always)] -pub pure fn cast<T:NumCast,U:NumCast>(n: T) -> U { +pub fn cast<T:NumCast,U:NumCast>(n: T) -> U { NumCast::from(n) } @@ -67,31 +67,31 @@ pub pure fn cast<T:NumCast,U:NumCast>(n: T) -> U { * An interface for generic numeric type casts */ pub trait NumCast { - static pure fn from<T:NumCast>(n: T) -> Self; - - pure fn to_u8(&self) -> u8; - pure fn to_u16(&self) -> u16; - pure fn to_u32(&self) -> u32; - pure fn to_u64(&self) -> u64; - pure fn to_uint(&self) -> uint; - - pure fn to_i8(&self) -> i8; - pure fn to_i16(&self) -> i16; - pure fn to_i32(&self) -> i32; - pure fn to_i64(&self) -> i64; - pure fn to_int(&self) -> int; - - pure fn to_f32(&self) -> f32; - pure fn to_f64(&self) -> f64; - pure fn to_float(&self) -> float; + fn from<T:NumCast>(n: T) -> Self; + + fn to_u8(&self) -> u8; + fn to_u16(&self) -> u16; + fn to_u32(&self) -> u32; + fn to_u64(&self) -> u64; + fn to_uint(&self) -> uint; + + fn to_i8(&self) -> i8; + fn to_i16(&self) -> i16; + fn to_i32(&self) -> i32; + fn to_i64(&self) -> i64; + fn to_int(&self) -> int; + + fn to_f32(&self) -> f32; + fn to_f64(&self) -> f64; + fn to_float(&self) -> float; } pub trait ToStrRadix { - pub pure fn to_str_radix(&self, radix: uint) -> ~str; + pub fn to_str_radix(&self, radix: uint) -> ~str; } pub trait FromStrRadix { - static pub pure fn from_str_radix(str: &str, radix: uint) -> Option<Self>; + pub fn from_str_radix(str: &str, radix: uint) -> Option<Self>; } // Generic math functions: @@ -109,7 +109,7 @@ pub trait FromStrRadix { * - If code written to use this function doesn't care about it, it's * probably assuming that `x^0` always equals `1`. */ -pub pure fn pow_with_uint<T:NumCast+One+Zero+Copy+Div<T,T>+Mul<T,T>>( +pub fn pow_with_uint<T:NumCast+One+Zero+Copy+Div<T,T>+Mul<T,T>>( radix: uint, pow: uint) -> T { let _0: T = Zero::zero(); let _1: T = One::one(); diff --git a/src/libcore/num/strconv.rs b/src/libcore/num/strconv.rs index 28e57a354c8..e39d52d86f2 100644 --- a/src/libcore/num/strconv.rs +++ b/src/libcore/num/strconv.rs @@ -37,12 +37,12 @@ pub enum SignFormat { } #[inline(always)] -pure fn is_NaN<T:Eq>(num: &T) -> bool { +fn is_NaN<T:Eq>(num: &T) -> bool { *num != *num } #[inline(always)] -pure fn is_inf<T:Eq+NumStrConv>(num: &T) -> bool { +fn is_inf<T:Eq+NumStrConv>(num: &T) -> bool { match NumStrConv::inf() { None => false, Some(n) => *num == n @@ -50,7 +50,7 @@ pure fn is_inf<T:Eq+NumStrConv>(num: &T) -> bool { } #[inline(always)] -pure fn is_neg_inf<T:Eq+NumStrConv>(num: &T) -> bool { +fn is_neg_inf<T:Eq+NumStrConv>(num: &T) -> bool { match NumStrConv::neg_inf() { None => false, Some(n) => *num == n @@ -58,7 +58,7 @@ pure fn is_neg_inf<T:Eq+NumStrConv>(num: &T) -> bool { } #[inline(always)] -pure fn is_neg_zero<T:Eq+One+Zero+NumStrConv+Div<T,T>>(num: &T) -> bool { +fn is_neg_zero<T:Eq+One+Zero+NumStrConv+Div<T,T>>(num: &T) -> bool { let _0: T = Zero::zero(); let _1: T = One::one(); @@ -66,35 +66,35 @@ pure fn is_neg_zero<T:Eq+One+Zero+NumStrConv+Div<T,T>>(num: &T) -> bool { } pub trait NumStrConv { - static pure fn NaN() -> Option<Self>; - static pure fn inf() -> Option<Self>; - static pure fn neg_inf() -> Option<Self>; - static pure fn neg_zero() -> Option<Self>; + fn NaN() -> Option<Self>; + fn inf() -> Option<Self>; + fn neg_inf() -> Option<Self>; + fn neg_zero() -> Option<Self>; - pure fn round_to_zero(&self) -> Self; - pure fn fractional_part(&self) -> Self; + fn round_to_zero(&self) -> Self; + fn fractional_part(&self) -> Self; } macro_rules! impl_NumStrConv_Floating (($t:ty) => ( impl NumStrConv for $t { #[inline(always)] - static pure fn NaN() -> Option<$t> { Some( 0.0 / 0.0) } + fn NaN() -> Option<$t> { Some( 0.0 / 0.0) } #[inline(always)] - static pure fn inf() -> Option<$t> { Some( 1.0 / 0.0) } + fn inf() -> Option<$t> { Some( 1.0 / 0.0) } #[inline(always)] - static pure fn neg_inf() -> Option<$t> { Some(-1.0 / 0.0) } + fn neg_inf() -> Option<$t> { Some(-1.0 / 0.0) } #[inline(always)] - static pure fn neg_zero() -> Option<$t> { Some(-0.0 ) } + fn neg_zero() -> Option<$t> { Some(-0.0 ) } #[inline(always)] - pure fn round_to_zero(&self) -> $t { + fn round_to_zero(&self) -> $t { ( if *self < 0.0 { f64::ceil(*self as f64) } else { f64::floor(*self as f64) } ) as $t } #[inline(always)] - pure fn fractional_part(&self) -> $t { + fn fractional_part(&self) -> $t { *self - self.round_to_zero() } } @@ -102,13 +102,13 @@ macro_rules! impl_NumStrConv_Floating (($t:ty) => ( macro_rules! impl_NumStrConv_Integer (($t:ty) => ( impl NumStrConv for $t { - #[inline(always)] static pure fn NaN() -> Option<$t> { None } - #[inline(always)] static pure fn inf() -> Option<$t> { None } - #[inline(always)] static pure fn neg_inf() -> Option<$t> { None } - #[inline(always)] static pure fn neg_zero() -> Option<$t> { None } + #[inline(always)] fn NaN() -> Option<$t> { None } + #[inline(always)] fn inf() -> Option<$t> { None } + #[inline(always)] fn neg_inf() -> Option<$t> { None } + #[inline(always)] fn neg_zero() -> Option<$t> { None } - #[inline(always)] pure fn round_to_zero(&self) -> $t { *self } - #[inline(always)] pure fn fractional_part(&self) -> $t { 0 } + #[inline(always)] fn round_to_zero(&self) -> $t { *self } + #[inline(always)] fn fractional_part(&self) -> $t { 0 } } )) @@ -161,7 +161,7 @@ impl_NumStrConv_Integer!(u64) * # Failure * - Fails if `radix` < 2 or `radix` > 36. */ -pub pure fn to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+ +pub fn to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+ Div<T,T>+Neg<T>+Modulo<T,T>+Mul<T,T>>( num: &T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits) -> (~[u8], bool) { @@ -383,7 +383,7 @@ pub pure fn to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+ * `to_str_bytes_common()`, for details see there. */ #[inline(always)] -pub pure fn to_str_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+ +pub fn to_str_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+ Div<T,T>+Neg<T>+Modulo<T,T>+Mul<T,T>>( num: &T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits) -> (~str, bool) { @@ -439,7 +439,7 @@ priv const DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u; * - Could accept option to allow ignoring underscores, allowing for numbers * formated like `FF_AE_FF_FF`. */ -pub pure fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+ +pub fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+ Mul<T,T>+Sub<T,T>+Neg<T>+Add<T,T>+ NumStrConv>( buf: &[u8], radix: uint, negative: bool, fractional: bool, @@ -628,7 +628,7 @@ pub pure fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+ * `from_str_bytes_common()`, for details see there. */ #[inline(always)] -pub pure fn from_str_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+Mul<T,T>+ +pub fn from_str_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+Mul<T,T>+ Sub<T,T>+Neg<T>+Add<T,T>+NumStrConv>( buf: &str, radix: uint, negative: bool, fractional: bool, special: bool, exponent: ExponentFormat, empty_zero: bool diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs index 9abbfb03d7a..b8e713ff3ab 100644 --- a/src/libcore/num/uint-template.rs +++ b/src/libcore/num/uint-template.rs @@ -30,44 +30,44 @@ pub const min_value: T = 0 as T; pub const max_value: T = 0 as T - 1 as T; #[inline(always)] -pub pure fn add(x: T, y: T) -> T { x + y } +pub fn add(x: T, y: T) -> T { x + y } #[inline(always)] -pub pure fn sub(x: T, y: T) -> T { x - y } +pub fn sub(x: T, y: T) -> T { x - y } #[inline(always)] -pub pure fn mul(x: T, y: T) -> T { x * y } +pub fn mul(x: T, y: T) -> T { x * y } #[inline(always)] -pub pure fn div(x: T, y: T) -> T { x / y } +pub fn div(x: T, y: T) -> T { x / y } #[inline(always)] -pub pure fn rem(x: T, y: T) -> T { x % y } +pub fn rem(x: T, y: T) -> T { x % y } #[inline(always)] -pub pure fn lt(x: T, y: T) -> bool { x < y } +pub fn lt(x: T, y: T) -> bool { x < y } #[inline(always)] -pub pure fn le(x: T, y: T) -> bool { x <= y } +pub fn le(x: T, y: T) -> bool { x <= y } #[inline(always)] -pub pure fn eq(x: T, y: T) -> bool { x == y } +pub fn eq(x: T, y: T) -> bool { x == y } #[inline(always)] -pub pure fn ne(x: T, y: T) -> bool { x != y } +pub fn ne(x: T, y: T) -> bool { x != y } #[inline(always)] -pub pure fn ge(x: T, y: T) -> bool { x >= y } +pub fn ge(x: T, y: T) -> bool { x >= y } #[inline(always)] -pub pure fn gt(x: T, y: T) -> bool { x > y } +pub fn gt(x: T, y: T) -> bool { x > y } #[inline(always)] -pub pure fn is_positive(x: T) -> bool { x > 0 as T } +pub fn is_positive(x: T) -> bool { x > 0 as T } #[inline(always)] -pub pure fn is_negative(x: T) -> bool { x < 0 as T } +pub fn is_negative(x: T) -> bool { x < 0 as T } #[inline(always)] -pub pure fn is_nonpositive(x: T) -> bool { x <= 0 as T } +pub fn is_nonpositive(x: T) -> bool { x <= 0 as T } #[inline(always)] -pub pure fn is_nonnegative(x: T) -> bool { x >= 0 as T } +pub fn is_nonnegative(x: T) -> bool { x >= 0 as T } #[inline(always)] /** * Iterate over the range [`start`,`start`+`step`..`stop`) * */ -pub pure fn range_step(start: T, +pub fn range_step(start: T, stop: T, step: T_SIGNED, it: &fn(T) -> bool) { @@ -91,110 +91,110 @@ pub pure fn range_step(start: T, #[inline(always)] /// Iterate over the range [`lo`..`hi`) -pub pure fn range(lo: T, hi: T, it: &fn(T) -> bool) { +pub fn range(lo: T, hi: T, it: &fn(T) -> bool) { range_step(lo, hi, 1 as T_SIGNED, it); } #[inline(always)] /// Iterate over the range [`hi`..`lo`) -pub pure fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) { +pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) { range_step(hi, lo, -1 as T_SIGNED, it); } /// Computes the bitwise complement #[inline(always)] -pub pure fn compl(i: T) -> T { +pub fn compl(i: T) -> T { max_value ^ i } #[cfg(notest)] impl Ord for T { #[inline(always)] - pure fn lt(&self, other: &T) -> bool { (*self) < (*other) } + fn lt(&self, other: &T) -> bool { (*self) < (*other) } #[inline(always)] - pure fn le(&self, other: &T) -> bool { (*self) <= (*other) } + fn le(&self, other: &T) -> bool { (*self) <= (*other) } #[inline(always)] - pure fn ge(&self, other: &T) -> bool { (*self) >= (*other) } + fn ge(&self, other: &T) -> bool { (*self) >= (*other) } #[inline(always)] - pure fn gt(&self, other: &T) -> bool { (*self) > (*other) } + fn gt(&self, other: &T) -> bool { (*self) > (*other) } } #[cfg(notest)] impl Eq for T { #[inline(always)] - pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); } + fn eq(&self, other: &T) -> bool { return (*self) == (*other); } #[inline(always)] - pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); } + fn ne(&self, other: &T) -> bool { return (*self) != (*other); } } impl num::Zero for T { #[inline(always)] - static pure fn zero() -> T { 0 } + fn zero() -> T { 0 } } impl num::One for T { #[inline(always)] - static pure fn one() -> T { 1 } + fn one() -> T { 1 } } #[cfg(notest)] impl ops::Add<T,T> for T { - pure fn add(&self, other: &T) -> T { *self + *other } + fn add(&self, other: &T) -> T { *self + *other } } #[cfg(notest)] impl ops::Sub<T,T> for T { - pure fn sub(&self, other: &T) -> T { *self - *other } + fn sub(&self, other: &T) -> T { *self - *other } } #[cfg(notest)] impl ops::Mul<T,T> for T { - pure fn mul(&self, other: &T) -> T { *self * *other } + fn mul(&self, other: &T) -> T { *self * *other } } #[cfg(notest)] impl ops::Div<T,T> for T { - pure fn div(&self, other: &T) -> T { *self / *other } + fn div(&self, other: &T) -> T { *self / *other } } #[cfg(notest)] impl ops::Modulo<T,T> for T { - pure fn modulo(&self, other: &T) -> T { *self % *other } + fn modulo(&self, other: &T) -> T { *self % *other } } #[cfg(notest)] impl ops::Neg<T> for T { - pure fn neg(&self) -> T { -*self } + fn neg(&self) -> T { -*self } } // String conversion functions and impl str -> num /// Parse a string as a number in base 10. #[inline(always)] -pub pure fn from_str(s: &str) -> Option<T> { +pub fn from_str(s: &str) -> Option<T> { strconv::from_str_common(s, 10u, false, false, false, strconv::ExpNone, false) } /// Parse a string as a number in the given base. #[inline(always)] -pub pure fn from_str_radix(s: &str, radix: uint) -> Option<T> { +pub fn from_str_radix(s: &str, radix: uint) -> Option<T> { strconv::from_str_common(s, radix, false, false, false, strconv::ExpNone, false) } /// Parse a byte slice as a number in the given base. #[inline(always)] -pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> { +pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> { strconv::from_str_bytes_common(buf, radix, false, false, false, strconv::ExpNone, false) } impl FromStr for T { #[inline(always)] - static pure fn from_str(s: &str) -> Option<T> { + fn from_str(s: &str) -> Option<T> { from_str(s) } } impl FromStrRadix for T { #[inline(always)] - static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> { + fn from_str_radix(s: &str, radix: uint) -> Option<T> { from_str_radix(s, radix) } } @@ -203,7 +203,7 @@ impl FromStrRadix for T { /// Convert to a string as a byte slice in a given base. #[inline(always)] -pub pure fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { +pub fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { let (buf, _) = strconv::to_str_bytes_common(&n, radix, false, strconv::SignNeg, strconv::DigAll); f(buf) @@ -211,7 +211,7 @@ pub pure fn to_str_bytes<U>(n: T, radix: uint, f: &fn(v: &[u8]) -> U) -> U { /// Convert to a string in base 10. #[inline(always)] -pub pure fn to_str(num: T) -> ~str { +pub fn to_str(num: T) -> ~str { let (buf, _) = strconv::to_str_common(&num, 10u, false, strconv::SignNeg, strconv::DigAll); buf @@ -219,7 +219,7 @@ pub pure fn to_str(num: T) -> ~str { /// Convert to a string in a given base. #[inline(always)] -pub pure fn to_str_radix(num: T, radix: uint) -> ~str { +pub fn to_str_radix(num: T, radix: uint) -> ~str { let (buf, _) = strconv::to_str_common(&num, radix, false, strconv::SignNeg, strconv::DigAll); buf @@ -227,14 +227,14 @@ pub pure fn to_str_radix(num: T, radix: uint) -> ~str { impl ToStr for T { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { to_str(*self) } } impl ToStrRadix for T { #[inline(always)] - pure fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> ~str { to_str_radix(*self, radix) } } diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs index 16a1d620929..bdd95120136 100644 --- a/src/libcore/num/uint-template/u16.rs +++ b/src/libcore/num/uint-template/u16.rs @@ -24,23 +24,23 @@ impl NumCast for u16 { * Cast `n` to a `u16` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> u16 { n.to_u16() } + fn from<N:NumCast>(n: N) -> u16 { n.to_u16() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs index cf92feb6427..7bef51489f2 100644 --- a/src/libcore/num/uint-template/u32.rs +++ b/src/libcore/num/uint-template/u32.rs @@ -24,23 +24,23 @@ impl NumCast for u32 { * Cast `n` to a `u32` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> u32 { n.to_u32() } + fn from<N:NumCast>(n: N) -> u32 { n.to_u32() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs index 269d8e185f3..fecafe37f3d 100644 --- a/src/libcore/num/uint-template/u64.rs +++ b/src/libcore/num/uint-template/u64.rs @@ -24,23 +24,23 @@ impl NumCast for u64 { * Cast `n` to a `u64` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> u64 { n.to_u64() } + fn from<N:NumCast>(n: N) -> u64 { n.to_u64() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs index 44428abdb4f..0d48de67334 100644 --- a/src/libcore/num/uint-template/u8.rs +++ b/src/libcore/num/uint-template/u8.rs @@ -23,7 +23,7 @@ mod inst { // Type-specific functions here. These must be reexported by the // parent module so that they appear in core::u8 and not core::u8::u8; - pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; } + pub fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; } } impl NumCast for u8 { @@ -31,23 +31,23 @@ impl NumCast for u8 { * Cast `n` to a `u8` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> u8 { n.to_u8() } + fn from<N:NumCast>(n: N) -> u8 { n.to_u8() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self as uint } + #[inline(always)] fn to_u8(&self) -> u8 { *self } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self as uint } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs index f73ff4442ce..f3f27a4e48a 100644 --- a/src/libcore/num/uint-template/uint.rs +++ b/src/libcore/num/uint-template/uint.rs @@ -45,7 +45,7 @@ pub mod inst { * * The smallest integer `q` such that `x/y <= q`. */ - pub pure fn div_ceil(x: uint, y: uint) -> uint { + pub fn div_ceil(x: uint, y: uint) -> uint { let div = x / y; if x % y == 0u { div } else { div + 1u } @@ -63,7 +63,7 @@ pub mod inst { * * The integer `q` closest to `x/y`. */ - pub pure fn div_round(x: uint, y: uint) -> uint { + pub fn div_round(x: uint, y: uint) -> uint { let div = x / y; if x % y * 2u < y { div } else { div + 1u } @@ -84,7 +84,7 @@ pub mod inst { * The smallest integer `q` such that `x/y <= q`. This * is either `x/y` or `x/y + 1`. */ - pub pure fn div_floor(x: uint, y: uint) -> uint { return x / y; } + pub fn div_floor(x: uint, y: uint) -> uint { return x / y; } /** * Iterate over the range [`lo`..`hi`), or stop when requested @@ -101,7 +101,7 @@ pub mod inst { * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ - pub pure fn iterate(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool { + pub fn iterate(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool { let mut i = lo; while i < hi { if (!it(i)) { return false; } @@ -122,7 +122,7 @@ pub mod inst { * use with integer literals of inferred integer-type as * the self-value (eg. `for 100.times { ... }`). */ - pure fn times(&self, it: &fn() -> bool) { + fn times(&self, it: &fn() -> bool) { let mut i = *self; while i > 0 { if !it() { break } @@ -133,7 +133,7 @@ pub mod inst { /// Returns the smallest power of 2 greater than or equal to `n` #[inline(always)] - pub pure fn next_power_of_two(n: uint) -> uint { + pub fn next_power_of_two(n: uint) -> uint { let halfbits: uint = sys::size_of::<uint>() * 4u; let mut tmp: uint = n - 1u; let mut shift: uint = 1u; @@ -215,23 +215,23 @@ impl NumCast for uint { * Cast `n` to a `uint` */ #[inline(always)] - static pure fn from<N:NumCast>(n: N) -> uint { n.to_uint() } + fn from<N:NumCast>(n: N) -> uint { n.to_uint() } - #[inline(always)] pure fn to_u8(&self) -> u8 { *self as u8 } - #[inline(always)] pure fn to_u16(&self) -> u16 { *self as u16 } - #[inline(always)] pure fn to_u32(&self) -> u32 { *self as u32 } - #[inline(always)] pure fn to_u64(&self) -> u64 { *self as u64 } - #[inline(always)] pure fn to_uint(&self) -> uint { *self } + #[inline(always)] fn to_u8(&self) -> u8 { *self as u8 } + #[inline(always)] fn to_u16(&self) -> u16 { *self as u16 } + #[inline(always)] fn to_u32(&self) -> u32 { *self as u32 } + #[inline(always)] fn to_u64(&self) -> u64 { *self as u64 } + #[inline(always)] fn to_uint(&self) -> uint { *self } - #[inline(always)] pure fn to_i8(&self) -> i8 { *self as i8 } - #[inline(always)] pure fn to_i16(&self) -> i16 { *self as i16 } - #[inline(always)] pure fn to_i32(&self) -> i32 { *self as i32 } - #[inline(always)] pure fn to_i64(&self) -> i64 { *self as i64 } - #[inline(always)] pure fn to_int(&self) -> int { *self as int } + #[inline(always)] fn to_i8(&self) -> i8 { *self as i8 } + #[inline(always)] fn to_i16(&self) -> i16 { *self as i16 } + #[inline(always)] fn to_i32(&self) -> i32 { *self as i32 } + #[inline(always)] fn to_i64(&self) -> i64 { *self as i64 } + #[inline(always)] fn to_int(&self) -> int { *self as int } - #[inline(always)] pure fn to_f32(&self) -> f32 { *self as f32 } - #[inline(always)] pure fn to_f64(&self) -> f64 { *self as f64 } - #[inline(always)] pure fn to_float(&self) -> float { *self as float } + #[inline(always)] fn to_f32(&self) -> f32 { *self as f32 } + #[inline(always)] fn to_f64(&self) -> f64 { *self as f64 } + #[inline(always)] fn to_float(&self) -> float { *self as float } } #[test] diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index aaa4ab3fecf..2f7fe1e4aa8 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -17,65 +17,65 @@ pub trait Drop { #[lang="add"] pub trait Add<RHS,Result> { - pure fn add(&self, rhs: &RHS) -> Result; + fn add(&self, rhs: &RHS) -> Result; } #[lang="sub"] pub trait Sub<RHS,Result> { - pure fn sub(&self, rhs: &RHS) -> Result; + fn sub(&self, rhs: &RHS) -> Result; } #[lang="mul"] pub trait Mul<RHS,Result> { - pure fn mul(&self, rhs: &RHS) -> Result; + fn mul(&self, rhs: &RHS) -> Result; } #[lang="div"] pub trait Div<RHS,Result> { - pure fn div(&self, rhs: &RHS) -> Result; + fn div(&self, rhs: &RHS) -> Result; } #[lang="modulo"] pub trait Modulo<RHS,Result> { - pure fn modulo(&self, rhs: &RHS) -> Result; + fn modulo(&self, rhs: &RHS) -> Result; } #[lang="neg"] pub trait Neg<Result> { - pure fn neg(&self) -> Result; + fn neg(&self) -> Result; } #[lang="not"] pub trait Not<Result> { - pure fn not(&self) -> Result; + fn not(&self) -> Result; } #[lang="bitand"] pub trait BitAnd<RHS,Result> { - pure fn bitand(&self, rhs: &RHS) -> Result; + fn bitand(&self, rhs: &RHS) -> Result; } #[lang="bitor"] pub trait BitOr<RHS,Result> { - pure fn bitor(&self, rhs: &RHS) -> Result; + fn bitor(&self, rhs: &RHS) -> Result; } #[lang="bitxor"] pub trait BitXor<RHS,Result> { - pure fn bitxor(&self, rhs: &RHS) -> Result; + fn bitxor(&self, rhs: &RHS) -> Result; } #[lang="shl"] pub trait Shl<RHS,Result> { - pure fn shl(&self, rhs: &RHS) -> Result; + fn shl(&self, rhs: &RHS) -> Result; } #[lang="shr"] pub trait Shr<RHS,Result> { - pure fn shr(&self, rhs: &RHS) -> Result; + fn shr(&self, rhs: &RHS) -> Result; } #[lang="index"] pub trait Index<Index,Result> { - pure fn index(&self, index: Index) -> Result; + fn index(&self, index: Index) -> Result; } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index c12b78b393f..dd92333b61d 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -59,7 +59,7 @@ pub enum Option<T> { } impl<T:Ord> Ord for Option<T> { - pure fn lt(&self, other: &Option<T>) -> bool { + fn lt(&self, other: &Option<T>) -> bool { match (self, other) { (&None, &None) => false, (&None, &Some(_)) => true, @@ -68,7 +68,7 @@ impl<T:Ord> Ord for Option<T> { } } - pure fn le(&self, other: &Option<T>) -> bool { + fn le(&self, other: &Option<T>) -> bool { match (self, other) { (&None, &None) => true, (&None, &Some(_)) => true, @@ -77,18 +77,18 @@ impl<T:Ord> Ord for Option<T> { } } - pure fn ge(&self, other: &Option<T>) -> bool { + fn ge(&self, other: &Option<T>) -> bool { ! (self < other) } - pure fn gt(&self, other: &Option<T>) -> bool { + fn gt(&self, other: &Option<T>) -> bool { ! (self <= other) } } impl<T: Copy + Add<T,T>> Add<Option<T>, Option<T>> for Option<T> { #[inline(always)] - pure fn add(&self, other: &Option<T>) -> Option<T> { + fn add(&self, other: &Option<T>) -> Option<T> { match (*self, *other) { (None, None) => None, (_, None) => *self, @@ -99,7 +99,7 @@ impl<T: Copy + Add<T,T>> Add<Option<T>, Option<T>> for Option<T> { } #[inline(always)] -pub pure fn get<T:Copy>(opt: Option<T>) -> T { +pub fn get<T:Copy>(opt: Option<T>) -> T { /*! Gets the value out of an option @@ -122,7 +122,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 { +pub fn get_ref<T>(opt: &'r Option<T>) -> &'r T { /*! Gets an immutable reference to the value inside an option. @@ -143,7 +143,7 @@ pub pure fn get_ref<T>(opt: &'r Option<T>) -> &'r T { } } -pub pure fn get_mut_ref<T>(opt: &'r mut Option<T>) -> &'r mut T { +pub fn get_mut_ref<T>(opt: &'r mut Option<T>) -> &'r mut T { /*! Gets a mutable reference to the value inside an option. @@ -165,14 +165,14 @@ pub pure fn get_mut_ref<T>(opt: &'r mut Option<T>) -> &'r mut T { } #[inline(always)] -pub pure fn map<T, U>(opt: &'r Option<T>, f: &fn(x: &'r T) -> U) -> Option<U> { +pub fn map<T, U>(opt: &'r Option<T>, f: &fn(x: &'r 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>, +pub fn map_consume<T, U>(opt: Option<T>, f: &fn(v: T) -> U) -> Option<U> { /*! * As `map`, but consumes the option and gives `f` ownership to avoid @@ -182,7 +182,7 @@ pub pure fn map_consume<T, U>(opt: Option<T>, } #[inline(always)] -pub pure fn chain<T, U>(opt: Option<T>, +pub fn chain<T, U>(opt: Option<T>, f: &fn(t: T) -> Option<U>) -> Option<U> { /*! * Update an optional value by optionally running its content through a @@ -196,7 +196,7 @@ pub pure fn chain<T, U>(opt: Option<T>, } #[inline(always)] -pub pure fn chain_ref<T, U>(opt: &Option<T>, +pub fn chain_ref<T, U>(opt: &Option<T>, f: &fn(x: &T) -> Option<U>) -> Option<U> { /*! * Update an optional value by optionally running its content by reference @@ -207,7 +207,7 @@ pub pure fn chain_ref<T, U>(opt: &Option<T>, } #[inline(always)] -pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> { +pub fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> { /*! * Returns the leftmost Some() value, or None if both are None. */ @@ -218,7 +218,7 @@ pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> { } #[inline(always)] -pub pure fn while_some<T>(x: Option<T>, blk: &fn(v: T) -> Option<T>) { +pub fn while_some<T>(x: Option<T>, blk: &fn(v: T) -> Option<T>) { //! Applies a function zero or more times until the result is none. let mut opt = x; @@ -228,35 +228,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: &const Option<T>) -> bool { +pub fn is_none<T>(opt: &const 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: &const Option<T>) -> bool { +pub fn is_some<T>(opt: &const 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 { +pub 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 { +pub 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: &'r Option<T>, def: U, +pub fn map_default<T, U>(opt: &'r Option<T>, def: U, f: &fn(&'r T) -> U) -> U { //! Applies a function to the contained value or returns a default @@ -264,7 +264,7 @@ pub pure fn map_default<T, U>(opt: &'r Option<T>, def: U, } #[inline(always)] -pub pure fn unwrap<T>(opt: Option<T>) -> T { +pub fn unwrap<T>(opt: Option<T>) -> T { /*! Moves a value out of an option type and returns it. @@ -302,7 +302,7 @@ pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T { } #[inline(always)] -pub pure fn expect<T>(opt: Option<T>, reason: &str) -> T { +pub fn expect<T>(opt: Option<T>, reason: &str) -> T { //! As unwrap, but with a specified failure message. match opt { Some(val) => val, @@ -313,12 +313,12 @@ pub pure fn expect<T>(opt: Option<T>, reason: &str) -> T { impl<T> BaseIter<T> for Option<T> { /// Performs an operation on the contained value by reference #[inline(always)] - pure fn each(&self, f: &fn(x: &'self T) -> bool) { + fn each(&self, f: &fn(x: &'self T) -> bool) { match *self { None => (), Some(ref t) => { f(t); } } } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { + fn size_hint(&self) -> Option<uint> { if self.is_some() { Some(1) } else { Some(0) } } } @@ -333,42 +333,42 @@ impl<T> MutableIter<T> for Option<T> { pub impl<T> Option<T> { /// Returns true if the option equals `none` #[inline(always)] - pure fn is_none(&const self) -> bool { is_none(self) } + fn is_none(&const self) -> bool { is_none(self) } /// Returns true if the option contains some value #[inline(always)] - pure fn is_some(&const self) -> bool { is_some(self) } + fn is_some(&const self) -> bool { is_some(self) } /** * Update an optional value by optionally running its content by reference * through a function that returns an option. */ #[inline(always)] - pure fn chain_ref<U>(&self, f: &fn(x: &T) -> Option<U>) -> Option<U> { + fn chain_ref<U>(&self, f: &fn(x: &T) -> Option<U>) -> Option<U> { chain_ref(self, f) } /// Maps a `some` value from one type to another by reference #[inline(always)] - pure fn map<U>(&self, f: &fn(&'self T) -> U) -> Option<U> { map(self, f) } + fn map<U>(&self, f: &fn(&'self T) -> U) -> Option<U> { map(self, f) } /// As `map`, but consumes the option and gives `f` ownership to avoid /// copying. #[inline(always)] - pure fn map_consume<U>(self, f: &fn(v: T) -> U) -> Option<U> { + fn map_consume<U>(self, f: &fn(v: T) -> U) -> Option<U> { map_consume(self, f) } /// Applies a function to the contained value or returns a default #[inline(always)] - pure fn map_default<U>(&self, def: U, f: &fn(&'self T) -> U) -> U { + fn map_default<U>(&self, def: U, f: &fn(&'self T) -> U) -> U { map_default(self, def, f) } /// As `map_default`, but consumes the option and gives `f` /// ownership to avoid copying. #[inline(always)] - pure fn map_consume_default<U>(self, def: U, f: &fn(v: T) -> U) -> U { + fn map_consume_default<U>(self, def: U, f: &fn(v: T) -> U) -> U { match self { None => def, Some(v) => f(v) } } @@ -403,7 +403,7 @@ pub impl<T> Option<T> { case explicitly. */ #[inline(always)] - pure fn get_ref(&self) -> &'self T { get_ref(self) } + fn get_ref(&self) -> &'self T { get_ref(self) } /** Gets a mutable reference to the value inside an option. @@ -420,7 +420,7 @@ pub impl<T> Option<T> { case explicitly. */ #[inline(always)] - pure fn get_mut_ref(&mut self) -> &'self mut T { get_mut_ref(self) } + fn get_mut_ref(&mut self) -> &'self mut T { get_mut_ref(self) } /** * Gets the value out of an option without copying. @@ -430,7 +430,7 @@ pub impl<T> Option<T> { * Fails if the value equals `none` */ #[inline(always)] - pure fn unwrap(self) -> T { unwrap(self) } + fn unwrap(self) -> T { unwrap(self) } /** * The option dance. Moves a value out of an option type and returns it, @@ -452,7 +452,7 @@ pub impl<T> Option<T> { * Fails if the value equals `none` */ #[inline(always)] - pure fn expect(self, reason: &str) -> T { expect(self, reason) } + fn expect(self, reason: &str) -> T { expect(self, reason) } } pub impl<T:Copy> Option<T> { @@ -471,21 +471,21 @@ pub impl<T:Copy> Option<T> { case explicitly. */ #[inline(always)] - pure fn get(self) -> T { get(self) } + fn get(self) -> T { get(self) } #[inline(always)] - pure fn get_or_default(self, def: T) -> T { get_or_default(self, def) } + fn get_or_default(self, def: T) -> T { get_or_default(self, def) } /// Applies a function zero or more times until the result is none. #[inline(always)] - pure fn while_some(self, blk: &fn(v: T) -> Option<T>) { + fn while_some(self, blk: &fn(v: T) -> Option<T>) { while_some(self, blk) } } pub impl<T:Copy + Zero> Option<T> { #[inline(always)] - pure fn get_or_zero(self) -> T { get_or_zero(self) } + fn get_or_zero(self) -> T { get_or_zero(self) } } #[test] diff --git a/src/libcore/owned.rs b/src/libcore/owned.rs index 486ce44147a..c483ec79e21 100644 --- a/src/libcore/owned.rs +++ b/src/libcore/owned.rs @@ -15,20 +15,20 @@ #[cfg(notest)] impl<T:Eq> Eq for ~T { #[inline(always)] - pure fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) } + fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) } #[inline(always)] - pure fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) } + fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) } } #[cfg(notest)] impl<T:Ord> Ord for ~T { #[inline(always)] - pure fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) } + fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) } #[inline(always)] - pure fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) } + fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) } #[inline(always)] - pure fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) } + fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) } #[inline(always)] - pure fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) } + fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) } } diff --git a/src/libcore/path.rs b/src/libcore/path.rs index df4a3fdfb9e..5181c08bba0 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -28,7 +28,7 @@ pub struct WindowsPath { components: ~[~str], } -pub pure fn WindowsPath(s: &str) -> WindowsPath { +pub fn WindowsPath(s: &str) -> WindowsPath { GenericPath::from_str(s) } @@ -38,42 +38,42 @@ pub struct PosixPath { components: ~[~str], } -pub pure fn PosixPath(s: &str) -> PosixPath { +pub fn PosixPath(s: &str) -> PosixPath { GenericPath::from_str(s) } pub trait GenericPath { - static pure fn from_str(&str) -> Self; + fn from_str(&str) -> Self; - pure fn dirname(&self) -> ~str; - pure fn filename(&self) -> Option<~str>; - pure fn filestem(&self) -> Option<~str>; - pure fn filetype(&self) -> Option<~str>; + fn dirname(&self) -> ~str; + fn filename(&self) -> Option<~str>; + fn filestem(&self) -> Option<~str>; + fn filetype(&self) -> Option<~str>; - pure fn with_dirname(&self, (&str)) -> Self; - pure fn with_filename(&self, (&str)) -> Self; - pure fn with_filestem(&self, (&str)) -> Self; - pure fn with_filetype(&self, (&str)) -> Self; + fn with_dirname(&self, (&str)) -> Self; + fn with_filename(&self, (&str)) -> Self; + fn with_filestem(&self, (&str)) -> Self; + fn with_filetype(&self, (&str)) -> Self; - pure fn dir_path(&self) -> Self; - pure fn file_path(&self) -> Self; + fn dir_path(&self) -> Self; + fn file_path(&self) -> Self; - pure fn push(&self, (&str)) -> Self; - pure fn push_rel(&self, (&Self)) -> Self; - pure fn push_many(&self, (&[~str])) -> Self; - pure fn pop(&self) -> Self; + fn push(&self, (&str)) -> Self; + fn push_rel(&self, (&Self)) -> Self; + fn push_many(&self, (&[~str])) -> Self; + fn pop(&self) -> Self; - pure fn unsafe_join(&self, (&Self)) -> Self; - pure fn is_restricted(&self) -> bool; + fn unsafe_join(&self, (&Self)) -> Self; + fn is_restricted(&self) -> bool; - pure fn normalize(&self) -> Self; + fn normalize(&self) -> Self; } #[cfg(windows)] pub type Path = WindowsPath; #[cfg(windows)] -pub pure fn Path(s: &str) -> Path { +pub fn Path(s: &str) -> Path { WindowsPath(s) } @@ -81,7 +81,7 @@ pub pure fn Path(s: &str) -> Path { pub type Path = PosixPath; #[cfg(unix)] -pub pure fn Path(s: &str) -> Path { +pub fn Path(s: &str) -> Path { PosixPath(s) } @@ -367,7 +367,7 @@ pub impl Path { } impl ToStr for PosixPath { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { let mut s = ~""; if self.is_absolute { s += "/"; @@ -380,14 +380,14 @@ impl ToStr for PosixPath { // PosixPath and WindowsPath, most of their methods are common. impl GenericPath for PosixPath { - static pure fn from_str(s: &str) -> PosixPath { + fn from_str(s: &str) -> PosixPath { let mut components = str::split_nonempty(s, |c| c == '/'); let is_absolute = (s.len() != 0 && s[0] == '/' as u8); return PosixPath { is_absolute: is_absolute, components: components } } - pure fn dirname(&self) -> ~str { + fn dirname(&self) -> ~str { unsafe { let s = self.dir_path().to_str(); if s.len() == 0 { @@ -398,14 +398,14 @@ impl GenericPath for PosixPath { } } - pure fn filename(&self) -> Option<~str> { + fn filename(&self) -> Option<~str> { match self.components.len() { 0 => None, n => Some(copy self.components[n - 1]) } } - pure fn filestem(&self) -> Option<~str> { + fn filestem(&self) -> Option<~str> { match self.filename() { None => None, Some(ref f) => { @@ -417,7 +417,7 @@ impl GenericPath for PosixPath { } } - pure fn filetype(&self) -> Option<~str> { + fn filetype(&self) -> Option<~str> { match self.filename() { None => None, Some(ref f) => { @@ -429,7 +429,7 @@ impl GenericPath for PosixPath { } } - pure fn with_dirname(&self, d: &str) -> PosixPath { + fn with_dirname(&self, d: &str) -> PosixPath { let dpath = PosixPath(d); match self.filename() { Some(ref f) => dpath.push(*f), @@ -437,21 +437,21 @@ impl GenericPath for PosixPath { } } - pure fn with_filename(&self, f: &str) -> PosixPath { + fn with_filename(&self, f: &str) -> PosixPath { unsafe { fail_unless!(! str::any(f, |c| windows::is_sep(c as u8))); self.dir_path().push(f) } } - pure fn with_filestem(&self, s: &str) -> PosixPath { + fn with_filestem(&self, s: &str) -> PosixPath { match self.filetype() { None => self.with_filename(s), Some(ref t) => self.with_filename(str::from_slice(s) + *t) } } - pure fn with_filetype(&self, t: &str) -> PosixPath { + fn with_filetype(&self, t: &str) -> PosixPath { if t.len() == 0 { match self.filestem() { None => copy *self, @@ -466,7 +466,7 @@ impl GenericPath for PosixPath { } } - pure fn dir_path(&self) -> PosixPath { + fn dir_path(&self) -> PosixPath { if self.components.len() != 0 { self.pop() } else { @@ -474,7 +474,7 @@ impl GenericPath for PosixPath { } } - pure fn file_path(&self) -> PosixPath { + fn file_path(&self) -> PosixPath { let cs = match self.filename() { None => ~[], Some(ref f) => ~[copy *f] @@ -483,12 +483,12 @@ impl GenericPath for PosixPath { components: cs } } - pure fn push_rel(&self, other: &PosixPath) -> PosixPath { + fn push_rel(&self, other: &PosixPath) -> PosixPath { fail_unless!(!other.is_absolute); self.push_many(other.components) } - pure fn unsafe_join(&self, other: &PosixPath) -> PosixPath { + fn unsafe_join(&self, other: &PosixPath) -> PosixPath { if other.is_absolute { PosixPath { is_absolute: true, components: copy other.components } @@ -497,11 +497,11 @@ impl GenericPath for PosixPath { } } - pure fn is_restricted(&self) -> bool { + fn is_restricted(&self) -> bool { false } - pure fn push_many(&self, cs: &[~str]) -> PosixPath { + fn push_many(&self, cs: &[~str]) -> PosixPath { let mut v = copy self.components; for cs.each |e| { let mut ss = str::split_nonempty( @@ -513,14 +513,14 @@ impl GenericPath for PosixPath { components: v } } - pure fn push(&self, s: &str) -> PosixPath { + fn push(&self, s: &str) -> PosixPath { let mut v = copy self.components; let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8)); unsafe { v.push_all_move(ss); } PosixPath { components: v, ..copy *self } } - pure fn pop(&self) -> PosixPath { + fn pop(&self) -> PosixPath { let mut cs = copy self.components; if cs.len() != 0 { unsafe { cs.pop(); } @@ -532,7 +532,7 @@ impl GenericPath for PosixPath { //..self } } - pure fn normalize(&self) -> PosixPath { + fn normalize(&self) -> PosixPath { return PosixPath { is_absolute: self.is_absolute, components: normalize(self.components) @@ -543,7 +543,7 @@ impl GenericPath for PosixPath { impl ToStr for WindowsPath { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { let mut s = ~""; match self.host { Some(ref h) => { s += "\\\\"; s += *h; } @@ -563,7 +563,7 @@ impl ToStr for WindowsPath { impl GenericPath for WindowsPath { - static pure fn from_str(s: &str) -> WindowsPath { + fn from_str(s: &str) -> WindowsPath { let host; let device; let rest; @@ -599,7 +599,7 @@ impl GenericPath for WindowsPath { components: components } } - pure fn dirname(&self) -> ~str { + fn dirname(&self) -> ~str { unsafe { let s = self.dir_path().to_str(); if s.len() == 0 { @@ -610,14 +610,14 @@ impl GenericPath for WindowsPath { } } - pure fn filename(&self) -> Option<~str> { + fn filename(&self) -> Option<~str> { match self.components.len() { 0 => None, n => Some(copy self.components[n - 1]) } } - pure fn filestem(&self) -> Option<~str> { + fn filestem(&self) -> Option<~str> { match self.filename() { None => None, Some(ref f) => { @@ -629,7 +629,7 @@ impl GenericPath for WindowsPath { } } - pure fn filetype(&self) -> Option<~str> { + fn filetype(&self) -> Option<~str> { match self.filename() { None => None, Some(ref f) => { @@ -641,7 +641,7 @@ impl GenericPath for WindowsPath { } } - pure fn with_dirname(&self, d: &str) -> WindowsPath { + fn with_dirname(&self, d: &str) -> WindowsPath { let dpath = WindowsPath(d); match self.filename() { Some(ref f) => dpath.push(*f), @@ -649,19 +649,19 @@ impl GenericPath for WindowsPath { } } - pure fn with_filename(&self, f: &str) -> WindowsPath { + fn with_filename(&self, f: &str) -> WindowsPath { fail_unless!(! str::any(f, |c| windows::is_sep(c as u8))); self.dir_path().push(f) } - pure fn with_filestem(&self, s: &str) -> WindowsPath { + fn with_filestem(&self, s: &str) -> WindowsPath { match self.filetype() { None => self.with_filename(s), Some(ref t) => self.with_filename(str::from_slice(s) + *t) } } - pure fn with_filetype(&self, t: &str) -> WindowsPath { + fn with_filetype(&self, t: &str) -> WindowsPath { if t.len() == 0 { match self.filestem() { None => copy *self, @@ -677,7 +677,7 @@ impl GenericPath for WindowsPath { } } - pure fn dir_path(&self) -> WindowsPath { + fn dir_path(&self) -> WindowsPath { if self.components.len() != 0 { self.pop() } else { @@ -685,7 +685,7 @@ impl GenericPath for WindowsPath { } } - pure fn file_path(&self) -> WindowsPath { + fn file_path(&self) -> WindowsPath { let cs = match self.filename() { None => ~[], Some(ref f) => ~[copy *f] @@ -696,12 +696,12 @@ impl GenericPath for WindowsPath { components: cs } } - pure fn push_rel(&self, other: &WindowsPath) -> WindowsPath { + fn push_rel(&self, other: &WindowsPath) -> WindowsPath { fail_unless!(!other.is_absolute); self.push_many(other.components) } - pure fn unsafe_join(&self, other: &WindowsPath) -> WindowsPath { + fn unsafe_join(&self, other: &WindowsPath) -> WindowsPath { /* rhs not absolute is simple push */ if !other.is_absolute { return self.push_many(other.components); @@ -743,7 +743,7 @@ impl GenericPath for WindowsPath { } } - pure fn is_restricted(&self) -> bool { + fn is_restricted(&self) -> bool { match self.filestem() { Some(stem) => { match stem.to_lower() { @@ -756,7 +756,7 @@ impl GenericPath for WindowsPath { } } - pure fn push_many(&self, cs: &[~str]) -> WindowsPath { + fn push_many(&self, cs: &[~str]) -> WindowsPath { let mut v = copy self.components; for cs.each |e| { let mut ss = str::split_nonempty( @@ -773,14 +773,14 @@ impl GenericPath for WindowsPath { } } - pure fn push(&self, s: &str) -> WindowsPath { + fn push(&self, s: &str) -> WindowsPath { let mut v = copy self.components; let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8)); unsafe { v.push_all_move(ss); } return WindowsPath { components: v, ..copy *self } } - pure fn pop(&self) -> WindowsPath { + fn pop(&self) -> WindowsPath { let mut cs = copy self.components; if cs.len() != 0 { unsafe { cs.pop(); } @@ -793,7 +793,7 @@ impl GenericPath for WindowsPath { } } - pure fn normalize(&self) -> WindowsPath { + fn normalize(&self) -> WindowsPath { return WindowsPath { host: copy self.host, device: match self.device { @@ -807,7 +807,7 @@ impl GenericPath for WindowsPath { } -pub pure fn normalize(components: &[~str]) -> ~[~str] { +pub fn normalize(components: &[~str]) -> ~[~str] { let mut cs = ~[]; unsafe { for components.each |c| { @@ -831,11 +831,11 @@ pub mod windows { use option::{None, Option, Some}; #[inline(always)] - pub pure fn is_sep(u: u8) -> bool { + pub fn is_sep(u: u8) -> bool { u == '/' as u8 || u == '\\' as u8 } - pub pure fn extract_unc_prefix(s: &str) -> Option<(~str,~str)> { + pub fn extract_unc_prefix(s: &str) -> Option<(~str,~str)> { if (s.len() > 1 && (s[0] == '\\' as u8 || s[0] == '/' as u8) && s[0] == s[1]) { @@ -852,7 +852,7 @@ pub mod windows { None } - pub pure fn extract_drive_prefix(s: &str) -> Option<(~str,~str)> { + pub fn extract_drive_prefix(s: &str) -> Option<(~str,~str)> { unsafe { if (s.len() > 1 && libc::isalpha(s[0] as libc::c_int) != 0 && diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index a5d1cfa2793..710f2c51ee8 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -111,10 +111,10 @@ enum State { } impl Eq for State { - pure fn eq(&self, other: &State) -> bool { + fn eq(&self, other: &State) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &State) -> bool { !(*self).eq(other) } + fn ne(&self, other: &State) -> bool { !(*self).eq(other) } } pub struct BufferHeader { @@ -551,7 +551,7 @@ pub fn try_recv<T:Owned,Tbuffer:Owned>(p: RecvPacketBuffered<T, Tbuffer>) } /// Returns true if messages are available. -pub pure fn peek<T:Owned,Tb:Owned>(p: &RecvPacketBuffered<T, Tb>) -> bool { +pub fn peek<T:Owned,Tb:Owned>(p: &RecvPacketBuffered<T, Tb>) -> bool { match unsafe {(*p.header()).state} { Empty | Terminated => false, Blocked => fail!(~"peeking on blocked packet"), @@ -723,11 +723,11 @@ pub fn select2<A:Owned,Ab:Owned,B:Owned,Bb:Owned>( #[doc(hidden)] pub trait Selectable { - pure fn header(&self) -> *PacketHeader; + fn header(&self) -> *PacketHeader; } impl Selectable for *PacketHeader { - pure fn header(&self) -> *PacketHeader { *self } + fn header(&self) -> *PacketHeader { *self } } /// Returns the index of an endpoint that is ready to receive. @@ -812,7 +812,7 @@ pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> { option::unwrap(p) } - pure fn header(&self) -> *PacketHeader { + fn header(&self) -> *PacketHeader { match self.p { Some(packet) => unsafe { let packet = &*packet; @@ -879,7 +879,7 @@ pub impl<T:Owned,Tbuffer:Owned> RecvPacketBuffered<T, Tbuffer> { } impl<T:Owned,Tbuffer:Owned> Selectable for RecvPacketBuffered<T, Tbuffer> { - pure fn header(&self) -> *PacketHeader { + fn header(&self) -> *PacketHeader { match self.p { Some(packet) => unsafe { let packet = &*packet; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index c1b6b26d86a..fa96467cb0f 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -51,11 +51,11 @@ pub mod rusti { /// Get an unsafe pointer to a value #[inline(always)] -pub pure fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } } +pub fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } } /// Calculate the offset from a pointer #[inline(always)] -pub pure fn offset<T>(ptr: *T, count: uint) -> *T { +pub fn offset<T>(ptr: *T, count: uint) -> *T { unsafe { (ptr as uint + count * sys::size_of::<T>()) as *T } @@ -63,7 +63,7 @@ pub pure fn offset<T>(ptr: *T, count: uint) -> *T { /// Calculate the offset from a const pointer #[inline(always)] -pub pure fn const_offset<T>(ptr: *const T, count: uint) -> *const T { +pub fn const_offset<T>(ptr: *const T, count: uint) -> *const T { unsafe { (ptr as uint + count * sys::size_of::<T>()) as *T } @@ -71,7 +71,7 @@ pub pure fn const_offset<T>(ptr: *const T, count: uint) -> *const T { /// Calculate the offset from a mut pointer #[inline(always)] -pub pure fn mut_offset<T>(ptr: *mut T, count: uint) -> *mut T { +pub fn mut_offset<T>(ptr: *mut T, count: uint) -> *mut T { (ptr as uint + count * sys::size_of::<T>()) as *mut T } @@ -93,19 +93,19 @@ pub unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint { /// Create an unsafe null pointer #[inline(always)] -pub pure fn null<T>() -> *T { unsafe { cast::reinterpret_cast(&0u) } } +pub fn null<T>() -> *T { unsafe { cast::reinterpret_cast(&0u) } } /// Create an unsafe mutable null pointer #[inline(always)] -pub pure fn mut_null<T>() -> *mut T { unsafe { cast::reinterpret_cast(&0u) } } +pub 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() } +pub 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) } +pub fn is_not_null<T>(ptr: *const T) -> bool { !is_null(ptr) } /** * Copies data from one location to another @@ -138,7 +138,7 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: int, count: uint) { reinterpret_cast. */ #[inline(always)] -pub pure fn to_unsafe_ptr<T>(thing: &T) -> *T { +pub fn to_unsafe_ptr<T>(thing: &T) -> *T { unsafe { cast::reinterpret_cast(&thing) } } @@ -148,7 +148,7 @@ pub pure fn to_unsafe_ptr<T>(thing: &T) -> *T { reinterpret_cast. */ #[inline(always)] -pub pure fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T { +pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T { unsafe { cast::reinterpret_cast(&thing) } } @@ -158,7 +158,7 @@ pub pure fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T { reinterpret_cast. */ #[inline(always)] -pub pure fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T { +pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T { unsafe { cast::reinterpret_cast(&thing) } } @@ -170,7 +170,7 @@ pub pure fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T { (I couldn't think of a cutesy name for this one.) */ #[inline(always)] -pub pure fn to_uint<T>(thing: &T) -> uint { +pub fn to_uint<T>(thing: &T) -> uint { unsafe { cast::reinterpret_cast(&thing) } @@ -178,7 +178,7 @@ pub pure fn to_uint<T>(thing: &T) -> uint { /// Determine if two borrowed pointers point to the same thing. #[inline(always)] -pub pure fn ref_eq<T>(thing: &'a T, other: &'b T) -> bool { +pub fn ref_eq<T>(thing: &'a T, other: &'b T) -> bool { to_uint(thing) == to_uint(other) } @@ -223,46 +223,46 @@ pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) { } pub trait Ptr<T> { - pure fn is_null(&const self) -> bool; - pure fn is_not_null(&const self) -> bool; - pure fn offset(&self, count: uint) -> Self; + fn is_null(&const self) -> bool; + fn is_not_null(&const self) -> bool; + fn offset(&self, count: uint) -> Self; } /// Extension methods for immutable pointers impl<T> Ptr<T> for *T { /// Returns true if the pointer is equal to the null pointer. #[inline(always)] - pure fn is_null(&const self) -> bool { is_null(*self) } + fn is_null(&const self) -> bool { is_null(*self) } /// Returns true if the pointer is not equal to the null pointer. #[inline(always)] - pure fn is_not_null(&const self) -> bool { is_not_null(*self) } + fn is_not_null(&const self) -> bool { is_not_null(*self) } /// Calculates the offset from a pointer. #[inline(always)] - pure fn offset(&self, count: uint) -> *T { offset(*self, count) } + fn offset(&self, count: uint) -> *T { offset(*self, count) } } /// Extension methods for mutable pointers impl<T> Ptr<T> for *mut T { /// Returns true if the pointer is equal to the null pointer. #[inline(always)] - pure fn is_null(&const self) -> bool { is_null(*self) } + fn is_null(&const self) -> bool { is_null(*self) } /// Returns true if the pointer is not equal to the null pointer. #[inline(always)] - pure fn is_not_null(&const self) -> bool { is_not_null(*self) } + fn is_not_null(&const self) -> bool { is_not_null(*self) } /// Calculates the offset from a mutable pointer. #[inline(always)] - pure fn offset(&self, count: uint) -> *mut T { mut_offset(*self, count) } + fn offset(&self, count: uint) -> *mut T { mut_offset(*self, count) } } // Equality for pointers #[cfg(notest)] impl<T> Eq for *const T { #[inline(always)] - pure fn eq(&self, other: &*const T) -> bool { + fn eq(&self, other: &*const T) -> bool { unsafe { let a: uint = cast::reinterpret_cast(&(*self)); let b: uint = cast::reinterpret_cast(&(*other)); @@ -270,14 +270,14 @@ impl<T> Eq for *const T { } } #[inline(always)] - pure fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) } + fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) } } // Comparison for pointers #[cfg(notest)] impl<T> Ord for *const T { #[inline(always)] - pure fn lt(&self, other: &*const T) -> bool { + fn lt(&self, other: &*const T) -> bool { unsafe { let a: uint = cast::reinterpret_cast(&(*self)); let b: uint = cast::reinterpret_cast(&(*other)); @@ -285,7 +285,7 @@ impl<T> Ord for *const T { } } #[inline(always)] - pure fn le(&self, other: &*const T) -> bool { + fn le(&self, other: &*const T) -> bool { unsafe { let a: uint = cast::reinterpret_cast(&(*self)); let b: uint = cast::reinterpret_cast(&(*other)); @@ -293,7 +293,7 @@ impl<T> Ord for *const T { } } #[inline(always)] - pure fn ge(&self, other: &*const T) -> bool { + fn ge(&self, other: &*const T) -> bool { unsafe { let a: uint = cast::reinterpret_cast(&(*self)); let b: uint = cast::reinterpret_cast(&(*other)); @@ -301,7 +301,7 @@ impl<T> Ord for *const T { } } #[inline(always)] - pure fn gt(&self, other: &*const T) -> bool { + fn gt(&self, other: &*const T) -> bool { unsafe { let a: uint = cast::reinterpret_cast(&(*self)); let b: uint = cast::reinterpret_cast(&(*other)); @@ -314,11 +314,11 @@ impl<T> Ord for *const T { #[cfg(notest)] impl<T:Eq> Eq for &'self const T { #[inline(always)] - pure fn eq(&self, other: & &'self const T) -> bool { + fn eq(&self, other: & &'self const T) -> bool { return *(*self) == *(*other); } #[inline(always)] - pure fn ne(&self, other: & &'self const T) -> bool { + fn ne(&self, other: & &'self const T) -> bool { return *(*self) != *(*other); } } @@ -327,19 +327,19 @@ impl<T:Eq> Eq for &'self const T { #[cfg(notest)] impl<T:Ord> Ord for &'self const T { #[inline(always)] - pure fn lt(&self, other: & &'self const T) -> bool { + fn lt(&self, other: & &'self const T) -> bool { *(*self) < *(*other) } #[inline(always)] - pure fn le(&self, other: & &'self const T) -> bool { + fn le(&self, other: & &'self const T) -> bool { *(*self) <= *(*other) } #[inline(always)] - pure fn ge(&self, other: & &'self const T) -> bool { + fn ge(&self, other: & &'self const T) -> bool { *(*self) >= *(*other) } #[inline(always)] - pure fn gt(&self, other: & &'self const T) -> bool { + fn gt(&self, other: & &'self const T) -> bool { *(*self) > *(*other) } } diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 4cb5e58b733..fbdda02dcdc 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -22,95 +22,95 @@ use libc::size_t; /// A type that can be randomly generated using an RNG pub trait Rand { - static fn rand(rng: @rand::Rng) -> Self; + fn rand(rng: @rand::Rng) -> Self; } impl Rand for int { - static fn rand(rng: @rand::Rng) -> int { + fn rand(rng: @rand::Rng) -> int { rng.gen_int() } } impl Rand for i8 { - static fn rand(rng: @rand::Rng) -> i8 { + fn rand(rng: @rand::Rng) -> i8 { rng.gen_i8() } } impl Rand for i16 { - static fn rand(rng: @rand::Rng) -> i16 { + fn rand(rng: @rand::Rng) -> i16 { rng.gen_i16() } } impl Rand for i32 { - static fn rand(rng: @rand::Rng) -> i32 { + fn rand(rng: @rand::Rng) -> i32 { rng.gen_i32() } } impl Rand for i64 { - static fn rand(rng: @rand::Rng) -> i64 { + fn rand(rng: @rand::Rng) -> i64 { rng.gen_i64() } } impl Rand for u8 { - static fn rand(rng: @rand::Rng) -> u8 { + fn rand(rng: @rand::Rng) -> u8 { rng.gen_u8() } } impl Rand for u16 { - static fn rand(rng: @rand::Rng) -> u16 { + fn rand(rng: @rand::Rng) -> u16 { rng.gen_u16() } } impl Rand for u32 { - static fn rand(rng: @rand::Rng) -> u32 { + fn rand(rng: @rand::Rng) -> u32 { rng.gen_u32() } } impl Rand for u64 { - static fn rand(rng: @rand::Rng) -> u64 { + fn rand(rng: @rand::Rng) -> u64 { rng.gen_u64() } } impl Rand for float { - static fn rand(rng: @rand::Rng) -> float { + fn rand(rng: @rand::Rng) -> float { rng.gen_float() } } impl Rand for f32 { - static fn rand(rng: @rand::Rng) -> f32 { + fn rand(rng: @rand::Rng) -> f32 { rng.gen_f32() } } impl Rand for f64 { - static fn rand(rng: @rand::Rng) -> f64 { + fn rand(rng: @rand::Rng) -> f64 { rng.gen_f64() } } impl Rand for char { - static fn rand(rng: @rand::Rng) -> char { + fn rand(rng: @rand::Rng) -> char { rng.gen_char() } } impl Rand for bool { - static fn rand(rng: @rand::Rng) -> bool { + fn rand(rng: @rand::Rng) -> bool { rng.gen_bool() } } impl<T:Rand> Rand for Option<T> { - static fn rand(rng: @rand::Rng) -> Option<T> { + fn rand(rng: @rand::Rng) -> Option<T> { if rng.gen_bool() { Some(Rand::rand(rng)) } else { @@ -527,12 +527,12 @@ impl Rng for XorShiftState { } } -pub pure fn xorshift() -> @Rng { +pub fn xorshift() -> @Rng { // constants taken from http://en.wikipedia.org/wiki/Xorshift seeded_xorshift(123456789u32, 362436069u32, 521288629u32, 88675123u32) } -pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> @Rng { +pub fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> @Rng { @XorShiftState { x: x, y: y, z: z, w: w } as @Rng } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 18594a73d65..5dd2eaf5533 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -36,7 +36,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 { +pub fn get<T:Copy,U>(res: &Result<T, U>) -> T { match *res { Ok(copy t) => t, Err(ref the_err) => unsafe { @@ -53,7 +53,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 { +pub fn get_ref<T, U>(res: &'a Result<T, U>) -> &'a T { match *res { Ok(ref t) => t, Err(ref the_err) => unsafe { @@ -70,7 +70,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 { +pub fn get_err<T, U: Copy>(res: &Result<T, U>) -> U { match *res { Err(copy u) => u, Ok(_) => fail!(~"get_err called on ok result") @@ -79,7 +79,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 { +pub fn is_ok<T, U>(res: &Result<T, U>) -> bool { match *res { Ok(_) => true, Err(_) => false @@ -88,7 +88,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 { +pub fn is_err<T, U>(res: &Result<T, U>) -> bool { !is_ok(res) } @@ -99,7 +99,7 @@ pub pure fn is_err<T, U>(res: &Result<T, U>) -> bool { * result variants are converted to `either::left`. */ #[inline(always)] -pub pure fn to_either<T:Copy,U:Copy>(res: &Result<U, T>) +pub fn to_either<T:Copy,U:Copy>(res: &Result<U, T>) -> Either<T, U> { match *res { Ok(copy res) => either::Right(res), @@ -122,7 +122,7 @@ pub pure fn to_either<T:Copy,U:Copy>(res: &Result<U, T>) * } */ #[inline(always)] -pub pure fn chain<T, U, V>(res: Result<T, V>, op: &fn(T) +pub fn chain<T, U, V>(res: Result<T, V>, op: &fn(T) -> Result<U, V>) -> Result<U, V> { match res { Ok(t) => op(t), @@ -139,7 +139,7 @@ pub pure fn chain<T, U, V>(res: Result<T, V>, op: &fn(T) * successful result while handling an error. */ #[inline(always)] -pub pure fn chain_err<T, U, V>( +pub fn chain_err<T, U, V>( res: Result<T, V>, op: &fn(t: V) -> Result<T, U>) -> Result<T, U> { @@ -164,7 +164,7 @@ pub pure fn chain_err<T, U, V>( * } */ #[inline(always)] -pub pure fn iter<T, E>(res: &Result<T, E>, f: &fn(&T)) { +pub fn iter<T, E>(res: &Result<T, E>, f: &fn(&T)) { match *res { Ok(ref t) => f(t), Err(_) => () @@ -180,7 +180,7 @@ pub pure fn iter<T, E>(res: &Result<T, E>, f: &fn(&T)) { * handling an error. */ #[inline(always)] -pub pure fn iter_err<T, E>(res: &Result<T, E>, f: &fn(&E)) { +pub fn iter_err<T, E>(res: &Result<T, E>, f: &fn(&E)) { match *res { Ok(_) => (), Err(ref e) => f(e) @@ -202,7 +202,7 @@ pub pure fn iter_err<T, E>(res: &Result<T, E>, f: &fn(&E)) { * } */ #[inline(always)] -pub pure fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: &fn(&T) -> U) +pub fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: &fn(&T) -> U) -> Result<U, E> { match *res { Ok(ref t) => Ok(op(t)), @@ -219,7 +219,7 @@ pub pure fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: &fn(&T) -> U) * 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) +pub fn map_err<T:Copy,E,F:Copy>(res: &Result<T, E>, op: &fn(&E) -> F) -> Result<T, F> { match *res { Ok(copy t) => Ok(t), @@ -229,53 +229,53 @@ pub pure fn map_err<T:Copy,E,F:Copy>(res: &Result<T, E>, op: &fn(&E) -> F) pub impl<T, E> Result<T, E> { #[inline(always)] - pure fn get_ref(&self) -> &'self T { get_ref(self) } + fn get_ref(&self) -> &'self T { get_ref(self) } #[inline(always)] - pure fn is_ok(&self) -> bool { is_ok(self) } + fn is_ok(&self) -> bool { is_ok(self) } #[inline(always)] - pure fn is_err(&self) -> bool { is_err(self) } + fn is_err(&self) -> bool { is_err(self) } #[inline(always)] - pure fn iter(&self, f: &fn(&T)) { iter(self, f) } + fn iter(&self, f: &fn(&T)) { iter(self, f) } #[inline(always)] - pure fn iter_err(&self, f: &fn(&E)) { iter_err(self, f) } + fn iter_err(&self, f: &fn(&E)) { iter_err(self, f) } #[inline(always)] - pure fn unwrap(self) -> T { unwrap(self) } + fn unwrap(self) -> T { unwrap(self) } #[inline(always)] - pure fn unwrap_err(self) -> E { unwrap_err(self) } + fn unwrap_err(self) -> E { unwrap_err(self) } #[inline(always)] - pure fn chain<U>(self, op: &fn(T) -> Result<U,E>) -> Result<U,E> { + fn chain<U>(self, op: &fn(T) -> Result<U,E>) -> Result<U,E> { chain(self, op) } #[inline(always)] - pure fn chain_err<F>(self, op: &fn(E) -> Result<T,F>) -> Result<T,F> { + fn chain_err<F>(self, op: &fn(E) -> Result<T,F>) -> Result<T,F> { chain_err(self, op) } } pub impl<T:Copy,E> Result<T, E> { #[inline(always)] - pure fn get(&self) -> T { get(self) } + fn get(&self) -> T { get(self) } #[inline(always)] - pure fn map_err<F:Copy>(&self, op: &fn(&E) -> F) -> Result<T,F> { + fn map_err<F:Copy>(&self, op: &fn(&E) -> F) -> Result<T,F> { map_err(self, op) } } pub impl<T, E: Copy> Result<T, E> { #[inline(always)] - pure fn get_err(&self) -> E { get_err(self) } + fn get_err(&self) -> E { get_err(self) } #[inline(always)] - pure fn map<U:Copy>(&self, op: &fn(&T) -> U) -> Result<U,E> { + fn map<U:Copy>(&self, op: &fn(&T) -> U) -> Result<U,E> { map(self, op) } } @@ -375,7 +375,7 @@ pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T], /// Unwraps a result, assuming it is an `ok(T)` #[inline(always)] -pub pure fn unwrap<T, U>(res: Result<T, U>) -> T { +pub fn unwrap<T, U>(res: Result<T, U>) -> T { match res { Ok(t) => t, Err(_) => fail!(~"unwrap called on an err result") @@ -384,7 +384,7 @@ pub pure fn unwrap<T, U>(res: Result<T, U>) -> T { /// Unwraps a result, assuming it is an `err(U)` #[inline(always)] -pub pure fn unwrap_err<T, U>(res: Result<T, U>) -> U { +pub fn unwrap_err<T, U>(res: Result<T, U>) -> U { match res { Err(u) => u, Ok(_) => fail!(~"unwrap called on an ok result") diff --git a/src/libcore/rt/context.rs b/src/libcore/rt/context.rs index dfb7bdf04c3..4150366dacf 100644 --- a/src/libcore/rt/context.rs +++ b/src/libcore/rt/context.rs @@ -19,14 +19,14 @@ use cast::{transmute, transmute_mut_unsafe, pub struct Context(~Registers); pub impl Context { - static fn empty() -> Context { + fn empty() -> Context { Context(new_regs()) } /// Create a new context that will resume execution by running ~fn() /// # Safety Note /// The `start` closure must remain valid for the life of the Task - static fn new(start: &~fn(), stack: &mut StackSegment) -> Context { + fn new(start: &~fn(), stack: &mut StackSegment) -> Context { // The C-ABI function that is the task entry point extern fn task_start_wrapper(f: &~fn()) { (*f)() } @@ -49,7 +49,7 @@ pub impl Context { return Context(regs); } - static fn swap(out_context: &mut Context, in_context: &Context) { + fn swap(out_context: &mut Context, in_context: &Context) { let out_regs: &mut Registers = match out_context { &Context(~ref mut r) => r }; @@ -184,7 +184,7 @@ fn align_down(sp: *mut uint) -> *mut uint { // XXX: ptr::offset is positive ints only #[inline(always)] -pub pure fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T { +pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T { use core::sys::size_of; unsafe { (ptr as int + count * (size_of::<T>() as int)) as *mut T diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs index 60dbc8b82da..4a140458fd3 100644 --- a/src/libcore/rt/sched.rs +++ b/src/libcore/rt/sched.rs @@ -50,11 +50,11 @@ pub struct Scheduler { // complaining type UnsafeTaskReceiver = sys::Closure; trait HackAroundBorrowCk { - static fn from_fn(&fn(&mut Scheduler, ~Task)) -> Self; + fn from_fn(&fn(&mut Scheduler, ~Task)) -> Self; fn to_fn(self) -> &fn(&mut Scheduler, ~Task); } impl HackAroundBorrowCk for UnsafeTaskReceiver { - static fn from_fn(f: &fn(&mut Scheduler, ~Task)) -> UnsafeTaskReceiver { + fn from_fn(f: &fn(&mut Scheduler, ~Task)) -> UnsafeTaskReceiver { unsafe { transmute(f) } } fn to_fn(self) -> &fn(&mut Scheduler, ~Task) { @@ -70,7 +70,7 @@ enum CleanupJob { pub impl Scheduler { - static pub fn new(event_loop: ~EventLoopObject) -> Scheduler { + pub fn new(event_loop: ~EventLoopObject) -> Scheduler { Scheduler { event_loop: event_loop, task_queue: WorkQueue::new(), @@ -114,7 +114,7 @@ pub impl Scheduler { return tlsched.take_scheduler(); } - static fn local(f: &fn(&mut Scheduler)) { + fn local(f: &fn(&mut Scheduler)) { let mut tlsched = ThreadLocalScheduler::new(); f(tlsched.get_scheduler()); } @@ -296,7 +296,7 @@ pub struct Task { } impl Task { - static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task { + pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task { // XXX: Putting main into a ~ so it's a thin pointer and can // be passed to the spawn function. Another unfortunate // allocation @@ -337,7 +337,7 @@ impl Task { struct ThreadLocalScheduler(tls::Key); impl ThreadLocalScheduler { - static fn new() -> ThreadLocalScheduler { + fn new() -> ThreadLocalScheduler { unsafe { // NB: This assumes that the TLS key has been created prior. // Currently done in rust_start. diff --git a/src/libcore/rt/stack.rs b/src/libcore/rt/stack.rs index b5e7d4f3aa2..9b164eb08fa 100644 --- a/src/libcore/rt/stack.rs +++ b/src/libcore/rt/stack.rs @@ -15,7 +15,7 @@ pub struct StackSegment { } pub impl StackSegment { - static fn new(size: uint) -> StackSegment { + fn new(size: uint) -> StackSegment { // Crate a block of uninitialized values let mut stack = vec::with_capacity(size); unsafe { @@ -37,7 +37,7 @@ pub impl StackSegment { pub struct StackPool(()); impl StackPool { - static pub fn new() -> StackPool { StackPool(()) } + pub fn new() -> StackPool { StackPool(()) } fn take_segment(&self, min_size: uint) -> StackSegment { StackSegment::new(min_size) diff --git a/src/libcore/rt/thread.rs b/src/libcore/rt/thread.rs index 5dccf90096e..c45e4295ab1 100644 --- a/src/libcore/rt/thread.rs +++ b/src/libcore/rt/thread.rs @@ -20,7 +20,7 @@ struct Thread { } impl Thread { - static pub fn start(main: ~fn()) -> Thread { + pub fn start(main: ~fn()) -> Thread { fn substart(main: &fn()) -> *raw_thread { unsafe { rust_raw_thread_start(&main) } } diff --git a/src/libcore/rt/uv.rs b/src/libcore/rt/uv.rs index e57d0f51870..4d87bdb02e8 100644 --- a/src/libcore/rt/uv.rs +++ b/src/libcore/rt/uv.rs @@ -74,7 +74,7 @@ impl Callback for NullCallback { } /// A type that wraps a native handle trait NativeHandle<T> { - static pub fn from_native_handle(T) -> Self; + pub fn from_native_handle(T) -> Self; pub fn native_handle(&self) -> T; } @@ -86,7 +86,7 @@ pub struct Loop { } pub impl Loop { - static fn new() -> Loop { + fn new() -> Loop { let handle = unsafe { uvll::loop_new() }; fail_unless!(handle.is_not_null()); NativeHandle::from_native_handle(handle) @@ -102,7 +102,7 @@ pub impl Loop { } impl NativeHandle<*uvll::uv_loop_t> for Loop { - static fn from_native_handle(handle: *uvll::uv_loop_t) -> Loop { + fn from_native_handle(handle: *uvll::uv_loop_t) -> Loop { Loop { handle: handle } } fn native_handle(&self) -> *uvll::uv_loop_t { @@ -132,7 +132,7 @@ type IdleCallback = ~fn(IdleWatcher, Option<UvError>); impl Callback for IdleCallback { } pub impl IdleWatcher { - static fn new(loop_: &mut Loop) -> IdleWatcher { + fn new(loop_: &mut Loop) -> IdleWatcher { unsafe { let handle = uvll::idle_new(); fail_unless!(handle.is_not_null()); @@ -177,7 +177,7 @@ pub impl IdleWatcher { } impl NativeHandle<*uvll::uv_idle_t> for IdleWatcher { - static fn from_native_handle(handle: *uvll::uv_idle_t) -> IdleWatcher { + fn from_native_handle(handle: *uvll::uv_idle_t) -> IdleWatcher { IdleWatcher(handle) } fn native_handle(&self) -> *uvll::uv_idle_t { @@ -307,7 +307,7 @@ pub impl StreamWatcher { } impl NativeHandle<*uvll::uv_stream_t> for StreamWatcher { - static fn from_native_handle( + fn from_native_handle( handle: *uvll::uv_stream_t) -> StreamWatcher { StreamWatcher(handle) } @@ -328,7 +328,7 @@ type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>); impl Callback for ConnectionCallback { } pub impl TcpWatcher { - static fn new(loop_: &mut Loop) -> TcpWatcher { + fn new(loop_: &mut Loop) -> TcpWatcher { unsafe { let size = size_of::<uvll::uv_tcp_t>() as size_t; let handle = malloc(size) as *uvll::uv_tcp_t; @@ -421,7 +421,7 @@ pub impl TcpWatcher { } impl NativeHandle<*uvll::uv_tcp_t> for TcpWatcher { - static fn from_native_handle(handle: *uvll::uv_tcp_t) -> TcpWatcher { + fn from_native_handle(handle: *uvll::uv_tcp_t) -> TcpWatcher { TcpWatcher(handle) } fn native_handle(&self) -> *uvll::uv_tcp_t { @@ -441,7 +441,7 @@ impl Request for ConnectRequest { } impl ConnectRequest { - static fn new() -> ConnectRequest { + fn new() -> ConnectRequest { let connect_handle = unsafe { malloc(size_of::<uvll::uv_connect_t>() as size_t) }; @@ -465,7 +465,7 @@ impl ConnectRequest { } impl NativeHandle<*uvll::uv_connect_t> for ConnectRequest { - static fn from_native_handle( + fn from_native_handle( handle: *uvll:: uv_connect_t) -> ConnectRequest { ConnectRequest(handle) } @@ -480,7 +480,7 @@ impl Request for WriteRequest { } impl WriteRequest { - static fn new() -> WriteRequest { + fn new() -> WriteRequest { let write_handle = unsafe { malloc(size_of::<uvll::uv_write_t>() as size_t) }; @@ -503,7 +503,7 @@ impl WriteRequest { } impl NativeHandle<*uvll::uv_write_t> for WriteRequest { - static fn from_native_handle(handle: *uvll:: uv_write_t) -> WriteRequest { + fn from_native_handle(handle: *uvll:: uv_write_t) -> WriteRequest { WriteRequest(handle) } fn native_handle(&self) -> *uvll::uv_write_t { @@ -518,7 +518,7 @@ struct UvError(uvll::uv_err_t); impl UvError { - pure fn name(&self) -> ~str { + fn name(&self) -> ~str { unsafe { let inner = match self { &UvError(ref a) => a }; let name_str = uvll::err_name(inner); @@ -527,7 +527,7 @@ impl UvError { } } - pure fn desc(&self) -> ~str { + fn desc(&self) -> ~str { unsafe { let inner = match self { &UvError(ref a) => a }; let desc_str = uvll::strerror(inner); @@ -538,7 +538,7 @@ impl UvError { } impl ToStr for UvError { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("%s: %s", self.name(), self.desc()) } } diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs index a971ed92b7e..58a4a65ca90 100644 --- a/src/libcore/rt/uvio.rs +++ b/src/libcore/rt/uvio.rs @@ -29,14 +29,14 @@ pub struct UvEventLoop { } pub impl UvEventLoop { - static fn new() -> UvEventLoop { + fn new() -> UvEventLoop { UvEventLoop { uvio: UvIoFactory(Loop::new()) } } /// A convenience constructor - static fn new_scheduler() -> Scheduler { + fn new_scheduler() -> Scheduler { Scheduler::new(~UvEventLoop::new()) } } @@ -221,7 +221,7 @@ impl TcpListener for UvTcpListener { pub struct UvStream(StreamWatcher); impl UvStream { - static fn new(watcher: StreamWatcher) -> UvStream { + fn new(watcher: StreamWatcher) -> UvStream { UvStream(watcher) } diff --git a/src/libcore/rt/work_queue.rs b/src/libcore/rt/work_queue.rs index 1be2eb26e62..dfa88b783c5 100644 --- a/src/libcore/rt/work_queue.rs +++ b/src/libcore/rt/work_queue.rs @@ -15,7 +15,7 @@ pub struct WorkQueue<T> { } pub impl<T> WorkQueue<T> { - static fn new() -> WorkQueue<T> { + fn new() -> WorkQueue<T> { WorkQueue { queue: ~[] } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 4cfdfabb0e7..fc4d1e387dd 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -44,27 +44,27 @@ Section: Creating a string * * Fails if invalid UTF-8 */ -pub pure fn from_bytes(vv: &[const u8]) -> ~str { +pub fn from_bytes(vv: &[const u8]) -> ~str { fail_unless!(is_utf8(vv)); return unsafe { raw::from_bytes(vv) }; } /// Copy a slice into a new unique str -pub pure fn from_slice(s: &str) -> ~str { +pub fn from_slice(s: &str) -> ~str { unsafe { raw::slice_bytes_unique(s, 0, len(s)) } } impl ToStr for ~str { #[inline(always)] - pure fn to_str(&self) -> ~str { copy *self } + fn to_str(&self) -> ~str { copy *self } } impl ToStr for &'self str { #[inline(always)] - pure fn to_str(&self) -> ~str { ::str::from_slice(*self) } + fn to_str(&self) -> ~str { ::str::from_slice(*self) } } impl ToStr for @str { #[inline(always)] - pure fn to_str(&self) -> ~str { ::str::from_slice(*self) } + fn to_str(&self) -> ~str { ::str::from_slice(*self) } } /** @@ -74,7 +74,7 @@ impl ToStr for @str { * * Fails if invalid UTF-8 */ -pub pure fn from_byte(b: u8) -> ~str { +pub fn from_byte(b: u8) -> ~str { fail_unless!(b < 128u8); unsafe { ::cast::transmute(~[b, 0u8]) } } @@ -151,14 +151,14 @@ pub fn push_char(s: &mut ~str, ch: char) { } /// Convert a char to a string -pub pure fn from_char(ch: char) -> ~str { +pub fn from_char(ch: char) -> ~str { let mut buf = ~""; unsafe { push_char(&mut buf, ch); } buf } /// Convert a vector of chars to a string -pub pure fn from_chars(chs: &[char]) -> ~str { +pub fn from_chars(chs: &[char]) -> ~str { let mut buf = ~""; unsafe { reserve(&mut buf, chs.len()); @@ -206,7 +206,7 @@ pub fn push_str(lhs: &mut ~str, rhs: &str) { /// Concatenate two strings together #[inline(always)] -pub pure fn append(lhs: ~str, rhs: &str) -> ~str { +pub fn append(lhs: ~str, rhs: &str) -> ~str { let mut v = lhs; unsafe { push_str_no_overallocate(&mut v, rhs); @@ -216,7 +216,7 @@ pub pure fn append(lhs: ~str, rhs: &str) -> ~str { /// Concatenate a vector of strings -pub pure fn concat(v: &[~str]) -> ~str { +pub fn concat(v: &[~str]) -> ~str { let mut s: ~str = ~""; for vec::each(v) |ss| { unsafe { push_str(&mut s, *ss) }; @@ -225,7 +225,7 @@ pub pure fn concat(v: &[~str]) -> ~str { } /// Concatenate a vector of strings, placing a given separator between each -pub pure fn connect(v: &[~str], sep: &str) -> ~str { +pub fn connect(v: &[~str], sep: &str) -> ~str { let mut s = ~"", first = true; for vec::each(v) |ss| { if first { first = false; } else { unsafe { push_str(&mut s, sep); } } @@ -235,7 +235,7 @@ pub pure fn connect(v: &[~str], sep: &str) -> ~str { } /// Concatenate a vector of strings, placing a given separator between each -pub pure fn connect_slices(v: &[&str], sep: &str) -> ~str { +pub fn connect_slices(v: &[&str], sep: &str) -> ~str { let mut s = ~"", first = true; for vec::each(v) |ss| { if first { first = false; } else { unsafe { push_str(&mut s, sep); } } @@ -245,7 +245,7 @@ pub pure fn connect_slices(v: &[&str], sep: &str) -> ~str { } /// Given a string, make a new string with repeated copies of it -pub pure fn repeat(ss: &str, nn: uint) -> ~str { +pub fn repeat(ss: &str, nn: uint) -> ~str { let mut acc = ~""; for nn.times { acc += ss; } acc @@ -313,7 +313,7 @@ pub fn unshift_char(s: &mut ~str, ch: char) { * * chars_to_trim - A vector of chars * */ -pub pure fn trim_left_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { +pub fn trim_left_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { if chars_to_trim.is_empty() { return s; } match find(s, |c| !chars_to_trim.contains(&c)) { @@ -331,7 +331,7 @@ pub pure fn trim_left_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { * * chars_to_trim - A vector of chars * */ -pub pure fn trim_right_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { +pub fn trim_right_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { if chars_to_trim.is_empty() { return s; } match rfind(s, |c| !chars_to_trim.contains(&c)) { @@ -352,12 +352,12 @@ pub pure fn trim_right_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { * * chars_to_trim - A vector of chars * */ -pub pure fn trim_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { +pub fn trim_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str { trim_left_chars(trim_right_chars(s, chars_to_trim), chars_to_trim) } /// Returns a string with leading whitespace removed -pub pure fn trim_left(s: &'a str) -> &'a str { +pub fn trim_left(s: &'a str) -> &'a str { match find(s, |c| !char::is_whitespace(c)) { None => "", Some(first) => unsafe { raw::slice_bytes(s, first, len(s)) } @@ -365,7 +365,7 @@ pub pure fn trim_left(s: &'a str) -> &'a str { } /// Returns a string with trailing whitespace removed -pub pure fn trim_right(s: &'a str) -> &'a str { +pub fn trim_right(s: &'a str) -> &'a str { match rfind(s, |c| !char::is_whitespace(c)) { None => "", Some(last) => { @@ -376,7 +376,7 @@ pub pure fn trim_right(s: &'a str) -> &'a str { } /// Returns a string with leading and trailing whitespace removed -pub pure fn trim(s: &'a str) -> &'a str { trim_left(trim_right(s)) } +pub fn trim(s: &'a str) -> &'a str { trim_left(trim_right(s)) } /* Section: Transforming strings @@ -387,7 +387,7 @@ Section: Transforming strings * * The result vector is not null-terminated. */ -pub pure fn to_bytes(s: &str) -> ~[u8] { +pub fn to_bytes(s: &str) -> ~[u8] { unsafe { let mut v: ~[u8] = ::cast::transmute(from_slice(s)); vec::raw::set_len(&mut v, len(s)); @@ -397,14 +397,14 @@ pub pure fn to_bytes(s: &str) -> ~[u8] { /// Work with the string as a byte slice, not including trailing null. #[inline(always)] -pub pure fn byte_slice<T>(s: &str, f: &fn(v: &[u8]) -> T) -> T { +pub fn byte_slice<T>(s: &str, f: &fn(v: &[u8]) -> T) -> T { do as_buf(s) |p,n| { unsafe { vec::raw::buf_as_slice(p, n-1u, f) } } } /// Convert a string to a vector of characters -pub pure fn chars(s: &str) -> ~[char] { +pub fn chars(s: &str) -> ~[char] { let mut buf = ~[], i = 0; let len = len(s); while i < len { @@ -421,7 +421,7 @@ pub pure fn chars(s: &str) -> ~[char] { * Returns a string containing `n` characters starting at byte offset * `begin`. */ -pub pure fn substr(s: &'a str, begin: uint, n: uint) -> &'a str { +pub fn substr(s: &'a str, begin: uint, n: uint) -> &'a str { slice(s, begin, begin + count_bytes(s, begin, n)) } @@ -431,7 +431,7 @@ pub pure fn substr(s: &'a str, begin: uint, n: uint) -> &'a str { * Fails when `begin` and `end` do not point to valid characters or beyond * the last character of the string */ -pub pure fn slice(s: &'a str, begin: uint, end: uint) -> &'a str { +pub fn slice(s: &'a str, begin: uint, end: uint) -> &'a str { fail_unless!(is_char_boundary(s, begin)); fail_unless!(is_char_boundary(s, end)); unsafe { raw::slice_bytes(s, begin, end) } @@ -439,7 +439,7 @@ pub pure fn slice(s: &'a str, begin: uint, end: uint) -> &'a str { /// Splits a string into substrings at each occurrence of a given /// character. -pub pure fn split_char(s: &str, sep: char) -> ~[~str] { +pub fn split_char(s: &str, sep: char) -> ~[~str] { split_char_inner(s, sep, len(s), true, true) } @@ -449,12 +449,12 @@ pub pure fn split_char(s: &str, sep: char) -> ~[~str] { * * The byte must be a valid UTF-8/ASCII byte */ -pub pure fn splitn_char(s: &str, sep: char, count: uint) -> ~[~str] { +pub fn splitn_char(s: &str, sep: char, count: uint) -> ~[~str] { split_char_inner(s, sep, count, true, true) } /// Like `split_char`, but omits empty strings from the returned vector -pub pure fn split_char_nonempty(s: &str, sep: char) -> ~[~str] { +pub fn split_char_nonempty(s: &str, sep: char) -> ~[~str] { split_char_inner(s, sep, len(s), false, false) } @@ -462,12 +462,12 @@ pub pure fn split_char_nonempty(s: &str, sep: char) -> ~[~str] { * Like `split_char`, but a trailing empty string is omitted * (e.g. `split_char_no_trailing("A B ",' ') == ~[~"A",~"B"]`) */ -pub pure fn split_char_no_trailing(s: &str, sep: char) -> ~[~str] { +pub fn split_char_no_trailing(s: &str, sep: char) -> ~[~str] { split_char_inner(s, sep, len(s), true, false) } -pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool, - allow_trailing_empty: bool) -> ~[~str] { +fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool, + allow_trailing_empty: bool) -> ~[~str] { if sep < 128u as char { let b = sep as u8, l = len(s); let mut result = ~[], done = 0u; @@ -496,7 +496,7 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool, /// Splits a string into substrings using a character function -pub pure fn split(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { +pub fn split(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { split_inner(s, sepfn, len(s), true, true) } @@ -504,7 +504,7 @@ pub pure fn split(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { * Splits a string into substrings using a character function, cutting at * most `count` times. */ -pub pure fn splitn(s: &str, +pub fn splitn(s: &str, sepfn: &fn(char) -> bool, count: uint) -> ~[~str] { @@ -512,7 +512,7 @@ pub pure fn splitn(s: &str, } /// Like `split`, but omits empty strings from the returned vector -pub pure fn split_nonempty(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { +pub fn split_nonempty(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { split_inner(s, sepfn, len(s), false, false) } @@ -521,11 +521,11 @@ pub pure fn split_nonempty(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { * Like `split`, but a trailing empty string is omitted * (e.g. `split_no_trailing("A B ",' ') == ~[~"A",~"B"]`) */ -pub pure fn split_no_trailing(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { +pub fn split_no_trailing(s: &str, sepfn: &fn(char) -> bool) -> ~[~str] { split_inner(s, sepfn, len(s), true, false) } -pure fn split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint, +fn split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint, allow_empty: bool, allow_trailing_empty: bool) -> ~[~str] { let l = len(s); let mut result = ~[], i = 0u, start = 0u, done = 0u; @@ -551,7 +551,7 @@ pure fn split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint, } // See Issue #1932 for why this is a naive search -pure fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { +fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { let sep_len = len(sep), l = len(s); fail_unless!(sep_len > 0u); let mut i = 0u, match_start = 0u, match_i = 0u; @@ -578,7 +578,7 @@ pure fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { } } -pure fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { +fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { let mut last_end = 0u; do iter_matches(s, sep) |from, to| { f(last_end, from); @@ -596,7 +596,7 @@ pure fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) { * fail_unless!(["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", ".")) * ~~~ */ -pub pure fn split_str(s: &'a str, sep: &'b str) -> ~[~str] { +pub fn split_str(s: &'a str, sep: &'b str) -> ~[~str] { let mut result = ~[]; do iter_between_matches(s, sep) |from, to| { unsafe { result.push(raw::slice_bytes_unique(s, from, to)); } @@ -604,7 +604,7 @@ pub pure fn split_str(s: &'a str, sep: &'b str) -> ~[~str] { result } -pub pure fn split_str_nonempty(s: &'a str, sep: &'b str) -> ~[~str] { +pub fn split_str_nonempty(s: &'a str, sep: &'b str) -> ~[~str] { let mut result = ~[]; do iter_between_matches(s, sep) |from, to| { if to > from { @@ -651,7 +651,7 @@ pub fn levdistance(s: &str, t: &str) -> uint { /** * Splits a string into a vector of the substrings separated by LF ('\n'). */ -pub pure fn lines(s: &str) -> ~[~str] { +pub fn lines(s: &str) -> ~[~str] { split_char_no_trailing(s, '\n') } @@ -659,7 +659,7 @@ pub pure fn lines(s: &str) -> ~[~str] { * Splits a string into a vector of the substrings separated by LF ('\n') * and/or CR LF ("\r\n") */ -pub pure fn lines_any(s: &str) -> ~[~str] { +pub fn lines_any(s: &str) -> ~[~str] { vec::map(lines(s), |s| { let l = len(*s); let mut cp = copy *s; @@ -671,7 +671,7 @@ pub pure fn lines_any(s: &str) -> ~[~str] { } /// Splits a string into a vector of the substrings separated by whitespace -pub pure fn words(s: &str) -> ~[~str] { +pub fn words(s: &str) -> ~[~str] { split_nonempty(s, char::is_whitespace) } @@ -710,14 +710,14 @@ pub fn split_within(ss: &str, lim: uint) -> ~[~str] { /// Convert a string to lowercase. ASCII only -pub pure fn to_lower(s: &str) -> ~str { +pub fn to_lower(s: &str) -> ~str { map(s, |c| unsafe{(libc::tolower(c as libc::c_char)) as char} ) } /// Convert a string to uppercase. ASCII only -pub pure fn to_upper(s: &str) -> ~str { +pub fn to_upper(s: &str) -> ~str { map(s, |c| unsafe{(libc::toupper(c as libc::c_char)) as char} ) @@ -736,7 +736,7 @@ pub pure fn to_upper(s: &str) -> ~str { * * The original string with all occurances of `from` replaced with `to` */ -pub pure fn replace(s: &str, from: &str, to: &str) -> ~str { +pub fn replace(s: &str, from: &str, to: &str) -> ~str { let mut result = ~"", first = true; do iter_between_matches(s, from) |start, end| { if first { @@ -756,7 +756,7 @@ Section: Comparing strings /// Bytewise slice equality #[cfg(notest)] #[lang="str_eq"] -pub pure fn eq_slice(a: &str, b: &str) -> bool { +pub fn eq_slice(a: &str, b: &str) -> bool { do as_buf(a) |ap, alen| { do as_buf(b) |bp, blen| { if (alen != blen) { false } @@ -772,7 +772,7 @@ pub pure fn eq_slice(a: &str, b: &str) -> bool { } #[cfg(test)] -pub pure fn eq_slice(a: &str, b: &str) -> bool { +pub fn eq_slice(a: &str, b: &str) -> bool { do as_buf(a) |ap, alen| { do as_buf(b) |bp, blen| { if (alen != blen) { false } @@ -790,16 +790,16 @@ pub pure fn eq_slice(a: &str, b: &str) -> bool { /// Bytewise string equality #[cfg(notest)] #[lang="uniq_str_eq"] -pub pure fn eq(a: &~str, b: &~str) -> bool { +pub fn eq(a: &~str, b: &~str) -> bool { eq_slice(*a, *b) } #[cfg(test)] -pub pure fn eq(a: &~str, b: &~str) -> bool { +pub fn eq(a: &~str, b: &~str) -> bool { eq_slice(*a, *b) } -pure fn cmp(a: &str, b: &str) -> Ordering { +fn cmp(a: &str, b: &str) -> Ordering { let low = uint::min(a.len(), b.len()); for uint::range(0, low) |idx| { @@ -815,21 +815,21 @@ pure fn cmp(a: &str, b: &str) -> Ordering { #[cfg(notest)] impl TotalOrd for &'self str { - pure fn cmp(&self, other: & &'self str) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: & &'self str) -> Ordering { cmp(*self, *other) } } #[cfg(notest)] impl TotalOrd for ~str { - pure fn cmp(&self, other: &~str) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: &~str) -> Ordering { cmp(*self, *other) } } #[cfg(notest)] impl TotalOrd for @str { - pure fn cmp(&self, other: &@str) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: &@str) -> Ordering { cmp(*self, *other) } } /// Bytewise slice less than -pure fn lt(a: &str, b: &str) -> bool { +fn lt(a: &str, b: &str) -> bool { let (a_len, b_len) = (a.len(), b.len()); let mut end = uint::min(a_len, b_len); @@ -845,90 +845,90 @@ pure fn lt(a: &str, b: &str) -> bool { } /// Bytewise less than or equal -pub pure fn le(a: &str, b: &str) -> bool { +pub fn le(a: &str, b: &str) -> bool { !lt(b, a) } /// Bytewise greater than or equal -pure fn ge(a: &str, b: &str) -> bool { +fn ge(a: &str, b: &str) -> bool { !lt(a, b) } /// Bytewise greater than -pure fn gt(a: &str, b: &str) -> bool { +fn gt(a: &str, b: &str) -> bool { !le(a, b) } #[cfg(notest)] impl Eq for &'self str { #[inline(always)] - pure fn eq(&self, other: & &'self str) -> bool { + fn eq(&self, other: & &'self str) -> bool { eq_slice((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: & &'self str) -> bool { !(*self).eq(other) } + fn ne(&self, other: & &'self str) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl Eq for ~str { #[inline(always)] - pure fn eq(&self, other: &~str) -> bool { + fn eq(&self, other: &~str) -> bool { eq_slice((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: &~str) -> bool { !(*self).eq(other) } + fn ne(&self, other: &~str) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl Eq for @str { #[inline(always)] - pure fn eq(&self, other: &@str) -> bool { + fn eq(&self, other: &@str) -> bool { eq_slice((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: &@str) -> bool { !(*self).eq(other) } + fn ne(&self, other: &@str) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl Ord for ~str { #[inline(always)] - pure fn lt(&self, other: &~str) -> bool { lt((*self), (*other)) } + fn lt(&self, other: &~str) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: &~str) -> bool { le((*self), (*other)) } + fn le(&self, other: &~str) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: &~str) -> bool { ge((*self), (*other)) } + fn ge(&self, other: &~str) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: &~str) -> bool { gt((*self), (*other)) } + fn gt(&self, other: &~str) -> bool { gt((*self), (*other)) } } #[cfg(notest)] impl Ord for &'self str { #[inline(always)] - pure fn lt(&self, other: & &'self str) -> bool { lt((*self), (*other)) } + fn lt(&self, other: & &'self str) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: & &'self str) -> bool { le((*self), (*other)) } + fn le(&self, other: & &'self str) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: & &'self str) -> bool { ge((*self), (*other)) } + fn ge(&self, other: & &'self str) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: & &'self str) -> bool { gt((*self), (*other)) } + fn gt(&self, other: & &'self str) -> bool { gt((*self), (*other)) } } #[cfg(notest)] impl Ord for @str { #[inline(always)] - pure fn lt(&self, other: &@str) -> bool { lt((*self), (*other)) } + fn lt(&self, other: &@str) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: &@str) -> bool { le((*self), (*other)) } + fn le(&self, other: &@str) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: &@str) -> bool { ge((*self), (*other)) } + fn ge(&self, other: &@str) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: &@str) -> bool { gt((*self), (*other)) } + fn gt(&self, other: &@str) -> bool { gt((*self), (*other)) } } #[cfg(notest)] impl Equiv<~str> for &'self str { #[inline(always)] - pure fn equiv(&self, other: &~str) -> bool { eq_slice(*self, *other) } + fn equiv(&self, other: &~str) -> bool { eq_slice(*self, *other) } } /* @@ -939,7 +939,7 @@ Section: Iterating through strings * Return true if a predicate matches all characters or if the string * contains no characters */ -pub pure fn all(s: &str, it: &fn(char) -> bool) -> bool { +pub fn all(s: &str, it: &fn(char) -> bool) -> bool { all_between(s, 0u, len(s), it) } @@ -947,12 +947,12 @@ pub pure fn all(s: &str, it: &fn(char) -> bool) -> bool { * Return true if a predicate matches any character (and false if it * matches none or there are no characters) */ -pub pure fn any(ss: &str, pred: &fn(char) -> bool) -> bool { +pub fn any(ss: &str, pred: &fn(char) -> bool) -> bool { !all(ss, |cc| !pred(cc)) } /// Apply a function to each character -pub pure fn map(ss: &str, ff: &fn(char) -> char) -> ~str { +pub fn map(ss: &str, ff: &fn(char) -> char) -> ~str { let mut result = ~""; unsafe { reserve(&mut result, len(ss)); @@ -965,13 +965,13 @@ pub pure fn map(ss: &str, ff: &fn(char) -> char) -> ~str { /// Iterate over the bytes in a string #[inline(always)] -pub pure fn each(s: &str, it: &fn(u8) -> bool) { +pub fn each(s: &str, it: &fn(u8) -> bool) { eachi(s, |_i, b| it(b)) } /// Iterate over the bytes in a string, with indices #[inline(always)] -pub pure fn eachi(s: &str, it: &fn(uint, u8) -> bool) { +pub fn eachi(s: &str, it: &fn(uint, u8) -> bool) { let mut pos = 0; let len = s.len(); @@ -983,13 +983,13 @@ pub pure fn eachi(s: &str, it: &fn(uint, u8) -> bool) { /// Iterate over the bytes in a string in reverse #[inline(always)] -pub pure fn each_reverse(s: &str, it: &fn(u8) -> bool) { +pub fn each_reverse(s: &str, it: &fn(u8) -> bool) { eachi_reverse(s, |_i, b| it(b) ) } /// Iterate over the bytes in a string in reverse, with indices #[inline(always)] -pub pure fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) { +pub fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) { let mut pos = s.len(); while pos > 0 { pos -= 1; @@ -999,13 +999,13 @@ pub pure fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) { /// Iterates over the chars in a string #[inline(always)] -pub pure fn each_char(s: &str, it: &fn(char) -> bool) { +pub fn each_char(s: &str, it: &fn(char) -> bool) { each_chari(s, |_i, c| it(c)) } /// Iterates over the chars in a string, with indices #[inline(always)] -pub pure fn each_chari(s: &str, it: &fn(uint, char) -> bool) { +pub fn each_chari(s: &str, it: &fn(uint, char) -> bool) { let mut pos = 0; let mut ch_pos = 0u; let len = s.len(); @@ -1019,7 +1019,7 @@ pub pure fn each_chari(s: &str, it: &fn(uint, char) -> bool) { /// Iterates over the chars in a string in reverse #[inline(always)] -pub pure fn each_char_reverse(s: &str, it: &fn(char) -> bool) { +pub fn each_char_reverse(s: &str, it: &fn(char) -> bool) { let mut pos = 0; let len = s.char_len(); while pos > 0 { @@ -1031,7 +1031,7 @@ pub pure fn each_char_reverse(s: &str, it: &fn(char) -> bool) { // Iterates over the chars in a string in reverse, with indices #[inline(always)] -pub pure fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) { +pub fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) { let mut ch_pos = s.char_len(); for s.each_char_reverse |ch| { ch_pos -= 1; @@ -1040,7 +1040,7 @@ pub pure fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) { } /// Apply a function to each substring after splitting by character -pub pure fn split_char_each(ss: &str, cc: char, ff: &fn(v: &str) -> bool) { +pub fn split_char_each(ss: &str, cc: char, ff: &fn(v: &str) -> bool) { vec::each(split_char(ss, cc), |s| ff(*s)) } @@ -1048,20 +1048,20 @@ pub pure fn split_char_each(ss: &str, cc: char, ff: &fn(v: &str) -> bool) { * Apply a function to each substring after splitting by character, up to * `count` times */ -pub pure fn splitn_char_each(ss: &str, sep: char, count: uint, +pub fn splitn_char_each(ss: &str, sep: char, count: uint, ff: &fn(v: &str) -> bool) { vec::each(splitn_char(ss, sep, count), |s| ff(*s)) } /// Apply a function to each word -pub pure fn words_each(ss: &str, ff: &fn(v: &str) -> bool) { +pub fn words_each(ss: &str, ff: &fn(v: &str) -> bool) { vec::each(words(ss), |s| ff(*s)) } /** * Apply a function to each line (by '\n') */ -pub pure fn lines_each(ss: &str, ff: &fn(v: &str) -> bool) { +pub fn lines_each(ss: &str, ff: &fn(v: &str) -> bool) { vec::each(lines(ss), |s| ff(*s)) } @@ -1082,7 +1082,7 @@ Section: Searching * An `option` containing the byte index of the first matching character * or `none` if there is no match */ -pub pure fn find_char(s: &str, c: char) -> Option<uint> { +pub fn find_char(s: &str, c: char) -> Option<uint> { find_char_between(s, c, 0u, len(s)) } @@ -1106,7 +1106,7 @@ pub pure fn find_char(s: &str, c: char) -> Option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be the * index of a character boundary, as defined by `is_char_boundary`. */ -pub pure fn find_char_from(s: &str, c: char, start: uint) -> Option<uint> { +pub fn find_char_from(s: &str, c: char, start: uint) -> Option<uint> { find_char_between(s, c, start, len(s)) } @@ -1131,7 +1131,7 @@ pub pure fn find_char_from(s: &str, c: char, start: uint) -> Option<uint> { * or equal to `len(s)`. `start` must be the index of a character boundary, * as defined by `is_char_boundary`. */ -pub pure fn find_char_between(s: &str, c: char, start: uint, end: uint) +pub fn find_char_between(s: &str, c: char, start: uint, end: uint) -> Option<uint> { if c < 128u as char { fail_unless!(start <= end); @@ -1161,7 +1161,7 @@ pub pure fn find_char_between(s: &str, c: char, start: uint, end: uint) * An `option` containing the byte index of the last matching character * or `none` if there is no match */ -pub pure fn rfind_char(s: &str, c: char) -> Option<uint> { +pub fn rfind_char(s: &str, c: char) -> Option<uint> { rfind_char_between(s, c, len(s), 0u) } @@ -1185,7 +1185,7 @@ pub pure fn rfind_char(s: &str, c: char) -> Option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be * the index of a character boundary, as defined by `is_char_boundary`. */ -pub pure fn rfind_char_from(s: &str, c: char, start: uint) -> Option<uint> { +pub fn rfind_char_from(s: &str, c: char, start: uint) -> Option<uint> { rfind_char_between(s, c, start, 0u) } @@ -1210,7 +1210,7 @@ pub pure fn rfind_char_from(s: &str, c: char, start: uint) -> Option<uint> { * or equal to `len(s)`. `start` must be the index of a character boundary, * as defined by `is_char_boundary`. */ -pub pure fn rfind_char_between(s: &str, c: char, start: uint, end: uint) +pub fn rfind_char_between(s: &str, c: char, start: uint, end: uint) -> Option<uint> { if c < 128u as char { fail_unless!(start >= end); @@ -1241,7 +1241,7 @@ pub pure fn rfind_char_between(s: &str, c: char, start: uint, end: uint) * An `option` containing the byte index of the first matching character * or `none` if there is no match */ -pub pure fn find(s: &str, f: &fn(char) -> bool) -> Option<uint> { +pub fn find(s: &str, f: &fn(char) -> bool) -> Option<uint> { find_between(s, 0u, len(s), f) } @@ -1265,7 +1265,7 @@ pub pure fn find(s: &str, f: &fn(char) -> bool) -> Option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be the * index of a character boundary, as defined by `is_char_boundary`. */ -pub pure fn find_from(s: &str, start: uint, f: &fn(char) +pub fn find_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option<uint> { find_between(s, start, len(s), f) } @@ -1292,7 +1292,7 @@ pub pure fn find_from(s: &str, start: uint, f: &fn(char) * or equal to `len(s)`. `start` must be the index of a character * boundary, as defined by `is_char_boundary`. */ -pub pure fn find_between(s: &str, +pub fn find_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) @@ -1323,7 +1323,7 @@ pub pure fn find_between(s: &str, * An option containing the byte index of the last matching character * or `none` if there is no match */ -pub pure fn rfind(s: &str, f: &fn(char) -> bool) -> Option<uint> { +pub fn rfind(s: &str, f: &fn(char) -> bool) -> Option<uint> { rfind_between(s, len(s), 0u, f) } @@ -1347,7 +1347,7 @@ pub pure fn rfind(s: &str, f: &fn(char) -> bool) -> Option<uint> { * `start` must be less than or equal to `len(s)', `start` must be the * index of a character boundary, as defined by `is_char_boundary` */ -pub pure fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) +pub fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option<uint> { rfind_between(s, start, 0u, f) } @@ -1374,7 +1374,7 @@ pub pure fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) * than or equal to `len(s)`. `start` must be the index of a character * boundary, as defined by `is_char_boundary` */ -pub pure fn rfind_between(s: &str, start: uint, end: uint, +pub fn rfind_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) -> Option<uint> { fail_unless!(start >= end); @@ -1390,7 +1390,7 @@ pub pure fn rfind_between(s: &str, start: uint, end: uint, } // Utility used by various searching functions -pure fn match_at(haystack: &'a str, needle: &'b str, at: uint) -> bool { +fn match_at(haystack: &'a str, needle: &'b str, at: uint) -> bool { let mut i = at; for each(needle) |c| { if haystack[i] != c { return false; } i += 1u; } return true; @@ -1409,7 +1409,7 @@ pure fn match_at(haystack: &'a str, needle: &'b str, at: uint) -> bool { * An `option` containing the byte index of the first matching substring * or `none` if there is no match */ -pub pure fn find_str(haystack: &'a str, needle: &'b str) -> Option<uint> { +pub fn find_str(haystack: &'a str, needle: &'b str) -> Option<uint> { find_str_between(haystack, needle, 0u, len(haystack)) } @@ -1432,7 +1432,7 @@ pub pure fn find_str(haystack: &'a str, needle: &'b str) -> Option<uint> { * * `start` must be less than or equal to `len(s)` */ -pub pure fn find_str_from(haystack: &'a str, needle: &'b str, start: uint) +pub fn find_str_from(haystack: &'a str, needle: &'b str, start: uint) -> Option<uint> { find_str_between(haystack, needle, start, len(haystack)) } @@ -1457,7 +1457,7 @@ pub pure fn find_str_from(haystack: &'a str, needle: &'b str, start: uint) * `start` must be less than or equal to `end` and `end` must be less than * or equal to `len(s)`. */ -pub pure fn find_str_between(haystack: &'a str, needle: &'b str, start: uint, +pub fn find_str_between(haystack: &'a str, needle: &'b str, start: uint, end:uint) -> Option<uint> { // See Issue #1932 for why this is a naive search @@ -1483,7 +1483,7 @@ pub pure fn find_str_between(haystack: &'a str, needle: &'b str, start: uint, * * haystack - The string to look in * * needle - The string to look for */ -pub pure fn contains(haystack: &'a str, needle: &'b str) -> bool { +pub fn contains(haystack: &'a str, needle: &'b str) -> bool { find_str(haystack, needle).is_some() } @@ -1495,7 +1495,7 @@ pub pure fn contains(haystack: &'a str, needle: &'b str) -> bool { * * haystack - The string to look in * * needle - The char to look for */ -pub pure fn contains_char(haystack: &str, needle: char) -> bool { +pub fn contains_char(haystack: &str, needle: char) -> bool { find_char(haystack, needle).is_some() } @@ -1507,7 +1507,7 @@ pub pure fn contains_char(haystack: &str, needle: char) -> bool { * * haystack - The string to look in * * needle - The string to look for */ -pub pure fn starts_with(haystack: &'a str, needle: &'b str) -> bool { +pub fn starts_with(haystack: &'a str, needle: &'b str) -> bool { let haystack_len = len(haystack), needle_len = len(needle); if needle_len == 0u { true } else if needle_len > haystack_len { false } @@ -1522,7 +1522,7 @@ pub pure fn starts_with(haystack: &'a str, needle: &'b str) -> bool { * * haystack - The string to look in * * needle - The string to look for */ -pub pure fn ends_with(haystack: &'a str, needle: &'b str) -> bool { +pub fn ends_with(haystack: &'a str, needle: &'b str) -> bool { let haystack_len = len(haystack), needle_len = len(needle); if needle_len == 0u { true } else if needle_len > haystack_len { false } @@ -1534,21 +1534,21 @@ Section: String properties */ /// Determines if a string contains only ASCII characters -pub pure fn is_ascii(s: &str) -> bool { +pub fn is_ascii(s: &str) -> bool { let mut i: uint = len(s); while i > 0u { i -= 1u; if !u8::is_ascii(s[i]) { return false; } } return true; } /// Returns true if the string has length 0 -pub pure fn is_empty(s: &str) -> bool { len(s) == 0u } +pub fn is_empty(s: &str) -> bool { len(s) == 0u } /** * Returns true if the string contains only whitespace * * Whitespace characters are determined by `char::is_whitespace` */ -pub pure fn is_whitespace(s: &str) -> bool { +pub fn is_whitespace(s: &str) -> bool { return all(s, char::is_whitespace); } @@ -1557,24 +1557,24 @@ pub pure fn is_whitespace(s: &str) -> bool { * * Alphanumeric characters are determined by `char::is_alphanumeric` */ -pure fn is_alphanumeric(s: &str) -> bool { +fn is_alphanumeric(s: &str) -> bool { return all(s, char::is_alphanumeric); } /// Returns the string length/size in bytes not counting the null terminator -pub pure fn len(s: &str) -> uint { +pub fn len(s: &str) -> uint { do as_buf(s) |_p, n| { n - 1u } } /// Returns the number of characters that a string holds -pub pure fn char_len(s: &str) -> uint { count_chars(s, 0u, len(s)) } +pub fn char_len(s: &str) -> uint { count_chars(s, 0u, len(s)) } /* Section: Misc */ /// Determines if a vector of bytes contains valid UTF-8 -pub pure fn is_utf8(v: &[const u8]) -> bool { +pub fn is_utf8(v: &[const u8]) -> bool { let mut i = 0u; let total = vec::len::<u8>(v); while i < total { @@ -1592,7 +1592,7 @@ pub pure fn is_utf8(v: &[const u8]) -> bool { } /// Determines if a vector of `u16` contains valid UTF-16 -pub pure fn is_utf16(v: &[u16]) -> bool { +pub fn is_utf16(v: &[u16]) -> bool { let len = vec::len(v); let mut i = 0u; while (i < len) { @@ -1613,7 +1613,7 @@ pub pure fn is_utf16(v: &[u16]) -> bool { } /// Converts to a vector of `u16` encoded as UTF-16 -pub pure fn to_utf16(s: &str) -> ~[u16] { +pub fn to_utf16(s: &str) -> ~[u16] { let mut u = ~[]; for s.each_char |ch| { // Arithmetic with u32 literals is easier on the eyes than chars. @@ -1638,7 +1638,7 @@ pub pure fn to_utf16(s: &str) -> ~[u16] { u } -pub pure fn utf16_chars(v: &[u16], f: &fn(char)) { +pub fn utf16_chars(v: &[u16], f: &fn(char)) { let len = vec::len(v); let mut i = 0u; while (i < len && v[i] != 0u16) { @@ -1663,7 +1663,7 @@ pub pure fn utf16_chars(v: &[u16], f: &fn(char)) { } -pub pure fn from_utf16(v: &[u16]) -> ~str { +pub fn from_utf16(v: &[u16]) -> ~str { let mut buf = ~""; unsafe { reserve(&mut buf, vec::len(v)); @@ -1672,7 +1672,7 @@ pub pure fn from_utf16(v: &[u16]) -> ~str { buf } -pub pure fn with_capacity(capacity: uint) -> ~str { +pub fn with_capacity(capacity: uint) -> ~str { let mut buf = ~""; unsafe { reserve(&mut buf, capacity); } buf @@ -1691,7 +1691,7 @@ pub pure fn with_capacity(capacity: uint) -> ~str { * * The number of Unicode characters in `s` between the given indices. */ -pub pure fn count_chars(s: &str, start: uint, end: uint) -> uint { +pub fn count_chars(s: &str, start: uint, end: uint) -> uint { fail_unless!(is_char_boundary(s, start)); fail_unless!(is_char_boundary(s, end)); let mut i = start, len = 0u; @@ -1704,7 +1704,7 @@ pub pure fn count_chars(s: &str, start: uint, end: uint) -> uint { } /// Counts the number of bytes taken by the `n` in `s` starting from `start`. -pub pure fn count_bytes(s: &'b str, start: uint, n: uint) -> uint { +pub fn count_bytes(s: &'b str, start: uint, n: uint) -> uint { fail_unless!(is_char_boundary(s, start)); let mut end = start, cnt = n; let l = len(s); @@ -1718,7 +1718,7 @@ pub pure fn count_bytes(s: &'b str, start: uint, n: uint) -> uint { } /// Given a first byte, determine how many bytes are in this UTF-8 character -pub pure fn utf8_char_width(b: u8) -> uint { +pub fn utf8_char_width(b: u8) -> uint { let byte: uint = b as uint; if byte < 128u { return 1u; } // Not a valid start byte @@ -1734,7 +1734,7 @@ pub pure fn utf8_char_width(b: u8) -> uint { * Returns false if the index points into the middle of a multi-byte * character sequence. */ -pub pure fn is_char_boundary(s: &str, index: uint) -> bool { +pub fn is_char_boundary(s: &str, index: uint) -> bool { if index == len(s) { return true; } let b = s[index]; return b < 128u8 || b >= 192u8; @@ -1789,7 +1789,7 @@ pub pure fn is_char_boundary(s: &str, index: uint) -> bool { * If `i` is greater than or equal to the length of the string. * If `i` is not the index of the beginning of a valid UTF-8 character. */ -pub pure fn char_range_at(s: &str, i: uint) -> CharRange { +pub fn char_range_at(s: &str, i: uint) -> CharRange { let b0 = s[i]; let w = utf8_char_width(b0); fail_unless!((w != 0u)); @@ -1812,7 +1812,7 @@ pub pure fn char_range_at(s: &str, i: uint) -> CharRange { } /// Plucks the `n`th character from the beginning of a string -pub pure fn char_at(s: &str, i: uint) -> char { +pub fn char_at(s: &str, i: uint) -> char { return char_range_at(s, i).ch; } @@ -1826,7 +1826,7 @@ pub struct CharRange { * * This function can be used to iterate over a unicode string in reverse. */ -pure fn char_range_at_reverse(ss: &str, start: uint) -> CharRange { +fn char_range_at_reverse(ss: &str, start: uint) -> CharRange { let mut prev = start; // while there is a previous byte == 10...... @@ -1842,7 +1842,7 @@ pure fn char_range_at_reverse(ss: &str, start: uint) -> CharRange { } /// Plucks the `n`th character from the end of a string -pub pure fn char_at_reverse(s: &str, i: uint) -> char { +pub fn char_at_reverse(s: &str, i: uint) -> char { char_range_at_reverse(s, i).ch } @@ -1868,7 +1868,7 @@ pub pure fn char_at_reverse(s: &str, i: uint) -> char { * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ -pub pure fn all_between(s: &str, start: uint, end: uint, +pub fn all_between(s: &str, start: uint, end: uint, it: &fn(char) -> bool) -> bool { fail_unless!(is_char_boundary(s, start)); let mut i = start; @@ -1901,7 +1901,7 @@ pub pure fn all_between(s: &str, start: uint, end: uint, * * `true` if `it` returns `true` for any character */ -pub pure fn any_between(s: &str, start: uint, end: uint, +pub fn any_between(s: &str, start: uint, end: uint, it: &fn(char) -> bool) -> bool { !all_between(s, start, end, |c| !it(c)) } @@ -1940,7 +1940,7 @@ pub const nan_buf: [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8]; * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) }; * ~~~ */ -pub pure fn as_bytes<T>(s: &const ~str, f: &fn(&~[u8]) -> T) -> T { +pub fn as_bytes<T>(s: &const ~str, f: &fn(&~[u8]) -> T) -> T { unsafe { let v: *~[u8] = cast::transmute(copy s); f(&*v) @@ -1952,7 +1952,7 @@ pub pure fn as_bytes<T>(s: &const ~str, f: &fn(&~[u8]) -> T) -> T { * * The byte slice does not include the null terminator. */ -pub pure fn as_bytes_slice(s: &'a str) -> &'a [u8] { +pub fn as_bytes_slice(s: &'a str) -> &'a [u8] { unsafe { let (ptr, len): (*u8, uint) = ::cast::reinterpret_cast(&s); let outgoing_tuple: (*u8, uint) = (ptr, len - 1); @@ -1975,7 +1975,7 @@ pub pure fn as_bytes_slice(s: &'a str) -> &'a [u8] { * let s = str::as_c_str("PATH", { |path| libc::getenv(path) }); * ~~~ */ -pub pure fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T { +pub fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T { do as_buf(s) |buf, len| { // NB: len includes the trailing null. fail_unless!(len > 0); @@ -1997,7 +1997,7 @@ pub pure fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T { * to full strings, or suffixes of them. */ #[inline(always)] -pub pure fn as_buf<T>(s: &str, f: &fn(*u8, uint) -> T) -> T { +pub fn as_buf<T>(s: &str, f: &fn(*u8, uint) -> T) -> T { unsafe { let v : *(*u8,uint) = ::cast::reinterpret_cast(&ptr::addr_of(&s)); let (buf,len) = *v; @@ -2056,7 +2056,7 @@ pub fn reserve_at_least(s: &mut ~str, n: uint) { * Returns the number of single-byte characters the string can hold without * reallocating */ -pub pure fn capacity(s: &const ~str) -> uint { +pub fn capacity(s: &const ~str) -> uint { do as_bytes(s) |buf| { let vcap = vec::capacity(buf); fail_unless!(vcap > 0u); @@ -2065,7 +2065,7 @@ pub pure fn capacity(s: &const ~str) -> uint { } /// Escape each char in `s` with char::escape_default. -pub pure fn escape_default(s: &str) -> ~str { +pub fn escape_default(s: &str) -> ~str { let mut out: ~str = ~""; unsafe { reserve_at_least(&mut out, str::len(s)); @@ -2077,7 +2077,7 @@ pub pure fn escape_default(s: &str) -> ~str { } /// Escape each char in `s` with char::escape_unicode. -pub pure fn escape_unicode(s: &str) -> ~str { +pub fn escape_unicode(s: &str) -> ~str { let mut out: ~str = ~""; unsafe { reserve_at_least(&mut out, str::len(s)); @@ -2263,7 +2263,7 @@ pub mod traits { impl Add<&'self str,~str> for ~str { #[inline(always)] - pure fn add(&self, rhs: & &'self str) -> ~str { + fn add(&self, rhs: & &'self str) -> ~str { append(copy *self, (*rhs)) } } @@ -2273,44 +2273,44 @@ pub mod traits { pub mod traits {} pub trait StrSlice { - pure fn all(&self, it: &fn(char) -> bool) -> bool; - pure fn any(&self, it: &fn(char) -> bool) -> bool; - pure fn contains(&self, needle: &'a str) -> bool; - pure fn contains_char(&self, needle: char) -> bool; - pure fn each(&self, it: &fn(u8) -> bool); - pure fn eachi(&self, it: &fn(uint, u8) -> bool); - pure fn each_reverse(&self, it: &fn(u8) -> bool); - pure fn eachi_reverse(&self, it: &fn(uint, u8) -> bool); - pure fn each_char(&self, it: &fn(char) -> bool); - pure fn each_chari(&self, it: &fn(uint, char) -> bool); - pure fn each_char_reverse(&self, it: &fn(char) -> bool); - pure fn each_chari_reverse(&self, it: &fn(uint, char) -> bool); - pure fn ends_with(&self, needle: &str) -> bool; - pure fn is_empty(&self) -> bool; - pure fn is_whitespace(&self) -> bool; - pure fn is_alphanumeric(&self) -> bool; - pure fn len(&self) -> uint; - pure fn char_len(&self) -> uint; - pure fn slice(&self, begin: uint, end: uint) -> &'self str; - pure fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str]; - pure fn split_char(&self, sep: char) -> ~[~str]; - pure fn split_str(&self, sep: &'a str) -> ~[~str]; - pure fn starts_with(&self, needle: &'a str) -> bool; - pure fn substr(&self, begin: uint, n: uint) -> &'self str; - pure fn to_lower(&self) -> ~str; - pure fn to_upper(&self) -> ~str; - pure fn escape_default(&self) -> ~str; - pure fn escape_unicode(&self) -> ~str; - pure fn trim(&self) -> &'self str; - pure fn trim_left(&self) -> &'self str; - pure fn trim_right(&self) -> &'self str; - pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str; - pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str; - pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str; - pure fn to_owned(&self) -> ~str; - pure fn to_managed(&self) -> @str; - pure fn char_at(&self, i: uint) -> char; - pure fn char_at_reverse(&self, i: uint) -> char; + fn all(&self, it: &fn(char) -> bool) -> bool; + fn any(&self, it: &fn(char) -> bool) -> bool; + fn contains(&self, needle: &'a str) -> bool; + fn contains_char(&self, needle: char) -> bool; + fn each(&self, it: &fn(u8) -> bool); + fn eachi(&self, it: &fn(uint, u8) -> bool); + fn each_reverse(&self, it: &fn(u8) -> bool); + fn eachi_reverse(&self, it: &fn(uint, u8) -> bool); + fn each_char(&self, it: &fn(char) -> bool); + fn each_chari(&self, it: &fn(uint, char) -> bool); + fn each_char_reverse(&self, it: &fn(char) -> bool); + fn each_chari_reverse(&self, it: &fn(uint, char) -> bool); + fn ends_with(&self, needle: &str) -> bool; + fn is_empty(&self) -> bool; + fn is_whitespace(&self) -> bool; + fn is_alphanumeric(&self) -> bool; + fn len(&self) -> uint; + fn char_len(&self) -> uint; + fn slice(&self, begin: uint, end: uint) -> &'self str; + fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str]; + fn split_char(&self, sep: char) -> ~[~str]; + fn split_str(&self, sep: &'a str) -> ~[~str]; + fn starts_with(&self, needle: &'a str) -> bool; + fn substr(&self, begin: uint, n: uint) -> &'self str; + fn to_lower(&self) -> ~str; + fn to_upper(&self) -> ~str; + fn escape_default(&self) -> ~str; + fn escape_unicode(&self) -> ~str; + fn trim(&self) -> &'self str; + fn trim_left(&self) -> &'self str; + fn trim_right(&self) -> &'self str; + fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str; + fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str; + fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str; + fn to_owned(&self) -> ~str; + fn to_managed(&self) -> @str; + fn char_at(&self, i: uint) -> char; + fn char_at_reverse(&self, i: uint) -> char; fn to_bytes(&self) -> ~[u8]; } @@ -2321,86 +2321,86 @@ impl StrSlice for &'self str { * contains no characters */ #[inline] - pure fn all(&self, it: &fn(char) -> bool) -> bool { all(*self, it) } + fn all(&self, it: &fn(char) -> bool) -> bool { all(*self, it) } /** * Return true if a predicate matches any character (and false if it * matches none or there are no characters) */ #[inline] - pure fn any(&self, it: &fn(char) -> bool) -> bool { any(*self, it) } + fn any(&self, it: &fn(char) -> bool) -> bool { any(*self, it) } /// Returns true if one string contains another #[inline] - pure fn contains(&self, needle: &'a str) -> bool { + fn contains(&self, needle: &'a str) -> bool { contains(*self, needle) } /// Returns true if a string contains a char #[inline] - pure fn contains_char(&self, needle: char) -> bool { + fn contains_char(&self, needle: char) -> bool { contains_char(*self, needle) } /// Iterate over the bytes in a string #[inline] - pure fn each(&self, it: &fn(u8) -> bool) { each(*self, it) } + fn each(&self, it: &fn(u8) -> bool) { each(*self, it) } /// Iterate over the bytes in a string, with indices #[inline] - pure fn eachi(&self, it: &fn(uint, u8) -> bool) { eachi(*self, it) } + fn eachi(&self, it: &fn(uint, u8) -> bool) { eachi(*self, it) } /// Iterate over the bytes in a string #[inline] - pure fn each_reverse(&self, it: &fn(u8) -> bool) { + fn each_reverse(&self, it: &fn(u8) -> bool) { each_reverse(*self, it) } /// Iterate over the bytes in a string, with indices #[inline] - pure fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) { + fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) { eachi_reverse(*self, it) } /// Iterate over the chars in a string #[inline] - pure fn each_char(&self, it: &fn(char) -> bool) { each_char(*self, it) } + fn each_char(&self, it: &fn(char) -> bool) { each_char(*self, it) } /// Iterate over the chars in a string, with indices #[inline] - pure fn each_chari(&self, it: &fn(uint, char) -> bool) { + fn each_chari(&self, it: &fn(uint, char) -> bool) { each_chari(*self, it) } /// Iterate over the chars in a string in reverse #[inline] - pure fn each_char_reverse(&self, it: &fn(char) -> bool) { + fn each_char_reverse(&self, it: &fn(char) -> bool) { each_char_reverse(*self, it) } /// Iterate over the chars in a string in reverse, with indices from the /// end #[inline] - pure fn each_chari_reverse(&self, it: &fn(uint, char) -> bool) { + fn each_chari_reverse(&self, it: &fn(uint, char) -> bool) { each_chari_reverse(*self, it) } /// Returns true if one string ends with another #[inline] - pure fn ends_with(&self, needle: &str) -> bool { + fn ends_with(&self, needle: &str) -> bool { ends_with(*self, needle) } /// Returns true if the string has length 0 #[inline] - pure fn is_empty(&self) -> bool { is_empty(*self) } + fn is_empty(&self) -> bool { is_empty(*self) } /** * Returns true if the string contains only whitespace * * Whitespace characters are determined by `char::is_whitespace` */ #[inline] - pure fn is_whitespace(&self) -> bool { is_whitespace(*self) } + fn is_whitespace(&self) -> bool { is_whitespace(*self) } /** * Returns true if the string contains only alphanumerics * * Alphanumeric characters are determined by `char::is_alphanumeric` */ #[inline] - pure fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) } + fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) } /// Returns the size in bytes not counting the null terminator #[inline] - pure fn len(&self) -> uint { len(*self) } + fn len(&self) -> uint { len(*self) } /// Returns the number of characters that a string holds #[inline] - pure fn char_len(&self) -> uint { char_len(*self) } + fn char_len(&self) -> uint { char_len(*self) } /** * Returns a slice of the given string from the byte range * [`begin`..`end`) @@ -2409,28 +2409,28 @@ impl StrSlice for &'self str { * beyond the last character of the string */ #[inline] - pure fn slice(&self, begin: uint, end: uint) -> &'self str { + fn slice(&self, begin: uint, end: uint) -> &'self str { slice(*self, begin, end) } /// Splits a string into substrings using a character function #[inline] - pure fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str] { + fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str] { split(*self, sepfn) } /** * Splits a string into substrings at each occurrence of a given character */ #[inline] - pure fn split_char(&self, sep: char) -> ~[~str] { split_char(*self, sep) } + fn split_char(&self, sep: char) -> ~[~str] { split_char(*self, sep) } /** * Splits a string into a vector of the substrings separated by a given * string */ #[inline] - pure fn split_str(&self, sep: &'a str) -> ~[~str] { split_str(*self, sep) } + fn split_str(&self, sep: &'a str) -> ~[~str] { split_str(*self, sep) } /// Returns true if one string starts with another #[inline] - pure fn starts_with(&self, needle: &'a str) -> bool { + fn starts_with(&self, needle: &'a str) -> bool { starts_with(*self, needle) } /** @@ -2440,51 +2440,51 @@ impl StrSlice for &'self str { * `begin`. */ #[inline] - pure fn substr(&self, begin: uint, n: uint) -> &'self str { + fn substr(&self, begin: uint, n: uint) -> &'self str { substr(*self, begin, n) } /// Convert a string to lowercase #[inline] - pure fn to_lower(&self) -> ~str { to_lower(*self) } + fn to_lower(&self) -> ~str { to_lower(*self) } /// Convert a string to uppercase #[inline] - pure fn to_upper(&self) -> ~str { to_upper(*self) } + fn to_upper(&self) -> ~str { to_upper(*self) } /// Escape each char in `s` with char::escape_default. #[inline] - pure fn escape_default(&self) -> ~str { escape_default(*self) } + fn escape_default(&self) -> ~str { escape_default(*self) } /// Escape each char in `s` with char::escape_unicode. #[inline] - pure fn escape_unicode(&self) -> ~str { escape_unicode(*self) } + fn escape_unicode(&self) -> ~str { escape_unicode(*self) } /// Returns a string with leading and trailing whitespace removed #[inline] - pure fn trim(&self) -> &'self str { trim(*self) } + fn trim(&self) -> &'self str { trim(*self) } /// Returns a string with leading whitespace removed #[inline] - pure fn trim_left(&self) -> &'self str { trim_left(*self) } + fn trim_left(&self) -> &'self str { trim_left(*self) } /// Returns a string with trailing whitespace removed #[inline] - pure fn trim_right(&self) -> &'self str { trim_right(*self) } + fn trim_right(&self) -> &'self str { trim_right(*self) } #[inline] - pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str { + fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str { trim_chars(*self, chars_to_trim) } #[inline] - pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str { + fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str { trim_left_chars(*self, chars_to_trim) } #[inline] - pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str { + fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str { trim_right_chars(*self, chars_to_trim) } #[inline] - pure fn to_owned(&self) -> ~str { from_slice(*self) } + fn to_owned(&self) -> ~str { from_slice(*self) } #[inline] - pure fn to_managed(&self) -> @str { + fn to_managed(&self) -> @str { let v = at_vec::from_fn(self.len() + 1, |i| { if i == self.len() { 0 } else { self[i] } }); @@ -2492,10 +2492,10 @@ impl StrSlice for &'self str { } #[inline] - pure fn char_at(&self, i: uint) -> char { char_at(*self, i) } + fn char_at(&self, i: uint) -> char { char_at(*self, i) } #[inline] - pure fn char_at_reverse(&self, i: uint) -> char { + fn char_at_reverse(&self, i: uint) -> char { char_at_reverse(*self, i) } diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index f7eceeebc1e..706cb10dba9 100644 --- a/src/libcore/sys.rs +++ b/src/libcore/sys.rs @@ -60,15 +60,15 @@ pub mod rustrt { /// Compares contents of two pointers using the default method. /// Equivalent to `*x1 == *x2`. Useful for hashtables. -pub pure fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool { +pub fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool { *x1 == *x2 } -pub pure fn shape_lt<T:Ord>(x1: &T, x2: &T) -> bool { +pub fn shape_lt<T:Ord>(x1: &T, x2: &T) -> bool { *x1 < *x2 } -pub pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool { +pub fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool { *x1 <= *x2 } @@ -79,13 +79,13 @@ pub pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool { * performing dark magick. */ #[inline(always)] -pub pure fn get_type_desc<T>() -> *TypeDesc { +pub fn get_type_desc<T>() -> *TypeDesc { unsafe { rusti::get_tydesc::<T>() as *TypeDesc } } /// Returns the size of a type #[inline(always)] -pub pure fn size_of<T>() -> uint { +pub fn size_of<T>() -> uint { unsafe { rusti::size_of::<T>() } } @@ -95,7 +95,7 @@ pub pure fn size_of<T>() -> uint { * Useful for building structures containing variable-length arrays. */ #[inline(always)] -pub pure fn nonzero_size_of<T>() -> uint { +pub fn nonzero_size_of<T>() -> uint { let s = size_of::<T>(); if s == 0 { 1 } else { s } } @@ -107,26 +107,26 @@ pub pure fn nonzero_size_of<T>() -> uint { * than the preferred alignment. */ #[inline(always)] -pub pure fn min_align_of<T>() -> uint { +pub fn min_align_of<T>() -> uint { unsafe { rusti::min_align_of::<T>() } } /// Returns the preferred alignment of a type #[inline(always)] -pub pure fn pref_align_of<T>() -> uint { +pub fn pref_align_of<T>() -> uint { unsafe { rusti::pref_align_of::<T>() } } /// Returns the refcount of a shared box (as just before calling this) #[inline(always)] -pub pure fn refcount<T>(t: @T) -> uint { +pub fn refcount<T>(t: @T) -> uint { unsafe { let ref_ptr: *uint = cast::reinterpret_cast(&t); *ref_ptr - 1 } } -pub pure fn log_str<T>(t: &T) -> ~str { +pub fn log_str<T>(t: &T) -> ~str { unsafe { do io::with_str_writer |wr| { repr::write_repr(wr, t) @@ -135,7 +135,7 @@ pub pure fn log_str<T>(t: &T) -> ~str { } /** Initiate task failure */ -pub pure fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! { +pub fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! { do str::as_buf(msg) |msg_buf, _msg_len| { do str::as_buf(file) |file_buf, _file_len| { unsafe { @@ -148,7 +148,7 @@ pub pure fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! { } // FIXME #4427: Temporary until rt::rt_fail_ goes away -pub pure fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! { +pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! { unsafe { gc::cleanup_stack_for_failure(); rustrt::rust_upcall_fail(msg, file, line); @@ -156,7 +156,7 @@ pub pure fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! { } } -pub pure fn fail_assert(msg: &str, file: &str, line: uint) -> ! { +pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! { unsafe { let (msg, file) = (msg.to_owned(), file.to_owned()); begin_unwind(~"assertion failed: " + msg, file, line) diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs index 6a933ef515f..59f4942b3a4 100644 --- a/src/libcore/task/local_data_priv.rs +++ b/src/libcore/task/local_data_priv.rs @@ -24,14 +24,14 @@ pub trait LocalData { } impl<T:Durable> LocalData for @T { } impl Eq for @LocalData { - pure fn eq(&self, other: &@LocalData) -> bool { + fn eq(&self, other: &@LocalData) -> bool { unsafe { let ptr_a: (uint, uint) = cast::reinterpret_cast(&(*self)); let ptr_b: (uint, uint) = cast::reinterpret_cast(other); return ptr_a == ptr_b; } } - pure fn ne(&self, other: &@LocalData) -> bool { !(*self).eq(other) } + fn ne(&self, other: &@LocalData) -> bool { !(*self).eq(other) } } // If TLS is used heavily in future, this could be made more efficient with a diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs index 1ef2316ec07..a38b44afb51 100644 --- a/src/libcore/task/mod.rs +++ b/src/libcore/task/mod.rs @@ -78,13 +78,13 @@ pub enum TaskResult { } impl Eq for TaskResult { - pure fn eq(&self, other: &TaskResult) -> bool { + fn eq(&self, other: &TaskResult) -> bool { match ((*self), (*other)) { (Success, Success) | (Failure, Failure) => true, (Success, _) | (Failure, _) => false } } - pure fn ne(&self, other: &TaskResult) -> bool { !(*self).eq(other) } + fn ne(&self, other: &TaskResult) -> bool { !(*self).eq(other) } } /// Scheduler modes diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index 40a6873ad67..b97a682c4e5 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -126,7 +126,7 @@ type TaskGroupArc = unstable::Exclusive<Option<TaskGroupData>>; type TaskGroupInner = &'self mut Option<TaskGroupData>; // A taskgroup is 'dead' when nothing can cause it to fail; only members can. -pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool { +fn taskgroup_is_dead(tg: &TaskGroupData) -> bool { (&const tg.members).is_empty() } diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs index e5fbad16717..f379878c8eb 100644 --- a/src/libcore/to_bytes.rs +++ b/src/libcore/to_bytes.rs @@ -43,12 +43,12 @@ pub trait IterBytes { * left-to-right in declaration order, regardless of * underlying memory endianness. */ - pure fn iter_bytes(&self, lsb0: bool, f: Cb); + fn iter_bytes(&self, lsb0: bool, f: Cb); } impl IterBytes for bool { #[inline(always)] - pure fn iter_bytes(&self, _lsb0: bool, f: Cb) { + fn iter_bytes(&self, _lsb0: bool, f: Cb) { f([ *self as u8 ]); @@ -57,7 +57,7 @@ impl IterBytes for bool { impl IterBytes for u8 { #[inline(always)] - pure fn iter_bytes(&self, _lsb0: bool, f: Cb) { + fn iter_bytes(&self, _lsb0: bool, f: Cb) { f([ *self ]); @@ -66,7 +66,7 @@ impl IterBytes for u8 { impl IterBytes for u16 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { if lsb0 { f([ *self as u8, @@ -83,7 +83,7 @@ impl IterBytes for u16 { impl IterBytes for u32 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { if lsb0 { f([ *self as u8, @@ -104,7 +104,7 @@ impl IterBytes for u32 { impl IterBytes for u64 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { if lsb0 { f([ *self as u8, @@ -133,35 +133,35 @@ impl IterBytes for u64 { impl IterBytes for i8 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u8).iter_bytes(lsb0, f) } } impl IterBytes for i16 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u16).iter_bytes(lsb0, f) } } impl IterBytes for i32 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u32).iter_bytes(lsb0, f) } } impl IterBytes for i64 { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u64).iter_bytes(lsb0, f) } } impl IterBytes for char { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u32).iter_bytes(lsb0, f) } } @@ -172,7 +172,7 @@ pub mod x32 { impl IterBytes for uint { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u32).iter_bytes(lsb0, f) } } @@ -184,7 +184,7 @@ pub mod x64 { impl IterBytes for uint { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u64).iter_bytes(lsb0, f) } } @@ -192,14 +192,14 @@ pub mod x64 { impl IterBytes for int { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as uint).iter_bytes(lsb0, f) } } impl<A:IterBytes> IterBytes for &'self [A] { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { for (*self).each |elt| { do elt.iter_bytes(lsb0) |bytes| { f(bytes) @@ -210,7 +210,7 @@ impl<A:IterBytes> IterBytes for &'self [A] { impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { match *self { (ref a, ref b) => { iter_bytes_2(a, b, lsb0, f); @@ -221,7 +221,7 @@ impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) { impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { match *self { (ref a, ref b, ref c) => { iter_bytes_3(a, b, c, lsb0, f); @@ -231,25 +231,25 @@ impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) { } // Move this to vec, probably. -pure fn borrow<A>(a: &'x [A]) -> &'x [A] { +fn borrow<A>(a: &'x [A]) -> &'x [A] { a } impl<A:IterBytes> IterBytes for ~[A] { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { borrow(*self).iter_bytes(lsb0, f) } } impl<A:IterBytes> IterBytes for @[A] { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { borrow(*self).iter_bytes(lsb0, f) } } -pub pure fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B, +pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B, lsb0: bool, z: Cb) { let mut flag = true; a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); @@ -257,7 +257,7 @@ pub pure fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B, b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } -pub pure fn iter_bytes_3<A: IterBytes, +pub fn iter_bytes_3<A: IterBytes, B: IterBytes, C: IterBytes>(a: &A, b: &B, c: &C, lsb0: bool, z: Cb) { @@ -269,7 +269,7 @@ pub pure fn iter_bytes_3<A: IterBytes, c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } -pub pure fn iter_bytes_4<A: IterBytes, +pub fn iter_bytes_4<A: IterBytes, B: IterBytes, C: IterBytes, D: IterBytes>(a: &A, b: &B, c: &C, @@ -285,7 +285,7 @@ pub pure fn iter_bytes_4<A: IterBytes, d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } -pub pure fn iter_bytes_5<A: IterBytes, +pub fn iter_bytes_5<A: IterBytes, B: IterBytes, C: IterBytes, D: IterBytes, @@ -304,7 +304,7 @@ pub pure fn iter_bytes_5<A: IterBytes, e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } -pub pure fn iter_bytes_6<A: IterBytes, +pub fn iter_bytes_6<A: IterBytes, B: IterBytes, C: IterBytes, D: IterBytes, @@ -326,7 +326,7 @@ pub pure fn iter_bytes_6<A: IterBytes, f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } -pub pure fn iter_bytes_7<A: IterBytes, +pub fn iter_bytes_7<A: IterBytes, B: IterBytes, C: IterBytes, D: IterBytes, @@ -354,7 +354,7 @@ pub pure fn iter_bytes_7<A: IterBytes, impl IterBytes for &'self str { #[inline(always)] - pure fn iter_bytes(&self, _lsb0: bool, f: Cb) { + fn iter_bytes(&self, _lsb0: bool, f: Cb) { do str::byte_slice(*self) |bytes| { f(bytes); } @@ -363,7 +363,7 @@ impl IterBytes for &'self str { impl IterBytes for ~str { #[inline(always)] - pure fn iter_bytes(&self, _lsb0: bool, f: Cb) { + fn iter_bytes(&self, _lsb0: bool, f: Cb) { do str::byte_slice(*self) |bytes| { f(bytes); } @@ -372,7 +372,7 @@ impl IterBytes for ~str { impl IterBytes for @str { #[inline(always)] - pure fn iter_bytes(&self, _lsb0: bool, f: Cb) { + fn iter_bytes(&self, _lsb0: bool, f: Cb) { do str::byte_slice(*self) |bytes| { f(bytes); } @@ -381,7 +381,7 @@ impl IterBytes for @str { impl<A:IterBytes> IterBytes for Option<A> { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { match *self { Some(ref a) => iter_bytes_2(&0u8, a, lsb0, f), None => 1u8.iter_bytes(lsb0, f) @@ -391,21 +391,21 @@ impl<A:IterBytes> IterBytes for Option<A> { impl<A:IterBytes> IterBytes for &'self A { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (**self).iter_bytes(lsb0, f); } } impl<A:IterBytes> IterBytes for @A { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (**self).iter_bytes(lsb0, f); } } impl<A:IterBytes> IterBytes for ~A { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (**self).iter_bytes(lsb0, f); } } @@ -414,7 +414,7 @@ impl<A:IterBytes> IterBytes for ~A { // to the target; it just gives you the pointer-bytes. impl<A> IterBytes for *const A { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: Cb) { + fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as uint).iter_bytes(lsb0, f); } } diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs index b687fde0c37..576f794483d 100644 --- a/src/libcore/to_str.rs +++ b/src/libcore/to_str.rs @@ -17,23 +17,23 @@ The `ToStr` trait for converting to strings use str; pub trait ToStr { - pure fn to_str(&self) -> ~str; + fn to_str(&self) -> ~str; } impl ToStr for bool { #[inline(always)] - pure fn to_str(&self) -> ~str { ::bool::to_str(*self) } + fn to_str(&self) -> ~str { ::bool::to_str(*self) } } impl ToStr for () { #[inline(always)] - pure fn to_str(&self) -> ~str { ~"()" } + fn to_str(&self) -> ~str { ~"()" } } // FIXME #4898: impl for one-tuples impl<A:ToStr,B:ToStr> ToStr for (A, B) { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { // FIXME(#4760): this causes an llvm assertion //let &(ref a, ref b) = self; match *self { @@ -45,7 +45,7 @@ impl<A:ToStr,B:ToStr> ToStr for (A, B) { } impl<A:ToStr,B:ToStr,C:ToStr> ToStr for (A, B, C) { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { // FIXME(#4760): this causes an llvm assertion //let &(ref a, ref b, ref c) = self; match *self { @@ -62,7 +62,7 @@ impl<A:ToStr,B:ToStr,C:ToStr> ToStr for (A, B, C) { impl<A:ToStr> ToStr for &'self [A] { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { unsafe { // FIXME #4568 // Bleh -- not really unsafe @@ -83,7 +83,7 @@ impl<A:ToStr> ToStr for &'self [A] { impl<A:ToStr> ToStr for ~[A] { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { unsafe { // FIXME #4568 // Bleh -- not really unsafe @@ -104,7 +104,7 @@ impl<A:ToStr> ToStr for ~[A] { impl<A:ToStr> ToStr for @[A] { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { unsafe { // FIXME #4568 // Bleh -- not really unsafe diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs index 3b9d3ad4b73..258de5c81db 100644 --- a/src/libcore/trie.rs +++ b/src/libcore/trie.rs @@ -32,17 +32,17 @@ pub struct TrieMap<T> { impl<T> BaseIter<(uint, &'self T)> for TrieMap<T> { /// Visit all key-value pairs in order #[inline(always)] - pure fn each(&self, f: &fn(&(uint, &'self T)) -> bool) { + fn each(&self, f: &fn(&(uint, &'self T)) -> bool) { self.root.each(f); } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<T> ReverseIter<(uint, &'self T)> for TrieMap<T> { /// Visit all key-value pairs in reverse order #[inline(always)] - pure fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) { + fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) { self.root.each_reverse(f); } } @@ -50,11 +50,11 @@ impl<T> ReverseIter<(uint, &'self T)> for TrieMap<T> { impl<T> Container for TrieMap<T> { /// Return the number of elements in the map #[inline(always)] - pure fn len(&const self) -> uint { self.length } + fn len(&const self) -> uint { self.length } /// Return true if the map contains no elements #[inline(always)] - pure fn is_empty(&const self) -> bool { self.len() == 0 } + fn is_empty(&const self) -> bool { self.len() == 0 } } impl<T> Mutable for TrieMap<T> { @@ -69,19 +69,19 @@ impl<T> Mutable for TrieMap<T> { impl<T> Map<uint, T> for TrieMap<T> { /// Return true if the map contains a value for the specified key #[inline(always)] - pure fn contains_key(&self, key: &uint) -> bool { + fn contains_key(&self, key: &uint) -> bool { self.find(key).is_some() } /// Visit all keys in order #[inline(always)] - pure fn each_key(&self, f: &fn(&uint) -> bool) { + fn each_key(&self, f: &fn(&uint) -> bool) { self.each(|&(k, _)| f(&k)) } /// Visit all values in order #[inline(always)] - pure fn each_value(&self, f: &fn(&T) -> bool) { + fn each_value(&self, f: &fn(&T) -> bool) { self.each(|&(_, v)| f(v)) } @@ -93,7 +93,7 @@ impl<T> Map<uint, T> for TrieMap<T> { /// Return the value corresponding to the key in the map #[inline(hint)] - pure fn find(&self, key: &uint) -> Option<&'self T> { + fn find(&self, key: &uint) -> Option<&'self T> { let mut node: &'self TrieNode<T> = &self.root; let mut idx = 0; loop { @@ -139,19 +139,19 @@ impl<T> Map<uint, T> for TrieMap<T> { pub impl<T> TrieMap<T> { /// Create an empty TrieMap #[inline(always)] - static pure fn new() -> TrieMap<T> { + fn new() -> TrieMap<T> { TrieMap{root: TrieNode::new(), length: 0} } /// Visit all keys in reverse order #[inline(always)] - pure fn each_key_reverse(&self, f: &fn(&uint) -> bool) { + fn each_key_reverse(&self, f: &fn(&uint) -> bool) { self.each_reverse(|&(k, _)| f(&k)) } /// Visit all values in reverse order #[inline(always)] - pure fn each_value_reverse(&self, f: &fn(&T) -> bool) { + fn each_value_reverse(&self, f: &fn(&T) -> bool) { self.each_reverse(|&(_, v)| f(v)) } } @@ -162,13 +162,13 @@ pub struct TrieSet { impl BaseIter<uint> for TrieSet { /// Visit all values in order - pure fn each(&self, f: &fn(&uint) -> bool) { self.map.each_key(f) } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn each(&self, f: &fn(&uint) -> bool) { self.map.each_key(f) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl ReverseIter<uint> for TrieSet { /// Visit all values in reverse order - pure fn each_reverse(&self, f: &fn(&uint) -> bool) { + fn each_reverse(&self, f: &fn(&uint) -> bool) { self.map.each_key_reverse(f) } } @@ -176,11 +176,11 @@ impl ReverseIter<uint> for TrieSet { impl Container for TrieSet { /// Return the number of elements in the set #[inline(always)] - pure fn len(&const self) -> uint { self.map.len() } + fn len(&const self) -> uint { self.map.len() } /// Return true if the set contains no elements #[inline(always)] - pure fn is_empty(&const self) -> bool { self.map.is_empty() } + fn is_empty(&const self) -> bool { self.map.is_empty() } } impl Mutable for TrieSet { @@ -192,13 +192,13 @@ impl Mutable for TrieSet { impl TrieSet { /// Create an empty TrieSet #[inline(always)] - static pure fn new() -> TrieSet { + fn new() -> TrieSet { TrieSet{map: TrieMap::new()} } /// Return true if the set contains a value #[inline(always)] - pure fn contains(&self, value: &uint) -> bool { + fn contains(&self, value: &uint) -> bool { self.map.contains_key(value) } @@ -220,7 +220,7 @@ struct TrieNode<T> { impl<T> TrieNode<T> { #[inline(always)] - static pure fn new() -> TrieNode<T> { + fn new() -> TrieNode<T> { // FIXME: #5244: [Nothing, ..SIZE] should be possible without Copy TrieNode{count: 0, children: [Nothing, Nothing, Nothing, Nothing, @@ -231,7 +231,7 @@ impl<T> TrieNode<T> { } impl<T> TrieNode<T> { - pure fn each(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool { + fn each(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool { for uint::range(0, self.children.len()) |idx| { match self.children[idx] { Internal(ref x) => if !x.each(f) { return false }, @@ -242,7 +242,7 @@ impl<T> TrieNode<T> { true } - pure fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool { + fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool { for uint::range_rev(self.children.len(), 0) |idx| { match self.children[idx - 1] { Internal(ref x) => if !x.each_reverse(f) { return false }, @@ -269,7 +269,7 @@ impl<T> TrieNode<T> { // if this was done via a trait, the key could be generic #[inline(always)] -pure fn chunk(n: uint, idx: uint) -> uint { +fn chunk(n: uint, idx: uint) -> uint { let sh = uint::bits - (SHIFT * (idx + 1)); (n >> sh) & MASK } diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index b4f68466c27..fc7834a7514 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -16,30 +16,30 @@ use vec; #[cfg(notest)] use cmp::{Eq, Ord}; pub trait CopyableTuple<T, U> { - pure fn first(&self) -> T; - pure fn second(&self) -> U; - pure fn swap(&self) -> (U, T); + fn first(&self) -> T; + fn second(&self) -> U; + fn swap(&self) -> (U, T); } impl<T:Copy,U:Copy> CopyableTuple<T, U> for (T, U) { /// Return the first element of self #[inline(always)] - pure fn first(&self) -> T { + fn first(&self) -> T { let (t, _) = *self; return t; } /// Return the second element of self #[inline(always)] - pure fn second(&self) -> U { + fn second(&self) -> U { let (_, u) = *self; return u; } /// Return the results of swapping the two elements of self #[inline(always)] - pure fn swap(&self) -> (U, T) { + fn swap(&self) -> (U, T) { let (t, u) = *self; return (u, t); } @@ -47,19 +47,19 @@ impl<T:Copy,U:Copy> CopyableTuple<T, U> for (T, U) { } pub trait ImmutableTuple<T, U> { - pure fn first_ref(&self) -> &'self T; - pure fn second_ref(&self) -> &'self U; + fn first_ref(&self) -> &'self T; + fn second_ref(&self) -> &'self U; } impl<T, U> ImmutableTuple<T, U> for (T, U) { #[inline(always)] - pure fn first_ref(&self) -> &'self T { + fn first_ref(&self) -> &'self T { match *self { (ref t, _) => t, } } #[inline(always)] - pure fn second_ref(&self) -> &'self U { + fn second_ref(&self) -> &'self U { match *self { (_, ref u) => u, } @@ -117,7 +117,7 @@ impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) { #[cfg(notest)] impl<A:Eq,B:Eq> Eq for (A, B) { #[inline(always)] - pure fn eq(&self, other: &(A, B)) -> bool { + fn eq(&self, other: &(A, B)) -> bool { match (*self) { (ref self_a, ref self_b) => match other { &(ref other_a, ref other_b) => { @@ -127,13 +127,13 @@ impl<A:Eq,B:Eq> Eq for (A, B) { } } #[inline(always)] - pure fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) } + fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl<A:Ord,B:Ord> Ord for (A, B) { #[inline(always)] - pure fn lt(&self, other: &(A, B)) -> bool { + fn lt(&self, other: &(A, B)) -> bool { match (*self) { (ref self_a, ref self_b) => { match (*other) { @@ -148,17 +148,17 @@ impl<A:Ord,B:Ord> Ord for (A, B) { } } #[inline(always)] - pure fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) } + fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) } #[inline(always)] - pure fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) } + fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) } #[inline(always)] - pure fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self)) } + fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self)) } } #[cfg(notest)] impl<A:Eq,B:Eq,C:Eq> Eq for (A, B, C) { #[inline(always)] - pure fn eq(&self, other: &(A, B, C)) -> bool { + fn eq(&self, other: &(A, B, C)) -> bool { match (*self) { (ref self_a, ref self_b, ref self_c) => match other { &(ref other_a, ref other_b, ref other_c) => { @@ -169,13 +169,13 @@ impl<A:Eq,B:Eq,C:Eq> Eq for (A, B, C) { } } #[inline(always)] - pure fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) } + fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl<A:Ord,B:Ord,C:Ord> Ord for (A, B, C) { #[inline(always)] - pure fn lt(&self, other: &(A, B, C)) -> bool { + fn lt(&self, other: &(A, B, C)) -> bool { match (*self) { (ref self_a, ref self_b, ref self_c) => { match (*other) { @@ -192,11 +192,11 @@ impl<A:Ord,B:Ord,C:Ord> Ord for (A, B, C) { } } #[inline(always)] - pure fn le(&self, other: &(A, B, C)) -> bool { !(*other).lt(&(*self)) } + 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) } + 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)) } + fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self)) } } #[test] diff --git a/src/libcore/unicode.rs b/src/libcore/unicode.rs index ff3b908186a..9f2ab66d5c2 100644 --- a/src/libcore/unicode.rs +++ b/src/libcore/unicode.rs @@ -11,7 +11,7 @@ #[doc(hidden)]; // FIXME #3538 pub mod general_category { - pub pure fn Cc(c: char) -> bool { + pub fn Cc(c: char) -> bool { return match c { '\x00' .. '\x1f' | '\x7f' .. '\x9f' => true, @@ -19,7 +19,7 @@ pub mod general_category { }; } - pub pure fn Cf(c: char) -> bool { + pub fn Cf(c: char) -> bool { return match c { '\xad' | '\u0600' .. '\u0603' @@ -38,21 +38,21 @@ pub mod general_category { }; } - pub pure fn Co(c: char) -> bool { + pub fn Co(c: char) -> bool { return match c { '\ue000' .. '\uf8ff' => true, _ => false }; } - pub pure fn Cs(c: char) -> bool { + pub fn Cs(c: char) -> bool { return match c { '\ud800' .. '\udfff' => true, _ => false }; } - pub pure fn Ll(c: char) -> bool { + pub fn Ll(c: char) -> bool { return match c { '\x61' .. '\x7a' | '\xaa' @@ -657,7 +657,7 @@ pub mod general_category { }; } - pub pure fn Lm(c: char) -> bool { + pub fn Lm(c: char) -> bool { return match c { '\u02b0' .. '\u02c1' | '\u02c6' .. '\u02d1' @@ -713,7 +713,7 @@ pub mod general_category { }; } - pub pure fn Lo(c: char) -> bool { + pub fn Lo(c: char) -> bool { return match c { '\u01bb' | '\u01c0' .. '\u01c3' @@ -899,7 +899,7 @@ pub mod general_category { }; } - pub pure fn Lt(c: char) -> bool { + pub fn Lt(c: char) -> bool { return match c { '\u01c5' | '\u01c8' @@ -916,7 +916,7 @@ pub mod general_category { }; } - pub pure fn Lu(c: char) -> bool { + pub fn Lu(c: char) -> bool { return match c { '\x41' .. '\x5a' | '\xc0' .. '\xd6' @@ -1508,7 +1508,7 @@ pub mod general_category { }; } - pub pure fn Mc(c: char) -> bool { + pub fn Mc(c: char) -> bool { return match c { '\u0903' | '\u093b' @@ -1619,7 +1619,7 @@ pub mod general_category { }; } - pub pure fn Me(c: char) -> bool { + pub fn Me(c: char) -> bool { return match c { '\u0488' .. '\u0489' | '\u20dd' .. '\u20e0' @@ -1630,7 +1630,7 @@ pub mod general_category { }; } - pub pure fn Mn(c: char) -> bool { + pub fn Mn(c: char) -> bool { return match c { '\u0300' .. '\u036f' | '\u0483' .. '\u0487' @@ -1823,7 +1823,7 @@ pub mod general_category { }; } - pub pure fn Nd(c: char) -> bool { + pub fn Nd(c: char) -> bool { return match c { '\x30' .. '\x39' | '\u0660' .. '\u0669' @@ -1867,7 +1867,7 @@ pub mod general_category { }; } - pub pure fn Nl(c: char) -> bool { + pub fn Nl(c: char) -> bool { return match c { '\u16ee' .. '\u16f0' | '\u2160' .. '\u2182' @@ -1886,7 +1886,7 @@ pub mod general_category { }; } - pub pure fn No(c: char) -> bool { + pub fn No(c: char) -> bool { return match c { '\xb2' .. '\xb3' | '\xb9' @@ -1934,7 +1934,7 @@ pub mod general_category { }; } - pub pure fn Pc(c: char) -> bool { + pub fn Pc(c: char) -> bool { return match c { '\x5f' | '\u203f' .. '\u2040' @@ -1947,7 +1947,7 @@ pub mod general_category { }; } - pub pure fn Pd(c: char) -> bool { + pub fn Pd(c: char) -> bool { return match c { '\x2d' | '\u058a' @@ -1969,7 +1969,7 @@ pub mod general_category { }; } - pub pure fn Pe(c: char) -> bool { + pub fn Pe(c: char) -> bool { return match c { '\x29' | '\x5d' @@ -2046,7 +2046,7 @@ pub mod general_category { }; } - pub pure fn Pf(c: char) -> bool { + pub fn Pf(c: char) -> bool { return match c { '\xbb' | '\u2019' @@ -2063,7 +2063,7 @@ pub mod general_category { }; } - pub pure fn Pi(c: char) -> bool { + pub fn Pi(c: char) -> bool { return match c { '\xab' | '\u2018' @@ -2081,7 +2081,7 @@ pub mod general_category { }; } - pub pure fn Po(c: char) -> bool { + pub fn Po(c: char) -> bool { return match c { '\x21' .. '\x23' | '\x25' .. '\x27' @@ -2214,7 +2214,7 @@ pub mod general_category { }; } - pub pure fn Ps(c: char) -> bool { + pub fn Ps(c: char) -> bool { return match c { '\x28' | '\x5b' @@ -2293,7 +2293,7 @@ pub mod general_category { }; } - pub pure fn Sc(c: char) -> bool { + pub fn Sc(c: char) -> bool { return match c { '\x24' | '\xa2' .. '\xa5' @@ -2316,7 +2316,7 @@ pub mod general_category { }; } - pub pure fn Sk(c: char) -> bool { + pub fn Sk(c: char) -> bool { return match c { '\x5e' | '\x60' @@ -2350,7 +2350,7 @@ pub mod general_category { }; } - pub pure fn Sm(c: char) -> bool { + pub fn Sm(c: char) -> bool { return match c { '\x2b' | '\x3c' .. '\x3e' @@ -2421,7 +2421,7 @@ pub mod general_category { }; } - pub pure fn So(c: char) -> bool { + pub fn So(c: char) -> bool { return match c { '\xa6' .. '\xa7' | '\xa9' @@ -2540,21 +2540,21 @@ pub mod general_category { }; } - pub pure fn Zl(c: char) -> bool { + pub fn Zl(c: char) -> bool { return match c { '\u2028' => true, _ => false }; } - pub pure fn Zp(c: char) -> bool { + pub fn Zp(c: char) -> bool { return match c { '\u2029' => true, _ => false }; } - pub pure fn Zs(c: char) -> bool { + pub fn Zs(c: char) -> bool { return match c { '\x20' | '\xa0' @@ -2572,7 +2572,7 @@ pub mod general_category { } mod derived_property { /// Check if a character has the alphabetic unicode property - pub pure fn Alphabetic(c: char) -> bool { + pub fn Alphabetic(c: char) -> bool { return match c { '\x41' .. '\x5a' | '\x61' .. '\x7a' @@ -3310,7 +3310,7 @@ mod derived_property { }; } - pub pure fn XID_Continue(c: char) -> bool { + pub fn XID_Continue(c: char) -> bool { return match c { '\x30' .. '\x39' | '\x41' .. '\x5a' @@ -4181,7 +4181,7 @@ mod derived_property { }; } - pub pure fn XID_Start(c: char) -> bool { + pub fn XID_Start(c: char) -> bool { return match c { '\x41' .. '\x5a' | '\x61' .. '\x7a' diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs index 7527a6afb55..2571dca1c96 100644 --- a/src/libcore/unstable/extfmt.rs +++ b/src/libcore/unstable/extfmt.rs @@ -140,7 +140,7 @@ pub mod ct { } pub impl<T> Parsed<T> { - static pure fn new(&self, val: T, next: uint) -> Parsed<T> { + fn new(val: T, next: uint) -> Parsed<T> { Parsed {val: val, next: next} } } @@ -705,7 +705,7 @@ pub mod rt { ty: Ty, } - pub pure fn conv_int(cv: Conv, i: int) -> ~str { + pub fn conv_int(cv: Conv, i: int) -> ~str { let radix = 10; let prec = get_int_precision(cv); let mut s : ~str = int_to_str_prec(i, radix, prec); @@ -718,7 +718,7 @@ pub mod rt { } return unsafe { pad(cv, s, PadSigned) }; } - pub pure fn conv_uint(cv: Conv, u: uint) -> ~str { + pub fn conv_uint(cv: Conv, u: uint) -> ~str { let prec = get_int_precision(cv); let mut rs = match cv.ty { @@ -730,17 +730,17 @@ pub mod rt { }; return unsafe { pad(cv, rs, PadUnsigned) }; } - pub pure fn conv_bool(cv: Conv, b: bool) -> ~str { + pub fn conv_bool(cv: Conv, b: bool) -> ~str { let s = if b { ~"true" } else { ~"false" }; // run the boolean conversion through the string conversion logic, // giving it the same rules for precision, etc. return conv_str(cv, s); } - pub pure fn conv_char(cv: Conv, c: char) -> ~str { + pub fn conv_char(cv: Conv, c: char) -> ~str { let mut s = str::from_char(c); return unsafe { pad(cv, s, PadNozero) }; } - pub pure fn conv_str(cv: Conv, s: &str) -> ~str { + pub fn conv_str(cv: Conv, s: &str) -> ~str { // For strings, precision is the maximum characters // displayed let mut unpadded = match cv.precision { @@ -753,7 +753,7 @@ pub mod rt { }; return unsafe { pad(cv, unpadded, PadNozero) }; } - pub pure fn conv_float(cv: Conv, f: float) -> ~str { + pub fn conv_float(cv: Conv, f: float) -> ~str { let (to_str, digits) = match cv.precision { CountIs(c) => (float::to_str_exact, c as uint), CountImplied => (float::to_str_digits, 6u) @@ -768,14 +768,14 @@ pub mod rt { } return unsafe { pad(cv, s, PadFloat) }; } - pub pure fn conv_poly<T>(cv: Conv, v: &T) -> ~str { + pub fn conv_poly<T>(cv: Conv, v: &T) -> ~str { let s = sys::log_str(v); return conv_str(cv, s); } // Convert an int to string with minimum number of digits. If precision is // 0 and num is 0 then the result is the empty string. - pub pure fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { + pub fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { return if num < 0 { ~"-" + uint_to_str_prec(-num as uint, radix, prec) } else { uint_to_str_prec(num as uint, radix, prec) }; @@ -784,7 +784,7 @@ pub mod rt { // Convert a uint to string with a minimum number of digits. If precision // is 0 and num is 0 then the result is the empty string. Could move this // to uint: but it doesn't seem all that useful. - pub pure fn uint_to_str_prec(num: uint, radix: uint, + pub fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str { return if prec == 0u && num == 0u { ~"" @@ -798,7 +798,7 @@ pub mod rt { } else { s } }; } - pub pure fn get_int_precision(cv: Conv) -> uint { + pub fn get_int_precision(cv: Conv) -> uint { return match cv.precision { CountIs(c) => c as uint, CountImplied => 1u @@ -828,7 +828,7 @@ pub mod rt { PadFloat => (true, true), PadUnsigned => (true, false) }; - pure fn have_precision(cv: Conv) -> bool { + fn have_precision(cv: Conv) -> bool { return match cv.precision { CountImplied => false, _ => true }; } let zero_padding = { @@ -858,7 +858,7 @@ pub mod rt { } return padstr + s; } - pub pure fn have_flag(flags: u32, f: u32) -> bool { + pub fn have_flag(flags: u32, f: u32) -> bool { flags & f != 0 } } diff --git a/src/libcore/util.rs b/src/libcore/util.rs index 214a9dea8d1..739314bf619 100644 --- a/src/libcore/util.rs +++ b/src/libcore/util.rs @@ -18,11 +18,11 @@ use prelude::*; /// The identity function. #[inline(always)] -pub pure fn id<T>(x: T) -> T { x } +pub fn id<T>(x: T) -> T { x } /// Ignores a value. #[inline(always)] -pub pure fn ignore<T>(_x: T) { } +pub fn ignore<T>(_x: T) { } /// Sets `*ptr` to `new_value`, invokes `op()`, and then restores the /// original value of `*ptr`. diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 2e20e859d55..56d547874d8 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -47,12 +47,12 @@ pub mod rustrt { } /// Returns true if a vector contains no elements -pub pure fn is_empty<T>(v: &[const T]) -> bool { +pub fn is_empty<T>(v: &[const T]) -> bool { as_const_buf(v, |_p, len| len == 0u) } /// Returns true if two vectors have the same length -pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool { +pub fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool { xs.len() == ys.len() } @@ -105,7 +105,7 @@ pub fn reserve_at_least<T>(v: &mut ~[T], n: uint) { /// Returns the number of elements the vector can hold without reallocating #[inline(always)] -pub pure fn capacity<T>(v: &const ~[T]) -> uint { +pub fn capacity<T>(v: &const ~[T]) -> uint { unsafe { let repr: **raw::VecRepr = ::cast::transmute(v); (**repr).unboxed.alloc / sys::nonzero_size_of::<T>() @@ -114,12 +114,12 @@ pub pure fn capacity<T>(v: &const ~[T]) -> uint { /// Returns the length of a vector #[inline(always)] -pub pure fn len<T>(v: &[const T]) -> uint { +pub fn len<T>(v: &[const T]) -> uint { as_const_buf(v, |_p, len| len) } // A botch to tide us over until core and std are fully demuted. -pub pure fn uniq_len<T>(v: &const ~[T]) -> uint { +pub fn uniq_len<T>(v: &const ~[T]) -> uint { unsafe { let v: &~[T] = ::cast::transmute(v); as_const_buf(*v, |_p, len| len) @@ -132,7 +132,7 @@ pub pure fn uniq_len<T>(v: &const ~[T]) -> uint { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value returned by the function `op`. */ -pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] { +pub fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] { unsafe { let mut v = with_capacity(n_elts); do as_mut_buf(v) |p, _len| { @@ -154,16 +154,16 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value `t`. */ -pub pure fn from_elem<T:Copy>(n_elts: uint, t: T) -> ~[T] { +pub fn from_elem<T:Copy>(n_elts: uint, t: T) -> ~[T] { from_fn(n_elts, |_i| copy t) } /// Creates a new unique vector with the same contents as the slice -pub pure fn from_slice<T:Copy>(t: &[T]) -> ~[T] { +pub fn from_slice<T:Copy>(t: &[T]) -> ~[T] { from_fn(t.len(), |i| t[i]) } -pub pure fn with_capacity<T>(capacity: uint) -> ~[T] { +pub fn with_capacity<T>(capacity: uint) -> ~[T] { let mut vec = ~[]; unsafe { reserve(&mut vec, capacity); } vec @@ -182,8 +182,7 @@ pub pure fn with_capacity<T>(capacity: uint) -> ~[T] { * onto the vector being constructed. */ #[inline(always)] -pub pure fn build_sized<A>(size: uint, - builder: &fn(push: &pure fn(v: A))) -> ~[A] { +pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> ~[A] { let mut vec = with_capacity(size); builder(|x| unsafe { vec.push(x) }); vec @@ -200,7 +199,7 @@ pub pure fn build_sized<A>(size: uint, * onto the vector being constructed. */ #[inline(always)] -pub pure fn build<A>(builder: &fn(push: &pure fn(v: A))) -> ~[A] { +pub fn build<A>(builder: &fn(push: &fn(v: A))) -> ~[A] { build_sized(4, builder) } @@ -217,54 +216,55 @@ pub pure fn build<A>(builder: &fn(push: &pure fn(v: A))) -> ~[A] { * onto the vector being constructed. */ #[inline(always)] -pub pure fn build_sized_opt<A>(size: Option<uint>, - builder: &fn(push: &pure fn(v: A))) -> ~[A] { +pub fn build_sized_opt<A>(size: Option<uint>, + builder: &fn(push: &fn(v: A))) + -> ~[A] { build_sized(size.get_or_default(4), builder) } // Accessors /// Returns the first element of a vector -pub pure fn head<T>(v: &'r [T]) -> &'r T { +pub fn head<T>(v: &'r [T]) -> &'r T { if v.len() == 0 { fail!(~"head: empty vector") } &v[0] } /// Returns `Some(x)` where `x` is the first element of the slice `v`, /// or `None` if the vector is empty. -pub pure fn head_opt<T>(v: &'r [T]) -> Option<&'r T> { +pub fn head_opt<T>(v: &'r [T]) -> Option<&'r T> { if v.len() == 0 { None } else { Some(&v[0]) } } /// Returns a vector containing all but the first element of a slice -pub pure fn tail<T>(v: &'r [T]) -> &'r [T] { slice(v, 1, v.len()) } +pub fn tail<T>(v: &'r [T]) -> &'r [T] { slice(v, 1, v.len()) } /// Returns a vector containing all but the first `n` elements of a slice -pub pure fn tailn<T>(v: &'r [T], n: uint) -> &'r [T] { slice(v, n, v.len()) } +pub fn tailn<T>(v: &'r [T], n: uint) -> &'r [T] { slice(v, n, v.len()) } /// Returns a vector containing all but the last element of a slice -pub pure fn init<T>(v: &'r [T]) -> &'r [T] { slice(v, 0, v.len() - 1) } +pub fn init<T>(v: &'r [T]) -> &'r [T] { slice(v, 0, v.len() - 1) } /// Returns a vector containing all but the last `n' elements of a slice -pub pure fn initn<T>(v: &'r [T], n: uint) -> &'r [T] { +pub fn initn<T>(v: &'r [T], n: uint) -> &'r [T] { slice(v, 0, v.len() - n) } /// Returns the last element of the slice `v`, failing if the slice is empty. -pub pure fn last<T>(v: &'r [T]) -> &'r T { +pub fn last<T>(v: &'r [T]) -> &'r T { if v.len() == 0 { fail!(~"last: empty vector") } &v[v.len() - 1] } /// Returns `Some(x)` where `x` is the last element of the slice `v`, or /// `None` if the vector is empty. -pub pure fn last_opt<T>(v: &'r [T]) -> Option<&'r T> { +pub fn last_opt<T>(v: &'r [T]) -> Option<&'r T> { if v.len() == 0 { None } else { Some(&v[v.len() - 1]) } } /// Return a slice that points into another slice. #[inline(always)] -pub pure fn slice<T>(v: &'r [T], start: uint, end: uint) -> &'r [T] { +pub fn slice<T>(v: &'r [T], start: uint, end: uint) -> &'r [T] { fail_unless!(start <= end); fail_unless!(end <= len(v)); do as_imm_buf(v) |p, _len| { @@ -278,10 +278,7 @@ pub pure fn slice<T>(v: &'r [T], start: uint, end: uint) -> &'r [T] { /// Return a slice that points into another slice. #[inline(always)] -pub pure fn mut_slice<T>(v: &'r mut [T], - start: uint, - end: uint) - -> &'r mut [T] { +pub fn mut_slice<T>(v: &'r mut [T], start: uint, end: uint) -> &'r mut [T] { fail_unless!(start <= end); fail_unless!(end <= v.len()); do as_mut_buf(v) |p, _len| { @@ -295,10 +292,8 @@ pub pure fn mut_slice<T>(v: &'r mut [T], /// Return a slice that points into another slice. #[inline(always)] -pub pure fn const_slice<T>(v: &'r [const T], - start: uint, - end: uint) - -> &'r [const T] { +pub fn const_slice<T>(v: &'r [const T], start: uint, end: uint) + -> &'r [const T] { fail_unless!(start <= end); fail_unless!(end <= len(v)); do as_const_buf(v) |p, _len| { @@ -434,7 +429,7 @@ pub fn partition<T>(v: ~[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) { * Partitions a vector into two new vectors: those that satisfies the * predicate, and those that do not. */ -pub pure fn partitioned<T:Copy>(v: &[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) { +pub fn partitioned<T:Copy>(v: &[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) { let mut lefts = ~[]; let mut rights = ~[]; @@ -713,7 +708,7 @@ pub fn dedup<T:Eq>(v: &mut ~[T]) { // Appending #[inline(always)] -pub pure fn append<T:Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] { +pub fn append<T:Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] { let mut v = lhs; unsafe { v.push_all(rhs); @@ -722,7 +717,7 @@ pub pure fn append<T:Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] { } #[inline(always)] -pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] { +pub fn append_one<T>(lhs: ~[T], x: T) -> ~[T] { let mut v = lhs; unsafe { v.push(x); } v @@ -788,7 +783,7 @@ pub fn grow_set<T:Copy>(v: &mut ~[T], index: uint, initval: &T, val: T) { // Functional utilities /// Apply a function to each element of a vector and return the results -pub pure fn map<T, U>(v: &[T], f: &fn(t: &T) -> U) -> ~[U] { +pub fn map<T, U>(v: &[T], f: &fn(t: &T) -> U) -> ~[U] { let mut result = with_capacity(len(v)); for each(v) |elem| { unsafe { @@ -807,7 +802,7 @@ pub fn map_consume<T, U>(v: ~[T], f: &fn(v: T) -> U) -> ~[U] { } /// Apply a function to each element of a vector and return the results -pub pure fn mapi<T, U>(v: &[T], f: &fn(uint, t: &T) -> U) -> ~[U] { +pub fn mapi<T, U>(v: &[T], f: &fn(uint, t: &T) -> U) -> ~[U] { let mut i = 0; do map(v) |e| { i += 1; @@ -819,14 +814,14 @@ pub pure fn mapi<T, U>(v: &[T], f: &fn(uint, t: &T) -> U) -> ~[U] { * Apply a function to each element of a vector and return a concatenation * of each result vector */ -pub pure fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] { +pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] { let mut result = ~[]; for each(v) |elem| { unsafe{ result.push_all_move(f(elem)); } } result } /// Apply a function to each pair of elements and return the results -pub pure fn map2<T:Copy,U:Copy,V>(v0: &[T], v1: &[U], +pub fn map2<T:Copy,U:Copy,V>(v0: &[T], v1: &[U], f: &fn(t: &T, v: &U) -> V) -> ~[V] { let v0_len = len(v0); if v0_len != len(v1) { fail!(); } @@ -860,7 +855,7 @@ pub fn filter_map<T, U>( result } -pub pure fn filter_mapped<T, U: Copy>( +pub fn filter_mapped<T, U: Copy>( v: &[T], f: &fn(t: &T) -> Option<U>) -> ~[U] { @@ -904,7 +899,7 @@ pub fn filter<T>(v: ~[T], f: &fn(t: &T) -> bool) -> ~[T] { * Apply function `f` to each element of `v` and return a vector containing * only those elements for which `f` returned true. */ -pub pure fn filtered<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[T] { +pub fn filtered<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[T] { let mut result = ~[]; for each(v) |elem| { if f(elem) { unsafe { result.push(*elem); } } @@ -915,7 +910,7 @@ pub pure fn filtered<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[T] { /** * Like `filter()`, but in place. Preserves order of `v`. Linear time. */ -pub fn retain<T>(v: &mut ~[T], f: &pure fn(t: &T) -> bool) { +pub fn retain<T>(v: &mut ~[T], f: &fn(t: &T) -> bool) { let len = v.len(); let mut deleted: uint = 0; @@ -937,14 +932,14 @@ pub fn retain<T>(v: &mut ~[T], f: &pure fn(t: &T) -> bool) { * * Flattens a vector of vectors of T into a single vector of T. */ -pub pure fn concat<T:Copy>(v: &[~[T]]) -> ~[T] { +pub fn concat<T:Copy>(v: &[~[T]]) -> ~[T] { let mut r = ~[]; for each(v) |inner| { unsafe { r.push_all(*inner); } } r } /// Concatenate a vector of vectors, placing a given separator between each -pub pure fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] { +pub fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] { let mut r: ~[T] = ~[]; let mut first = true; for each(v) |inner| { @@ -971,7 +966,7 @@ pub pure fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] { * ~~~ * */ -pub pure fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T { +pub fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T { let mut accum = z; let mut i = 0; let l = v.len(); @@ -1003,7 +998,7 @@ pub pure fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T { * ~~~ * */ -pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U { +pub fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U { let mut accum = z; for v.each_reverse |elt| { accum = p(elt, accum); @@ -1016,7 +1011,7 @@ pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U { * * If the vector contains no elements then false is returned. */ -pub pure fn any<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { +pub fn any<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { for each(v) |elem| { if f(elem) { return true; } } false } @@ -1026,7 +1021,7 @@ pub pure fn any<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { * * If the vectors contains no elements then false is returned. */ -pub pure fn any2<T, U>(v0: &[T], v1: &[U], +pub fn any2<T, U>(v0: &[T], v1: &[U], f: &fn(a: &T, b: &U) -> bool) -> bool { let v0_len = len(v0); let v1_len = len(v1); @@ -1043,7 +1038,7 @@ pub pure fn any2<T, U>(v0: &[T], v1: &[U], * * If the vector contains no elements then true is returned. */ -pub pure fn all<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { +pub fn all<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { for each(v) |elem| { if !f(elem) { return false; } } true } @@ -1053,7 +1048,7 @@ pub pure fn all<T>(v: &[T], f: &fn(t: &T) -> bool) -> bool { * * If the vector contains no elements then true is returned. */ -pub pure fn alli<T>(v: &[T], f: &fn(uint, t: &T) -> bool) -> bool { +pub fn alli<T>(v: &[T], f: &fn(uint, t: &T) -> bool) -> bool { for eachi(v) |i, elem| { if !f(i, elem) { return false; } } true } @@ -1063,7 +1058,7 @@ pub pure fn alli<T>(v: &[T], f: &fn(uint, t: &T) -> bool) -> bool { * * If the vectors are not the same size then false is returned. */ -pub pure fn all2<T, U>(v0: &[T], v1: &[U], +pub fn all2<T, U>(v0: &[T], v1: &[U], f: &fn(t: &T, u: &U) -> bool) -> bool { let v0_len = len(v0); if v0_len != len(v1) { return false; } @@ -1073,13 +1068,13 @@ pub pure fn all2<T, U>(v0: &[T], v1: &[U], } /// Return true if a vector contains an element with the given value -pub pure fn contains<T:Eq>(v: &[T], x: &T) -> bool { +pub fn contains<T:Eq>(v: &[T], x: &T) -> bool { for each(v) |elt| { if *x == *elt { return true; } } false } /// Returns the number of elements that are equal to a given value -pub pure fn count<T:Eq>(v: &[T], x: &T) -> uint { +pub fn count<T:Eq>(v: &[T], x: &T) -> uint { let mut cnt = 0u; for each(v) |elt| { if *x == *elt { cnt += 1u; } } cnt @@ -1092,7 +1087,7 @@ pub pure fn count<T:Eq>(v: &[T], x: &T) -> uint { * When function `f` returns true then an option containing the element * is returned. If `f` matches no elements then none is returned. */ -pub pure fn find<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { +pub fn find<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { find_between(v, 0u, len(v), f) } @@ -1103,7 +1098,7 @@ pub pure fn find<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { * [`start`, `end`). When function `f` returns true then an option containing * the element is returned. If `f` matches no elements then none is returned. */ -pub pure fn find_between<T:Copy>(v: &[T], start: uint, end: uint, +pub fn find_between<T:Copy>(v: &[T], start: uint, end: uint, f: &fn(t: &T) -> bool) -> Option<T> { position_between(v, start, end, f).map(|i| v[*i]) } @@ -1115,7 +1110,7 @@ pub pure fn find_between<T:Copy>(v: &[T], start: uint, end: uint, * `f` returns true then an option containing the element is returned. If `f` * matches no elements then none is returned. */ -pub pure fn rfind<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { +pub fn rfind<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { rfind_between(v, 0u, len(v), f) } @@ -1126,13 +1121,16 @@ pub pure fn rfind<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> Option<T> { * [`start`, `end`). When function `f` returns true then an option containing * the element is returned. If `f` matches no elements then none is return. */ -pub pure fn rfind_between<T:Copy>(v: &[T], start: uint, end: uint, - f: &fn(t: &T) -> bool) -> Option<T> { +pub fn rfind_between<T:Copy>(v: &[T], + start: uint, + end: uint, + f: &fn(t: &T) -> bool) + -> Option<T> { rposition_between(v, start, end, f).map(|i| v[*i]) } /// Find the first index containing a matching value -pub pure fn position_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { +pub fn position_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { position(v, |y| *x == *y) } @@ -1143,7 +1141,7 @@ pub pure fn position_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { * then an option containing the index is returned. If `f` matches no elements * then none is returned. */ -pub pure fn position<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { +pub fn position<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { position_between(v, 0u, len(v), f) } @@ -1154,8 +1152,11 @@ pub pure fn position<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { * [`start`, `end`). When function `f` returns true then an option containing * the index is returned. If `f` matches no elements then none is returned. */ -pub pure fn position_between<T>(v: &[T], start: uint, end: uint, - f: &fn(t: &T) -> bool) -> Option<uint> { +pub fn position_between<T>(v: &[T], + start: uint, + end: uint, + f: &fn(t: &T) -> bool) + -> Option<uint> { fail_unless!(start <= end); fail_unless!(end <= len(v)); let mut i = start; @@ -1164,7 +1165,7 @@ pub pure fn position_between<T>(v: &[T], start: uint, end: uint, } /// Find the last index containing a matching value -pure fn rposition_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { +pub fn rposition_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { rposition(v, |y| *x == *y) } @@ -1175,7 +1176,7 @@ pure fn rposition_elem<T:Eq>(v: &[T], x: &T) -> Option<uint> { * `f` returns true then an option containing the index is returned. If `f` * matches no elements then none is returned. */ -pub pure fn rposition<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { +pub fn rposition<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { rposition_between(v, 0u, len(v), f) } @@ -1187,7 +1188,7 @@ pub pure fn rposition<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> { * containing the index is returned. If `f` matches no elements then none is * returned. */ -pub pure fn rposition_between<T>(v: &[T], start: uint, end: uint, +pub fn rposition_between<T>(v: &[T], start: uint, end: uint, f: &fn(t: &T) -> bool) -> Option<uint> { fail_unless!(start <= end); fail_unless!(end <= len(v)); @@ -1206,7 +1207,7 @@ pub pure fn rposition_between<T>(v: &[T], start: uint, end: uint, /** * Convert a vector of pairs into a pair of vectors, by reference. As unzip(). */ -pure fn unzip_slice<T:Copy,U:Copy>(v: &[(T, U)]) -> (~[T], ~[U]) { +pub fn unzip_slice<T:Copy,U:Copy>(v: &[(T, U)]) -> (~[T], ~[U]) { let mut ts = ~[], us = ~[]; for each(v) |p| { let (t, u) = *p; @@ -1226,7 +1227,7 @@ pure fn unzip_slice<T:Copy,U:Copy>(v: &[(T, U)]) -> (~[T], ~[U]) { * and the i-th element of the second vector contains the second element * of the i-th tuple of the input vector. */ -pub pure fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) { +pub fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) { let mut ts = ~[], us = ~[]; unsafe { do consume(v) |_i, p| { @@ -1241,7 +1242,7 @@ pub pure fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) { /** * Convert two vectors to a vector of pairs, by reference. As zip(). */ -pub pure fn zip_slice<T:Copy,U:Copy>(v: &[const T], u: &[const U]) +pub fn zip_slice<T:Copy,U:Copy>(v: &[const T], u: &[const U]) -> ~[(T, U)] { let mut zipped = ~[]; let sz = len(v); @@ -1259,7 +1260,7 @@ pub pure fn zip_slice<T:Copy,U:Copy>(v: &[const T], u: &[const U]) * Returns a vector of tuples, where the i-th tuple contains contains the * i-th elements from each of the input vectors. */ -pub pure fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] { +pub fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] { let mut i = len(v); fail_unless!(i == len(u)); let mut w = with_capacity(i); @@ -1292,7 +1293,7 @@ pub fn reverse<T>(v: &mut [T]) { } /// Returns a vector with the order of elements reversed -pub pure fn reversed<T:Copy>(v: &[const T]) -> ~[T] { +pub fn reversed<T:Copy>(v: &[const T]) -> ~[T] { let mut rs: ~[T] = ~[]; let mut i = len::<T>(v); if i == 0 { return (rs); } else { i -= 1; } @@ -1342,7 +1343,7 @@ pub pure fn reversed<T:Copy>(v: &[const T]) -> ~[T] { * ~~~ */ #[inline(always)] -pub pure fn each<T>(v: &'r [T], f: &fn(&'r T) -> bool) { +pub fn each<T>(v: &'r [T], f: &fn(&'r T) -> bool) { // ^^^^ // NB---this CANNOT be &[const T]! The reason // is that you are passing it to `f()` using @@ -1380,7 +1381,7 @@ pub fn each_mut<T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) { /// Like `each()`, but for the case where you have a vector that *may or may /// not* have mutable contents. #[inline(always)] -pub pure fn each_const<T>(v: &[const T], f: &fn(elem: &const T) -> bool) { +pub fn each_const<T>(v: &[const T], f: &fn(elem: &const T) -> bool) { let mut i = 0; let n = v.len(); while i < n { @@ -1397,7 +1398,7 @@ pub pure fn each_const<T>(v: &[const T], f: &fn(elem: &const T) -> bool) { * Return true to continue, false to break. */ #[inline(always)] -pub pure fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) { +pub fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) { let mut i = 0; for each(v) |p| { if !f(i, p) { return; } @@ -1411,7 +1412,7 @@ pub pure fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) { * Return true to continue, false to break. */ #[inline(always)] -pub pure fn each_reverse<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) { +pub fn each_reverse<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) { eachi_reverse(v, |_i, v| blk(v)) } @@ -1421,7 +1422,7 @@ pub pure fn each_reverse<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) { * Return true to continue, false to break. */ #[inline(always)] -pub pure fn eachi_reverse<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) { +pub fn eachi_reverse<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) { let mut i = v.len(); while i > 0 { i -= 1; @@ -1439,7 +1440,7 @@ pub pure fn eachi_reverse<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) { * Both vectors must have the same length */ #[inline] -pub pure fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) { +pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) { fail_unless!(len(v1) == len(v2)); for uint::range(0u, len(v1)) |i| { if !f(&v1[i], &v2[i]) { @@ -1458,7 +1459,7 @@ pub pure fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) { * The total number of permutations produced is `len(v)!`. If `v` contains * repeated elements, then some permutations are repeated. */ -pub pure fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) { +pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) { let ln = len(v); if ln <= 1 { put(v); @@ -1482,7 +1483,7 @@ pub pure fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) { } } -pub pure fn windowed<TT:Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] { +pub fn windowed<TT:Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] { let mut ww = ~[]; fail_unless!(1u <= nn); for vec::eachi (xx) |ii, _x| { @@ -1503,9 +1504,9 @@ pub pure fn windowed<TT:Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] { * foreign interop. */ #[inline(always)] -pub pure fn as_imm_buf<T,U>(s: &[T], - /* NB---this CANNOT be const, see below */ - f: &fn(*T, uint) -> U) -> U { +pub fn as_imm_buf<T,U>(s: &[T], + /* NB---this CANNOT be const, see below */ + f: &fn(*T, uint) -> U) -> U { // NB---Do not change the type of s to `&[const T]`. This is // unsound. The reason is that we are going to create immutable pointers @@ -1523,9 +1524,7 @@ pub pure fn as_imm_buf<T,U>(s: &[T], /// Similar to `as_imm_buf` but passing a `*const T` #[inline(always)] -pub pure fn as_const_buf<T,U>(s: &[const T], - f: &fn(*const T, uint) -> U) -> U { - +pub fn as_const_buf<T,U>(s: &[const T], f: &fn(*const T, uint) -> U) -> U { unsafe { let v : *(*const T,uint) = ::cast::reinterpret_cast(&addr_of(&s)); @@ -1536,9 +1535,7 @@ pub pure fn as_const_buf<T,U>(s: &[const T], /// Similar to `as_imm_buf` but passing a `*mut T` #[inline(always)] -pub pure fn as_mut_buf<T,U>(s: &mut [T], - f: &fn(*mut T, uint) -> U) -> U { - +pub fn as_mut_buf<T,U>(s: &mut [T], f: &fn(*mut T, uint) -> U) -> U { unsafe { let v : *(*mut T,uint) = ::cast::reinterpret_cast(&addr_of(&s)); @@ -1549,7 +1546,7 @@ pub pure fn as_mut_buf<T,U>(s: &mut [T], // Equality -pure fn eq<T:Eq>(a: &[T], b: &[T]) -> bool { +fn eq<T:Eq>(a: &[T], b: &[T]) -> bool { let (a_len, b_len) = (a.len(), b.len()); if a_len != b_len { return false; } @@ -1565,37 +1562,37 @@ pure fn eq<T:Eq>(a: &[T], b: &[T]) -> bool { #[cfg(notest)] impl<T:Eq> Eq for &'self [T] { #[inline(always)] - pure fn eq(&self, other: & &'self [T]) -> bool { eq((*self), (*other)) } + fn eq(&self, other: & &'self [T]) -> bool { eq((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: & &'self [T]) -> bool { !(*self).eq(other) } + fn ne(&self, other: & &'self [T]) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl<T:Eq> Eq for ~[T] { #[inline(always)] - pure fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) } + fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: &~[T]) -> bool { !(*self).eq(other) } + fn ne(&self, other: &~[T]) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl<T:Eq> Eq for @[T] { #[inline(always)] - pure fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) } + fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) } #[inline(always)] - pure fn ne(&self, other: &@[T]) -> bool { !(*self).eq(other) } + fn ne(&self, other: &@[T]) -> bool { !(*self).eq(other) } } #[cfg(notest)] impl<T:Eq> Equiv<~[T]> for &'self [T] { #[inline(always)] - pure fn equiv(&self, other: &~[T]) -> bool { eq(*self, *other) } + fn equiv(&self, other: &~[T]) -> bool { eq(*self, *other) } } // Lexicographical comparison -pure fn cmp<T: TotalOrd>(a: &[T], b: &[T]) -> Ordering { +fn cmp<T: TotalOrd>(a: &[T], b: &[T]) -> Ordering { let low = uint::min(a.len(), b.len()); for uint::range(0, low) |idx| { @@ -1612,22 +1609,22 @@ pure fn cmp<T: TotalOrd>(a: &[T], b: &[T]) -> Ordering { #[cfg(notest)] impl<T: TotalOrd> TotalOrd for &'self [T] { #[inline(always)] - pure fn cmp(&self, other: & &'self [T]) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: & &'self [T]) -> Ordering { cmp(*self, *other) } } #[cfg(notest)] impl<T: TotalOrd> TotalOrd for ~[T] { #[inline(always)] - pure fn cmp(&self, other: &~[T]) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: &~[T]) -> Ordering { cmp(*self, *other) } } #[cfg(notest)] impl<T: TotalOrd> TotalOrd for @[T] { #[inline(always)] - pure fn cmp(&self, other: &@[T]) -> Ordering { cmp(*self, *other) } + fn cmp(&self, other: &@[T]) -> Ordering { cmp(*self, *other) } } -pure fn lt<T:Ord>(a: &[T], b: &[T]) -> bool { +fn lt<T:Ord>(a: &[T], b: &[T]) -> bool { let (a_len, b_len) = (a.len(), b.len()); let mut end = uint::min(a_len, b_len); @@ -1642,44 +1639,44 @@ pure fn lt<T:Ord>(a: &[T], b: &[T]) -> bool { a_len < b_len } -pure fn le<T:Ord>(a: &[T], b: &[T]) -> bool { !lt(b, a) } -pure fn ge<T:Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) } -pure fn gt<T:Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) } +fn le<T:Ord>(a: &[T], b: &[T]) -> bool { !lt(b, a) } +fn ge<T:Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) } +fn gt<T:Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) } #[cfg(notest)] impl<T:Ord> Ord for &'self [T] { #[inline(always)] - pure fn lt(&self, other: & &'self [T]) -> bool { lt((*self), (*other)) } + fn lt(&self, other: & &'self [T]) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: & &'self [T]) -> bool { le((*self), (*other)) } + fn le(&self, other: & &'self [T]) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: & &'self [T]) -> bool { ge((*self), (*other)) } + fn ge(&self, other: & &'self [T]) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: & &'self [T]) -> bool { gt((*self), (*other)) } + fn gt(&self, other: & &'self [T]) -> bool { gt((*self), (*other)) } } #[cfg(notest)] impl<T:Ord> Ord for ~[T] { #[inline(always)] - pure fn lt(&self, other: &~[T]) -> bool { lt((*self), (*other)) } + fn lt(&self, other: &~[T]) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: &~[T]) -> bool { le((*self), (*other)) } + fn le(&self, other: &~[T]) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: &~[T]) -> bool { ge((*self), (*other)) } + fn ge(&self, other: &~[T]) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: &~[T]) -> bool { gt((*self), (*other)) } + fn gt(&self, other: &~[T]) -> bool { gt((*self), (*other)) } } #[cfg(notest)] impl<T:Ord> Ord for @[T] { #[inline(always)] - pure fn lt(&self, other: &@[T]) -> bool { lt((*self), (*other)) } + fn lt(&self, other: &@[T]) -> bool { lt((*self), (*other)) } #[inline(always)] - pure fn le(&self, other: &@[T]) -> bool { le((*self), (*other)) } + fn le(&self, other: &@[T]) -> bool { le((*self), (*other)) } #[inline(always)] - pure fn ge(&self, other: &@[T]) -> bool { ge((*self), (*other)) } + fn ge(&self, other: &@[T]) -> bool { ge((*self), (*other)) } #[inline(always)] - pure fn gt(&self, other: &@[T]) -> bool { gt((*self), (*other)) } + fn gt(&self, other: &@[T]) -> bool { gt((*self), (*other)) } } #[cfg(notest)] @@ -1690,7 +1687,7 @@ pub mod traits { impl<T:Copy> Add<&'self [const T],~[T]> for ~[T] { #[inline(always)] - pure fn add(&self, rhs: & &'self [const T]) -> ~[T] { + fn add(&self, rhs: & &'self [const T]) -> ~[T] { append(copy *self, (*rhs)) } } @@ -1699,22 +1696,22 @@ pub mod traits { impl<T> Container for &'self [const T] { /// Returns true if a vector contains no elements #[inline] - pure fn is_empty(&const self) -> bool { is_empty(*self) } + fn is_empty(&const self) -> bool { is_empty(*self) } /// Returns the length of a vector #[inline] - pure fn len(&const self) -> uint { len(*self) } + fn len(&const self) -> uint { len(*self) } } pub trait CopyableVector<T> { - pure fn to_owned(&self) -> ~[T]; + fn to_owned(&self) -> ~[T]; } /// Extension methods for vectors impl<T: Copy> CopyableVector<T> for &'self [const T] { /// Returns a copy of `v`. #[inline] - pure fn to_owned(&self) -> ~[T] { + fn to_owned(&self) -> ~[T] { let mut result = ~[]; // FIXME: #4568 unsafe { @@ -1729,93 +1726,93 @@ impl<T: Copy> CopyableVector<T> for &'self [const T] { } pub trait ImmutableVector<T> { - pure fn slice(&self, start: uint, end: uint) -> &'self [T]; - pure fn head(&self) -> &'self T; - pure fn head_opt(&self) -> Option<&'self T>; - pure fn tail(&self) -> &'self [T]; - pure fn tailn(&self, n: uint) -> &'self [T]; - pure fn init(&self) -> &'self [T]; - pure fn initn(&self, n: uint) -> &'self [T]; - pure fn last(&self) -> &'self T; - pure fn last_opt(&self) -> Option<&'self T>; - pure fn each_reverse(&self, blk: &fn(&T) -> bool); - pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool); - pure fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U; - pure fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U]; - pure fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U]; + fn slice(&self, start: uint, end: uint) -> &'self [T]; + fn head(&self) -> &'self T; + fn head_opt(&self) -> Option<&'self T>; + fn tail(&self) -> &'self [T]; + fn tailn(&self, n: uint) -> &'self [T]; + fn init(&self) -> &'self [T]; + fn initn(&self, n: uint) -> &'self [T]; + fn last(&self) -> &'self T; + fn last_opt(&self) -> Option<&'self T>; + fn each_reverse(&self, blk: &fn(&T) -> bool); + fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool); + fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U; + fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U]; + fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U]; fn map_r<U>(&self, f: &fn(x: &T) -> U) -> ~[U]; - pure fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool; - pure fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U]; - pure fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U]; + fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool; + fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U]; + fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U]; } /// Extension methods for vectors impl<T> ImmutableVector<T> for &'self [T] { /// Return a slice that points into another slice. #[inline] - pure fn slice(&self, start: uint, end: uint) -> &'self [T] { + fn slice(&self, start: uint, end: uint) -> &'self [T] { slice(*self, start, end) } /// Returns the first element of a vector, failing if the vector is empty. #[inline] - pure fn head(&self) -> &'self T { head(*self) } + fn head(&self) -> &'self T { head(*self) } /// Returns the first element of a vector #[inline] - pure fn head_opt(&self) -> Option<&'self T> { head_opt(*self) } + fn head_opt(&self) -> Option<&'self T> { head_opt(*self) } /// Returns all but the first element of a vector #[inline] - pure fn tail(&self) -> &'self [T] { tail(*self) } + fn tail(&self) -> &'self [T] { tail(*self) } /// Returns all but the first `n' elements of a vector #[inline] - pure fn tailn(&self, n: uint) -> &'self [T] { tailn(*self, n) } + fn tailn(&self, n: uint) -> &'self [T] { tailn(*self, n) } /// Returns all but the last elemnt of a vector #[inline] - pure fn init(&self) -> &'self [T] { init(*self) } + fn init(&self) -> &'self [T] { init(*self) } /// Returns all but the last `n' elemnts of a vector #[inline] - pure fn initn(&self, n: uint) -> &'self [T] { initn(*self, n) } + fn initn(&self, n: uint) -> &'self [T] { initn(*self, n) } /// Returns the last element of a `v`, failing if the vector is empty. #[inline] - pure fn last(&self) -> &'self T { last(*self) } + fn last(&self) -> &'self T { last(*self) } /// Returns the last element of a `v`, failing if the vector is empty. #[inline] - pure fn last_opt(&self) -> Option<&'self T> { last_opt(*self) } + fn last_opt(&self) -> Option<&'self T> { last_opt(*self) } /// Iterates over a vector's elements in reverse. #[inline] - pure fn each_reverse(&self, blk: &fn(&T) -> bool) { + fn each_reverse(&self, blk: &fn(&T) -> bool) { each_reverse(*self, blk) } /// Iterates over a vector's elements and indices in reverse. #[inline] - pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) { + fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) { eachi_reverse(*self, blk) } /// Reduce a vector from right to left #[inline] - pure fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U { + fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U { foldr(*self, z, p) } /// Apply a function to each element of a vector and return the results #[inline] - pure fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] { map(*self, f) } + fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] { map(*self, f) } /** * Apply a function to the index and value of each element in the vector * and return the results */ - pure fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U] { + fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U] { mapi(*self, f) } @@ -1835,7 +1832,7 @@ impl<T> ImmutableVector<T> for &'self [T] { * * If the vector is empty, true is returned. */ - pure fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool { + fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool { alli(*self, f) } /** @@ -1843,7 +1840,7 @@ impl<T> ImmutableVector<T> for &'self [T] { * of each result vector */ #[inline] - pure fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U] { + fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U] { flat_map(*self, f) } /** @@ -1853,16 +1850,16 @@ impl<T> ImmutableVector<T> for &'self [T] { * the resulting vector. */ #[inline] - pure fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U] { + fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U] { filter_mapped(*self, f) } } pub trait ImmutableEqVector<T:Eq> { - pure fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>; - pure fn position_elem(&self, t: &T) -> Option<uint>; - pure fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>; - pure fn rposition_elem(&self, t: &T) -> Option<uint>; + fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>; + fn position_elem(&self, t: &T) -> Option<uint>; + fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>; + fn rposition_elem(&self, t: &T) -> Option<uint>; } impl<T:Eq> ImmutableEqVector<T> for &'self [T] { @@ -1874,13 +1871,13 @@ impl<T:Eq> ImmutableEqVector<T> for &'self [T] { * elements then none is returned. */ #[inline] - pure fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> { + fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> { position(*self, f) } /// Find the first index containing a matching value #[inline] - pure fn position_elem(&self, x: &T) -> Option<uint> { + fn position_elem(&self, x: &T) -> Option<uint> { position_elem(*self, x) } @@ -1892,21 +1889,21 @@ impl<T:Eq> ImmutableEqVector<T> for &'self [T] { * returned. If `f` matches no elements then none is returned. */ #[inline] - pure fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> { + fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> { rposition(*self, f) } /// Find the last index containing a matching value #[inline] - pure fn rposition_elem(&self, t: &T) -> Option<uint> { + fn rposition_elem(&self, t: &T) -> Option<uint> { rposition_elem(*self, t) } } pub trait ImmutableCopyableVector<T> { - pure fn filtered(&self, f: &fn(&T) -> bool) -> ~[T]; - pure fn rfind(&self, f: &fn(t: &T) -> bool) -> Option<T>; - pure fn partitioned(&self, f: &fn(&T) -> bool) -> (~[T], ~[T]); + fn filtered(&self, f: &fn(&T) -> bool) -> ~[T]; + fn rfind(&self, f: &fn(t: &T) -> bool) -> Option<T>; + fn partitioned(&self, f: &fn(&T) -> bool) -> (~[T], ~[T]); } /// Extension methods for vectors @@ -1919,7 +1916,7 @@ impl<T:Copy> ImmutableCopyableVector<T> for &'self [T] { * containing only those elements for which `f` returned true. */ #[inline] - pure fn filtered(&self, f: &fn(t: &T) -> bool) -> ~[T] { + fn filtered(&self, f: &fn(t: &T) -> bool) -> ~[T] { filtered(*self, f) } @@ -1931,7 +1928,7 @@ impl<T:Copy> ImmutableCopyableVector<T> for &'self [T] { * returned. If `f` matches no elements then none is returned. */ #[inline] - pure fn rfind(&self, f: &fn(t: &T) -> bool) -> Option<T> { + fn rfind(&self, f: &fn(t: &T) -> bool) -> Option<T> { rfind(*self, f) } @@ -1940,7 +1937,7 @@ impl<T:Copy> ImmutableCopyableVector<T> for &'self [T] { * those that do not. */ #[inline] - pure fn partitioned(&self, f: &fn(&T) -> bool) -> (~[T], ~[T]) { + fn partitioned(&self, f: &fn(&T) -> bool) -> (~[T], ~[T]) { partitioned(*self, f) } } @@ -1955,10 +1952,10 @@ pub trait OwnedVector<T> { fn remove(&mut self, i: uint) -> T; fn swap_remove(&mut self, index: uint) -> T; fn truncate(&mut self, newlen: uint); - fn retain(&mut self, f: &pure fn(t: &T) -> bool); + fn retain(&mut self, f: &fn(t: &T) -> bool); fn consume(self, f: &fn(uint, v: T)); fn filter(self, f: &fn(t: &T) -> bool) -> ~[T]; - fn partition(self, f: &pure fn(&T) -> bool) -> (~[T], ~[T]); + fn partition(self, f: &fn(&T) -> bool) -> (~[T], ~[T]); fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>); } @@ -2009,7 +2006,7 @@ impl<T> OwnedVector<T> for ~[T] { } #[inline] - fn retain(&mut self, f: &pure fn(t: &T) -> bool) { + fn retain(&mut self, f: &fn(t: &T) -> bool) { retain(self, f); } @@ -2258,7 +2255,7 @@ pub mod bytes { use vec; /// Bytewise string comparison - pub pure fn memcmp(a: &~[u8], b: &~[u8]) -> int { + pub fn memcmp(a: &~[u8], b: &~[u8]) -> int { let a_len = a.len(); let b_len = b.len(); let n = uint::min(a_len, b_len) as libc::size_t; @@ -2279,22 +2276,22 @@ pub mod bytes { } /// Bytewise less than or equal - pub pure fn lt(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) < 0 } + pub fn lt(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) < 0 } /// Bytewise less than or equal - pub pure fn le(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) <= 0 } + pub fn le(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) <= 0 } /// Bytewise equality - pub pure fn eq(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) == 0 } + pub fn eq(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) == 0 } /// Bytewise inequality - pub pure fn ne(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) != 0 } + pub fn ne(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) != 0 } /// Bytewise greater than or equal - pub pure fn ge(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) >= 0 } + pub fn ge(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) >= 0 } /// Bytewise greater than - pub pure fn gt(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) > 0 } + pub fn gt(a: &~[u8], b: &~[u8]) -> bool { memcmp(a, b) > 0 } /** * Copies data from one vector to another. @@ -2314,25 +2311,25 @@ pub mod bytes { impl<A> iter::BaseIter<A> for &'self [A] { #[inline(always)] - pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } + fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } // FIXME(#4148): This should be redundant impl<A> iter::BaseIter<A> for ~[A] { #[inline(always)] - pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } + fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } // FIXME(#4148): This should be redundant impl<A> iter::BaseIter<A> for @[A] { #[inline(always)] - pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } + fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<A> iter::MutableIter<A> for &'self mut [A] { @@ -2359,25 +2356,25 @@ impl<A> iter::MutableIter<A> for @mut [A] { } impl<A> iter::ExtendedIter<A> for &'self [A] { - pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { + pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { iter::eachi(self, blk) } - pub pure fn all(&self, blk: &fn(&A) -> bool) -> bool { + pub fn all(&self, blk: &fn(&A) -> bool) -> bool { iter::all(self, blk) } - pub pure fn any(&self, blk: &fn(&A) -> bool) -> bool { + pub fn any(&self, blk: &fn(&A) -> bool) -> bool { iter::any(self, blk) } - pub pure fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { + pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { iter::foldl(self, b0, blk) } - pub pure fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { + pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { iter::position(self, f) } - pure fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { + fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { iter::map_to_vec(self, op) } - pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) + fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B] { iter::flat_map_to_vec(self, op) } @@ -2385,25 +2382,25 @@ impl<A> iter::ExtendedIter<A> for &'self [A] { // FIXME(#4148): This should be redundant impl<A> iter::ExtendedIter<A> for ~[A] { - pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { + pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { iter::eachi(self, blk) } - pub pure fn all(&self, blk: &fn(&A) -> bool) -> bool { + pub fn all(&self, blk: &fn(&A) -> bool) -> bool { iter::all(self, blk) } - pub pure fn any(&self, blk: &fn(&A) -> bool) -> bool { + pub fn any(&self, blk: &fn(&A) -> bool) -> bool { iter::any(self, blk) } - pub pure fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { + pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { iter::foldl(self, b0, blk) } - pub pure fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { + pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { iter::position(self, f) } - pure fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { + fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { iter::map_to_vec(self, op) } - pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) + fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B] { iter::flat_map_to_vec(self, op) } @@ -2411,98 +2408,98 @@ impl<A> iter::ExtendedIter<A> for ~[A] { // FIXME(#4148): This should be redundant impl<A> iter::ExtendedIter<A> for @[A] { - pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { + pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) { iter::eachi(self, blk) } - pub pure fn all(&self, blk: &fn(&A) -> bool) -> bool { + pub fn all(&self, blk: &fn(&A) -> bool) -> bool { iter::all(self, blk) } - pub pure fn any(&self, blk: &fn(&A) -> bool) -> bool { + pub fn any(&self, blk: &fn(&A) -> bool) -> bool { iter::any(self, blk) } - pub pure fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { + pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { iter::foldl(self, b0, blk) } - pub pure fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { + pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { iter::position(self, f) } - pure fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { + fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] { iter::map_to_vec(self, op) } - pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) + fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B] { iter::flat_map_to_vec(self, op) } } impl<A:Eq> iter::EqIter<A> for &'self [A] { - pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } - pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) } + pub fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + pub fn count(&self, x: &A) -> uint { iter::count(self, x) } } // FIXME(#4148): This should be redundant impl<A:Eq> iter::EqIter<A> for ~[A] { - pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } - pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) } + pub fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + pub fn count(&self, x: &A) -> uint { iter::count(self, x) } } // FIXME(#4148): This should be redundant impl<A:Eq> iter::EqIter<A> for @[A] { - pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } - pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) } + pub fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + pub fn count(&self, x: &A) -> uint { iter::count(self, x) } } impl<A:Copy> iter::CopyableIter<A> for &'self [A] { - pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { + fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { iter::filter_to_vec(self, pred) } - pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) } - pub pure fn find(&self, f: &fn(&A) -> bool) -> Option<A> { + fn to_vec(&self) -> ~[A] { iter::to_vec(self) } + pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> { iter::find(self, f) } } // FIXME(#4148): This should be redundant impl<A:Copy> iter::CopyableIter<A> for ~[A] { - pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { + fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { iter::filter_to_vec(self, pred) } - pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) } - pub pure fn find(&self, f: &fn(&A) -> bool) -> Option<A> { + fn to_vec(&self) -> ~[A] { iter::to_vec(self) } + pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> { iter::find(self, f) } } // FIXME(#4148): This should be redundant impl<A:Copy> iter::CopyableIter<A> for @[A] { - pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { + fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { iter::filter_to_vec(self, pred) } - pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) } - pub pure fn find(&self, f: &fn(&A) -> bool) -> Option<A> { + fn to_vec(&self) -> ~[A] { iter::to_vec(self) } + pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> { iter::find(self, f) } } impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for &'self [A] { - pure fn min(&self) -> A { iter::min(self) } - pure fn max(&self) -> A { iter::max(self) } + fn min(&self) -> A { iter::min(self) } + fn max(&self) -> A { iter::max(self) } } // FIXME(#4148): This should be redundant impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for ~[A] { - pure fn min(&self) -> A { iter::min(self) } - pure fn max(&self) -> A { iter::max(self) } + fn min(&self) -> A { iter::min(self) } + fn max(&self) -> A { iter::max(self) } } // FIXME(#4148): This should be redundant impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for @[A] { - pure fn min(&self) -> A { iter::min(self) } - pure fn max(&self) -> A { iter::max(self) } + fn min(&self) -> A { iter::min(self) } + fn max(&self) -> A { iter::max(self) } } impl<A:Copy> iter::CopyableNonstrictIter<A> for &'self [A] { - pure fn each_val(&const self, f: &fn(A) -> bool) { + fn each_val(&const self, f: &fn(A) -> bool) { let mut i = 0; while i < self.len() { if !f(copy self[i]) { break; } @@ -2513,7 +2510,7 @@ impl<A:Copy> iter::CopyableNonstrictIter<A> for &'self [A] { // FIXME(#4148): This should be redundant impl<A:Copy> iter::CopyableNonstrictIter<A> for ~[A] { - pure fn each_val(&const self, f: &fn(A) -> bool) { + fn each_val(&const self, f: &fn(A) -> bool) { let mut i = 0; while i < uniq_len(self) { if !f(copy self[i]) { break; } @@ -2524,7 +2521,7 @@ impl<A:Copy> iter::CopyableNonstrictIter<A> for ~[A] { // FIXME(#4148): This should be redundant impl<A:Copy> iter::CopyableNonstrictIter<A> for @[A] { - pure fn each_val(&const self, f: &fn(A) -> bool) { + fn each_val(&const self, f: &fn(A) -> bool) { let mut i = 0; while i < self.len() { if !f(copy self[i]) { break; } @@ -2559,11 +2556,11 @@ mod tests { fn square_ref(n: &uint) -> uint { square(*n) } - pure fn is_three(n: &uint) -> bool { *n == 3u } + fn is_three(n: &uint) -> bool { *n == 3u } - pure fn is_odd(n: &uint) -> bool { *n % 2u == 1u } + fn is_odd(n: &uint) -> bool { *n % 2u == 1u } - pure fn is_equal(x: &uint, y:&uint) -> bool { *x == *y } + fn is_equal(x: &uint, y:&uint) -> bool { *x == *y } fn square_if_odd_r(n: &uint) -> Option<uint> { if *n % 2u == 1u { Some(*n * *n) } else { None } diff --git a/src/libfuzzer/ast_match.rs b/src/libfuzzer/ast_match.rs index 81048a69ca9..eedd3bebedf 100644 --- a/src/libfuzzer/ast_match.rs +++ b/src/libfuzzer/ast_match.rs @@ -25,8 +25,8 @@ fn vec_equal<T>(v: ~[T], return true; } -pure fn builtin_equal<T>(&&a: T, &&b: T) -> bool { return a == b; } -pure fn builtin_equal_int(&&a: int, &&b: int) -> bool { return a == b; } +fn builtin_equal<T>(&&a: T, &&b: T) -> bool { return a == b; } +fn builtin_equal_int(&&a: int, &&b: int) -> bool { return a == b; } fn main() { fail_unless!((builtin_equal(5, 5))); diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc index 21015a767b7..71f7072fa7f 100644 --- a/src/libfuzzer/fuzzer.rc +++ b/src/libfuzzer/fuzzer.rc @@ -95,11 +95,11 @@ pub fn common_exprs() -> ~[ast::expr] { ] } -pub pure fn safe_to_steal_expr(e: @ast::expr, tm: test_mode) -> bool { +pub fn safe_to_steal_expr(e: @ast::expr, tm: test_mode) -> bool { safe_to_use_expr(*e, tm) } -pub pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool { +pub fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool { match tm { tm_converge => { match e.node { diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index 1911764da3c..1137b2a2c08 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -20,7 +20,7 @@ use core::util; use core::vec; use core::hashmap::linear::LinearSet; -pure fn not_win32(os: session::os) -> bool { +fn not_win32(os: session::os) -> bool { match os { session::os_win32 => false, _ => true diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 655bfc4446e..b952aff9e1c 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -872,7 +872,7 @@ pub fn get_item_attrs(cdata: cmd, } } -pure fn struct_field_family_to_visibility(family: Family) -> ast::visibility { +fn struct_field_family_to_visibility(family: Family) -> ast::visibility { match family { PublicField => ast::public, PrivateField => ast::private, diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index daa365aade1..d5c4b27e6cb 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -444,7 +444,7 @@ pub impl LoanKind { /// Creates and returns a new root_map impl to_bytes::IterBytes for root_map_key { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f); } } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index f88be89ad00..c319ca89105 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -82,7 +82,7 @@ pub struct LanguageItems { } pub impl LanguageItems { - static pub fn new(&self) -> LanguageItems { + pub fn new() -> LanguageItems { LanguageItems { items: [ None, ..35 ] } @@ -96,7 +96,7 @@ pub impl LanguageItems { } } - static pub fn item_name(&self, index: uint) -> &'static str { + pub fn item_name(index: uint) -> &'static str { match index { 0 => "const", 1 => "copy", diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index c95ec0f3083..2b16ccdd1d2 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -534,7 +534,7 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) { } fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) { - pure fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T, + fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T, min: T, max: T) -> bool { match binop { ast::lt => v <= max, @@ -546,7 +546,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) { } } - pure fn rev_binop(binop: ast::binop) -> ast::binop { + fn rev_binop(binop: ast::binop) -> ast::binop { match binop { ast::lt => ast::gt, ast::le => ast::ge, @@ -556,7 +556,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) { } } - pure fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) { + fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) { match int_ty { ast::ty_i => (int::min_value as i64, int::max_value as i64), ast::ty_char => (u32::min_value as i64, u32::max_value as i64), @@ -567,7 +567,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) { } } - pure fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) { + fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) { match uint_ty { ast::ty_u => (uint::min_value as u64, uint::max_value as u64), ast::ty_u8 => (u8::min_value as u64, u8::max_value as u64), @@ -622,7 +622,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) { } } - pure fn is_comparison(binop: ast::binop) -> bool { + fn is_comparison(binop: ast::binop) -> bool { match binop { ast::eq | ast::lt | ast::le | ast::ne | ast::ge | ast::gt => true, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 7f14b215858..0959e2eb093 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -141,13 +141,13 @@ struct Variable(uint); struct LiveNode(uint); impl cmp::Eq for Variable { - pure fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) } - pure fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) } + fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) } + fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) } } impl cmp::Eq for LiveNode { - pure fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) } - pure fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) } + fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) } + fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) } } enum LiveNodeKind { @@ -158,7 +158,7 @@ enum LiveNodeKind { } impl cmp::Eq for LiveNodeKind { - pure fn eq(&self, other: &LiveNodeKind) -> bool { + fn eq(&self, other: &LiveNodeKind) -> bool { match (*self) { FreeVarNode(e0a) => { match (*other) { @@ -186,7 +186,7 @@ impl cmp::Eq for LiveNodeKind { } } } - pure fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) } + fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) } } fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str { @@ -224,11 +224,11 @@ pub fn check_crate(tcx: ty::ctxt, } impl to_str::ToStr for LiveNode { - pure fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) } + fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) } } impl to_str::ToStr for Variable { - pure fn to_str(&self) -> ~str { fmt!("v(%u)", **self) } + fn to_str(&self) -> ~str { fmt!("v(%u)", **self) } } // ______________________________________________________________________ @@ -254,7 +254,7 @@ impl to_str::ToStr for Variable { // assignment. And so forth. pub impl LiveNode { - pure fn is_valid(&self) -> bool { **self != uint::max_value } + fn is_valid(&self) -> bool { **self != uint::max_value } } fn invalid_node() -> LiveNode { LiveNode(uint::max_value) } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index d85570444d8..e767b0ff812 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -305,13 +305,13 @@ pub struct mem_categorization_ctxt { } impl ToStr for MutabilityCategory { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("%?", *self) } } pub impl MutabilityCategory { - static fn from_mutbl(&self, m: ast::mutability) -> MutabilityCategory { + fn from_mutbl(m: ast::mutability) -> MutabilityCategory { match m { m_imm => McImmutable, m_const => McReadOnly, diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 1d3a0f8b4b6..9517494e492 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -151,7 +151,7 @@ pub enum NamespaceResult { } pub impl NamespaceResult { - pure fn is_unknown(&self) -> bool { + fn is_unknown(&self) -> bool { match *self { UnknownResult => true, _ => false diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index f7226812b96..4d0ad2c19f1 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -41,10 +41,10 @@ enum x86_64_reg_class { } impl cmp::Eq for x86_64_reg_class { - pure fn eq(&self, other: &x86_64_reg_class) -> bool { + fn eq(&self, other: &x86_64_reg_class) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &x86_64_reg_class) -> bool { !(*self).eq(other) } + fn ne(&self, other: &x86_64_reg_class) -> bool { !(*self).eq(other) } } fn is_sse(++c: x86_64_reg_class) -> bool { diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 112d42d8f57..c220bd23e20 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -678,9 +678,9 @@ pub fn block_parent(cx: block) -> block { // Accessors pub impl block_ { - pure fn ccx(@mut self) -> @CrateContext { *self.fcx.ccx } - pure fn tcx(@mut self) -> ty::ctxt { self.fcx.ccx.tcx } - pure fn sess(@mut self) -> Session { self.fcx.ccx.sess } + fn ccx(@mut self) -> @CrateContext { *self.fcx.ccx } + fn tcx(@mut self) -> ty::ctxt { self.fcx.ccx.tcx } + fn sess(@mut self) -> Session { self.fcx.ccx.sess } fn node_id_to_str(@mut self, id: ast::node_id) -> ~str { ast_map::node_id_to_str(self.tcx().items, id, self.sess().intr()) @@ -1290,7 +1290,7 @@ pub struct mono_id_ { pub type mono_id = @mono_id_; impl to_bytes::IterBytes for mono_param_id { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { mono_precise(t, ref mids) => to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), mids, lsb0, f), @@ -1304,7 +1304,7 @@ impl to_bytes::IterBytes for mono_param_id { } impl to_bytes::IterBytes for mono_id_ { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f); } } diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 08ed83a9634..600f637f72b 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -158,14 +158,14 @@ pub impl DatumMode { } impl cmp::Eq for DatumMode { - pure fn eq(&self, other: &DatumMode) -> bool { + fn eq(&self, other: &DatumMode) -> bool { (*self) as uint == (*other as uint) } - pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) } + fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) } } impl to_bytes::IterBytes for DatumMode { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 93b9d775409..7cfa1ff4929 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -175,7 +175,7 @@ pub impl Dest { } impl cmp::Eq for Dest { - pure fn eq(&self, other: &Dest) -> bool { + fn eq(&self, other: &Dest) -> bool { match ((*self), (*other)) { (SaveIn(e0a), SaveIn(e0b)) => e0a == e0b, (Ignore, Ignore) => true, @@ -183,7 +183,7 @@ impl cmp::Eq for Dest { (Ignore, _) => false, } } - pure fn ne(&self, other: &Dest) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Dest) -> bool { !(*self).eq(other) } } fn drop_and_cancel_clean(bcx: block, dat: Datum) -> block { @@ -1695,7 +1695,7 @@ pub enum cast_kind { } impl cmp::Eq for cast_kind { - pure fn eq(&self, other: &cast_kind) -> bool { + fn eq(&self, other: &cast_kind) -> bool { match ((*self), (*other)) { (cast_pointer, cast_pointer) => true, (cast_integral, cast_integral) => true, @@ -1709,7 +1709,7 @@ impl cmp::Eq for cast_kind { (cast_other, _) => false, } } - pure fn ne(&self, other: &cast_kind) -> bool { !(*self).eq(other) } + fn ne(&self, other: &cast_kind) -> bool { !(*self).eq(other) } } pub fn cast_type_kind(t: ty::t) -> cast_kind { diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 2352ada8ced..bf5a699ed82 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -218,8 +218,8 @@ pub fn simplified_glue_type(tcx: ty::ctxt, field: uint, t: ty::t) -> ty::t { return t; } -pub pure fn cast_glue(ccx: @CrateContext, ti: @mut tydesc_info, v: ValueRef) - -> ValueRef { +pub fn cast_glue(ccx: @CrateContext, ti: @mut tydesc_info, v: ValueRef) + -> ValueRef { unsafe { let llfnty = type_of_glue_fn(ccx, ti.ty); llvm::LLVMConstPointerCast(v, T_ptr(llfnty)) diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 205acedb9e1..ce6f6c8efa7 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -282,7 +282,7 @@ pub fn trans_static_method_callee(bcx: block, // When we translate a static fn defined in a trait like: // // trait<T1...Tn> Trait { - // static fn foo<M1...Mn>(...) {...} + // fn foo<M1...Mn>(...) {...} // } // // this winds up being translated as something like: diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index e3b315068f3..cbd2ad86b75 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -121,7 +121,7 @@ pub struct creader_cache_key { type creader_cache = HashMap<creader_cache_key, t>; impl to_bytes::IterBytes for creader_cache_key { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_3(&self.cnum, &self.pos, &self.len, lsb0, f); } } @@ -135,18 +135,18 @@ struct intern_key { // implementation will not recurse through sty and you will get stack // exhaustion. impl cmp::Eq for intern_key { - pure fn eq(&self, other: &intern_key) -> bool { + fn eq(&self, other: &intern_key) -> bool { unsafe { *self.sty == *other.sty && self.o_def_id == other.o_def_id } } - pure fn ne(&self, other: &intern_key) -> bool { + fn ne(&self, other: &intern_key) -> bool { !self.eq(other) } } impl to_bytes::IterBytes for intern_key { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { unsafe { to_bytes::iter_bytes_2(&*self.sty, &self.o_def_id, lsb0, f); } @@ -165,7 +165,7 @@ pub type opt_region_variance = Option<region_variance>; pub enum region_variance { rv_covariant, rv_invariant, rv_contravariant } impl cmp::Eq for region_variance { - pure fn eq(&self, other: ®ion_variance) -> bool { + fn eq(&self, other: ®ion_variance) -> bool { match ((*self), (*other)) { (rv_covariant, rv_covariant) => true, (rv_invariant, rv_invariant) => true, @@ -175,7 +175,7 @@ impl cmp::Eq for region_variance { (rv_contravariant, _) => false } } - pure fn ne(&self, other: ®ion_variance) -> bool { !(*self).eq(other) } + fn ne(&self, other: ®ion_variance) -> bool { !(*self).eq(other) } } #[auto_encode] @@ -334,7 +334,7 @@ struct t_box_ { enum t_opaque {} pub type t = *t_opaque; -pub pure fn get(t: t) -> t_box { +pub fn get(t: t) -> t_box { unsafe { let t2 = cast::reinterpret_cast::<t, t_box>(&t); let t3 = t2; @@ -343,21 +343,21 @@ pub pure fn get(t: t) -> t_box { } } -pub pure fn tbox_has_flag(tb: t_box, flag: tbox_flag) -> bool { +pub fn tbox_has_flag(tb: t_box, flag: tbox_flag) -> bool { (tb.flags & (flag as uint)) != 0u } -pub pure fn type_has_params(t: t) -> bool { +pub fn type_has_params(t: t) -> bool { tbox_has_flag(get(t), has_params) } -pub pure fn type_has_self(t: t) -> bool { tbox_has_flag(get(t), has_self) } -pub pure fn type_needs_infer(t: t) -> bool { +pub fn type_has_self(t: t) -> bool { tbox_has_flag(get(t), has_self) } +pub fn type_needs_infer(t: t) -> bool { tbox_has_flag(get(t), needs_infer) } -pub pure fn type_has_regions(t: t) -> bool { +pub fn type_has_regions(t: t) -> bool { tbox_has_flag(get(t), has_regions) } -pub pure fn type_def_id(t: t) -> Option<ast::def_id> { get(t).o_def_id } -pub pure fn type_id(t: t) -> uint { get(t).id } +pub fn type_def_id(t: t) -> Option<ast::def_id> { get(t).o_def_id } +pub fn type_id(t: t) -> uint { get(t).id } #[deriving(Eq)] pub struct BareFnTy { @@ -388,13 +388,13 @@ pub struct FnSig { } impl to_bytes::IterBytes for BareFnTy { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_3(&self.purity, &self.abi, &self.sig, lsb0, f) } } impl to_bytes::IterBytes for ClosureTy { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_5(&self.purity, &self.sigil, &self.onceness, &self.region, &self.sig, lsb0, f) } @@ -407,7 +407,7 @@ pub struct param_ty { } impl to_bytes::IterBytes for param_ty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.idx, &self.def_id, lsb0, f) } } @@ -616,7 +616,7 @@ pub enum InferTy { } impl to_bytes::IterBytes for InferTy { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f), IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f), @@ -633,7 +633,7 @@ pub enum InferRegion { } impl to_bytes::IterBytes for InferRegion { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { ReVar(ref rv) => to_bytes::iter_bytes_2(&0u8, rv, lsb0, f), ReSkolemized(ref v, _) => to_bytes::iter_bytes_2(&1u8, v, lsb0, f) @@ -642,7 +642,7 @@ impl to_bytes::IterBytes for InferRegion { } impl cmp::Eq for InferRegion { - pure fn eq(&self, other: &InferRegion) -> bool { + fn eq(&self, other: &InferRegion) -> bool { match ((*self), *other) { (ReVar(rva), ReVar(rvb)) => { rva == rvb @@ -653,13 +653,13 @@ impl cmp::Eq for InferRegion { _ => false } } - pure fn ne(&self, other: &InferRegion) -> bool { + fn ne(&self, other: &InferRegion) -> bool { !((*self) == (*other)) } } impl to_bytes::IterBytes for param_bound { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { bound_copy => 0u8.iter_bytes(lsb0, f), bound_durable => 1u8.iter_bytes(lsb0, f), @@ -672,50 +672,50 @@ impl to_bytes::IterBytes for param_bound { } pub trait Vid { - pure fn to_uint(&self) -> uint; + fn to_uint(&self) -> uint; } impl Vid for TyVid { - pure fn to_uint(&self) -> uint { **self } + fn to_uint(&self) -> uint { **self } } impl ToStr for TyVid { - pure fn to_str(&self) -> ~str { fmt!("<V%u>", self.to_uint()) } + fn to_str(&self) -> ~str { fmt!("<V%u>", self.to_uint()) } } impl Vid for IntVid { - pure fn to_uint(&self) -> uint { **self } + fn to_uint(&self) -> uint { **self } } impl ToStr for IntVid { - pure fn to_str(&self) -> ~str { fmt!("<VI%u>", self.to_uint()) } + fn to_str(&self) -> ~str { fmt!("<VI%u>", self.to_uint()) } } impl Vid for FloatVid { - pure fn to_uint(&self) -> uint { **self } + fn to_uint(&self) -> uint { **self } } impl ToStr for FloatVid { - pure fn to_str(&self) -> ~str { fmt!("<VF%u>", self.to_uint()) } + fn to_str(&self) -> ~str { fmt!("<VF%u>", self.to_uint()) } } impl Vid for RegionVid { - pure fn to_uint(&self) -> uint { self.id } + fn to_uint(&self) -> uint { self.id } } impl ToStr for RegionVid { - pure fn to_str(&self) -> ~str { fmt!("%?", self.id) } + fn to_str(&self) -> ~str { fmt!("%?", self.id) } } impl ToStr for FnSig { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { // grr, without tcx not much we can do. return ~"(...)"; } } impl ToStr for InferTy { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { TyVar(ref v) => v.to_str(), IntVar(ref v) => v.to_str(), @@ -725,7 +725,7 @@ impl ToStr for InferTy { } impl ToStr for IntVarValue { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { IntType(ref v) => v.to_str(), UintType(ref v) => v.to_str(), @@ -734,25 +734,25 @@ impl ToStr for IntVarValue { } impl to_bytes::IterBytes for TyVid { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } impl to_bytes::IterBytes for IntVid { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } impl to_bytes::IterBytes for FloatVid { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } impl to_bytes::IterBytes for RegionVid { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } @@ -1112,7 +1112,7 @@ pub fn mk_with_id(cx: ctxt, base: t, def_id: ast::def_id) -> t { } // Converts s to its machine type equivalent -pub pure fn mach_sty(cfg: @session::config, t: t) -> sty { +pub fn mach_sty(cfg: @session::config, t: t) -> sty { match get(t).sty { ty_int(ast::ty_i) => ty_int(cfg.int_type), ty_uint(ast::ty_u) => ty_uint(cfg.uint_type), @@ -1532,14 +1532,14 @@ pub fn get_element_type(ty: t, i: uint) -> t { } } -pub pure fn type_is_box(ty: t) -> bool { +pub fn type_is_box(ty: t) -> bool { match get(ty).sty { ty_box(_) => return true, _ => return false } } -pub pure fn type_is_boxed(ty: t) -> bool { +pub fn type_is_boxed(ty: t) -> bool { match get(ty).sty { ty_box(_) | ty_opaque_box | ty_evec(_, vstore_box) | ty_estr(vstore_box) => true, @@ -1547,35 +1547,35 @@ pub pure fn type_is_boxed(ty: t) -> bool { } } -pub pure fn type_is_region_ptr(ty: t) -> bool { +pub fn type_is_region_ptr(ty: t) -> bool { match get(ty).sty { ty_rptr(_, _) => true, _ => false } } -pub pure fn type_is_slice(ty: t) -> bool { +pub fn type_is_slice(ty: t) -> bool { match get(ty).sty { ty_evec(_, vstore_slice(_)) | ty_estr(vstore_slice(_)) => true, _ => return false } } -pub pure fn type_is_unique_box(ty: t) -> bool { +pub fn type_is_unique_box(ty: t) -> bool { match get(ty).sty { ty_uniq(_) => return true, _ => return false } } -pub pure fn type_is_unsafe_ptr(ty: t) -> bool { +pub fn type_is_unsafe_ptr(ty: t) -> bool { match get(ty).sty { ty_ptr(_) => return true, _ => return false } } -pub pure fn type_is_vec(ty: t) -> bool { +pub fn type_is_vec(ty: t) -> bool { return match get(ty).sty { ty_evec(_, _) | ty_unboxed_vec(_) => true, ty_estr(_) => true, @@ -1583,7 +1583,7 @@ pub pure fn type_is_vec(ty: t) -> bool { }; } -pub pure fn type_is_unique(ty: t) -> bool { +pub fn type_is_unique(ty: t) -> bool { match get(ty).sty { ty_uniq(_) | ty_evec(_, vstore_uniq) | @@ -1598,7 +1598,7 @@ pub pure fn type_is_unique(ty: t) -> bool { (A ty_ptr is scalar because it represents a non-managed pointer, so its contents are abstract to rustc.) */ -pub pure fn type_is_scalar(ty: t) -> bool { +pub fn type_is_scalar(ty: t) -> bool { match get(ty).sty { ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) | ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | ty_type | @@ -1720,7 +1720,7 @@ pub impl TypeContents { !self.intersects(TypeContents::noncopyable(cx)) } - static fn noncopyable(_cx: ctxt) -> TypeContents { + fn noncopyable(_cx: ctxt) -> TypeContents { TC_DTOR + TC_BORROWED_MUT + TC_ONCE_CLOSURE + TC_OWNED_CLOSURE + TC_EMPTY_ENUM } @@ -1729,7 +1729,7 @@ pub impl TypeContents { !self.intersects(TypeContents::nondurable(cx)) } - static fn nondurable(_cx: ctxt) -> TypeContents { + fn nondurable(_cx: ctxt) -> TypeContents { TC_BORROWED_POINTER } @@ -1737,7 +1737,7 @@ pub impl TypeContents { !self.intersects(TypeContents::nonowned(cx)) } - static fn nonowned(_cx: ctxt) -> TypeContents { + fn nonowned(_cx: ctxt) -> TypeContents { TC_MANAGED + TC_BORROWED_POINTER } @@ -1749,7 +1749,7 @@ pub impl TypeContents { !self.intersects(TypeContents::nonconst(cx)) } - static fn nonconst(_cx: ctxt) -> TypeContents { + fn nonconst(_cx: ctxt) -> TypeContents { TC_MUTABLE } @@ -1757,7 +1757,7 @@ pub impl TypeContents { self.intersects(TypeContents::nonimplicitly_copyable(cx)) } - static fn nonimplicitly_copyable(cx: ctxt) -> TypeContents { + fn nonimplicitly_copyable(cx: ctxt) -> TypeContents { let base = TypeContents::noncopyable(cx) + TC_OWNED_POINTER; if cx.vecs_implicitly_copyable {base} else {base + TC_OWNED_VEC} } @@ -1766,7 +1766,7 @@ pub impl TypeContents { !self.intersects(TypeContents::nondefault_mode(cx)) } - static fn nondefault_mode(cx: ctxt) -> TypeContents { + fn nondefault_mode(cx: ctxt) -> TypeContents { let tc = TypeContents::nonimplicitly_copyable(cx); tc + TC_BIG + TC_OWNED_VEC // disregard cx.vecs_implicitly_copyable } @@ -1776,26 +1776,26 @@ pub impl TypeContents { self.intersects(tc) } - static fn owned(&self, _cx: ctxt) -> TypeContents { + fn owned(_cx: ctxt) -> TypeContents { //! Any kind of owned contents. TC_OWNED_CLOSURE + TC_OWNED_POINTER + TC_OWNED_VEC } } impl ops::Add<TypeContents,TypeContents> for TypeContents { - pure fn add(&self, other: &TypeContents) -> TypeContents { + fn add(&self, other: &TypeContents) -> TypeContents { TypeContents {bits: self.bits | other.bits} } } impl ops::Sub<TypeContents,TypeContents> for TypeContents { - pure fn sub(&self, other: &TypeContents) -> TypeContents { + fn sub(&self, other: &TypeContents) -> TypeContents { TypeContents {bits: self.bits & !other.bits} } } impl ToStr for TypeContents { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("TypeContents(%s)", u32::to_str_radix(self.bits, 2)) } } @@ -2534,7 +2534,7 @@ pub fn index_sty(cx: ctxt, sty: &sty) -> Option<mt> { } impl to_bytes::IterBytes for bound_region { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { ty::br_self => 0u8.iter_bytes(lsb0, f), @@ -2554,7 +2554,7 @@ impl to_bytes::IterBytes for bound_region { } impl to_bytes::IterBytes for Region { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { re_bound(ref br) => to_bytes::iter_bytes_2(&0u8, br, lsb0, f), @@ -2574,7 +2574,7 @@ impl to_bytes::IterBytes for Region { } impl to_bytes::IterBytes for vstore { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { vstore_fixed(ref u) => to_bytes::iter_bytes_2(&0u8, u, lsb0, f), @@ -2589,7 +2589,7 @@ impl to_bytes::IterBytes for vstore { } impl to_bytes::IterBytes for TraitStore { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { BareTraitStore => 0u8.iter_bytes(lsb0, f), UniqTraitStore => 1u8.iter_bytes(lsb0, f), @@ -2600,7 +2600,7 @@ impl to_bytes::IterBytes for TraitStore { } impl to_bytes::IterBytes for substs { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_3(&self.self_r, &self.self_ty, &self.tps, lsb0, f) @@ -2608,28 +2608,28 @@ impl to_bytes::IterBytes for substs { } impl to_bytes::IterBytes for mt { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.ty, &self.mutbl, lsb0, f) } } impl to_bytes::IterBytes for field { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.ident, &self.mt, lsb0, f) } } impl to_bytes::IterBytes for arg { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.mode, &self.ty, lsb0, f) } } impl to_bytes::IterBytes for FnSig { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.inputs, &self.output, lsb0, f); @@ -2637,7 +2637,7 @@ impl to_bytes::IterBytes for FnSig { } impl to_bytes::IterBytes for sty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { ty_nil => 0u8.iter_bytes(lsb0, f), ty_bool => 1u8.iter_bytes(lsb0, f), @@ -2768,7 +2768,7 @@ pub fn ty_fn_purity(fty: t) -> ast::purity { } } -pub pure fn ty_fn_ret(fty: t) -> t { +pub fn ty_fn_ret(fty: t) -> t { match get(fty).sty { ty_bare_fn(ref f) => f.sig.output, ty_closure(ref f) => f.sig.output, @@ -2786,7 +2786,7 @@ pub fn is_fn_ty(fty: t) -> bool { } } -pub pure fn ty_vstore(ty: t) -> vstore { +pub fn ty_vstore(ty: t) -> vstore { match get(ty).sty { ty_evec(_, vstore) => vstore, ty_estr(vstore) => vstore, @@ -3716,13 +3716,13 @@ pub enum DtorKind { } pub impl DtorKind { - pure fn is_not_present(&const self) -> bool { + fn is_not_present(&const self) -> bool { match *self { NoDtor => true, _ => false } } - pure fn is_present(&const self) -> bool { + fn is_present(&const self) -> bool { !self.is_not_present() } } @@ -4000,7 +4000,7 @@ pub fn lookup_struct_field(cx: ctxt, } } -pure fn is_public(f: field_ty) -> bool { +fn is_public(f: field_ty) -> bool { // XXX: This is wrong. match f.vis { public | inherited => true, @@ -4260,7 +4260,7 @@ pub fn eval_repeat_count(tcx: ctxt, count_expr: @ast::expr) -> uint { } // Determine what purity to check a nested function under -pub pure fn determine_inherited_purity(parent_purity: ast::purity, +pub fn determine_inherited_purity(parent_purity: ast::purity, child_purity: ast::purity, child_sigil: ast::Sigil) -> ast::purity { @@ -4364,14 +4364,14 @@ pub fn get_impl_id(tcx: ctxt, trait_id: def_id, self_ty: t) -> def_id { } impl cmp::Eq for mt { - pure fn eq(&self, other: &mt) -> bool { + fn eq(&self, other: &mt) -> bool { (*self).ty == (*other).ty && (*self).mutbl == (*other).mutbl } - pure fn ne(&self, other: &mt) -> bool { !(*self).eq(other) } + fn ne(&self, other: &mt) -> bool { !(*self).eq(other) } } impl cmp::Eq for Region { - pure fn eq(&self, other: &Region) -> bool { + fn eq(&self, other: &Region) -> bool { match (*self) { re_bound(e0a) => { match (*other) { @@ -4405,11 +4405,11 @@ impl cmp::Eq for Region { } } } - pure fn ne(&self, other: &Region) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Region) -> bool { !(*self).eq(other) } } impl cmp::Eq for bound_region { - pure fn eq(&self, other: &bound_region) -> bool { + fn eq(&self, other: &bound_region) -> bool { match (*self) { br_self => { match (*other) { @@ -4443,11 +4443,11 @@ impl cmp::Eq for bound_region { } } } - pure fn ne(&self, other: &bound_region) -> bool { !(*self).eq(other) } + fn ne(&self, other: &bound_region) -> bool { !(*self).eq(other) } } impl cmp::Eq for param_bound { - pure fn eq(&self, other: ¶m_bound) -> bool { + fn eq(&self, other: ¶m_bound) -> bool { match (*self) { bound_copy => { match (*other) { @@ -4481,7 +4481,7 @@ impl cmp::Eq for param_bound { } } } - pure fn ne(&self, other: ¶m_bound) -> bool { !self.eq(other) } + fn ne(&self, other: ¶m_bound) -> bool { !self.eq(other) } } // Local Variables: diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 1ce59064765..a83d6f1755e 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -51,27 +51,23 @@ use util::common::indenter; use std::list; pub trait LatticeValue { - static fn sub(&self, cf: &CombineFields, a: &Self, b: &Self) -> ures; - static fn lub(&self, cf: &CombineFields, a: &Self, b: &Self) - -> cres<Self>; - static fn glb(&self, cf: &CombineFields, a: &Self, b: &Self) - -> cres<Self>; + fn sub(cf: &CombineFields, a: &Self, b: &Self) -> ures; + fn lub(cf: &CombineFields, a: &Self, b: &Self) -> cres<Self>; + fn glb(cf: &CombineFields, a: &Self, b: &Self) -> cres<Self>; } pub type LatticeOp<T> = &'self fn(cf: &CombineFields, a: &T, b: &T) -> cres<T>; impl LatticeValue for ty::t { - static fn sub(&self, cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures { + fn sub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures { Sub(*cf).tys(*a, *b).to_ures() } - static fn lub(&self, cf: &CombineFields, a: &ty::t, b: &ty::t) - -> cres<ty::t> { + fn lub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> cres<ty::t> { Lub(*cf).tys(*a, *b) } - static fn glb(&self, cf: &CombineFields, a: &ty::t, b: &ty::t) - -> cres<ty::t> { + fn glb(cf: &CombineFields, a: &ty::t, b: &ty::t) -> cres<ty::t> { Glb(*cf).tys(*a, *b) } } diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index df309bcec2f..f0b5ce9ff60 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -563,7 +563,7 @@ enum Constraint { } impl cmp::Eq for Constraint { - pure fn eq(&self, other: &Constraint) -> bool { + fn eq(&self, other: &Constraint) -> bool { match ((*self), (*other)) { (ConstrainVarSubVar(v0a, v1a), ConstrainVarSubVar(v0b, v1b)) => { v0a == v0b && v1a == v1b @@ -579,11 +579,11 @@ impl cmp::Eq for Constraint { (ConstrainVarSubReg(*), _) => false } } - pure fn ne(&self, other: &Constraint) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Constraint) -> bool { !(*self).eq(other) } } impl to_bytes::IterBytes for Constraint { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { ConstrainVarSubVar(ref v0, ref v1) => to_bytes::iter_bytes_3(&0u8, v0, v1, lsb0, f), @@ -603,14 +603,14 @@ struct TwoRegions { } impl cmp::Eq for TwoRegions { - pure fn eq(&self, other: &TwoRegions) -> bool { + fn eq(&self, other: &TwoRegions) -> bool { (*self).a == (*other).a && (*self).b == (*other).b } - pure fn ne(&self, other: &TwoRegions) -> bool { !(*self).eq(other) } + fn ne(&self, other: &TwoRegions) -> bool { !(*self).eq(other) } } impl to_bytes::IterBytes for TwoRegions { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.a, &self.b, lsb0, f) } } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index fe77b62de43..7711794d91d 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -35,8 +35,8 @@ pub struct Node<V, T> { } pub trait UnifyVid<T> { - static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) - -> &'v mut ValsAndBindings<Self, T>; + fn appropriate_vals_and_bindings(infcx: &'v mut InferCtxt) + -> &'v mut ValsAndBindings<Self, T>; } pub impl InferCtxt { @@ -144,7 +144,7 @@ pub impl InferCtxt { // doesn't have a subtyping relationship we need to worry about. pub trait SimplyUnifiable { - static fn to_type_err(&self, expected_found<Self>) -> ty::type_err; + fn to_type_err(expected_found<Self>) -> ty::type_err; } pub fn mk_err<T:SimplyUnifiable>(+a_is_expected: bool, @@ -235,36 +235,34 @@ pub impl InferCtxt { // ______________________________________________________________________ impl UnifyVid<Bounds<ty::t>> for ty::TyVid { - static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + fn appropriate_vals_and_bindings(infcx: &'v mut InferCtxt) -> &'v mut ValsAndBindings<ty::TyVid, Bounds<ty::t>> { return &mut infcx.ty_var_bindings; } } impl UnifyVid<Option<IntVarValue>> for ty::IntVid { - static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + fn appropriate_vals_and_bindings(infcx: &'v mut InferCtxt) -> &'v mut ValsAndBindings<ty::IntVid, Option<IntVarValue>> { return &mut infcx.int_var_bindings; } } impl SimplyUnifiable for IntVarValue { - static fn to_type_err(&self, err: expected_found<IntVarValue>) - -> ty::type_err { + fn to_type_err(err: expected_found<IntVarValue>) -> ty::type_err { return ty::terr_int_mismatch(err); } } impl UnifyVid<Option<ast::float_ty>> for ty::FloatVid { - static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + fn appropriate_vals_and_bindings(infcx: &'v mut InferCtxt) -> &'v mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> { return &mut infcx.float_var_bindings; } } impl SimplyUnifiable for ast::float_ty { - static fn to_type_err(&self, err: expected_found<ast::float_ty>) - -> ty::type_err { + fn to_type_err(err: expected_found<ast::float_ty>) -> ty::type_err { return ty::terr_float_mismatch(err); } } diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 956d6ba2c5b..84f2f5191f3 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -29,10 +29,10 @@ pub enum OutputFormat { } impl cmp::Eq for OutputFormat { - pure fn eq(&self, other: &OutputFormat) -> bool { + fn eq(&self, other: &OutputFormat) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &OutputFormat) -> bool { !(*self).eq(other) } + fn ne(&self, other: &OutputFormat) -> bool { !(*self).eq(other) } } /// How to organize the output @@ -44,10 +44,10 @@ pub enum OutputStyle { } impl cmp::Eq for OutputStyle { - pure fn eq(&self, other: &OutputStyle) -> bool { + fn eq(&self, other: &OutputStyle) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &OutputStyle) -> bool { !(*self).eq(other) } + fn ne(&self, other: &OutputStyle) -> bool { !(*self).eq(other) } } /// The configuration for a rustdoc session diff --git a/src/librustdoc/doc.rs b/src/librustdoc/doc.rs index 43172fd22c0..4ed510c353b 100644 --- a/src/librustdoc/doc.rs +++ b/src/librustdoc/doc.rs @@ -358,11 +358,11 @@ impl PageUtils for ~[Page] { } pub trait Item { - pure fn item(&self) -> ItemDoc; + fn item(&self) -> ItemDoc; } impl Item for ItemTag { - pure fn item(&self) -> ItemDoc { + fn item(&self) -> ItemDoc { match self { &doc::ModTag(ref doc) => copy doc.item, &doc::NmodTag(ref doc) => copy doc.item, @@ -378,64 +378,64 @@ impl Item for ItemTag { } impl Item for SimpleItemDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for ModDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for NmodDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for EnumDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for TraitDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for ImplDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } impl Item for StructDoc { - pure fn item(&self) -> ItemDoc { copy self.item } + fn item(&self) -> ItemDoc { copy self.item } } pub trait ItemUtils { - pure fn id(&self) -> AstId; - pure fn name(&self) -> ~str; - pure fn path(&self) -> ~[~str]; - pure fn brief(&self) -> Option<~str>; - pure fn desc(&self) -> Option<~str>; - pure fn sections(&self) -> ~[Section]; + fn id(&self) -> AstId; + fn name(&self) -> ~str; + fn path(&self) -> ~[~str]; + fn brief(&self) -> Option<~str>; + fn desc(&self) -> Option<~str>; + fn sections(&self) -> ~[Section]; } impl<A:Item> ItemUtils for A { - pure fn id(&self) -> AstId { + fn id(&self) -> AstId { self.item().id } - pure fn name(&self) -> ~str { + fn name(&self) -> ~str { copy self.item().name } - pure fn path(&self) -> ~[~str] { + fn path(&self) -> ~[~str] { copy self.item().path } - pure fn brief(&self) -> Option<~str> { + fn brief(&self) -> Option<~str> { copy self.item().brief } - pure fn desc(&self) -> Option<~str> { + fn desc(&self) -> Option<~str> { copy self.item().desc } - pure fn sections(&self) -> ~[Section] { + fn sections(&self) -> ~[Section] { copy self.item().sections } } diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 6cb840fb937..227eb25aa81 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -45,8 +45,8 @@ fn run( writer_factory: WriterFactory ) -> doc::Doc { - pure fn mods_last(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { - pure fn is_mod(item: &doc::ItemTag) -> bool { + fn mods_last(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { + fn is_mod(item: &doc::ItemTag) -> bool { match *item { doc::ModTag(_) => true, _ => false diff --git a/src/librustdoc/sort_item_name_pass.rs b/src/librustdoc/sort_item_name_pass.rs index 0e6d83fa45f..b3fb874cdb2 100644 --- a/src/librustdoc/sort_item_name_pass.rs +++ b/src/librustdoc/sort_item_name_pass.rs @@ -16,7 +16,7 @@ use pass::Pass; use sort_pass; pub fn mk_pass() -> Pass { - pure fn by_item_name(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { + fn by_item_name(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { (*item1).name() <= (*item2).name() } sort_pass::mk_pass(~"sort_item_name", by_item_name) diff --git a/src/librustdoc/sort_item_type_pass.rs b/src/librustdoc/sort_item_type_pass.rs index cddd5068816..96727f6386d 100644 --- a/src/librustdoc/sort_item_type_pass.rs +++ b/src/librustdoc/sort_item_type_pass.rs @@ -15,8 +15,8 @@ use pass::Pass; use sort_pass; pub fn mk_pass() -> Pass { - pure fn by_score(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { - pure fn score(item: &doc::ItemTag) -> int { + fn by_score(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { + fn score(item: &doc::ItemTag) -> int { match *item { doc::ConstTag(_) => 0, doc::TyTag(_) => 1, diff --git a/src/librustdoc/sort_pass.rs b/src/librustdoc/sort_pass.rs index 4f4c5ea65d4..e66eb3c0fae 100644 --- a/src/librustdoc/sort_pass.rs +++ b/src/librustdoc/sort_pass.rs @@ -21,7 +21,7 @@ use util::NominalOp; use std::sort; -pub type ItemLtEqOp = @pure fn(v1: &doc::ItemTag, v2: &doc::ItemTag) -> bool; +pub type ItemLtEqOp = @fn(v1: &doc::ItemTag, v2: &doc::ItemTag) -> bool; type ItemLtEq = NominalOp<ItemLtEqOp>; @@ -59,7 +59,7 @@ fn fold_mod( #[test] fn test() { - pure fn name_lteq(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { + fn name_lteq(item1: &doc::ItemTag, item2: &doc::ItemTag) -> bool { (*item1).name() <= (*item2).name() } @@ -76,7 +76,7 @@ fn test() { #[test] fn should_be_stable() { - pure fn always_eq(_item1: &doc::ItemTag, _item2: &doc::ItemTag) -> bool { + fn always_eq(_item1: &doc::ItemTag, _item2: &doc::ItemTag) -> bool { true } diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs index 911abf95ff8..d76438dd89b 100644 --- a/src/libstd/arena.rs +++ b/src/libstd/arena.rs @@ -123,7 +123,7 @@ pub fn Arena() -> Arena { } #[inline(always)] -pure fn round_up_to(base: uint, align: uint) -> uint { +fn round_up_to(base: uint, align: uint) -> uint { (base + (align - 1)) & !(align - 1) } diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 56ce54be44e..ff026324404 100644 --- a/src/libstd/base64.rs +++ b/src/libstd/base64.rs @@ -13,11 +13,11 @@ use core::str; use core::vec; pub trait ToBase64 { - pure fn to_base64(&self) -> ~str; + fn to_base64(&self) -> ~str; } impl ToBase64 for &'self [u8] { - pure fn to_base64(&self) -> ~str { + fn to_base64(&self) -> ~str { let chars = str::chars( ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ); @@ -70,17 +70,17 @@ impl ToBase64 for &'self [u8] { } impl ToBase64 for &'self str { - pure fn to_base64(&self) -> ~str { + fn to_base64(&self) -> ~str { str::to_bytes(*self).to_base64() } } pub trait FromBase64 { - pure fn from_base64(&self) -> ~[u8]; + fn from_base64(&self) -> ~[u8]; } impl FromBase64 for ~[u8] { - pure fn from_base64(&self) -> ~[u8] { + fn from_base64(&self) -> ~[u8] { if self.len() % 4u != 0u { fail!(~"invalid base64 length"); } let len = self.len(); @@ -142,7 +142,7 @@ impl FromBase64 for ~[u8] { } impl FromBase64 for ~str { - pure fn from_base64(&self) -> ~[u8] { + fn from_base64(&self) -> ~[u8] { str::to_bytes(*self).from_base64() } } diff --git a/src/libstd/bigint.rs b/src/libstd/bigint.rs index 01153a4b78e..309925e7cf9 100644 --- a/src/libstd/bigint.rs +++ b/src/libstd/bigint.rs @@ -53,16 +53,16 @@ pub mod BigDigit { priv const hi_mask: uint = (-1 as uint) << bits; priv const lo_mask: uint = (-1 as uint) >> bits; - priv pure fn get_hi(n: uint) -> BigDigit { (n >> bits) as BigDigit } - priv pure fn get_lo(n: uint) -> BigDigit { (n & lo_mask) as BigDigit } + priv fn get_hi(n: uint) -> BigDigit { (n >> bits) as BigDigit } + priv fn get_lo(n: uint) -> BigDigit { (n & lo_mask) as BigDigit } /// Split one machine sized unsigned integer into two BigDigits. - pub pure fn from_uint(n: uint) -> (BigDigit, BigDigit) { + pub fn from_uint(n: uint) -> (BigDigit, BigDigit) { (get_hi(n), get_lo(n)) } /// Join two BigDigits into one machine sized unsigned integer - pub pure fn to_uint(hi: BigDigit, lo: BigDigit) -> uint { + pub fn to_uint(hi: BigDigit, lo: BigDigit) -> uint { (lo as uint) | ((hi as uint) << bits) } } @@ -78,29 +78,29 @@ pub struct BigUint { } impl Eq for BigUint { - pure fn eq(&self, other: &BigUint) -> bool { self.cmp(other) == 0 } - pure fn ne(&self, other: &BigUint) -> bool { self.cmp(other) != 0 } + fn eq(&self, other: &BigUint) -> bool { self.cmp(other) == 0 } + fn ne(&self, other: &BigUint) -> bool { self.cmp(other) != 0 } } impl Ord for BigUint { - pure fn lt(&self, other: &BigUint) -> bool { self.cmp(other) < 0 } - pure fn le(&self, other: &BigUint) -> bool { self.cmp(other) <= 0 } - pure fn ge(&self, other: &BigUint) -> bool { self.cmp(other) >= 0 } - pure fn gt(&self, other: &BigUint) -> bool { self.cmp(other) > 0 } + fn lt(&self, other: &BigUint) -> bool { self.cmp(other) < 0 } + fn le(&self, other: &BigUint) -> bool { self.cmp(other) <= 0 } + fn ge(&self, other: &BigUint) -> bool { self.cmp(other) >= 0 } + fn gt(&self, other: &BigUint) -> bool { self.cmp(other) > 0 } } impl ToStr for BigUint { - pure fn to_str(&self) -> ~str { self.to_str_radix(10) } + fn to_str(&self) -> ~str { self.to_str_radix(10) } } impl from_str::FromStr for BigUint { - static pure fn from_str(s: &str) -> Option<BigUint> { + fn from_str(s: &str) -> Option<BigUint> { BigUint::from_str_radix(s, 10) } } impl Shl<uint, BigUint> for BigUint { - pure fn shl(&self, rhs: &uint) -> BigUint { + fn shl(&self, rhs: &uint) -> BigUint { let n_unit = *rhs / BigDigit::bits; let n_bits = *rhs % BigDigit::bits; return self.shl_unit(n_unit).shl_bits(n_bits); @@ -108,7 +108,7 @@ impl Shl<uint, BigUint> for BigUint { } impl Shr<uint, BigUint> for BigUint { - pure fn shr(&self, rhs: &uint) -> BigUint { + fn shr(&self, rhs: &uint) -> BigUint { let n_unit = *rhs / BigDigit::bits; let n_bits = *rhs % BigDigit::bits; return self.shr_unit(n_unit).shr_bits(n_bits); @@ -116,15 +116,15 @@ impl Shr<uint, BigUint> for BigUint { } impl Zero for BigUint { - static pure fn zero() -> BigUint { BigUint::new(~[]) } + fn zero() -> BigUint { BigUint::new(~[]) } } impl One for BigUint { - static pub pure fn one() -> BigUint { BigUint::new(~[1]) } + pub fn one() -> BigUint { BigUint::new(~[1]) } } impl Add<BigUint, BigUint> for BigUint { - pure fn add(&self, other: &BigUint) -> BigUint { + fn add(&self, other: &BigUint) -> BigUint { let new_len = uint::max(self.data.len(), other.data.len()); let mut carry = 0; @@ -143,7 +143,7 @@ impl Add<BigUint, BigUint> for BigUint { } impl Sub<BigUint, BigUint> for BigUint { - pure fn sub(&self, other: &BigUint) -> BigUint { + fn sub(&self, other: &BigUint) -> BigUint { let new_len = uint::max(self.data.len(), other.data.len()); let mut borrow = 0; @@ -168,7 +168,7 @@ impl Sub<BigUint, BigUint> for BigUint { } impl Mul<BigUint, BigUint> for BigUint { - pure fn mul(&self, other: &BigUint) -> BigUint { + fn mul(&self, other: &BigUint) -> BigUint { if self.is_zero() || other.is_zero() { return Zero::zero(); } let s_len = self.data.len(), o_len = other.data.len(); @@ -200,7 +200,7 @@ impl Mul<BigUint, BigUint> for BigUint { return ll + mm.shl_unit(half_len) + hh.shl_unit(half_len * 2); - pure fn mul_digit(a: &BigUint, n: BigDigit) -> BigUint { + fn mul_digit(a: &BigUint, n: BigDigit) -> BigUint { if n == 0 { return Zero::zero(); } if n == 1 { return copy *a; } @@ -216,14 +216,14 @@ impl Mul<BigUint, BigUint> for BigUint { return BigUint::new(prod + [carry]); } - pure fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) { + fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) { let mid = uint::min(a.data.len(), n); return (BigUint::from_slice(vec::slice(a.data, mid, a.data.len())), BigUint::from_slice(vec::slice(a.data, 0, mid))); } - pure fn sub_sign(a: BigUint, b: BigUint) -> (int, BigUint) { + fn sub_sign(a: BigUint, b: BigUint) -> (int, BigUint) { match a.cmp(&b) { s if s < 0 => (s, b - a), s if s > 0 => (s, a - b), @@ -234,36 +234,36 @@ impl Mul<BigUint, BigUint> for BigUint { } impl Div<BigUint, BigUint> for BigUint { - pure fn div(&self, other: &BigUint) -> BigUint { + fn div(&self, other: &BigUint) -> BigUint { let (d, _) = self.divmod(other); return d; } } impl Modulo<BigUint, BigUint> for BigUint { - pure fn modulo(&self, other: &BigUint) -> BigUint { + fn modulo(&self, other: &BigUint) -> BigUint { let (_, m) = self.divmod(other); return m; } } impl Neg<BigUint> for BigUint { - pure fn neg(&self) -> BigUint { fail!() } + fn neg(&self) -> BigUint { fail!() } } impl IntConvertible for BigUint { - pure fn to_int(&self) -> int { + fn to_int(&self) -> int { uint::min(self.to_uint(), int::max_value as uint) as int } - static pure fn from_int(n: int) -> BigUint { + fn from_int(n: int) -> BigUint { if (n < 0) { Zero::zero() } else { BigUint::from_uint(n as uint) } } } pub impl BigUint { /// Creates and initializes an BigUint. - static pub pure fn new(v: ~[BigDigit]) -> BigUint { + pub fn new(v: ~[BigDigit]) -> BigUint { // omit trailing zeros let new_len = v.rposition(|n| *n != 0).map_default(0, |p| *p + 1); @@ -274,7 +274,7 @@ pub impl BigUint { } /// Creates and initializes an BigUint. - static pub pure fn from_uint(n: uint) -> BigUint { + pub fn from_uint(n: uint) -> BigUint { match BigDigit::from_uint(n) { (0, 0) => Zero::zero(), (0, n0) => BigUint::new(~[n0]), @@ -283,18 +283,18 @@ pub impl BigUint { } /// Creates and initializes an BigUint. - static pub pure fn from_slice(slice: &[BigDigit]) -> BigUint { + pub fn from_slice(slice: &[BigDigit]) -> BigUint { return BigUint::new(vec::from_slice(slice)); } /// Creates and initializes an BigUint. - static pub pure fn from_str_radix(s: &str, radix: uint) + pub fn from_str_radix(s: &str, radix: uint) -> Option<BigUint> { BigUint::parse_bytes(str::to_bytes(s), radix) } /// Creates and initializes an BigUint. - static pub pure fn parse_bytes(buf: &[u8], radix: uint) + pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<BigUint> { let (base, unit_len) = get_radix_base(radix); let base_num: BigUint = BigUint::from_uint(base); @@ -316,10 +316,10 @@ pub impl BigUint { } } - pure fn abs(&self) -> BigUint { copy *self } + fn abs(&self) -> BigUint { copy *self } /// Compare two BigUint value. - pure fn cmp(&self, other: &BigUint) -> int { + fn cmp(&self, other: &BigUint) -> int { let s_len = self.data.len(), o_len = other.data.len(); if s_len < o_len { return -1; } if s_len > o_len { return 1; } @@ -334,7 +334,7 @@ pub impl BigUint { return 0; } - pure fn divmod(&self, other: &BigUint) -> (BigUint, BigUint) { + fn divmod(&self, other: &BigUint) -> (BigUint, BigUint) { if other.is_zero() { fail!() } if self.is_zero() { return (Zero::zero(), Zero::zero()); } if *other == One::one() { return (copy *self, Zero::zero()); } @@ -355,7 +355,7 @@ pub impl BigUint { let (d, m) = divmod_inner(self << shift, other << shift); return (d, m >> shift); - pure fn divmod_inner(a: BigUint, b: BigUint) -> (BigUint, BigUint) { + fn divmod_inner(a: BigUint, b: BigUint) -> (BigUint, BigUint) { let mut r = a; let mut d = Zero::zero::<BigUint>(); let mut n = 1; @@ -377,7 +377,7 @@ pub impl BigUint { return (d, r); } - pure fn div_estimate(a: &BigUint, b: &BigUint, n: uint) + fn div_estimate(a: &BigUint, b: &BigUint, n: uint) -> (BigUint, BigUint, BigUint) { if a.data.len() < n { return (Zero::zero(), Zero::zero(), copy *a); @@ -405,26 +405,26 @@ pub impl BigUint { } } - pure fn quot(&self, other: &BigUint) -> BigUint { + fn quot(&self, other: &BigUint) -> BigUint { let (q, _) = self.quotrem(other); return q; } - pure fn rem(&self, other: &BigUint) -> BigUint { + fn rem(&self, other: &BigUint) -> BigUint { let (_, r) = self.quotrem(other); return r; } - pure fn quotrem(&self, other: &BigUint) -> (BigUint, BigUint) { + fn quotrem(&self, other: &BigUint) -> (BigUint, BigUint) { self.divmod(other) } - pure fn is_zero(&self) -> bool { self.data.is_empty() } - pure fn is_not_zero(&self) -> bool { !self.data.is_empty() } - pure fn is_positive(&self) -> bool { self.is_not_zero() } - pure fn is_negative(&self) -> bool { false } - pure fn is_nonpositive(&self) -> bool { self.is_zero() } - pure fn is_nonnegative(&self) -> bool { true } + fn is_zero(&self) -> bool { self.data.is_empty() } + fn is_not_zero(&self) -> bool { !self.data.is_empty() } + fn is_positive(&self) -> bool { self.is_not_zero() } + fn is_negative(&self) -> bool { false } + fn is_nonpositive(&self) -> bool { self.is_zero() } + fn is_nonnegative(&self) -> bool { true } - pure fn to_uint(&self) -> uint { + fn to_uint(&self) -> uint { match self.data.len() { 0 => 0, 1 => self.data[0] as uint, @@ -433,7 +433,7 @@ pub impl BigUint { } } - pure fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> ~str { fail_unless!(1 < radix && radix <= 16); let (base, max_len) = get_radix_base(radix); if base == BigDigit::base { @@ -441,7 +441,7 @@ pub impl BigUint { } return fill_concat(convert_base(copy *self, base), radix, max_len); - pure fn convert_base(n: BigUint, base: uint) -> ~[BigDigit] { + fn convert_base(n: BigUint, base: uint) -> ~[BigDigit] { let divider = BigUint::from_uint(base); let mut result = ~[]; let mut r = n; @@ -456,7 +456,7 @@ pub impl BigUint { return result; } - pure fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str { + fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str { if v.is_empty() { return ~"0" } let s = str::concat(vec::reversed(v).map(|n| { let s = uint::to_str_radix(*n as uint, radix); @@ -466,13 +466,13 @@ pub impl BigUint { } } - priv pure fn shl_unit(self, n_unit: uint) -> BigUint { + priv fn shl_unit(self, n_unit: uint) -> BigUint { if n_unit == 0 || self.is_zero() { return self; } return BigUint::new(vec::from_elem(n_unit, 0) + self.data); } - priv pure fn shl_bits(self, n_bits: uint) -> BigUint { + priv fn shl_bits(self, n_bits: uint) -> BigUint { if n_bits == 0 || self.is_zero() { return self; } let mut carry = 0; @@ -487,7 +487,7 @@ pub impl BigUint { return BigUint::new(shifted + [carry]); } - priv pure fn shr_unit(self, n_unit: uint) -> BigUint { + priv fn shr_unit(self, n_unit: uint) -> BigUint { if n_unit == 0 { return self; } if self.data.len() < n_unit { return Zero::zero(); } return BigUint::from_slice( @@ -495,7 +495,7 @@ pub impl BigUint { ); } - priv pure fn shr_bits(self, n_bits: uint) -> BigUint { + priv fn shr_bits(self, n_bits: uint) -> BigUint { if n_bits == 0 || self.data.is_empty() { return self; } let mut borrow = 0; @@ -509,7 +509,7 @@ pub impl BigUint { } #[cfg(target_arch = "x86_64")] -priv pure fn get_radix_base(radix: uint) -> (uint, uint) { +priv fn get_radix_base(radix: uint) -> (uint, uint) { fail_unless!(1 < radix && radix <= 16); match radix { 2 => (4294967296, 32), @@ -534,7 +534,7 @@ priv pure fn get_radix_base(radix: uint) -> (uint, uint) { #[cfg(target_arch = "arm")] #[cfg(target_arch = "x86")] #[cfg(target_arch = "mips")] -priv pure fn get_radix_base(radix: uint) -> (uint, uint) { +priv fn get_radix_base(radix: uint) -> (uint, uint) { fail_unless!(1 < radix && radix <= 16); match radix { 2 => (65536, 16), @@ -560,20 +560,20 @@ priv pure fn get_radix_base(radix: uint) -> (uint, uint) { pub enum Sign { Minus, Zero, Plus } impl Eq for Sign { - pure fn eq(&self, other: &Sign) -> bool { self.cmp(other) == 0 } - pure fn ne(&self, other: &Sign) -> bool { self.cmp(other) != 0 } + fn eq(&self, other: &Sign) -> bool { self.cmp(other) == 0 } + fn ne(&self, other: &Sign) -> bool { self.cmp(other) != 0 } } impl Ord for Sign { - pure fn lt(&self, other: &Sign) -> bool { self.cmp(other) < 0 } - pure fn le(&self, other: &Sign) -> bool { self.cmp(other) <= 0 } - pure fn ge(&self, other: &Sign) -> bool { self.cmp(other) >= 0 } - pure fn gt(&self, other: &Sign) -> bool { self.cmp(other) > 0 } + fn lt(&self, other: &Sign) -> bool { self.cmp(other) < 0 } + fn le(&self, other: &Sign) -> bool { self.cmp(other) <= 0 } + fn ge(&self, other: &Sign) -> bool { self.cmp(other) >= 0 } + fn gt(&self, other: &Sign) -> bool { self.cmp(other) > 0 } } pub impl Sign { /// Compare two Sign. - pure fn cmp(&self, other: &Sign) -> int { + fn cmp(&self, other: &Sign) -> int { match (*self, *other) { (Minus, Minus) | (Zero, Zero) | (Plus, Plus) => 0, (Minus, Zero) | (Minus, Plus) | (Zero, Plus) => -1, @@ -582,7 +582,7 @@ pub impl Sign { } /// Negate Sign value. - pure fn neg(&self) -> Sign { + fn neg(&self) -> Sign { match *self { Minus => Plus, Zero => Zero, @@ -598,53 +598,53 @@ pub struct BigInt { } impl Eq for BigInt { - pure fn eq(&self, other: &BigInt) -> bool { self.cmp(other) == 0 } - pure fn ne(&self, other: &BigInt) -> bool { self.cmp(other) != 0 } + fn eq(&self, other: &BigInt) -> bool { self.cmp(other) == 0 } + fn ne(&self, other: &BigInt) -> bool { self.cmp(other) != 0 } } impl Ord for BigInt { - pure fn lt(&self, other: &BigInt) -> bool { self.cmp(other) < 0 } - pure fn le(&self, other: &BigInt) -> bool { self.cmp(other) <= 0 } - pure fn ge(&self, other: &BigInt) -> bool { self.cmp(other) >= 0 } - pure fn gt(&self, other: &BigInt) -> bool { self.cmp(other) > 0 } + fn lt(&self, other: &BigInt) -> bool { self.cmp(other) < 0 } + fn le(&self, other: &BigInt) -> bool { self.cmp(other) <= 0 } + fn ge(&self, other: &BigInt) -> bool { self.cmp(other) >= 0 } + fn gt(&self, other: &BigInt) -> bool { self.cmp(other) > 0 } } impl ToStr for BigInt { - pure fn to_str(&self) -> ~str { self.to_str_radix(10) } + fn to_str(&self) -> ~str { self.to_str_radix(10) } } impl from_str::FromStr for BigInt { - static pure fn from_str(s: &str) -> Option<BigInt> { + fn from_str(s: &str) -> Option<BigInt> { BigInt::from_str_radix(s, 10) } } impl Shl<uint, BigInt> for BigInt { - pure fn shl(&self, rhs: &uint) -> BigInt { + fn shl(&self, rhs: &uint) -> BigInt { BigInt::from_biguint(self.sign, self.data << *rhs) } } impl Shr<uint, BigInt> for BigInt { - pure fn shr(&self, rhs: &uint) -> BigInt { + fn shr(&self, rhs: &uint) -> BigInt { BigInt::from_biguint(self.sign, self.data >> *rhs) } } impl Zero for BigInt { - static pub pure fn zero() -> BigInt { + pub fn zero() -> BigInt { BigInt::from_biguint(Zero, Zero::zero()) } } impl One for BigInt { - static pub pure fn one() -> BigInt { + pub fn one() -> BigInt { BigInt::from_biguint(Plus, One::one()) } } impl Add<BigInt, BigInt> for BigInt { - pure fn add(&self, other: &BigInt) -> BigInt { + fn add(&self, other: &BigInt) -> BigInt { match (self.sign, other.sign) { (Zero, _) => copy *other, (_, Zero) => copy *self, @@ -658,7 +658,7 @@ impl Add<BigInt, BigInt> for BigInt { } impl Sub<BigInt, BigInt> for BigInt { - pure fn sub(&self, other: &BigInt) -> BigInt { + fn sub(&self, other: &BigInt) -> BigInt { match (self.sign, other.sign) { (Zero, _) => -other, (_, Zero) => copy *self, @@ -678,7 +678,7 @@ impl Sub<BigInt, BigInt> for BigInt { } impl Mul<BigInt, BigInt> for BigInt { - pure fn mul(&self, other: &BigInt) -> BigInt { + fn mul(&self, other: &BigInt) -> BigInt { match (self.sign, other.sign) { (Zero, _) | (_, Zero) => Zero::zero(), (Plus, Plus) | (Minus, Minus) => { @@ -692,27 +692,27 @@ impl Mul<BigInt, BigInt> for BigInt { } impl Div<BigInt, BigInt> for BigInt { - pure fn div(&self, other: &BigInt) -> BigInt { + fn div(&self, other: &BigInt) -> BigInt { let (d, _) = self.divmod(other); return d; } } impl Modulo<BigInt, BigInt> for BigInt { - pure fn modulo(&self, other: &BigInt) -> BigInt { + fn modulo(&self, other: &BigInt) -> BigInt { let (_, m) = self.divmod(other); return m; } } impl Neg<BigInt> for BigInt { - pure fn neg(&self) -> BigInt { + fn neg(&self) -> BigInt { BigInt::from_biguint(self.sign.neg(), copy self.data) } } impl IntConvertible for BigInt { - pure fn to_int(&self) -> int { + fn to_int(&self) -> int { match self.sign { Plus => uint::min(self.to_uint(), int::max_value as uint) as int, Zero => 0, @@ -721,7 +721,7 @@ impl IntConvertible for BigInt { } } - static pure fn from_int(n: int) -> BigInt { + fn from_int(n: int) -> BigInt { if n > 0 { return BigInt::from_biguint(Plus, BigUint::from_uint(n as uint)); } @@ -736,12 +736,12 @@ impl IntConvertible for BigInt { pub impl BigInt { /// Creates and initializes an BigInt. - static pub pure fn new(sign: Sign, v: ~[BigDigit]) -> BigInt { + pub fn new(sign: Sign, v: ~[BigDigit]) -> BigInt { BigInt::from_biguint(sign, BigUint::new(v)) } /// Creates and initializes an BigInt. - static pub pure fn from_biguint(sign: Sign, data: BigUint) -> BigInt { + pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt { if sign == Zero || data.is_zero() { return BigInt { sign: Zero, data: Zero::zero() }; } @@ -749,24 +749,24 @@ pub impl BigInt { } /// Creates and initializes an BigInt. - static pub pure fn from_uint(n: uint) -> BigInt { + pub fn from_uint(n: uint) -> BigInt { if n == 0 { return Zero::zero(); } return BigInt::from_biguint(Plus, BigUint::from_uint(n)); } /// Creates and initializes an BigInt. - static pub pure fn from_slice(sign: Sign, slice: &[BigDigit]) -> BigInt { + pub fn from_slice(sign: Sign, slice: &[BigDigit]) -> BigInt { BigInt::from_biguint(sign, BigUint::from_slice(slice)) } /// Creates and initializes an BigInt. - static pub pure fn from_str_radix(s: &str, radix: uint) + pub fn from_str_radix(s: &str, radix: uint) -> Option<BigInt> { BigInt::parse_bytes(str::to_bytes(s), radix) } /// Creates and initializes an BigInt. - static pub pure fn parse_bytes(buf: &[u8], radix: uint) + pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<BigInt> { if buf.is_empty() { return None; } let mut sign = Plus; @@ -779,11 +779,11 @@ pub impl BigInt { .map(|bu| BigInt::from_biguint(sign, *bu)); } - pure fn abs(&self) -> BigInt { + fn abs(&self) -> BigInt { BigInt::from_biguint(Plus, copy self.data) } - pure fn cmp(&self, other: &BigInt) -> int { + fn cmp(&self, other: &BigInt) -> int { let ss = self.sign, os = other.sign; if ss < os { return -1; } if ss > os { return 1; } @@ -796,7 +796,7 @@ pub impl BigInt { } } - pure fn divmod(&self, other: &BigInt) -> (BigInt, BigInt) { + fn divmod(&self, other: &BigInt) -> (BigInt, BigInt) { // m.sign == other.sign let (d_ui, m_ui) = self.data.divmod(&other.data); let d = BigInt::from_biguint(Plus, d_ui), @@ -818,16 +818,16 @@ pub impl BigInt { } } - pure fn quot(&self, other: &BigInt) -> BigInt { + fn quot(&self, other: &BigInt) -> BigInt { let (q, _) = self.quotrem(other); return q; } - pure fn rem(&self, other: &BigInt) -> BigInt { + fn rem(&self, other: &BigInt) -> BigInt { let (_, r) = self.quotrem(other); return r; } - pure fn quotrem(&self, other: &BigInt) -> (BigInt, BigInt) { + fn quotrem(&self, other: &BigInt) -> (BigInt, BigInt) { // r.sign == self.sign let (q_ui, r_ui) = self.data.quotrem(&other.data); let q = BigInt::from_biguint(Plus, q_ui); @@ -841,14 +841,14 @@ pub impl BigInt { } } - pure fn is_zero(&self) -> bool { self.sign == Zero } - pure fn is_not_zero(&self) -> bool { self.sign != Zero } - pure fn is_positive(&self) -> bool { self.sign == Plus } - pure fn is_negative(&self) -> bool { self.sign == Minus } - pure fn is_nonpositive(&self) -> bool { self.sign != Plus } - pure fn is_nonnegative(&self) -> bool { self.sign != Minus } + fn is_zero(&self) -> bool { self.sign == Zero } + fn is_not_zero(&self) -> bool { self.sign != Zero } + fn is_positive(&self) -> bool { self.sign == Plus } + fn is_negative(&self) -> bool { self.sign == Minus } + fn is_nonpositive(&self) -> bool { self.sign != Plus } + fn is_nonnegative(&self) -> bool { self.sign != Minus } - pure fn to_uint(&self) -> uint { + fn to_uint(&self) -> uint { match self.sign { Plus => self.data.to_uint(), Zero => 0, @@ -856,7 +856,7 @@ pub impl BigInt { } } - pure fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> ~str { match self.sign { Plus => self.data.to_str_radix(radix), Zero => ~"0", diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index d4b4c7b097c..270a2c1fc1b 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -27,7 +27,7 @@ fn small_mask(nbits: uint) -> uint { } pub impl SmallBitv { - static fn new(bits: uint) -> SmallBitv { + fn new(bits: uint) -> SmallBitv { SmallBitv {bits: bits} } @@ -62,7 +62,7 @@ pub impl SmallBitv { } #[inline(always)] - pure fn get(&self, i: uint) -> bool { + fn get(&self, i: uint) -> bool { (self.bits & (1 << i)) != 0 } @@ -124,7 +124,7 @@ fn big_mask(nbits: uint, elem: uint) -> uint { } pub impl BigBitv { - static fn new(storage: ~[uint]) -> BigBitv { + fn new(storage: ~[uint]) -> BigBitv { BigBitv {storage: storage} } @@ -181,7 +181,7 @@ pub impl BigBitv { } #[inline(always)] - pure fn get(&self, i: uint) -> bool { + fn get(&self, i: uint) -> bool { let w = i / uint::bits; let b = i % uint::bits; let x = 1 & self.storage[w] >> b; @@ -256,7 +256,7 @@ priv impl Bitv { } pub impl Bitv { - static fn new(nbits: uint, init: bool) -> Bitv { + fn new(nbits: uint, init: bool) -> Bitv { let rep = if nbits <= uint::bits { Small(~SmallBitv::new(if init {!0} else {0})) } @@ -299,7 +299,7 @@ pub impl Bitv { /// Retrieve the value at index `i` #[inline(always)] - pure fn get(&self, i: uint) -> bool { + fn get(&self, i: uint) -> bool { fail_unless!((i < self.nbits)); match self.rep { Big(ref b) => b.get(i), @@ -555,13 +555,13 @@ pub fn from_fn(len: uint, f: &fn(index: uint) -> bool) -> Bitv { } impl ops::Index<uint,bool> for Bitv { - pure fn index(&self, i: uint) -> bool { + fn index(&self, i: uint) -> bool { self.get(i) } } #[inline(always)] -pure fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool { +fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool { if bits == 0 { return true; } @@ -592,12 +592,12 @@ pub struct BitvSet { pub impl BitvSet { /// Creates a new bit vector set with initially no contents - static fn new() -> BitvSet { + fn new() -> BitvSet { BitvSet{ size: 0, bitv: BigBitv::new(~[0]) } } /// Creates a new bit vector set from the given bit vector - static fn from_bitv(bitv: Bitv) -> BitvSet { + fn from_bitv(bitv: Bitv) -> BitvSet { let mut size = 0; for bitv.ones |_| { size += 1; @@ -612,7 +612,7 @@ pub impl BitvSet { /// Returns the capacity in bits for this bit vector. Inserting any /// element less than this amount will not trigger a resizing. - pure fn capacity(&self) -> uint { self.bitv.storage.len() * uint::bits } + fn capacity(&self) -> uint { self.bitv.storage.len() * uint::bits } /// Consumes this set to return the underlying bit vector fn unwrap(self) -> Bitv { @@ -667,9 +667,9 @@ pub impl BitvSet { } impl BaseIter<uint> for BitvSet { - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } - pure fn each(&self, blk: &fn(v: &uint) -> bool) { + fn each(&self, blk: &fn(v: &uint) -> bool) { for self.bitv.storage.eachi |i, &w| { if !iterate_bits(i * uint::bits, w, |b| blk(&b)) { return; @@ -679,7 +679,7 @@ impl BaseIter<uint> for BitvSet { } impl cmp::Eq for BitvSet { - pure fn eq(&self, other: &BitvSet) -> bool { + fn eq(&self, other: &BitvSet) -> bool { if self.size != other.size { return false; } @@ -696,12 +696,12 @@ impl cmp::Eq for BitvSet { return true; } - pure fn ne(&self, other: &BitvSet) -> bool { !self.eq(other) } + fn ne(&self, other: &BitvSet) -> bool { !self.eq(other) } } impl Container for BitvSet { - pure fn len(&const self) -> uint { self.size } - pure fn is_empty(&const self) -> bool { self.size == 0 } + fn len(&const self) -> uint { self.size } + fn is_empty(&const self) -> bool { self.size == 0 } } impl Mutable for BitvSet { @@ -712,7 +712,7 @@ impl Mutable for BitvSet { } impl Set<uint> for BitvSet { - pure fn contains(&self, value: &uint) -> bool { + fn contains(&self, value: &uint) -> bool { *value < self.bitv.storage.len() * uint::bits && self.bitv.get(*value) } @@ -748,14 +748,14 @@ impl Set<uint> for BitvSet { return true; } - pure fn is_disjoint(&self, other: &BitvSet) -> bool { + fn is_disjoint(&self, other: &BitvSet) -> bool { for self.intersection(other) |_| { return false; } return true; } - pure fn is_subset(&self, other: &BitvSet) -> bool { + fn is_subset(&self, other: &BitvSet) -> bool { for self.each_common(other) |_, w1, w2| { if w1 & w2 != w1 { return false; @@ -774,11 +774,11 @@ impl Set<uint> for BitvSet { return true; } - pure fn is_superset(&self, other: &BitvSet) -> bool { + fn is_superset(&self, other: &BitvSet) -> bool { other.is_subset(self) } - pure fn difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) { + fn difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) { for self.each_common(other) |i, w1, w2| { if !iterate_bits(i, w1 & !w2, |b| f(&b)) { return; @@ -790,7 +790,7 @@ impl Set<uint> for BitvSet { ); } - pure fn symmetric_difference(&self, other: &BitvSet, + fn symmetric_difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) { for self.each_common(other) |i, w1, w2| { if !iterate_bits(i, w1 ^ w2, |b| f(&b)) { @@ -802,7 +802,7 @@ impl Set<uint> for BitvSet { ); } - pure fn intersection(&self, other: &BitvSet, f: &fn(&uint) -> bool) { + fn intersection(&self, other: &BitvSet, f: &fn(&uint) -> bool) { for self.each_common(other) |i, w1, w2| { if !iterate_bits(i, w1 & w2, |b| f(&b)) { return; @@ -810,7 +810,7 @@ impl Set<uint> for BitvSet { } } - pure fn union(&self, other: &BitvSet, f: &fn(&uint) -> bool) { + fn union(&self, other: &BitvSet, f: &fn(&uint) -> bool) { for self.each_common(other) |i, w1, w2| { if !iterate_bits(i, w1 | w2, |b| f(&b)) { return; @@ -827,7 +827,7 @@ priv impl BitvSet { /// both have in common. The three yielded arguments are (bit location, /// w1, w2) where the bit location is the number of bits offset so far, /// and w1/w2 are the words coming from the two vectors self, other. - pure fn each_common(&self, other: &BitvSet, + fn each_common(&self, other: &BitvSet, f: &fn(uint, uint, uint) -> bool) { let min = uint::min(self.bitv.storage.len(), other.bitv.storage.len()); @@ -845,7 +845,7 @@ priv impl BitvSet { /// The yielded arguments are a bool, the bit offset, and a word. The bool /// is true if the word comes from 'self', and false if it comes from /// 'other'. - pure fn each_outlier(&self, other: &BitvSet, + fn each_outlier(&self, other: &BitvSet, f: &fn(bool, uint, uint) -> bool) { let len1 = self.bitv.storage.len(); let len2 = other.bitv.storage.len(); diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index d9595656f05..1787be75e24 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -141,7 +141,7 @@ pub fn set<T:Copy>(t: CVec<T>, ofs: uint, v: T) { */ /// Returns the length of the vector -pub pure fn len<T>(t: CVec<T>) -> uint { t.len } +pub fn len<T>(t: CVec<T>) -> uint { t.len } /// Returns a pointer to the first element of the vector pub unsafe fn ptr<T>(t: CVec<T>) -> *mut T { t.base } diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs index b6362f83f44..6fd77de0342 100644 --- a/src/libstd/cmp.rs +++ b/src/libstd/cmp.rs @@ -17,36 +17,36 @@ use core::float; pub const FUZZY_EPSILON: float = 1.0e-6; pub trait FuzzyEq<Eps> { - pure fn fuzzy_eq(&self, other: &Self) -> bool; - pure fn fuzzy_eq_eps(&self, other: &Self, epsilon: &Eps) -> bool; + fn fuzzy_eq(&self, other: &Self) -> bool; + fn fuzzy_eq_eps(&self, other: &Self, epsilon: &Eps) -> bool; } impl FuzzyEq<float> for float { - pure fn fuzzy_eq(&self, other: &float) -> bool { + fn fuzzy_eq(&self, other: &float) -> bool { self.fuzzy_eq_eps(other, &FUZZY_EPSILON) } - pure fn fuzzy_eq_eps(&self, other: &float, epsilon: &float) -> bool { + fn fuzzy_eq_eps(&self, other: &float, epsilon: &float) -> bool { float::abs(*self - *other) < *epsilon } } impl FuzzyEq<f32> for f32 { - pure fn fuzzy_eq(&self, other: &f32) -> bool { + fn fuzzy_eq(&self, other: &f32) -> bool { self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f32)) } - pure fn fuzzy_eq_eps(&self, other: &f32, epsilon: &f32) -> bool { + fn fuzzy_eq_eps(&self, other: &f32, epsilon: &f32) -> bool { f32::abs(*self - *other) < *epsilon } } impl FuzzyEq<f64> for f64 { - pure fn fuzzy_eq(&self, other: &f64) -> bool { + fn fuzzy_eq(&self, other: &f64) -> bool { self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f64)) } - pure fn fuzzy_eq_eps(&self, other: &f64, epsilon: &f64) -> bool { + fn fuzzy_eq_eps(&self, other: &f64, epsilon: &f64) -> bool { f64::abs(*self - *other) < *epsilon } } @@ -71,11 +71,11 @@ mod test_complex{ struct Complex { r: float, i: float } impl FuzzyEq<float> for Complex { - pure fn fuzzy_eq(&self, other: &Complex) -> bool { + fn fuzzy_eq(&self, other: &Complex) -> bool { self.fuzzy_eq_eps(other, &FUZZY_EPSILON) } - pure fn fuzzy_eq_eps(&self, other: &Complex, + fn fuzzy_eq_eps(&self, other: &Complex, epsilon: &float) -> bool { self.r.fuzzy_eq_eps(&other.r, epsilon) && self.i.fuzzy_eq_eps(&other.i, epsilon) diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs index 314a601fb61..9f68c676222 100644 --- a/src/libstd/comm.rs +++ b/src/libstd/comm.rs @@ -39,7 +39,7 @@ pub impl<T:Owned,U:Owned> DuplexStream<T, U> { fn try_recv(&self) -> Option<U> { self.port.try_recv() } - pure fn peek(&self) -> bool { + fn peek(&self) -> bool { self.port.peek() } } @@ -67,13 +67,13 @@ impl<T:Owned,U:Owned> GenericPort<U> for DuplexStream<T, U> { } impl<T:Owned,U:Owned> Peekable<U> for DuplexStream<T, U> { - pure fn peek(&self) -> bool { + fn peek(&self) -> bool { self.port.peek() } } impl<T:Owned,U:Owned> Selectable for DuplexStream<T, U> { - pure fn header(&self) -> *pipes::PacketHeader { + fn header(&self) -> *pipes::PacketHeader { self.port.header() } } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 64d28dcde83..4f61321b4e7 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -25,10 +25,10 @@ pub struct Deque<T> { impl<T> Container for Deque<T> { /// Return the number of elements in the deque - pure fn len(&const self) -> uint { self.nelts } + fn len(&const self) -> uint { self.nelts } /// Return true if the deque contains no elements - pure fn is_empty(&const self) -> bool { self.len() == 0 } + fn is_empty(&const self) -> bool { self.len() == 0 } } impl<T> Mutable for Deque<T> { @@ -43,7 +43,7 @@ impl<T> Mutable for Deque<T> { pub impl<T> Deque<T> { /// Create an empty Deque - static pure fn new() -> Deque<T> { + fn new() -> Deque<T> { Deque{nelts: 0, lo: 0, hi: 0, elts: vec::from_fn(initial_capacity, |_| None)} } diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 4ab119abf1c..437ab561f95 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -69,7 +69,7 @@ pub mod reader { // ebml reading impl ops::Index<uint,Doc> for Doc { - pure fn index(&self, tag: uint) -> Doc { + fn index(&self, tag: uint) -> Doc { unsafe { get_doc(*self, tag) } diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs index 105e34761a8..9855e803ccb 100644 --- a/src/libstd/flatpipes.rs +++ b/src/libstd/flatpipes.rs @@ -314,7 +314,7 @@ impl<T,F:Flattener<T>,C:ByteChan> GenericChan<T> for FlatChan<T, F, C> { } pub impl<T,U:Unflattener<T>,P:BytePort> FlatPort<T, U, P> { - static fn new(u: U, p: P) -> FlatPort<T, U, P> { + fn new(u: U, p: P) -> FlatPort<T, U, P> { FlatPort { unflattener: u, byte_port: p @@ -323,7 +323,7 @@ pub impl<T,U:Unflattener<T>,P:BytePort> FlatPort<T, U, P> { } pub impl<T,F:Flattener<T>,C:ByteChan> FlatChan<T, F, C> { - static fn new(f: F, c: C) -> FlatChan<T, F, C> { + fn new(f: F, c: C) -> FlatChan<T, F, C> { FlatChan { flattener: f, byte_chan: c @@ -376,7 +376,7 @@ pub mod flatteners { } pub impl<T:Copy + Owned> PodUnflattener<T> { - static fn new() -> PodUnflattener<T> { + fn new() -> PodUnflattener<T> { PodUnflattener { bogus: () } @@ -384,7 +384,7 @@ pub mod flatteners { } pub impl<T:Copy + Owned> PodFlattener<T> { - static fn new() -> PodFlattener<T> { + fn new() -> PodFlattener<T> { PodFlattener { bogus: () } @@ -419,7 +419,7 @@ pub mod flatteners { } pub impl<D:Decoder,T:Decodable<D>> DeserializingUnflattener<D, T> { - static fn new(deserialize_buffer: DeserializeBuffer<T>) + fn new(deserialize_buffer: DeserializeBuffer<T>) -> DeserializingUnflattener<D, T> { DeserializingUnflattener { deserialize_buffer: deserialize_buffer @@ -428,7 +428,7 @@ pub mod flatteners { } pub impl<S:Encoder,T:Encodable<S>> SerializingFlattener<S, T> { - static fn new(serialize_value: SerializeValue<T>) + fn new(serialize_value: SerializeValue<T>) -> SerializingFlattener<S, T> { SerializingFlattener { serialize_value: serialize_value @@ -459,15 +459,15 @@ pub mod flatteners { } pub trait FromReader { - static fn from_reader(r: @Reader) -> Self; + fn from_reader(r: @Reader) -> Self; } pub trait FromWriter { - static fn from_writer(w: @Writer) -> Self; + fn from_writer(w: @Writer) -> Self; } impl FromReader for json::Decoder/&self { - static fn from_reader(r: @Reader) -> json::Decoder/&self { + fn from_reader(r: @Reader) -> json::Decoder/&self { match json::from_reader(r) { Ok(json) => { json::Decoder(json) @@ -478,13 +478,13 @@ pub mod flatteners { } impl FromWriter for json::Encoder { - static fn from_writer(w: @Writer) -> json::Encoder { + fn from_writer(w: @Writer) -> json::Encoder { json::Encoder(w) } } impl FromReader for ebml::reader::Decoder { - static fn from_reader(r: @Reader) -> ebml::reader::Decoder { + fn from_reader(r: @Reader) -> ebml::reader::Decoder { let buf = @r.read_whole_stream(); let doc = ebml::reader::Doc(buf); ebml::reader::Decoder(doc) @@ -492,7 +492,7 @@ pub mod flatteners { } impl FromWriter for ebml::writer::Encoder { - static fn from_writer(w: @Writer) -> ebml::writer::Encoder { + fn from_writer(w: @Writer) -> ebml::writer::Encoder { ebml::writer::Encoder(w) } } @@ -543,7 +543,7 @@ pub mod bytepipes { } pub impl<R:Reader> ReaderBytePort<R> { - static fn new(r: R) -> ReaderBytePort<R> { + fn new(r: R) -> ReaderBytePort<R> { ReaderBytePort { reader: r } @@ -551,7 +551,7 @@ pub mod bytepipes { } pub impl<W:Writer> WriterByteChan<W> { - static fn new(w: W) -> WriterByteChan<W> { + fn new(w: W) -> WriterByteChan<W> { WriterByteChan { writer: w } @@ -606,7 +606,7 @@ pub mod bytepipes { } pub impl PipeBytePort { - static fn new(p: Port<~[u8]>) -> PipeBytePort { + fn new(p: Port<~[u8]>) -> PipeBytePort { PipeBytePort { port: p, buf: ~[] @@ -615,7 +615,7 @@ pub mod bytepipes { } pub impl PipeByteChan { - static fn new(c: Chan<~[u8]>) -> PipeByteChan { + fn new(c: Chan<~[u8]>) -> PipeByteChan { PipeByteChan { chan: c } diff --git a/src/libstd/future.rs b/src/libstd/future.rs index fc60932b67a..29771fa3501 100644 --- a/src/libstd/future.rs +++ b/src/libstd/future.rs @@ -56,7 +56,7 @@ pub impl<A:Copy> Future<A> { pub impl<A> Future<A> { - pure fn get_ref(&self) -> &'self A { + fn get_ref(&self) -> &'self A { /*! * Executes the future's closure and then returns a borrowed * pointer to the result. The borrowed pointer lasts as long as diff --git a/src/libstd/io_util.rs b/src/libstd/io_util.rs index 7d673feaf25..50d2eb6a785 100644 --- a/src/libstd/io_util.rs +++ b/src/libstd/io_util.rs @@ -17,7 +17,7 @@ pub struct BufReader { } pub impl BufReader { - static pub fn new(v: ~[u8]) -> BufReader { + pub fn new(v: ~[u8]) -> BufReader { BufReader { buf: v, pos: 0 diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 00b6501ffce..0973e90dad3 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -345,7 +345,7 @@ pub fn to_writer(wr: @io::Writer, json: &Json) { } /// Encodes a json value into a string -pub pure fn to_str(json: &Json) -> ~str { +pub fn to_str(json: &Json) -> ~str { unsafe { // ugh, should be safe io::with_str_writer(|wr| to_writer(wr, json)) @@ -947,7 +947,7 @@ impl serialize::Decoder for Decoder/&self { } impl Eq for Json { - pure fn eq(&self, other: &Json) -> bool { + fn eq(&self, other: &Json) -> bool { match (self) { &Number(f0) => match other { &Number(f1) => f0 == f1, _ => false }, @@ -980,12 +980,12 @@ impl Eq for Json { } } } - pure fn ne(&self, other: &Json) -> bool { !self.eq(other) } + fn ne(&self, other: &Json) -> bool { !self.eq(other) } } /// Test if two json values are less than one another impl Ord for Json { - pure fn lt(&self, other: &Json) -> bool { + fn lt(&self, other: &Json) -> bool { match (*self) { Number(f0) => { match *other { @@ -1055,18 +1055,18 @@ impl Ord for Json { } } } - pure fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) } - pure fn ge(&self, other: &Json) -> bool { !(*self).lt(other) } - pure fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) } + fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) } + fn ge(&self, other: &Json) -> bool { !(*self).lt(other) } + fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) } } impl Eq for Error { - pure fn eq(&self, other: &Error) -> bool { + fn eq(&self, other: &Error) -> bool { (*self).line == other.line && (*self).col == other.col && (*self).msg == other.msg } - pure fn ne(&self, other: &Error) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Error) -> bool { !(*self).eq(other) } } trait ToJson { fn to_json(&self) -> Json; } @@ -1191,11 +1191,11 @@ impl<A:ToJson> ToJson for Option<A> { } impl to_str::ToStr for Json { - pure fn to_str(&self) -> ~str { to_str(self) } + fn to_str(&self) -> ~str { to_str(self) } } impl to_str::ToStr for Error { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("%u:%u: %s", self.line, self.col, *self.msg) } } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index eb1c249be69..b918f8505c8 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -22,7 +22,7 @@ pub enum List<T> { } /// Create a list from a vector -pub pure fn from_vec<T:Copy>(v: &[T]) -> @List<T> { +pub fn from_vec<T:Copy>(v: &[T]) -> @List<T> { vec::foldr(v, @Nil::<T>, |h, t| @Cons(*h, t)) } @@ -52,7 +52,7 @@ pub fn foldl<T:Copy,U>(z: T, ls: @List<U>, f: &fn(&T, &U) -> T) -> T { * When function `f` returns true then an option containing the element * is returned. If `f` matches no elements then none is returned. */ -pub pure fn find<T:Copy>(ls: @List<T>, f: &fn(&T) -> bool) -> Option<T> { +pub fn find<T:Copy>(ls: @List<T>, f: &fn(&T) -> bool) -> Option<T> { let mut ls = ls; loop { ls = match *ls { @@ -74,7 +74,7 @@ pub fn has<T:Copy + Eq>(ls: @List<T>, elt: T) -> bool { } /// Returns true if the list is empty -pub pure fn is_empty<T:Copy>(ls: @List<T>) -> bool { +pub fn is_empty<T:Copy>(ls: @List<T>) -> bool { match *ls { Nil => true, _ => false @@ -82,14 +82,14 @@ pub pure fn is_empty<T:Copy>(ls: @List<T>) -> bool { } /// Returns the length of a list -pub pure fn len<T>(ls: @List<T>) -> uint { +pub fn len<T>(ls: @List<T>) -> uint { let mut count = 0u; iter(ls, |_e| count += 1u); count } /// Returns all but the first element of a list -pub pure fn tail<T:Copy>(ls: @List<T>) -> @List<T> { +pub fn tail<T:Copy>(ls: @List<T>) -> @List<T> { match *ls { Cons(_, tl) => return tl, Nil => fail!(~"list empty") @@ -97,7 +97,7 @@ pub pure fn tail<T:Copy>(ls: @List<T>) -> @List<T> { } /// Returns the first element of a list -pub pure fn head<T:Copy>(ls: @List<T>) -> T { +pub fn head<T:Copy>(ls: @List<T>) -> T { match *ls { Cons(copy hd, _) => hd, // makes me sad @@ -106,7 +106,7 @@ pub pure fn head<T:Copy>(ls: @List<T>) -> T { } /// Appends one list to another -pub pure fn append<T:Copy>(l: @List<T>, m: @List<T>) -> @List<T> { +pub fn append<T:Copy>(l: @List<T>, m: @List<T>) -> @List<T> { match *l { Nil => return m, Cons(copy x, xs) => { @@ -119,13 +119,13 @@ pub pure fn append<T:Copy>(l: @List<T>, m: @List<T>) -> @List<T> { /* /// Push one element into the front of a list, returning a new list /// THIS VERSION DOESN'T ACTUALLY WORK -pure fn push<T:Copy>(ll: &mut @list<T>, vv: T) { +fn push<T:Copy>(ll: &mut @list<T>, vv: T) { ll = &mut @cons(vv, *ll) } */ /// Iterate over a list -pub pure fn iter<T>(l: @List<T>, f: &fn(&T)) { +pub fn iter<T>(l: @List<T>, f: &fn(&T)) { let mut cur = l; loop { cur = match *cur { @@ -139,7 +139,7 @@ pub pure fn iter<T>(l: @List<T>, f: &fn(&T)) { } /// Iterate over a list -pub pure fn each<T>(l: @List<T>, f: &fn(&T) -> bool) { +pub fn each<T>(l: @List<T>, f: &fn(&T) -> bool) { let mut cur = l; loop { cur = match *cur { diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index df254543512..e20ac624278 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -19,7 +19,7 @@ struct Quad { d: u32 } -pub pure fn md4(msg: &[u8]) -> Quad { +pub fn md4(msg: &[u8]) -> Quad { // subtle: if orig_len is merely uint, then the code below // which performs shifts by 32 bits or more has undefined // results. @@ -45,7 +45,7 @@ pub pure fn md4(msg: &[u8]) -> Quad { let mut c = 0x98badcfeu32; let mut d = 0x10325476u32; - pure fn rot(r: int, x: u32) -> u32 { + fn rot(r: int, x: u32) -> u32 { let r = r as u32; (x << r) | (x >> (32u32 - r)) } @@ -103,9 +103,9 @@ pub pure fn md4(msg: &[u8]) -> Quad { return Quad {a: a, b: b, c: c, d: d}; } -pub pure fn md4_str(msg: &[u8]) -> ~str { +pub fn md4_str(msg: &[u8]) -> ~str { let Quad {a, b, c, d} = md4(msg); - pure fn app(a: u32, b: u32, c: u32, d: u32, f: &fn(u32)) { + fn app(a: u32, b: u32, c: u32, d: u32, f: &fn(u32)) { f(a); f(b); f(c); f(d); } let mut result = ~""; @@ -121,7 +121,7 @@ pub pure fn md4_str(msg: &[u8]) -> ~str { result } -pub pure fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) } +pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) } #[test] fn test_md4() { diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 6fb4f6747a3..21b60584635 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -45,7 +45,7 @@ struct UserInfo { pub type Query = ~[(~str, ~str)]; pub impl Url { - static pure fn new( + fn new( scheme: ~str, user: Option<UserInfo>, host: ~str, @@ -67,7 +67,7 @@ pub impl Url { } pub impl UserInfo { - static pure fn new(user: ~str, pass: Option<~str>) -> UserInfo { + fn new(user: ~str, pass: Option<~str>) -> UserInfo { UserInfo { user: user, pass: pass } } } @@ -117,7 +117,7 @@ fn encode_inner(s: &str, full_url: bool) -> ~str { * * This function is compliant with RFC 3986. */ -pub pure fn encode(s: &str) -> ~str { +pub fn encode(s: &str) -> ~str { // FIXME(#3722): unsafe only because encode_inner does (string) IO unsafe {encode_inner(s, true)} } @@ -129,7 +129,7 @@ pub pure fn encode(s: &str) -> ~str { * This function is compliant with RFC 3986. */ -pub pure fn encode_component(s: &str) -> ~str { +pub fn encode_component(s: &str) -> ~str { // FIXME(#3722): unsafe only because encode_inner does (string) IO unsafe {encode_inner(s, false)} } @@ -177,7 +177,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str { * * This will only decode escape sequences generated by encode. */ -pub pure fn decode(s: &str) -> ~str { +pub fn decode(s: &str) -> ~str { // FIXME(#3722): unsafe only because decode_inner does (string) IO unsafe {decode_inner(s, true)} } @@ -185,7 +185,7 @@ pub pure fn decode(s: &str) -> ~str { /** * Decode a string encoded with percent encoding. */ -pub pure fn decode_component(s: &str) -> ~str { +pub fn decode_component(s: &str) -> ~str { // FIXME(#3722): unsafe only because decode_inner does (string) IO unsafe {decode_inner(s, false)} } @@ -297,7 +297,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> LinearMap<~str, ~[~str]> { } -pure fn split_char_first(s: &str, c: char) -> (~str, ~str) { +fn split_char_first(s: &str, c: char) -> (~str, ~str) { let len = str::len(s); let mut index = len; let mut mat = 0; @@ -324,7 +324,7 @@ pure fn split_char_first(s: &str, c: char) -> (~str, ~str) { } } -pure fn userinfo_from_str(uinfo: &str) -> UserInfo { +fn userinfo_from_str(uinfo: &str) -> UserInfo { let (user, p) = split_char_first(uinfo, ':'); let pass = if str::len(p) == 0 { None @@ -334,14 +334,14 @@ pure fn userinfo_from_str(uinfo: &str) -> UserInfo { return UserInfo::new(user, pass); } -pure fn userinfo_to_str(userinfo: &UserInfo) -> ~str { +fn userinfo_to_str(userinfo: &UserInfo) -> ~str { match userinfo.pass { Some(ref pass) => fmt!("%s:%s@", userinfo.user, *pass), None => fmt!("%s@", userinfo.user), } } -pure fn query_from_str(rawquery: &str) -> Query { +fn query_from_str(rawquery: &str) -> Query { let mut query: Query = ~[]; if str::len(rawquery) != 0 { for str::split_char(rawquery, '&').each |p| { @@ -353,7 +353,7 @@ pure fn query_from_str(rawquery: &str) -> Query { return query; } -pub pure fn query_to_str(query: &Query) -> ~str { +pub fn query_to_str(query: &Query) -> ~str { unsafe { // FIXME(#3722): unsafe only because decode_inner does (string) IO let mut strvec = ~[]; @@ -372,7 +372,7 @@ pub pure fn query_to_str(query: &Query) -> ~str { } // returns the scheme and the rest of the url, or a parsing error -pub pure fn get_scheme(rawurl: &str) -> Result<(~str, ~str), ~str> { +pub fn get_scheme(rawurl: &str) -> Result<(~str, ~str), ~str> { for str::each_chari(rawurl) |i,c| { match c { 'A' .. 'Z' | 'a' .. 'z' => loop, @@ -406,7 +406,7 @@ enum Input { } // returns userinfo, host, port, and unparsed part, or an error -pure fn get_authority(rawurl: &str) -> +fn get_authority(rawurl: &str) -> Result<(Option<UserInfo>, ~str, Option<~str>, ~str), ~str> { if !str::starts_with(rawurl, ~"//") { // there is no authority. @@ -534,7 +534,7 @@ pure fn get_authority(rawurl: &str) -> let end = end; // make end immutable so it can be captured - let host_is_end_plus_one: &pure fn() -> bool = || { + let host_is_end_plus_one: &fn() -> bool = || { end+1 == len && !['?', '#', '/'].contains(&(rawurl[end] as char)) }; @@ -573,7 +573,7 @@ pure fn get_authority(rawurl: &str) -> // returns the path and unparsed part of url, or an error -pure fn get_path(rawurl: &str, authority: bool) -> +fn get_path(rawurl: &str, authority: bool) -> Result<(~str, ~str), ~str> { let len = str::len(rawurl); let mut end = len; @@ -604,7 +604,7 @@ pure fn get_path(rawurl: &str, authority: bool) -> } // returns the parsed query and the fragment, if present -pure fn get_query_fragment(rawurl: &str) -> +fn get_query_fragment(rawurl: &str) -> Result<(Query, Option<~str>), ~str> { if !str::starts_with(rawurl, ~"?") { if str::starts_with(rawurl, ~"#") { @@ -636,7 +636,7 @@ pure fn get_query_fragment(rawurl: &str) -> * */ -pub pure fn from_str(rawurl: &str) -> Result<Url, ~str> { +pub fn from_str(rawurl: &str) -> Result<Url, ~str> { // scheme let (scheme, rest) = match get_scheme(rawurl) { Ok(val) => val, @@ -666,7 +666,7 @@ pub pure fn from_str(rawurl: &str) -> Result<Url, ~str> { } impl FromStr for Url { - static pure fn from_str(s: &str) -> Option<Url> { + fn from_str(s: &str) -> Option<Url> { match from_str(s) { Ok(url) => Some(url), Err(_) => None @@ -689,7 +689,7 @@ impl FromStr for Url { * result in just "http://somehost.com". * */ -pub pure fn to_str(url: &Url) -> ~str { +pub fn to_str(url: &Url) -> ~str { let user = match url.user { Some(ref user) => userinfo_to_str(user), None => ~"", @@ -716,13 +716,13 @@ pub pure fn to_str(url: &Url) -> ~str { } impl to_str::ToStr for Url { - pub pure fn to_str(&self) -> ~str { + pub fn to_str(&self) -> ~str { to_str(self) } } impl to_bytes::IterBytes for Url { - pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { self.to_str().iter_bytes(lsb0, f) } } diff --git a/src/libstd/oldmap.rs b/src/libstd/oldmap.rs index 0a07a24e8ee..0b688f0c678 100644 --- a/src/libstd/oldmap.rs +++ b/src/libstd/oldmap.rs @@ -31,7 +31,7 @@ pub mod util { den: int, } - pub pure fn rational_leq(x: Rational, y: Rational) -> bool { + pub fn rational_leq(x: Rational, y: Rational) -> bool { // NB: Uses the fact that rationals have positive denominators WLOG: x.num * y.den <= y.num * x.den @@ -74,7 +74,7 @@ pub mod chained { } priv impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> { - pure fn search_rem(&self, k: &K, h: uint, idx: uint, + fn search_rem(&self, k: &K, h: uint, idx: uint, e_root: @Entry<K,V>) -> SearchResult<K,V> { let mut e0 = e_root; let mut comp = 1u; // for logging @@ -100,7 +100,7 @@ pub mod chained { }; } - pure fn search_tbl(&self, k: &K, h: uint) -> SearchResult<K,V> { + fn search_tbl(&self, k: &K, h: uint) -> SearchResult<K,V> { let idx = h % vec::uniq_len(&const self.chains); match copy self.chains[idx] { None => { @@ -134,7 +134,7 @@ pub mod chained { } pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> { - pure fn each_entry(&self, blk: &fn(@Entry<K,V>) -> bool) { + fn each_entry(&self, blk: &fn(@Entry<K,V>) -> bool) { // n.b. we can't use vec::iter() here because self.chains // is stored in a mutable location. let mut i = 0u, n = vec::uniq_len(&const self.chains); @@ -161,12 +161,12 @@ pub mod chained { } impl<K:Eq + IterBytes + Hash,V> Container for HashMap_<K, V> { - pure fn len(&const self) -> uint { self.count } - pure fn is_empty(&const self) -> bool { self.count == 0 } + fn len(&const self) -> uint { self.count } + fn is_empty(&const self) -> bool { self.count == 0 } } pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> { - pure fn contains_key(@self, k: &K) -> bool { + fn contains_key(@self, k: &K) -> bool { let hash = k.hash_keyed(0,0) as uint; match self.search_tbl(k, hash) { NotFound => false, @@ -234,23 +234,23 @@ pub mod chained { } } - pure fn each(@self, blk: &fn(key: &K, value: &V) -> bool) { + fn each(@self, blk: &fn(key: &K, value: &V) -> bool) { for self.each_entry |entry| { if !blk(&entry.key, &entry.value) { break; } } } - pure fn each_key(@self, blk: &fn(key: &K) -> bool) { + fn each_key(@self, blk: &fn(key: &K) -> bool) { self.each(|k, _v| blk(k)) } - pure fn each_value(@self, blk: &fn(value: &V) -> bool) { + fn each_value(@self, blk: &fn(value: &V) -> bool) { self.each(|_k, v| blk(v)) } } pub impl<K:Eq + IterBytes + Hash + Copy,V:Copy> HashMap_<K, V> { - pure fn find(&self, k: &K) -> Option<V> { + fn find(&self, k: &K) -> Option<V> { match self.search_tbl(k, k.hash_keyed(0,0) as uint) { NotFound => None, FoundFirst(_, entry) => Some(entry.value), @@ -314,7 +314,7 @@ pub mod chained { return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1)); } - pure fn get(&self, k: &K) -> V { + fn get(&self, k: &K) -> V { let opt_v = self.find(k); if opt_v.is_none() { fail!(fmt!("Key not found in table: %?", k)); @@ -348,7 +348,7 @@ pub mod chained { impl<K:Eq + IterBytes + Hash + Copy + ToStr,V:ToStr + Copy> ToStr for HashMap_<K, V> { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { unsafe { // Meh -- this should be safe do io::with_str_writer |wr| { self.to_writer(wr) } @@ -358,7 +358,7 @@ pub mod chained { impl<K:Eq + IterBytes + Hash + Copy,V:Copy> ops::Index<K, V> for HashMap_<K, V> { - pure fn index(&self, k: K) -> V { + fn index(&self, k: K) -> V { self.get(&k) } } @@ -391,7 +391,7 @@ pub fn set_add<K:Eq + IterBytes + Hash + Const + Copy>(set: Set<K>, key: K) } /// Convert a set into a vector. -pub pure fn vec_from_set<T:Eq + IterBytes + Hash + Copy>(s: Set<T>) -> ~[T] { +pub fn vec_from_set<T:Eq + IterBytes + Hash + Copy>(s: Set<T>) -> ~[T] { do vec::build_sized(s.len()) |push| { for s.each_key() |&k| { push(k); @@ -422,8 +422,8 @@ mod tests { #[test] fn test_simple() { debug!("*** starting test_simple"); - pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } - pure fn uint_id(x: &uint) -> uint { *x } + fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } + fn uint_id(x: &uint) -> uint { *x } debug!("uint -> uint"); let hm_uu: HashMap<uint, uint> = HashMap::<uint, uint>(); @@ -491,8 +491,8 @@ mod tests { fn test_growth() { debug!("*** starting test_growth"); let num_to_insert: uint = 64u; - pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } - pure fn uint_id(x: &uint) -> uint { *x } + fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } + fn uint_id(x: &uint) -> uint { *x } debug!("uint -> uint"); let hm_uu: HashMap<uint, uint> = HashMap::<uint, uint>(); diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs index a5a291c5b18..03d518f1f63 100644 --- a/src/libstd/priority_queue.rs +++ b/src/libstd/priority_queue.rs @@ -31,16 +31,16 @@ impl<T:Ord> BaseIter<T> for PriorityQueue<T> { /// Visit all values in the underlying vector. /// /// The values are **not** visited in order. - pure fn each(&self, f: &fn(&T) -> bool) { self.data.each(f) } - pure fn size_hint(&self) -> Option<uint> { self.data.size_hint() } + fn each(&self, f: &fn(&T) -> bool) { self.data.each(f) } + fn size_hint(&self) -> Option<uint> { self.data.size_hint() } } impl<T:Ord> Container for PriorityQueue<T> { /// Returns the length of the queue - pure fn len(&const self) -> uint { vec::uniq_len(&const self.data) } + fn len(&const self) -> uint { vec::uniq_len(&const self.data) } /// Returns true if a queue contains no elements - pure fn is_empty(&const self) -> bool { self.len() == 0 } + fn is_empty(&const self) -> bool { self.len() == 0 } } impl<T:Ord> Mutable for PriorityQueue<T> { @@ -50,15 +50,15 @@ impl<T:Ord> Mutable for PriorityQueue<T> { pub impl <T:Ord> PriorityQueue<T> { /// Returns the greatest item in the queue - fails if empty - pure fn top(&self) -> &'self T { &self.data[0] } + fn top(&self) -> &'self T { &self.data[0] } /// Returns the greatest item in the queue - None if empty - pure fn maybe_top(&self) -> Option<&'self T> { + fn maybe_top(&self) -> Option<&'self T> { if self.is_empty() { None } else { Some(self.top()) } } /// Returns the number of elements the queue can hold without reallocating - pure fn capacity(&self) -> uint { vec::capacity(&self.data) } + fn capacity(&self) -> uint { vec::capacity(&self.data) } fn reserve(&mut self, n: uint) { vec::reserve(&mut self.data, n) } @@ -102,11 +102,11 @@ pub impl <T:Ord> PriorityQueue<T> { } /// Consume the PriorityQueue and return the underlying vector - pure fn to_vec(self) -> ~[T] { let PriorityQueue{data: v} = self; v } + fn to_vec(self) -> ~[T] { let PriorityQueue{data: v} = self; v } /// Consume the PriorityQueue and return a vector in sorted /// (ascending) order - pure fn to_sorted_vec(self) -> ~[T] { + fn to_sorted_vec(self) -> ~[T] { let mut q = self; let mut end = q.len(); while end > 1 { @@ -118,10 +118,10 @@ pub impl <T:Ord> PriorityQueue<T> { } /// Create an empty PriorityQueue - static pure fn new() -> PriorityQueue<T> { PriorityQueue{data: ~[],} } + fn new() -> PriorityQueue<T> { PriorityQueue{data: ~[],} } /// Create a PriorityQueue from a vector (heapify) - static pure fn from_vec(xs: ~[T]) -> PriorityQueue<T> { + fn from_vec(xs: ~[T]) -> PriorityQueue<T> { let mut q = PriorityQueue{data: xs,}; let mut n = q.len() / 2; while n > 0 { diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index ff7d4ec3b1c..c9ad762880c 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -47,7 +47,7 @@ pub type Rope = node::Root; */ /// Create an empty rope -pub pure fn empty() -> Rope { +pub fn empty() -> Rope { return node::Empty; } @@ -491,7 +491,7 @@ pub mod iterator { * * Constant time. */ -pub pure fn height(rope: Rope) -> uint { +pub fn height(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::height(x) @@ -507,7 +507,7 @@ pub pure fn height(rope: Rope) -> uint { * * Constant time. */ -pub pure fn char_len(rope: Rope) -> uint { +pub fn char_len(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::char_len(x) @@ -521,7 +521,7 @@ pub pure fn char_len(rope: Rope) -> uint { * * Constant time. */ -pub pure fn byte_len(rope: Rope) -> uint { +pub fn byte_len(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::byte_len(x) @@ -761,7 +761,7 @@ pub mod node { } } - pub pure fn byte_len(node: @Node) -> uint { + pub fn byte_len(node: @Node) -> uint { //FIXME (#2744): Could we do this without the pattern-matching? match (*node) { Leaf(y) => y.byte_len, @@ -769,7 +769,7 @@ pub mod node { } } - pub pure fn char_len(node: @Node) -> uint { + pub fn char_len(node: @Node) -> uint { match (*node) { Leaf(y) => y.char_len, Concat(ref y) => y.char_len @@ -1050,7 +1050,7 @@ pub mod node { }) } - pub pure fn height(node: @Node) -> uint { + pub fn height(node: @Node) -> uint { match (*node) { Leaf(_) => 0u, Concat(ref x) => x.height, @@ -1131,7 +1131,7 @@ pub mod node { * proportional to the height of the rope + the (bounded) * length of the largest leaf. */ - pub pure fn char_at(node: @Node, pos: uint) -> char { + pub fn char_at(node: @Node, pos: uint) -> char { let mut node = node; let mut pos = pos; loop { diff --git a/src/libstd/semver.rs b/src/libstd/semver.rs index 3593ccc5ae8..50579db4707 100644 --- a/src/libstd/semver.rs +++ b/src/libstd/semver.rs @@ -27,7 +27,7 @@ pub enum Identifier { impl cmp::Ord for Identifier { #[inline(always)] - pure fn lt(&self, other: &Identifier) -> bool { + fn lt(&self, other: &Identifier) -> bool { match (self, other) { (&Numeric(a), &Numeric(b)) => a < b, (&Numeric(_), _) => true, @@ -36,22 +36,22 @@ impl cmp::Ord for Identifier { } } #[inline(always)] - pure fn le(&self, other: &Identifier) -> bool { + fn le(&self, other: &Identifier) -> bool { ! (other < self) } #[inline(always)] - pure fn gt(&self, other: &Identifier) -> bool { + fn gt(&self, other: &Identifier) -> bool { other < self } #[inline(always)] - pure fn ge(&self, other: &Identifier) -> bool { + fn ge(&self, other: &Identifier) -> bool { ! (self < other) } } impl ToStr for Identifier { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match self { &Numeric(n) => n.to_str(), &AlphaNumeric(ref s) => s.to_str() @@ -71,7 +71,7 @@ pub struct Version { impl ToStr for Version { #[inline(always)] - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { let s = fmt!("%u.%u.%u", self.major, self.minor, self.patch); let s = if self.pre.is_empty() { s @@ -88,7 +88,7 @@ impl ToStr for Version { impl cmp::Ord for Version { #[inline(always)] - pure fn lt(&self, other: &Version) -> bool { + fn lt(&self, other: &Version) -> bool { self.major < other.major || @@ -121,15 +121,15 @@ impl cmp::Ord for Version { } #[inline(always)] - pure fn le(&self, other: &Version) -> bool { + fn le(&self, other: &Version) -> bool { ! (other < self) } #[inline(always)] - pure fn gt(&self, other: &Version) -> bool { + fn gt(&self, other: &Version) -> bool { other < self } #[inline(always)] - pure fn ge(&self, other: &Version) -> bool { + fn ge(&self, other: &Version) -> bool { ! (self < other) } } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 2c927b5db16..d288c06d293 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -110,7 +110,7 @@ pub trait Encodable<S:Encoder> { } pub trait Decodable<D:Decoder> { - static fn decode(&self, d: &D) -> Self; + fn decode(d: &D) -> Self; } impl<S:Encoder> Encodable<S> for uint { @@ -118,7 +118,7 @@ impl<S:Encoder> Encodable<S> for uint { } impl<D:Decoder> Decodable<D> for uint { - static fn decode(&self, d: &D) -> uint { + fn decode(d: &D) -> uint { d.read_uint() } } @@ -128,7 +128,7 @@ impl<S:Encoder> Encodable<S> for u8 { } impl<D:Decoder> Decodable<D> for u8 { - static fn decode(&self, d: &D) -> u8 { + fn decode(d: &D) -> u8 { d.read_u8() } } @@ -138,7 +138,7 @@ impl<S:Encoder> Encodable<S> for u16 { } impl<D:Decoder> Decodable<D> for u16 { - static fn decode(&self, d: &D) -> u16 { + fn decode(d: &D) -> u16 { d.read_u16() } } @@ -148,7 +148,7 @@ impl<S:Encoder> Encodable<S> for u32 { } impl<D:Decoder> Decodable<D> for u32 { - static fn decode(&self, d: &D) -> u32 { + fn decode(d: &D) -> u32 { d.read_u32() } } @@ -158,7 +158,7 @@ impl<S:Encoder> Encodable<S> for u64 { } impl<D:Decoder> Decodable<D> for u64 { - static fn decode(&self, d: &D) -> u64 { + fn decode(d: &D) -> u64 { d.read_u64() } } @@ -168,7 +168,7 @@ impl<S:Encoder> Encodable<S> for int { } impl<D:Decoder> Decodable<D> for int { - static fn decode(&self, d: &D) -> int { + fn decode(d: &D) -> int { d.read_int() } } @@ -178,7 +178,7 @@ impl<S:Encoder> Encodable<S> for i8 { } impl<D:Decoder> Decodable<D> for i8 { - static fn decode(&self, d: &D) -> i8 { + fn decode(d: &D) -> i8 { d.read_i8() } } @@ -188,7 +188,7 @@ impl<S:Encoder> Encodable<S> for i16 { } impl<D:Decoder> Decodable<D> for i16 { - static fn decode(&self, d: &D) -> i16 { + fn decode(d: &D) -> i16 { d.read_i16() } } @@ -198,7 +198,7 @@ impl<S:Encoder> Encodable<S> for i32 { } impl<D:Decoder> Decodable<D> for i32 { - static fn decode(&self, d: &D) -> i32 { + fn decode(d: &D) -> i32 { d.read_i32() } } @@ -208,7 +208,7 @@ impl<S:Encoder> Encodable<S> for i64 { } impl<D:Decoder> Decodable<D> for i64 { - static fn decode(&self, d: &D) -> i64 { + fn decode(d: &D) -> i64 { d.read_i64() } } @@ -222,7 +222,7 @@ impl<S:Encoder> Encodable<S> for ~str { } impl<D:Decoder> Decodable<D> for ~str { - static fn decode(&self, d: &D) -> ~str { + fn decode(d: &D) -> ~str { d.read_owned_str() } } @@ -232,7 +232,7 @@ impl<S:Encoder> Encodable<S> for @str { } impl<D:Decoder> Decodable<D> for @str { - static fn decode(&self, d: &D) -> @str { + fn decode(d: &D) -> @str { d.read_managed_str() } } @@ -242,7 +242,7 @@ impl<S:Encoder> Encodable<S> for float { } impl<D:Decoder> Decodable<D> for float { - static fn decode(&self, d: &D) -> float { + fn decode(d: &D) -> float { d.read_float() } } @@ -252,7 +252,7 @@ impl<S:Encoder> Encodable<S> for f32 { } impl<D:Decoder> Decodable<D> for f32 { - static fn decode(&self, d: &D) -> f32 { + fn decode(d: &D) -> f32 { d.read_f32() } } @@ -261,7 +261,7 @@ impl<S:Encoder> Encodable<S> for f64 { } impl<D:Decoder> Decodable<D> for f64 { - static fn decode(&self, d: &D) -> f64 { + fn decode(d: &D) -> f64 { d.read_f64() } } @@ -271,7 +271,7 @@ impl<S:Encoder> Encodable<S> for bool { } impl<D:Decoder> Decodable<D> for bool { - static fn decode(&self, d: &D) -> bool { + fn decode(d: &D) -> bool { d.read_bool() } } @@ -281,7 +281,7 @@ impl<S:Encoder> Encodable<S> for () { } impl<D:Decoder> Decodable<D> for () { - static fn decode(&self, d: &D) -> () { + fn decode(d: &D) -> () { d.read_nil() } } @@ -299,7 +299,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T { } impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T { - static fn decode(&self, d: &D) -> ~T { + fn decode(d: &D) -> ~T { d.read_owned(|| ~Decodable::decode(d)) } } @@ -311,7 +311,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T { } impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T { - static fn decode(&self, d: &D) -> @T { + fn decode(d: &D) -> @T { d.read_managed(|| @Decodable::decode(d)) } } @@ -337,7 +337,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] { } impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] { - static fn decode(&self, d: &D) -> ~[T] { + fn decode(d: &D) -> ~[T] { do d.read_owned_vec |len| { do vec::from_fn(len) |i| { d.read_vec_elt(i, || Decodable::decode(d)) @@ -357,7 +357,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] { } impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] { - static fn decode(&self, d: &D) -> @[T] { + fn decode(d: &D) -> @[T] { do d.read_managed_vec |len| { do at_vec::from_fn(len) |i| { d.read_vec_elt(i, || Decodable::decode(d)) @@ -382,7 +382,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> { } impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> { - static fn decode(&self, d: &D) -> Option<T> { + fn decode(d: &D) -> Option<T> { do d.read_enum(~"option") { do d.read_enum_variant |i| { match i { @@ -410,7 +410,7 @@ impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S> for (T0, T1) { } impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D> for (T0, T1) { - static fn decode(&self, d: &D) -> (T0, T1) { + fn decode(d: &D) -> (T0, T1) { do d.read_tup(2) { ( d.read_tup_elt(0, || Decodable::decode(d)), @@ -445,7 +445,7 @@ impl< T1: Decodable<D>, T2: Decodable<D> > Decodable<D> for (T0, T1, T2) { - static fn decode(&self, d: &D) -> (T0, T1, T2) { + fn decode(d: &D) -> (T0, T1, T2) { do d.read_tup(3) { ( d.read_tup_elt(0, || Decodable::decode(d)), @@ -484,7 +484,7 @@ impl< T2: Decodable<D>, T3: Decodable<D> > Decodable<D> for (T0, T1, T2, T3) { - static fn decode(&self, d: &D) -> (T0, T1, T2, T3) { + fn decode(d: &D) -> (T0, T1, T2, T3) { do d.read_tup(4) { ( d.read_tup_elt(0, || Decodable::decode(d)), @@ -527,7 +527,7 @@ impl< T3: Decodable<D>, T4: Decodable<D> > Decodable<D> for (T0, T1, T2, T3, T4) { - static fn decode(&self, d: &D) + fn decode(d: &D) -> (T0, T1, T2, T3, T4) { do d.read_tup(5) { ( diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index dc2688a20e7..a559e7540d4 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -24,7 +24,7 @@ pub struct SmallIntMap<T> { impl<V> BaseIter<(uint, &'self V)> for SmallIntMap<V> { /// Visit all key-value pairs in order - pure fn each(&self, it: &fn(&(uint, &'self V)) -> bool) { + fn each(&self, it: &fn(&(uint, &'self V)) -> bool) { for uint::range(0, self.v.len()) |i| { match self.v[i] { Some(ref elt) => if !it(&(i, elt)) { break }, @@ -33,12 +33,12 @@ impl<V> BaseIter<(uint, &'self V)> for SmallIntMap<V> { } } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<V> ReverseIter<(uint, &'self V)> for SmallIntMap<V> { /// Visit all key-value pairs in reverse order - pure fn each_reverse(&self, it: &fn(&(uint, &'self V)) -> bool) { + fn each_reverse(&self, it: &fn(&(uint, &'self V)) -> bool) { for uint::range_rev(self.v.len(), 0) |i| { match self.v[i - 1] { Some(ref elt) => if !it(&(i - 1, elt)) { break }, @@ -50,7 +50,7 @@ impl<V> ReverseIter<(uint, &'self V)> for SmallIntMap<V> { impl<V> Container for SmallIntMap<V> { /// Return the number of elements in the map - pure fn len(&const self) -> uint { + fn len(&const self) -> uint { let mut sz = 0; for uint::range(0, vec::uniq_len(&const self.v)) |i| { match self.v[i] { @@ -62,7 +62,7 @@ impl<V> Container for SmallIntMap<V> { } /// Return true if the map contains no elements - pure fn is_empty(&const self) -> bool { self.len() == 0 } + fn is_empty(&const self) -> bool { self.len() == 0 } } impl<V> Mutable for SmallIntMap<V> { @@ -72,17 +72,17 @@ impl<V> Mutable for SmallIntMap<V> { impl<V> Map<uint, V> for SmallIntMap<V> { /// Return true if the map contains a value for the specified key - pure fn contains_key(&self, key: &uint) -> bool { + fn contains_key(&self, key: &uint) -> bool { self.find(key).is_some() } /// Visit all keys in order - pure fn each_key(&self, blk: &fn(key: &uint) -> bool) { + fn each_key(&self, blk: &fn(key: &uint) -> bool) { self.each(|&(k, _)| blk(&k)) } /// Visit all values in order - pure fn each_value(&self, blk: &fn(value: &V) -> bool) { + fn each_value(&self, blk: &fn(value: &V) -> bool) { self.each(|&(_, v)| blk(v)) } @@ -97,7 +97,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> { } /// Iterate over the map and mutate the contained values - pure fn find(&self, key: &uint) -> Option<&'self V> { + fn find(&self, key: &uint) -> Option<&'self V> { if *key < self.v.len() { match self.v[*key] { Some(ref value) => Some(value), @@ -135,9 +135,9 @@ impl<V> Map<uint, V> for SmallIntMap<V> { pub impl<V> SmallIntMap<V> { /// Create an empty SmallIntMap - static pure fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} } + fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} } - pure fn get(&self, key: &uint) -> &'self V { + fn get(&self, key: &uint) -> &'self V { self.find(key).expect("key not present") } } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index db8311ca035..8ab2c40116a 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -16,7 +16,7 @@ use core::util; use core::vec::{len, push}; use core::vec; -type Le<T> = &'self pure fn(v1: &T, v2: &T) -> bool; +type Le<T> = &'self fn(v1: &T, v2: &T) -> bool; /** * Merge sort. Returns a new vector containing the sorted list. @@ -24,7 +24,7 @@ type Le<T> = &'self pure fn(v1: &T, v2: &T) -> bool; * Has worst case O(n log n) performance, best case O(n), but * is not space efficient. This is a stable sort. */ -pub pure fn merge_sort<T:Copy>(v: &[const T], le: Le<T>) -> ~[T] { +pub fn merge_sort<T:Copy>(v: &[const T], le: Le<T>) -> ~[T] { type Slice = (uint, uint); unsafe {return merge_sort_(v, (0u, len(v)), le);} @@ -259,7 +259,7 @@ fn reverse_slice<T>(v: &mut [T], start: uint, end:uint) { } } -pure fn min_run_length(n: uint) -> uint { +fn min_run_length(n: uint) -> uint { let mut n = n; let mut r = 0; // becomes 1 if any 1 bits are shifted off @@ -290,7 +290,7 @@ fn count_run_ascending<T:Copy + Ord>(array: &mut [T]) -> uint { return run; } -pure fn gallop_left<T:Copy + Ord>(key: &const T, array: &[const T], +fn gallop_left<T:Copy + Ord>(key: &const T, array: &[const T], hint: uint) -> uint { let size = array.len(); fail_unless!(size != 0 && hint < size); @@ -339,7 +339,7 @@ pure fn gallop_left<T:Copy + Ord>(key: &const T, array: &[const T], return ofs; } -pure fn gallop_right<T:Copy + Ord>(key: &const T, array: &[const T], +fn gallop_right<T:Copy + Ord>(key: &const T, array: &[const T], hint: uint) -> uint { let size = array.len(); fail_unless!(size != 0 && hint < size); @@ -779,7 +779,7 @@ mod test_qsort { pub fn check_sort(v1: &mut [int], v2: &mut [int]) { let len = vec::len::<int>(v1); - pure fn leual(a: &int, b: &int) -> bool { *a <= *b } + fn leual(a: &int, b: &int) -> bool { *a <= *b } quick_sort::<int>(v1, leual); let mut i = 0u; while i < len { @@ -844,7 +844,7 @@ mod tests { pub fn check_sort(v1: &[int], v2: &[int]) { let len = vec::len::<int>(v1); - pub pure fn le(a: &int, b: &int) -> bool { *a <= *b } + pub fn le(a: &int, b: &int) -> bool { *a <= *b } let f = le; let v3 = merge_sort::<int>(v1, f); let mut i = 0u; @@ -874,7 +874,7 @@ mod tests { #[test] pub fn test_merge_sort_mutable() { - pub pure fn le(a: &int, b: &int) -> bool { *a <= *b } + pub fn le(a: &int, b: &int) -> bool { *a <= *b } let mut v1 = ~[3, 2, 1]; let v2 = merge_sort(v1, le); fail_unless!(v2 == ~[1, 2, 3]); @@ -883,7 +883,7 @@ mod tests { #[test] pub fn test_merge_sort_stability() { // tjc: funny that we have to use parens - pure fn ile(x: &(&'static str), y: &(&'static str)) -> bool + fn ile(x: &(&'static str), y: &(&'static str)) -> bool { unsafe // to_lower is not pure... { @@ -917,16 +917,16 @@ mod test_tim_sort { } impl Ord for CVal { - pure fn lt(&self, other: &CVal) -> bool { + fn lt(&self, other: &CVal) -> bool { unsafe { let rng = rand::Rng(); if rng.gen_float() > 0.995 { fail!(~"It's happening!!!"); } } (*self).val < other.val } - pure fn le(&self, other: &CVal) -> bool { (*self).val <= other.val } - pure fn gt(&self, other: &CVal) -> bool { (*self).val > other.val } - pure fn ge(&self, other: &CVal) -> bool { (*self).val >= other.val } + fn le(&self, other: &CVal) -> bool { (*self).val <= other.val } + fn gt(&self, other: &CVal) -> bool { (*self).val > other.val } + fn ge(&self, other: &CVal) -> bool { (*self).val >= other.val } } fn check_sort(v1: &mut [int], v2: &mut [int]) { @@ -982,10 +982,10 @@ mod test_tim_sort { struct DVal { val: uint } impl Ord for DVal { - pure fn lt(&self, _x: &DVal) -> bool { true } - pure fn le(&self, _x: &DVal) -> bool { true } - pure fn gt(&self, _x: &DVal) -> bool { true } - pure fn ge(&self, _x: &DVal) -> bool { true } + fn lt(&self, _x: &DVal) -> bool { true } + fn le(&self, _x: &DVal) -> bool { true } + fn gt(&self, _x: &DVal) -> bool { true } + fn ge(&self, _x: &DVal) -> bool { true } } #[test] @@ -1206,16 +1206,16 @@ mod big_tests { } impl Ord for LVal/&self { - pure fn lt(&self, other: &'a LVal/&self) -> bool { + fn lt(&self, other: &'a LVal/&self) -> bool { (*self).val < other.val } - pure fn le(&self, other: &'a LVal/&self) -> bool { + fn le(&self, other: &'a LVal/&self) -> bool { (*self).val <= other.val } - pure fn gt(&self, other: &'a LVal/&self) -> bool { + fn gt(&self, other: &'a LVal/&self) -> bool { (*self).val > other.val } - pure fn ge(&self, other: &'a LVal/&self) -> bool { + fn ge(&self, other: &'a LVal/&self) -> bool { (*self).val >= other.val } } diff --git a/src/libstd/task_pool.rs b/src/libstd/task_pool.rs index d8ca5559f42..16645f151ee 100644 --- a/src/libstd/task_pool.rs +++ b/src/libstd/task_pool.rs @@ -43,9 +43,10 @@ pub impl<T> TaskPool<T> { /// new scheduler with the given mode. The provided `init_fn_factory` /// returns a function which, given the index of the task, should return /// local data to be kept around in that task. - static fn new(n_tasks: uint, - opt_sched_mode: Option<SchedMode>, - init_fn_factory: ~fn() -> ~fn(uint) -> T) -> TaskPool<T> { + fn new(n_tasks: uint, + opt_sched_mode: Option<SchedMode>, + init_fn_factory: ~fn() -> ~fn(uint) -> T) + -> TaskPool<T> { fail_unless!(n_tasks >= 1); let channels = do vec::from_fn(n_tasks) |i| { diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 1829e29826f..7531992ae84 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -53,7 +53,7 @@ pub enum TestName { DynTestName(~str) } impl ToStr for TestName { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match self { &StaticTestName(s) => s.to_str(), &DynTestName(s) => s.to_str() @@ -536,7 +536,7 @@ pub fn filter_tests( }; // Sort the tests alphabetically - pure fn lteq(t1: &TestDescAndFn, t2: &TestDescAndFn) -> bool { + fn lteq(t1: &TestDescAndFn, t2: &TestDescAndFn) -> bool { str::le(t1.desc.name.to_str(), t2.desc.name.to_str()) } sort::quick_sort(filtered, lteq); diff --git a/src/libstd/time.rs b/src/libstd/time.rs index c72b3675c4c..b46d58f891b 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -51,27 +51,27 @@ pub struct Timespec { sec: i64, nsec: i32 } * nsec: 800_000_000_i32 }`. */ pub impl Timespec { - static pure fn new(sec: i64, nsec: i32) -> Timespec { + fn new(sec: i64, nsec: i32) -> Timespec { fail_unless!(nsec >= 0 && nsec < NSEC_PER_SEC); Timespec { sec: sec, nsec: nsec } } } impl Eq for Timespec { - pure fn eq(&self, other: &Timespec) -> bool { + fn eq(&self, other: &Timespec) -> bool { self.sec == other.sec && self.nsec == other.nsec } - pure fn ne(&self, other: &Timespec) -> bool { !self.eq(other) } + fn ne(&self, other: &Timespec) -> bool { !self.eq(other) } } impl Ord for Timespec { - pure fn lt(&self, other: &Timespec) -> bool { + fn lt(&self, other: &Timespec) -> bool { self.sec < other.sec || (self.sec == other.sec && self.nsec < other.nsec) } - pure fn le(&self, other: &Timespec) -> bool { !other.lt(self) } - pure fn ge(&self, other: &Timespec) -> bool { !self.lt(other) } - pure fn gt(&self, other: &Timespec) -> bool { !self.le(other) } + fn le(&self, other: &Timespec) -> bool { !other.lt(self) } + fn ge(&self, other: &Timespec) -> bool { !self.lt(other) } + fn gt(&self, other: &Timespec) -> bool { !self.le(other) } } /** @@ -133,7 +133,7 @@ pub struct Tm { } impl Eq for Tm { - pure fn eq(&self, other: &Tm) -> bool { + fn eq(&self, other: &Tm) -> bool { self.tm_sec == (*other).tm_sec && self.tm_min == (*other).tm_min && self.tm_hour == (*other).tm_hour && @@ -147,10 +147,10 @@ impl Eq for Tm { self.tm_zone == (*other).tm_zone && self.tm_nsec == (*other).tm_nsec } - pure fn ne(&self, other: &Tm) -> bool { !self.eq(other) } + fn ne(&self, other: &Tm) -> bool { !self.eq(other) } } -pub pure fn empty_tm() -> Tm { +pub fn empty_tm() -> Tm { Tm { tm_sec: 0_i32, tm_min: 0_i32, @@ -198,14 +198,14 @@ pub fn now() -> Tm { } /// Parses the time from the string according to the format string. -pub pure fn strptime(s: &str, format: &str) -> Result<Tm, ~str> { +pub fn strptime(s: &str, format: &str) -> Result<Tm, ~str> { // unsafe only because do_strptime is annoying to make pure // (it does IO with a str_reader) unsafe {do_strptime(s, format)} } /// Formats the time according to the format string. -pub pure fn strftime(format: &str, tm: &Tm) -> ~str { +pub fn strftime(format: &str, tm: &Tm) -> ~str { // unsafe only because do_strftime is annoying to make pure // (it does IO with a str_reader) unsafe { do_strftime(format, tm) } @@ -239,10 +239,10 @@ pub impl Tm { * Return a string of the current time in the form * "Thu Jan 1 00:00:00 1970". */ - pure fn ctime(&self) -> ~str { self.strftime(~"%c") } + fn ctime(&self) -> ~str { self.strftime(~"%c") } /// Formats the time according to the format string. - pure fn strftime(&self, format: &str) -> ~str { + fn strftime(&self, format: &str) -> ~str { strftime(format, self) } @@ -252,7 +252,7 @@ pub impl Tm { * local: "Thu, 22 Mar 2012 07:53:18 PST" * utc: "Thu, 22 Mar 2012 14:53:18 UTC" */ - pure fn rfc822(&self) -> ~str { + fn rfc822(&self) -> ~str { if self.tm_gmtoff == 0_i32 { self.strftime(~"%a, %d %b %Y %T GMT") } else { @@ -266,7 +266,7 @@ pub impl Tm { * local: "Thu, 22 Mar 2012 07:53:18 -0700" * utc: "Thu, 22 Mar 2012 14:53:18 -0000" */ - pure fn rfc822z(&self) -> ~str { + fn rfc822z(&self) -> ~str { self.strftime(~"%a, %d %b %Y %T %z") } @@ -276,7 +276,7 @@ pub impl Tm { * local: "2012-02-22T07:53:18-07:00" * utc: "2012-02-22T14:53:18Z" */ - pure fn rfc3339(&self) -> ~str { + fn rfc3339(&self) -> ~str { if self.tm_gmtoff == 0_i32 { self.strftime(~"%Y-%m-%dT%H:%M:%SZ") } else { diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index f4d58568ae7..e42c6590724 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -36,7 +36,7 @@ pub struct TreeMap<K, V> { } impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> { - pure fn eq(&self, other: &TreeMap<K, V>) -> bool { + fn eq(&self, other: &TreeMap<K, V>) -> bool { if self.len() != other.len() { false } else { @@ -53,11 +53,11 @@ impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> { true } } - pure fn ne(&self, other: &TreeMap<K, V>) -> bool { !self.eq(other) } + fn ne(&self, other: &TreeMap<K, V>) -> bool { !self.eq(other) } } // Lexicographical comparison -pure fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>, +fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>, b: &TreeMap<K, V>) -> bool { let mut x = a.iter(); let mut y = b.iter(); @@ -77,21 +77,21 @@ pure fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>, impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> { #[inline(always)] - pure fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) } + fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) } #[inline(always)] - pure fn le(&self, other: &TreeMap<K, V>) -> bool { !lt(other, self) } + fn le(&self, other: &TreeMap<K, V>) -> bool { !lt(other, self) } #[inline(always)] - pure fn ge(&self, other: &TreeMap<K, V>) -> bool { !lt(self, other) } + fn ge(&self, other: &TreeMap<K, V>) -> bool { !lt(self, other) } #[inline(always)] - pure fn gt(&self, other: &TreeMap<K, V>) -> bool { lt(other, self) } + fn gt(&self, other: &TreeMap<K, V>) -> bool { lt(other, self) } } impl<'self, K: TotalOrd, V> BaseIter<(&'self K, &'self V)> for TreeMap<K, V> { /// Visit all key-value pairs in order - pure fn each(&self, f: &fn(&(&'self K, &'self V)) -> bool) { + fn each(&self, f: &fn(&(&'self K, &'self V)) -> bool) { each(&self.root, f) } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<'self, K: TotalOrd, V> @@ -99,17 +99,17 @@ impl<'self, K: TotalOrd, V> for TreeMap<K, V> { /// Visit all key-value pairs in reverse order - pure fn each_reverse(&self, f: &fn(&(&'self K, &'self V)) -> bool) { + fn each_reverse(&self, f: &fn(&(&'self K, &'self V)) -> bool) { each_reverse(&self.root, f); } } impl<K: TotalOrd, V> Container for TreeMap<K, V> { /// Return the number of elements in the map - pure fn len(&const self) -> uint { self.length } + fn len(&const self) -> uint { self.length } /// Return true if the map contains no elements - pure fn is_empty(&const self) -> bool { self.root.is_none() } + fn is_empty(&const self) -> bool { self.root.is_none() } } impl<K: TotalOrd, V> Mutable for TreeMap<K, V> { @@ -122,15 +122,15 @@ impl<K: TotalOrd, V> Mutable for TreeMap<K, V> { impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> { /// Return true if the map contains a value for the specified key - pure fn contains_key(&self, key: &K) -> bool { + fn contains_key(&self, key: &K) -> bool { self.find(key).is_some() } /// Visit all keys in order - pure fn each_key(&self, f: &fn(&K) -> bool) { self.each(|&(k, _)| f(k)) } + fn each_key(&self, f: &fn(&K) -> bool) { self.each(|&(k, _)| f(k)) } /// Visit all values in order - pure fn each_value(&self, f: &fn(&V) -> bool) { + fn each_value(&self, f: &fn(&V) -> bool) { self.each(|&(_, v)| f(v)) } @@ -140,7 +140,7 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> { } /// Return the value corresponding to the key in the map - pure fn find(&self, key: &K) -> Option<&'self V> { + fn find(&self, key: &K) -> Option<&'self V> { let mut current: &'self Option<~TreeNode<K, V>> = &self.root; loop { match *current { @@ -176,21 +176,21 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> { pub impl<K: TotalOrd, V> TreeMap<K, V> { /// Create an empty TreeMap - static pure fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} } + fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} } /// Visit all keys in reverse order - pure fn each_key_reverse(&self, f: &fn(&K) -> bool) { + fn each_key_reverse(&self, f: &fn(&K) -> bool) { self.each_reverse(|&(k, _)| f(k)) } /// Visit all values in reverse order - pure fn each_value_reverse(&self, f: &fn(&V) -> bool) { + fn each_value_reverse(&self, f: &fn(&V) -> bool) { self.each_reverse(|&(_, v)| f(v)) } /// Get a lazy iterator over the key-value pairs in the map. /// Requires that it be frozen (immutable). - pure fn iter(&self) -> TreeMapIterator/&self<K, V> { + fn iter(&self) -> TreeMapIterator/&self<K, V> { TreeMapIterator{stack: ~[], node: &self.root} } } @@ -242,45 +242,45 @@ pub struct TreeSet<T> { impl<T: TotalOrd> BaseIter<T> for TreeSet<T> { /// Visit all values in order #[inline(always)] - pure fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) } + fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) } #[inline(always)] - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<T: TotalOrd> ReverseIter<T> for TreeSet<T> { /// Visit all values in reverse order #[inline(always)] - pure fn each_reverse(&self, f: &fn(&T) -> bool) { + fn each_reverse(&self, f: &fn(&T) -> bool) { self.map.each_key_reverse(f) } } impl<T: Eq + TotalOrd> Eq for TreeSet<T> { #[inline(always)] - pure fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map } + fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map } #[inline(always)] - pure fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map } + fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map } } impl<T: Ord + TotalOrd> Ord for TreeSet<T> { #[inline(always)] - pure fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map } + fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map } #[inline(always)] - pure fn le(&self, other: &TreeSet<T>) -> bool { self.map <= other.map } + fn le(&self, other: &TreeSet<T>) -> bool { self.map <= other.map } #[inline(always)] - pure fn ge(&self, other: &TreeSet<T>) -> bool { self.map >= other.map } + fn ge(&self, other: &TreeSet<T>) -> bool { self.map >= other.map } #[inline(always)] - pure fn gt(&self, other: &TreeSet<T>) -> bool { self.map > other.map } + fn gt(&self, other: &TreeSet<T>) -> bool { self.map > other.map } } impl<T: TotalOrd> Container for TreeSet<T> { /// Return the number of elements in the set #[inline(always)] - pure fn len(&const self) -> uint { self.map.len() } + fn len(&const self) -> uint { self.map.len() } /// Return true if the set contains no elements #[inline(always)] - pure fn is_empty(&const self) -> bool { self.map.is_empty() } + fn is_empty(&const self) -> bool { self.map.is_empty() } } impl<T: TotalOrd> Mutable for TreeSet<T> { @@ -292,7 +292,7 @@ impl<T: TotalOrd> Mutable for TreeSet<T> { impl<T: TotalOrd> Set<T> for TreeSet<T> { /// Return true if the set contains a value #[inline(always)] - pure fn contains(&self, value: &T) -> bool { + fn contains(&self, value: &T) -> bool { self.map.contains_key(value) } @@ -308,7 +308,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { /// Return true if the set has no elements in common with `other`. /// This is equivalent to checking for an empty intersection. - pure fn is_disjoint(&self, other: &TreeSet<T>) -> bool { + fn is_disjoint(&self, other: &TreeSet<T>) -> bool { let mut x = self.iter(); let mut y = other.iter(); unsafe { // purity workaround @@ -329,12 +329,12 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { /// Return true if the set is a subset of another #[inline(always)] - pure fn is_subset(&self, other: &TreeSet<T>) -> bool { + fn is_subset(&self, other: &TreeSet<T>) -> bool { other.is_superset(self) } /// Return true if the set is a superset of another - pure fn is_superset(&self, other: &TreeSet<T>) -> bool { + fn is_superset(&self, other: &TreeSet<T>) -> bool { let mut x = self.iter(); let mut y = other.iter(); unsafe { // purity workaround @@ -361,7 +361,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { } /// Visit the values (in-order) representing the difference - pure fn difference(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { + fn difference(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { let mut x = self.iter(); let mut y = other.iter(); @@ -393,7 +393,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { } /// Visit the values (in-order) representing the symmetric difference - pure fn symmetric_difference(&self, other: &TreeSet<T>, + fn symmetric_difference(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { let mut x = self.iter(); let mut y = other.iter(); @@ -433,7 +433,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { } /// Visit the values (in-order) representing the intersection - pure fn intersection(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { + fn intersection(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { let mut x = self.iter(); let mut y = other.iter(); @@ -460,7 +460,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { } /// Visit the values (in-order) representing the union - pure fn union(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { + fn union(&self, other: &TreeSet<T>, f: &fn(&T) -> bool) { let mut x = self.iter(); let mut y = other.iter(); @@ -501,12 +501,12 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> { pub impl <T: TotalOrd> TreeSet<T> { /// Create an empty TreeSet #[inline(always)] - static pure fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} } + fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} } /// Get a lazy iterator over the values in the set. /// Requires that it be frozen (immutable). #[inline(always)] - pure fn iter(&self) -> TreeSetIterator/&self<T> { + fn iter(&self) -> TreeSetIterator/&self<T> { TreeSetIterator{iter: self.map.iter()} } } @@ -542,12 +542,12 @@ struct TreeNode<K, V> { pub impl<K: TotalOrd, V> TreeNode<K, V> { #[inline(always)] - static pure fn new(key: K, value: V) -> TreeNode<K, V> { + fn new(key: K, value: V) -> TreeNode<K, V> { TreeNode{key: key, value: value, left: None, right: None, level: 1} } } -pure fn each<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, +fn each<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, f: &fn(&(&'r K, &'r V)) -> bool) { for node.each |x| { each(&x.left, f); @@ -555,7 +555,7 @@ pure fn each<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, } } -pure fn each_reverse<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, +fn each_reverse<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, f: &fn(&(&'r K, &'r V)) -> bool) { for node.each |x| { each_reverse(&x.right, f); diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index b3581e2690c..f22bdaff3a0 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -173,12 +173,12 @@ pub mod icu { } } -pub pure fn is_XID_start(c: char) -> bool { +pub fn is_XID_start(c: char) -> bool { return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START) == icu::TRUE; } -pub pure fn is_XID_continue(c: char) -> bool { +pub fn is_XID_continue(c: char) -> bool { return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START) == icu::TRUE; } @@ -188,7 +188,7 @@ Function: is_digit Returns true if a character is a digit. */ -pub pure fn is_digit(c: char) -> bool { +pub fn is_digit(c: char) -> bool { return icu::libicu::u_isdigit(c) == icu::TRUE; } @@ -197,7 +197,7 @@ Function: is_lower Returns true if a character is a lowercase letter. */ -pub pure fn is_lower(c: char) -> bool { +pub fn is_lower(c: char) -> bool { return icu::libicu::u_islower(c) == icu::TRUE; } @@ -206,7 +206,7 @@ Function: is_space Returns true if a character is space. */ -pub pure fn is_space(c: char) -> bool { +pub fn is_space(c: char) -> bool { return icu::libicu::u_isspace(c) == icu::TRUE; } @@ -215,7 +215,7 @@ Function: is_upper Returns true if a character is an uppercase letter. */ -pub pure fn is_upper(c: char) -> bool { +pub fn is_upper(c: char) -> bool { return icu::libicu::u_isupper(c) == icu::TRUE; } diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs index f8b4337e437..b26b4b1c333 100644 --- a/src/libstd/workcache.rs +++ b/src/libstd/workcache.rs @@ -106,7 +106,7 @@ struct WorkKey { impl to_bytes::IterBytes for WorkKey { #[inline(always)] - pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { let mut flag = true; self.kind.iter_bytes(lsb0, |bytes| {flag = f(bytes); flag}); if !flag { return; } @@ -115,24 +115,24 @@ impl to_bytes::IterBytes for WorkKey { } impl cmp::Ord for WorkKey { - pure fn lt(&self, other: &WorkKey) -> bool { + fn lt(&self, other: &WorkKey) -> bool { self.kind < other.kind || (self.kind == other.kind && self.name < other.name) } - pure fn le(&self, other: &WorkKey) -> bool { + fn le(&self, other: &WorkKey) -> bool { self.lt(other) || self.eq(other) } - pure fn ge(&self, other: &WorkKey) -> bool { + fn ge(&self, other: &WorkKey) -> bool { self.gt(other) || self.eq(other) } - pure fn gt(&self, other: &WorkKey) -> bool { + fn gt(&self, other: &WorkKey) -> bool { ! self.le(other) } } pub impl WorkKey { - static fn new(kind: &str, name: &str) -> WorkKey { + fn new(kind: &str, name: &str) -> WorkKey { WorkKey { kind: kind.to_owned(), name: name.to_owned() } } } @@ -151,7 +151,7 @@ impl<S:Encoder> Encodable<S> for WorkMap { } impl<D:Decoder> Decodable<D> for WorkMap { - static fn decode(&self, d: &D) -> WorkMap { + fn decode(d: &D) -> WorkMap { let v : ~[(WorkKey,~str)] = Decodable::decode(d); let mut w = LinearMap::new(); for v.each |&(k, v)| { @@ -258,7 +258,7 @@ fn digest_file(path: &Path) -> ~str { pub impl Context { - static fn new(db: @Mut<Database>, + fn new(db: @Mut<Database>, lg: @Mut<Logger>, cfg: @json::Object) -> Context { Context{db: db, logger: lg, cfg: cfg, freshness: LinearMap::new()} @@ -367,7 +367,7 @@ impl TPrep for @Mut<Prep> { pub impl<T:Owned + Encodable<json::Encoder> + Decodable<json::Decoder/&static>> Work<T> { // FIXME(#5121) - static fn new(p: @Mut<Prep>, e: Either<T,PortOne<(Exec,T)>>) -> Work<T> { + fn new(p: @Mut<Prep>, e: Either<T,PortOne<(Exec,T)>>) -> Work<T> { Work { prep: p, res: Some(e) } } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index cbdcef3eff6..c37d9d1c1c4 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -75,7 +75,7 @@ impl<S:Encoder> Encodable<S> for ident { } impl<D:Decoder> Decodable<D> for ident { - static fn decode(d: &D) -> ident { + fn decode(d: &D) -> ident { let intr = match unsafe { task::local_data::local_data_get(interner_key!()) } { @@ -88,7 +88,7 @@ impl<D:Decoder> Decodable<D> for ident { } impl to_bytes::IterBytes for ident { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.repr.iter_bytes(lsb0, f) } } @@ -274,7 +274,7 @@ pub enum binding_mode { } impl to_bytes::IterBytes for binding_mode { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { bind_by_copy => 0u8.iter_bytes(lsb0, f), @@ -320,7 +320,7 @@ pub enum pat_ { pub enum mutability { m_mutbl, m_imm, m_const, } impl to_bytes::IterBytes for mutability { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -333,13 +333,13 @@ pub enum Abi { } impl to_bytes::IterBytes for Abi { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } impl ToStr for Abi { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { RustAbi => ~"\"rust\"" } @@ -356,13 +356,13 @@ pub enum Sigil { } impl to_bytes::IterBytes for Sigil { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } impl ToStr for Sigil { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { BorrowedSigil => ~"&", OwnedSigil => ~"~", @@ -440,7 +440,7 @@ pub enum inferable<T> { } impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { expl(ref t) => to_bytes::iter_bytes_2(&0u8, t, lsb0, f), @@ -458,7 +458,7 @@ impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> { pub enum rmode { by_ref, by_copy } impl to_bytes::IterBytes for rmode { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -796,13 +796,13 @@ pub enum trait_method { pub enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, } impl ToStr for int_ty { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { ::ast_util::int_ty_to_str(*self) } } impl to_bytes::IterBytes for int_ty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -813,13 +813,13 @@ impl to_bytes::IterBytes for int_ty { pub enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, } impl ToStr for uint_ty { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { ::ast_util::uint_ty_to_str(*self) } } impl to_bytes::IterBytes for uint_ty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -830,13 +830,13 @@ impl to_bytes::IterBytes for uint_ty { pub enum float_ty { ty_f, ty_f32, ty_f64, } impl ToStr for float_ty { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { ::ast_util::float_ty_to_str(*self) } } impl to_bytes::IterBytes for float_ty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -872,7 +872,7 @@ pub enum Onceness { } impl ToStr for Onceness { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { Once => ~"once", Many => ~"many" @@ -881,7 +881,7 @@ impl ToStr for Onceness { } impl to_bytes::IterBytes for Onceness { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); } } @@ -930,7 +930,7 @@ pub enum ty_ { } impl to_bytes::IterBytes for Ty { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f); } } @@ -966,7 +966,7 @@ pub enum purity { } impl ToStr for purity { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { impure_fn => ~"impure", unsafe_fn => ~"unsafe", @@ -977,7 +977,7 @@ impl ToStr for purity { } impl to_bytes::IterBytes for purity { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -992,7 +992,7 @@ pub enum ret_style { } impl to_bytes::IterBytes for ret_style { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -1278,7 +1278,7 @@ pub enum item_ { pub enum struct_mutability { struct_mutable, struct_immutable } impl to_bytes::IterBytes for struct_mutability { - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 9371055556e..8989bb88cd7 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -33,7 +33,7 @@ pub enum path_elt { } impl cmp::Eq for path_elt { - pure fn eq(&self, other: &path_elt) -> bool { + fn eq(&self, other: &path_elt) -> bool { match (*self) { path_mod(e0a) => { match (*other) { @@ -49,7 +49,7 @@ impl cmp::Eq for path_elt { } } } - pure fn ne(&self, other: &path_elt) -> bool { !(*self).eq(other) } + fn ne(&self, other: &path_elt) -> bool { !(*self).eq(other) } } pub type path = ~[path_elt]; diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 1225e71cb8c..764393e0feb 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -24,22 +24,21 @@ use core::str; use core::to_bytes; use core::vec; -pub pure fn path_name_i(idents: &[ident], intr: @token::ident_interner) - -> ~str { +pub fn path_name_i(idents: &[ident], intr: @token::ident_interner) -> ~str { // FIXME: Bad copies (#2543 -- same for everything else that says "bad") str::connect(idents.map(|i| copy *intr.get(*i)), ~"::") } -pub pure fn path_to_ident(p: @path) -> ident { copy *p.idents.last() } +pub fn path_to_ident(p: @path) -> ident { copy *p.idents.last() } -pub pure fn local_def(id: node_id) -> def_id { +pub fn local_def(id: node_id) -> def_id { ast::def_id { crate: local_crate, node: id } } -pub pure fn is_local(did: ast::def_id) -> bool { did.crate == local_crate } +pub fn is_local(did: ast::def_id) -> bool { did.crate == local_crate } -pub pure fn stmt_id(s: stmt) -> node_id { +pub fn stmt_id(s: stmt) -> node_id { match s.node { stmt_decl(_, id) => id, stmt_expr(_, id) => id, @@ -57,7 +56,7 @@ pub fn variant_def_ids(d: def) -> (def_id, def_id) { } } -pub pure fn def_id_of_def(d: def) -> def_id { +pub fn def_id_of_def(d: def) -> def_id { match d { def_fn(id, _) | def_static_method(id, _, _) | def_mod(id) | def_foreign_mod(id) | def_const(id) | @@ -75,7 +74,7 @@ pub pure fn def_id_of_def(d: def) -> def_id { } } -pub pure fn binop_to_str(op: binop) -> ~str { +pub fn binop_to_str(op: binop) -> ~str { match op { add => return ~"+", subtract => return ~"-", @@ -98,7 +97,7 @@ pub pure fn binop_to_str(op: binop) -> ~str { } } -pub pure fn binop_to_method_name(op: binop) -> Option<~str> { +pub fn binop_to_method_name(op: binop) -> Option<~str> { match op { add => return Some(~"add"), subtract => return Some(~"sub"), @@ -120,7 +119,7 @@ pub pure fn binop_to_method_name(op: binop) -> Option<~str> { } } -pub pure fn lazy_binop(b: binop) -> bool { +pub fn lazy_binop(b: binop) -> bool { match b { and => true, or => true, @@ -128,7 +127,7 @@ pub pure fn lazy_binop(b: binop) -> bool { } } -pub pure fn is_shift_binop(b: binop) -> bool { +pub fn is_shift_binop(b: binop) -> bool { match b { shl => true, shr => true, @@ -136,7 +135,7 @@ pub pure fn is_shift_binop(b: binop) -> bool { } } -pub pure fn unop_to_str(op: unop) -> ~str { +pub fn unop_to_str(op: unop) -> ~str { match op { box(mt) => if mt == m_mutbl { ~"@mut " } else { ~"@" }, uniq(mt) => if mt == m_mutbl { ~"~mut " } else { ~"~" }, @@ -146,11 +145,11 @@ pub pure fn unop_to_str(op: unop) -> ~str { } } -pub pure fn is_path(e: @expr) -> bool { +pub fn is_path(e: @expr) -> bool { return match e.node { expr_path(_) => true, _ => false }; } -pub pure fn int_ty_to_str(t: int_ty) -> ~str { +pub fn int_ty_to_str(t: int_ty) -> ~str { match t { ty_char => ~"u8", // ??? ty_i => ~"", @@ -161,7 +160,7 @@ pub pure fn int_ty_to_str(t: int_ty) -> ~str { } } -pub pure fn int_ty_max(t: int_ty) -> u64 { +pub fn int_ty_max(t: int_ty) -> u64 { match t { ty_i8 => 0x80u64, ty_i16 => 0x8000u64, @@ -170,7 +169,7 @@ pub pure fn int_ty_max(t: int_ty) -> u64 { } } -pub pure fn uint_ty_to_str(t: uint_ty) -> ~str { +pub fn uint_ty_to_str(t: uint_ty) -> ~str { match t { ty_u => ~"u", ty_u8 => ~"u8", @@ -180,7 +179,7 @@ pub pure fn uint_ty_to_str(t: uint_ty) -> ~str { } } -pub pure fn uint_ty_max(t: uint_ty) -> u64 { +pub fn uint_ty_max(t: uint_ty) -> u64 { match t { ty_u8 => 0xffu64, ty_u16 => 0xffffu64, @@ -189,18 +188,18 @@ pub pure fn uint_ty_max(t: uint_ty) -> u64 { } } -pub pure fn float_ty_to_str(t: float_ty) -> ~str { +pub fn float_ty_to_str(t: float_ty) -> ~str { match t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" } } -pub pure fn is_call_expr(e: @expr) -> bool { +pub fn is_call_expr(e: @expr) -> bool { match e.node { expr_call(_, _, _) => true, _ => false } } // This makes def_id hashable impl to_bytes::IterBytes for def_id { #[inline(always)] - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f); } } @@ -238,14 +237,14 @@ pub fn ident_to_pat(id: node_id, s: span, +i: ident) -> @pat { span: s } } -pub pure fn is_unguarded(a: &arm) -> bool { +pub fn is_unguarded(a: &arm) -> bool { match a.guard { None => true, _ => false } } -pub pure fn unguarded_pat(a: &arm) -> Option<~[@pat]> { +pub fn unguarded_pat(a: &arm) -> Option<~[@pat]> { if is_unguarded(a) { Some(/* FIXME (#2543) */ copy a.pats) } else { None } } @@ -290,7 +289,7 @@ pub fn split_trait_methods(trait_methods: &[trait_method]) (reqd, provd) } -pub pure fn struct_field_visibility(field: ast::struct_field) -> visibility { +pub fn struct_field_visibility(field: ast::struct_field) -> visibility { match field.node.kind { ast::named_field(_, _, visibility) => visibility, ast::unnamed_field => ast::public @@ -509,7 +508,7 @@ pub fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range { compute_id_range(|f| visit_ids_for_inlined_item(item, f)) } -pub pure fn is_item_impl(item: @ast::item) -> bool { +pub fn is_item_impl(item: @ast::item) -> bool { match item.node { item_impl(*) => true, _ => false diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index a410d6cf8e3..b22d71afaed 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -89,11 +89,11 @@ pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute { /* Accessors */ -pub pure fn get_attr_name(attr: &ast::attribute) -> @~str { +pub fn get_attr_name(attr: &ast::attribute) -> @~str { get_meta_item_name(attr.node.value) } -pub pure fn get_meta_item_name(meta: @ast::meta_item) -> @~str { +pub fn get_meta_item_name(meta: @ast::meta_item) -> @~str { match meta.node { ast::meta_word(n) => n, ast::meta_name_value(n, _) => n, @@ -333,10 +333,10 @@ pub enum inline_attr { } impl cmp::Eq for inline_attr { - pure fn eq(&self, other: &inline_attr) -> bool { + fn eq(&self, other: &inline_attr) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &inline_attr) -> bool { !(*self).eq(other) } + fn ne(&self, other: &inline_attr) -> bool { !(*self).eq(other) } } /// True if something like #[inline] is found in the list of attrs. diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index c84e3abf50b..c082f4c0838 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -30,8 +30,8 @@ use core::uint; use std::serialize::{Encodable, Decodable, Encoder, Decoder}; pub trait Pos { - static pure fn from_uint(n: uint) -> Self; - pure fn to_uint(&self) -> uint; + fn from_uint(n: uint) -> Self; + fn to_uint(&self) -> uint; } /// A byte offset @@ -45,71 +45,71 @@ pub struct CharPos(uint); // have been unsuccessful impl Pos for BytePos { - static pure fn from_uint(n: uint) -> BytePos { BytePos(n) } - pure fn to_uint(&self) -> uint { **self } + fn from_uint(n: uint) -> BytePos { BytePos(n) } + fn to_uint(&self) -> uint { **self } } impl cmp::Eq for BytePos { - pure fn eq(&self, other: &BytePos) -> bool { **self == **other } - pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) } + fn eq(&self, other: &BytePos) -> bool { **self == **other } + fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) } } impl cmp::Ord for BytePos { - pure fn lt(&self, other: &BytePos) -> bool { **self < **other } - pure fn le(&self, other: &BytePos) -> bool { **self <= **other } - pure fn ge(&self, other: &BytePos) -> bool { **self >= **other } - pure fn gt(&self, other: &BytePos) -> bool { **self > **other } + fn lt(&self, other: &BytePos) -> bool { **self < **other } + fn le(&self, other: &BytePos) -> bool { **self <= **other } + fn ge(&self, other: &BytePos) -> bool { **self >= **other } + fn gt(&self, other: &BytePos) -> bool { **self > **other } } impl Add<BytePos, BytePos> for BytePos { - pure fn add(&self, rhs: &BytePos) -> BytePos { + fn add(&self, rhs: &BytePos) -> BytePos { BytePos(**self + **rhs) } } impl Sub<BytePos, BytePos> for BytePos { - pure fn sub(&self, rhs: &BytePos) -> BytePos { + fn sub(&self, rhs: &BytePos) -> BytePos { BytePos(**self - **rhs) } } impl to_bytes::IterBytes for BytePos { - pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } impl Pos for CharPos { - static pure fn from_uint(n: uint) -> CharPos { CharPos(n) } - pure fn to_uint(&self) -> uint { **self } + fn from_uint(n: uint) -> CharPos { CharPos(n) } + fn to_uint(&self) -> uint { **self } } impl cmp::Eq for CharPos { - pure fn eq(&self, other: &CharPos) -> bool { **self == **other } - pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) } + fn eq(&self, other: &CharPos) -> bool { **self == **other } + fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) } } impl cmp::Ord for CharPos { - pure fn lt(&self, other: &CharPos) -> bool { **self < **other } - pure fn le(&self, other: &CharPos) -> bool { **self <= **other } - pure fn ge(&self, other: &CharPos) -> bool { **self >= **other } - pure fn gt(&self, other: &CharPos) -> bool { **self > **other } + fn lt(&self, other: &CharPos) -> bool { **self < **other } + fn le(&self, other: &CharPos) -> bool { **self <= **other } + fn ge(&self, other: &CharPos) -> bool { **self >= **other } + fn gt(&self, other: &CharPos) -> bool { **self > **other } } impl to_bytes::IterBytes for CharPos { - pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } impl Add<CharPos,CharPos> for CharPos { - pure fn add(&self, rhs: &CharPos) -> CharPos { + fn add(&self, rhs: &CharPos) -> CharPos { CharPos(**self + **rhs) } } impl Sub<CharPos,CharPos> for CharPos { - pure fn sub(&self, rhs: &CharPos) -> CharPos { + fn sub(&self, rhs: &CharPos) -> CharPos { CharPos(**self - **rhs) } } @@ -132,10 +132,10 @@ pub struct span { pub struct spanned<T> { node: T, span: span } impl cmp::Eq for span { - pure fn eq(&self, other: &span) -> bool { + fn eq(&self, other: &span) -> bool { return (*self).lo == (*other).lo && (*self).hi == (*other).hi; } - pure fn ne(&self, other: &span) -> bool { !(*self).eq(other) } + fn ne(&self, other: &span) -> bool { !(*self).eq(other) } } impl<S:Encoder> Encodable<S> for span { @@ -144,30 +144,30 @@ impl<S:Encoder> Encodable<S> for span { } impl<D:Decoder> Decodable<D> for span { - static fn decode(_d: &D) -> span { + fn decode(_d: &D) -> span { dummy_sp() } } -pub pure fn spanned<T>(+lo: BytePos, +hi: BytePos, +t: T) -> spanned<T> { +pub fn spanned<T>(+lo: BytePos, +hi: BytePos, +t: T) -> spanned<T> { respan(mk_sp(lo, hi), t) } -pub pure fn respan<T>(sp: span, +t: T) -> spanned<T> { +pub fn respan<T>(sp: span, +t: T) -> spanned<T> { spanned {node: t, span: sp} } -pub pure fn dummy_spanned<T>(+t: T) -> spanned<T> { +pub fn dummy_spanned<T>(+t: T) -> spanned<T> { respan(dummy_sp(), t) } /* assuming that we're not in macro expansion */ -pub pure fn mk_sp(+lo: BytePos, +hi: BytePos) -> span { +pub fn mk_sp(+lo: BytePos, +hi: BytePos) -> span { span {lo: lo, hi: hi, expn_info: None} } // make this a const, once the compiler supports it -pub pure fn dummy_sp() -> span { return mk_sp(BytePos(0), BytePos(0)); } +pub fn dummy_sp() -> span { return mk_sp(BytePos(0), BytePos(0)); } @@ -286,7 +286,7 @@ pub struct CodeMap { } pub impl CodeMap { - static pub fn new() -> CodeMap { + pub fn new() -> CodeMap { CodeMap { files: @mut ~[], } diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index e5f818eef5c..54ca5dc0d72 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -32,7 +32,7 @@ impl<S:std::serialize::Encoder> Encodable<S> for Node { } impl<D:Decoder> Decodable for node_id { - static fn decode(d: &D) -> Node { + fn decode(d: &D) -> Node { do d.read_struct("Node", 1) { Node { id: d.read_field(~"x", 0, || decode(d)) @@ -66,7 +66,7 @@ would yield functions like: D: Decoder, T: Decodable<D> > spanned<T>: Decodable<D> { - static fn decode(d: &D) -> spanned<T> { + fn decode(d: &D) -> spanned<T> { do d.read_rec { { node: d.read_field(~"node", 0, || decode(d)), diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 50f89d37fae..d93a997213d 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -231,7 +231,7 @@ pub trait ext_ctxt { fn span_bug(@mut self, sp: span, msg: &str) -> !; fn bug(@mut self, msg: &str) -> !; fn next_id(@mut self) -> ast::node_id; - pure fn trace_macros(@mut self) -> bool; + fn trace_macros(@mut self) -> bool; fn set_trace_macros(@mut self, x: bool); /* for unhygienic identifier transformation */ fn str_of(@mut self, id: ast::ident) -> ~str; @@ -310,7 +310,7 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, +cfg: ast::crate_cfg) fn next_id(@mut self) -> ast::node_id { return parse::next_node_id(self.parse_sess); } - pure fn trace_macros(@mut self) -> bool { + fn trace_macros(@mut self) -> bool { self.trace_mac } fn set_trace_macros(@mut self, x: bool) { @@ -439,7 +439,7 @@ pub enum MapChain<K,V> { impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{ // Constructor. I don't think we need a zero-arg one. - static fn new(+init: ~LinearMap<K,@V>) -> @mut MapChain<K,V> { + fn new(+init: ~LinearMap<K,@V>) -> @mut MapChain<K,V> { @mut BaseMapChain(init) } @@ -464,7 +464,7 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{ // traits just don't work anywhere...? //pub impl Map<Name,SyntaxExtension> for MapChain { - pure fn contains_key (&self, key: &K) -> bool { + fn contains_key (&self, key: &K) -> bool { match *self { BaseMapChain (ref map) => map.contains_key(key), ConsMapChain (ref map,ref rest) => @@ -475,11 +475,11 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{ // should each_key and each_value operate on shadowed // names? I think not. // delaying implementing this.... - pure fn each_key (&self, _f: &fn (&K)->bool) { + fn each_key (&self, _f: &fn (&K)->bool) { fail!(~"unimplemented 2013-02-15T10:01"); } - pure fn each_value (&self, _f: &fn (&V) -> bool) { + fn each_value (&self, _f: &fn (&V) -> bool) { fail!(~"unimplemented 2013-02-15T10:02"); } diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index d72da6f2d35..4a8ceedc8e3 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -21,7 +21,7 @@ use core::to_str::ToStr; pub enum direction { send, recv } impl ToStr for direction { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { send => ~"Send", recv => ~"Recv" diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 0196ee6d184..49076c74972 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -79,7 +79,7 @@ pub fn new_tt_reader(sp_diag: @span_handler, return r; } -pure fn dup_tt_frame(f: @mut TtFrame) -> @mut TtFrame { +fn dup_tt_frame(f: @mut TtFrame) -> @mut TtFrame { @mut TtFrame { readme: @mut (copy *f.readme), idx: f.idx, @@ -92,7 +92,7 @@ pure fn dup_tt_frame(f: @mut TtFrame) -> @mut TtFrame { } } -pub pure fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader { +pub fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader { @mut TtReader { sp_diag: r.sp_diag, interner: r.interner, @@ -106,10 +106,10 @@ pub pure fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader { } -pure fn lookup_cur_matched_by_matched(r: &mut TtReader, +fn lookup_cur_matched_by_matched(r: &mut TtReader, start: @named_match) -> @named_match { - pure fn red(+ad: @named_match, idx: &uint) -> @named_match { + fn red(+ad: @named_match, idx: &uint) -> @named_match { match *ad { matched_nonterminal(_) => { // end of the line; duplicate henceforth diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs index 435bfbdad24..67c3d19dd0f 100644 --- a/src/libsyntax/opt_vec.rs +++ b/src/libsyntax/opt_vec.rs @@ -61,18 +61,18 @@ impl<T> OptVec<T> { } } - pure fn get(&self, i: uint) -> &'self T { + fn get(&self, i: uint) -> &'self T { match *self { Empty => fail!(fmt!("Invalid index %u", i)), Vec(ref v) => &v[i] } } - pure fn is_empty(&self) -> bool { + fn is_empty(&self) -> bool { self.len() == 0 } - pure fn len(&self) -> uint { + fn len(&self) -> uint { match *self { Empty => 0, Vec(ref v) => v.len() @@ -105,7 +105,7 @@ impl<T:Copy> OptVec<T> { } impl<A:Eq> Eq for OptVec<A> { - pure fn eq(&self, other: &OptVec<A>) -> bool { + fn eq(&self, other: &OptVec<A>) -> bool { // Note: cannot use #[deriving(Eq)] here because // (Empty, Vec(~[])) ought to be equal. match (self, other) { @@ -116,51 +116,51 @@ impl<A:Eq> Eq for OptVec<A> { } } - pure fn ne(&self, other: &OptVec<A>) -> bool { + fn ne(&self, other: &OptVec<A>) -> bool { !self.eq(other) } } impl<A> BaseIter<A> for OptVec<A> { - pure fn each(&self, blk: &fn(v: &A) -> bool) { + fn each(&self, blk: &fn(v: &A) -> bool) { match *self { Empty => {} Vec(ref v) => v.each(blk) } } - pure fn size_hint(&self) -> Option<uint> { + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<A> iter::ExtendedIter<A> for OptVec<A> { #[inline(always)] - pure fn eachi(&self, blk: &fn(+v: uint, v: &A) -> bool) { + fn eachi(&self, blk: &fn(+v: uint, v: &A) -> bool) { iter::eachi(self, blk) } #[inline(always)] - pure fn all(&self, blk: &fn(&A) -> bool) -> bool { + fn all(&self, blk: &fn(&A) -> bool) -> bool { iter::all(self, blk) } #[inline(always)] - pure fn any(&self, blk: &fn(&A) -> bool) -> bool { + 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 { + fn foldl<B>(&self, +b0: B, blk: &fn(&B, &A) -> B) -> B { iter::foldl(self, b0, blk) } #[inline(always)] - pure fn position(&self, f: &fn(&A) -> bool) -> Option<uint> { + 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] { + 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) + fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B] { iter::flat_map_to_vec(self, op) } @@ -169,27 +169,27 @@ impl<A> iter::ExtendedIter<A> for OptVec<A> { impl<A: Eq> iter::EqIter<A> for OptVec<A> { #[inline(always)] - pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + fn contains(&self, x: &A) -> bool { iter::contains(self, x) } #[inline(always)] - pure fn count(&self, x: &A) -> uint { iter::count(self, x) } + fn count(&self, x: &A) -> uint { iter::count(self, x) } } impl<A: Copy> iter::CopyableIter<A> for OptVec<A> { #[inline(always)] - pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] { + 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) } + fn to_vec(&self) -> ~[A] { iter::to_vec(self) } #[inline(always)] - pure fn find(&self, f: &fn(&A) -> bool) -> Option<A> { + fn find(&self, f: &fn(&A) -> bool) -> Option<A> { iter::find(self, f) } } impl<A: Copy+Ord> iter::CopyableOrderedIter<A> for OptVec<A> { #[inline(always)] - pure fn min(&self) -> A { iter::min(self) } + fn min(&self) -> A { iter::min(self) } #[inline(always)] - pure fn max(&self) -> A { iter::max(self) } + fn max(&self) -> A { iter::max(self) } } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 6ebaa42357e..3f8a5588c71 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -35,10 +35,10 @@ pub enum cmnt_style { } impl cmp::Eq for cmnt_style { - pure fn eq(&self, other: &cmnt_style) -> bool { + fn eq(&self, other: &cmnt_style) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &cmnt_style) -> bool { + fn ne(&self, other: &cmnt_style) -> bool { ((*self) as uint) != ((*other) as uint) } } diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 1b64a9a6275..ea599e8290a 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -134,7 +134,7 @@ pub impl Parser { } } - pure fn token_is_word(&self, word: &~str, tok: &token::Token) -> bool { + fn token_is_word(&self, word: &~str, tok: &token::Token) -> bool { match *tok { token::IDENT(sid, false) => { *self.id_to_str(sid) == *word } _ => { false } diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index f53ac271901..ffd2a1d801c 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -32,7 +32,7 @@ pub trait reader { fn next_token(@mut self) -> TokenAndSpan; fn fatal(@mut self, ~str) -> !; fn span_diag(@mut self) -> @span_handler; - pure fn interner(@mut self) -> @token::ident_interner; + fn interner(@mut self) -> @token::ident_interner; fn peek(@mut self) -> TokenAndSpan; fn dup(@mut self) -> @reader; } @@ -122,7 +122,7 @@ impl reader for StringReader { self.span_diagnostic.span_fatal(copy self.peek_span, m) } fn span_diag(@mut self) -> @span_handler { self.span_diagnostic } - pure fn interner(@mut self) -> @token::ident_interner { self.interner } + fn interner(@mut self) -> @token::ident_interner { self.interner } fn peek(@mut self) -> TokenAndSpan { TokenAndSpan { tok: copy self.peek_tok, @@ -139,7 +139,7 @@ impl reader for TtReader { self.sp_diag.span_fatal(copy self.cur_span, m); } fn span_diag(@mut self) -> @span_handler { self.sp_diag } - pure fn interner(@mut self) -> @token::ident_interner { self.interner } + fn interner(@mut self) -> @token::ident_interner { self.interner } fn peek(@mut self) -> TokenAndSpan { TokenAndSpan { tok: copy self.cur_tok, @@ -261,7 +261,7 @@ fn consume_whitespace_and_comments(rdr: @mut StringReader) return consume_any_line_comment(rdr); } -pub pure fn is_line_non_doc_comment(s: &str) -> bool { +pub fn is_line_non_doc_comment(s: &str) -> bool { s.trim_right().all(|ch| ch == '/') } @@ -313,7 +313,7 @@ fn consume_any_line_comment(rdr: @mut StringReader) return None; } -pub pure fn is_block_non_doc_comment(s: &str) -> bool { +pub fn is_block_non_doc_comment(s: &str) -> bool { fail_unless!(s.len() >= 1u); str::all_between(s, 1u, s.len() - 1u, |ch| ch == '*') } diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 5cc1ea756e4..65eb87fb83c 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -63,7 +63,7 @@ pub enum ObsoleteSyntax { impl to_bytes::IterBytes for ObsoleteSyntax { #[inline(always)] - pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 07f8c8b743b..7ee45eea0de 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -196,8 +196,8 @@ macro_rules! maybe_whole ( ) -pure fn maybe_append(+lhs: ~[attribute], rhs: Option<~[attribute]>) - -> ~[attribute] { +fn maybe_append(+lhs: ~[attribute], rhs: Option<~[attribute]>) + -> ~[attribute] { match rhs { None => lhs, Some(ref attrs) => vec::append(lhs, (*attrs)) @@ -331,7 +331,7 @@ pub impl Parser { } fn get_id(&self) -> node_id { next_node_id(self.sess) } - pure fn id_to_str(&self, id: ident) -> @~str { + fn id_to_str(&self, id: ident) -> @~str { self.sess.interner.get(id) } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 5a774718b7d..f5542fa81a6 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -118,7 +118,7 @@ pub enum nonterminal { nt_matchers(~[ast::matcher]) } -pub pure fn binop_to_str(o: binop) -> ~str { +pub fn binop_to_str(o: binop) -> ~str { match o { PLUS => ~"+", MINUS => ~"-", @@ -228,7 +228,7 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str { } } -pub pure fn can_begin_expr(t: &Token) -> bool { +pub fn can_begin_expr(t: &Token) -> bool { match *t { LPAREN => true, LBRACE => true, @@ -286,22 +286,22 @@ pub fn is_lit(t: &Token) -> bool { } } -pub pure fn is_ident(t: &Token) -> bool { +pub fn is_ident(t: &Token) -> bool { match *t { IDENT(_, _) => true, _ => false } } -pub pure fn is_ident_or_path(t: &Token) -> bool { +pub fn is_ident_or_path(t: &Token) -> bool { match *t { IDENT(_, _) | INTERPOLATED(nt_path(*)) => true, _ => false } } -pub pure fn is_plain_ident(t: &Token) -> bool { +pub fn is_plain_ident(t: &Token) -> bool { match *t { IDENT(_, false) => true, _ => false } } -pub pure fn is_bar(t: &Token) -> bool { +pub fn is_bar(t: &Token) -> bool { match *t { BINOP(OR) | OROR => true, _ => false } } @@ -366,7 +366,7 @@ pub impl ident_interner { fn gensym(&self, val: @~str) -> ast::ident { ast::ident { repr: self.interner.gensym(val) } } - pure fn get(&self, idx: ast::ident) -> @~str { + fn get(&self, idx: ast::ident) -> @~str { self.interner.get(idx.repr) } fn len(&self) -> uint { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 27c4763e973..ce12e0a7b87 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2214,7 +2214,7 @@ pub fn opt_sigil_to_str(opt_p: Option<ast::Sigil>) -> ~str { } } -pub pure fn purity_to_str(p: ast::purity) -> ~str { +pub fn purity_to_str(p: ast::purity) -> ~str { match p { ast::impure_fn => ~"impure", ast::unsafe_fn => ~"unsafe", @@ -2223,7 +2223,7 @@ pub pure fn purity_to_str(p: ast::purity) -> ~str { } } -pub pure fn onceness_to_str(o: ast::Onceness) -> ~str { +pub fn onceness_to_str(o: ast::Onceness) -> ~str { match o { ast::Once => ~"once", ast::Many => ~"many" diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index b4a85ce1617..159a205637b 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -22,14 +22,14 @@ pub struct Interner<T> { // when traits can extend traits, we should extend index<uint,T> to get [] pub impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> { - static fn new() -> Interner<T> { + fn new() -> Interner<T> { Interner { map: @mut LinearMap::new(), vect: @mut ~[], } } - static fn prefill(init: &[T]) -> Interner<T> { + fn prefill(init: &[T]) -> Interner<T> { let rv = Interner::new(); for init.each() |v| { rv.intern(*v); } rv @@ -61,7 +61,7 @@ pub impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> { // this isn't "pure" in the traditional sense, because it can go from // failing to returning a value as items are interned. But for typestate, // where we first check a pred and then rely on it, ceasing to fail is ok. - pure fn get(&self, idx: uint) -> T { self.vect[idx] } + fn get(&self, idx: uint) -> T { self.vect[idx] } fn len(&self) -> uint { let vect = &*self.vect; vect.len() } } diff --git a/src/test/auxiliary/anon_trait_static_method_lib.rs b/src/test/auxiliary/anon_trait_static_method_lib.rs index 1162131960a..9a778b18874 100644 --- a/src/test/auxiliary/anon_trait_static_method_lib.rs +++ b/src/test/auxiliary/anon_trait_static_method_lib.rs @@ -13,7 +13,7 @@ pub struct Foo { } pub impl Foo { - static fn new() -> Foo { + fn new() -> Foo { Foo { x: 3 } } } diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs index 5006c72ad15..edda0644b16 100644 --- a/src/test/auxiliary/cci_class_cast.rs +++ b/src/test/auxiliary/cci_class_cast.rs @@ -18,7 +18,7 @@ pub mod kitty { } impl ToStr for cat { - pure fn to_str(&self) -> ~str { copy self.name } + fn to_str(&self) -> ~str { copy self.name } } priv impl cat { diff --git a/src/test/auxiliary/crateresolve5-1.rs b/src/test/auxiliary/crateresolve5-1.rs index 01c2dccb7b9..c120a971c6b 100644 --- a/src/test/auxiliary/crateresolve5-1.rs +++ b/src/test/auxiliary/crateresolve5-1.rs @@ -25,11 +25,11 @@ pub enum e { pub fn nominal() -> e { e_val } -pub pure fn nominal_eq(e1: e, e2: e) -> bool { true } +pub fn nominal_eq(e1: e, e2: e) -> bool { true } impl Eq for e { - pure fn eq(&self, other: &e) -> bool { nominal_eq(*self, *other) } - pure fn ne(&self, other: &e) -> bool { !nominal_eq(*self, *other) } + fn eq(&self, other: &e) -> bool { nominal_eq(*self, *other) } + fn ne(&self, other: &e) -> bool { !nominal_eq(*self, *other) } } pub fn f() -> int { 10 } diff --git a/src/test/auxiliary/crateresolve5-2.rs b/src/test/auxiliary/crateresolve5-2.rs index 328b9aa0ecb..230fdad0468 100644 --- a/src/test/auxiliary/crateresolve5-2.rs +++ b/src/test/auxiliary/crateresolve5-2.rs @@ -23,12 +23,12 @@ pub enum e { } impl Eq for e { - pure fn eq(&self, other: &e) -> bool { !nominal_neq(*self, *other) } - pure fn ne(&self, other: &e) -> bool { nominal_neq(*self, *other) } + fn eq(&self, other: &e) -> bool { !nominal_neq(*self, *other) } + fn ne(&self, other: &e) -> bool { nominal_neq(*self, *other) } } pub fn nominal() -> e { e_val } -pub pure fn nominal_neq(e1: e, e2: e) -> bool { false } +pub fn nominal_neq(e1: e, e2: e) -> bool { false } pub fn f() -> int { 20 } diff --git a/src/test/auxiliary/impl_privacy_xc_2.rs b/src/test/auxiliary/impl_privacy_xc_2.rs index d8c2a9ede5c..0fa15fa14f6 100644 --- a/src/test/auxiliary/impl_privacy_xc_2.rs +++ b/src/test/auxiliary/impl_privacy_xc_2.rs @@ -7,8 +7,8 @@ pub struct Fish { mod unexported { use super::Fish; impl Eq for Fish { - pure fn eq(&self, _: &Fish) -> bool { true } - pure fn ne(&self, _: &Fish) -> bool { false } + fn eq(&self, _: &Fish) -> bool { true } + fn ne(&self, _: &Fish) -> bool { false } } } diff --git a/src/test/auxiliary/static-methods-crate.rs b/src/test/auxiliary/static-methods-crate.rs index dbfff4e8aca..74c46a8b8c6 100644 --- a/src/test/auxiliary/static-methods-crate.rs +++ b/src/test/auxiliary/static-methods-crate.rs @@ -14,17 +14,17 @@ #[crate_type = "lib"]; pub trait read { - static fn readMaybe(s: ~str) -> Option<Self>; + fn readMaybe(s: ~str) -> Option<Self>; } impl read for int { - static fn readMaybe(s: ~str) -> Option<int> { + fn readMaybe(s: ~str) -> Option<int> { int::from_str(s) } } impl read for bool { - static fn readMaybe(s: ~str) -> Option<bool> { + fn readMaybe(s: ~str) -> Option<bool> { match s { ~"true" => Some(true), ~"false" => Some(false), diff --git a/src/test/auxiliary/static_fn_inline_xc_aux.rs b/src/test/auxiliary/static_fn_inline_xc_aux.rs index f595529b7f6..b1bdfcfcffc 100644 --- a/src/test/auxiliary/static_fn_inline_xc_aux.rs +++ b/src/test/auxiliary/static_fn_inline_xc_aux.rs @@ -11,14 +11,14 @@ pub mod num { pub trait Num2 { - static pure fn from_int2(n: int) -> Self; + static fn from_int2(n: int) -> Self; } } pub mod float { impl ::num::Num2 for float { #[inline] - static pure fn from_int2(n: int) -> float { return n as float; } + static fn from_int2(n: int) -> float { return n as float; } } } diff --git a/src/test/auxiliary/static_fn_trait_xc_aux.rs b/src/test/auxiliary/static_fn_trait_xc_aux.rs index 80734b8336b..cc03ac38943 100644 --- a/src/test/auxiliary/static_fn_trait_xc_aux.rs +++ b/src/test/auxiliary/static_fn_trait_xc_aux.rs @@ -1,11 +1,11 @@ pub mod num { pub trait Num2 { - static pure fn from_int2(n: int) -> Self; + fn from_int2(n: int) -> Self; } } pub mod float { impl ::num::Num2 for float { - static pure fn from_int2(n: int) -> float { return n as float; } + fn from_int2(n: int) -> float { return n as float; } } } diff --git a/src/test/auxiliary/trait_inheritance_overloading_xc.rs b/src/test/auxiliary/trait_inheritance_overloading_xc.rs index e86f7cfd26a..1b480ff17b3 100644 --- a/src/test/auxiliary/trait_inheritance_overloading_xc.rs +++ b/src/test/auxiliary/trait_inheritance_overloading_xc.rs @@ -18,24 +18,24 @@ pub struct MyInt { } impl Add<MyInt, MyInt> for MyInt { - pure fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } + fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } } impl Sub<MyInt, MyInt> for MyInt { - pure fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) } + fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) } } impl Mul<MyInt, MyInt> for MyInt { - pure fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } + fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } } impl Eq for MyInt { - pure fn eq(&self, other: &MyInt) -> bool { self.val == other.val } + fn eq(&self, other: &MyInt) -> bool { self.val == other.val } - pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } + fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } impl MyNum for MyInt; -pure fn mi(v: int) -> MyInt { MyInt { val: v } } +fn mi(v: int) -> MyInt { MyInt { val: v } } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index fc980e3d6db..f0847b635b4 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -27,14 +27,14 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str { return (xx as float) * 100f / (yy as float); } - pure fn le_by_val<TT:Copy,UU:Copy + Ord>(kv0: &(TT,UU), + fn le_by_val<TT:Copy,UU:Copy + Ord>(kv0: &(TT,UU), kv1: &(TT,UU)) -> bool { let (_, v0) = *kv0; let (_, v1) = *kv1; return v0 >= v1; } - pure fn le_by_key<TT:Copy + Ord,UU:Copy>(kv0: &(TT,UU), + fn le_by_key<TT:Copy + Ord,UU:Copy>(kv0: &(TT,UU), kv1: &(TT,UU)) -> bool { let (k0, _) = *kv0; let (k1, _) = *kv1; diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index eeea62d50fb..ada5ff7be2f 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -33,7 +33,7 @@ struct cmplx { } impl ops::Mul<cmplx,cmplx> for cmplx { - pure fn mul(&self, x: &cmplx) -> cmplx { + fn mul(&self, x: &cmplx) -> cmplx { cmplx { re: self.re*(*x).re - self.im*(*x).im, im: self.re*(*x).im + self.im*(*x).re @@ -42,7 +42,7 @@ impl ops::Mul<cmplx,cmplx> for cmplx { } impl ops::Add<cmplx,cmplx> for cmplx { - pure fn add(&self, x: &cmplx) -> cmplx { + fn add(&self, x: &cmplx) -> cmplx { cmplx { re: self.re + (*x).re, im: self.im + (*x).im @@ -52,7 +52,7 @@ impl ops::Add<cmplx,cmplx> for cmplx { struct Line {i: uint, b: ~[u8]} -pure fn cabs(x: cmplx) -> f64 +fn cabs(x: cmplx) -> f64 { x.re*x.re + x.im*x.im } diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index ae92be6a4de..1e32697eb10 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -40,11 +40,11 @@ struct Sudoku { } pub impl Sudoku { - static pub fn new(g: grid) -> Sudoku { + pub fn new(g: grid) -> Sudoku { return Sudoku { grid: g } } - static pub fn from_vec(vec: &[[u8 * 9] * 9]) -> Sudoku { + pub fn from_vec(vec: &[[u8 * 9] * 9]) -> Sudoku { let mut g = do vec::from_fn(9u) |i| { do vec::from_fn(9u) |j| { vec[i][j] } }; @@ -62,7 +62,7 @@ pub impl Sudoku { return true; } - static pub fn read(reader: @io::Reader) -> Sudoku { + pub fn read(reader: @io::Reader) -> Sudoku { fail_unless!(reader.read_line() == ~"9,9"); /* assert first line is exactly "9,9" */ let mut g = vec::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }); @@ -156,7 +156,7 @@ struct Colors(u16); const heads: u16 = (1u16 << 10) - 1; /* bits 9..0 */ impl Colors { - static fn new(start_color: u8) -> Colors { + fn new(start_color: u8) -> Colors { // Sets bits 9..start_color let tails = !0u16 << start_color; return Colors(heads & tails); diff --git a/src/test/compile-fail/auto-ref-slice-plus-ref.rs b/src/test/compile-fail/auto-ref-slice-plus-ref.rs index 7faee6f7ea2..609e8de87d6 100644 --- a/src/test/compile-fail/auto-ref-slice-plus-ref.rs +++ b/src/test/compile-fail/auto-ref-slice-plus-ref.rs @@ -20,9 +20,9 @@ fn main() { } trait MyIter { - pure fn test_mut(&mut self); + fn test_mut(&mut self); } impl MyIter for &'self [int] { - pure fn test_mut(&mut self) { } + fn test_mut(&mut self) { } } diff --git a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs index ece9ae7e861..482d1b6b8b6 100644 --- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs @@ -13,7 +13,7 @@ struct foo(~uint); impl Add<foo, foo> for foo { - pure fn add(f: &foo) -> foo { + fn add(f: &foo) -> foo { foo(~(**self + **(*f))) } } diff --git a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs index 23debb4c5e2..a4ad7e69b33 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs @@ -14,7 +14,7 @@ struct Point { } impl ops::Add<int,int> for Point { - pure fn add(&self, z: &int) -> int { + fn add(&self, z: &int) -> int { self.x + self.y + (*z) } } diff --git a/src/test/compile-fail/borrowck-loan-rcvr.rs b/src/test/compile-fail/borrowck-loan-rcvr.rs index 4a7228dcca3..4473574926a 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr.rs @@ -13,7 +13,7 @@ struct point { x: int, y: int } trait methods { fn impurem(&self); fn blockm(&self, f: &fn()); - pure fn purem(&self); + fn purem(&self); } impl methods for point { @@ -22,7 +22,7 @@ impl methods for point { fn blockm(&self, f: &fn()) { f() } - pure fn purem(&self) { + fn purem(&self) { } } diff --git a/src/test/compile-fail/issue-3344.rs b/src/test/compile-fail/issue-3344.rs index df768860cba..e931a8fa7e1 100644 --- a/src/test/compile-fail/issue-3344.rs +++ b/src/test/compile-fail/issue-3344.rs @@ -10,8 +10,8 @@ struct thing(uint); impl cmp::Ord for thing { //~ ERROR missing method `gt` - pure fn lt(&self, other: &thing) -> bool { **self < **other } - pure fn le(&self, other: &thing) -> bool { **self < **other } - pure fn ge(&self, other: &thing) -> bool { **self < **other } + fn lt(&self, other: &thing) -> bool { **self < **other } + fn le(&self, other: &thing) -> bool { **self < **other } + fn ge(&self, other: &thing) -> bool { **self < **other } } fn main() {} diff --git a/src/test/compile-fail/issue-3707.rs b/src/test/compile-fail/issue-3707.rs index 040bd46ab8c..2c8f94c4695 100644 --- a/src/test/compile-fail/issue-3707.rs +++ b/src/test/compile-fail/issue-3707.rs @@ -14,10 +14,10 @@ struct Obj { } pub impl Obj { - static pure fn boom() -> bool { + fn boom() -> bool { return 1+1 == 2 } - pure fn chirp() { + fn chirp() { self.boom(); //~ ERROR wat } } diff --git a/src/test/compile-fail/issue-3820.rs b/src/test/compile-fail/issue-3820.rs index 3a726d270ff..68c00494b9b 100644 --- a/src/test/compile-fail/issue-3820.rs +++ b/src/test/compile-fail/issue-3820.rs @@ -14,7 +14,7 @@ struct Thing { } impl Mul<int, Thing>*/ for Thing/* { //~ ERROR Look ma, no Mul! - pure fn mul(c: &int) -> Thing { + fn mul(c: &int) -> Thing { Thing {x: self.x * *c} } } diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs index bfc17c589db..b726f090e7d 100644 --- a/src/test/compile-fail/issue-3953.rs +++ b/src/test/compile-fail/issue-3953.rs @@ -25,8 +25,8 @@ struct Lol(int); impl Hahaha for Lol { } impl Eq for Lol { - pure fn eq(&self, other: &Lol) -> bool { **self != **other } - pure fn ne(&self, other: &Lol) -> bool { **self == **other } + fn eq(&self, other: &Lol) -> bool { **self != **other } + fn ne(&self, other: &Lol) -> bool { **self == **other } } fn main() { diff --git a/src/test/compile-fail/issue-3969.rs b/src/test/compile-fail/issue-3969.rs index e2bf708feab..60991d40a54 100644 --- a/src/test/compile-fail/issue-3969.rs +++ b/src/test/compile-fail/issue-3969.rs @@ -17,7 +17,7 @@ trait BikeMethods { } impl BikeMethods for Bike { - static fn woops(&const self) -> ~str { ~"foo" } + fn woops() -> ~str { ~"foo" } //~^ ERROR method `woops` is declared as static in its impl, but not in its trait } diff --git a/src/test/compile-fail/issue-3973.rs b/src/test/compile-fail/issue-3973.rs index 19244d24bcc..b1d741f9186 100644 --- a/src/test/compile-fail/issue-3973.rs +++ b/src/test/compile-fail/issue-3973.rs @@ -16,11 +16,11 @@ struct Point { } impl ToStr for Point { //~ ERROR implements a method not defined in the trait - static fn new(x: float, y: float) -> Point { + fn new(x: float, y: float) -> Point { Point { x: x, y: y } } - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("(%f, %f)", self.x, self.y) } } diff --git a/src/test/compile-fail/missing-derivable-attr.rs b/src/test/compile-fail/missing-derivable-attr.rs index 057e6dbc068..67cf67bfa5a 100644 --- a/src/test/compile-fail/missing-derivable-attr.rs +++ b/src/test/compile-fail/missing-derivable-attr.rs @@ -9,7 +9,7 @@ // except according to those terms. trait MyEq { - pure fn eq(&self, other: &Self) -> bool; + fn eq(&self, other: &Self) -> bool; } struct A { @@ -17,7 +17,7 @@ struct A { } impl MyEq for int { - pure fn eq(&self, other: &int) -> bool { *self == *other } + fn eq(&self, other: &int) -> bool { *self == *other } } impl MyEq for A; //~ ERROR missing method diff --git a/src/test/compile-fail/static-method-privacy.rs b/src/test/compile-fail/static-method-privacy.rs index d9b4112b1bd..50df4f04971 100644 --- a/src/test/compile-fail/static-method-privacy.rs +++ b/src/test/compile-fail/static-method-privacy.rs @@ -1,7 +1,7 @@ mod a { pub struct S; impl S { - static fn new() -> S { S } + fn new() -> S { S } } } diff --git a/src/test/compile-fail/staticness-mismatch.rs b/src/test/compile-fail/staticness-mismatch.rs index 531d722d8bc..719da233335 100644 --- a/src/test/compile-fail/staticness-mismatch.rs +++ b/src/test/compile-fail/staticness-mismatch.rs @@ -10,7 +10,7 @@ trait foo { - static fn bar(); + fn bar(); } impl foo for int { diff --git a/src/test/run-fail/die-macro-pure.rs b/src/test/run-fail/die-macro-pure.rs index 4479c2ecbeb..296fba2ae9b 100644 --- a/src/test/run-fail/die-macro-pure.rs +++ b/src/test/run-fail/die-macro-pure.rs @@ -1,6 +1,6 @@ // error-pattern:test -pure fn f() { +fn f() { fail!(~"test"); } diff --git a/src/test/run-fail/if-check-fail.rs b/src/test/run-fail/if-check-fail.rs index a3831a10874..a77d520b07e 100644 --- a/src/test/run-fail/if-check-fail.rs +++ b/src/test/run-fail/if-check-fail.rs @@ -9,7 +9,7 @@ // except according to those terms. // error-pattern:Number is odd -pure fn even(x: uint) -> bool { +fn even(x: uint) -> bool { if x < 2u { return false; } else if x == 2u { return true; } else { return even(x - 2u); } diff --git a/src/test/run-pass/anon-trait-static-method.rs b/src/test/run-pass/anon-trait-static-method.rs index 2ec0b59e13f..8e11786786f 100644 --- a/src/test/run-pass/anon-trait-static-method.rs +++ b/src/test/run-pass/anon-trait-static-method.rs @@ -13,7 +13,7 @@ struct Foo { } pub impl Foo { - static fn new() -> Foo { + fn new() -> Foo { Foo { x: 3 } } } diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 7538892f038..1a8ad446c79 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -60,7 +60,7 @@ enum Expr { } impl cmp::Eq for Expr { - pure fn eq(&self, other: &Expr) -> bool { + fn eq(&self, other: &Expr) -> bool { match *self { Val(e0a) => { match *other { @@ -82,18 +82,18 @@ impl cmp::Eq for Expr { } } } - pure fn ne(&self, other: &Expr) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Expr) -> bool { !(*self).eq(other) } } impl cmp::Eq for Point { - pure fn eq(&self, other: &Point) -> bool { + fn eq(&self, other: &Point) -> bool { self.x == other.x && self.y == other.y } - pure fn ne(&self, other: &Point) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Point) -> bool { !(*self).eq(other) } } impl<T:cmp::Eq> cmp::Eq for Quark<T> { - pure fn eq(&self, other: &Quark<T>) -> bool { + fn eq(&self, other: &Quark<T>) -> bool { match *self { Top(ref q) => { match *other { @@ -109,14 +109,14 @@ impl<T:cmp::Eq> cmp::Eq for Quark<T> { }, } } - pure fn ne(&self, other: &Quark<T>) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Quark<T>) -> bool { !(*self).eq(other) } } impl cmp::Eq for CLike { - pure fn eq(&self, other: &CLike) -> bool { + fn eq(&self, other: &CLike) -> bool { (*self) as int == *other as int } - pure fn ne(&self, other: &CLike) -> bool { !self.eq(other) } + fn ne(&self, other: &CLike) -> bool { !self.eq(other) } } #[auto_encode] diff --git a/src/test/run-pass/auto-ref-slice-plus-ref.rs b/src/test/run-pass/auto-ref-slice-plus-ref.rs index 39fe34bfe52..65366a350ef 100644 --- a/src/test/run-pass/auto-ref-slice-plus-ref.rs +++ b/src/test/run-pass/auto-ref-slice-plus-ref.rs @@ -12,18 +12,18 @@ // and also references them to create the &self pointer trait MyIter { - pure fn test_imm(&self); - pure fn test_const(&const self); + fn test_imm(&self); + fn test_const(&const self); } impl MyIter for &'self [int] { - pure fn test_imm(&self) { fail_unless!(self[0] == 1) } - pure fn test_const(&const self) { fail_unless!(self[0] == 1) } + fn test_imm(&self) { fail_unless!(self[0] == 1) } + fn test_const(&const self) { fail_unless!(self[0] == 1) } } impl MyIter for &'self str { - pure fn test_imm(&self) { fail_unless!(*self == "test") } - pure fn test_const(&const self) { fail_unless!(*self == "test") } + fn test_imm(&self) { fail_unless!(*self == "test") } + fn test_const(&const self) { fail_unless!(*self == "test") } } pub fn main() { diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index a0a4ea19964..40dd1a46574 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -16,10 +16,10 @@ use core::iter::BaseIter; enum cat_type { tuxedo, tabby, tortoiseshell } impl cmp::Eq for cat_type { - pure fn eq(&self, other: &cat_type) -> bool { + fn eq(&self, other: &cat_type) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &cat_type) -> bool { !(*self).eq(other) } + fn ne(&self, other: &cat_type) -> bool { !(*self).eq(other) } } // Very silly -- this just returns the value of the name field @@ -50,7 +50,7 @@ pub impl<T> cat<T> { } impl<T> BaseIter<(int, &'self T)> for cat<T> { - pure fn each(&self, f: &fn(&(int, &'self T)) -> bool) { + fn each(&self, f: &fn(&(int, &'self T)) -> bool) { let mut n = int::abs(self.meows); while n > 0 { if !f(&(n, &self.name)) { break; } @@ -58,12 +58,12 @@ impl<T> BaseIter<(int, &'self T)> for cat<T> { } } - pure fn size_hint(&self) -> Option<uint> { Some(self.len()) } + fn size_hint(&self) -> Option<uint> { Some(self.len()) } } impl<T> Container for cat<T> { - pure fn len(&const self) -> uint { self.meows as uint } - pure fn is_empty(&const self) -> bool { self.meows == 0 } + fn len(&const self) -> uint { self.meows as uint } + fn is_empty(&const self) -> bool { self.meows == 0 } } impl<T> Mutable for cat<T> { @@ -71,13 +71,13 @@ impl<T> Mutable for cat<T> { } impl<T> Map<int, T> for cat<T> { - pure fn contains_key(&self, k: &int) -> bool { *k <= self.meows } + fn contains_key(&self, k: &int) -> bool { *k <= self.meows } - pure fn each_key(&self, f: &fn(v: &int) -> bool) { + fn each_key(&self, f: &fn(v: &int) -> bool) { for self.each |&(k, _)| { if !f(&k) { break; } loop;}; } - pure fn each_value(&self, f: &fn(v: &T) -> bool) { + fn each_value(&self, f: &fn(v: &T) -> bool) { for self.each |&(_, v)| { if !f(v) { break; } loop;}; } @@ -90,7 +90,7 @@ impl<T> Map<int, T> for cat<T> { true } - pure fn find(&self, k: &int) -> Option<&'self T> { + fn find(&self, k: &int) -> Option<&'self T> { if *k <= self.meows { Some(&self.name) } else { @@ -108,14 +108,14 @@ impl<T> Map<int, T> for cat<T> { } pub impl<T> cat<T> { - pure fn get(&self, k: &int) -> &'self T { + fn get(&self, k: &int) -> &'self T { match self.find(k) { Some(v) => { v } None => { fail!(~"epic fail"); } } } - static pure fn new(in_x: int, in_y: int, in_name: T) -> cat<T> { + fn new(in_x: int, in_y: int, in_name: T) -> cat<T> { cat{meows: in_x, how_hungry: in_y, name: in_name } } } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index bb07597a188..168f2d872e7 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -51,7 +51,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat { } impl ToStr for cat { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { // FIXME #5384: this unsafe block is to work around purity unsafe { self.name.clone() diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-arg.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-arg.rs index 905046756f6..e40272bb7a4 100644 --- a/src/test/run-pass/coerce-reborrow-imm-ptr-arg.rs +++ b/src/test/run-pass/coerce-reborrow-imm-ptr-arg.rs @@ -1,4 +1,4 @@ -pure fn negate(x: &int) -> int { +fn negate(x: &int) -> int { -*x } diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs index 54d9758aa21..12ca00fedd3 100644 --- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs @@ -3,7 +3,7 @@ struct SpeechMaker { } pub impl SpeechMaker { - pure fn how_many(&const self) -> uint { self.speeches } + fn how_many(&const self) -> uint { self.speeches } } fn foo(speaker: &const SpeechMaker) -> uint { diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs b/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs index a18b4a2b0c6..ad5eb50ccef 100644 --- a/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs @@ -1,6 +1,6 @@ // xfail-test -pure fn sum(x: &[int]) -> int { +fn sum(x: &[int]) -> int { let mut sum = 0; for x.each |y| { sum += *y; } return sum; diff --git a/src/test/run-pass/coherence-impl-in-fn.rs b/src/test/run-pass/coherence-impl-in-fn.rs index 4fb43092500..7643799df06 100644 --- a/src/test/run-pass/coherence-impl-in-fn.rs +++ b/src/test/run-pass/coherence-impl-in-fn.rs @@ -11,9 +11,9 @@ pub fn main() { enum x { foo } impl ::core::cmp::Eq for x { - pure fn eq(&self, other: &x) -> bool { + fn eq(&self, other: &x) -> bool { (*self) as int == (*other) as int } - pure fn ne(&self, other: &x) -> bool { !(*self).eq(other) } + fn ne(&self, other: &x) -> bool { !(*self).eq(other) } } } diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs index 223825f60a7..38854abff47 100644 --- a/src/test/run-pass/conditional-compile.rs +++ b/src/test/run-pass/conditional-compile.rs @@ -130,9 +130,9 @@ mod test_methods { impl Fooable for Foo { #[cfg(bogus)] - static fn what(&self) { } + fn what(&self) { } - static fn what(&self) { } + fn what(&self) { } #[cfg(bogus)] fn the(&self) { } @@ -142,9 +142,9 @@ mod test_methods { trait Fooable { #[cfg(bogus)] - static fn what(&self); + fn what(&self); - static fn what(&self); + fn what(&self); #[cfg(bogus)] fn the(&self); diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs index b210b20458c..f2b5be4e36f 100644 --- a/src/test/run-pass/const-struct.rs +++ b/src/test/run-pass/const-struct.rs @@ -12,12 +12,12 @@ struct foo { a: int, b: int, c: int } impl cmp::Eq for foo { - pure fn eq(&self, other: &foo) -> bool { + fn eq(&self, other: &foo) -> bool { (*self).a == (*other).a && (*self).b == (*other).b && (*self).c == (*other).c } - pure fn ne(&self, other: &foo) -> bool { !(*self).eq(other) } + fn ne(&self, other: &foo) -> bool { !(*self).eq(other) } } const x : foo = foo { a:1, b:2, c: 3 }; diff --git a/src/test/run-pass/do-pure.rs b/src/test/run-pass/do-pure.rs index 41686cf5b37..08056f59acd 100644 --- a/src/test/run-pass/do-pure.rs +++ b/src/test/run-pass/do-pure.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pure fn f(f: &fn()) { +fn f(f: &fn()) { } -pure fn g() { +fn g() { // `f || { }` is considered pure, so `do f { }` should be too do f { } } diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs index ca81489e0bd..0589ffc79e0 100644 --- a/src/test/run-pass/empty-tag.rs +++ b/src/test/run-pass/empty-tag.rs @@ -11,10 +11,10 @@ enum chan { chan_t, } impl cmp::Eq for chan { - pure fn eq(&self, other: &chan) -> bool { + fn eq(&self, other: &chan) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &chan) -> bool { !(*self).eq(other) } + fn ne(&self, other: &chan) -> bool { !(*self).eq(other) } } fn wrapper3(i: chan) { diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs index 16c4986fc53..e22e739f570 100644 --- a/src/test/run-pass/explicit-self-generic.rs +++ b/src/test/run-pass/explicit-self-generic.rs @@ -15,8 +15,8 @@ extern mod std; * * The hash should concentrate entropy in the lower bits. */ -type HashFn<K> = ~pure fn(K) -> uint; -type EqFn<K> = ~pure fn(K, K) -> bool; +type HashFn<K> = ~fn(K) -> uint; +type EqFn<K> = ~fn(K, K) -> bool; struct LM { resize_at: uint, size: uint } diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs index 36483f88377..4634cc4ef11 100644 --- a/src/test/run-pass/export-unexported-dep.rs +++ b/src/test/run-pass/export-unexported-dep.rs @@ -16,10 +16,10 @@ mod foo { enum t { t1, t2, } impl cmp::Eq for t { - pure fn eq(&self, other: &t) -> bool { + fn eq(&self, other: &t) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &t) -> bool { !(*self).eq(other) } + fn ne(&self, other: &t) -> bool { !(*self).eq(other) } } pub fn f() -> t { return t1; } diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs index 564fb1a912c..03358f2511b 100644 --- a/src/test/run-pass/expr-alt-struct.rs +++ b/src/test/run-pass/expr-alt-struct.rs @@ -24,10 +24,10 @@ fn test_rec() { enum mood { happy, sad, } impl cmp::Eq for mood { - pure fn eq(&self, other: &mood) -> bool { + fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &mood) -> bool { !(*self).eq(other) } + fn ne(&self, other: &mood) -> bool { !(*self).eq(other) } } fn test_tag() { diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index d37a67d922e..14212347835 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -25,10 +25,10 @@ fn test_rec() { enum mood { happy, sad, } impl cmp::Eq for mood { - pure fn eq(&self, other: &mood) -> bool { + fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &mood) -> bool { !(*self).eq(other) } + fn ne(&self, other: &mood) -> bool { !(*self).eq(other) } } fn test_tag() { diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs index 3ee0808fa95..5c72de87ccb 100644 --- a/src/test/run-pass/if-check.rs +++ b/src/test/run-pass/if-check.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pure fn even(x: uint) -> bool { +fn even(x: uint) -> bool { if x < 2u { return false; } else if x == 2u { return true; } else { return even(x - 2u); } diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs index 49c8d27814c..8a7e2b8a9a9 100644 --- a/src/test/run-pass/issue-2904.rs +++ b/src/test/run-pass/issue-2904.rs @@ -28,7 +28,7 @@ enum square { } impl to_str::ToStr for square { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { match *self { bot => { ~"R" } wall => { ~"#" } diff --git a/src/test/run-pass/issue-3149.rs b/src/test/run-pass/issue-3149.rs index df102f93c2b..e433141c44d 100644 --- a/src/test/run-pass/issue-3149.rs +++ b/src/test/run-pass/issue-3149.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pure fn Matrix4<T:Copy>(m11: T, m12: T, m13: T, m14: T, - m21: T, m22: T, m23: T, m24: T, - m31: T, m32: T, m33: T, m34: T, - m41: T, m42: T, m43: T, m44: T) - -> Matrix4<T> { +fn Matrix4<T:Copy>(m11: T, m12: T, m13: T, m14: T, + m21: T, m22: T, m23: T, m24: T, + m31: T, m32: T, m33: T, m34: T, + m41: T, m42: T, m43: T, m44: T) + -> Matrix4<T> { Matrix4 { m11: m11, m12: m12, m13: m13, m14: m14, diff --git a/src/test/run-pass/issue-3480.rs b/src/test/run-pass/issue-3480.rs index e813cde7c27..aaff822398d 100644 --- a/src/test/run-pass/issue-3480.rs +++ b/src/test/run-pass/issue-3480.rs @@ -13,13 +13,12 @@ type IMap<K:Copy,V:Copy> = ~[(K, V)]; trait ImmutableMap<K:Copy,V:Copy> { - pure fn contains_key(key: K) -> bool; + fn contains_key(key: K) -> bool; } impl<K:Copy,V:Copy> IMap<K, V> : ImmutableMap<K, V> { - pure fn contains_key(key: K) -> bool - { + fn contains_key(key: K) -> bool { vec::find(self, |e| {e.first() == key}).is_some() } } diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index ad6cae0bff9..fdbd7ec304e 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -111,8 +111,7 @@ impl AsciiArt // Allows AsciiArt to be converted to a string using the libcore ToStr trait. // Note that the %s fmt! specifier will not call this automatically. impl ToStr for AsciiArt { - pure fn to_str(&self) -> ~str - { + fn to_str(&self) -> ~str { // Convert each line into a string. let lines = do self.lines.map |line| {str::from_chars(*line)}; diff --git a/src/test/run-pass/issue-3874.rs b/src/test/run-pass/issue-3874.rs index 8d62da9efad..f54d2f9fafc 100644 --- a/src/test/run-pass/issue-3874.rs +++ b/src/test/run-pass/issue-3874.rs @@ -11,7 +11,7 @@ // xfail-test enum PureCounter { PureCounter(uint) } -pure fn each(self: PureCounter, blk: &fn(v: &uint)) { +fn each(self: PureCounter, blk: &fn(v: &uint)) { let PureCounter(ref x) = self; blk(x); } diff --git a/src/test/run-pass/mod-merge-hack-template.rs b/src/test/run-pass/mod-merge-hack-template.rs index 94edb596b5f..8628d84d4e7 100644 --- a/src/test/run-pass/mod-merge-hack-template.rs +++ b/src/test/run-pass/mod-merge-hack-template.rs @@ -13,4 +13,4 @@ use T = self::inst::T; pub const bits: uint = inst::bits; -pub pure fn min(x: T, y: T) -> T { if x < y { x } else { y } } +pub fn min(x: T, y: T) -> T { if x < y { x } else { y } } diff --git a/src/test/run-pass/new-impl-syntax.rs b/src/test/run-pass/new-impl-syntax.rs index aad7ded42d3..12b41fc9148 100644 --- a/src/test/run-pass/new-impl-syntax.rs +++ b/src/test/run-pass/new-impl-syntax.rs @@ -4,7 +4,7 @@ struct Thingy { } impl ToStr for Thingy { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { fmt!("{ x: %d, y: %d }", self.x, self.y) } } @@ -14,7 +14,7 @@ struct PolymorphicThingy<T> { } impl<T:ToStr> ToStr for PolymorphicThingy<T> { - pure fn to_str(&self) -> ~str { + fn to_str(&self) -> ~str { self.x.to_str() } } diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs index 83273a7aae6..ae241e458fc 100644 --- a/src/test/run-pass/non-boolean-pure-fns.rs +++ b/src/test/run-pass/non-boolean-pure-fns.rs @@ -14,13 +14,13 @@ extern mod std; use std::list::*; -pure fn pure_length_go<T:Copy>(ls: @List<T>, acc: uint) -> uint { +fn pure_length_go<T:Copy>(ls: @List<T>, acc: uint) -> uint { match *ls { Nil => { acc } Cons(_, tl) => { pure_length_go(tl, acc + 1u) } } } -pure fn pure_length<T:Copy>(ls: @List<T>) -> uint { pure_length_go(ls, 0u) } +fn pure_length<T:Copy>(ls: @List<T>) -> uint { pure_length_go(ls, 0u) } -pure fn nonempty_list<T:Copy>(ls: @List<T>) -> bool { pure_length(ls) > 0u } +fn nonempty_list<T:Copy>(ls: @List<T>) -> bool { pure_length(ls) > 0u } fn safe_head<T:Copy>(ls: @List<T>) -> T { fail_unless!(!is_empty(ls)); diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index 3873cdf615b..9299e3e365e 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -16,40 +16,40 @@ struct Point { } impl ops::Add<Point,Point> for Point { - pure fn add(&self, other: &Point) -> Point { + fn add(&self, other: &Point) -> Point { Point {x: self.x + (*other).x, y: self.y + (*other).y} } } impl ops::Sub<Point,Point> for Point { - pure fn sub(&self, other: &Point) -> Point { + fn sub(&self, other: &Point) -> Point { Point {x: self.x - (*other).x, y: self.y - (*other).y} } } impl ops::Neg<Point> for Point { - pure fn neg(&self) -> Point { + fn neg(&self) -> Point { Point {x: -self.x, y: -self.y} } } impl ops::Not<Point> for Point { - pure fn not(&self) -> Point { + fn not(&self) -> Point { Point {x: !self.x, y: !self.y } } } impl ops::Index<bool,int> for Point { - pure fn index(&self, +x: bool) -> int { + fn index(&self, +x: bool) -> int { if x { self.x } else { self.y } } } impl cmp::Eq for Point { - pure fn eq(&self, other: &Point) -> bool { + fn eq(&self, other: &Point) -> bool { (*self).x == (*other).x && (*self).y == (*other).y } - pure fn ne(&self, other: &Point) -> bool { !(*self).eq(other) } + fn ne(&self, other: &Point) -> bool { !(*self).eq(other) } } pub fn main() { diff --git a/src/test/run-pass/pred-not-bool.rs b/src/test/run-pass/pred-not-bool.rs index 4b90b99cb31..127b845ad4c 100644 --- a/src/test/run-pass/pred-not-bool.rs +++ b/src/test/run-pass/pred-not-bool.rs @@ -11,6 +11,6 @@ // this checks that a pred with a non-bool return // type is rejected, even if the pred is never used -pure fn bad(a: int) -> int { return 37; } //~ ERROR Non-boolean return type +fn bad(a: int) -> int { return 37; } //~ ERROR Non-boolean return type pub fn main() { } diff --git a/src/test/run-pass/pure-fmt.rs b/src/test/run-pass/pure-fmt.rs index b65c33939c8..424a5e4e8ef 100644 --- a/src/test/run-pass/pure-fmt.rs +++ b/src/test/run-pass/pure-fmt.rs @@ -13,7 +13,7 @@ struct Big { b: @~str, c: uint, d: int, e: char, f: float, g: bool } -pure fn foo() { +fn foo() { let a = Big { b: @~"hi", c: 0, diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs index cac6b4ef349..6327a3f238d 100644 --- a/src/test/run-pass/pure-sum.rs +++ b/src/test/run-pass/pure-sum.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Check that pure functions can modify local state. +// Check that functions can modify local state. -pure fn sums_to(v: ~[int], sum: int) -> bool { +fn sums_to(v: ~[int], sum: int) -> bool { let mut i = 0u, sum0 = 0; while i < v.len() { sum0 += v[i]; @@ -19,7 +19,7 @@ pure fn sums_to(v: ~[int], sum: int) -> bool { return sum0 == sum; } -pure fn sums_to_using_uniq(v: ~[int], sum: int) -> bool { +fn sums_to_using_uniq(v: ~[int], sum: int) -> bool { let mut i = 0u, sum0 = ~0; while i < v.len() { *sum0 += v[i]; @@ -28,7 +28,7 @@ pure fn sums_to_using_uniq(v: ~[int], sum: int) -> bool { return *sum0 == sum; } -pure fn sums_to_using_rec(v: ~[int], sum: int) -> bool { +fn sums_to_using_rec(v: ~[int], sum: int) -> bool { let mut i = 0u, sum0 = F {f: 0}; while i < v.len() { sum0.f += v[i]; @@ -39,7 +39,7 @@ pure fn sums_to_using_rec(v: ~[int], sum: int) -> bool { struct F<T> { f: T } -pure fn sums_to_using_uniq_rec(v: ~[int], sum: int) -> bool { +fn sums_to_using_uniq_rec(v: ~[int], sum: int) -> bool { let mut i = 0u, sum0 = F {f: ~0}; while i < v.len() { *sum0.f += v[i]; diff --git a/src/test/run-pass/purity-infer.rs b/src/test/run-pass/purity-infer.rs index ce9b3b78a9c..debde77b211 100644 --- a/src/test/run-pass/purity-infer.rs +++ b/src/test/run-pass/purity-infer.rs @@ -9,7 +9,7 @@ // except according to those terms. -fn something(f: &pure fn()) { f(); } +fn something(f: &fn()) { f(); } pub fn main() { something(|| error!("hi!") ); } diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs index 1146412ec4f..1b5cb86360b 100644 --- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs +++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs @@ -13,11 +13,11 @@ trait Deserializer { } trait Deserializable<D:Deserializer> { - static fn deserialize(&self, d: &D) -> Self; + fn deserialize(d: &D) -> Self; } impl<D:Deserializer> Deserializable<D> for int { - static fn deserialize(&self, d: &D) -> int { + fn deserialize(d: &D) -> int { return d.read_int(); } } diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index 0c6359375d3..624a38b789b 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -14,7 +14,7 @@ // A trait for objects that can be used to do an if-then-else // (No actual need for this to be static, but it is a simple test.) trait bool_like { - static fn select<A>(b: Self, +x1: A, +x2: A) -> A; + fn select<A>(b: Self, +x1: A, +x2: A) -> A; } fn andand<T:bool_like + Copy>(x1: T, x2: T) -> T { @@ -22,41 +22,38 @@ fn andand<T:bool_like + Copy>(x1: T, x2: T) -> T { } impl bool_like for bool { - static fn select<A>(&&b: bool, +x1: A, +x2: A) -> A { + fn select<A>(&&b: bool, +x1: A, +x2: A) -> A { if b { x1 } else { x2 } } } impl bool_like for int { - static fn select<A>(&&b: int, +x1: A, +x2: A) -> A { + fn select<A>(&&b: int, +x1: A, +x2: A) -> A { if b != 0 { x1 } else { x2 } } } // A trait for sequences that can be constructed imperatively. trait buildable<A> { - static pure fn build_sized(size: uint, - builder: &fn(push: &pure fn(+v: A))) -> Self; + fn build_sized(size: uint, builder: &fn(push: &fn(+v: A))) -> Self; } impl<A> buildable<A> for @[A] { #[inline(always)] - static pure fn build_sized(size: uint, - builder: &fn(push: &pure fn(+v: A))) -> @[A] { + fn build_sized(size: uint, builder: &fn(push: &fn(+v: A))) -> @[A] { at_vec::build_sized(size, builder) } } impl<A> buildable<A> for ~[A] { #[inline(always)] - static pure fn build_sized(size: uint, - builder: &fn(push: &pure fn(+v: A))) -> ~[A] { + fn build_sized(size: uint, builder: &fn(push: &fn(+v: A))) -> ~[A] { vec::build_sized(size, builder) } } #[inline(always)] -pure fn build<A, B: buildable<A>>(builder: &fn(push: &pure fn(+v: A))) -> B { +fn build<A, B: buildable<A>>(builder: &fn(push: &fn(+v: A))) -> B { buildable::build_sized(4, builder) } diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs index be83fe4d3ab..24bcfcef1e7 100644 --- a/src/test/run-pass/static-methods-in-traits.rs +++ b/src/test/run-pass/static-methods-in-traits.rs @@ -10,17 +10,17 @@ mod a { pub trait Foo { - static pub fn foo() -> Self; + pub fn foo() -> Self; } impl Foo for int { - static pub fn foo() -> int { + pub fn foo() -> int { 3 } } impl Foo for uint { - static pub fn foo() -> uint { + pub fn foo() -> uint { 5u } } diff --git a/src/test/run-pass/static-methods-in-traits2.rs b/src/test/run-pass/static-methods-in-traits2.rs index 20ab9014c70..20e6efa11f0 100644 --- a/src/test/run-pass/static-methods-in-traits2.rs +++ b/src/test/run-pass/static-methods-in-traits2.rs @@ -1,17 +1,17 @@ pub trait Number: NumConv { - static pure fn from<T:Number>(n: T) -> Self; + fn from<T:Number>(n: T) -> Self; } impl Number for float { - static pure fn from<T:Number>(n: T) -> float { n.to_float() } + fn from<T:Number>(n: T) -> float { n.to_float() } } pub trait NumConv { - pure fn to_float(&self) -> float; + fn to_float(&self) -> float; } impl NumConv for float { - pure fn to_float(&self) -> float { *self } + fn to_float(&self) -> float { *self } } pub fn main() { diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index f32fc27e3aa..d9872033447 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -13,10 +13,10 @@ enum foo { large, small, } impl cmp::Eq for foo { - pure fn eq(&self, other: &foo) -> bool { + fn eq(&self, other: &foo) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &foo) -> bool { !(*self).eq(other) } + fn ne(&self, other: &foo) -> bool { !(*self).eq(other) } } pub fn main() { diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index 2f87142d688..63300342bd3 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -20,10 +20,10 @@ enum color { } impl cmp::Eq for color { - pure fn eq(&self, other: &color) -> bool { + fn eq(&self, other: &color) -> bool { ((*self) as uint) == ((*other) as uint) } - pure fn ne(&self, other: &color) -> bool { !(*self).eq(other) } + fn ne(&self, other: &color) -> bool { !(*self).eq(other) } } pub fn main() { diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index 729e11dfc64..4e126379410 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -15,7 +15,7 @@ enum colour { red(int, int), green, } impl cmp::Eq for colour { - pure fn eq(&self, other: &colour) -> bool { + fn eq(&self, other: &colour) -> bool { match *self { red(a0, b0) => { match (*other) { @@ -31,7 +31,7 @@ impl cmp::Eq for colour { } } } - pure fn ne(&self, other: &colour) -> bool { !(*self).eq(other) } + fn ne(&self, other: &colour) -> bool { !(*self).eq(other) } } fn f() { let x = red(1, 2); let y = green; fail_unless!((x != y)); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index c50dfe79169..89dad2d462c 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -52,7 +52,7 @@ enum t { } impl cmp::Eq for t { - pure fn eq(&self, other: &t) -> bool { + fn eq(&self, other: &t) -> bool { match *self { tag1 => { match (*other) { @@ -75,7 +75,7 @@ impl cmp::Eq for t { } } } - pure fn ne(&self, other: &t) -> bool { !(*self).eq(other) } + fn ne(&self, other: &t) -> bool { !(*self).eq(other) } } fn test_tag() { diff --git a/src/test/run-pass/trait-inheritance-num0.rs b/src/test/run-pass/trait-inheritance-num0.rs index 7f0d4d77b62..aae430dc4cd 100644 --- a/src/test/run-pass/trait-inheritance-num0.rs +++ b/src/test/run-pass/trait-inheritance-num0.rs @@ -15,7 +15,7 @@ use core::num::NumCast::from; trait Num { - static fn from_int(i: int) -> Self; + fn from_int(i: int) -> Self; fn gt(&self, other: &Self) -> bool; } diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs index ce370854a41..283ed8ae2c1 100644 --- a/src/test/run-pass/trait-inheritance-overloading-simple.rs +++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs @@ -15,8 +15,8 @@ trait MyNum : Eq { } struct MyInt { val: int } impl Eq for MyInt { - pure fn eq(&self, other: &MyInt) -> bool { self.val == other.val } - pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } + fn eq(&self, other: &MyInt) -> bool { self.val == other.val } + fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } impl MyNum for MyInt; @@ -25,7 +25,7 @@ fn f<T:MyNum>(x: T, y: T) -> bool { return x == y; } -pure fn mi(v: int) -> MyInt { MyInt { val: v } } +fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y, z) = (mi(3), mi(5), mi(3)); diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs index f97412f4207..d4d16f2b43e 100644 --- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs +++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs @@ -18,7 +18,7 @@ fn f<T:Copy + MyNum>(x: T, y: T) -> (T, T, T) { return (x + y, x - y, x * y); } -pure fn mi(v: int) -> MyInt { MyInt { val: v } } +fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index aadc0650958..d4f8d50b92b 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -15,20 +15,20 @@ trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + Eq { } struct MyInt { val: int } impl Add<MyInt, MyInt> for MyInt { - pure fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } + fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } } impl Sub<MyInt, MyInt> for MyInt { - pure fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) } + fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) } } impl Mul<MyInt, MyInt> for MyInt { - pure fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } + fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } } impl Eq for MyInt { - pure fn eq(&self, other: &MyInt) -> bool { self.val == other.val } - pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } + fn eq(&self, other: &MyInt) -> bool { self.val == other.val } + fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } impl MyNum for MyInt; @@ -37,7 +37,7 @@ fn f<T:Copy + MyNum>(x: T, y: T) -> (T, T, T) { return (x + y, x - y, x * y); } -pure fn mi(v: int) -> MyInt { MyInt { val: v } } +fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs index 1d11870b21a..f3adea18ecd 100644 --- a/src/test/run-pass/trait-inheritance-static.rs +++ b/src/test/run-pass/trait-inheritance-static.rs @@ -9,7 +9,7 @@ // except according to those terms. trait MyNum { - static fn from_int(int) -> Self; + fn from_int(int) -> Self; } pub trait NumExt: MyNum { } @@ -17,7 +17,7 @@ pub trait NumExt: MyNum { } struct S { v: int } impl MyNum for S { - static fn from_int(i: int) -> S { + fn from_int(i: int) -> S { S { v: i } diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs index 30fefa7501f..45369d4ec19 100644 --- a/src/test/run-pass/trait-inheritance-static2.rs +++ b/src/test/run-pass/trait-inheritance-static2.rs @@ -11,7 +11,7 @@ trait MyEq { } trait MyNum { - static fn from_int(int) -> Self; + fn from_int(int) -> Self; } pub trait NumExt: MyEq + MyNum { } @@ -21,7 +21,7 @@ struct S { v: int } impl MyEq for S { } impl MyNum for S { - static fn from_int(i: int) -> S { + fn from_int(i: int) -> S { S { v: i } diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs index c1ee7a2c00a..9d0e5fa1f13 100644 --- a/src/test/run-pass/trait-inheritance-subst.rs +++ b/src/test/run-pass/trait-inheritance-subst.rs @@ -9,7 +9,7 @@ // except according to those terms. pub trait Add<RHS,Result> { - pure fn add(&self, rhs: &RHS) -> Result; + fn add(&self, rhs: &RHS) -> Result; } trait MyNum : Add<Self,Self> { } @@ -17,7 +17,7 @@ trait MyNum : Add<Self,Self> { } struct MyInt { val: int } impl Add<MyInt, MyInt> for MyInt { - pure fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } + fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } } impl MyNum for MyInt; @@ -26,7 +26,7 @@ fn f<T:MyNum>(x: T, y: T) -> T { return x.add(&y); } -pure fn mi(v: int) -> MyInt { MyInt { val: v } } +fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs index 9565919a5d8..a8a579422a3 100644 --- a/src/test/run-pass/trait-static-method-overwriting.rs +++ b/src/test/run-pass/trait-static-method-overwriting.rs @@ -12,7 +12,7 @@ mod base { pub trait HasNew<T> { - static pure fn new() -> T; + fn new() -> T; } pub struct Foo { @@ -20,7 +20,7 @@ mod base { } impl ::base::HasNew<Foo> for Foo { - static pure fn new() -> Foo { + fn new() -> Foo { unsafe { io::println("Foo"); } Foo { dummy: () } } @@ -31,7 +31,7 @@ mod base { } impl ::base::HasNew<Bar> for Bar { - static pure fn new() -> Bar { + fn new() -> Bar { unsafe { io::println("Bar"); } Bar { dummy: () } } diff --git a/src/test/run-pass/tstate-loop-break.rs b/src/test/run-pass/tstate-loop-break.rs index 8b626611c41..4228f72b7ca 100644 --- a/src/test/run-pass/tstate-loop-break.rs +++ b/src/test/run-pass/tstate-loop-break.rs @@ -10,7 +10,7 @@ // xfail-test -pure fn is_even(i: int) -> bool { (i%2) == 0 } +fn is_even(i: int) -> bool { (i%2) == 0 } fn even(i: int) : is_even(i) -> int { i } fn test() { diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs index cd914aaa318..7303f5ecbdf 100644 --- a/src/test/run-pass/typeclasses-eq-example-static.rs +++ b/src/test/run-pass/typeclasses-eq-example-static.rs @@ -12,13 +12,13 @@ // methods! trait Equal { - static fn isEq(a: Self, b: Self) -> bool; + fn isEq(a: Self, b: Self) -> bool; } enum Color { cyan, magenta, yellow, black } impl Equal for Color { - static fn isEq(a: Color, b: Color) -> bool { + fn isEq(a: Color, b: Color) -> bool { match (a, b) { (cyan, cyan) => { true } (magenta, magenta) => { true } @@ -35,7 +35,7 @@ enum ColorTree { } impl Equal for ColorTree { - static fn isEq(a: ColorTree, b: ColorTree) -> bool { + fn isEq(a: ColorTree, b: ColorTree) -> bool { match (a, b) { (leaf(x), leaf(y)) => { Equal::isEq(x, y) } (branch(l1, r1), branch(l2, r2)) => { diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index a7ac8554b3d..0af35a6c619 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -56,7 +56,7 @@ fn notsure() { } fn canttouchthis() -> uint { - pure fn p() -> bool { true } + fn p() -> bool { true } let _a = (fail_unless!((true)) == (fail_unless!(p()))); let _c = (fail_unless!((p())) == ()); let _b: bool = (debug!("%d", 0) == (return 0u)); |