---

yaml
---
r: 144621
b: refs/heads/try2
c: c70486f
h: refs/heads/master
i:
  144619: efffd4f
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 30fc2c8df2fc565b20d8df3a202cb0c7d089afd0
+refs/heads/try2: c70486fffe4d1eb682233749779cf0053cf83b01
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-container.md

@@ -105,14 +105,18 @@ impl Iterator<int> for ZeroStream {
 }
 ~~~
 
+In general, you cannot rely on the behavior of the `next()` method after it has
+returned `None`. Some iterators may return `None` forever. Others may behave
+differently.
+
 ## Container iterators
 
 Containers implement iteration over the contained elements by returning an
 iterator object. For example, vector slices several iterators available:
 
 * `iter()` and `rev_iter()`, for immutable references to the elements
 * `mut_iter()` and `mut_rev_iter()`, for mutable references to the elements
-* `move_iter()` and `move_rev_iter`, to move the elements out by-value
+* `move_iter()` and `move_rev_iter()`, to move the elements out by-value
 
 A typical mutable container will implement at least `iter()`, `mut_iter()` and
 `move_iter()` along with the reverse variants if it maintains an order.
@@ -149,7 +153,7 @@ let result = xs.iter().fold(0, |accumulator, item| accumulator - *item);
 assert_eq!(result, -41);
 ~~~
 
-Some adaptors return an adaptor object implementing the `Iterator` trait itself:
+Most adaptors return an adaptor object implementing the `Iterator` trait itself:
 
 ~~~
 let xs = [1, 9, 2, 3, 14, 12];
@@ -158,6 +162,35 @@ let sum = xs.iter().chain(ys.iter()).fold(0, |a, b| a + *b);
 assert_eq!(sum, 57);
 ~~~
 
+Some iterator adaptors may return `None` before exhausting the underlying
+iterator. Additionally, if these iterator adaptors are called again after
+returning `None`, they may call their underlying iterator again even if the
+adaptor will continue to return `None` forever. This may not be desired if the
+underlying iterator has side-effects.
+
+In order to provide a guarantee about behavior once `None` has been returned, an
+iterator adaptor named `fuse()` is provided. This returns an iterator that will
+never call its underlying iterator again once `None` has been returned:
+
+~~~
+let xs = [1,2,3,4,5];
+let mut calls = 0;
+let it = xs.iter().scan((), |_, x| {
+    calls += 1;
+    if *x < 3 { Some(x) } else { None }});
+// the iterator will only yield 1 and 2 before returning None
+// If we were to call it 5 times, calls would end up as 5, despite only 2 values
+// being yielded (and therefore 3 unique calls being made). The fuse() adaptor
+// can fix this.
+let mut it = it.fuse();
+it.next();
+it.next();
+it.next();
+it.next();
+it.next();
+assert_eq!(calls, 3);
+~~~
+
 ## For loops
 
 The function `range` (or `range_inclusive`) allows to simply iterate through a given range:

branches/try2/src/librustc/back/arm.rs

@@ -13,46 +13,46 @@ use driver::session::sess_os_to_meta_os;
 use driver::session;
 use metadata::loader::meta_section_name;
 
