---

yaml
---
r: 28111
b: refs/heads/try
c: 0c6e470
h: refs/heads/master
i:
  28109: 7b2c69a
  28107: 969d0dd
  28103: fea3e44
  28095: 18fc6ff
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: 3a1582012eafb8b672e15b12b5424e72ea6096af
+refs/heads/try: 0c6e470a257fc546555aa10ededded4a77460a71
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/cargo/cargo.rs

@@ -7,7 +7,7 @@ import rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest,
                                      get_cargo_sysroot, libdir};
 import syntax::diagnostic;
 
-import result::{ok, err};
+import result::{Ok, Err};
 import io::WriterUtil;
 import std::{map, json, tempfile, term, sort, getopts};
 import map::hashmap;
@@ -429,14 +429,14 @@ fn try_parse_sources(filename: &Path, sources: map::hashmap<~str, source>) {
     if !os::path_exists(filename)  { return; }
     let c = io::read_whole_file_str(filename);
     match json::from_str(result::get(c)) {
-        ok(json::dict(j)) => {
+        Ok(json::dict(j)) => {
           for j.each |k, v| {
                 sources.insert(k, parse_source(k, v));
                 debug!("source: %s", k);
             }
         }
-        ok(_) => fail ~"malformed sources.json",
-        err(e) => fail fmt!("%s:%s", filename.to_str(), e.to_str())
+        Ok(_) => fail ~"malformed sources.json",
+        Err(e) => fail fmt!("%s:%s", filename.to_str(), e.to_str())
     }
 }
 
@@ -548,17 +548,17 @@ fn load_source_info(c: cargo, src: source) {
     if !os::path_exists(&srcfile) { return; }
     let srcstr = io::read_whole_file_str(&srcfile);
     match json::from_str(result::get(srcstr)) {
-        ok(json::dict(s)) => {
+        Ok(json::dict(s)) => {
             let o = parse_source(src.name, json::dict(s));
 
             src.key = o.key;
             src.keyfp = o.keyfp;
         }
-        ok(_) => {
+        Ok(_) => {
             warn(~"malformed source.json: " + src.name +
                  ~"(source info is not a dict)");
         }
-        err(e) => {
+        Err(e) => {
             warn(fmt!("%s:%s", src.name, e.to_str()));
         }
     };
@@ -570,7 +570,7 @@ fn load_source_packages(c: cargo, src: source) {
     if !os::path_exists(&pkgfile) { return; }
     let pkgstr = io::read_whole_file_str(&pkgfile);
     match json::from_str(result::get(pkgstr)) {
-        ok(json::list(js)) => {
+        Ok(json::list(js)) => {
           for (*js).each |j| {
                 match j {
                     json::dict(p) => {
@@ -583,20 +583,20 @@ fn load_source_packages(c: cargo, src: source) {
                 }
             }
         }
-        ok(_) => {
+        Ok(_) => {
             warn(~"malformed packages.json: " + src.name +
                  ~"(packages is not a list)");
         }
-        err(e) => {
+        Err(e) => {
             warn(fmt!("%s:%s", src.name, e.to_str()));
         }
     };
 }
 
 fn build_cargo_options(argv: ~[~str]) -> options {
     let matches = match getopts::getopts(argv, opts()) {
-        result::ok(m) => m,
-        result::err(f) => {
+        result::Ok(m) => m,
+        result::Err(f) => {
             fail fmt!("%s", getopts::fail_str(f));
         }
     };
@@ -626,8 +626,8 @@ fn build_cargo_options(argv: ~[~str]) -> options {
 
 fn configure(opts: options) -> cargo {
     let home = match get_cargo_root() {
-        ok(home) => home,
-        err(_err) => result::get(get_cargo_sysroot())
+        Ok(home) => home,
+        Err(_err) => result::get(get_cargo_sysroot())
     };
 
     let get_cargo_dir = match opts.mode {
@@ -1571,7 +1571,7 @@ fn dump_sources(c: cargo) {
     }
 
     match io::buffered_file_writer(&out) {
-        result::ok(writer) => {
+        result::Ok(writer) => {
             let hash = map::str_hash();
             let root = json::dict(hash);
 
@@ -1600,7 +1600,7 @@ fn dump_sources(c: cargo) {
 
             writer.write_str(json::to_str(root));
         }
-        result::err(e) => {
+        result::Err(e) => {
             error(fmt!("could not dump sources: %s", e));
         }
     }

branches/try/src/compiletest/compiletest.rs

@@ -6,7 +6,7 @@ import vec;
 import task;
 
 import core::result;
-import result::{ok, err};
+import result::{Ok, Err};
 
 import common::config;
 import common::mode_run_pass;
@@ -38,8 +38,8 @@ fn parse_config(args: ~[~str]) -> config {
     let args_ = vec::tail(args);
     let matches =
         match getopts::getopts(args_, opts) {
-          ok(m) => m,
-          err(f) => fail getopts::fail_str(f)
+          Ok(m) => m,
+          Err(f) => fail getopts::fail_str(f)
         };
 
     fn opt_path(m: getopts::matches, nm: ~str) -> Path {

branches/try/src/libcore/either.rs

@@ -4,7 +4,7 @@
 
 //! A type that represents one of two alternatives
 
-import result::result;
+import result::Result;
 
 /// The either type
 enum Either<T, U> {
@@ -83,7 +83,7 @@ pure fn flip<T: copy, U: copy>(eith: &Either<T, U>) -> Either<U, T> {
     }
 }
 
-pure fn to_result<T: copy, U: copy>(eith: &Either<T, U>) -> result<U, T> {
+pure fn to_result<T: copy, U: copy>(eith: &Either<T, U>) -> Result<U, T> {
     /*!
      * Converts either::t to a result::t
      *
@@ -92,8 +92,8 @@ pure fn to_result<T: copy, U: copy>(eith: &Either<T, U>) -> result<U, T> {
      */
 
     match *eith {
-      Right(r) => result::ok(r),
-      Left(l) => result::err(l)
+      Right(r) => result::Ok(r),
+      Left(l) => result::Err(l)
     }
 }
 

branches/try/src/libcore/io.rs

@@ -4,7 +4,7 @@ Module: io
 Basic input/output
 */
 
-import result::result;
+import result::Result;
 
 import dvec::{DVec, dvec};
 import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
@@ -264,16 +264,16 @@ fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader {
 
 fn stdin() -> Reader { rustrt::rust_get_stdin() as Reader }
 
-fn file_reader(path: &Path) -> result<Reader, ~str> {
+fn file_reader(path: &Path) -> Result<Reader, ~str> {
     let f = os::as_c_charp(path.to_str(), |pathbuf| {
         os::as_c_charp("r", |modebuf|
             libc::fopen(pathbuf, modebuf)
         )
     });
-    return if f as uint == 0u { result::err(~"error opening "
+    return if f as uint == 0u { result::Err(~"error opening "
                                             + path.to_str()) }
     else {
-        result::ok(FILE_reader(f, true))
+        result::Ok(FILE_reader(f, true))
     }
 }
 
@@ -421,7 +421,7 @@ fn fd_writer(fd: fd_t, cleanup: bool) -> Writer {
 
 
 fn mk_file_writer(path: &Path, flags: ~[FileFlag])
-    -> result<Writer, ~str> {
+    -> Result<Writer, ~str> {
 
     #[cfg(windows)]
     fn wb() -> c_int { (O_WRONLY | O_BINARY) as c_int }
@@ -443,10 +443,10 @@ fn mk_file_writer(path: &Path, flags: ~[FileFlag])
                    (S_IRUSR | S_IWUSR) as c_int)
     };
     if fd < (0 as c_int) {
-        result::err(fmt!("error opening %s: %s", path.to_str(),
+        result::Err(fmt!("error opening %s: %s", path.to_str(),
                          os::last_os_error()))
     } else {
-        result::ok(fd_writer(fd, true))
+        result::Ok(fd_writer(fd, true))
     }
 }
 
@@ -623,21 +623,21 @@ impl<T: Writer> T : WriterUtil {
     fn write_u8(n: u8) { self.write(&[n]) }
 }
 
-fn file_writer(path: &Path, flags: ~[FileFlag]) -> result<Writer, ~str> {
-    result::chain(mk_file_writer(path, flags), |w| result::ok(w))
+fn file_writer(path: &Path, flags: ~[FileFlag]) -> Result<Writer, ~str> {
+    result::chain(mk_file_writer(path, flags), |w| result::Ok(w))
 }
 
 
 // FIXME: fileflags // #2004
-fn buffered_file_writer(path: &Path) -> result<Writer, ~str> {
+fn buffered_file_writer(path: &Path) -> Result<Writer, ~str> {
     let f = do os::as_c_charp(path.to_str()) |pathbuf| {
         do os::as_c_charp("w") |modebuf| {
             libc::fopen(pathbuf, modebuf)
         }
     };
-    return if f as uint == 0u { result::err(~"error opening "
+    return if f as uint == 0u { result::Err(~"error opening "
                                             + path.to_str()) }
-    else { result::ok(FILE_writer(f, true)) }
+    else { result::Ok(FILE_writer(f, true)) }
 }
 
 // FIXME (#2004) it would be great if this could be a const
@@ -719,21 +719,21 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: SeekStyle) ->
     return bpos as uint;
 }
 
-fn read_whole_file_str(file: &Path) -> result<~str, ~str> {
+fn read_whole_file_str(file: &Path) -> Result<~str, ~str> {
     result::chain(read_whole_file(file), |bytes| {
         if str::is_utf8(bytes) {
-            result::ok(str::from_bytes(bytes))
+            result::Ok(str::from_bytes(bytes))
        } else {
-           result::err(file.to_str() + ~" is not UTF-8")
+           result::Err(file.to_str() + ~" is not UTF-8")
        }
     })
 }
 
 // FIXME (#2004): implement this in a low-level way. Going through the
 // abstractions is pointless.
-fn read_whole_file(file: &Path) -> result<~[u8], ~str> {
+fn read_whole_file(file: &Path) -> Result<~[u8], ~str> {
     result::chain(file_reader(file), |rdr| {
-        result::ok(rdr.read_whole_stream())
+        result::Ok(rdr.read_whole_stream())
     })
 }
 
@@ -892,30 +892,30 @@ mod tests {
     #[test]
     fn file_reader_not_exist() {
         match io::file_reader(&Path("not a file")) {
-          result::err(e) => {
+          result::Err(e) => {
             assert e == ~"error opening not a file";
           }
-          result::ok(_) => fail
+          result::Ok(_) => fail
         }
     }
 
     #[test]
     fn file_writer_bad_name() {
         match io::file_writer(&Path("?/?"), ~[]) {
-          result::err(e) => {
+          result::Err(e) => {
             assert str::starts_with(e, "error opening");
           }
-          result::ok(_) => fail
+          result::Ok(_) => fail
         }
     }
 
     #[test]
     fn buffered_file_writer_bad_name() {
         match io::buffered_file_writer(&Path("?/?")) {
-          result::err(e) => {
+          result::Err(e) => {
             assert str::starts_with(e, "error opening");
           }
-          result::ok(_) => fail
+          result::Ok(_) => fail
         }
     }