---

yaml
---
r: 124590
b: refs/heads/auto
c: 0c30e1f
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 793b1424ac52b7d1cb20e508e313ce516530cea7
+refs/heads/auto: 0c30e1faad86214e28454d223ffa040212897a1e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/docs.mk

@@ -30,7 +30,7 @@ DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport \
 	complement-lang-faq complement-design-faq complement-project-faq rust \
-    rustdoc guide-unsafe
+    rustdoc guide-unsafe guide-strings
 
 PDF_DOCS := tutorial rust
 

branches/auto/src/doc/guide-strings.md

@@ -1,7 +1,5 @@
 % The Strings Guide
 
-# Strings
-
 Strings are an important concept to master in any programming language. If you
 come from a managed language background, you may be surprised at the complexity
 of string handling in a systems programming language. Efficient access and
@@ -14,7 +12,7 @@ Additionally, strings are not null-terminated and can contain null bytes.
 
 Rust has two main types of strings: `&str` and `String`.
 
-## &str
+# &str
 
 The first kind is a `&str`. This is pronounced a 'string slice.' String literals
 are of the type `&str`:
@@ -38,7 +36,7 @@ Like vector slices, string slices are simply a pointer plus a length. This
 means that they're a 'view' into an already-allocated string, such as a
 `&'static str` or a `String`.
 
-## String
+# String
 
 A `String` is a heap-allocated string. This string is growable, and is also
 guaranteed to be UTF-8.
