---

yaml
---
r: 57182
b: refs/heads/try
c: 11d04d4
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: dcd49ccd0ba5616995da00454389b6454423813c
+refs/heads/try: 11d04d452fa8fd8adde10f8de902bfffc59ab704
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -802,7 +802,7 @@ An example of `use` declarations:
 
 ~~~~
 use core::float::sin;
-use core::str::{slice, contains};
+use core::str::{slice, to_upper};
 use core::option::Some;
 
 fn main() {
@@ -813,8 +813,8 @@ fn main() {
     info!(Some(1.0));
 
     // Equivalent to
-    // 'info!(core::str::contains(core::str::slice("foo", 0, 1), "oo"));'
-    info!(contains(slice("foo", 0, 1), "oo"));
+    // 'info!(core::str::to_upper(core::str::slice("foo", 0, 1)));'
+    info!(to_upper(slice("foo", 0, 1)));
 }
 ~~~~
 

branches/try/src/compiletest/errors.rs

@@ -50,11 +50,7 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
     while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
     let start_kind = idx;
     while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
-
-    // FIXME: #4318 Instead of to_ascii and to_str_ascii, could use
-    // to_ascii_consume and to_str_consume to not do a unnecessary copy.
-    let kind = str::slice(line, start_kind, idx);
-    let kind = kind.to_ascii().to_lower().to_str_ascii();
+    let kind = str::to_lower(str::slice(line, start_kind, idx).to_owned());
 
     // Extract msg:
     while idx < len && line[idx] == (' ' as u8) { idx += 1u; }

branches/try/src/libcore/char.rs

@@ -100,6 +100,12 @@ pub fn is_alphanumeric(c: char) -> bool {
         unicode::general_category::No(c);
 }
 
+/// Indicates whether the character is an ASCII character
+#[inline(always)]
+pub fn is_ascii(c: char) -> bool {
+   c - ('\x7F' & c) == '\x00'
+}
+
 /// Indicates whether the character is numeric (Nd, Nl, or No)
 #[inline(always)]
 pub fn is_digit(c: char) -> bool {
@@ -110,7 +116,7 @@ pub fn is_digit(c: char) -> bool {
 
 /**
  * Checks if a character parses as a numeric digit in the given radix.
- * Compared to `is_digit()`, this function only recognizes the
+ * Compared to `is_digit()`, this function only recognizes the ascii
  * characters `0-9`, `a-z` and `A-Z`.
  *
  * Returns `true` if `c` is a valid digit under `radix`, and `false`
@@ -157,7 +163,7 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
 }
 
 /**
- * Converts a number to the character representing it.
+ * Converts a number to the ascii character representing it.
  *
  * Returns `Some(char)` if `num` represents one digit under `radix`,
  * using one character of `0-9` or `a-z`, or `None` if it doesn't.
@@ -310,6 +316,12 @@ fn test_to_digit() {
     assert!(to_digit('$', 36u).is_none());
 }
 
+#[test]
+fn test_is_ascii() {
+   assert!(str::all(~"banana", is_ascii));
+   assert!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii));
+}
+
 #[test]
 fn test_is_digit() {
    assert!(is_digit('2'));

branches/try/src/libcore/core.rc

@@ -77,7 +77,9 @@ pub use kinds::{Const, Copy, Owned, Durable};
 pub use ops::{Drop};
 #[cfg(stage0)]
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
-#[cfg(not(stage0))]
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 pub use ops::{Add, Sub, Mul, Quot, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Shl, Shr, Index};
@@ -104,8 +106,6 @@ pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 pub use iter::{ExtendedMutableIter};
 
 pub use num::{Num, NumCast};
-pub use num::{Signed, Unsigned, Integer};
-pub use num::{Fractional, Real, RealExt};
 pub use ptr::Ptr;
 pub use to_str::ToStr;
 pub use clone::Clone;

branches/try/src/libcore/flate.rs

@@ -85,7 +85,7 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
 #[test]
 #[allow(non_implicitly_copyable_typarams)]
 fn test_flate_round_trip() {
-    let r = rand::rng();
+    let r = rand::Rng();
     let mut words = ~[];
     for 20.times {
         words.push(r.gen_bytes(r.gen_uint_range(1, 10)));

branches/try/src/libcore/hashmap.rs

@@ -56,7 +56,7 @@ fn resize_at(capacity: uint) -> uint {
 pub fn linear_map_with_capacity<K:Eq + Hash,V>(
     initial_capacity: uint) -> HashMap<K, V> {
     let r = rand::task_rng();
-    linear_map_with_capacity_and_keys(r.gen(), r.gen(),
+    linear_map_with_capacity_and_keys(r.gen_u64(), r.gen_u64(),
                                       initial_capacity)
 }
 

branches/try/src/libcore/iterator.rs

@@ -312,6 +312,19 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
     }
 }
 
+pub struct ScanIterator<'self, A, B, T, St> {
+    priv iter: T,
+    priv f: &'self fn(&mut St, A) -> Option<B>,
+    state: St
+}
+
+impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+    }
+}
+
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
     state: St
@@ -335,16 +348,25 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
+/// An infinite iterator starting at `start` and advancing by `step` with each iteration
+pub struct Counter<A> {
+    state: A,
+    step: A
 }
 
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+pub impl<A> Counter<A> {
+    #[inline(always)]
+    fn new(start: A, step: A) -> Counter<A> {
+        Counter{state: start, step: step}
+    }
+}
+
+impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
+    #[inline(always)]
+    fn next(&mut self) -> Option<A> {
+        let result = self.state.clone();
+        self.state = self.state.add(&self.step); // FIXME: #6050
+        Some(result)
     }
 }
 
@@ -353,6 +375,13 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    #[test]
+    fn test_counter_to_vec() {
+        let mut it = Counter::new(0, 5).take(10);
+        let xs = iter::iter_to_vec(|f| it.advance(f));
+        assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
+    }
+
     #[test]
     fn test_iterator_chain() {
         let xs = [0u, 1, 2, 3, 4, 5];