---

yaml
---
r: 277804
b: refs/heads/try
c: 6100b70
h: refs/heads/master

Author: birkenfeld

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: fb382df1f8e9f7124659f4cdb02f0ab311ea02b4
+refs/heads/try: 6100b70b98ee090c9b8e7b4788e4513e64fcc3ff
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/book/error-handling.md

@@ -1573,9 +1573,8 @@ detail on Getopts, but there is [some good documentation][15]
 describing it. The short story is that Getopts generates an argument
 parser and a help message from a vector of options (The fact that it
 is a vector is hidden behind a struct and a set of methods). Once the
-parsing is done, the parser returns a struct that records matches
-for defined options, and remaining "free" arguments.
-From there, we can get information about the flags, for
+parsing is done, we can decode the program arguments into a Rust
+struct. From there, we can get information about the flags, for
 instance, whether they were passed in, and what arguments they
 had. Here's our program with the appropriate `extern crate`
 statements, and the basic argument setup for Getopts:
@@ -1606,8 +1605,8 @@ fn main() {
         print_usage(&program, opts);
         return;
     }
-    let data_path = &matches.free[0];
-    let city: &str = &matches.free[1];
+    let data_path = &args[1];
+    let city = &args[2];
 
     // Do stuff with information
 }
@@ -1681,8 +1680,8 @@ fn main() {
         return;
     }
 
-    let data_path = &matches.free[0];
-    let city: &str = &matches.free[1];
+    let data_path = &args[1];
+    let city: &str = &args[2];
 
     let file = File::open(data_path).unwrap();
     let mut rdr = csv::Reader::from_reader(file);
@@ -1793,15 +1792,13 @@ fn main() {
         Ok(m)  => { m }
         Err(e) => { panic!(e.to_string()) }
     };
-
     if matches.opt_present("h") {
         print_usage(&program, opts);
         return;
     }
 
-    let data_path = &matches.free[0];
-    let city: &str = &matches.free[1];
-
+    let data_path = &args[1];
+    let city = &args[2];
     for pop in search(data_path, city) {
         println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
     }
@@ -1879,14 +1876,14 @@ when calling `search`:
 
 ```rust,ignore
 ...
-    match search(data_path, city) {
-        Ok(pops) => {
-            for pop in pops {
-                println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
-            }
+match search(&data_file, &city) {
+    Ok(pops) => {
+        for pop in pops {
+            println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
         }
-        Err(err) => println!("{}", err)
     }
+    Err(err) => println!("{}", err)
+}
 ...
 ```
 
@@ -1917,37 +1914,43 @@ fn print_usage(program: &str, opts: Options) {
     println!("{}", opts.usage(&format!("Usage: {} [options] <city>", program)));
 }
 ```
-Of course we need to adapt the argument handling code:
+The next part is going to be only a little harder:
 
 ```rust,ignore
 ...
