Repository: clap-rs/clap
Pull request #1911 (2020-05-06 17:24:41)

Option vec to vec
<!--
If your PR closes some issues, please write `Closes #XXXX`
where `XXXX` is the number of the issue you want to fix.
Each issue goes on it's own line.
-->
Our conversation about `Option<Vec>` ergonomics got me thinking: we use this pattern in clap all the time, but there isn't a single place where `None` and `Some([])` mean different things. If fact, reducing these `Option<Vec>` to `Vec` can simplify our code considerably. 

This PR replaces all internal `Option<Vec>` occurrences with plain `Vec`. -300 LOC, yay!

pksunkara: bors r+
CreepySkeleton: bors r-

Wwhait, I'd rather merge https://github.com/clap-rs/clap/pull/1901 first so that guy won't need to rebase his PR. It looks ready.
bors[bot]: Canceled.
pksunkara: bors r+
bors[bot]: Merge conflict.
pksunkara: @CreepySkeleton I guess you have to rebase this.

Patch:
diff --git a/clap_generate/src/generators/shells/bash.rs b/clap_generate/src/generators/shells/bash.rs
index 3e2d6be3..40bd33aa 100644
--- a/clap_generate/src/generators/shells/bash.rs
+++ b/clap_generate/src/generators/shells/bash.rs
@@ -43,7 +43,7 @@ impl Generator for Bash {
         {cmd})
             opts=\"{name_opts}\"
             if [[ ${{cur}} == -* || ${{COMP_CWORD}} -eq 1 ]] ; then