-pub fn get_target_strs(target_triple: ~str, target_os: session::os) -> target_strs::t {
+pub fn get_target_strs(target_triple: ~str, target_os: session::Os) -> target_strs::t {
     return target_strs::t {
         module_asm: ~"",
 
-        meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
+        meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)).to_owned(),
 
         data_layout: match target_os {
-          session::os_macos => {
+          session::OsMacos => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_win32 => {
+          session::OsWin32 => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_linux => {
+          session::OsLinux => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_android => {
+          session::OsAndroid => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_freebsd => {
+          session::OsFreebsd => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +

branches/try2/src/librustc/back/link.rs

@@ -814,13 +814,13 @@ pub fn mangle_internal_name_by_seq(_ccx: &mut CrateContext, flav: &str) -> ~str
 }
 
 
-pub fn output_dll_filename(os: session::os, lm: LinkMeta) -> ~str {
+pub fn output_dll_filename(os: session::Os, lm: LinkMeta) -> ~str {
     let (dll_prefix, dll_suffix) = match os {
-        session::os_win32 => (win32::DLL_PREFIX, win32::DLL_SUFFIX),
-        session::os_macos => (macos::DLL_PREFIX, macos::DLL_SUFFIX),
-        session::os_linux => (linux::DLL_PREFIX, linux::DLL_SUFFIX),
-        session::os_android => (android::DLL_PREFIX, android::DLL_SUFFIX),
-        session::os_freebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
+        session::OsWin32 => (win32::DLL_PREFIX, win32::DLL_SUFFIX),
+        session::OsMacos => (macos::DLL_PREFIX, macos::DLL_SUFFIX),
+        session::OsLinux => (linux::DLL_PREFIX, linux::DLL_SUFFIX),
+        session::OsAndroid => (android::DLL_PREFIX, android::DLL_SUFFIX),
+        session::OsFreebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
     };
     fmt!("%s%s-%s-%s%s", dll_prefix, lm.name, lm.extras_hash, lm.vers, dll_suffix)
 }
@@ -835,7 +835,7 @@ pub fn get_cc_prog(sess: Session) -> ~str {
     match sess.opts.linker {
         Some(ref linker) => linker.to_str(),
         None => match sess.targ_cfg.os {
-            session::os_android =>
+            session::OsAndroid =>
                 match &sess.opts.android_cross_path {
                     &Some(ref path) => {
                         fmt!("%s/bin/arm-linux-androideabi-gcc", *path)
@@ -845,7 +845,7 @@ pub fn get_cc_prog(sess: Session) -> ~str {
                                     (--android-cross-path)")
                     }
                 },
-            session::os_win32 => ~"g++",
+            session::OsWin32 => ~"g++",
             _ => ~"cc"
         }
     }
@@ -892,7 +892,7 @@ pub fn link_binary(sess: Session,
     }
 
     // Clean up on Darwin
-    if sess.targ_cfg.os == session::os_macos {
+    if sess.targ_cfg.os == session::OsMacos {
         run::process_status("dsymutil", [output.to_str()]);
     }
 
@@ -913,7 +913,7 @@ pub fn link_args(sess: Session,
     // Converts a library file-stem into a cc -l argument
     fn unlib(config: @session::config, stem: ~str) -> ~str {
         if stem.starts_with("lib") &&
-            config.os != session::os_win32 {
+            config.os != session::OsWin32 {
             stem.slice(3, stem.len()).to_owned()
         } else {
             stem
@@ -939,7 +939,7 @@ pub fn link_args(sess: Session,
         obj_filename.to_str()]);
 
     let lib_cmd = match sess.targ_cfg.os {
-        session::os_macos => ~"-dynamiclib",
+        session::OsMacos => ~"-dynamiclib",
         _ => ~"-shared"
     };
 
@@ -995,28 +995,28 @@ pub fn link_args(sess: Session,
 
         // On mac we need to tell the linker to let this library
         // be rpathed
-        if sess.targ_cfg.os == session::os_macos {
+        if sess.targ_cfg.os == session::OsMacos {
             args.push(~"-Wl,-install_name,@rpath/"
                       + output.filename().unwrap());
         }
     }
 
     // On linux librt and libdl are an indirect dependencies via rustrt,
     // and binutils 2.22+ won't add them automatically
-    if sess.targ_cfg.os == session::os_linux {
+    if sess.targ_cfg.os == session::OsLinux {
         args.push_all([~"-lrt", ~"-ldl"]);
 
         // LLVM implements the `frem` instruction as a call to `fmod`,
         // which lives in libm. Similar to above, on some linuxes we
         // have to be explicit about linking to it. See #2510
         args.push(~"-lm");
     }
-    else if sess.targ_cfg.os == session::os_android {
+    else if sess.targ_cfg.os == session::OsAndroid {
         args.push_all([~"-ldl", ~"-llog",  ~"-lsupc++", ~"-lgnustl_shared"]);
         args.push(~"-lm");
     }
 
-    if sess.targ_cfg.os == session::os_freebsd {
+    if sess.targ_cfg.os == session::OsFreebsd {
         args.push_all([~"-pthread", ~"-lrt",
                        ~"-L/usr/local/lib", ~"-lexecinfo",
                        ~"-L/usr/local/lib/gcc46",
@@ -1030,7 +1030,7 @@ pub fn link_args(sess: Session,
     // linker from the dwarf unwind info. Unfortunately, it does not seem to
     // understand how to unwind our __morestack frame, so we have to turn it
     // off. This has impacted some other projects like GHC.
-    if sess.targ_cfg.os == session::os_macos {
+    if sess.targ_cfg.os == session::OsMacos {
         args.push(~"-Wl,-no_compact_unwind");
     }
 

branches/try2/src/librustc/back/mips.rs

@@ -13,46 +13,46 @@ use driver::session;
 use driver::session::sess_os_to_meta_os;
 use metadata::loader::meta_section_name;
 
-pub fn get_target_strs(target_triple: ~str, target_os: session::os) -> target_strs::t {
+pub fn get_target_strs(target_triple: ~str, target_os: session::Os) -> target_strs::t {
     return target_strs::t {
         module_asm: ~"",
 
-        meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
+        meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)).to_owned(),
 
         data_layout: match target_os {
-          session::os_macos => {
+          session::OsMacos => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_win32 => {
+          session::OsWin32 => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_linux => {
+          session::OsLinux => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_android => {
+          session::OsAndroid => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
-          session::os_freebsd => {
+          session::OsFreebsd => {
             ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +

branches/try2/src/librustc/back/rpath.rs

@@ -16,16 +16,16 @@ use metadata::filesearch;
 use std::hashmap::HashSet;
 use std::{os, util, vec};
 
-fn not_win32(os: session::os) -> bool {
-  os != session::os_win32
+fn not_win32(os: session::Os) -> bool {
+  os != session::OsWin32
 }
 
 pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
                     -> ~[~str] {
     let os = sess.targ_cfg.os;
 
     // No rpath on windows
-    if os == session::os_win32 {
+    if os == session::OsWin32 {
         return ~[];
     }
 
@@ -52,7 +52,7 @@ pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
     rpaths.iter().map(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect()
 }
 
-fn get_rpaths(os: session::os,
+fn get_rpaths(os: session::Os,
               sysroot: &Path,
               output: &Path,
               libs: &[Path],
@@ -97,13 +97,13 @@ fn get_rpaths(os: session::os,
     return rpaths;
 }
 
-fn get_rpaths_relative_to_output(os: session::os,
+fn get_rpaths_relative_to_output(os: session::Os,
                                  output: &Path,
                                  libs: &[Path]) -> ~[Path] {
     libs.iter().map(|a| get_rpath_relative_to_output(os, output, a)).collect()
 }
 
-pub fn get_rpath_relative_to_output(os: session::os,
+pub fn get_rpath_relative_to_output(os: session::Os,
                                     output: &Path,
                                     lib: &Path)
                                  -> Path {
@@ -113,10 +113,10 @@ pub fn get_rpath_relative_to_output(os: session::os,
 
     // Mac doesn't appear to support $ORIGIN
     let prefix = match os {
-        session::os_android | session::os_linux | session::os_freebsd
+        session::OsAndroid | session::OsLinux | session::OsFreebsd
                           => "$ORIGIN",
-        session::os_macos => "@executable_path",
-        session::os_win32 => util::unreachable()
+        session::OsMacos => "@executable_path",
+        session::OsWin32 => util::unreachable()
     };
 
     Path(prefix).push_rel(&os::make_absolute(output).get_relative_to(&os::make_absolute(lib)))
@@ -205,7 +205,7 @@ mod test {
     #[cfg(target_os = "linux")]
     #[cfg(target_os = "android")]
     fn test_rpath_relative() {
-      let o = session::os_linux;
+      let o = session::OsLinux;
       let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
       assert_eq!(res.to_str(), ~"$ORIGIN/../lib");
@@ -214,7 +214,7 @@ mod test {
     #[test]
     #[cfg(target_os = "freebsd")]
     fn test_rpath_relative() {
-        let o = session::os_freebsd;
+        let o = session::OsFreebsd;
         let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
         assert_eq!(res.to_str(), ~"$ORIGIN/../lib");
@@ -223,7 +223,7 @@ mod test {
     #[test]
     #[cfg(target_os = "macos")]
     fn test_rpath_relative() {
-        let o = session::os_macos;
+        let o = session::OsMacos;
         let res = get_rpath_relative_to_output(o,
                                                &Path("bin/rustc"),
                                                &Path("lib/libstd.so"));