---

yaml
---
r: 12097
b: refs/heads/master
c: 042c532
h: refs/heads/master
i:
  12095: e5dfbeb
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 40443768b16747cb3ef90a2fb2fd9e7f317ff383
+refs/heads/master: 042c532a084fa3871a3a2d8955ff82c246db8015
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libcore/iter.rs

@@ -169,14 +169,14 @@ fn test_enumerate() {
 #[test]
 fn test_map_and_to_list() {
     let a = bind vec::iter([0, 1, 2], _);
-    let b = bind map(a, {|i| i*2}, _);
+    let b = bind map(a, {|i| 2*i}, _);
     let c = to_list(b);
     assert c == [0, 2, 4];
 }
 
 #[test]
 fn test_map_directly_on_vec() {
-    let b = bind map([0, 1, 2], {|i| i*2}, _);
+    let b = bind map([0, 1, 2], {|i| 2*i}, _);
     let c = to_list(b);
     assert c == [0, 2, 4];
 }

trunk/src/libcore/result.rs

@@ -91,6 +91,24 @@ fn chain<T, U: copy, V: copy>(res: result<T, V>, op: fn(T) -> result<U, V>)
     }
 }
 
+#[doc = "
+Call a function based on a previous result
+
+If `res` is `err` then the value is extracted and passed to `op`
+whereupon `op`s result is returned. if `res` is `ok` then it is
+immediately returned.  This function can be used to pass through a
+successful result while handling an error.
+"]
+fn chain_err<T: copy, U: copy, V: copy>(
+    res: result<T, V>,
+    op: fn(V) -> result<T, U>)
+    -> result<T, U> {
+    alt res {
+      ok(t) { ok(t) }
+      err(v) { op(v) }
+    }
+}
+
 // ______________________________________________________________________
 // Note:
 //
@@ -171,6 +189,22 @@ fn map2<S,T,U:copy,V:copy,W>(ss: [S], ts: [T],
     ret nxt(vs);
 }
 