-                COMPREPLY=( $(compgen -W \"${{opts}}\" -- \"${{cur}}\") )
+                COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
                 return 0
             fi
             case \"${{prev}}\" in
@@ -52,7 +52,7 @@ impl Generator for Bash {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W \"${{opts}}\" -- \"${{cur}}\") )
+            COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
             return 0
             ;;
         {subcmd_details}
@@ -117,7 +117,7 @@ fn subcommand_details(app: &App) -> String {
         {subcmd})
             opts=\"{sc_opts}\"
             if [[ ${{cur}} == -* || ${{COMP_CWORD}} -eq {level} ]] ; then
-                COMPREPLY=( $(compgen -W \"${{opts}}\" -- \"${{cur}}\") )
+                COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
                 return 0
             fi
             case \"${{prev}}\" in
@@ -126,7 +126,7 @@ fn subcommand_details(app: &App) -> String {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W \"${{opts}}\" -- \"${{cur}}\") )
+            COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
             return 0
             ;;",
             subcmd_dets,
@@ -181,9 +181,9 @@ fn vals_for(o: &Arg) -> String {
     debug!("vals_for: o={}", o.get_name());
 
     if let Some(ref vals) = o.get_possible_values() {
-        format!("$(compgen -W \"{}\" -- \"${{cur}}\")", vals.join(" "))
+        format!("$(compgen -W \"{}\" -- ${{cur}})", vals.join(" "))
     } else {
-        String::from("$(compgen -f \"${cur}\")")
+        String::from("$(compgen -f ${cur})")
     }
 }
 
diff --git a/examples/04_using_matches.rs b/examples/04_using_matches.rs
index ab5b8563..97f27c93 100644
--- a/examples/04_using_matches.rs
+++ b/examples/04_using_matches.rs
@@ -44,8 +44,8 @@ fn main() {
         println!("Debugging is turned on");
     }
 
-    // If we wanted to do some custom initialization based off some configuration file
-    // provided by the user, we could get the file (A string of the file)
+    // If we wanted to some custom initialization based off some configuration file provided
+    // by the user, we could get the file (A string of the file)
     if let Some(ref file) = matches.value_of("config") {
         println!("Using config file: {}", file);
     }
diff --git a/src/build/app/mod.rs b/src/build/app/mod.rs
index 12126f11..b952d07d 100644
--- a/src/build/app/mod.rs
+++ b/src/build/app/mod.rs
@@ -80,7 +80,7 @@ pub struct App<'b> {
     pub(crate) long_about: Option<&'b str>,
     pub(crate) before_help: Option<&'b str>,
     pub(crate) after_help: Option<&'b str>,
-    pub(crate) aliases: Option<Vec<(&'b str, bool)>>, // (name, visible)
+    pub(crate) aliases: Vec<(&'b str, bool)>, // (name, visible)
     pub(crate) usage_str: Option<&'b str>,
     pub(crate) usage: Option<String>,
     pub(crate) help_str: Option<&'b str>,
@@ -124,19 +124,13 @@ impl<'b> App<'b> {
     /// Iterate through the *visible* aliases for this subcommand.
     #[inline]
     pub fn get_visible_aliases(&self) -> impl Iterator<Item = &str> {
-        self.aliases
-            .as_ref()
-            .into_iter()
-            .flat_map(|aliases| aliases.iter().filter(|(_, vis)| *vis).map(|a| a.0))
+        self.aliases.iter().filter(|(_, vis)| *vis).map(|a| a.0)
     }
 
     /// Iterate through the set of *all* the aliases for this subcommand, both visible and hidden.
     #[inline]
     pub fn get_all_aliases(&self) -> impl Iterator<Item = &str> {
-        self.aliases
-            .as_ref()
-            .into_iter()
-            .flat_map(|aliases| aliases.iter().map(|a| a.0))
+        self.aliases.iter().map(|a| a.0)
     }
 
     /// Get the list of subcommands
@@ -164,19 +158,15 @@ impl<'b> App<'b> {
     /// Panics if the given arg conflicts with an argument that is unknown to this application
     pub fn get_arg_conflicts_with<'a, 'x, 'y>(&'a self, arg: &'x Arg<'y>) -> Vec<&Arg<'b>> // FIXME: This could probably have been an iterator
     {
-        if let Some(black_ids) = arg.blacklist.as_ref() {
-            black_ids
-                .iter()
-                .map(|id| {
-                    self.args.args.iter().find(|arg| arg.id == *id).expect(
-                        "App::get_arg_conflicts_with: \
-                        The passed arg conflicts with an arg unknown to the app",
-                    )
-                })
-                .collect()
-        } else {
-            vec![]
-        }
+        arg.blacklist
+            .iter()
+            .map(|id| {
+                self.args.args.iter().find(|arg| arg.id == *id).expect(
+                    "App::get_arg_conflicts_with: \
+                    The passed arg conflicts with an arg unknown to the app",
+                )
+            })
+            .collect()
     }
 
     /// Check if the setting was set either with [`App::setting`] or [`App::global_setting`]
@@ -770,11 +760,7 @@ impl<'b> App<'b> {
     /// ```
     /// [``]: ./struct..html
     pub fn alias<S: Into<&'b str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            als.push((name.into(), false));
-        } else {
-            self.aliases = Some(vec![(name.into(), false)]);
-        }
+        self.aliases.push((name.into(), false));
         self
     }
 
@@ -799,13 +785,7 @@ impl<'b> App<'b> {
     /// ```
     /// [``]: ./struct..html
     pub fn aliases(mut self, names: &[&'b str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            for n in names {
-                als.push((n, false));
-            }
-        } else {
-            self.aliases = Some(names.iter().map(|n| (*n, false)).collect::<Vec<_>>());
-        }
+        self.aliases.extend(names.iter().map(|n| (*n, false)));
         self
     }
 
@@ -825,11 +805,7 @@ impl<'b> App<'b> {
     /// [``]: ./struct..html
     /// [`App::alias`]: ./struct.App.html#method.alias
     pub fn visible_alias<S: Into<&'b str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            als.push((name.into(), true));
-        } else {
-            self.aliases = Some(vec![(name.into(), true)]);
-        }
+        self.aliases.push((name.into(), true));
         self
     }
 
@@ -849,13 +825,7 @@ impl<'b> App<'b> {
     /// [``]: ./struct..html
     /// [`App::aliases`]: ./struct.App.html#method.aliases
     pub fn visible_aliases(mut self, names: &[&'b str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            for n in names {
-                als.push((n, true));
-            }
-        } else {
-            self.aliases = Some(names.iter().map(|n| (*n, true)).collect::<Vec<_>>());
-        }
+        self.aliases.extend(names.iter().map(|n| (*n, true)));
         self
     }
 
@@ -1523,18 +1493,16 @@ impl<'b> App<'b> {
         let mut pos_counter = 1;
         for a in self.args.args.iter_mut() {
             // Fill in the groups
-            if let Some(ref grps) = a.groups {
-                for g in grps {
-                    let mut found = false;
-                    if let Some(ag) = self.groups.iter_mut().find(|grp| grp.id == *g) {
-                        ag.args.push(a.id.clone());
-                        found = true;
-                    }
-                    if !found {
-                        let mut ag = ArgGroup::_with_id(g.clone());
-                        ag.args.push(a.id.clone());
-                        self.groups.push(ag);
-                    }
+            for g in &a.groups {
+                let mut found = false;
+                if let Some(ag) = self.groups.iter_mut().find(|grp| grp.id == *g) {
+                    ag.args.push(a.id.clone());
+                    found = true;
+                }
+                if !found {
+                    let mut ag = ArgGroup::_with_id(g.clone());
+                    ag.args.push(a.id.clone());
+                    self.groups.push(ag);
                 }
             }
 
@@ -1654,46 +1622,39 @@ impl<'b> App<'b> {
             }
 
             // requires, r_if, r_unless
-            if let Some(reqs) = &arg.requires {
-                for req in reqs {
-                    assert!(
-                        self.id_exists(&req.1),
-                        "Argument or group '{:?}' specified in 'requires*' for '{}' does not exist",
-                        req.1,
-                        arg.name,
-                    );
-                }
+            for req in &arg.requires {
+                assert!(
+                    self.id_exists(&req.1),
+                    "Argument or group '{:?}' specified in 'requires*' for '{}' does not exist",
+                    req.1,
+                    arg.name,
+                );
             }
 
-            if let Some(reqs) = &arg.r_ifs {
-                for req in reqs {
-                    assert!(
-                        self.id_exists(&req.0),
-                        "Argument or group '{:?}' specified in 'required_if*' for '{}' does not exist",
-                        req.0, arg.name
-                    );
-                }
+            for req in &arg.r_ifs {
+                assert!(
+                    self.id_exists(&req.0),
+                    "Argument or group '{:?}' specified in 'required_if*' for '{}' does not exist",
+                    req.0,
+                    arg.name
+                );
             }
 
-            if let Some(reqs) = &arg.r_unless {
-                for req in reqs {
-                    assert!(
-                        self.id_exists(req),
-                        "Argument or group '{:?}' specified in 'required_unless*' for '{}' does not exist",
-                        req, arg.name,
-                    );
-                }
+            for req in &arg.r_unless {
+                assert!(
+                    self.id_exists(req),
+                    "Argument or group '{:?}' specified in 'required_unless*' for '{}' does not exist",
+                    req, arg.name,
+                );
             }
 
             // blacklist
-            if let Some(reqs) = &arg.blacklist {
-                for req in reqs {
-                    assert!(
-                        self.id_exists(req),
-                        "Argument or group '{:?}' specified in 'conflicts_with*' for '{}' does not exist",
-                        req, arg.name,
-                    );
-                }
+            for req in &arg.blacklist {
+                assert!(
+                    self.id_exists(req),
+                    "Argument or group '{:?}' specified in 'conflicts_with*' for '{}' does not exist",
+                    req, arg.name,
+                );
             }
 
             if arg.is_set(ArgSettings::Last) {
@@ -1811,8 +1772,7 @@ impl<'b> App<'b> {
             .args
             .args
             .iter()
-            .any(|x| x.long == Some("help") || x.id == Id::help_hash())
-            || self.is_set(AppSettings::DisableHelpFlags))
+            .any(|x| x.long == Some("help") || x.id == Id::help_hash()))
         {
             debug!("App::_create_help_and_version: Building --help");
             let mut help = Arg::with_name("help")
@@ -2074,15 +2034,13 @@ impl<'b> App<'b> {
             processed.push(a);
 
             if let Some(arg) = self.find(a) {
-                if let Some(ref reqs) = arg.requires {
-                    for r in reqs.iter().filter_map(requires_if_or_not) {
-                        if let Some(req) = self.find(&r) {
-                            if req.requires.is_some() {
-                                r_vec.push(&req.id)
-                            }
+                for r in arg.requires.iter().filter_map(requires_if_or_not) {
+                    if let Some(req) = self.find(&r) {
+                        if !req.requires.is_empty() {
+                            r_vec.push(&req.id)
                         }
-                        args.push(r);
                     }
+                    args.push(r);
                 }
             }
         }
@@ -2129,7 +2087,6 @@ impl<'a> From<&'a Yaml> for App<'a> {
         }
 
         yaml_str!(a, yaml, version);
-        yaml_str!(a, yaml, long_version);
         yaml_str!(a, yaml, author);
         yaml_str!(a, yaml, bin_name);
         yaml_str!(a, yaml, about);
diff --git a/src/build/app/settings.rs b/src/build/app/settings.rs
index 39d644a9..e66e2263 100644
--- a/src/build/app/settings.rs
+++ b/src/build/app/settings.rs
@@ -48,7 +48,6 @@ bitflags! {
         const ARGS_OVERRIDE_SELF             = 1 << 39;
         const HELP_REQUIRED                  = 1 << 40;
         const SUBCOMMAND_PRECEDENCE_OVER_ARG = 1 << 41;
-        const DISABLE_HELP_FLAGS             = 1 << 42;
     }
 }
 
@@ -101,8 +100,6 @@ impl_settings! { AppSettings, AppFlags,
         => Flags::DERIVE_DISP_ORDER,
     DisableHelpSubcommand("disablehelpsubcommand")
         => Flags::DISABLE_HELP_SC,
-    DisableHelpFlags("disablehelpflags")
-        => Flags::DISABLE_HELP_FLAGS,
     DisableVersion("disableversion")
         => Flags::DISABLE_VERSION,
     GlobalVersion("globalversion")
@@ -604,37 +601,6 @@ pub enum AppSettings {
     /// [`Arg::use_delimiter(false)`]: ./struct.Arg.html#method.use_delimiter
     DontDelimitTrailingValues,
 
-    /// Disables `-h` and `--help` [`App`] without affecting any of the [`SubCommand`]s
-    /// (Defaults to `false`; application *does* have help flags)
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use clap::{App, AppSettings, ErrorKind};
-    /// let res = App::new("myprog")
-    ///     .setting(AppSettings::DisableHelpFlags)
-    ///     .try_get_matches_from(vec![
-    ///         "myprog", "-h"
-    ///     ]);
-    /// assert!(res.is_err());
-    /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
-    /// ```
-    ///
-    /// ```rust
-    /// # use clap::{App, AppSettings, ErrorKind};
-    /// let res = App::new("myprog")
-    ///     .setting(AppSettings::DisableHelpFlags)
-    ///     .subcommand(App::new("test"))
-    ///     .try_get_matches_from(vec![
-    ///         "myprog", "test", "-h"
-    ///     ]);
-    /// assert!(res.is_err());
-    /// assert_eq!(res.unwrap_err().kind, ErrorKind::HelpDisplayed);
-    /// ```
-    /// [`SubCommand`]: ./struct.SubCommand.html
-    /// [`App`]: ./struct.App.html
-    DisableHelpFlags,
-
     /// Disables the `help` subcommand
     ///
     /// # Examples
@@ -1001,7 +967,7 @@ pub enum AppSettings {
     /// Disables `-V` and `--version` for all [``]s
     /// (Defaults to `false`; subcommands *do* have version flags.)
     ///
-    /// **NOTE:** This setting must be set **prior** to adding any subcommands.
+    /// **NOTE:** This setting must be set **prior** adding any subcommands
     ///
     /// # Examples
     ///
@@ -1074,10 +1040,6 @@ mod test {
     #[allow(clippy::cognitive_complexity)]
     #[test]
     fn app_settings_fromstr() {
-        assert_eq!(
-            "disablehelpflags".parse::<AppSettings>().unwrap(),
-            AppSettings::DisableHelpFlags
-        );
         assert_eq!(
             "argsnegatesubcommands".parse::<AppSettings>().unwrap(),
             AppSettings::ArgsNegateSubcommands
diff --git a/src/build/arg/mod.rs b/src/build/arg/mod.rs
index 03641489..caa2df1c 100644
--- a/src/build/arg/mod.rs
+++ b/src/build/arg/mod.rs
@@ -57,29 +57,29 @@ pub struct Arg<'help> {
     pub(crate) name: &'help str,
     pub(crate) about: Option<&'help str>,
     pub(crate) long_about: Option<&'help str>,
-    pub(crate) blacklist: Option<Vec<Id>>,
+    pub(crate) blacklist: Vec<Id>,
     pub(crate) settings: ArgFlags,
-    pub(crate) overrides: Option<Vec<Id>>,
-    pub(crate) groups: Option<Vec<Id>>,
-    pub(crate) requires: Option<Vec<(Option<&'help str>, Id)>>,
-    pub(crate) r_ifs: Option<Vec<(Id, &'help str)>>,
-    pub(crate) r_unless: Option<Vec<Id>>,
+    pub(crate) overrides: Vec<Id>,
+    pub(crate) groups: Vec<Id>,
+    pub(crate) requires: Vec<(Option<&'help str>, Id)>,
+    pub(crate) r_ifs: Vec<(Id, &'help str)>,
+    pub(crate) r_unless: Vec<Id>,
     pub(crate) short: Option<char>,
     pub(crate) long: Option<&'help str>,
-    pub(crate) aliases: Option<Vec<(&'help str, bool)>>, // (name, visible)
-    pub(crate) short_aliases: Vec<(char, bool)>,         // (name, visible)
+    pub(crate) aliases: Vec<(&'help str, bool)>, // (name, visible)
+    pub(crate) short_aliases: Vec<(char, bool)>, // (name, visible)
     pub(crate) disp_ord: usize,
     pub(crate) unified_ord: usize,
-    pub(crate) possible_vals: Option<Vec<&'help str>>,
-    pub(crate) val_names: Option<VecMap<&'help str>>,
+    pub(crate) possible_vals: Vec<&'help str>,
+    pub(crate) val_names: VecMap<&'help str>,
     pub(crate) num_vals: Option<u64>,
     pub(crate) max_vals: Option<u64>,
     pub(crate) min_vals: Option<u64>,
     pub(crate) validator: Option<Validator>,
     pub(crate) validator_os: Option<ValidatorOs>,
     pub(crate) val_delim: Option<char>,
-    pub(crate) default_vals: Option<Vec<&'help OsStr>>,
-    pub(crate) default_vals_ifs: Option<VecMap<(Id, Option<&'help OsStr>, &'help OsStr)>>,
+    pub(crate) default_vals: Vec<&'help OsStr>,
+    pub(crate) default_vals_ifs: VecMap<(Id, Option<&'help OsStr>, &'help OsStr)>,
     pub(crate) env: Option<(&'help OsStr, Option<OsString>)>,
     pub(crate) terminator: Option<&'help str>,
     pub(crate) index: Option<u64>,
@@ -123,7 +123,11 @@ impl<'help> Arg<'help> {
     /// Get the list of the possible values for this argument, if any
     #[inline]
     pub fn get_possible_values(&self) -> Option<&[&str]> {
-        self.possible_vals.as_deref()
+        if self.possible_vals.is_empty() {
+            None
+        } else {
+            Some(&self.possible_vals)
+        }
     }
 
     /// Get the index of this argument, if any
@@ -236,7 +240,6 @@ impl<'help> Arg<'help> {
                 "hide_default_value" => yaml_to_bool!(a, v, hide_default_value),
                 "overrides_with" => yaml_vec_or_str!(v, a, overrides_with),
                 "possible_values" => yaml_vec_or_str!(v, a, possible_value),
-                "case_insensitive" => yaml_to_bool!(a, v, case_insensitive),
                 "required_unless_one" => yaml_vec_or_str!(v, a, required_unless),
                 "required_unless_all" => {
                     a = yaml_vec_or_str!(v, a, required_unless);
@@ -359,11 +362,7 @@ impl<'help> Arg<'help> {
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     pub fn alias<S: Into<&'help str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            als.push((name.into(), false));
-        } else {
-            self.aliases = Some(vec![(name.into(), false)]);
-        }
+        self.aliases.push((name.into(), false));
         self
     }
 
@@ -419,13 +418,7 @@ impl<'help> Arg<'help> {
     /// ```
     /// [`Arg`]: ./struct.Arg.html
     pub fn aliases(mut self, names: &[&'help str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            for n in names {
-                als.push((n, false));
-            }
-        } else {
-            self.aliases = Some(names.iter().map(|&x| (x, false)).collect());
-        }
+        self.aliases.extend(names.iter().map(|&x| (x, false)));
         self
     }
 
@@ -481,11 +474,7 @@ impl<'help> Arg<'help> {
     /// [`Arg`]: ./struct.Arg.html
     /// [`App::alias`]: ./struct.Arg.html#method.alias
     pub fn visible_alias<S: Into<&'help str>>(mut self, name: S) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            als.push((name.into(), true));
-        } else {
-            self.aliases = Some(vec![(name.into(), true)]);
-        }
+        self.aliases.push((name.into(), true));
         self
     }
 
@@ -537,13 +526,7 @@ impl<'help> Arg<'help> {
     /// [`Arg`]: ./struct.Arg.html
     /// [`App::aliases`]: ./struct.Arg.html#method.aliases
     pub fn visible_aliases(mut self, names: &[&'help str]) -> Self {
-        if let Some(ref mut als) = self.aliases {
-            for n in names {
-                als.push((n, true));
-            }
-        } else {
-            self.aliases = Some(names.iter().map(|n| (*n, true)).collect::<Vec<_>>());
-        }
+        self.aliases.extend(names.iter().map(|n| (*n, true)));
         self
     }
 
@@ -774,12 +757,7 @@ impl<'help> Arg<'help> {
     /// [`Arg::required`]: ./struct.Arg.html#method.required
     /// [`Arg::required_unless(name)`]: ./struct.Arg.html#method.required_unless
     pub fn required_unless<T: Key>(mut self, arg_id: T) -> Self {
-        let id = arg_id.into();
-        if let Some(ref mut vec) = self.r_unless {
-            vec.push(id);
-        } else {
-            self.r_unless = Some(vec![id]);
-        }
+        self.r_unless.push(arg_id.into());
         self
     }
 
@@ -847,13 +825,7 @@ impl<'help> Arg<'help> {
     /// [`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: &[&str]) -> Self {
-        if let Some(ref mut vec) = self.r_unless {
-            for s in names {
-                vec.push(s.into());
-            }
-        } else {
-            self.r_unless = Some(names.iter().map(Into::into).collect());
-        }
+        self.r_unless.extend(names.iter().map(Id::from));
         self.setting(ArgSettings::RequiredUnlessAll)
     }
 
@@ -922,13 +894,7 @@ impl<'help> Arg<'help> {
     /// [`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: &[&str]) -> Self {
-        if let Some(ref mut vec) = self.r_unless {
-            for s in names {
-                vec.push(s.into());
-            }
-        } else {
-            self.r_unless = Some(names.iter().map(Into::into).collect());
-        }
+        self.r_unless.extend(names.iter().map(Id::from));
         self
     }
 
@@ -978,12 +944,7 @@ impl<'help> Arg<'help> {
     /// [`Arg::exclusive(true)`]: ./struct.Arg.html#method.exclusive
 
     pub fn conflicts_with<T: Key>(mut self, arg_id: T) -> Self {
-        let name = arg_id.into();
-        if let Some(ref mut vec) = self.blacklist {
-            vec.push(name);
-        } else {
-            self.blacklist = Some(vec![name]);
-        }
+        self.blacklist.push(arg_id.into());
         self
     }
 
@@ -1033,13 +994,7 @@ impl<'help> Arg<'help> {
     /// [`Arg::exclusive(true)`]: ./struct.Arg.html#method.exclusive
 
     pub fn conflicts_with_all(mut self, names: &[&str]) -> Self {
-        if let Some(ref mut vec) = self.blacklist {
-            for s in names {
-                vec.push(s.into());
-            }
-        } else {
-            self.blacklist = Some(names.iter().map(Into::into).collect());
-        }
+        self.blacklist.extend(names.iter().map(Id::from));
         self
     }
 
@@ -1190,12 +1145,7 @@ impl<'help> Arg<'help> {
     /// [`Multiple*`]: ./enum.ArgSettings.html#variant.MultipleValues
     /// [`UseValueDelimiter`]: ./enum.ArgSettings.html#variant.UseValueDelimiter
     pub fn overrides_with<T: Key>(mut self, arg_id: T) -> Self {
-        let name = arg_id.into();
-        if let Some(ref mut vec) = self.overrides {
-            vec.push(name);
-        } else {
-            self.overrides = Some(vec![name]);
-        }
+        self.overrides.push(arg_id.into());
         self
     }
 
@@ -1227,13 +1177,7 @@ impl<'help> Arg<'help> {
     /// assert!(!m.is_present("flag"));
     /// ```
     pub fn overrides_with_all<T: Key>(mut self, names: &[T]) -> Self {
-        if let Some(ref mut vec) = self.overrides {
-            for s in names {
-                vec.push(s.into());
-            }
-        } else {
-            self.overrides = Some(names.iter().map(Into::into).collect());
-        }
+        self.overrides.extend(names.iter().map(Id::from));
         self
     }
 
@@ -1293,12 +1237,7 @@ impl<'help> Arg<'help> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires<T: Key>(mut self, arg_id: T) -> Self {
-        let arg = arg_id.into();
-        if let Some(ref mut vec) = self.requires {
-            vec.push((None, arg));
-        } else {
-            self.requires = Some(vec![(None, arg)]);
-        }
+        self.requires.push((None, arg_id.into()));
         self
     }
 
@@ -1362,12 +1301,7 @@ impl<'help> Arg<'help> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires_if<T: Key>(mut self, val: &'help str, arg_id: T) -> Self {
-        let arg = arg_id.into();
-        if let Some(ref mut vec) = self.requires {
-            vec.push((Some(val), arg));
-        } else {
-            self.requires = Some(vec![(Some(val), arg)]);
-        }
+        self.requires.push((Some(val), arg_id.into()));
         self
     }
 
@@ -1423,17 +1357,8 @@ impl<'help> Arg<'help> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [override]: ./struct.Arg.html#method.overrides_with
     pub fn requires_ifs<T: Key>(mut self, ifs: &[(&'help str, T)]) -> Self {
-        if let Some(ref mut vec) = self.requires {
-            for (val, arg) in ifs {
-                vec.push((Some(val), arg.into()));
-            }
-        } else {
-            let mut vec = vec![];
-            for (val, arg) in ifs {
-                vec.push((Some(*val), arg.into()));
-            }
-            self.requires = Some(vec);
-        }
+        self.requires
+            .extend(ifs.iter().map(|(val, arg)| (Some(*val), Id::from(arg))));
         self
     }
 
@@ -1501,12 +1426,7 @@ impl<'help> Arg<'help> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [required]: ./struct.Arg.html#method.required
     pub fn required_if<T: Key>(mut self, arg_id: T, val: &'help str) -> Self {
-        let arg = arg_id.into();
-        if let Some(ref mut vec) = self.r_ifs {
-            vec.push((arg, val));
-        } else {
-            self.r_ifs = Some(vec![(arg, val)]);
-        }
+        self.r_ifs.push((arg_id.into(), val));
         self
     }
 
@@ -1591,17 +1511,8 @@ impl<'help> Arg<'help> {
     /// [Conflicting]: ./struct.Arg.html#method.conflicts_with
     /// [required]: ./struct.Arg.html#method.required
     pub fn required_ifs<T: Key>(mut self, ifs: &[(T, &'help str)]) -> Self {
-        if let Some(ref mut vec) = self.r_ifs {
-            for (id, val) in ifs {
-                vec.push((Id::from_ref(id), *val));
-            }
-        } else {
-            let mut vec = vec![];
-            for (id, val) in ifs {
-                vec.push((Id::from_ref(id), *val));
-            }
-            self.r_ifs = Some(vec);
-        }
+        self.r_ifs
+            .extend(ifs.iter().map(|(id, val)| (Id::from_ref(id), *val)));
         self
     }
 
@@ -1668,13 +1579,7 @@ impl<'help> Arg<'help> {
     /// [override]: ./struct.Arg.html#method.overrides_with
     /// [`Arg::requires_all(&[arg, arg2])`]: ./struct.Arg.html#method.requires_all
     pub fn requires_all<T: Key>(mut self, names: &[T]) -> Self {
-        if let Some(ref mut vec) = self.requires {
-            for s in names {
-                vec.push((None, s.into()));
-            }
-        } else {
-            self.requires = Some(names.iter().map(|s| (None, s.into())).collect());
-        }
+        self.requires.extend(names.iter().map(|s| (None, s.into())));
         self
     }
 
@@ -1832,13 +1737,7 @@ impl<'help> Arg<'help> {
     /// [positional arguments]: ./struct.Arg.html#method.index
     pub fn possible_values(mut self, names: &[&'help str]) -> Self {
         self.set_mut(ArgSettings::TakesValue);
-        if let Some(ref mut vec) = self.possible_vals {
-            for s in names {
-                vec.push(s);
-            }
-        } else {
-            self.possible_vals = Some(names.to_vec());
-        }
+        self.possible_vals.extend(names);
         self
     }
 
@@ -1897,11 +1796,7 @@ impl<'help> Arg<'help> {
     /// [positional arguments]: ./struct.Arg.html#method.index
     pub fn possible_value(mut self, name: &'help str) -> Self {
         self.set_mut(ArgSettings::TakesValue);
-        if let Some(ref mut vec) = self.possible_vals {
-            vec.push(name);
-        } else {
-            self.possible_vals = Some(vec![name]);
-        }
+        self.possible_vals.push(name);
         self
     }
 
@@ -1936,12 +1831,7 @@ impl<'help> Arg<'help> {
     /// ```
     /// [`ArgGroup`]: ./struct.ArgGroup.html
     pub fn group<T: Key>(mut self, group_id: T) -> Self {
-        let name = group_id.into();
-        if let Some(ref mut vec) = self.groups {
-            vec.push(name);
-        } else {
-            self.groups = Some(vec![name]);
-        }
+        self.groups.push(group_id.into());
         self
     }
 
@@ -1977,13 +1867,7 @@ impl<'help> Arg<'help> {
     /// ```
     /// [`ArgGroup`]: ./struct.ArgGroup.html
     pub fn groups<T: Key>(mut self, group_ids: &[T]) -> Self {
-        if let Some(ref mut vec) = self.groups {
-            for s in group_ids {
-                vec.push(s.into());
-            }
-        } else {
-            self.groups = Some(group_ids.iter().map(Into::into).collect());
-        }
+        self.groups.extend(group_ids.iter().map(Id::from));
         self
     }
 
@@ -2343,19 +2227,13 @@ impl<'help> Arg<'help> {
             self.unset_mut(ArgSettings::ValueDelimiterNotSet);
             self.set_mut(ArgSettings::UseValueDelimiter);
         }
-        if let Some(ref mut vals) = self.val_names {
-            let mut l = vals.len();
-            for s in names {
-                vals.insert(l, s);
-                l += 1;
-            }
-        } else {
-            let mut vm = VecMap::new();
-            for (i, n) in names.iter().enumerate() {
-                vm.insert(i, *n);
-            }
-            self.val_names = Some(vm);
+
+        let mut i = self.val_names.len();
+        for s in names {
+            self.val_names.insert(i, s);
+            i += 1;
         }
+
         self
     }
 
@@ -2407,14 +2285,8 @@ impl<'help> Arg<'help> {
     /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value
     pub fn value_name(mut self, name: &'help str) -> Self {
         self.set_mut(ArgSettings::TakesValue);
-        if let Some(ref mut vals) = self.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);
-        }
+        let l = self.val_names.len();
+        self.val_names.insert(l, name);
         self
     }
 
@@ -2510,7 +2382,7 @@ impl<'help> Arg<'help> {
     #[inline]
     pub fn default_values_os(mut self, vals: &[&'help OsStr]) -> Self {
         self.set_mut(ArgSettings::TakesValue);
-        self.default_vals = Some(vals.to_vec());
+        self.default_vals = vals.to_vec();
         self
     }
 
@@ -2629,16 +2501,10 @@ impl<'help> Arg<'help> {
         val: Option<&'help OsStr>,
         default: &'help OsStr,
     ) -> Self {
-        let arg = arg_id.into();
         self.set_mut(ArgSettings::TakesValue);
-        if let Some(ref mut vm) = self.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);
-        }
+        let l = self.default_vals_ifs.len();
+        self.default_vals_ifs
+            .insert(l, (arg_id.into(), val, default));
         self
     }
 
@@ -4257,12 +4123,8 @@ impl<'help> Arg<'help> {
                 self.set_mut(ArgSettings::MultipleValues);
                 self.set_mut(ArgSettings::MultipleOccurrences);
             }
-        } else if self.is_set(ArgSettings::TakesValue) {
-            if let Some(ref vec) = self.val_names {
-                if vec.len() > 1 {
-                    self.num_vals = Some(vec.len() as u64);
-                }
-            }
+        } else if self.is_set(ArgSettings::TakesValue) && self.val_names.len() > 1 {
+            self.num_vals = Some(self.val_names.len() as u64);
         }
     }
 
@@ -4288,10 +4150,8 @@ impl<'help> Arg<'help> {
 
     // Used for positionals when printing
     pub(crate) fn multiple_str(&self) -> &str {
-        let mult_vals = self
-            .val_names
-            .as_ref()
-            .map_or(true, |names| names.len() < 2);
+        // FIXME: This should probably be > 1
+        let mult_vals = self.val_names.len() < 2;
         if (self.is_set(ArgSettings::MultipleValues)
             || self.is_set(ArgSettings::MultipleOccurrences))
             && mult_vals
@@ -4311,19 +4171,19 @@ impl<'help> Arg<'help> {
         } else {
             ' '
         });
-        if let Some(ref names) = self.val_names {
-            debug!("Arg::name_no_brackets: val_names={:#?}", names);
+        if !self.val_names.is_empty() {
+            debug!("Arg::name_no_brackets: val_names={:#?}", self.val_names);
 
-            if names.len() > 1 {
+            if self.val_names.len() > 1 {
                 Cow::Owned(
-                    names
+                    self.val_names
                         .values()
                         .map(|n| format!("<{}>", n))
                         .collect::<Vec<_>>()
                         .join(&*delim),
                 )
             } else {
-                Cow::Borrowed(names.values().next().expect(INTERNAL_ERROR_MSG))
+                Cow::Borrowed(self.val_names.values().next().expect(INTERNAL_ERROR_MSG))
             }
         } else {
             debug!("Arg::name_no_brackets: just name");
@@ -4337,13 +4197,12 @@ impl<'a> Arg<'a> {
         debug!("Arg::_debug_asserts:{}", self.name);
 
         // Self conflict
-        if let Some(vec) = &self.blacklist {
-            assert!(
-                !vec.iter().any(|x| *x == self.id),
-                "Argument '{}' cannot conflict with itself",
-                self.name,
-            );
-        }
+        // TODO: this check should be recursive
+        assert!(
+            !self.blacklist.iter().any(|x| *x == self.id),
+            "Argument '{}' cannot conflict with itself",
+            self.name,
+        );
     }
 }
 
@@ -4375,11 +4234,11 @@ impl<'help> Display for Arg<'help> {
             } else {
                 ' '
             });
-            if let Some(ref names) = self.val_names {
+            if !self.val_names.is_empty() {
                 write!(
                     f,
                     "{}",
-                    names
+                    self.val_names
                         .values()
                         .map(|n| format!("<{}>", n))
                         .collect::<Vec<_>>()
@@ -4388,10 +4247,7 @@ impl<'help> Display for Arg<'help> {
             } else {
                 write!(f, "<{}>", self.name)?;
             }
-            if self.settings.is_set(ArgSettings::MultipleValues)
-                && (self.val_names.is_none()
-                    || (self.val_names.is_some() && self.val_names.as_ref().unwrap().len() == 1))
-            {
+            if self.settings.is_set(ArgSettings::MultipleValues) && self.val_names.len() < 2 {
                 write!(f, "...")?;
             }
             return Ok(());
@@ -4423,15 +4279,15 @@ impl<'help> Display for Arg<'help> {
         };
 
         // Write the values such as <name1> <name2>
-        if let Some(ref vec) = self.val_names {
-            let mut it = vec.iter().peekable();
+        if !self.val_names.is_empty() {
+            let mut it = self.val_names.iter().peekable();
             while let Some((_, val)) = it.next() {
                 write!(f, "<{}>", val)?;
                 if it.peek().is_some() {
                     write!(f, "{}", delim)?;
                 }
             }
-            let num = vec.len();
+            let num = self.val_names.len();
             if self.is_set(ArgSettings::MultipleValues) && num == 1 {
                 write!(f, "...")?;
             }
@@ -4548,7 +4404,7 @@ mod test {
     fn flag_display_single_alias() {
         let mut f = Arg::with_name("flg");
         f.long = Some("flag");
-        f.aliases = Some(vec![("als", true)]);
+        f.aliases = vec![("als", true)];
 
         assert_eq!(&*format!("{}", f), "--flag")
     }
@@ -4557,12 +4413,12 @@ mod test {
     fn flag_display_multiple_aliases() {
         let mut f = Arg::with_name("flg");
         f.short = Some('f');
-        f.aliases = Some(vec![
+        f.aliases = vec![
             ("alias_not_visible", false),
             ("f2", true),
             ("f3", true),
             ("f4", true),
-        ]);
+        ];
         assert_eq!(&*format!("{}", f), "-f");
     }
 
@@ -4680,7 +4536,7 @@ mod test {
         let mut vm = VecMap::new();
         vm.insert(0, "file1");
         vm.insert(1, "file2");
-        p2.val_names = Some(vm);
+        p2.val_names = vm;
 
         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
     }
@@ -4692,7 +4548,7 @@ mod test {
         let mut vm = VecMap::new();
         vm.insert(0, "file1");
         vm.insert(1, "file2");
-        p2.val_names = Some(vm);
+        p2.val_names = vm;
 
         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
     }
diff --git a/src/build/arg_group.rs b/src/build/arg_group.rs
index e1b19916..07515852 100644
--- a/src/build/arg_group.rs
+++ b/src/build/arg_group.rs
@@ -43,7 +43,7 @@ use crate::util::{Id, Key};
 ///     .arg("--minor         'auto increase minor'")
 ///     .arg("--patch         'auto increase patch'")
 ///     .group(ArgGroup::with_name("vers")
-///          .args(&["set-ver", "major", "minor", "patch"])
+///          .args(&["set-ver", "major", "minor","patch"])
 ///          .required(true))
 ///     .try_get_matches_from(vec!["app", "--major", "--patch"]);
 /// // Because we used two args in the group it's an error
@@ -80,8 +80,8 @@ pub struct ArgGroup<'a> {
     pub(crate) name: &'a str,
     pub(crate) args: Vec<Id>,
     pub(crate) required: bool,
-    pub(crate) requires: Option<Vec<Id>>,
-    pub(crate) conflicts: Option<Vec<Id>>,
+    pub(crate) requires: Vec<Id>,
+    pub(crate) conflicts: Vec<Id>,
     pub(crate) multiple: bool,
 }
 
@@ -299,12 +299,7 @@ impl<'a> ArgGroup<'a> {
     /// [required group]: ./struct.ArgGroup.html#method.required
     /// [argument requirement rules]: ./struct.Arg.html#method.requires
     pub fn requires<T: Key>(mut self, id: T) -> Self {
-        let arg_id = id.into();
-        if let Some(ref mut reqs) = self.requires {
-            reqs.push(arg_id);
-        } else {
-            self.requires = Some(vec![arg_id]);
-        }
+        self.requires.push(id.into());
         self
     }
 
@@ -375,12 +370,7 @@ impl<'a> ArgGroup<'a> {
     /// ```
     /// [argument exclusion rules]: ./struct.Arg.html#method.conflicts_with
     pub fn conflicts_with<T: Key>(mut self, id: T) -> Self {
-        let arg_id = id.into();
-        if let Some(ref mut confs) = self.conflicts {
-            confs.push(arg_id);
-        } else {
-            self.conflicts = Some(vec![arg_id]);
-        }
+        self.conflicts.push(id.into());
         self
     }
 
@@ -527,8 +517,8 @@ mod test {
         let confs = vec!["c1".into(), "c2".into(), "c3".into(), "c4".into()];
 
         assert_eq!(g.args, args);
-        assert_eq!(g.requires, Some(reqs));
-        assert_eq!(g.conflicts, Some(confs));
+        assert_eq!(g.requires, reqs);
+        assert_eq!(g.conflicts, confs);
     }
 
     #[test]
@@ -572,10 +562,7 @@ mod test {
              \trequires: {:?},\n\
              \tconflicts: {:?},\n\
              }}",
-            args,
-            true,
-            Some(reqs),
-            Some(confs)
+            args, true, reqs, confs
         );
         assert_eq!(&*format!("{:?}", g), &*debug_str);
     }
@@ -600,8 +587,8 @@ mod test {
 
         let g2 = ArgGroup::from(&g);
         assert_eq!(g2.args, args);
-        assert_eq!(g2.requires, Some(reqs));
-        assert_eq!(g2.conflicts, Some(confs));
+        assert_eq!(g2.requires, reqs);
+        assert_eq!(g2.conflicts, confs);
     }
 
     #[cfg(feature = "yaml")]
@@ -629,8 +616,8 @@ requires:
         let reqs = vec!["r1".into(), "r2".into(), "r3".into(), "r4".into()];
         let confs = vec!["c1".into(), "c2".into(), "c3".into(), "c4".into()];
         assert_eq!(g.args, args);
-        assert_eq!(g.requires, Some(reqs));
-        assert_eq!(g.conflicts, Some(confs));
+        assert_eq!(g.requires, reqs);
+        assert_eq!(g.conflicts, confs);
     }
 }
 
diff --git a/src/build/usage_parser.rs b/src/build/usage_parser.rs
index f1364c4f..8512d3a9 100644
--- a/src/build/usage_parser.rs
+++ b/src/build/usage_parser.rs
@@ -1,7 +1,6 @@
 // Internal
 use crate::{
     build::{Arg, ArgSettings},
-    util::VecMap,
     INTERNAL_ERROR_MSG,
 };
 
@@ -63,9 +62,10 @@ impl<'a> UsageParser<'a> {
                 break;
             }
         }
-        arg.num_vals = match arg.val_names {
-            Some(ref v) if v.len() >= 2 => Some(v.len() as u64),
-            _ => None,
+        arg.num_vals = if arg.val_names.len() > 1 {
+            Some(arg.val_names.len() as u64)
+        } else {
+            None
         };
         if !arg.has_switch() && arg.is_set(ArgSettings::MultipleOccurrences) {
             // We had a positional and need to set mult vals too
@@ -101,15 +101,11 @@ impl<'a> UsageParser<'a> {
             }
         } else {
             debug!("UsageParser::name: setting val name...{}", name);
-            if let Some(ref mut v) = arg.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);
+            if arg.val_names.is_empty() {
                 arg.set_mut(ArgSettings::TakesValue);
             }
+            let len = arg.val_names.len();
+            arg.val_names.insert(len, name);
             self.prev = UsageToken::ValName;
         }
     }
@@ -221,9 +217,7 @@ impl<'a> UsageParser<'a> {
             &self.usage[self.start..self.pos]
         );
         arg.set_mut(ArgSettings::TakesValue);
-        arg.default_vals = Some(vec![std::ffi::OsStr::new(
-            &self.usage[self.start..self.pos],
-        )]);
+        arg.default_vals = vec![std::ffi::OsStr::new(&self.usage[self.start..self.pos])];
         self.prev = UsageToken::Default;
     }
 }
@@ -266,7 +260,7 @@ mod test {
         assert!(a.long.is_none());
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] --flag 'some help info'");
@@ -275,7 +269,7 @@ mod test {
         assert!(a.short.is_none());
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flag 'some help info'");
@@ -284,7 +278,7 @@ mod test {
         assert!(a.short.is_none());
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f --flag 'some help info'");
@@ -293,7 +287,7 @@ mod test {
         assert_eq!(a.long.unwrap(), "flag");
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f... 'some help info'");
@@ -302,7 +296,7 @@ mod test {
         assert!(a.long.is_none());
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f --flag... 'some help info'");
@@ -311,7 +305,7 @@ mod test {
         assert_eq!(a.short.unwrap(), 'f');
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f --flag... 'some help info'");
@@ -320,33 +314,33 @@ mod test {
         assert_eq!(a.short.unwrap(), 'f');
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flags");
         assert_eq!(a.name, "flags");
         assert_eq!(a.long.unwrap(), "flags");
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flags...");
         assert_eq!(a.name, "flags");
         assert_eq!(a.long.unwrap(), "flags");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flags] -f");
         assert_eq!(a.name, "flags");
         assert_eq!(a.short.unwrap(), 'f');
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flags] -f...");
         assert_eq!(a.name, "flags");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f 'some help info'");
@@ -355,20 +349,20 @@ mod test {
         assert!(a.long.is_none());
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f");
         assert_eq!(a.name, "f");
         assert_eq!(a.short.unwrap(), 'f');
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f...");
         assert_eq!(a.name, "f");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -384,7 +378,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -399,7 +393,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -414,7 +408,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -429,7 +423,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -444,7 +438,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -458,7 +452,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -473,7 +467,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -488,7 +482,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -502,7 +496,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -517,7 +511,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -532,7 +526,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -547,10 +541,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -565,7 +556,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -580,10 +571,7 @@ mod test {
         assert!(!a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -598,7 +586,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -612,7 +600,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -627,10 +615,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -645,7 +630,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -659,7 +644,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -675,10 +660,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -694,7 +676,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -710,10 +692,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -729,7 +708,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -745,10 +724,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -764,7 +740,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -778,7 +754,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -794,10 +770,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -813,7 +786,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -827,7 +800,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -843,10 +816,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -862,10 +832,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -881,10 +848,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -900,7 +864,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -916,10 +880,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -933,10 +894,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -952,10 +910,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -969,7 +924,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -985,10 +940,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1004,10 +956,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1023,10 +972,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1042,7 +988,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1058,10 +1004,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1075,10 +1018,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1094,10 +1034,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1111,7 +1048,7 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.val_names.unwrap().values().collect::<Vec<_>>(), [&"opt"]);
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1127,10 +1064,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"option"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);
         assert!(a.num_vals.is_none());
     }
 
@@ -1146,10 +1080,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
     }
 
@@ -1165,10 +1096,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
     }
 
@@ -1184,10 +1112,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
     }
 
@@ -1203,10 +1128,7 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
     }
 
@@ -1234,7 +1156,7 @@ mod test {
             !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1247,7 +1169,7 @@ mod test {
             !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))
         );
         assert!(a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1260,7 +1182,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1273,7 +1195,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1286,7 +1208,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1302,7 +1224,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1318,7 +1240,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1331,7 +1253,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1343,7 +1265,7 @@ mod test {
             !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))
         );
         assert!(a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1355,7 +1277,7 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(!a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
     }
 
@@ -1368,9 +1290,9 @@ mod test {
             a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)
         );
         assert!(a.is_set(ArgSettings::Required));
-        assert!(a.val_names.is_none());
+        assert!(a.val_names.is_empty());
         assert!(a.num_vals.is_none());
-        assert_eq!(a.default_vals, Some(vec![std::ffi::OsStr::new("a")]));
+        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
     #[test]
@@ -1385,12 +1307,9 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
-        assert_eq!(a.default_vals, Some(vec![std::ffi::OsStr::new("a")]));
+        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
     #[test]
@@ -1405,12 +1324,9 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
-        assert_eq!(
-            a.val_names.unwrap().values().collect::<Vec<_>>(),
-            [&"file", &"mode"]
-        );
+        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);
         assert_eq!(a.num_vals.unwrap(), 2);
-        assert_eq!(a.default_vals, Some(vec![std::ffi::OsStr::new("a")]));
+        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
     #[test]
@@ -1435,10 +1351,7 @@ mod test {
         let a = Arg::from("[ñä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.val_names.values().collect::<Vec<_>>(), [&"üñíčöĐ€"]);
         assert_eq!(a.about, Some("hælp"));
     }
 }
diff --git a/src/macros.rs b/src/macros.rs
index a063e015..946eb88f 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -262,8 +262,7 @@ macro_rules! app_from_crate {
 ///         (author: "Someone E. <someone_else@other.com>")
 ///         (@arg verbose: -v --verbose "Print test information verbosely")
 ///     )
-/// )
-/// .get_matches();
+/// );
 /// # }
 /// ```
 ///
@@ -495,13 +494,9 @@ macro_rules! clap_app {
     (@arg ($arg:expr) $modes:tt $ident:ident[$($target:ident)*] $($tail:tt)*) => {
         $crate::clap_app!{ @arg ($arg $( .$ident(stringify!($target)) )*) $modes $($tail)* }
     };
-    // Inherit builder's functions, e.g. `index(2)`, `requires_if("val", "arg")`
-    (@arg ($arg:expr) $modes:tt $ident:ident($($expr:expr),*) $($tail:tt)*) => {
-        $crate::clap_app!{ @arg ($arg.$ident($($expr),*)) $modes $($tail)* }
-    };
-    // Inherit builder's functions with trailing comma, e.g. `index(2,)`, `requires_if("val", "arg",)`
-    (@arg ($arg:expr) $modes:tt $ident:ident($($expr:expr,)*) $($tail:tt)*) => {
-        $crate::clap_app!{ @arg ($arg.$ident($($expr),*)) $modes $($tail)* }
+    // Inherit builder's functions
+    (@arg ($arg:expr) $modes:tt $ident:ident($($expr:expr)*) $($tail:tt)*) => {
+        $crate::clap_app!{ @arg ($arg.$ident($($expr)*)) $modes $($tail)* }
     };
     // Build a subcommand outside of an app.
     (@subcommand ($name:expr) => $($tail:tt)*) => {
@@ -685,8 +680,8 @@ macro_rules! names {
         $app.get_subcommands().iter().map(|s| &*s.get_name()).chain(
             $app.get_subcommands()
                 .iter()
-                .filter(|s| s.aliases.is_some())
-                .flat_map(|s| s.aliases.as_ref().unwrap().iter().map(|&(n, _)| n)),
+                .filter(|s| !s.aliases.is_empty()) // REFACTOR
+                .flat_map(|s| s.aliases.iter().map(|&(n, _)| n)),
         )
     }};
 }
diff --git a/src/mkeymap.rs b/src/mkeymap.rs
index 828c4bfe..45e8d4fc 100644
--- a/src/mkeymap.rs
+++ b/src/mkeymap.rs
@@ -146,14 +146,15 @@ fn _get_keys(arg: &Arg) -> Vec<KeyType> {
     if let Some(c) = arg.short {
         keys.push(KeyType::Short(c));
     }
-    if let Some(ref aliases) = arg.aliases {
-        for long in aliases
-            .iter()
-            .map(|(a, _)| KeyType::Long(OsString::from(a)))
-        {
-            keys.push(long);
-        }
+
+    for long in arg
+        .aliases
+        .iter()
+        .map(|(a, _)| KeyType::Long(OsString::from(a)))
+    {
+        keys.push(long);
     }
+
     if let Some(long) = arg.long {
         keys.push(KeyType::Long(OsString::from(long)));
     }
diff --git a/src/output/help.rs b/src/output/help.rs
index 99d04e40..01e60bd2 100644
--- a/src/output/help.rs
+++ b/src/output/help.rs
@@ -278,15 +278,15 @@ impl<'b, 'c, 'd, 'w> Help<'b, 'c, 'd, 'w> {
             } else {
                 ' '
             };
-            if let Some(ref vec) = arg.val_names {
-                let mut it = vec.iter().peekable();
+            if !arg.val_names.is_empty() {
+                let mut it = arg.val_names.iter().peekable();
                 while let Some((_, val)) = it.next() {
                     self.good(&format!("<{}>", val))?;
                     if it.peek().is_some() {
                         self.none(&delim.to_string())?;
                     }
                 }
-                let num = vec.len();
+                let num = arg.val_names.len();
                 if mult && num == 1 {
                     self.good("...")?;
                 }
@@ -473,23 +473,26 @@ impl<'b, 'c, 'd, 'w> Help<'b, 'c, 'd, 'w> {
             let env_info = format!(" [env: {}{}]", env.0.to_string_lossy(), env_val);
             spec_vals.push(env_info);
         }
-        if !a.is_set(ArgSettings::HideDefaultValue) {
-            if let Some(ref pv) = a.default_vals {
-                debug!("Help::spec_vals: Found default value...[{:?}]", pv);
+        if !a.is_set(ArgSettings::HideDefaultValue) && !a.default_vals.is_empty() {
+            debug!(
+                "Help::spec_vals: Found default value...[{:?}]",
+                a.default_vals
+            );
 
-                let pvs = pv
-                    .iter()
-                    .map(|&pvs| pvs.to_string_lossy())
-                    .collect::<Vec<_>>()
-                    .join(" ");
+            let pvs = a
+                .default_vals
+                .iter()
+                .map(|&pvs| pvs.to_string_lossy())
+                .collect::<Vec<_>>()
+                .join(" ");
 
-                spec_vals.push(format!(" [default: {}]", pvs));
-            }
+            spec_vals.push(format!(" [default: {}]", pvs));
         }
-        if let Some(ref aliases) = a.aliases {
-            debug!("Help::spec_vals: Found aliases...{:?}", aliases);
+        if !a.aliases.is_empty() {
+            debug!("Help::spec_vals: Found aliases...{:?}", a.aliases);
 
-            let als = aliases
+            let als = a
+                .aliases
                 .iter()
                 .filter(|&als| als.1) // visible
                 .map(|&als| als.0) // name
@@ -520,12 +523,19 @@ impl<'b, 'c, 'd, 'w> Help<'b, 'c, 'd, 'w> {
             }
         }
 
-        if !self.hide_pv && !a.is_set(ArgSettings::HidePossibleValues) {
-            if let Some(ref pv) = a.possible_vals {
-                debug!("Help::spec_vals: Found possible vals...{:?}", pv);
+        if !self.hide_pv
+            && !a.is_set(ArgSettings::HidePossibleValues)
+            && !a.possible_vals.is_empty()
+        {
+            debug!(
+                "Help::spec_vals: Found possible vals...{:?}",
+                a.possible_vals
+            );
 
-                spec_vals.push(format!(" [possible values: {}]", pv.join(", ")));
-            }
+            spec_vals.push(format!(
+                " [possible values: {}]",
+                a.possible_vals.join(", ")
+            ));
         }
         spec_vals.join(" ")
     }
@@ -563,10 +573,11 @@ impl<'b, 'c, 'd, 'w> Help<'b, 'c, 'd, 'w> {
     fn sc_spec_vals(&self, a: &App) -> String {
         debug!("Help::sc_spec_vals: a={}", a.name);
         let mut spec_vals = vec![];
-        if let Some(ref aliases) = a.aliases {
-            debug!("Help::spec_vals: Found aliases...{:?}", aliases);
+        if !a.aliases.is_empty() {
+            debug!("Help::spec_vals: Found aliases...{:?}", a.aliases);
 
-            let als = aliases
+            let als = a
+                .aliases
                 .iter()
                 .filter(|&als| als.1) // visible
                 .map(|&als| als.0) // name
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index 56bc6362..f2fbae3f 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -318,10 +318,8 @@ where
                 debug!("Parser::_build: adding {} to default requires", a.name);
                 let idx = self.required.insert(a.id.clone());
                 // If the arg is required, add all it's requirements to master required list
-                if let Some(ref areqs) = a.requires {
-                    for (_, name) in areqs.iter().filter(|(val, _)| val.is_none()) {
-                        self.required.insert_child(idx, name.clone());
-                    }
+                for (_, name) in a.requires.iter().filter(|(val, _)| val.is_none()) {
+                    self.required.insert_child(idx, name.clone());
                 }
             }
         }
@@ -352,10 +350,8 @@ where
         for group in &self.app.groups {
             if group.required {
                 let idx = self.required.insert(group.id.clone());
-                if let Some(ref reqs) = group.requires {
-                    for a in reqs {
-                        self.required.insert_child(idx, a.clone());
-                    }
+                for a in &group.requires {
+                    self.required.insert_child(idx, a.clone());
                 }
             }
         }
@@ -1410,17 +1406,15 @@ where
                     self_override.push(o.clone());
                     false
                 };
-                if let Some(ref overrides) = arg.overrides {
-                    debug!("Parser::remove_overrides:iter:{:?}:{:?}", name, overrides);
-                    for o in overrides {
-                        if *o == arg.id {
-                            if handle_self_override(o) {
-                                continue;
-                            }
-                        } else {
-                            arg_overrides.push((arg.id.clone(), o));
-                            arg_overrides.push((o.clone(), &arg.id));
+                for o in &arg.overrides {
+                    debug!("Parser::remove_overrides:iter:{:?} => {:?}", name, o);
+                    if *o == arg.id {
+                        if handle_self_override(o) {
+                            continue;
                         }
+                    } else {
+                        arg_overrides.push((arg.id.clone(), o));
+                        arg_overrides.push((o.clone(), &arg.id));
                     }
                 }
                 if self.is_set(AS::AllArgsOverrideSelf) {
@@ -1477,12 +1471,12 @@ where
     }
 
     fn add_value(&self, arg: &Arg<'b>, matcher: &mut ArgMatcher, ty: ValueType) -> ClapResult<()> {
-        if let Some(ref vm) = arg.default_vals_ifs {
+        if !arg.default_vals_ifs.is_empty() {
             debug!("Parser::add_value: has conditional defaults");
 
             let mut done = false;
             if matcher.get(&arg.id).is_none() {
-                for (id, val, default) in vm.values() {
+                for (id, val, default) in arg.default_vals_ifs.values() {
                     let add = if let Some(a) = matcher.get(&id) {
                         if let Some(v) = val {
                             a.vals.iter().any(|value| v == value)
@@ -1508,7 +1502,7 @@ where
             debug!("Parser::add_value: doesn't have conditional defaults");
         }
 
-        if let Some(ref vals) = arg.default_vals {
+        if !arg.default_vals.is_empty() {
             debug!("Parser::add_value:iter:{}: has default vals", arg.name);
             if matcher
                 .get(&arg.id)
@@ -1521,7 +1515,7 @@ where
                     arg.name
                 );
 
-                for val in vals {
+                for val in &arg.default_vals {
                     self.add_val_to_arg(arg, &ArgStr::new(val), matcher, ty)?;
                 }
             } else if matcher.get(&arg.id).is_some() {
@@ -1531,7 +1525,7 @@ where
             } else {
                 debug!("Parser::add_value:iter:{}: wasn't used", arg.name);
 
-                for val in vals {
+                for val in &arg.default_vals {
                     self.add_val_to_arg(arg, &ArgStr::new(val), matcher, ty)?;
                 }
             }
diff --git a/src/parse/validator.rs b/src/parse/validator.rs
index 84571287..eed0cfa0 100644
--- a/src/parse/validator.rs
+++ b/src/parse/validator.rs
@@ -97,13 +97,18 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
                     self.p.app.color(),
                 )?);
             }
-            if let Some(ref p_vals) = arg.possible_vals {
-                debug!("Validator::validate_arg_values: possible_vals={:?}", p_vals);
+            if !arg.possible_vals.is_empty() {
+                debug!(
+                    "Validator::validate_arg_values: possible_vals={:?}",
+                    arg.possible_vals
+                );
                 let val_str = val.to_string_lossy();
                 let ok = if arg.is_set(ArgSettings::IgnoreCase) {
-                    p_vals.iter().any(|pv| pv.eq_ignore_ascii_case(&val_str))
+                    arg.possible_vals
+                        .iter()
+                        .any(|pv| pv.eq_ignore_ascii_case(&val_str))
                 } else {
-                    p_vals.contains(&&*val_str)
+                    arg.possible_vals.contains(&&*val_str)
                 };
                 if !ok {
                     let used: Vec<Id> = matcher
@@ -117,7 +122,7 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
                         .collect();
                     return Err(Error::invalid_value(
                         val_str,
-                        p_vals,
+                        &arg.possible_vals,
                         arg,
                         &*Usage::new(self.p).create_usage_with_title(&*used),
                         self.p.app.color(),
@@ -167,15 +172,13 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
         if let Some(other_arg) = self.p.app.find(name) {
             for k in matcher.arg_names() {
                 if let Some(a) = self.p.app.find(k) {
-                    if let Some(ref v) = a.blacklist {
-                        if v.contains(&name) {
-                            return Err(Error::argument_conflict(
-                                a,
-                                Some(other_arg.to_string()),
-                                &*usg,
-                                self.p.app.color(),
-                            )?);
-                        }
+                    if a.blacklist.contains(&name) {
+                        return Err(Error::argument_conflict(
+                            a,
+                            Some(other_arg.to_string()),
+                            &*usg,
+                            self.p.app.color(),
+                        )?);
                     }
                 }
             }
@@ -226,16 +229,12 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
                     .count()
                     > 1;
 
-                let conf_with_arg = g
-                    .conflicts
-                    .as_ref()
-                    .map_or(false, |c| c.iter().any(|x| matcher.contains(x)));
+                let conf_with_arg = g.conflicts.iter().any(|x| matcher.contains(x));
 
                 let arg_conf_with_gr = matcher
                     .arg_names()
                     .filter_map(|x| self.p.app.find(x))
-                    .filter_map(|x| x.blacklist.as_ref())
-                    .any(|c| c.iter().any(|c| *c == g.id));
+                    .any(|x| x.blacklist.iter().any(|c| *c == g.id));
 
                 should_err = conf_with_self || conf_with_arg || arg_conf_with_gr;
             } else if let Some(ma) = matcher.get(name) {
@@ -292,19 +291,17 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
 
             if let Some(arg) = self.p.app.find(name) {
                 // Since an arg was used, every arg it conflicts with is added to the conflicts
-                if let Some(ref bl) = arg.blacklist {
-                    for conf in bl {
-                        if self.p.app.find(conf).is_some() {
-                            if conf != name {
-                                self.c.insert(conf.clone());
-                            }
-                        } else {
-                            // for g_arg in self.p.app.unroll_args_in_group(conf) {
-                            //     if &g_arg != name {
-                            self.c.insert(conf.clone()); // TODO ERROR is here - groups allow one arg but this line disallows all group args
-                                                         //     }
-                                                         // }
+                for conf in &arg.blacklist {
+                    if self.p.app.find(conf).is_some() {
+                        if conf != name {
+                            self.c.insert(conf.clone());
                         }
+                    } else {
+                        // for g_arg in self.p.app.unroll_args_in_group(conf) {
+                        //     if &g_arg != name {
+                        self.c.insert(conf.clone()); // TODO ERROR is here - groups allow one arg but this line disallows all group args
+                                                     //     }
+                                                     // }
                     }
                 }
 
@@ -352,10 +349,8 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
                 }
             } else if let Some(g) = self.p.app.groups.iter().find(|grp| grp.id == *name) {
                 debug!("Validator::gather_conflicts:iter:{:?}:group", name);
-                if let Some(ref reqs) = g.requires {
-                    for r in reqs {
-                        self.p.required.insert(r.clone());
-                    }
+                for r in &g.requires {
+                    self.p.required.insert(r.clone());
                 }
             }
         }
@@ -381,10 +376,8 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
                     .iter()
                     .find(|g| g.id == *name)
                     .expect(INTERNAL_ERROR_MSG);
-                if let Some(ref g_reqs) = grp.requires {
-                    if g_reqs.iter().any(|n| !matcher.contains(n)) {
-                        return self.missing_required_error(matcher, Some(name));
-                    }
+                if grp.requires.iter().any(|n| !matcher.contains(n)) {
+                    return self.missing_required_error(matcher, Some(name));
                 }
             }
         }
@@ -483,16 +476,14 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
         matcher: &ArgMatcher,
     ) -> ClapResult<()> {
         debug!("Validator::validate_arg_requires:{:?}", a.name);
-        if let Some(ref a_reqs) = a.requires {
-            for (val, name) in a_reqs.iter() {
-                if let Some(val) = val {
-                    let missing_req = |v| v == val && !matcher.contains(&name);
-                    if ma.vals.iter().any(missing_req) {
-                        return self.missing_required_error(matcher, Some(&a.id));
-                    }
-                } else if !matcher.contains(&name) {
-                    return self.missing_required_error(matcher, Some(&name));
+        for (val, name) in &a.requires {
+            if let Some(val) = val {
+                let missing_req = |v| v == val && !matcher.contains(&name);
+                if ma.vals.iter().any(missing_req) {
+                    return self.missing_required_error(matcher, Some(&a.id));
                 }
+            } else if !matcher.contains(&name) {
+                return self.missing_required_error(matcher, Some(&name));
             }
         }
         Ok(())
@@ -527,16 +518,8 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
         }
 
         // Validate the conditionally required args
-        for (a, r_ifs) in self
-            .p
-            .app
-            .args
-            .args
-            .iter()
-            .filter(|a| a.r_ifs.is_some())
-            .map(|a| (a, a.r_ifs.as_ref().unwrap()))
-        {
-            for (other, val) in r_ifs.iter() {
+        for a in self.p.app.args.args.iter() {
+            for (other, val) in &a.r_ifs {
                 if let Some(ma) = matcher.get(other) {
                     if ma.contains_val(val) && !matcher.contains(&a.id) {
                         return self.missing_required_error(matcher, Some(&a.id));
@@ -554,21 +537,16 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
 
     fn validate_arg_conflicts(&self, a: &Arg<'b>, matcher: &ArgMatcher) -> bool {
         debug!("Validator::validate_arg_conflicts: a={:?}", a.name);
-        a.blacklist
-            .as_ref()
-            .map(|bl| {
-                bl.iter().any(|conf| {
-                    matcher.contains(conf)
-                        || self
-                            .p
-                            .app
-                            .groups
-                            .iter()
-                            .find(|g| g.id == *conf)
-                            .map_or(false, |g| g.args.iter().any(|arg| matcher.contains(arg)))
-                })
-            })
-            .unwrap_or(false)
+        a.blacklist.iter().any(|conf| {
+            matcher.contains(conf)
+                || self
+                    .p
+                    .app
+                    .groups
+                    .iter()
+                    .find(|g| g.id == *conf)
+                    .map_or(false, |g| g.args.iter().any(|arg| matcher.contains(arg)))
+        })
     }
 
     fn validate_required_unless(&self, matcher: &ArgMatcher) -> ClapResult<()> {
@@ -579,7 +557,7 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
             .args
             .args
             .iter()
-            .filter(|a| a.r_unless.is_some())
+            .filter(|a| !a.r_unless.is_empty())
             .filter(|a| !matcher.contains(&a.id))
         {
             debug!("Validator::validate_required_unless:iter:{}", a.name);
@@ -594,19 +572,12 @@ impl<'b, 'c, 'z> Validator<'b, 'c, 'z> {
     // Failing a required unless means, the arg's "unless" wasn't present, and neither were they
     fn fails_arg_required_unless(&self, a: &Arg<'b>, matcher: &ArgMatcher) -> bool {
         debug!("Validator::fails_arg_required_unless: a={:?}", a.name);
-        macro_rules! check {
-            ($how:ident, $_self:expr, $a:ident, $m:ident) => {{
-                $a.r_unless
-                    .as_ref()
-                    .map_or(false, |ru| !ru.iter().$how(|n| $m.contains(n)))
-            }};
-        }
         if a.is_set(ArgSettings::RequiredUnlessAll) {
             debug!("Validator::fails_arg_required_unless:{}:All", a.name);
-            check!(all, self.p, a, matcher)
+            !a.r_unless.iter().all(|id| matcher.contains(id))
         } else {
             debug!("Validator::fails_arg_required_unless:{}:Any", a.name);
-            check!(any, self.p, a, matcher)
+            !a.r_unless.iter().any(|id| matcher.contains(id))
         }
     }
 
diff --git a/src/util/graph.rs b/src/util/graph.rs
index 169ea08f..183b2d9d 100644
--- a/src/util/graph.rs
+++ b/src/util/graph.rs
@@ -1,12 +1,15 @@
 #[derive(Debug)]
 struct Child<T> {
     id: T,
-    children: Option<Vec<usize>>,
+    children: Vec<usize>,
 }
 
 impl<T> Child<T> {
     fn new(id: T) -> Self {
-        Child { id, children: None }
+        Child {
+            id,
+            children: vec![],
+        }
     }
 }
 
@@ -39,15 +42,7 @@ where
     pub(crate) fn insert_child(&mut self, parent: usize, child: T) -> usize {
         let c_idx = self.0.len();
         self.0.push(Child::new(child));
-        let parent = &mut self.0[parent];
-        if let Some(ref mut v) = parent.children {
-            v.push(c_idx);
-        } else {
-            let mut v = Vec::with_capacity(5);
-            v.push(c_idx);
-            parent.children = Some(v);
-        }
-
+        self.0[parent].children.push(c_idx);
         c_idx
     }
 


Test patch:
diff --git a/clap_generate/tests/completions.rs b/clap_generate/tests/completions.rs
index 74046645..73e96d39 100644
--- a/clap_generate/tests/completions.rs
+++ b/clap_generate/tests/completions.rs
@@ -47,7 +47,7 @@ static BASH: &str = r#"_myapp() {
         myapp)
             opts=" -h -V  --help --version  <file> test help"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
@@ -56,14 +56,14 @@ static BASH: &str = r#"_myapp() {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         
         myapp__help)
             opts=" -h -V  --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
@@ -72,26 +72,26 @@ static BASH: &str = r#"_myapp() {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         myapp__test)
             opts=" -h -V  --case --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
                 
                 --case)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=($(compgen -f ${cur}))
                     return 0
                     ;;
                 *)
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
     esac
@@ -574,7 +574,7 @@ static BASH_SPECIAL_CMDS: &str = r#"_my_app() {
         my_app)
             opts=" -h -V  --help --version  <file> test some_cmd some-cmd-with-hypens help"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
@@ -583,14 +583,14 @@ static BASH_SPECIAL_CMDS: &str = r#"_my_app() {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         
         my_app__help)
             opts=" -h -V  --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
@@ -599,13 +599,13 @@ static BASH_SPECIAL_CMDS: &str = r#"_my_app() {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         my_app__some__cmd__with__hypens)
             opts=" -h -V  --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
@@ -614,45 +614,45 @@ static BASH_SPECIAL_CMDS: &str = r#"_my_app() {
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         my_app__some_cmd)
             opts=" -h -V  --config --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
                 
                 --config)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=($(compgen -f ${cur}))
                     return 0
                     ;;
                 *)
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
         my_app__test)
             opts=" -h -V  --case --help --version  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
                 return 0
             fi
             case "${prev}" in
                 
                 --case)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=($(compgen -f ${cur}))
                     return 0
                     ;;
                 *)
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
             return 0
             ;;
     esac
diff --git a/src/build/arg/tests.rs b/src/build/arg/tests.rs
index 29d3b51e..9d529293 100644
--- a/src/build/arg/tests.rs
+++ b/src/build/arg/tests.rs
@@ -8,7 +8,7 @@ fn short_flag_misspel() {
     assert_eq!(a.long.unwrap(), "flag");
     assert_eq!(a.about.unwrap(), "some flag");
     assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-    assert!(a.val_names.is_none());
+    assert!(a.val_names.is_empty());
     assert!(a.num_vals.is_none());
 }
 
@@ -20,6 +20,6 @@ fn short_flag_name_missing() {
     assert!(a.long.is_none());
     assert_eq!(a.about.unwrap(), "some flag");
     assert!(!a.is_set(ArgSettings::MultipleOccurrences));
-    assert!(a.val_names.is_none());
+    assert!(a.val_names.is_empty());
     assert!(a.num_vals.is_none());
 }
diff --git a/tests/app_settings.rs b/tests/app_settings.rs
index 40ad2aaf..cbc50a32 100644
--- a/tests/app_settings.rs
+++ b/tests/app_settings.rs
@@ -724,25 +724,6 @@ fn issue_1093_allow_ext_sc() {
     ));
 }
 
-#[test]
-fn allow_ext_sc_when_sc_required() {
-    let res = App::new("clap-test")
-        .version("v1.4.8")
-        .setting(AppSettings::AllowExternalSubcommands)
-        .setting(AppSettings::SubcommandRequiredElseHelp)
-        .try_get_matches_from(vec!["clap-test", "external-cmd", "foo"]);
-
-    assert!(res.is_ok());
-
-    match res.unwrap().subcommand() {
-        (name, Some(args)) => {
-            assert_eq!(name, "external-cmd");
-            assert_eq!(args.values_of_lossy(""), Some(vec!["foo".to_string()]));
-        }
-        _ => unreachable!(),
-    }
-}
-
 #[test]
 fn external_subcommand_looks_like_built_in() {
     let res = App::new("cargo")
diff --git a/tests/fixtures/app.yml b/tests/fixtures/app.yml
index 416c2424..87b2e7ac 100644
--- a/tests/fixtures/app.yml
+++ b/tests/fixtures/app.yml
@@ -107,12 +107,8 @@ args:
         long: exclusive
         about: Tests 3 exclusive
         exclusive: true
-    - case_insensitive:
-        index: 4
-        help: Test case_insensitive
-        possible_values: [test123, test321]
-        case_insensitive: true
-
+    
+    
 arg_groups:
     - test:
         args:
diff --git a/tests/macros.rs b/tests/macros.rs
index 32cad5de..526723f5 100755
--- a/tests/macros.rs
+++ b/tests/macros.rs
@@ -330,31 +330,3 @@ fn literals() {
         false
     ));
 }
-
-#[test]
-fn multiarg() {
-    let app = clap_app!(claptests =>
-        (@arg flag: --flag "value")
-        (@arg multiarg: --multiarg
-            default_value("flag-unset") default_value_if("flag", None, "flag-set")
-            "multiarg")
-        (@arg multiarg2: --multiarg2
-            default_value("flag-unset") default_value_if("flag", None, "flag-set",)
-            "multiarg2")
-    );
-
-    let matches = app
-        .clone()
-        .try_get_matches_from(vec!["bin_name"])
-        .expect("match failed");
-
-    assert_eq!(matches.value_of("multiarg"), Some("flag-unset"));
-    assert_eq!(matches.value_of("multiarg2"), Some("flag-unset"));
-
-    let matches = app
-        .try_get_matches_from(vec!["bin_name", "--flag"])
-        .expect("match failed");
-
-    assert_eq!(matches.value_of("multiarg"), Some("flag-set"));
-    assert_eq!(matches.value_of("multiarg2"), Some("flag-set"));
-}