Do some re-arranging.

include/program_args/arguments.h

@@ -8,8 +8,8 @@ namespace program {
 
 template <typename Impl> class Arguments {
 protected:
-  struct Option;
   struct Argument;
+  struct Option;
   template <typename, typename> struct WithDefault;
 
 public:
@@ -40,18 +40,11 @@ private:
   std::vector<std::string> arguments;
 };
 
-template <typename Impl>
-template <typename B, typename V>
-struct Arguments<Impl>::WithDefault {
-  B impl;
-  V default_value;
-  template <typename T> operator T() const { return impl ?: T(default_value); }
-};
-
-template <typename Impl> struct Arguments<Impl>::Option {
+template <typename Impl> struct Arguments<Impl>::Argument {
   Arguments<Impl> * self;
+  size_t index;
+  bool is_optional;
   std::string name;
-  char abbrev;
   std::string description;
 
   template <typename T> auto operator=(T && value);
@@ -60,11 +53,10 @@ template <typename Impl> struct Arguments<Impl>::Option {
   explicit operator bool() const;
 };
 
-template <typename Impl> struct Arguments<Impl>::Argument {
+template <typename Impl> struct Arguments<Impl>::Option {
   Arguments<Impl> * self;
-  size_t index;
-  bool is_optional;
   std::string name;
+  char abbrev;
   std::string description;
 
   template <typename T> auto operator=(T && value);
@@ -73,6 +65,14 @@ template <typename Impl> struct Arguments<Impl>::Argument {
   explicit operator bool() const;
 };
 
+template <typename Impl>
+template <typename B, typename V>
+struct Arguments<Impl>::WithDefault {
+  B impl;
+  V default_value;
+  template <typename T> operator T() const { return impl ?: T(default_value); }
+};
+
 }
 
 #include "arguments_impl.hpp"

include/program_args/arguments_impl.hpp

@@ -8,39 +8,6 @@
 
 namespace program {
 
-template <typename Impl>
-template <typename T>
-Arguments<Impl>::Option::operator T() const {
-  return (*this) ? convert<T>(self->options.at(name)) : T();
-}
-
-template <typename Impl> Arguments<Impl>::Option::operator bool() const {
-  return primed() && self->options.count(name);
-}
-
-template <typename Impl>
-template <typename T>
-auto Arguments<Impl>::Option::operator=(T && value) {
-  return WithDefault<Option, T>{*this, std::forward<T>(value)};
-}
-
-template <typename Impl> bool Arguments<Impl>::Option::primed() const {
-  if (self->primed_) { return true; }
-  std::vector<std::string> aliases{"--" + name};
-  if (abbrev) { aliases.emplace_back(std::string{'-', abbrev}); }
-  for (auto & alias : aliases) {
-    if (!self->option_name_mapping.emplace(alias, name).second) {
-      throw ArgumentStructureError("Duplicate option string", alias);
-    }
-  }
-  self->option_descriptions.emplace(join("/", aliases), description);
-  return false;
-}
-
-}
-
-namespace program {
-
 template <typename Impl>
 template <typename T>
 Arguments<Impl>::Argument::operator T() const {
@@ -78,6 +45,39 @@ template <typename Impl> bool Arguments<Impl>::Argument::primed() const {
 
 }
 
+namespace program {
+
+template <typename Impl>
+template <typename T>
+Arguments<Impl>::Option::operator T() const {
+  return (*this) ? convert<T>(self->options.at(name)) : T();
+}
+
+template <typename Impl> Arguments<Impl>::Option::operator bool() const {
+  return primed() && self->options.count(name);
+}
+
+template <typename Impl>
+template <typename T>
+auto Arguments<Impl>::Option::operator=(T && value) {
+  return WithDefault<Option, T>{*this, std::forward<T>(value)};
+}
+
+template <typename Impl> bool Arguments<Impl>::Option::primed() const {
+  if (self->primed_) { return true; }
+  std::vector<std::string> aliases{"--" + name};
+  if (abbrev) { aliases.emplace_back(std::string{'-', abbrev}); }
+  for (auto & alias : aliases) {
+    if (!self->option_name_mapping.emplace(alias, name).second) {
+      throw ArgumentStructureError("Duplicate option string", alias);
+    }
+  }
+  self->option_descriptions.emplace(join("/", aliases), description);
+  return false;
+}
+
+}
+
 #define arg_equals(str) !strncmp(argv[i], str, sizeof(str))
 namespace program {