+fn iter2<S,T,U:copy>(ss: [S], ts: [T],
+                     op: fn(S,T) -> result<(),U>)
+    : vec::same_length(ss, ts)
+    -> result<(),U> {
+    let n = vec::len(ts);
+    let mut i = 0u;
+    while i < n {
+        alt op(ss[i],ts[i]) {
+          ok(()) { }
+          err(u) { ret err(u); }
+        }
+        i += 1u;
+    }
+    ret ok(());
+}
+
 #[cfg(test)]
 mod tests {
     fn op1() -> result::result<int, str> { result::ok(666) }

trunk/src/libcore/vec.rs

@@ -27,6 +27,7 @@ export rsplit;
 export rsplitn;
 export shift;
 export pop;
+export clear;
 export push;
 export grow;
 export grow_fn;
@@ -164,6 +165,13 @@ fn from_mut<T>(+v: [mutable T]) -> [T] unsafe {
     r
 }
 
+// This function only exists to work around bugs in the type checker.
+fn from_const<T>(+v: [const T]) -> [T] unsafe {
+    let r = ::unsafe::reinterpret_cast(v);
+    ::unsafe::forget(v);
+    r
+}
+
 // Accessors
 
 #[doc = "Returns the first element of a vector"]
@@ -336,6 +344,14 @@ fn pop<T>(&v: [const T]) -> T unsafe {
     val
 }
 
+#[doc = "
+Removes all elements from a vector without affecting
+how much space is reserved.
+"]
+fn clear<T>(&v: [const T]) unsafe {
+    unsafe::set_len(v, 0u);
+}
+
 #[doc = "Append an element to a vector"]
 fn push<T>(&v: [const T], +initval: T) {
     v += [initval];
@@ -466,8 +482,8 @@ Concatenate a vector of vectors.
 Flattens a vector of vectors of T into a single vector of T.
 "]
 fn concat<T: copy>(v: [const [const T]]) -> [T] {
-    let mut r: [T] = [];
-    for inner: [T] in v { r += inner; }
+    let mut r = [];
+    for inner in v { r += from_const(inner); }
     ret r;
 }
 
@@ -477,9 +493,9 @@ Concatenate a vector of vectors, placing a given separator between each
 fn connect<T: copy>(v: [const [const T]], sep: T) -> [T] {
     let mut r: [T] = [];
     let mut first = true;
-    for inner: [T] in v {
+    for inner in v {
         if first { first = false; } else { push(r, sep); }
-        r += inner;
+        r += from_const(inner);
     }
     ret r;
 }
@@ -885,7 +901,7 @@ fn as_mut_buf<E,T>(v: [mutable E], f: fn(*mutable E) -> T) -> T unsafe {
 }
 
 #[doc = "An extension implementation providing a `len` method"]
-impl vec_len<T> for [T] {
+impl vec_len<T> for [const T] {
     #[doc = "Return the length of the vector"]
     #[inline(always)]
     fn len() -> uint { len(self) }

trunk/src/libstd/getopts.rs

@@ -63,6 +63,7 @@ export opt_str;
 export opt_strs;
 export opt_maybe_str;
 export opt_default;
+export result; //NDM
 
 enum name { long(str), short(char), }
 

trunk/src/rustc/metadata/astencode.rs

@@ -634,6 +634,7 @@ impl helpers for @e::encode_ctxt {
     fn ty_str_ctxt() -> @tyencode::ctxt {
         @{ds: e::def_to_str,
           tcx: self.ccx.tcx,
+          reachable: self.ccx.reachable,
           abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
     }
 }

trunk/src/rustc/metadata/encoder.rs

@@ -221,6 +221,7 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
                             params: [ty_param]) {
     let ty_str_ctxt = @{ds: def_to_str,
                         tcx: ecx.ccx.tcx,
+                        reachable: ecx.ccx.reachable,
                         abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     for param in params {
         ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
@@ -240,6 +241,7 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
     let ty_str_ctxt =
         @{ds: def_to_str,
           tcx: ecx.ccx.tcx,
+          reachable: ecx.ccx.reachable,
           abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
 }
@@ -966,7 +968,10 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> [u8] {
 
 // Get the encoded string for a type
 fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> str {
-    let cx = @{ds: def_to_str, tcx: tcx, abbrevs: tyencode::ac_no_abbrevs};
+    let cx = @{ds: def_to_str,
+               tcx: tcx,
+               reachable: std::map::int_hash(),
+               abbrevs: tyencode::ac_no_abbrevs};
     let buf = io::mem_buffer();
     tyencode::enc_ty(io::mem_buffer_writer(buf), cx, t);
     ret io::mem_buffer_str(buf);

trunk/src/rustc/metadata/tyencode.rs

@@ -6,6 +6,7 @@ import syntax::ast::*;
 import driver::session::session;
 import middle::ty;
 import syntax::print::pprust::*;
+import middle::trans::reachable;
 
 export ctxt;
 export ty_abbrev;
@@ -18,7 +19,8 @@ export enc_mode;
 type ctxt =
     // Def -> str Callback:
     // The type context.
-    {ds: fn@(def_id) -> str, tcx: ty::ctxt, abbrevs: abbrev_ctxt};
+    {ds: fn@(def_id) -> str, tcx: ty::ctxt,
+     reachable: reachable::map, abbrevs: abbrev_ctxt};
 
 // Compact string representation for ty.t values. API ty_str & parse_from_str.
 // Extra parameters are for converting to/from def_ids in the string rep.
@@ -55,9 +57,14 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) {
             let pos = w.tell();
             alt ty::type_def_id(t) {
               some(def_id) {
-                w.write_char('"');
-                w.write_str(cx.ds(def_id));
-                w.write_char('|');
+                // Do not emit node ids that map to unexported names.  Those
+                // are not helpful.
+                if def_id.crate != local_crate ||
+                    cx.reachable.contains_key(def_id.node) {
+                    w.write_char('"');
+                    w.write_str(cx.ds(def_id));
+                    w.write_char('|');
+                }
               }
               _ {}
             }