@@ -73,9 +71,9 @@ let x: &[u8] = &[b'a', b'b'];
 let stack_str: &str = str::from_utf8(x).unwrap();
 ```
 
-## Best Practices
+# Best Practices
 
-### `String` vs. `&str`
+## `String` vs. `&str`
 
 In general, you should prefer `String` when you need ownership, and `&str` when
 you just need to borrow a string. This is very similar to using `Vec<T>` vs. `&[T]`,
@@ -98,7 +96,7 @@ need, and it can make your lifetimes more complex. Furthermore, you can pass
 either kind of string into `foo` by using `.as_slice()` on any `String` you
 need to pass in, so the `&str` version is more flexible.
 
-### Comparisons
+## Comparisons
 
 To compare a String to a constant string, prefer `as_slice()`...
 
@@ -123,7 +121,7 @@ fn compare(string: String) {
 Converting a `String` to a `&str` is cheap, but converting the `&str` to a
 `String` involves an allocation.
 
-## Other Documentation
+# Other Documentation
 
 * [the `&str` API documentation](/std/str/index.html)
 * [the `String` API documentation](std/string/index.html)

branches/auto/src/doc/index.md

@@ -13,6 +13,7 @@ li {list-style-type: none; }
 
 # Guides
 
+* [Strings](guide-strings.html)
 * [Pointers](guide-pointers.html)
 * [References and Lifetimes](guide-lifetimes.html)
 * [Containers and Iterators](guide-container.html)

branches/auto/src/libcollections/dlist.rs

@@ -278,23 +278,6 @@ impl<T> DList<T> {
     /// Move the last element to the front of the list.
     ///
     /// If the list is empty, do nothing.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::collections::{DList, Deque};
-    ///
-    /// let mut dl = DList::new();
-    /// dl.push_back(1i);
-    /// dl.push_back(2);
-    /// dl.push_back(3);
-    ///
-    /// dl.rotate_forward();
-    ///
-    /// for e in dl.iter() {
-    ///     println!("{}", e); // prints 3, then 1, then 2
-    /// }
-    /// ```
     #[inline]
     pub fn rotate_forward(&mut self) {
         self.pop_back_node().map(|tail| {
@@ -305,23 +288,6 @@ impl<T> DList<T> {
     /// Move the first element to the back of the list.
     ///
     /// If the list is empty, do nothing.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::collections::{DList, Deque};
-    ///
-    /// let mut dl = DList::new();
-    /// dl.push_back(1i);
-    /// dl.push_back(2);
-    /// dl.push_back(3);
-    ///
-    /// dl.rotate_backward();
-    ///
-    /// for e in dl.iter() {
-    ///     println!("{}", e); // prints 2, then 3, then 1
-    /// }
-    /// ```
     #[inline]
     pub fn rotate_backward(&mut self) {
         self.pop_front_node().map(|head| {
@@ -332,25 +298,6 @@ impl<T> DList<T> {
     /// Add all elements from `other` to the end of the list
     ///
     /// O(1)
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::collections::{DList, Deque};
-    ///
-    /// let mut a = DList::new();
-    /// let mut b = DList::new();
-    /// a.push_back(1i);
-    /// a.push_back(2);
-    /// b.push_back(3i);
-    /// b.push_back(4);
-    ///
-    /// a.append(b);
-    ///
-    /// for e in a.iter() {
-    ///     println!("{}", e); // prints 1, then 2, then 3, then 4
-    /// }
-    /// ```
     pub fn append(&mut self, mut other: DList<T>) {
         match self.list_tail.resolve() {
             None => *self = other,
@@ -373,25 +320,6 @@ impl<T> DList<T> {
     /// Add all elements from `other` to the beginning of the list
     ///
     /// O(1)
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::collections::{DList, Deque};
-    ///
-    /// let mut a = DList::new();
-    /// let mut b = DList::new();
-    /// a.push_back(1i);
-    /// a.push_back(2);
-    /// b.push_back(3i);
-    /// b.push_back(4);
-    ///
-    /// a.prepend(b);
-    ///
-    /// for e in a.iter() {
-    ///     println!("{}", e); // prints 3, then 4, then 1, then 2
-    /// }
-    /// ```
     #[inline]
     pub fn prepend(&mut self, mut other: DList<T>) {
         mem::swap(self, &mut other);
@@ -402,25 +330,6 @@ impl<T> DList<T> {
     /// or at the end.
     ///
     /// O(N)
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::collections::{DList, Deque};
-    ///
-    /// let mut a: DList<int> = DList::new();
-    /// a.push_back(2i);
-    /// a.push_back(4);
-    /// a.push_back(7);
-    /// a.push_back(8);
-    ///
-    /// // insert 11 before the first odd number in the list
-    /// a.insert_when(11, |&e, _| e % 2 == 1);
-    ///
-    /// for e in a.iter() {
-    ///     println!("{}", e); // prints 2, then 4, then 11, then 7, then 8
-    /// }
-    /// ```
     pub fn insert_when(&mut self, elt: T, f: |&T, &T| -> bool) {
         {
             let mut it = self.mut_iter();

branches/auto/src/libcollections/str.rs

@@ -808,7 +808,6 @@ impl OwnedStr for String {
 #[cfg(test)]
 mod tests {
     use std::iter::AdditiveIterator;
-    use std::iter::range;
     use std::default::Default;
     use std::char::Char;
     use std::clone::Clone;
@@ -1611,30 +1610,6 @@ mod tests {
         assert_eq!(pos, v.len());
     }
 
-    #[test]
-    fn test_chars_decoding() {
-        let mut bytes = [0u8, ..4];
-        for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
-            let len = c.encode_utf8(bytes);
-            let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
-            if Some(c) != s.chars().next() {
-                fail!("character {:x}={} does not decode correctly", c as u32, c);
-            }
-        }
-    }
-
-    #[test]
-    fn test_chars_rev_decoding() {
-        let mut bytes = [0u8, ..4];
-        for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
-            let len = c.encode_utf8(bytes);
-            let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
-            if Some(c) != s.chars().rev().next() {
-                fail!("character {:x}={} does not decode correctly", c as u32, c);
-            }
-        }
-    }
-
     #[test]
     fn test_iterator_clone() {
         let s = "ศไทย中华Việt Nam";
@@ -2265,26 +2240,16 @@ mod tests {
 #[cfg(test)]
 mod bench {
     use test::Bencher;
-    use test::black_box;
     use super::*;
-    use std::option::{None, Some};
     use std::iter::{Iterator, DoubleEndedIterator};
     use std::collections::Collection;
 
     #[bench]
     fn char_iterator(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+        let len = s.char_len();
 
-        b.iter(|| s.chars().count());
-    }
-
-    #[bench]
-    fn char_iterator_for(b: &mut Bencher) {
-        let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-        b.iter(|| {
-            for ch in s.chars() { black_box(ch) }
-        });
+        b.iter(|| assert_eq!(s.chars().count(), len));
     }
 
     #[bench]
@@ -2295,24 +2260,17 @@ mod bench {
         Mary had a little lamb, Little lamb
         Mary had a little lamb, Little lamb
         Mary had a little lamb, Little lamb";
+        let len = s.char_len();
 
-        b.iter(|| s.chars().count());
+        b.iter(|| assert_eq!(s.chars().count(), len));
     }
 
     #[bench]
     fn char_iterator_rev(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+        let len = s.char_len();
 
-        b.iter(|| s.chars().rev().count());
-    }
-
-    #[bench]
-    fn char_iterator_rev_for(b: &mut Bencher) {
-        let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-        b.iter(|| {
-            for ch in s.chars().rev() { black_box(ch) }
-        });
+        b.iter(|| assert_eq!(s.chars().rev().count(), len));
     }
 
     #[bench]

branches/auto/src/libcore/ops.rs

@@ -749,23 +749,19 @@ pub trait DerefMut<Result>: Deref<Result> {
 #[lang="fn"]
 pub trait Fn<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
     fn call(&self, args: Args) -> Result;
 }
 
 /// A version of the call operator that takes a mutable receiver.
 #[lang="fn_mut"]
 pub trait FnMut<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
     fn call_mut(&mut self, args: Args) -> Result;
 }
 
 /// A version of the call operator that takes a by-value receiver.
 #[lang="fn_once"]
 pub trait FnOnce<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
     fn call_once(self, args: Args) -> Result;
 }
-

branches/auto/src/libcore/prelude.rs

@@ -35,7 +35,6 @@ pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Drop, Deref, DerefMut};
 pub use ops::{Shl, Shr};
 pub use ops::{Index, IndexMut};
-pub use ops::{Fn, FnMut, FnOnce};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};