-    let mut opts = Options::new();
-    opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME");
-    opts.optflag("h", "help", "Show this usage message.");
-    ...
-    let data_path = matches.opt_str("f");
-
-    let city = if !matches.free.is_empty() {
-        &matches.free[0]
-    } else {
-        print_usage(&program, opts);
-        return;
-    };
-
-    match search(&data_path, city) {
-        Ok(pops) => {
-            for pop in pops {
-                println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
-            }
+let mut opts = Options::new();
+opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME");
+opts.optflag("h", "help", "Show this usage message.");
+...
+let file = matches.opt_str("f");
+let data_file = &file.as_ref().map(Path::new);
+
+let city = if !matches.free.is_empty() {
+    &matches.free[0]
+} else {
+    print_usage(&program, opts);
+    return;
+};
+
+match search(data_file, city) {
+    Ok(pops) => {
+        for pop in pops {
+            println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
         }
-        Err(err) => println!("{}", err)
     }
+    Err(err) => println!("{}", err)
+}
 ...
 ```
 
-We've made the user experience a bit nicer by showing the usage message,
-instead of a panic from an out-of-bounds index, when `city`, the
-remaining free argument, is not present.
+In this piece of code, we take `file` (which has the type
+`Option<String>`), and convert it to a type that `search` can use, in
+this case, `&Option<AsRef<Path>>`. To do this, we take a reference of
+file, and map `Path::new` onto it. In this case, `as_ref()` converts
+the `Option<String>` into an `Option<&str>`, and from there, we can
+execute `Path::new` to the content of the optional, and return the
+optional of the new value. Once we have that, it is a simple matter of
+getting the `city` argument and executing `search`.
 
 Modifying `search` is slightly trickier. The `csv` crate can build a
 parser out of
@@ -1997,8 +2000,6 @@ enum CliError {
 And now for impls on `Display` and `Error`:
 
 ```rust,ignore
-use std::fmt;
-
 impl fmt::Display for CliError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -2019,13 +2020,13 @@ impl Error for CliError {
         }
     }
 
-    fn cause(&self) -> Option<&Error> {
-        match *self {
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {            
             CliError::Io(ref err) => Some(err),
-            CliError::Csv(ref err) => Some(err),
-            // Our custom error doesn't have an underlying cause,
-            // but we could modify it so that it does.
-            CliError::NotFound => None,
+            CliError::Parse(ref err) => Some(err),
+            // Our custom error doesn't have an underlying cause, but we could
+            // modify it so that it does.
+            CliError::NotFound() => None,
         }
     }
 }
@@ -2121,27 +2122,24 @@ string and add a flag to the Option variable. Once we've done that, Getopts does
 
 ```rust,ignore
 ...
-    let mut opts = Options::new();
-    opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME");
-    opts.optflag("h", "help", "Show this usage message.");
-    opts.optflag("q", "quiet", "Silences errors and warnings.");
+let mut opts = Options::new();
+opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME");
+opts.optflag("h", "help", "Show this usage message.");
+opts.optflag("q", "quiet", "Silences errors and warnings.");
 ...
 ```
 
 Now we only need to implement our “quiet” functionality. This requires us to
 tweak the case analysis in `main`:
 
 ```rust,ignore
-use std::process;
-...
-    match search(&data_path, city) {
-        Err(CliError::NotFound) if matches.opt_present("q") => process::exit(1),
-        Err(err) => panic!("{}", err),
-        Ok(pops) => for pop in pops {
-            println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
-        }
+match search(&args.arg_data_path, &args.arg_city) {
+    Err(CliError::NotFound) if args.flag_quiet => process::exit(1),
+    Err(err) => panic!("{}", err),
+    Ok(pops) => for pop in pops {
+        println!("{}, {}: {:?}", pop.city, pop.country, pop.count);
     }
-...
+}
 ```
 
 Certainly, we don't want to be quiet if there was an IO error or if the data

branches/try/src/doc/reference.md

@@ -2091,8 +2091,6 @@ The following configurations must be defined by the implementation:
 * `target_pointer_width = "..."` - Target pointer width in bits. This is set
   to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
   64-bit pointers.
-* `target_has_atomic = "..."` - Set of integer sizes on which the target can perform
-  atomic operations. Values are `"8"`, `"16"`, `"32"`, `"64"` and `"ptr"`.
 * `target_vendor = "..."` - Vendor of the target, for example `apple`, `pc`, or
   simply `"unknown"`.
 * `test` - Enabled when compiling the test harness (using the `--test` flag).
@@ -2297,9 +2295,6 @@ The currently implemented features of the reference compiler are:
 * `cfg_target_vendor` - Allows conditional compilation using the `target_vendor`
                         matcher which is subject to change.
 
-* `cfg_target_has_atomic` - Allows conditional compilation using the `target_has_atomic`
-                            matcher which is subject to change.
-
 * `concat_idents` - Allows use of the `concat_idents` macro, which is in many
                     ways insufficient for concatenating identifiers, and may be
                     removed entirely for something more wholesome.

branches/try/src/libcollectionstest/string.rs

@@ -52,7 +52,7 @@ fn test_from_utf8() {
                String::from("ศไทย中华Việt Nam"));
 
     let xs = b"hello\xFF".to_vec();
-    let err = String::from_utf8(xs).unwrap_err();
+    let err = String::from_utf8(xs).err().unwrap();
     assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
 }
 

branches/try/src/libcore/lib.rs

@@ -63,7 +63,6 @@
 #![feature(associated_type_defaults)]
 #![feature(concat_idents)]
 #![feature(const_fn)]
-#![feature(cfg_target_has_atomic)]
 #![feature(custom_attribute)]
 #![feature(fundamental)]
 #![feature(inclusive_range_syntax)]