Repository: kbknapp/clap-rs
Pull request #867 (2017-02-21 02:16:36)

Stop the leaks


Patch:
diff --git a/src/app/help.rs b/src/app/help.rs
index ad677756..848671a8 100644
--- a/src/app/help.rs
+++ b/src/app/help.rs
@@ -384,7 +384,8 @@ impl<'a> Help<'a> {
         debugln!("Help::write_before_after_help;");
         let mut help = String::new();
         // determine if our help fits or needs to wrap
-        debugln!("Help::write_before_after_help: Term width...{}", self.term_w);
+        debugln!("Help::write_before_after_help: Term width...{}",
+                 self.term_w);
         let too_long = str_width(h) >= self.term_w;
 
         debug!("Help::write_before_after_help: Too long...");
@@ -392,10 +393,12 @@ impl<'a> Help<'a> {
             sdebugln!("Yes");
             help.push_str(h);
             debugln!("Help::write_before_after_help: help: {}", help);
-            debugln!("Help::write_before_after_help: help width: {}", str_width(&*help));
+            debugln!("Help::write_before_after_help: help width: {}",
+                     str_width(&*help));
             // Determine how many newlines we need to insert
-            debugln!("Help::write_before_after_help: Usable space: {}", self.term_w);
-            let longest_w = find_longest!(help);            
+            debugln!("Help::write_before_after_help: Usable space: {}",
+                     self.term_w);
+            let longest_w = find_longest!(help);
             help = help.replace("{n}", "\n");
             wrap_help(&mut help, longest_w, self.term_w);
         } else {
@@ -451,7 +454,7 @@ impl<'a> Help<'a> {
             // Determine how many newlines we need to insert
             let avail_chars = self.term_w - spcs;
             debugln!("Help::help: Usable space...{}", avail_chars);
-            let longest_w = find_longest!(help);            
+            let longest_w = find_longest!(help);
             help = help.replace("{n}", "\n");
             wrap_help(&mut help, longest_w, avail_chars);
         } else {
@@ -491,12 +494,12 @@ impl<'a> Help<'a> {
         debugln!("Help::spec_vals: a={}", a);
         let mut spec_vals = vec![];
         if let Some(pv) = a.default_val() {
-            debugln!("Help::spec_vals: Found default value...[{}]", pv);
+            debugln!("Help::spec_vals: Found default value...[{:?}]", pv);
             spec_vals.push(format!(" [default: {}]",
                                    if self.color {
-                                       self.cizer.good(pv)
+                                       self.cizer.good(pv.to_string_lossy())
                                    } else {
-                                       Format::None(pv)
+                                       Format::None(pv.to_string_lossy())
                                    }));
         }
         if let Some(ref aliases) = a.aliases() {
@@ -938,7 +941,8 @@ fn wrap_help(help: &mut String, longest_w: usize, avail_chars: usize) {
             debugln!("Help::wrap_help:iter: idx={}, g={}", idx, g);
             if g == "\n" {
                 debugln!("Help::wrap_help:iter: Newline found...");
-                debugln!("Help::wrap_help:iter: Still space...{:?}", str_width(&help[j..idx]) < avail_chars);
+                debugln!("Help::wrap_help:iter: Still space...{:?}",
+                         str_width(&help[j..idx]) < avail_chars);
                 if str_width(&help[j..idx]) < avail_chars {
                     j = idx;
                     continue;
@@ -957,7 +961,7 @@ fn wrap_help(help: &mut String, longest_w: usize, avail_chars: usize) {
             j = prev_space;
             debugln!("Help::wrap_help:iter: prev_space={}, j={}", prev_space, j);
             debugln!("Help::wrap_help:iter: Removing...{}", j);
-            debugln!("Help::wrap_help:iter: Char at {}: {:?}", j, &help[j..j+1]);
+            debugln!("Help::wrap_help:iter: Char at {}: {:?}", j, &help[j..j + 1]);
             help.remove(j);
             help.insert(j, '\n');
             prev_space = idx;
diff --git a/src/app/mod.rs b/src/app/mod.rs
index 4a6afb01..7135e9f7 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -24,8 +24,7 @@ use yaml_rust::Yaml;
 // Internal
 use app::help::Help;
 use app::parser::Parser;
-use args::{ArgKind, AnyArg, Arg, ArgGroup, ArgMatcher, ArgMatches, ArgSettings};
-use errors::Error;
+use args::{AnyArg, Arg, ArgGroup, ArgMatcher, ArgMatches, ArgSettings};
 use errors::Result as ClapResult;
 pub use self::settings::AppSettings;
 use completions::Shell;
@@ -1268,7 +1267,21 @@ impl<'a, 'b> App<'a, 'b> {
     {
         self.get_matches_from_safe_borrow(itr).unwrap_or_else(|e| {
             // Otherwise, write to stderr and exit
-            self.maybe_wait_for_exit(e);
+            if e.use_stderr() {
+                wlnerr!("{}", e.message);
+                if self.p.is_set(AppSettings::WaitOnError) {
+                    wlnerr!("\nPress [ENTER] / [RETURN] to continue...");
+                    let mut s = String::new();
+                    let i = io::stdin();
+                    i.lock().read_line(&mut s).unwrap();
+                }
+                drop(self);
+                drop(e);
+                process::exit(1);
+            }
+
+            drop(self);
+            e.exit()
         })
     }
 
@@ -1373,29 +1386,12 @@ impl<'a, 'b> App<'a, 'b> {
 
         if self.p.is_set(AppSettings::PropagateGlobalValuesDown) {
             for a in &self.p.global_args {
-                matcher.propagate(a.name);
+                matcher.propagate(a.b.name);
             }
         }
 
         Ok(matcher.into())
     }
-
-    // Re-implements ClapError::exit except it checks if we should wait for input before exiting
-    // since ClapError doesn't have that info and the error message must be printed before exiting
-    fn maybe_wait_for_exit(&self, e: Error) -> ! {
-        if e.use_stderr() {
-            wlnerr!("{}", e.message);
-            if self.p.is_set(AppSettings::WaitOnError) {
-                wlnerr!("\nPress [ENTER] / [RETURN] to continue...");
-                let mut s = String::new();
-                let i = io::stdin();
-                i.lock().read_line(&mut s).unwrap();
-            }
-            process::exit(1);
-        }
-
-        e.exit()
-    }
 }
 
 #[cfg(feature = "yaml")]
@@ -1536,14 +1532,13 @@ impl<'n, 'e> AnyArg<'n, 'e> for App<'n, 'e> {
         unreachable!("App struct does not support AnyArg::name, this is a bug!")
     }
     fn id(&self) -> usize { self.p.id }
-    fn kind(&self) -> ArgKind { ArgKind::Subcmd }
     fn overrides(&self) -> Option<&[&'e str]> { None }
     fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { None }
     fn blacklist(&self) -> Option<&[&'e str]> { None }
     fn required_unless(&self) -> Option<&[&'e str]> { None }
     fn val_names(&self) -> Option<&VecMap<&'e str>> { None }
     fn is_set(&self, _: ArgSettings) -> bool { false }
-    fn val_terminator(&self) -> Option<&'e str> {None}
+    fn val_terminator(&self) -> Option<&'e str> { None }
     fn set(&mut self, _: ArgSettings) {
         unreachable!("App struct does not support AnyArg::set, this is a bug!")
     }
@@ -1559,8 +1554,10 @@ impl<'n, 'e> AnyArg<'n, 'e> for App<'n, 'e> {
     fn val_delim(&self) -> Option<char> { None }
     fn takes_value(&self) -> bool { true }
     fn help(&self) -> Option<&'e str> { self.p.meta.about }
-    fn default_val(&self) -> Option<&'n str> { None }
-    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>> {None}
+    fn default_val(&self) -> Option<&'e OsStr> { None }
+    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e OsStr>, &'e OsStr)>> {
+        None
+    }
     fn longest_filter(&self) -> bool { true }
     fn aliases(&self) -> Option<Vec<&'e str>> {
         if let Some(ref aliases) = self.p.meta.aliases {
diff --git a/src/app/parser.rs b/src/app/parser.rs
index 350f5bfd..4b5ec83c 100644
--- a/src/app/parser.rs
+++ b/src/app/parser.rs
@@ -148,28 +148,28 @@ impl<'a, 'b> Parser<'a, 'b>
 
     // actually adds the arguments
     pub fn add_arg(&mut self, a: &Arg<'a, 'b>) {
-        debug_assert!(!(self.flags.iter().any(|f| &f.b.name == &a.name) ||
-                        self.opts.iter().any(|o| o.b.name == a.name) ||
-                        self.positionals.values().any(|p| p.b.name == a.name)),
-                      format!("Non-unique argument name: {} is already in use", a.name));
+        debug_assert!(!(self.flags.iter().any(|f| &f.b.name == &a.b.name) ||
+                        self.opts.iter().any(|o| o.b.name == a.b.name) ||
+                        self.positionals.values().any(|p| p.b.name == a.b.name)),
+                      format!("Non-unique argument name: {} is already in use", a.b.name));
         if let Some(ref r_ifs) = a.r_ifs {
             for &(arg, val) in r_ifs {
-                self.r_ifs.push((arg, val, a.name));
+                self.r_ifs.push((arg, val, a.b.name));
             }
         }
-        if let Some(ref grps) = a.groups {
+        if let Some(ref grps) = a.b.groups {
             for g in grps {
                 let ag = self.groups.entry(g).or_insert_with(|| ArgGroup::with_name(g));
-                ag.args.push(a.name);
+                ag.args.push(a.b.name);
             }
         }
-        if let Some(s) = a.short {
+        if let Some(s) = a.s.short {
             debug_assert!(!self.short_list.contains(&s),
                           format!("Argument short must be unique\n\n\t-{} is already in use",
                                   s));
             self.short_list.push(s);
         }
-        if let Some(l) = a.long {
+        if let Some(l) = a.s.long {
             debug_assert!(!self.long_list.contains(&l),
                           format!("Argument long must be unique\n\n\t--{} is already in use",
                                   l));
@@ -181,9 +181,9 @@ impl<'a, 'b> Parser<'a, 'b>
             }
         }
         if a.is_set(ArgSettings::Required) {
-            self.required.push(a.name);
+            self.required.push(a.b.name);
         }
-        if a.index.is_some() || (a.short.is_none() && a.long.is_none()) {
+        if a.index.is_some() || (a.s.short.is_none() && a.s.long.is_none()) {
             let i = if a.index.is_none() {
                 (self.positionals.len() + 1)
             } else {
@@ -193,7 +193,7 @@ impl<'a, 'b> Parser<'a, 'b>
                           format!("Argument \"{}\" has the same index as another positional \
                     argument\n\n\tPerhaps try .multiple(true) to allow one positional argument \
                     to take multiple values",
-                                  a.name));
+                                  a.b.name));
             let pb = PosBuilder::from_arg(a, i as u64, &mut self.required);
             self.positionals.insert(i, pb);
         } else if a.is_set(ArgSettings::TakesValue) {
@@ -213,7 +213,7 @@ impl<'a, 'b> Parser<'a, 'b>
             debug_assert!(!a.is_set(ArgSettings::Required),
                           format!("Global arguments cannot be required.\n\n\t'{}' is marked as \
                           global and required",
-                                  a.name));
+                                  a.b.name));
             self.global_args.push(a.into());
         }
     }
@@ -243,7 +243,8 @@ impl<'a, 'b> Parser<'a, 'b>
 
     pub fn add_subcommand(&mut self, mut subcmd: App<'a, 'b>) {
         debugln!("Parser::add_subcommand: term_w={:?}, name={}",
-                 self.meta.term_w, subcmd.p.meta.name);
+                 self.meta.term_w,
+                 subcmd.p.meta.name);
         subcmd.p.meta.term_w = self.meta.term_w;
         if subcmd.p.meta.name == "help" {
             self.settings.unset(AppSettings::NeedsSubcommandHelp);
@@ -253,11 +254,14 @@ impl<'a, 'b> Parser<'a, 'b>
     }
 
     pub fn propogate_settings(&mut self) {
-        debugln!("Parser::propogate_settings: self={}, g_settings={:#?}", 
-            self.meta.name, self.g_settings);
+        debugln!("Parser::propogate_settings: self={}, g_settings={:#?}",
+                 self.meta.name,
+                 self.g_settings);
         for sc in &mut self.subcommands {
-            debugln!("Parser::propogate_settings: sc={}, settings={:#?}, g_settings={:#?}", 
-                sc.p.meta.name, sc.p.settings, sc.p.g_settings);
+            debugln!("Parser::propogate_settings: sc={}, settings={:#?}, g_settings={:#?}",
+                     sc.p.meta.name,
+                     sc.p.settings,
+                     sc.p.g_settings);
             // We have to create a new scope in order to tell rustc the borrow of `sc` is
             // done and to recursively call this method
             {
@@ -308,12 +312,15 @@ impl<'a, 'b> Parser<'a, 'b>
 
     pub fn required(&self) -> Iter<&str> { self.required.iter() }
 
+    #[cfg_attr(feature = "lints", allow(needless_borrow))]
     pub fn get_required_from(&self,
                              reqs: &[&'a str],
                              matcher: Option<&ArgMatcher<'a>>,
                              extra: Option<&str>)
                              -> VecDeque<String> {
-        debugln!("Parser::get_required_from: reqs={:?}, extra={:?}", reqs, extra);
+        debugln!("Parser::get_required_from: reqs={:?}, extra={:?}",
+                 reqs,
+                 extra);
         let mut c_flags: Vec<&str> = vec![];
         let mut c_pos: Vec<&str> = vec![];
         let mut c_opt: Vec<&str> = vec![];
@@ -402,7 +409,7 @@ impl<'a, 'b> Parser<'a, 'b>
             .filter_map(|p| self.positionals.values().find(|x| x.b.name == p))
             .filter(|p| !args_in_groups.contains(&p.b.name))
             .map(|p| (p.index, p))
-            .collect::<BTreeMap<u64, &PosBuilder>>();// sort by index
+            .collect::<BTreeMap<u64, &PosBuilder>>(); // sort by index
         debugln!("Parser::get_required_from: args_in_groups={:?}", args_in_groups);
         for &p in pmap.values() {
             let s = p.to_string();
@@ -547,12 +554,12 @@ impl<'a, 'b> Parser<'a, 'b>
         }
 
         // Next we verify that only the highest index has a .multiple(true) (if any)
-        if self.positionals
-            .values()
-            .any(|a| {
-                a.b.settings.is_set(ArgSettings::Multiple) &&
-                (a.index as usize != self.positionals.len())
-            }) {
+        if 
+            self.positionals
+                .values()
+                .any(|a| {
+                    a.is_set(ArgSettings::Multiple) && (a.index as usize != self.positionals.len())
+                }) {
 
             debug_assert!({
                     let mut it = self.positionals.values().rev();
@@ -827,7 +834,7 @@ impl<'a, 'b> Parser<'a, 'b>
                     if let Some(name) = needs_val_of {
                         // Check to see if parsing a value from a previous arg
                         if let Some(arg) = find_by_name!(self, &name, opts, iter) {
-                        // get the OptBuilder so we can check the settings
+                            // get the OptBuilder so we can check the settings
                             needs_val_of = try!(self.add_val_to_arg(&*arg, &arg_os, matcher));
                             // get the next value from the iterator
                             continue;
@@ -843,7 +850,8 @@ impl<'a, 'b> Parser<'a, 'b>
                         }
 
                         needs_val_of = try!(self.parse_long_arg(matcher, &arg_os));
-                        if !(needs_val_of.is_none() && self.is_set(AppSettings::AllowLeadingHyphen)) {
+                        if !(needs_val_of.is_none() &&
+                             self.is_set(AppSettings::AllowLeadingHyphen)) {
                             continue;
                         }
                     } else if arg_os.starts_with(b"-") && arg_os.len_() != 1 {
@@ -855,7 +863,7 @@ impl<'a, 'b> Parser<'a, 'b>
                         if needs_val_of.is_none() {
                             if self.is_set(AppSettings::AllowNegativeNumbers) {
                                 if !(arg_os.to_string_lossy().parse::<i64>().is_ok() ||
-                                    arg_os.to_string_lossy().parse::<f64>().is_ok()) {
+                                     arg_os.to_string_lossy().parse::<f64>().is_ok()) {
                                     return Err(Error::unknown_argument(&*arg_os.to_string_lossy(),
                                                                 "",
                                                                 &*self.create_current_usage(matcher, None),
@@ -871,19 +879,20 @@ impl<'a, 'b> Parser<'a, 'b>
                 }
 
                 if !self.is_set(AppSettings::ArgsNegateSubcommands) {
-                    if let Some(cdate) =
-                    suggestions::did_you_mean(&*arg_os.to_string_lossy(),
-                                              self.subcommands
-                                                  .iter()
-                                                  .map(|s| &s.p.meta.name)) {
-                        return Err(Error::invalid_subcommand(arg_os.to_string_lossy().into_owned(),
-                                                            cdate,
-                                                            self.meta
-                                                                .bin_name
-                                                                .as_ref()
-                                                                .unwrap_or(&self.meta.name),
-                                                            &*self.create_current_usage(matcher, None),
-                                                            self.color()));
+                    if let Some(cdate) = suggestions::did_you_mean(&*arg_os.to_string_lossy(),
+                                                                   self.subcommands
+                                                                       .iter()
+                                                                       .map(|s| &s.p.meta.name)) {
+                        return Err(Error::invalid_subcommand(arg_os.to_string_lossy()
+                                                                 .into_owned(),
+                                                             cdate,
+                                                             self.meta
+                                                                 .bin_name
+                                                                 .as_ref()
+                                                                 .unwrap_or(&self.meta.name),
+                                                             &*self.create_current_usage(matcher,
+                                                                                         None),
+                                                             self.color()));
                     }
                 }
             }
@@ -892,8 +901,8 @@ impl<'a, 'b> Parser<'a, 'b>
                                   !self.positionals.is_empty() &&
                                   pos_counter == (self.positionals.len() - 1);
             let missing_pos = self.is_set(AppSettings::AllowMissingPositional) &&
-                                  !self.positionals.is_empty() &&
-                                  pos_counter == (self.positionals.len() - 1);
+                              !self.positionals.is_empty() &&
+                              pos_counter == (self.positionals.len() - 1);
             debugln!("Parser::get_matches_with: Low index multiples...{:?}", low_index_mults);
             debugln!("Parser::get_matches_with: Positional counter...{}", pos_counter);
             if low_index_mults || missing_pos {
@@ -931,7 +940,8 @@ impl<'a, 'b> Parser<'a, 'b>
                     Some(s) => s.to_string(),
                     None => {
                         if !self.settings.is_set(AppSettings::StrictUtf8) {
-                            return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None),
+                            return Err(Error::invalid_utf8(&*self.create_current_usage(matcher,
+                                                                                       None),
                                                            self.color()));
                         }
                         arg_os.to_string_lossy().into_owned()
@@ -1023,15 +1033,15 @@ impl<'a, 'b> Parser<'a, 'b>
                 };
                 if should_err {
                     return Err(Error::empty_value(o,
-                                                &*self.create_current_usage(matcher, None),
-                                                self.color()));
+                                                  &*self.create_current_usage(matcher, None),
+                                                  self.color()));
                 }
             }
         }
 
         try!(self.validate_blacklist(matcher));
-        if !(self.settings.is_set(AppSettings::SubcommandsNegateReqs) && subcmd_name.is_some()) &&
-           !reqs_validated {
+        if !(self.settings.is_set(AppSettings::SubcommandsNegateReqs) &&
+             subcmd_name.is_some()) && !reqs_validated {
             try!(self.validate_required(matcher));
         }
         try!(self.validate_matched_args(matcher));
@@ -1377,7 +1387,7 @@ impl<'a, 'b> Parser<'a, 'b>
         if let Some(opt) = find_by_long!(self, &arg, opts) {
             debugln!("Parser::parse_long_arg: Found valid opt '{}'", opt.to_string());
             self.valid_arg = true;
-            let ret = try!(self.parse_opt(val, opt, matcher));
+            let ret = try!(self.parse_opt(val, opt, val.is_some(), matcher));
             arg_post_processing!(self, opt, matcher);
 
             return Ok(ret);
@@ -1459,7 +1469,7 @@ impl<'a, 'b> Parser<'a, 'b>
                 };
 
                 // Default to "we're expecting a value later"
-                let ret = try!(self.parse_opt(val, opt, matcher));
+                let ret = try!(self.parse_opt(val, opt, false, matcher));
 
                 arg_post_processing!(self, opt, matcher);
 
@@ -1491,17 +1501,20 @@ impl<'a, 'b> Parser<'a, 'b>
     fn parse_opt(&self,
                  val: Option<&OsStr>,
                  opt: &OptBuilder<'a, 'b>,
+                 had_eq: bool,
                  matcher: &mut ArgMatcher<'a>)
                  -> ClapResult<Option<&'a str>> {
-        debugln!("Parser::parse_opt;");
+        debugln!("Parser::parse_opt; opt={}, val={:?}", opt.b.name, val);
+        debugln!("Parser::parse_opt; opt.settings={:?}", opt.b.settings);
         validate_multiples!(self, opt, matcher);
         let mut has_eq = false;
 
-        debug!("Parser::parse_optChecking for val...");
+        debug!("Parser::parse_opt; Checking for val...");
         if let Some(fv) = val {
-            has_eq = fv.starts_with(&[b'=']);
+            has_eq = fv.starts_with(&[b'=']) || had_eq;
             let v = fv.trim_left_matches(b'=');
-            if !opt.is_set(ArgSettings::EmptyValues) && v.len_() == 0 {
+            if !opt.is_set(ArgSettings::EmptyValues) &&
+               (v.len_() == 0 || (opt.is_set(ArgSettings::RequireEquals) && !has_eq)) {
                 sdebugln!("Found Empty - Error");
                 return Err(Error::empty_value(opt,
                                               &*self.create_current_usage(matcher, None),
@@ -1510,6 +1523,12 @@ impl<'a, 'b> Parser<'a, 'b>
             sdebugln!("Found - {:?}, len: {}", v, v.len_());
             debugln!("Parser::parse_opt: {:?} contains '='...{:?}", fv, fv.starts_with(&[b'=']));
             try!(self.add_val_to_arg(opt, v, matcher));
+        } else if opt.is_set(ArgSettings::RequireEquals) && !opt.is_set(ArgSettings::EmptyValues) {
+            sdebugln!("None, but requires equals...Error");
+            return Err(Error::empty_value(opt,
+                                          &*self.create_current_usage(matcher, None),
+                                          self.color()));
+
         } else {
             sdebugln!("None");
         }
@@ -1536,8 +1555,10 @@ impl<'a, 'b> Parser<'a, 'b>
                          -> ClapResult<Option<&'a str>>
         where A: AnyArg<'a, 'b> + Display
     {
-        debugln!("Parser::add_val_to_arg;");
+        debugln!("Parser::add_val_to_arg; arg={}, val={:?}", arg.name(), val);
         let mut ret = None;
+        debugln!("Parser::add_val_to_arg; trailing_vals={:?}, DontDelimTrailingVals={:?}",
+            self.trailing_vals, self.is_set(AppSettings::DontDelimitTrailingValues));
         if !(self.trailing_vals && self.is_set(AppSettings::DontDelimitTrailingValues)) {
             if let Some(delim) = arg.val_delim() {
                 if val.is_empty_() {
@@ -1598,7 +1619,8 @@ impl<'a, 'b> Parser<'a, 'b>
     {
         debugln!("Parser::validate_value: val={:?}", val);
         if self.is_set(AppSettings::StrictUtf8) && val.to_str().is_none() {
-            return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None), self.color()));
+            return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None),
+                                           self.color()));
         }
         if let Some(p_vals) = arg.possible_vals() {
             let val_str = val.to_string_lossy();
@@ -1612,7 +1634,9 @@ impl<'a, 'b> Parser<'a, 'b>
         }
         if !arg.is_set(ArgSettings::EmptyValues) && val.is_empty_() &&
            matcher.contains(&*arg.name()) {
-            return Err(Error::empty_value(arg, &*self.create_current_usage(matcher, None), self.color()));
+            return Err(Error::empty_value(arg,
+                                          &*self.create_current_usage(matcher, None),
+                                          self.color()));
         }
         if let Some(vtor) = arg.validator() {
             if let Err(e) = vtor(val.to_string_lossy().into_owned()) {
@@ -1788,7 +1812,9 @@ impl<'a, 'b> Parser<'a, 'b>
         }
         // Issue 665 (https://github.com/kbknapp/clap-rs/issues/665)
         if a.takes_value() && !a.is_set(ArgSettings::EmptyValues) && ma.vals.is_empty() {
-            return Err(Error::empty_value(a, &*self.create_current_usage(matcher, None), self.color()));
+            return Err(Error::empty_value(a,
+                                          &*self.create_current_usage(matcher, None),
+                                          self.color()));
         }
         Ok(())
     }
@@ -1976,10 +2002,12 @@ impl<'a, 'b> Parser<'a, 'b>
             usage.push_str(&*self.meta
                 .usage
                 .as_ref()
-                .unwrap_or_else(|| self.meta
-                    .bin_name
-                    .as_ref()
-                    .unwrap_or(&self.meta.name)));
+                .unwrap_or_else(|| {
+                    self.meta
+                        .bin_name
+                        .as_ref()
+                        .unwrap_or(&self.meta.name)
+                }));
             let mut reqs: Vec<&str> = self.required().map(|r| &**r).collect();
             reqs.dedup();
             let req_string = self.get_required_from(&reqs, None, None)
@@ -2044,11 +2072,14 @@ impl<'a, 'b> Parser<'a, 'b>
         usage.push_str(&self.meta
             .usage
             .as_ref()
-            .unwrap_or_else(|| self.meta
-                .bin_name
-                .as_ref()
-                .unwrap_or(&self.meta
-                    .name))[..]);
+            .unwrap_or_else(|| {
+                self.meta
+                    .bin_name
+                    .as_ref()
+                    .unwrap_or(&self.meta
+                        .name)
+            })
+                            [..]);
         usage.push_str(&*r_string);
         if self.is_set(AppSettings::SubcommandRequired) {
             usage.push_str(" <SUBCOMMAND>");
diff --git a/src/app/settings.rs b/src/app/settings.rs
index 891897b5..a3f879bf 100644
--- a/src/app/settings.rs
+++ b/src/app/settings.rs
@@ -48,9 +48,7 @@ pub struct AppFlags(Flags);
 
 impl BitOr for AppFlags {
     type Output = Self;
-    fn bitor(self, rhs: Self) -> Self {
-        AppFlags(self.0 | rhs.0)
-    }
+    fn bitor(self, rhs: Self) -> Self { AppFlags(self.0 | rhs.0) }
 }
 
 impl Default for AppFlags {
@@ -206,7 +204,7 @@ pub enum AppSettings {
     ///
     /// This would otherwise not be allowed. This is useful when `[optional]` has a default value.
     ///
-    /// **Note:** In addition to using this setting, the second positional argument *must* be 
+    /// **Note:** In addition to using this setting, the second positional argument *must* be
     /// [required]
     ///
     /// # Examples
@@ -267,9 +265,9 @@ pub enum AppSettings {
     AllowExternalSubcommands,
 
     /// Specifies that use of a valid [argument] negates [subcomands] being used after. By default
-    /// `clap` allows arguments between subcommands such as 
-    /// `<cmd> [cmd_args] <cmd2> [cmd2_args] <cmd3> [cmd3_args]`. This setting disables that 
-    /// functionality and says that arguments can only follow the *final* subcommand. For instance 
+    /// `clap` allows arguments between subcommands such as
+    /// `<cmd> [cmd_args] <cmd2> [cmd2_args] <cmd3> [cmd3_args]`. This setting disables that
+    /// functionality and says that arguments can only follow the *final* subcommand. For instance
     /// using this setting makes only the following invocations possible:
     ///
     /// * `<cmd> <cmd2> <cmd3> [cmd3_args]`
@@ -294,7 +292,7 @@ pub enum AppSettings {
     /// **NOTE:** [`SubCommand`]s count as arguments
     ///
     /// **NOTE:** Setting [`Arg::default_value`] effectively disables this option as it will
-    /// ensure that some argument is always present. 
+    /// ensure that some argument is always present.
     ///
     /// # Examples
     ///
@@ -413,7 +411,7 @@ pub enum AppSettings {
     /// [`Arg::use_delimiter(false)`]: ./struct.Arg.html#method.use_delimiter
     DontDelimitTrailingValues,
 
-    /// Disables the `help` subcommand 
+    /// Disables the `help` subcommand
     ///
     /// # Examples
     ///
@@ -424,7 +422,7 @@ pub enum AppSettings {
     ///     .setting(AppSettings::DisableHelpSubcommand)
     ///     // Normally, creating a subcommand causes a `help` subcommand to automaticaly
     ///     // be generated as well
-    ///     .subcommand(SubCommand::with_name("test")) 
+    ///     .subcommand(SubCommand::with_name("test"))
     ///     .get_matches_from_safe(vec![
     ///         "myprog", "help"
     ///     ]);
diff --git a/src/args/any_arg.rs b/src/args/any_arg.rs
index efa664da..6b20cca6 100644
--- a/src/args/any_arg.rs
+++ b/src/args/any_arg.rs
@@ -8,7 +8,6 @@ use vec_map::{self, VecMap};
 
 // Internal
 use args::settings::ArgSettings;
-use args::ArgKind;
 
 #[doc(hidden)]
 pub trait AnyArg<'n, 'e>: std_fmt::Display {
@@ -34,10 +33,9 @@ pub trait AnyArg<'n, 'e>: std_fmt::Display {
     fn takes_value(&self) -> bool;
     fn val_names(&self) -> Option<&VecMap<&'e str>>;
     fn help(&self) -> Option<&'e str>;
-    fn default_val(&self) -> Option<&'n str>;
-    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>>;
+    fn default_val(&self) -> Option<&'e OsStr>;
+    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e OsStr>, &'e OsStr)>>;
     fn longest_filter(&self) -> bool;
-    fn kind(&self) -> ArgKind;
     fn val_terminator(&self) -> Option<&'e str>;
 }
 
diff --git a/src/args/arg.rs b/src/args/arg.rs
index 8bd19853..bb6bc50e 100644
--- a/src/args/arg.rs
+++ b/src/args/arg.rs
@@ -2,13 +2,19 @@
 use std::collections::BTreeMap;
 use std::rc::Rc;
 use std::ffi::{OsString, OsStr};
+#[cfg(target_os="windows")]
+use osstringext::OsStrExt3;
+#[cfg(not(target_os="windows"))]
+use std::os::unix::ffi::OsStrExt;
+
 
 #[cfg(feature = "yaml")]
 use yaml_rust::Yaml;
 use vec_map::VecMap;
 
 use usage_parser::UsageParser;
-use args::settings::{ArgFlags, ArgSettings};
+use args::settings::ArgSettings;
+use args::arg_builder::{Base, Valued, Switched};
 
 /// The abstract representation of a command line argument. Used to set all the options and
 /// relationships that define a valid argument for the program.
@@ -33,94 +39,22 @@ use args::settings::{ArgFlags, ArgSettings};
 /// ```
 /// [`Arg`]: ./struct.Arg.html
 #[allow(missing_debug_implementations)]
+#[derive(Default, Clone)]
 pub struct Arg<'a, 'b>
     where 'a: 'b
 {
     #[doc(hidden)]
-    pub name: &'a str,
-    #[doc(hidden)]
-    pub short: Option<char>,
-    #[doc(hidden)]
-    pub long: Option<&'b str>,
+    pub b: Base<'a, 'b>,
     #[doc(hidden)]
-    pub aliases: Option<Vec<(&'b str, bool)>>, // (name, visible)
+    pub s: Switched<'b>,
     #[doc(hidden)]
-    pub help: Option<&'b str>,
+    pub v: Valued<'a, 'b>,
     #[doc(hidden)]
     pub index: Option<u64>,
     #[doc(hidden)]
-    pub blacklist: Option<Vec<&'a str>>,
-    #[doc(hidden)]
-    pub possible_vals: Option<Vec<&'b str>>,
-    #[doc(hidden)]
-    pub requires: Option<Vec<(Option<&'b str>, &'a str)>>,
-    #[doc(hidden)]
-    pub groups: Option<Vec<&'a str>>,
-    #[doc(hidden)]
-    pub val_names: Option<VecMap<&'b str>>,
-    #[doc(hidden)]
-    pub num_vals: Option<u64>,
-    #[doc(hidden)]
-    pub max_vals: Option<u64>,
-    #[doc(hidden)]
-    pub min_vals: Option<u64>,
-    #[doc(hidden)]
-    pub validator: Option<Rc<Fn(String) -> Result<(), String>>>,
-    #[doc(hidden)]
-    pub validator_os: Option<Rc<Fn(&OsStr) -> Result<(), OsString>>>,
-    #[doc(hidden)]
-    pub overrides: Option<Vec<&'a str>>,
-    #[doc(hidden)]
-    pub settings: ArgFlags,
-    #[doc(hidden)]
-    pub val_delim: Option<char>,
-    #[doc(hidden)]
-    pub default_val: Option<&'a str>,
-    #[doc(hidden)]
-    pub default_vals_ifs: Option<VecMap<(&'a str, Option<&'b str>, &'b str)>>,
-    #[doc(hidden)]
-    pub disp_ord: usize,
-    #[doc(hidden)]
-    pub r_unless: Option<Vec<&'a str>>,
-    #[doc(hidden)]
     pub r_ifs: Option<Vec<(&'a str, &'b str)>>,
-    #[doc(hidden)]
-    pub val_terminator: Option<&'b str>,
 }
 
-impl<'a, 'b> Default for Arg<'a, 'b> {
-    fn default() -> Self {
-        Arg {
-            name: "".as_ref(),
-            short: None,
-            long: None,
-            aliases: None,
-            help: None,
-            index: None,
-            blacklist: None,
-            possible_vals: None,
-            requires: None,
-            groups: None,
-            val_names: None,
-            num_vals: None,
-            max_vals: None,
-            min_vals: None,
-            validator: None,
-            validator_os: None,
-            overrides: None,
-            settings: ArgFlags::new(),
-            val_delim: None,
-            default_val: None,
-            default_vals_ifs: None,
-            disp_ord: 999,
-            r_unless: None,
-            r_ifs: None,
-            val_terminator: None,
-        }
-    }
-}
-
-
 impl<'a, 'b> Arg<'a, 'b> {
     /// Creates a new instance of [`Arg`] using a unique string name. The name will be used to get
     /// information about whether or not the argument was used at runtime, get values, set
@@ -139,7 +73,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// ```
     /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value
     /// [`Arg`]: ./struct.Arg.html
-    pub fn with_name(n: &'a str) -> Self { Arg { name: n, ..Default::default() } }
+    pub fn with_name(n: &'a str) -> Self { Arg { b: Base::new(n), ..Default::default() } }
 
     /// Creates a new instance of [`Arg`] from a .yml (YAML) file.
     ///
@@ -339,7 +273,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// App::new("myprog")
+    /// App::new("prog")
     ///     .args(&[
     ///         Arg::from_usage("--config <FILE> 'a required file for the configuration and no short'"),
     ///         Arg::from_usage("-d, --debug... 'turns on debugging information and allows multiples'"),
@@ -380,18 +314,18 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("shorttest")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("config")
     ///         .short("c"))
     ///     .get_matches_from(vec![
-    ///         "shorttest", "-c"
+    ///         "prog", "-c"
     ///     ]);
     ///
     /// assert!(m.is_present("config"));
     /// ```
     /// [`short`]: ./struct.Arg.html#method.short
     pub fn short<S: AsRef<str>>(mut self, s: S) -> Self {
-        self.short = s.as_ref().trim_left_matches(|c| c == '-').chars().nth(0);
+        self.s.short = s.as_ref().trim_left_matches(|c| c == '-').chars().nth(0);
         self
     }
 
@@ -421,17 +355,17 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("longtest")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .long("config"))
     ///     .get_matches_from(vec![
-    ///         "longtest", "--config"
+    ///         "prog", "--config"
     ///     ]);
     ///
     /// assert!(m.is_present("cfg"));
     /// ```
     pub fn long(mut self, l: &'b str) -> Self {
-        self.long = Some(l.trim_left_matches(|c| c == '-'));
+        self.s.long = Some(l.trim_left_matches(|c| c == '-'));
         self
     }
 
@@ -444,21 +378,23 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("myprog")
+    /// let m = App::new("prog")
     ///             .arg(Arg::with_name("test")
     ///             .long("test")
     ///             .alias("alias")
     ///             .takes_value(true))
-    ///        .get_matches_from(vec!["myprog", "--alias", "cool"]);
+    ///        .get_matches_from(vec![
+    ///             "prog", "--alias", "cool"
+    ///         ]);
     /// assert!(m.is_present("test"));
     /// assert_eq!(m.value_of("test"), Some("cool"));
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     pub fn alias<S: Into<&'b str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
+        if let Some(ref mut als) = self.s.aliases {
             als.push((name.into(), false));
         } else {
-            self.aliases = Some(vec![(name.into(), false)]);
+            self.s.aliases = Some(vec![(name.into(), false)]);
         }
         self
     }
@@ -472,23 +408,25 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("myprog")
+    /// let m = App::new("prog")
     ///             .arg(Arg::with_name("test")
     ///                     .long("test")
     ///                     .aliases(&["do-stuff", "do-tests", "tests"])
     ///                     .help("the file to add")
     ///                     .required(false))
-    ///             .get_matches_from(vec!["myprog", "--do-tests"]);
+    ///             .get_matches_from(vec![
+    ///                 "prog", "--do-tests"
+    ///             ]);
     /// assert!(m.is_present("test"));
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     pub fn aliases(mut self, names: &[&'b str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
+        if let Some(ref mut als) = self.s.aliases {
             for n in names {
                 als.push((n, false));
             }
         } else {
-            self.aliases = Some(names.iter().map(|n| (*n, false)).collect::<Vec<_>>());
+            self.s.aliases = Some(names.iter().map(|n| (*n, false)).collect::<Vec<_>>());
         }
         self
     }
@@ -500,22 +438,24 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("myprog")
+    /// let m = App::new("prog")
     ///             .arg(Arg::with_name("test")
     ///                 .visible_alias("something-awesome")
     ///                 .long("test")
     ///                 .takes_value(true))
-    ///        .get_matches_from(vec!["myprog", "--something-awesome", "coffee"]);
+    ///        .get_matches_from(vec![
+    ///             "prog", "--something-awesome", "coffee"
+    ///         ]);
     /// assert!(m.is_present("test"));
     /// assert_eq!(m.value_of("test"), Some("coffee"));
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     /// [`App::alias`]: ./struct.Arg.html#method.alias
     pub fn visible_alias<S: Into<&'b str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
+        if let Some(ref mut als) = self.s.aliases {
             als.push((name.into(), true));
         } else {
-            self.aliases = Some(vec![(name.into(), true)]);
+            self.s.aliases = Some(vec![(name.into(), true)]);
         }
         self
     }
@@ -527,22 +467,24 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("myprog")
+    /// let m = App::new("prog")
     ///             .arg(Arg::with_name("test")
     ///                 .long("test")
     ///                 .visible_aliases(&["something", "awesome", "cool"]))
-    ///        .get_matches_from(vec!["myprog", "--awesome"]);
+    ///        .get_matches_from(vec![
+    ///             "prog", "--awesome"
+    ///         ]);
     /// assert!(m.is_present("test"));
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     /// [`App::aliases`]: ./struct.Arg.html#method.aliases
     pub fn visible_aliases(mut self, names: &[&'b str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
+        if let Some(ref mut als) = self.s.aliases {
             for n in names {
                 als.push((n, true));
             }
         } else {
-            self.aliases = Some(names.iter().map(|n| (*n, true)).collect::<Vec<_>>());
+            self.s.aliases = Some(names.iter().map(|n| (*n, true)).collect::<Vec<_>>());
         }
         self
     }
@@ -568,12 +510,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("helptest")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .long("config")
     ///         .help("Some help text describing the --config arg"))
     ///     .get_matches_from(vec![
-    ///         "shorttest", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     ///
@@ -591,7 +533,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// -V, --version    Prints version information
     /// ```
     pub fn help(mut self, h: &'b str) -> Self {
-        self.help = Some(h);
+        self.b.help = Some(h);
         self
     }
 
@@ -617,13 +559,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("longtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required(true)
     ///         .takes_value(true)
     ///         .long("config"))
     ///     .get_matches_from_safe(vec![
-    ///         "shorttest", "--config", "file.conf"
+    ///         "prog", "--config", "file.conf"
     ///     ]);
     ///
     /// assert!(res.is_ok());
@@ -633,13 +575,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("longtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required(true)
     ///         .takes_value(true)
     ///         .long("config"))
     ///     .get_matches_from_safe(vec![
-    ///         "shorttest"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -654,6 +596,69 @@ impl<'a, 'b> Arg<'a, 'b> {
         }
     }
 
+    /// Requires that options use the `--option=val` syntax (i.e. an equals between the option and
+    /// associated value) **Default:** `false`
+    ///
+    /// **NOTE:** This setting also removes the default of allowing empty values and implies
+    /// [`Arg::empty_values(false)`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use clap::Arg;
+    /// Arg::with_name("config")
+    ///     .long("config")
+    ///     .takes_value(true)
+    ///     .require_equals(true)
+    /// # ;
+    /// ```
+    ///
+    /// Setting [`Arg::require_equals(true)`] requires that the option have an equals sign between
+    /// it and the associated value.
+    ///
+    /// ```rust
+    /// # use clap::{App, Arg};
+    /// let res = App::new("prog")
+    ///     .arg(Arg::with_name("cfg")
+    ///         .require_equals(true)
+    ///         .takes_value(true)
+    ///         .long("config"))
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "--config=file.conf"
+    ///     ]);
+    ///
+    /// assert!(res.is_ok());
+    /// ```
+    ///
+    /// Setting [`Arg::require_equals(true)`] and *not* supplying the equals will cause an error
+    /// unless [`Arg::empty_values(true)`] is set.
+    ///
+    /// ```rust
+    /// # use clap::{App, Arg, ErrorKind};
+    /// let res = App::new("prog")
+    ///     .arg(Arg::with_name("cfg")
+    ///         .require_equals(true)
+    ///         .takes_value(true)
+    ///         .long("config"))
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "--config", "file.conf"
+    ///     ]);
+    ///
+    /// assert!(res.is_err());
+    /// assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
+    /// ```
+    /// [`Arg::require_equals(true)`]: ./struct.Arg.html#method.require_equals
+    /// [`Arg::empty_values(true)`]: ./struct.Arg.html#method.empty_values
+    /// [`Arg::empty_values(false)`]: ./struct.Arg.html#method.empty_values
+    pub fn require_equals(mut self, r: bool) -> Self {
+        if r {
+            self.unsetb(ArgSettings::EmptyValues);
+            self.set(ArgSettings::RequireEquals)
+        } else {
+            self.unset(ArgSettings::RequireEquals)
+        }
+    }
+
     /// Allows values which start with a leading hyphen (`-`)
     ///
     /// **WARNING**: When building your CLIs, consider the effects of allowing leading hyphens and
@@ -674,13 +679,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("pattest")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("pat")
     ///         .allow_hyphen_values(true)
     ///         .takes_value(true)
     ///         .long("pattern"))
     ///     .get_matches_from(vec![
-    ///         "pattest", "--pattern", "-file"
+    ///         "prog", "--pattern", "-file"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("pat"), Some("-file"));
@@ -691,12 +696,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("pattest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("pat")
     ///         .takes_value(true)
     ///         .long("pattern"))
     ///     .get_matches_from_safe(vec![
-    ///         "pattest", "--pattern", "-file"
+    ///         "prog", "--pattern", "-file"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -731,7 +736,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("unlesstest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless("dbg")
     ///         .takes_value(true)
@@ -739,7 +744,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("dbg")
     ///         .long("debug"))
     ///     .get_matches_from_safe(vec![
-    ///         "unlesstest", "--debug"
+    ///         "prog", "--debug"
     ///     ]);
     ///
     /// assert!(res.is_ok());
@@ -749,7 +754,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("unlesstest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless("dbg")
     ///         .takes_value(true)
@@ -757,7 +762,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("dbg")
     ///         .long("debug"))
     ///     .get_matches_from_safe(vec![
-    ///         "unlesstest"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -767,10 +772,10 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::required`]: ./struct.Arg.html#method.required
     /// [`Arg::required_unless(name)`]: ./struct.Arg.html#method.required_unless
     pub fn required_unless(mut self, name: &'a str) -> Self {
-        if let Some(ref mut vec) = self.r_unless {
+        if let Some(ref mut vec) = self.b.r_unless {
             vec.push(name);
         } else {
-            self.r_unless = Some(vec![name]);
+            self.b.r_unless = Some(vec![name]);
         }
         self.required(true)
     }
@@ -797,7 +802,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("unlessall")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless_all(&["dbg", "infile"])
     ///         .takes_value(true)
@@ -808,7 +813,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("i")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "unlessall", "--debug", "-i", "file"
+    ///         "prog", "--debug", "-i", "file"
     ///     ]);
     ///
     /// assert!(res.is_ok());
@@ -819,7 +824,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("unlessall")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless_all(&["dbg", "infile"])
     ///         .takes_value(true)
@@ -830,7 +835,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("i")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "unlessall"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -839,12 +844,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::required_unless_one`]: ./struct.Arg.html#method.required_unless_one
     /// [`Arg::required_unless_all(names)`]: ./struct.Arg.html#method.required_unless_all
     pub fn required_unless_all(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.r_unless {
+        if let Some(ref mut vec) = self.b.r_unless {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.r_unless = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
+            self.b.r_unless = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
         }
         self.setb(ArgSettings::RequiredUnlessAll);
         self.required(true)
@@ -872,7 +877,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("unlessone")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless_one(&["dbg", "infile"])
     ///         .takes_value(true)
@@ -883,7 +888,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("i")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "unlessone", "--debug"
+    ///         "prog", "--debug"
     ///     ]);
     ///
     /// assert!(res.is_ok());
@@ -894,7 +899,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("unlessone")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_unless_one(&["dbg", "infile"])
     ///         .takes_value(true)
@@ -905,7 +910,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("i")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "unlessone"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -915,12 +920,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::required_unless_one(names)`]: ./struct.Arg.html#method.required_unless_one
     /// [`Arg::required_unless_all`]: ./struct.Arg.html#method.required_unless_all
     pub fn required_unless_one(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.r_unless {
+        if let Some(ref mut vec) = self.b.r_unless {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.r_unless = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
+            self.b.r_unless = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
         }
         self.required(true)
     }
@@ -948,7 +953,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("conflictions")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .conflicts_with("debug")
@@ -956,17 +961,17 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug"))
     ///     .get_matches_from_safe(vec![
-    ///         "conflictions", "--debug", "--config", "file.conf"
+    ///         "prog", "--debug", "--config", "file.conf"
     ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::ArgumentConflict);
     /// ```
     pub fn conflicts_with(mut self, name: &'a str) -> Self {
-        if let Some(ref mut vec) = self.blacklist {
+        if let Some(ref mut vec) = self.b.blacklist {
             vec.push(name);
         } else {
-            self.blacklist = Some(vec![name]);
+            self.b.blacklist = Some(vec![name]);
         }
         self
     }
@@ -995,7 +1000,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("conflictions")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .conflicts_with_all(&["debug", "input"])
@@ -1005,7 +1010,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("input")
     ///         .index(1))
     ///     .get_matches_from_safe(vec![
-    ///         "conflictions", "--config", "file.conf", "file.txt"
+    ///         "prog", "--config", "file.conf", "file.txt"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1013,12 +1018,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// ```
     /// [`Arg::conflicts_with`]: ./struct.Arg.html#method.conflicts_with
     pub fn conflicts_with_all(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.blacklist {
+        if let Some(ref mut vec) = self.b.blacklist {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.blacklist = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
+            self.b.blacklist = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
         }
         self
     }
@@ -1034,14 +1039,15 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posix")
+    /// let m = App::new("prog")
     ///     .arg(Arg::from_usage("-f, --flag 'some flag'")
     ///         .conflicts_with("debug"))
     ///     .arg(Arg::from_usage("-d, --debug 'other flag'"))
     ///     .arg(Arg::from_usage("-c, --color 'third flag'")
     ///         .overrides_with("flag"))
-    ///     .get_matches_from(vec!["posix", "-f", "-d", "-c"]);
-    ///                                 //    ^~~~~~~~~~~~^~~~~ flag is overridden by color
+    ///     .get_matches_from(vec![
+    ///         "prog", "-f", "-d", "-c"]);
+    ///             //    ^~~~~~~~~~~~^~~~~ flag is overridden by color
     ///
     /// assert!(m.is_present("color"));
     /// assert!(m.is_present("debug")); // even though flag conflicts with debug, it's as if flag
@@ -1049,10 +1055,10 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// assert!(!m.is_present("flag"));
     /// ```
     pub fn overrides_with(mut self, name: &'a str) -> Self {
-        if let Some(ref mut vec) = self.overrides {
+        if let Some(ref mut vec) = self.b.overrides {
             vec.push(name.as_ref());
         } else {
-            self.overrides = Some(vec![name.as_ref()]);
+            self.b.overrides = Some(vec![name.as_ref()]);
         }
         self
     }
@@ -1068,14 +1074,15 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posix")
+    /// let m = App::new("prog")
     ///     .arg(Arg::from_usage("-f, --flag 'some flag'")
     ///         .conflicts_with("color"))
     ///     .arg(Arg::from_usage("-d, --debug 'other flag'"))
     ///     .arg(Arg::from_usage("-c, --color 'third flag'")
     ///         .overrides_with_all(&["flag", "debug"]))
-    ///     .get_matches_from(vec!["posix", "-f", "-d", "-c"]);
-    ///                                 //    ^~~~~~^~~~~~~~~ flag and debug are overridden by color
+    ///     .get_matches_from(vec![
+    ///         "prog", "-f", "-d", "-c"]);
+    ///             //    ^~~~~~^~~~~~~~~ flag and debug are overridden by color
     ///
     /// assert!(m.is_present("color")); // even though flag conflicts with color, it's as if flag
     ///                                 // and debug were never used because they were overridden
@@ -1084,12 +1091,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// assert!(!m.is_present("flag"));
     /// ```
     pub fn overrides_with_all(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.overrides {
+        if let Some(ref mut vec) = self.b.overrides {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.overrides = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
+            self.b.overrides = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
         }
         self
     }
@@ -1114,7 +1121,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires("input")
@@ -1122,7 +1129,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("input")
     ///         .index(1))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_ok()); // We didn't use cfg, so input wasn't required
@@ -1132,7 +1139,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires("input")
@@ -1140,7 +1147,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("input")
     ///         .index(1))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--config", "file.conf"
+    ///         "prog", "--config", "file.conf"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1150,12 +1157,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires(mut self, name: &'a str) -> Self {
-        if let Some(ref mut vec) = self.requires {
+        if let Some(ref mut vec) = self.b.requires {
             vec.push((None, name));
         } else {
             let mut vec = vec![];
             vec.push((None, name));
-            self.requires = Some(vec);
+            self.b.requires = Some(vec);
         }
         self
     }
@@ -1185,14 +1192,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires_if("my.cfg", "other")
     ///         .long("config"))
     ///     .arg(Arg::with_name("other"))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--config", "some.cfg"
+    ///         "prog", "--config", "some.cfg"
     ///     ]);
     ///
     /// assert!(res.is_ok()); // We didn't use --config=my.cfg, so other wasn't required
@@ -1203,14 +1210,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires_if("my.cfg", "input")
     ///         .long("config"))
     ///     .arg(Arg::with_name("input"))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--config", "my.cfg"
+    ///         "prog", "--config", "my.cfg"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1220,10 +1227,10 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires_if(mut self, val: &'b str, arg: &'a str) -> Self {
-        if let Some(ref mut vec) = self.requires {
+        if let Some(ref mut vec) = self.b.requires {
             vec.push((Some(val), arg));
         } else {
-            self.requires = Some(vec![(Some(val), arg)]);
+            self.b.requires = Some(vec![(Some(val), arg)]);
         }
         self
     }
@@ -1257,7 +1264,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires_ifs(&[
@@ -1270,7 +1277,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .takes_value(true))
     ///     .arg(Arg::with_name("other"))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--config", "special.conf"
+    ///         "prog", "--config", "special.conf"
     ///     ]);
     ///
     /// assert!(res.is_err()); // We  used --config=special.conf so --option <val> is required
@@ -1280,7 +1287,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires_ifs(mut self, ifs: &[(&'b str, &'a str)]) -> Self {
-        if let Some(ref mut vec) = self.requires {
+        if let Some(ref mut vec) = self.b.requires {
             for &(val, arg) in ifs {
                 vec.push((Some(val), arg));
             }
@@ -1289,7 +1296,7 @@ impl<'a, 'b> Arg<'a, 'b> {
             for &(val, arg) in ifs {
                 vec.push((Some(val), arg));
             }
-            self.requires = Some(vec);
+            self.b.requires = Some(vec);
         }
         self
     }
@@ -1319,7 +1326,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .required_if("other", "special")
@@ -1328,7 +1335,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .long("other")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--other", "not-special" 
+    ///         "prog", "--other", "not-special" 
     ///     ]);
     ///
     /// assert!(res.is_ok()); // We didn't use --other=special, so "cfg" wasn't required
@@ -1339,7 +1346,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .required_if("other", "special")
@@ -1348,7 +1355,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .long("other")
     ///         .takes_value(true))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--other", "special" 
+    ///         "prog", "--other", "special" 
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1396,7 +1403,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("ri")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_ifs(&[
     ///             ("extra", "val"),
@@ -1411,7 +1418,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .takes_value(true)
     ///         .long("option"))
     ///     .get_matches_from_safe(vec![
-    ///         "ri", "--option", "other"
+    ///         "prog", "--option", "other"
     ///     ]);
     ///
     /// assert!(res.is_ok()); // We didn't use --option=spec, or --extra=val so "cfg" isn't required
@@ -1422,7 +1429,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("ri")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .required_ifs(&[
     ///             ("extra", "val"),
@@ -1437,7 +1444,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .takes_value(true)
     ///         .long("option"))
     ///     .get_matches_from_safe(vec![
-    ///         "ri", "--option", "spec"
+    ///         "prog", "--option", "spec"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1482,7 +1489,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires("input")
@@ -1492,7 +1499,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("output")
     ///         .index(2))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest"
+    ///         "prog"
     ///     ]);
     ///
     /// assert!(res.is_ok()); // We didn't use cfg, so input and output weren't required
@@ -1503,7 +1510,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqtest")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .takes_value(true)
     ///         .requires_all(&["input", "output"])
@@ -1513,7 +1520,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     .arg(Arg::with_name("output")
     ///         .index(2))
     ///     .get_matches_from_safe(vec![
-    ///         "reqtest", "--config", "file.conf", "in.txt"
+    ///         "prog", "--config", "file.conf", "in.txt"
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -1524,7 +1531,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [override]: ./struct.Arg.html#method.overrides_with
     /// [`Arg::requires_all(&[arg, arg2])`]: ./struct.Arg.html#method.requires_all
     pub fn requires_all(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.requires {
+        if let Some(ref mut vec) = self.b.requires {
             for s in names {
                 vec.push((None, s));
             }
@@ -1533,7 +1540,7 @@ impl<'a, 'b> Arg<'a, 'b> {
             for s in names {
                 vec.push((None, *s));
             }
-            self.requires = Some(vec);
+            self.b.requires = Some(vec);
         }
         self
     }
@@ -1562,11 +1569,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .takes_value(true))
-    ///     .get_matches_from(vec!["posvals", "--mode", "fast"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--mode", "fast"
+    ///     ]);
     ///
     /// assert!(m.is_present("mode"));
     /// assert_eq!(m.value_of("mode"), Some("fast"));
@@ -1599,7 +1608,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("hide_posvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .possible_values(&["fast", "slow"])
@@ -1647,12 +1656,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .index(1))
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug"))
-    ///     .get_matches_from(vec!["posvals", "--debug", "fast"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--debug", "fast"
+    ///     ]);
     ///
     /// assert!(m.is_present("mode"));
     /// assert_eq!(m.value_of("mode"), Some("fast")); // notice index(1) means "first positional"
@@ -1704,11 +1715,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("verbose")
     ///         .multiple(true)
     ///         .short("v"))
-    ///     .get_matches_from(vec!["mults", "-v", "-v", "-v"]); // note, -vvv would have same result
+    ///     .get_matches_from(vec![
+    ///         "prog", "-v", "-v", "-v"    // note, -vvv would have same result
+    ///     ]); 
     ///
     /// assert!(m.is_present("verbose"));
     /// assert_eq!(m.occurrences_of("verbose"), 3);
@@ -1718,12 +1731,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .multiple(true)
     ///         .takes_value(true)
     ///         .short("F"))
-    ///     .get_matches_from(vec!["mults", "-F", "file1", "file2", "file3"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "-F", "file1", "file2", "file3"
+    ///     ]);
     ///
     /// assert!(m.is_present("file"));
     /// assert_eq!(m.occurrences_of("file"), 1); // notice only one occurrence
@@ -1734,12 +1749,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .multiple(true)
     ///         .takes_value(true)
     ///         .short("F"))
-    ///     .get_matches_from(vec!["mults", "-F", "file1", "-F", "file2", "-F", "file3"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "-F", "file1", "-F", "file2", "-F", "file3"
+    ///     ]);
     /// let files: Vec<_> = m.values_of("file").unwrap().collect();
     /// assert_eq!(files, ["file1", "file2", "file3"]);
     ///
@@ -1753,14 +1770,16 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .multiple(true)
     ///         .takes_value(true)
     ///         .short("F"))
     ///     .arg(Arg::with_name("word")
     ///         .index(1))
-    ///     .get_matches_from(vec!["mults", "-F", "file1", "file2", "file3", "word"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "-F", "file1", "file2", "file3", "word"
+    ///     ]);
     ///
     /// assert!(m.is_present("file"));
     /// let files: Vec<_> = m.values_of("file").unwrap().collect();
@@ -1776,7 +1795,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .multiple(true)
     ///         .takes_value(true)
@@ -1784,7 +1803,9 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("F"))
     ///     .arg(Arg::with_name("word")
     ///         .index(1))
-    ///     .get_matches_from(vec!["mults", "-F", "file1", "-F", "file2", "-F", "file3", "word"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "-F", "file1", "-F", "file2", "-F", "file3", "word"
+    ///     ]);
     ///
     /// assert!(m.is_present("file"));
     /// let files: Vec<_> = m.values_of("file").unwrap().collect();
@@ -1798,7 +1819,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("mults")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .multiple(true)
     ///         .takes_value(true)
@@ -1806,7 +1827,9 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .short("F"))
     ///     .arg(Arg::with_name("word")
     ///         .index(1))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1", "file2", "file3", "word"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1", "file2", "file3", "word"
+    ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
@@ -1848,13 +1871,15 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("do")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("cmds")
     ///         .multiple(true)
     ///         .allow_hyphen_values(true)
     ///         .value_terminator(";"))
     ///     .arg(Arg::with_name("location"))
-    ///     .get_matches_from(vec!["do", "find", "-type", "f", "-name", "special", ";", "/home/clap"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "find", "-type", "f", "-name", "special", ";", "/home/clap"
+    ///     ]);
     /// let cmds: Vec<_> = m.values_of("cmds").unwrap().collect();
     /// assert_eq!(&cmds, &["find", "-type", "f", "-name", "special"]);
     /// assert_eq!(m.value_of("location"), Some("/home/clap"));
@@ -1867,7 +1892,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`max_values`]: ./struct.Arg.html#method.max_values
     pub fn value_terminator(mut self, term: &'b str) -> Self {
         self.setb(ArgSettings::TakesValue);
-        self.val_terminator = Some(term);
+        self.v.terminator = Some(term);
         self
     }
 
@@ -1898,14 +1923,16 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, SubCommand};
-    /// let m = App::new("mults")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("verb")
     ///         .long("verbose")
     ///         .short("v")
     ///         .global(true))
     ///     .subcommand(SubCommand::with_name("test"))
     ///     .subcommand(SubCommand::with_name("do-stuff"))
-    ///     .get_matches_from(vec!["mults", "do-stuff", "--verbose"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "do-stuff", "--verbose"
+    ///     ]);
     ///
     /// assert_eq!(m.subcommand_name(), Some("do-stuff"));
     /// let sub_m = m.subcommand_matches("do-stuff").unwrap();
@@ -1945,12 +1972,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("evals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .long("config")
     ///         .short("v")
     ///         .empty_values(false))
-    ///     .get_matches_from_safe(vec!["evals", "--config="]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "--config="
+    ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
@@ -1981,13 +2010,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("helptest")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("cfg")
     ///         .long("config")
     ///         .hidden(true)
     ///         .help("Some help text describing the --config arg"))
     ///     .get_matches_from(vec![
-    ///         "shorttest", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     ///
@@ -2028,12 +2057,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .takes_value(true)
     ///         .possible_values(&["fast", "slow", "medium"]))
-    ///     .get_matches_from(vec!["posvals", "--mode", "fast"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--mode", "fast"
+    ///     ]);
     /// assert!(m.is_present("mode"));
     /// assert_eq!(m.value_of("mode"), Some("fast"));
     /// ```
@@ -2043,24 +2074,26 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("posvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .takes_value(true)
     ///         .possible_values(&["fast", "slow", "medium"]))
-    ///     .get_matches_from_safe(vec!["myprog", "--mode", "wrong"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "--mode", "wrong"
+    ///     ]);
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::InvalidValue);
     /// ```
     /// [options]: ./struct.Arg.html#method.takes_value
     /// [positional arguments]: ./struct.Arg.html#method.index
     pub fn possible_values(mut self, names: &[&'b str]) -> Self {
-        if let Some(ref mut vec) = self.possible_vals {
+        if let Some(ref mut vec) = self.v.possible_vals {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.possible_vals = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
+            self.v.possible_vals = Some(names.iter().map(|s| *s).collect::<Vec<_>>());
         }
         self
     }
@@ -2084,14 +2117,16 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("posvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .takes_value(true)
     ///         .possible_value("fast")
     ///         .possible_value("slow")
     ///         .possible_value("medium"))
-    ///     .get_matches_from(vec!["posvals", "--mode", "fast"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--mode", "fast"
+    ///     ]);
     /// assert!(m.is_present("mode"));
     /// assert_eq!(m.value_of("mode"), Some("fast"));
     /// ```
@@ -2101,24 +2136,26 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("posvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("mode")
     ///         .long("mode")
     ///         .takes_value(true)
     ///         .possible_value("fast")
     ///         .possible_value("slow")
     ///         .possible_value("medium"))
-    ///     .get_matches_from_safe(vec!["myprog", "--mode", "wrong"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "--mode", "wrong"
+    ///     ]);
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::InvalidValue);
     /// ```
     /// [options]: ./struct.Arg.html#method.takes_value
     /// [positional arguments]: ./struct.Arg.html#method.index
     pub fn possible_value(mut self, name: &'b str) -> Self {
-        if let Some(ref mut vec) = self.possible_vals {
+        if let Some(ref mut vec) = self.v.possible_vals {
             vec.push(name);
         } else {
-            self.possible_vals = Some(vec![name]);
+            self.v.possible_vals = Some(vec![name]);
         }
         self
     }
@@ -2140,22 +2177,24 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("groups")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug")
     ///         .group("mode"))
     ///     .arg(Arg::with_name("verbose")
     ///         .long("verbose")
     ///         .group("mode"))
-    ///     .get_matches_from(vec!["posvals", "--debug"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--debug"
+    ///     ]);
     /// assert!(m.is_present("mode"));
     /// ```
     /// [`ArgGroup`]: ./struct.ArgGroup.html
     pub fn group(mut self, name: &'a str) -> Self {
-        if let Some(ref mut vec) = self.groups {
+        if let Some(ref mut vec) = self.b.groups {
             vec.push(name);
         } else {
-            self.groups = Some(vec![name]);
+            self.b.groups = Some(vec![name]);
         }
         self
     }
@@ -2177,25 +2216,27 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("groups")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug")
     ///         .groups(&["mode", "verbosity"]))
     ///     .arg(Arg::with_name("verbose")
     ///         .long("verbose")
     ///         .groups(&["mode", "verbosity"]))
-    ///     .get_matches_from(vec!["posvals", "--debug"]);
+    ///     .get_matches_from(vec![
+    ///         "prog", "--debug"
+    ///     ]);
     /// assert!(m.is_present("mode"));
     /// assert!(m.is_present("verbosity"));
     /// ```
     /// [`ArgGroup`]: ./struct.ArgGroup.html
     pub fn groups(mut self, names: &[&'a str]) -> Self {
-        if let Some(ref mut vec) = self.groups {
+        if let Some(ref mut vec) = self.b.groups {
             for s in names {
                 vec.push(s);
             }
         } else {
-            self.groups = Some(names.into_iter().map(|s| *s).collect::<Vec<_>>());
+            self.b.groups = Some(names.into_iter().map(|s| *s).collect::<Vec<_>>());
         }
         self
     }
@@ -2223,12 +2264,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("numvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .takes_value(true)
     ///         .number_of_values(2)
     ///         .short("F"))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1"
+    ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
@@ -2236,7 +2279,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple
     pub fn number_of_values(mut self, qty: u64) -> Self {
         self.setb(ArgSettings::TakesValue);
-        self.num_vals = Some(qty);
+        self.v.num_vals = Some(qty);
         self
     }
 
@@ -2262,12 +2305,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     if v.contains("@") { return Ok(()); }
     ///     Err(String::from("The value did not contain the required @ sigil"))
     /// }
-    /// let res = App::new("validators")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .index(1)
     ///         .validator(has_at))
     ///     .get_matches_from_safe(vec![
-    ///         "validators", "some@file"
+    ///         "prog", "some@file"
     ///     ]);
     /// assert!(res.is_ok());
     /// assert_eq!(res.unwrap().value_of("file"), Some("some@file"));
@@ -2279,7 +2322,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     pub fn validator<F>(mut self, f: F) -> Self
         where F: Fn(String) -> Result<(), String> + 'static
     {
-        self.validator = Some(Rc::new(f));
+        self.v.validator = Some(Rc::new(f));
         self
     }
 
@@ -2291,12 +2334,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///     if v.contains("&") { return Ok(()); }
     ///     Err(String::from("The value did not contain the required & sigil"))
     /// }
-    /// let res = App::new("validators")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .index(1)
     ///         .validator(has_ampersand))
     ///     .get_matches_from_safe(vec![
-    ///         "validators", "Fish & chips"
+    ///         "prog", "Fish & chips"
     ///     ]);
     /// assert!(res.is_ok());
     /// assert_eq!(res.unwrap().value_of("file"), Some("Fish & chips"));
@@ -2310,7 +2353,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     pub fn validator_os<F>(mut self, f: F) -> Self
         where F: Fn(&OsStr) -> Result<(), OsString> + 'static
     {
-        self.validator_os = Some(Rc::new(f));
+        self.v.validator_os = Some(Rc::new(f));
         self
     }
 
@@ -2338,12 +2381,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("numvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .takes_value(true)
     ///         .max_values(3)
     ///         .short("F"))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1", "file2"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1", "file2"
+    ///     ]);
     ///
     /// assert!(res.is_ok());
     /// let m = res.unwrap();
@@ -2355,12 +2400,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("numvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .takes_value(true)
     ///         .max_values(2)
     ///         .short("F"))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1", "file2", "file3"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1", "file2", "file3"
+    ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::TooManyValues);
@@ -2368,7 +2415,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple
     pub fn max_values(mut self, qty: u64) -> Self {
         self.setb(ArgSettings::TakesValue);
-        self.max_vals = Some(qty);
+        self.v.max_vals = Some(qty);
         self
     }
 
@@ -2397,12 +2444,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let res = App::new("numvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .takes_value(true)
     ///         .min_values(2)
     ///         .short("F"))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1", "file2", "file3"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1", "file2", "file3"
+    ///     ]);
     ///
     /// assert!(res.is_ok());
     /// let m = res.unwrap();
@@ -2414,19 +2463,21 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("numvals")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("file")
     ///         .takes_value(true)
     ///         .min_values(2)
     ///         .short("F"))
-    ///     .get_matches_from_safe(vec!["mults", "-F", "file1"]);
+    ///     .get_matches_from_safe(vec![
+    ///         "prog", "-F", "file1"
+    ///     ]);
     ///
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::TooFewValues);
     /// ```
     /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple
     pub fn min_values(mut self, qty: u64) -> Self {
-        self.min_vals = Some(qty);
+        self.v.min_vals = Some(qty);
         self.set(ArgSettings::TakesValue)
     }
 
@@ -2444,14 +2495,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let delims = App::new("delims")
+    /// let delims = App::new("prog")
     ///     .arg(Arg::with_name("option")
     ///         .long("option")
     ///         .use_delimiter(true)
     ///         .takes_value(true))
     ///     .get_matches_from(vec![
-    ///         "delims",
-    ///         "--option=val1,val2,val3",
+    ///         "prog", "--option=val1,val2,val3",
     ///     ]);
     ///
     /// assert!(delims.is_present("option"));
@@ -2463,14 +2513,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let nodelims = App::new("nodelims")
+    /// let nodelims = App::new("prog")
     ///     .arg(Arg::with_name("option")
     ///         .long("option")
     ///         .use_delimiter(false)
     ///         .takes_value(true))
     ///     .get_matches_from(vec![
-    ///         "nodelims",
-    ///         "--option=val1,val2,val3",
+    ///         "prog", "--option=val1,val2,val3",
     ///     ]);
     ///
     /// assert!(nodelims.is_present("option"));
@@ -2480,14 +2529,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::value_delimiter`]: ./struct.Arg.html#method.value_delimiter
     pub fn use_delimiter(mut self, d: bool) -> Self {
         if d {
-            if self.val_delim.is_none() {
-                self.val_delim = Some(',');
+            if self.v.val_delim.is_none() {
+                self.v.val_delim = Some(',');
             }
             self.setb(ArgSettings::TakesValue);
             self.setb(ArgSettings::UseValueDelimiter);
             self.unset(ArgSettings::ValueDelimiterNotSet)
         } else {
-            self.val_delim = None;
+            self.v.val_delim = None;
             self.unsetb(ArgSettings::UseValueDelimiter);
             self.unset(ArgSettings::ValueDelimiterNotSet)
         }
@@ -2512,15 +2561,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let delims = App::new("reqdelims")
+    /// let delims = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .short("o")
     ///         .takes_value(true)
     ///         .multiple(true)
     ///         .require_delimiter(true))
-    ///     // Simulate "$ reqdelims -o val1,val2,val3"
     ///     .get_matches_from(vec![
-    ///         "reqdelims", "-o", "val1,val2,val3",
+    ///         "prog", "-o", "val1,val2,val3",
     ///     ]);
     ///
     /// assert!(delims.is_present("opt"));
@@ -2530,15 +2578,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("reqdelims")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .short("o")
     ///         .takes_value(true)
     ///         .multiple(true)
     ///         .require_delimiter(true))
-    ///     // Simulate "$ reqdelims -o val1 val2 val3"
     ///     .get_matches_from_safe(vec![
-    ///         "reqdelims", "-o", "val1", "val2", "val3",
+    ///         "prog", "-o", "val1", "val2", "val3",
     ///     ]);
     ///
     /// assert!(res.is_err());
@@ -2554,14 +2601,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let delims = App::new("reqdelims")
+    /// let delims = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .short("o")
     ///         .takes_value(true)
     ///         .multiple(true))
-    ///     // Simulate "$ reqdelims -o val1 val2 val3"
     ///     .get_matches_from(vec![
-    ///         "reqdelims", "-o", "val1", "val2", "val3",
+    ///         "prog", "-o", "val1", "val2", "val3",
     ///     ]);
     ///
     /// assert!(delims.is_present("opt"));
@@ -2591,15 +2637,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let app = App::new("fake")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("config")
     ///         .short("c")
     ///         .long("config")
-    ///         .value_delimiter(";"));
-    ///
-    /// let m = app.get_matches_from(vec![
-    ///     "fake", "--config=val1;val2;val3"
-    /// ]);
+    ///         .value_delimiter(";"))
+    ///     .get_matches_from(vec![
+    ///         "prog", "--config=val1;val2;val3"
+    ///     ]);
     ///
     /// assert_eq!(m.values_of("config").unwrap().collect::<Vec<_>>(), ["val1", "val2", "val3"])
     /// ```
@@ -2609,7 +2654,7 @@ impl<'a, 'b> Arg<'a, 'b> {
         self.unsetb(ArgSettings::ValueDelimiterNotSet);
         self.setb(ArgSettings::TakesValue);
         self.setb(ArgSettings::UseValueDelimiter);
-        self.val_delim = Some(d.chars()
+        self.v.val_delim = Some(d.chars()
             .nth(0)
             .expect("Failed to get value_delimiter from arg"));
         self
@@ -2647,12 +2692,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let app = App::new("valnames")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("io")
     ///         .long("io-files")
     ///         .value_names(&["INFILE", "OUTFILE"]))
     ///     .get_matches_from(vec![
-    ///         "valnames", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     /// Running the above program produces the following output
@@ -2676,11 +2721,11 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple
     pub fn value_names(mut self, names: &[&'b str]) -> Self {
         self.setb(ArgSettings::TakesValue);
-        if self.settings.is_set(ArgSettings::ValueDelimiterNotSet) {
+        if self.is_set(ArgSettings::ValueDelimiterNotSet) {
             self.unsetb(ArgSettings::ValueDelimiterNotSet);
             self.setb(ArgSettings::UseValueDelimiter);
         }
-        if let Some(ref mut vals) = self.val_names {
+        if let Some(ref mut vals) = self.v.val_names {
             let mut l = vals.len();
             for s in names {
                 vals.insert(l, s);
@@ -2691,7 +2736,7 @@ impl<'a, 'b> Arg<'a, 'b> {
             for (i, n) in names.iter().enumerate() {
                 vm.insert(i, *n);
             }
-            self.val_names = Some(vm);
+            self.v.val_names = Some(vm);
         }
         self
     }
@@ -2716,12 +2761,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let app = App::new("valnames")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("config")
     ///         .long("config")
     ///         .value_name("FILE"))
     ///     .get_matches_from(vec![
-    ///         "valnames", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     /// Running the above program produces the following output
@@ -2744,13 +2789,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value
     pub fn value_name(mut self, name: &'b str) -> Self {
         self.setb(ArgSettings::TakesValue);
-        if let Some(ref mut vals) = self.val_names {
+        if let Some(ref mut vals) = self.v.val_names {
             let l = vals.len();
             vals.insert(l, name);
         } else {
             let mut vm = VecMap::new();
             vm.insert(0, name);
-            self.val_names = Some(vm);
+            self.v.val_names = Some(vm);
         }
         self
     }
@@ -2784,12 +2829,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("defvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .long("myopt")
     ///         .default_value("myval"))
     ///     .get_matches_from(vec![
-    ///         "defvals"
+    ///         "prog"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("opt"), Some("myval"));
@@ -2801,12 +2846,12 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("defvals")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .long("myopt")
     ///         .default_value("myval"))
     ///     .get_matches_from(vec![
-    ///         "defvals", "--myopt=non_default"
+    ///         "prog", "--myopt=non_default"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("opt"), Some("non_default"));
@@ -2820,7 +2865,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [`Arg::default_value_if`]: ./struct.Arg.html#method.default_value_if
     pub fn default_value(mut self, val: &'a str) -> Self {
         self.setb(ArgSettings::TakesValue);
-        self.default_val = Some(val);
+        self.v.default_val = Some(OsStr::from_bytes(val.as_bytes()));
         self
     }
 
@@ -2852,14 +2897,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("flag")
     ///         .long("flag"))
     ///     .arg(Arg::with_name("other")
     ///         .long("other")
     ///         .default_value_if("flag", None, "default"))
     ///     .get_matches_from(vec![
-    ///         "dvif", "--flag"
+    ///         "prog", "--flag"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), Some("default"));
@@ -2869,14 +2914,14 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("flag")
     ///         .long("flag"))
     ///     .arg(Arg::with_name("other")
     ///         .long("other")
     ///         .default_value_if("flag", None, "default"))
     ///     .get_matches_from(vec![
-    ///         "dvif"
+    ///         "prog"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), None);
@@ -2886,7 +2931,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .takes_value(true)
     ///         .long("opt"))
@@ -2894,7 +2939,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .long("other")
     ///         .default_value_if("opt", Some("special"), "default"))
     ///     .get_matches_from(vec![
-    ///         "dvif", "--opt", "special"
+    ///         "prog", "--opt", "special"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), Some("default"));
@@ -2905,7 +2950,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .takes_value(true)
     ///         .long("opt"))
@@ -2913,26 +2958,38 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///         .long("other")
     ///         .default_value_if("opt", Some("special"), "default"))
     ///     .get_matches_from(vec![
-    ///         "dvif", "--opt", "hahaha"
+    ///         "prog", "--opt", "hahaha"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), None);
     /// ```
     /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value
     /// [`Arg::default_value`]: ./struct.Arg.html#method.default_value
-    pub fn default_value_if(mut self,
+    pub fn default_value_if(self,
                             arg: &'a str,
                             val: Option<&'b str>,
                             default: &'b str)
                             -> Self {
+        self.default_value_if_os(arg, val.map(str::as_bytes).map(OsStr::from_bytes), OsStr::from_bytes(default.as_bytes()))
+    }
+
+    /// Provides a conditional default value in the exact same manner as [`Arg::default_value_if`]
+    /// only using [`OsStr`]s instead.
+    /// [`Arg::default_value_if`]: ./struct.Arg.html#method.default_value_if
+    /// [`OsStr`]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html
+    pub fn default_value_if_os(mut self,
+                            arg: &'a str,
+                            val: Option<&'b OsStr>,
+                            default: &'b OsStr)
+                            -> Self {
         self.setb(ArgSettings::TakesValue);
-        if let Some(ref mut vm) = self.default_vals_ifs {
+        if let Some(ref mut vm) = self.v.default_vals_ifs {
             let l = vm.len();
             vm.insert(l, (arg, val, default));
         } else {
             let mut vm = VecMap::new();
             vm.insert(0, (arg, val, default));
-            self.default_vals_ifs = Some(vm);
+            self.v.default_vals_ifs = Some(vm);
         }
         self
     }
@@ -2957,7 +3014,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("flag")
     ///         .long("flag"))
     ///     .arg(Arg::with_name("opt")
@@ -2970,7 +3027,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///             ("opt", Some("channal"), "chan"),
     ///         ]))
     ///     .get_matches_from(vec![
-    ///         "dvif", "--opt", "channal"
+    ///         "prog", "--opt", "channal"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), Some("chan"));
@@ -2980,7 +3037,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("flag")
     ///         .long("flag"))
     ///     .arg(Arg::with_name("other")
@@ -2990,7 +3047,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///             ("opt", Some("channal"), "chan"),
     ///         ]))
     ///     .get_matches_from(vec![
-    ///         "dvif"
+    ///         "prog"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), None);
@@ -3001,7 +3058,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("dvif")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("flag")
     ///         .long("flag"))
     ///     .arg(Arg::with_name("opt")
@@ -3014,30 +3071,28 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///             ("opt", Some("channal"), "chan"),
     ///         ]))
     ///     .get_matches_from(vec![
-    ///         "dvif", "--opt", "channal", "--flag"
+    ///         "prog", "--opt", "channal", "--flag"
     ///     ]);
     ///
     /// assert_eq!(m.value_of("other"), Some("default"));
     /// ```
     /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value
     /// [`Arg::default_value`]: ./struct.Arg.html#method.default_value
-    #[cfg_attr(feature = "lints", allow(explicit_counter_loop))]
     pub fn default_value_ifs(mut self, ifs: &[(&'a str, Option<&'b str>, &'b str)]) -> Self {
-        self.setb(ArgSettings::TakesValue);
-        if let Some(ref mut vm) = self.default_vals_ifs {
-            let mut l = vm.len();
-            for &(arg, val, default) in ifs {
-                vm.insert(l, (arg, val, default));
-                l += 1;
-            }
-        } else {
-            let mut vm = VecMap::new();
-            let mut l = 0;
-            for &(arg, val, default) in ifs {
-                vm.insert(l, (arg, val, default));
-                l += 1;
-            }
-            self.default_vals_ifs = Some(vm);
+        for &(arg, val, default) in ifs {
+            self = self.default_value_if_os(arg, val.map(str::as_bytes).map(OsStr::from_bytes), OsStr::from_bytes(default.as_bytes()));
+        }
+        self
+    }   
+
+    /// Provides multiple conditional default values in the exact same manner as 
+    /// [`Arg::default_value_ifs`] only using [`OsStr`]s instead.
+    /// [`Arg::default_value_ifs`]: ./struct.Arg.html#method.default_value_ifs
+    /// [`OsStr`]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html
+    #[cfg_attr(feature = "lints", allow(explicit_counter_loop))]
+    pub fn default_value_ifs_os(mut self, ifs: &[(&'a str, Option<&'b OsStr>, &'b OsStr)]) -> Self {
+        for &(arg, val, default) in ifs {
+            self = self.default_value_if_os(arg, val, default);
         }
         self
     }
@@ -3053,7 +3108,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("nlh")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("opt")
     ///         .long("long-option-flag")
     ///         .short("o")
@@ -3064,7 +3119,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///                on a line after the option")
     ///         .next_line_help(true))
     ///     .get_matches_from(vec![
-    ///         "nlh", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     ///
@@ -3111,7 +3166,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///
     /// ```rust
     /// # use clap::{App, Arg};
-    /// let m = App::new("cust-ord")
+    /// let m = App::new("prog")
     ///     .arg(Arg::with_name("a") // Typically args are grouped alphabetically by name.
     ///                              // Args without a display_order have a value of 999 and are
     ///                              // displayed alphabetically with all other 999 valued args.
@@ -3129,7 +3184,7 @@ impl<'a, 'b> Arg<'a, 'b> {
     ///                             // alphabetically with this one...then 2 values, then 3, etc.
     ///         .help("I should be first!"))
     ///     .get_matches_from(vec![
-    ///         "cust-ord", "--help"
+    ///         "prog", "--help"
     ///     ]);
     /// ```
     ///
@@ -3152,13 +3207,13 @@ impl<'a, 'b> Arg<'a, 'b> {
     /// [positional arguments]: ./struct.Arg.html#method.index
     /// [index]: ./struct.Arg.html#method.index
     pub fn display_order(mut self, ord: usize) -> Self {
-        self.disp_ord = ord;
+        self.s.disp_ord = ord;
         self
     }
 
     /// Checks if one of the [`ArgSettings`] settings is set for the argument
     /// [`ArgSettings`]: ./enum.ArgSettings.html
-    pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) }
+    pub fn is_set(&self, s: ArgSettings) -> bool { self.b.is_set(s) }
 
     /// Sets one of the [`ArgSettings`] settings for the argument
     /// [`ArgSettings`]: ./enum.ArgSettings.html
@@ -3175,72 +3230,20 @@ impl<'a, 'b> Arg<'a, 'b> {
     }
 
     #[doc(hidden)]
-    pub fn setb(&mut self, s: ArgSettings) { self.settings.set(s); }
+    pub fn setb(&mut self, s: ArgSettings) { self.b.set(s); }
 
     #[doc(hidden)]
-    pub fn unsetb(&mut self, s: ArgSettings) { self.settings.unset(s); }
+    pub fn unsetb(&mut self, s: ArgSettings) { self.b.unset(s); }
 }
 
 impl<'a, 'b, 'z> From<&'z Arg<'a, 'b>> for Arg<'a, 'b> {
     fn from(a: &'z Arg<'a, 'b>) -> Self {
         Arg {
-            name: a.name,
-            short: a.short,
-            long: a.long,
-            aliases: a.aliases.clone(),
-            help: a.help,
+            b: a.b.clone(),
+            v: a.v.clone(),
+            s: a.s.clone(),
             index: a.index,
-            possible_vals: a.possible_vals.clone(),
-            blacklist: a.blacklist.clone(),
-            requires: a.requires.clone(),
-            num_vals: a.num_vals,
-            min_vals: a.min_vals,
-            max_vals: a.max_vals,
-            val_names: a.val_names.clone(),
-            groups: a.groups.clone(),
-            validator: a.validator.clone(),
-            validator_os: a.validator_os.clone(),
-            overrides: a.overrides.clone(),
-            settings: a.settings,
-            val_delim: a.val_delim,
-            default_val: a.default_val,
-            default_vals_ifs: a.default_vals_ifs.clone(),
-            disp_ord: a.disp_ord,
-            r_unless: a.r_unless.clone(),
             r_ifs: a.r_ifs.clone(),
-            val_terminator: a.val_terminator,
-        }
-    }
-}
-
-impl<'a, 'b> Clone for Arg<'a, 'b> {
-    fn clone(&self) -> Self {
-        Arg {
-            name: self.name,
-            short: self.short,
-            long: self.long,
-            aliases: self.aliases.clone(),
-            help: self.help,
-            index: self.index,
-            possible_vals: self.possible_vals.clone(),
-            blacklist: self.blacklist.clone(),
-            requires: self.requires.clone(),
-            num_vals: self.num_vals,
-            min_vals: self.min_vals,
-            max_vals: self.max_vals,
-            val_names: self.val_names.clone(),
-            groups: self.groups.clone(),
-            validator: self.validator.clone(),
-            validator_os: self.validator_os.clone(),
-            overrides: self.overrides.clone(),
-            settings: self.settings,
-            val_delim: self.val_delim,
-            default_val: self.default_val,
-            default_vals_ifs: self.default_vals_ifs.clone(),
-            disp_ord: self.disp_ord,
-            r_unless: self.r_unless.clone(),
-            r_ifs: self.r_ifs.clone(),
-            val_terminator: self.val_terminator,
         }
     }
 }
diff --git a/src/args/arg_builder/base.rs b/src/args/arg_builder/base.rs
index 8e568244..fa52016f 100644
--- a/src/args/arg_builder/base.rs
+++ b/src/args/arg_builder/base.rs
@@ -1,12 +1,11 @@
-use args::{ArgSettings, Arg, ArgFlags, ArgKind};
+use args::{ArgSettings, Arg, ArgFlags};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Base<'a, 'b>
     where 'a: 'b
 {
     pub name: &'a str,
     pub id: usize,
-    pub kind: ArgKind,
     pub help: Option<&'b str>,
     pub blacklist: Option<Vec<&'a str>>,
     pub settings: ArgFlags,
@@ -16,42 +15,16 @@ pub struct Base<'a, 'b>
     pub requires: Option<Vec<(Option<&'b str>, &'a str)>>,
 }
 
-impl<'n, 'e> Default for Base<'n, 'e> {
-    fn default() -> Self {
-        Base {
-            name: "",
-            id: 0,
-            kind: ArgKind::Pos,
-            help: None,
-            blacklist: None,
-            settings: ArgFlags::new(),
-            r_unless: None,
-            overrides: None,
-            requires: None,
-            groups: None,
-        }
-    }
-}
-
 impl<'n, 'e> Base<'n, 'e> {
     pub fn new(name: &'n str) -> Self { Base { name: name, ..Default::default() } }
 
     pub fn set(&mut self, s: ArgSettings) { self.settings.set(s); }
+    pub fn unset(&mut self, s: ArgSettings) { self.settings.unset(s); }
+    pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) }
 }
 
 impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Base<'n, 'e> {
     fn from(a: &'z Arg<'n, 'e>) -> Self {
-        Base {
-            name: a.name,
-            help: a.help,
-            id: 0,
-            kind: ArgKind::Pos,
-            blacklist: a.blacklist.clone(),
-            settings: a.settings,
-            r_unless: a.r_unless.clone(),
-            overrides: a.overrides.clone(),
-            requires: a.requires.clone(),
-            groups: a.groups.clone(),
-        }
+        a.b.clone()
     }
 }
diff --git a/src/args/arg_builder/flag.rs b/src/args/arg_builder/flag.rs
index 6371848a..ec3b5c35 100644
--- a/src/args/arg_builder/flag.rs
+++ b/src/args/arg_builder/flag.rs
@@ -10,7 +10,7 @@ use vec_map::{self, VecMap};
 
 // Internal
 use Arg;
-use args::{ArgSettings, ArgKind, Base, Switched, AnyArg, DispOrder};
+use args::{ArgSettings, Base, Switched, AnyArg, DispOrder};
 
 #[derive(Default, Clone, Debug)]
 #[doc(hidden)]
@@ -51,7 +51,6 @@ impl<'n, 'e> Display for FlagBuilder<'n, 'e> {
 impl<'n, 'e> AnyArg<'n, 'e> for FlagBuilder<'n, 'e> {
     fn name(&self) -> &'n str { self.b.name }
     fn id(&self) -> usize { self.b.id }
-    fn kind(&self) -> ArgKind { ArgKind::Flag }
     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
     fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) }
     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
@@ -72,8 +71,8 @@ impl<'n, 'e> AnyArg<'n, 'e> for FlagBuilder<'n, 'e> {
     fn val_delim(&self) -> Option<char> { None }
     fn help(&self) -> Option<&'e str> { self.b.help }
     fn val_terminator(&self) -> Option<&'e str> {None}
-    fn default_val(&self) -> Option<&'n str> { None }
-    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>> {None}
+    fn default_val(&self) -> Option<&'e OsStr> { None }
+    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e OsStr>, &'e OsStr)>> {None}
     fn longest_filter(&self) -> bool { self.s.long.is_some() }
     fn aliases(&self) -> Option<Vec<&'e str>> {
         if let Some(ref aliases) = self.s.aliases {
diff --git a/src/args/arg_builder/option.rs b/src/args/arg_builder/option.rs
index f091f49d..0bb784e4 100644
--- a/src/args/arg_builder/option.rs
+++ b/src/args/arg_builder/option.rs
@@ -8,7 +8,7 @@ use std::ffi::{OsStr, OsString};
 use vec_map::{self, VecMap};
 
 // Internal
-use args::{ArgSettings, ArgKind, AnyArg, Base, Switched, Valued, Arg, DispOrder};
+use args::{ArgSettings, AnyArg, Base, Switched, Valued, Arg, DispOrder};
 
 #[allow(missing_debug_implementations)]
 #[doc(hidden)]
@@ -33,7 +33,7 @@ impl<'n, 'e> OptBuilder<'n, 'e> {
         };
         // If the arg is required, add all it's requirements to master required list
         if a.is_set(ArgSettings::Required) {
-            if let Some(ref areqs) = a.requires {
+            if let Some(ref areqs) = a.b.requires {
                 for r in areqs.iter().filter(|r| r.0.is_none()) {
                     reqs.push(r.1);
                 }
@@ -95,7 +95,6 @@ impl<'n, 'e> Display for OptBuilder<'n, 'e> {
 impl<'n, 'e> AnyArg<'n, 'e> for OptBuilder<'n, 'e> {
     fn name(&self) -> &'n str { self.b.name }
     fn id(&self) -> usize { self.b.id }
-    fn kind(&self) -> ArgKind { ArgKind::Opt }
     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
     fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) }
     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
@@ -120,8 +119,8 @@ impl<'n, 'e> AnyArg<'n, 'e> for OptBuilder<'n, 'e> {
     fn val_delim(&self) -> Option<char> { self.v.val_delim }
     fn takes_value(&self) -> bool { true }
     fn help(&self) -> Option<&'e str> { self.b.help }
-    fn default_val(&self) -> Option<&'n str> { self.v.default_val }
-    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>> { self.v.default_vals_ifs.as_ref().map(|vm| vm.values()) }
+    fn default_val(&self) -> Option<&'e OsStr> { self.v.default_val }
+    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e OsStr>, &'e OsStr)>> { self.v.default_vals_ifs.as_ref().map(|vm| vm.values()) }
     fn longest_filter(&self) -> bool { true }
     fn aliases(&self) -> Option<Vec<&'e str>> {
         if let Some(ref aliases) = self.s.aliases {
diff --git a/src/args/arg_builder/positional.rs b/src/args/arg_builder/positional.rs
index 132e1da4..3d2da818 100644
--- a/src/args/arg_builder/positional.rs
+++ b/src/args/arg_builder/positional.rs
@@ -10,7 +10,7 @@ use vec_map::{self, VecMap};
 
 // Internal
 use Arg;
-use args::{ArgSettings, Base, Valued, ArgKind, AnyArg, DispOrder};
+use args::{ArgSettings, Base, Valued, AnyArg, DispOrder};
 
 #[allow(missing_debug_implementations)]
 #[doc(hidden)]
@@ -41,13 +41,13 @@ impl<'n, 'e> PosBuilder<'n, 'e> {
             v: Valued::from(a),
             index: idx,
         };
-        if a.max_vals.is_some() || a.min_vals.is_some() ||
-           (a.num_vals.is_some() && a.num_vals.unwrap() > 1) {
+        if a.v.max_vals.is_some() || a.v.min_vals.is_some() ||
+           (a.v.num_vals.is_some() && a.v.num_vals.unwrap() > 1) {
             pb.b.settings.set(ArgSettings::Multiple);
         }
         // If the arg is required, add all it's requirements to master required list
         if a.is_set(ArgSettings::Required) {
-            if let Some(ref areqs) = a.requires {
+            if let Some(ref areqs) = a.b.requires {
                 for name in areqs.iter().filter(|&&(val,_)|val.is_none()).map(|&(_, name)| name) {
                     reqs.push(name);
                 }
@@ -99,7 +99,6 @@ impl<'n, 'e> Display for PosBuilder<'n, 'e> {
 impl<'n, 'e> AnyArg<'n, 'e> for PosBuilder<'n, 'e> {
     fn name(&self) -> &'n str { self.b.name }
     fn id(&self) -> usize { self.b.id }
-    fn kind(&self) -> ArgKind { ArgKind::Pos }
     fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
     fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) }
     fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
@@ -124,8 +123,8 @@ impl<'n, 'e> AnyArg<'n, 'e> for PosBuilder<'n, 'e> {
     fn val_delim(&self) -> Option<char> { self.v.val_delim }
     fn takes_value(&self) -> bool { true }
     fn help(&self) -> Option<&'e str> { self.b.help }
-    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e str>, &'e str)>> { self.v.default_vals_ifs.as_ref().map(|vm| vm.values()) }
-    fn default_val(&self) -> Option<&'n str> { self.v.default_val }
+    fn default_vals_ifs(&self) -> Option<vec_map::Values<(&'n str, Option<&'e OsStr>, &'e OsStr)>> { self.v.default_vals_ifs.as_ref().map(|vm| vm.values()) }
+    fn default_val(&self) -> Option<&'e OsStr> { self.v.default_val }
     fn longest_filter(&self) -> bool { true }
     fn aliases(&self) -> Option<Vec<&'e str>> { None }
 }
diff --git a/src/args/arg_builder/switched.rs b/src/args/arg_builder/switched.rs
index 33402e16..777ff1d5 100644
--- a/src/args/arg_builder/switched.rs
+++ b/src/args/arg_builder/switched.rs
@@ -23,13 +23,7 @@ impl<'e> Default for Switched<'e> {
 
 impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Switched<'e> {
     fn from(a: &'z Arg<'n, 'e>) -> Self {
-        Switched {
-            short: a.short,
-            long: a.long,
-            aliases: a.aliases.clone(),
-            disp_ord: a.disp_ord,
-            ..Default::default()
-        }
+        a.s.clone()
     }
 }
 
diff --git a/src/args/arg_builder/valued.rs b/src/args/arg_builder/valued.rs
index 503b0d59..d98e3c34 100644
--- a/src/args/arg_builder/valued.rs
+++ b/src/args/arg_builder/valued.rs
@@ -18,8 +18,8 @@ pub struct Valued<'a, 'b>
     pub validator: Option<Rc<Fn(String) -> Result<(), String>>>,
     pub validator_os: Option<Rc<Fn(&OsStr) -> Result<(), OsString>>>,
     pub val_delim: Option<char>,
-    pub default_val: Option<&'a str>,
-    pub default_vals_ifs: Option<VecMap<(&'a str, Option<&'b str>, &'b str)>>,
+    pub default_val: Option<&'b OsStr>,
+    pub default_vals_ifs: Option<VecMap<(&'a str, Option<&'b OsStr>, &'b OsStr)>>,
     pub terminator: Option<&'b str>,
 }
 
@@ -33,7 +33,7 @@ impl<'n, 'e> Default for Valued<'n, 'e> {
             val_names: None,
             validator: None,
             validator_os: None,
-            val_delim: Some(','),
+            val_delim: None,
             default_val: None,
             default_vals_ifs: None,
             terminator: None,
@@ -43,25 +43,13 @@ impl<'n, 'e> Default for Valued<'n, 'e> {
 
 impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Valued<'n, 'e> {
     fn from(a: &'z Arg<'n, 'e>) -> Self {
-        let mut v = Valued {
-            possible_vals: a.possible_vals.clone(),
-            num_vals: a.num_vals,
-            min_vals: a.min_vals,
-            max_vals: a.max_vals,
-            val_names: a.val_names.clone(),
-            validator: a.validator.clone(),
-            validator_os: a.validator_os.clone(),
-            val_delim: a.val_delim,
-            default_val: a.default_val,
-            default_vals_ifs: a.default_vals_ifs.clone(),
-            terminator: a.val_terminator,
-        };
-        if let Some(ref vec) = a.val_names {
+        let mut v = a.v.clone();
+        if let Some(ref vec) = a.v.val_names {
             if vec.len() > 1 {
                 v.num_vals = Some(vec.len() as u64);
             }
         }
-        if let Some(ref vec) = a.val_names {
+        if let Some(ref vec) = a.v.val_names {
             if vec.len() > 1 {
                 v.num_vals = Some(vec.len() as u64);
             }
diff --git a/src/args/mod.rs b/src/args/mod.rs
index 5acec4ce..5c87e1be 100644
--- a/src/args/mod.rs
+++ b/src/args/mod.rs
@@ -19,13 +19,3 @@ mod arg_builder;
 mod matched_arg;
 mod group;
 pub mod settings;
-
-#[doc(hidden)]
-#[derive(Copy, Clone, Debug)]
-pub enum ArgKind {
-    Flag,
-    Opt,
-    Pos,
-    Subcmd,
-    Group,
-}
diff --git a/src/args/settings.rs b/src/args/settings.rs
index bf4bb025..d2a85561 100644
--- a/src/args/settings.rs
+++ b/src/args/settings.rs
@@ -4,19 +4,20 @@ use std::str::FromStr;
 
 bitflags! {
     flags Flags: u16 {
-        const REQUIRED       = 0b0000000000001,
-        const MULTIPLE       = 0b0000000000010,
-        const EMPTY_VALS     = 0b0000000000100,
-        const GLOBAL         = 0b0000000001000,
-        const HIDDEN         = 0b0000000010000,
-        const TAKES_VAL      = 0b0000000100000,
-        const USE_DELIM      = 0b0000001000000,
-        const NEXT_LINE_HELP = 0b0000010000000,
-        const R_UNLESS_ALL   = 0b0000100000000,
-        const REQ_DELIM      = 0b0001000000000,
-        const DELIM_NOT_SET  = 0b0010000000000,
-        const HIDE_POS_VALS  = 0b0100000000000,
-        const ALLOW_TAC_VALS = 0b1000000000000,
+        const REQUIRED       = 0b00000000000001,
+        const MULTIPLE       = 0b00000000000010,
+        const EMPTY_VALS     = 0b00000000000100,
+        const GLOBAL         = 0b00000000001000,
+        const HIDDEN         = 0b00000000010000,
+        const TAKES_VAL      = 0b00000000100000,
+        const USE_DELIM      = 0b00000001000000,
+        const NEXT_LINE_HELP = 0b00000010000000,
+        const R_UNLESS_ALL   = 0b00000100000000,
+        const REQ_DELIM      = 0b00001000000000,
+        const DELIM_NOT_SET  = 0b00010000000000,
+        const HIDE_POS_VALS  = 0b00100000000000,
+        const ALLOW_TAC_VALS = 0b01000000000000,
+        const REQUIRE_EQUALS = 0b10000000000000,
     }
 }
 
@@ -40,7 +41,8 @@ impl ArgFlags {
         RequireDelimiter => REQ_DELIM,
         ValueDelimiterNotSet => DELIM_NOT_SET,
         HidePossibleValues => HIDE_POS_VALS,
-        AllowLeadingHyphen => ALLOW_TAC_VALS
+        AllowLeadingHyphen => ALLOW_TAC_VALS,
+        RequireEquals => REQUIRE_EQUALS 
     }
 }
 
@@ -78,6 +80,8 @@ pub enum ArgSettings {
     HidePossibleValues,
     /// Allows vals that start with a '-'
     AllowLeadingHyphen,
+    /// Require options use `--option=val` syntax
+    RequireEquals,
     #[doc(hidden)]
     RequiredUnlessAll,
     #[doc(hidden)]
@@ -101,6 +105,7 @@ impl FromStr for ArgSettings {
             "valuedelimiternotset" => Ok(ArgSettings::ValueDelimiterNotSet),
             "hidepossiblevalues" => Ok(ArgSettings::HidePossibleValues),
             "allowleadinghyphen" => Ok(ArgSettings::AllowLeadingHyphen),
+            "requireequals" => Ok(ArgSettings::RequireEquals),
             _ => Err("unknown ArgSetting, cannot convert from str".to_owned()),
         }
     }
@@ -138,6 +143,8 @@ mod test {
                    ArgSettings::UseValueDelimiter);
         assert_eq!("valuedelimiternotset".parse::<ArgSettings>().unwrap(),
                    ArgSettings::ValueDelimiterNotSet);
+        assert_eq!("requireequals".parse::<ArgSettings>().unwrap(),
+                   ArgSettings::RequireEquals);
         assert!("hahahaha".parse::<ArgSettings>().is_err());
     }
 }
diff --git a/src/errors.rs b/src/errors.rs
index 359b18ea..37a49537 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -26,11 +26,11 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("speed")
     ///         .possible_value("fast")
     ///         .possible_value("slow"))
-    ///     .get_matches_from_safe(vec!["myprog", "other"]);
+    ///     .get_matches_from_safe(vec!["prog", "other"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidValue);
     /// ```
@@ -43,9 +43,9 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::from_usage("--flag 'some flag'"))
-    ///     .get_matches_from_safe(vec!["myprog", "--other"]);
+    ///     .get_matches_from_safe(vec!["prog", "--other"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnknownArgument);
     /// ```
@@ -61,13 +61,13 @@ pub enum ErrorKind {
     #[cfg_attr(not(feature="suggestions"), doc=" ```no_run")]
     #[cfg_attr(    feature="suggestions" , doc=" ```")]
     /// # use clap::{App, Arg, ErrorKind, SubCommand};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .subcommand(SubCommand::with_name("config")
     ///         .about("Used for configuration")
     ///         .arg(Arg::with_name("config_file")
     ///             .help("The configuration file to use")
     ///             .index(1)))
-    ///     .get_matches_from_safe(vec!["myprog", "confi"]);
+    ///     .get_matches_from_safe(vec!["prog", "confi"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidSubcommand);
     /// ```
@@ -87,13 +87,13 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind, SubCommand};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .subcommand(SubCommand::with_name("config")
     ///         .about("Used for configuration")
     ///         .arg(Arg::with_name("config_file")
     ///             .help("The configuration file to use")
     ///             .index(1)))
-    ///     .get_matches_from_safe(vec!["myprog", "help", "nothing"]);
+    ///     .get_matches_from_safe(vec!["prog", "help", "nothing"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand);
     /// ```
@@ -109,11 +109,11 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let res = App::new("myprog")
+    /// let res = App::new("prog")
     ///     .arg(Arg::with_name("color")
     ///          .long("color")
     ///          .empty_values(false))
-    ///     .get_matches_from_safe(vec!["myprog", "--color="]);
+    ///     .get_matches_from_safe(vec!["prog", "--color="]);
     /// assert!(res.is_err());
     /// assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
     /// ```
@@ -133,10 +133,10 @@ pub enum ErrorKind {
     ///     }
     /// }
     ///
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("num")
     ///          .validator(is_numeric))
-    ///     .get_matches_from_safe(vec!["myprog", "NotANumber"]);
+    ///     .get_matches_from_safe(vec!["prog", "NotANumber"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::ValueValidation);
     /// ```
@@ -149,11 +149,11 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("arg")
     ///         .multiple(true)
     ///         .max_values(2))
-    ///     .get_matches_from_safe(vec!["myprog", "too", "many", "values"]);
+    ///     .get_matches_from_safe(vec!["prog", "too", "many", "values"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::TooManyValues);
     /// ```
@@ -167,11 +167,11 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("some_opt")
     ///         .long("opt")
     ///         .min_values(3))
-    ///     .get_matches_from_safe(vec!["myprog", "--opt", "too", "few"]);
+    ///     .get_matches_from_safe(vec!["prog", "--opt", "too", "few"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::TooFewValues);
     /// ```
@@ -186,12 +186,12 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("some_opt")
     ///         .long("opt")
     ///         .takes_value(true)
     ///         .number_of_values(2))
-    ///     .get_matches_from_safe(vec!["myprog", "--opt", "wrong"]);
+    ///     .get_matches_from_safe(vec!["prog", "--opt", "wrong"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
     /// ```
@@ -207,13 +207,13 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug")
     ///         .conflicts_with("color"))
     ///     .arg(Arg::with_name("color")
     ///         .long("color"))
-    ///     .get_matches_from_safe(vec!["myprog", "--debug", "--color"]);
+    ///     .get_matches_from_safe(vec!["prog", "--debug", "--color"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::ArgumentConflict);
     /// ```
@@ -225,10 +225,10 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("debug")
     ///         .required(true))
-    ///     .get_matches_from_safe(vec!["myprog"]);
+    ///     .get_matches_from_safe(vec!["prog"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
     /// ```
@@ -241,7 +241,7 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, AppSettings, SubCommand, ErrorKind};
-    /// let err = App::new("myprog")
+    /// let err = App::new("prog")
     ///     .setting(AppSettings::SubcommandRequired)
     ///     .subcommand(SubCommand::with_name("test"))
     ///     .get_matches_from_safe(vec![
@@ -261,13 +261,13 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, AppSettings, ErrorKind, SubCommand};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .setting(AppSettings::ArgRequiredElseHelp)
     ///     .subcommand(SubCommand::with_name("config")
     ///         .about("Used for configuration")
     ///         .arg(Arg::with_name("config_file")
     ///             .help("The configuration file to use")))
-    ///     .get_matches_from_safe(vec!["myprog"]);
+    ///     .get_matches_from_safe(vec!["prog"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingArgumentOrSubcommand);
     /// ```
@@ -281,11 +281,11 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .arg(Arg::with_name("debug")
     ///         .long("debug")
     ///         .multiple(false))
-    ///     .get_matches_from_safe(vec!["myprog", "--debug", "--debug"]);
+    ///     .get_matches_from_safe(vec!["prog", "--debug", "--debug"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnexpectedMultipleUsage);
     /// ```
@@ -305,7 +305,7 @@ pub enum ErrorKind {
     /// # use clap::{App, Arg, ErrorKind, AppSettings};
     /// # use std::os::unix::ffi::OsStringExt;
     /// # use std::ffi::OsString;
-    /// let result = App::new("myprog")
+    /// let result = App::new("prog")
     ///     .setting(AppSettings::StrictUtf8)
     ///     .arg(Arg::with_name("utf8")
     ///         .short("u")
@@ -329,8 +329,8 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
-    ///     .get_matches_from_safe(vec!["myprog", "--help"]);
+    /// let result = App::new("prog")
+    ///     .get_matches_from_safe(vec!["prog", "--help"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::HelpDisplayed);
     /// ```
@@ -343,8 +343,8 @@ pub enum ErrorKind {
     ///
     /// ```rust
     /// # use clap::{App, Arg, ErrorKind};
-    /// let result = App::new("myprog")
-    ///     .get_matches_from_safe(vec!["myprog", "--version"]);
+    /// let result = App::new("prog")
+    ///     .get_matches_from_safe(vec!["prog", "--version"]);
     /// assert!(result.is_err());
     /// assert_eq!(result.unwrap_err().kind, ErrorKind::VersionDisplayed);
     /// ```
diff --git a/src/osstringext.rs b/src/osstringext.rs
index 21651085..303cbcbe 100644
--- a/src/osstringext.rs
+++ b/src/osstringext.rs
@@ -5,7 +5,7 @@ use std::ffi::OsStr;
 use std::os::unix::ffi::OsStrExt;
 
 #[cfg(target_os = "windows")]
-trait OsStrExt3 {
+pub trait OsStrExt3 {
     fn from_bytes(b: &[u8]) -> &Self;
     fn as_bytes(&self) -> &[u8];
 }
diff --git a/src/usage_parser.rs b/src/usage_parser.rs
index f747d932..e890e333 100644
--- a/src/usage_parser.rs
+++ b/src/usage_parser.rs
@@ -61,14 +61,14 @@ impl<'a> UsageParser<'a> {
                 break;
             }
         }
-        debug_assert!(!arg.name.is_empty(),
+        debug_assert!(!arg.b.name.is_empty(),
                       format!("No name found for Arg when parsing usage string: {}",
                               self.usage));
-        arg.num_vals = match arg.val_names {
+        arg.v.num_vals = match arg.v.val_names {
             Some(ref v) if v.len() >= 2 => Some(v.len() as u64),
             _ => None,
         };
-        debugln!("UsageParser::parse: vals...{:?}", arg.val_names);
+        debugln!("UsageParser::parse: vals...{:?}", arg.v.val_names);
         arg
     }
 
@@ -83,21 +83,21 @@ impl<'a> UsageParser<'a> {
         let name = &self.usage[self.start..self.pos];
         if self.prev == UsageToken::Unknown {
             debugln!("UsageParser::name: setting name...{}", name);
-            arg.name = name;
-            if arg.long.is_none() && arg.short.is_none() {
+            arg.b.name = name;
+            if arg.s.long.is_none() && arg.s.short.is_none() {
                 debugln!("UsageParser::name: explicit name set...");
                 self.explicit_name_set = true;
                 self.prev = UsageToken::Name;
             }
         } else {
             debugln!("UsageParser::name: setting val name...{}", name);
-            if let Some(ref mut v) = arg.val_names {
+            if let Some(ref mut v) = arg.v.val_names {
                 let len = v.len();
                 v.insert(len, name);
             } else {
                 let mut v = VecMap::new();
                 v.insert(0, name);
-                arg.val_names = Some(v);
+                arg.v.val_names = Some(v);
                 arg.setb(ArgSettings::TakesValue);
             }
             self.prev = UsageToken::ValName;
@@ -129,10 +129,10 @@ impl<'a> UsageParser<'a> {
         let name = &self.usage[self.start..self.pos];
         if !self.explicit_name_set {
             debugln!("UsageParser::long: setting name...{}", name);
-            arg.name = name;
+            arg.b.name = name;
         }
         debugln!("UsageParser::long: setting long...{}", name);
-        arg.long = Some(name);
+        arg.s.long = Some(name);
         self.prev = UsageToken::Long;
     }
 
@@ -141,12 +141,12 @@ impl<'a> UsageParser<'a> {
         let start = &self.usage[self.pos..];
         let short = start.chars().nth(0).expect(INTERNAL_ERROR_MSG);
         debugln!("UsageParser::short: setting short...{}", short);
-        arg.short = Some(short);
-        if arg.name.is_empty() {
+        arg.s.short = Some(short);
+        if arg.b.name.is_empty() {
             // --long takes precedence but doesn't set self.explicit_name_set
             let name = &start[..short.len_utf8()];
             debugln!("UsageParser::short: setting name...{}", name);
-            arg.name = name;
+            arg.b.name = name;
         }
         self.prev = UsageToken::Short;
     }
@@ -163,11 +163,11 @@ impl<'a> UsageParser<'a> {
             if dot_counter == 3 {
                 debugln!("UsageParser::multiple: setting multiple");
                 arg.setb(ArgSettings::Multiple);
-                if arg.settings.is_set(ArgSettings::TakesValue) {
+                if arg.is_set(ArgSettings::TakesValue) {
                     arg.setb(ArgSettings::UseValueDelimiter);
                     arg.unsetb(ArgSettings::ValueDelimiterNotSet);
-                    if arg.val_delim.is_none() {
-                        arg.val_delim = Some(',');
+                    if arg.v.val_delim.is_none() {
+                        arg.v.val_delim = Some(',');
                     }
                 }
                 self.prev = UsageToken::Multiple;
@@ -183,7 +183,7 @@ impl<'a> UsageParser<'a> {
         self.start = self.pos + 1;
         self.pos = self.usage.len() - 1;
         debugln!("UsageParser::help: setting help...{}", &self.usage[self.start..self.pos]);
-        arg.help = Some(&self.usage[self.start..self.pos]);
+        arg.b.help = Some(&self.usage[self.start..self.pos]);
         self.pos += 1;   // Move to next byte to keep from thinking ending ' is a start
         self.prev = UsageToken::Help;
     }
@@ -211,989 +211,989 @@ mod test {
     #[test]
     fn create_flag_usage() {
         let a = Arg::from_usage("[flag] -f 'some help info'");
-        assert_eq!(a.name, "flag");
-        assert_eq!(a.short.unwrap(), 'f');
-        assert!(a.long.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "flag");
+        assert_eq!(a.s.short.unwrap(), 'f');
+        assert!(a.s.long.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
-        assert!(a.val_names.is_none());
-        assert!(a.num_vals.is_none());
+        assert!(a.v.val_names.is_none());
+        assert!(a.v.num_vals.is_none());
 
         let b = Arg::from_usage("[flag] --flag 'some help info'");
-        assert_eq!(b.name, "flag");
-        assert_eq!(b.long.unwrap(), "flag");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "flag");
+        assert_eq!(b.s.long.unwrap(), "flag");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
-        assert!(a.val_names.is_none());
-        assert!(a.num_vals.is_none());
+        assert!(a.v.val_names.is_none());
+        assert!(a.v.num_vals.is_none());
 
         let b = Arg::from_usage("--flag 'some help info'");
-        assert_eq!(b.name, "flag");
-        assert_eq!(b.long.unwrap(), "flag");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "flag");
+        assert_eq!(b.s.long.unwrap(), "flag");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
-        assert!(b.val_names.is_none());
-        assert!(b.num_vals.is_none());
+        assert!(b.v.val_names.is_none());
+        assert!(b.v.num_vals.is_none());
 
         let c = Arg::from_usage("[flag] -f --flag 'some help info'");
-        assert_eq!(c.name, "flag");
-        assert_eq!(c.short.unwrap(), 'f');
-        assert_eq!(c.long.unwrap(), "flag");
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "flag");
+        assert_eq!(c.s.short.unwrap(), 'f');
+        assert_eq!(c.s.long.unwrap(), "flag");
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
 
         let d = Arg::from_usage("[flag] -f... 'some help info'");
-        assert_eq!(d.name, "flag");
-        assert_eq!(d.short.unwrap(), 'f');
-        assert!(d.long.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "flag");
+        assert_eq!(d.s.short.unwrap(), 'f');
+        assert!(d.s.long.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
-        assert!(d.val_names.is_none());
-        assert!(d.num_vals.is_none());
+        assert!(d.v.val_names.is_none());
+        assert!(d.v.num_vals.is_none());
 
         let e = Arg::from_usage("[flag] -f --flag... 'some help info'");
-        assert_eq!(e.name, "flag");
-        assert_eq!(e.long.unwrap(), "flag");
-        assert_eq!(e.short.unwrap(), 'f');
-        assert_eq!(e.help.unwrap(), "some help info");
+        assert_eq!(e.b.name, "flag");
+        assert_eq!(e.s.long.unwrap(), "flag");
+        assert_eq!(e.s.short.unwrap(), 'f');
+        assert_eq!(e.b.help.unwrap(), "some help info");
         assert!(e.is_set(ArgSettings::Multiple));
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("-f --flag... 'some help info'");
-        assert_eq!(e.name, "flag");
-        assert_eq!(e.long.unwrap(), "flag");
-        assert_eq!(e.short.unwrap(), 'f');
-        assert_eq!(e.help.unwrap(), "some help info");
+        assert_eq!(e.b.name, "flag");
+        assert_eq!(e.s.long.unwrap(), "flag");
+        assert_eq!(e.s.short.unwrap(), 'f');
+        assert_eq!(e.b.help.unwrap(), "some help info");
         assert!(e.is_set(ArgSettings::Multiple));
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("--flags");
-        assert_eq!(e.name, "flags");
-        assert_eq!(e.long.unwrap(), "flags");
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert_eq!(e.b.name, "flags");
+        assert_eq!(e.s.long.unwrap(), "flags");
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("--flags...");
-        assert_eq!(e.name, "flags");
-        assert_eq!(e.long.unwrap(), "flags");
+        assert_eq!(e.b.name, "flags");
+        assert_eq!(e.s.long.unwrap(), "flags");
         assert!(e.is_set(ArgSettings::Multiple));
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("[flags] -f");
-        assert_eq!(e.name, "flags");
-        assert_eq!(e.short.unwrap(), 'f');
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert_eq!(e.b.name, "flags");
+        assert_eq!(e.s.short.unwrap(), 'f');
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("[flags] -f...");
-        assert_eq!(e.name, "flags");
-        assert_eq!(e.short.unwrap(), 'f');
+        assert_eq!(e.b.name, "flags");
+        assert_eq!(e.s.short.unwrap(), 'f');
         assert!(e.is_set(ArgSettings::Multiple));
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let a = Arg::from_usage("-f 'some help info'");
-        assert_eq!(a.name, "f");
-        assert_eq!(a.short.unwrap(), 'f');
-        assert!(a.long.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "f");
+        assert_eq!(a.s.short.unwrap(), 'f');
+        assert!(a.s.long.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
-        assert!(a.val_names.is_none());
-        assert!(a.num_vals.is_none());
+        assert!(a.v.val_names.is_none());
+        assert!(a.v.num_vals.is_none());
 
         let e = Arg::from_usage("-f");
-        assert_eq!(e.name, "f");
-        assert_eq!(e.short.unwrap(), 'f');
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert_eq!(e.b.name, "f");
+        assert_eq!(e.s.short.unwrap(), 'f');
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
 
         let e = Arg::from_usage("-f...");
-        assert_eq!(e.name, "f");
-        assert_eq!(e.short.unwrap(), 'f');
+        assert_eq!(e.b.name, "f");
+        assert_eq!(e.s.short.unwrap(), 'f');
         assert!(e.is_set(ArgSettings::Multiple));
-        assert!(e.val_names.is_none());
-        assert!(e.num_vals.is_none());
+        assert!(e.v.val_names.is_none());
+        assert!(e.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage0() {
         // Short only
         let a = Arg::from_usage("[option] -o [opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert!(a.long.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert!(a.s.long.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage1() {
         let b = Arg::from_usage("-o [opt] 'some help info'");
-        assert_eq!(b.name, "o");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert!(b.long.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "o");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert!(b.s.long.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(b.num_vals.is_none());
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage2() {
         let c = Arg::from_usage("<option> -o <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert!(c.long.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert!(c.s.long.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage3() {
         let d = Arg::from_usage("-o <opt> 'some help info'");
-        assert_eq!(d.name, "o");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert!(d.long.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "o");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert!(d.s.long.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(d.num_vals.is_none());
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage4() {
         let a = Arg::from_usage("[option] -o [opt]... 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert!(a.long.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert!(a.s.long.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage5() {
         let a = Arg::from_usage("[option]... -o [opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert!(a.long.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert!(a.s.long.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage6() {
         let b = Arg::from_usage("-o [opt]... 'some help info'");
-        assert_eq!(b.name, "o");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert!(b.long.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "o");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert!(b.s.long.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(b.num_vals.is_none());
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage7() {
         let c = Arg::from_usage("<option> -o <opt>... 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert!(c.long.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert!(c.s.long.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage8() {
         let c = Arg::from_usage("<option>... -o <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert!(c.long.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert!(c.s.long.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage9() {
         let d = Arg::from_usage("-o <opt>... 'some help info'");
-        assert_eq!(d.name, "o");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert!(d.long.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "o");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert!(d.s.long.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(d.num_vals.is_none());
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long1() {
         let a = Arg::from_usage("[option] --opt [opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long2() {
         let b = Arg::from_usage("--opt [option] 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long3() {
         let c = Arg::from_usage("<option> --opt <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long4() {
         let d = Arg::from_usage("--opt <option> 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long5() {
         let a = Arg::from_usage("[option] --opt [opt]... 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long6() {
         let a = Arg::from_usage("[option]... --opt [opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long7() {
         let b = Arg::from_usage("--opt [option]... 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long8() {
         let c = Arg::from_usage("<option> --opt <opt>... 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long9() {
         let c = Arg::from_usage("<option>... --opt <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long10() {
         let d = Arg::from_usage("--opt <option>... 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals1() {
         let a = Arg::from_usage("[option] --opt=[opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals2() {
         let b = Arg::from_usage("--opt=[option] 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals3() {
         let c = Arg::from_usage("<option> --opt=<opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals4() {
         let d = Arg::from_usage("--opt=<option> 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals5() {
         let a = Arg::from_usage("[option] --opt=[opt]... 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals6() {
         let a = Arg::from_usage("[option]... --opt=[opt] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert!(a.short.is_none());
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert!(a.s.short.is_none());
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals7() {
         let b = Arg::from_usage("--opt=[option]... 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert!(b.short.is_none());
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert!(b.s.short.is_none());
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals8() {
         let c = Arg::from_usage("<option> --opt=<opt>... 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals9() {
         let c = Arg::from_usage("<option>... --opt=<opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert!(c.short.is_none());
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert!(c.s.short.is_none());
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_long_equals10() {
         let d = Arg::from_usage("--opt=<option>... 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both1() {
         let a = Arg::from_usage("[option] -o --opt [option] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(a.num_vals.is_none());
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both2() {
         let b = Arg::from_usage("-o --opt [option] 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both3() {
         let c = Arg::from_usage("<option> -o --opt <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both4() {
         let d = Arg::from_usage("-o --opt <option> 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both5() {
         let a = Arg::from_usage("[option]... -o --opt [option] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(a.num_vals.is_none());
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both6() {
         let b = Arg::from_usage("-o --opt [option]... 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both7() {
         let c = Arg::from_usage("<option>... -o --opt <opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both8() {
         let d = Arg::from_usage("-o --opt <option>... 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals1() {
         let a = Arg::from_usage("[option] -o --opt=[option] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(a.num_vals.is_none());
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals2() {
         let b = Arg::from_usage("-o --opt=[option] 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals3() {
         let c = Arg::from_usage("<option> -o --opt=<opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(!c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals4() {
         let d = Arg::from_usage("-o --opt=<option> 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals5() {
         let a = Arg::from_usage("[option]... -o --opt=[option] 'some help info'");
-        assert_eq!(a.name, "option");
-        assert_eq!(a.long.unwrap(), "opt");
-        assert_eq!(a.short.unwrap(), 'o');
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "option");
+        assert_eq!(a.s.long.unwrap(), "opt");
+        assert_eq!(a.s.short.unwrap(), 'o');
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::Multiple));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(a.num_vals.is_none());
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals6() {
         let b = Arg::from_usage("-o --opt=[option]... 'some help info'");
-        assert_eq!(b.name, "opt");
-        assert_eq!(b.long.unwrap(), "opt");
-        assert_eq!(b.short.unwrap(), 'o');
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "opt");
+        assert_eq!(b.s.long.unwrap(), "opt");
+        assert_eq!(b.s.short.unwrap(), 'o');
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::TakesValue));
         assert!(!b.is_set(ArgSettings::Required));
-        assert_eq!(b.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(b.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(b.num_vals.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals7() {
         let c = Arg::from_usage("<option>... -o --opt=<opt> 'some help info'");
-        assert_eq!(c.name, "option");
-        assert_eq!(c.long.unwrap(), "opt");
-        assert_eq!(c.short.unwrap(), 'o');
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "option");
+        assert_eq!(c.s.long.unwrap(), "opt");
+        assert_eq!(c.s.short.unwrap(), 'o');
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(c.is_set(ArgSettings::TakesValue));
         assert!(c.is_set(ArgSettings::Required));
-        assert_eq!(c.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
-        assert!(c.num_vals.is_none());
+        assert_eq!(c.v.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_usage_both_equals8() {
         let d = Arg::from_usage("-o --opt=<option>... 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"option"]);
-        assert!(d.num_vals.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn create_option_with_vals1() {
         let d = Arg::from_usage("-o <file> <mode> 'some help info'");
-        assert_eq!(d.name, "o");
-        assert!(d.long.is_none());
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "o");
+        assert!(d.s.long.is_none());
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"file", &"mode"]);
-        assert_eq!(d.num_vals.unwrap(), 2);
+        assert_eq!(d.v.num_vals.unwrap(), 2);
     }
 
     #[test]
     fn create_option_with_vals2() {
         let d = Arg::from_usage("-o <file> <mode>... 'some help info'");
-        assert_eq!(d.name, "o");
-        assert!(d.long.is_none());
-        assert_eq!(d.short.unwrap(), 'o');
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "o");
+        assert!(d.s.long.is_none());
+        assert_eq!(d.s.short.unwrap(), 'o');
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"file", &"mode"]);
-        assert_eq!(d.num_vals.unwrap(), 2);
+        assert_eq!(d.v.num_vals.unwrap(), 2);
     }
 
     #[test]
     fn create_option_with_vals3() {
         let d = Arg::from_usage("--opt <file> <mode>... 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"file", &"mode"]);
-        assert_eq!(d.num_vals.unwrap(), 2);
+        assert_eq!(d.v.num_vals.unwrap(), 2);
     }
 
     #[test]
     fn create_option_with_vals4() {
         let d = Arg::from_usage("[myopt] --opt <file> <mode> 'some help info'");
-        assert_eq!(d.name, "myopt");
-        assert!(d.short.is_none());
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "myopt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(!d.is_set(ArgSettings::Required));
-        assert_eq!(d.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(d.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"file", &"mode"]);
-        assert_eq!(d.num_vals.unwrap(), 2);
+        assert_eq!(d.v.num_vals.unwrap(), 2);
     }
 
     #[test]
     fn create_option_with_vals5() {
         let d = Arg::from_usage("--opt <file> <mode> 'some help info'");
-        assert_eq!(d.name, "opt");
-        assert!(d.short.is_none());
-        assert_eq!(d.long.unwrap(), "opt");
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "opt");
+        assert!(d.s.short.is_none());
+        assert_eq!(d.s.long.unwrap(), "opt");
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(!d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::TakesValue));
         assert!(d.is_set(ArgSettings::Required));
-        assert_eq!(d.num_vals.unwrap(), 2);
+        assert_eq!(d.v.num_vals.unwrap(), 2);
     }
 
     #[test]
     fn create_positional_usage() {
         let a = Arg::from_usage("[pos] 'some help info'");
-        assert_eq!(a.name, "pos");
-        assert_eq!(a.help.unwrap(), "some help info");
+        assert_eq!(a.b.name, "pos");
+        assert_eq!(a.b.help.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::Multiple));
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
-        assert!(a.num_vals.is_none());
+        assert!(a.v.val_names.is_none());
+        assert!(a.v.num_vals.is_none());
     }
 
     #[test]
     fn create_positional_usage0() {
         let b = Arg::from_usage("<pos> 'some help info'");
-        assert_eq!(b.name, "pos");
-        assert_eq!(b.help.unwrap(), "some help info");
+        assert_eq!(b.b.name, "pos");
+        assert_eq!(b.b.help.unwrap(), "some help info");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::Required));
-        assert!(b.val_names.is_none());
-        assert!(b.num_vals.is_none());
+        assert!(b.v.val_names.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_mult_help() {
         let c = Arg::from_usage("[pos]... 'some help info'");
-        assert_eq!(c.name, "pos");
-        assert_eq!(c.help.unwrap(), "some help info");
+        assert_eq!(c.b.name, "pos");
+        assert_eq!(c.b.help.unwrap(), "some help info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_help_lit_single_quote() {
         let c = Arg::from_usage("[pos]... 'some help\' info'");
-        assert_eq!(c.name, "pos");
-        assert_eq!(c.help.unwrap(), "some help' info");
+        assert_eq!(c.b.name, "pos");
+        assert_eq!(c.b.help.unwrap(), "some help' info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_help_double_lit_single_quote() {
         let c = Arg::from_usage("[pos]... 'some \'help\' info'");
-        assert_eq!(c.name, "pos");
-        assert_eq!(c.help.unwrap(), "some 'help' info");
+        assert_eq!(c.b.name, "pos");
+        assert_eq!(c.b.help.unwrap(), "some 'help' info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_help_newline() {
         let c = Arg::from_usage("[pos]... 'some help{n}\
                                            info'");
-        assert_eq!(c.name, "pos");
-        assert_eq!(c.help.unwrap(), "some help{n}info");
+        assert_eq!(c.b.name, "pos");
+        assert_eq!(c.b.help.unwrap(), "some help{n}info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_help_newline_lit_sq() {
         let c = Arg::from_usage("[pos]... 'some help\' stuff{n}\
                                            info'");
-        assert_eq!(c.name, "pos");
-        assert_eq!(c.help.unwrap(), "some help' stuff{n}info");
+        assert_eq!(c.b.name, "pos");
+        assert_eq!(c.b.help.unwrap(), "some help' stuff{n}info");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_req_mult_help() {
         let d = Arg::from_usage("<pos>... 'some help info'");
-        assert_eq!(d.name, "pos");
-        assert_eq!(d.help.unwrap(), "some help info");
+        assert_eq!(d.b.name, "pos");
+        assert_eq!(d.b.help.unwrap(), "some help info");
         assert!(d.is_set(ArgSettings::Multiple));
         assert!(d.is_set(ArgSettings::Required));
-        assert!(d.val_names.is_none());
-        assert!(d.num_vals.is_none());
+        assert!(d.v.val_names.is_none());
+        assert!(d.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_req() {
         let b = Arg::from_usage("<pos>");
-        assert_eq!(b.name, "pos");
+        assert_eq!(b.b.name, "pos");
         assert!(!b.is_set(ArgSettings::Multiple));
         assert!(b.is_set(ArgSettings::Required));
-        assert!(b.val_names.is_none());
-        assert!(b.num_vals.is_none());
+        assert!(b.v.val_names.is_none());
+        assert!(b.v.num_vals.is_none());
     }
 
     #[test]
     fn pos_mult() {
         let c = Arg::from_usage("[pos]...");
-        assert_eq!(c.name, "pos");
+        assert_eq!(c.b.name, "pos");
         assert!(c.is_set(ArgSettings::Multiple));
         assert!(!c.is_set(ArgSettings::Required));
-        assert!(c.val_names.is_none());
-        assert!(c.num_vals.is_none());
+        assert!(c.v.val_names.is_none());
+        assert!(c.v.num_vals.is_none());
     }
 
     #[test]
     fn nonascii() {
         let a = Arg::from_usage("<ASCII> 'üñíčöĐ€'");
-        assert_eq!(a.name, "ASCII");
-        assert_eq!(a.help, Some("üñíčöĐ€"));
+        assert_eq!(a.b.name, "ASCII");
+        assert_eq!(a.b.help, Some("üñíčöĐ€"));
         let a = Arg::from_usage("<üñíčöĐ€> 'ASCII'");
-        assert_eq!(a.name, "üñíčöĐ€");
-        assert_eq!(a.help, Some("ASCII"));
+        assert_eq!(a.b.name, "üñíčöĐ€");
+        assert_eq!(a.b.help, Some("ASCII"));
         let a = Arg::from_usage("<üñíčöĐ€> 'üñíčöĐ€'");
-        assert_eq!(a.name, "üñíčöĐ€");
-        assert_eq!(a.help, Some("üñíčöĐ€"));
+        assert_eq!(a.b.name, "üñíčöĐ€");
+        assert_eq!(a.b.help, Some("üñíčöĐ€"));
         let a = Arg::from_usage("-ø 'ø'");
-        assert_eq!(a.name, "ø");
-        assert_eq!(a.short, Some('ø'));
-        assert_eq!(a.help, Some("ø"));
+        assert_eq!(a.b.name, "ø");
+        assert_eq!(a.s.short, Some('ø'));
+        assert_eq!(a.b.help, Some("ø"));
         let a = Arg::from_usage("--üñíčöĐ€ 'Nōṫ ASCII'");
-        assert_eq!(a.name, "üñíčöĐ€");
-        assert_eq!(a.long, Some("üñíčöĐ€"));
-        assert_eq!(a.help, Some("Nōṫ ASCII"));
+        assert_eq!(a.b.name, "üñíčöĐ€");
+        assert_eq!(a.s.long, Some("üñíčöĐ€"));
+        assert_eq!(a.b.help, Some("Nōṫ ASCII"));
         let a = Arg::from_usage("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'");
-        assert_eq!(a.name, "ñämê");
-        assert_eq!(a.long, Some("ôpt"));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(),
+        assert_eq!(a.b.name, "ñämê");
+        assert_eq!(a.s.long, Some("ôpt"));
+        assert_eq!(a.v.val_names.unwrap().values().collect::<Vec<_>>(),
                    [&"üñíčöĐ€"]);
-        assert_eq!(a.help, Some("hælp"));
+        assert_eq!(a.b.help, Some("hælp"));
     }
 }


Test patch:
diff --git a/tests/flags.rs b/tests/flags.rs
index 1f8072f7..143404ee 100644
--- a/tests/flags.rs
+++ b/tests/flags.rs
@@ -124,24 +124,24 @@ fn multiple_flags_in_single() {
 #[test]
 fn short_flag_misspel() {
     let a = Arg::from_usage("-f1, --flag 'some flag'");
-    assert_eq!(a.name, "flag");
-    assert_eq!(a.short.unwrap(), 'f');
-    assert_eq!(a.long.unwrap(), "flag");
-    assert_eq!(a.help.unwrap(), "some flag");
+    assert_eq!(a.b.name, "flag");
+    assert_eq!(a.s.short.unwrap(), 'f');
+    assert_eq!(a.s.long.unwrap(), "flag");
+    assert_eq!(a.b.help.unwrap(), "some flag");
     assert!(!a.is_set(ArgSettings::Multiple));
-    assert!(a.val_names.is_none());
-    assert!(a.num_vals.is_none());
+    assert!(a.v.val_names.is_none());
+    assert!(a.v.num_vals.is_none());
 }
 
 #[test]
 fn short_flag_name_missing() {
     let a = Arg::from_usage("-f 'some flag'");
-    assert_eq!(a.name, "f");
-    assert_eq!(a.short.unwrap(), 'f');
-    assert!(a.long.is_none());
-    assert_eq!(a.help.unwrap(), "some flag");
+    assert_eq!(a.b.name, "f");
+    assert_eq!(a.s.short.unwrap(), 'f');
+    assert!(a.s.long.is_none());
+    assert_eq!(a.b.help.unwrap(), "some flag");
     assert!(!a.is_set(ArgSettings::Multiple));
-    assert!(a.val_names.is_none());
-    assert!(a.num_vals.is_none());
+    assert!(a.v.val_names.is_none());
+    assert!(a.v.num_vals.is_none());
 
 }
diff --git a/tests/opts.rs b/tests/opts.rs
index fedfb8fa..a7d2abe7 100644
--- a/tests/opts.rs
+++ b/tests/opts.rs
@@ -14,6 +14,62 @@ USAGE:
 
 For more information try --help";
 
+#[test]
+fn require_equals_fail() {
+    let res = App::new("prog")
+        .arg(Arg::with_name("cfg")
+            .require_equals(true)
+            .takes_value(true)
+            .long("config"))
+        .get_matches_from_safe(vec![
+            "prog", "--config", "file.conf"
+        ]);
+    assert!(res.is_err());
+    assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
+}
+
+#[test]
+fn require_equals_no_empty_values_fail() {
+    let res = App::new("prog")
+        .arg(Arg::with_name("cfg")
+            .require_equals(true)
+            .takes_value(true)
+            .long("config"))
+        .arg(Arg::with_name("some"))
+        .get_matches_from_safe(vec![
+            "prog", "--config=", "file.conf"
+        ]);
+    assert!(res.is_err());
+    assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
+}
+
+#[test]
+fn require_equals_empty_vals_pass() {
+    let res = App::new("prog")
+        .arg(Arg::with_name("cfg")
+            .require_equals(true)
+            .takes_value(true)
+            .empty_values(true)
+            .long("config"))
+        .get_matches_from_safe(vec![
+            "prog", "--config="
+        ]);
+    assert!(res.is_ok());
+}
+
+#[test]
+fn require_equals_pass() {
+    let res = App::new("prog")
+        .arg(Arg::with_name("cfg")
+            .require_equals(true)
+            .takes_value(true)
+            .long("config"))
+        .get_matches_from_safe(vec![
+            "prog", "--config=file.conf"
+        ]);
+    assert!(res.is_ok());
+}
+
 #[test]
 fn stdin_char() {
     let r = App::new("opts")