diff --git a/src/common_parsers.hpp b/src/common_parsers.hpp
index e7bedd3..285234f 100644
--- a/src/common_parsers.hpp
+++ b/src/common_parsers.hpp
@@ -8,26 +8,21 @@
 #pragma once
 #include <boost/spirit/home/x3.hpp>
 #include "ast_handlers.hpp"
-x3::rule<module_identifier_class, std::string> const module_identifier = "module_identifier";
-x3::rule<module_class, module_> const module = "module";
-x3::rule<node_identifier_class, std::string> const node_identifier = "node_identifier";
-x3::rule<space_separator_class, x3::unused_type> const space_separator = "a space";
-x3::rule<completing_class, x3::unused_type> const completing = "completing";
 
 // This is a pseudo-parser, that fails if we're not completing a command
-auto const completing_def =
+auto const completing = x3::rule<completing_class, x3::unused_type>{"completing"} =
     x3::eps;
 
-auto const node_identifier_def =
+auto const node_identifier = x3::rule<node_identifier_class, std::string>{"node_identifier"} =
     ((x3::alpha | x3::char_("_")) >> *(x3::alnum | x3::char_("_") | x3::char_("-") | x3::char_(".")));
 
-auto const module_def =
+auto const module_identifier = x3::rule<module_identifier_class, std::string>{"module_identifier"} =
+    ((x3::alpha | x3::char_("_")) >> *(x3::alnum | x3::char_("_") | x3::char_("-") | x3::char_(".")));
+
+auto const module = x3::rule<module_class, module_>{"module"} =
     module_identifier >> ':' >> !x3::space;
 
-auto const module_identifier_def =
-    ((x3::alpha | x3::char_("_")) >> *(x3::alnum | x3::char_("_") | x3::char_("-") | x3::char_(".")));
-
-auto const space_separator_def =
+auto const space_separator = x3::rule<space_separator_class, x3::unused_type>{"a space"} =
     x3::omit[+x3::space];
 
 template <typename CoerceTo>
@@ -45,9 +40,3 @@
 // someParser will have its attribute coerced to std::string
 // https://github.com/boostorg/spirit/issues/530#issuecomment-584836532
 template <typename CoerceTo> const as_type<CoerceTo> as{};
-
-BOOST_SPIRIT_DEFINE(node_identifier)
-BOOST_SPIRIT_DEFINE(module)
-BOOST_SPIRIT_DEFINE(module_identifier)
-BOOST_SPIRIT_DEFINE(space_separator)
-BOOST_SPIRIT_DEFINE(completing)
diff --git a/src/grammars.hpp b/src/grammars.hpp
index b1f2878..d0d2d0c 100644
--- a/src/grammars.hpp
+++ b/src/grammars.hpp
@@ -67,27 +67,6 @@
 }
 #endif
 
-x3::rule<discard_class, discard_> const discard = "discard";
-x3::rule<ls_class, ls_> const ls = "ls";
-x3::rule<cd_class, cd_> const cd = "cd";
-x3::rule<set_class, set_> const set = "set";
-x3::rule<get_class, get_> const get = "get";
-x3::rule<create_class, create_> const create = "create";
-x3::rule<delete_class, delete_> const delete_rule = "delete_rule";
-x3::rule<commit_class, commit_> const commit = "commit";
-x3::rule<describe_class, describe_> const describe = "describe";
-x3::rule<help_class, help_> const help = "help";
-x3::rule<copy_class, copy_> const copy = "copy";
-x3::rule<move_class, move_> const move = "move";
-x3::rule<dump_class, dump_> const dump = "dump";
-x3::rule<prepare_class, prepare_> const prepare = "prepare";
-x3::rule<exec_class, exec_> const exec = "exec";
-x3::rule<switch_class, switch_> const switch_rule = "switch";
-x3::rule<cancel_class, cancel_> const cancel = "cancel";
-x3::rule<quit_class, quit_> const quit = "quit";
-x3::rule<command_class, command_> const command = "command";
-
-x3::rule<createCommandSuggestions_class, x3::unused_type> const createCommandSuggestions = "createCommandSuggestions";
 
 #if __clang__
 #pragma GCC diagnostic push
@@ -104,30 +83,30 @@
     }
 } const ls_options;
 
-auto const ls_def =
+auto const ls = x3::rule<ls_class, ls_>{"ls"} =
     ls_::name >> *(space_separator >> ls_options) >> -(space_separator > (anyPath | (module >> "*")));
 
-auto const cd_def =
+auto const cd = x3::rule<cd_class, cd_>{"cd"} =
     cd_::name >> space_separator > cdPath;
 
 #if BOOST_VERSION <= 107700
-auto const create_def =
+auto const create = x3::rule<create_class, create_>{"create"} =
     create_::name >> space_separator >
     (x3::eps >> presenceContainerPath |
      x3::eps >> listInstancePath |
      x3::eps >> leafListElementPath);
 
-auto const delete_rule_def =
+auto const delete_rule = x3::rule<delete_class, delete_>{"delete_rule"} =
     delete_::name >> space_separator >
     (x3::eps >> presenceContainerPath |
      x3::eps >> listInstancePath |
      x3::eps >> leafListElementPath |
      x3::eps >> writableLeafPath);
 #else
-auto const create_def =
+auto const create = x3::rule<create_class, create_>{"create"} =
     create_::name >> space_separator > (presenceContainerPath | listInstancePath | leafListElementPath);
 
-auto const delete_rule_def =
+auto const delete_rule = x3::rule<delete_class, delete_>{"delete_rule"} =
     delete_::name >> space_separator > (presenceContainerPath | listInstancePath | leafListElementPath | writableLeafPath);
 #endif
 
@@ -143,18 +122,18 @@
     }
 } const ds_target_table;
 
-auto const get_def =
+auto const get = x3::rule<get_class, get_>{"get"} =
     get_::name
     >> -(space_separator >> "-" > staticSuggestions({"-datastore"}) > "-datastore" > space_separator > dsTargetSuggestions > ds_target_table)
     >> -(space_separator > getPath);
 
-auto const set_def =
+auto const set = x3::rule<set_class, set_>{"set"} =
     set_::name >> space_separator > writableLeafPath > space_separator > leaf_data;
 
-auto const commit_def =
+auto const commit = x3::rule<commit_class, commit_>{"commit"} =
     commit_::name >> x3::attr(commit_());
 
-auto const discard_def =
+auto const discard = x3::rule<discard_class, discard_>{"discard"} =
     discard_::name >> x3::attr(discard_());
 
 struct command_names_table : x3::symbols<decltype(help_::m_cmd)> {
@@ -166,7 +145,10 @@
     }
 } const command_names;
 
-auto const help_def =
+auto const createCommandSuggestions = x3::rule<createCommandSuggestions_class, x3::unused_type>{"createCommandSuggestions"} =
+    x3::eps;
+
+auto const help = x3::rule<help_class, help_>{"help"} =
     help_::name > createCommandSuggestions >> -command_names;
 
 struct datastore_symbol_table : x3::symbols<Datastore> {
@@ -211,10 +193,10 @@
     }
 } const copy_args;
 
-auto const copy_def =
+auto const copy = x3::rule<copy_class, copy_>{"copy"} =
     copy_::name > space_separator > copy_args;
 
-auto const describe_def =
+auto const describe = x3::rule<describe_class, describe_>{"describe"} =
     describe_::name >> space_separator > anyPath;
 
 struct move_mode_table : x3::symbols<MoveMode> {
@@ -312,7 +294,7 @@
     }
 } const move_args;
 
-auto const move_def =
+auto const move = x3::rule<move_class, move_>{"move"} =
     move_::name >> space_separator >> move_args;
 
 struct format_table : x3::symbols<DataFormat> {
@@ -340,28 +322,25 @@
     }
 } const dump_args;
 
-auto const prepare_def =
+auto const prepare = x3::rule<prepare_class, prepare_>{"prepare"} =
     prepare_::name > space_separator > as<dataPath_>[RpcActionPath<AllowInput::Yes>{}];
 
-auto const exec_def =
+auto const exec = x3::rule<exec_class, exec_>{"exec"} =
     exec_::name > -(space_separator > -as<dataPath_>[RpcActionPath<AllowInput::No>{}]);
 
-auto const switch_rule_def =
+auto const switch_rule = x3::rule<switch_class, switch_>{"switch"} =
     switch_::name > space_separator > dsTargetSuggestions > ds_target_table;
 
-auto const cancel_def =
+auto const cancel = x3::rule<cancel_class, cancel_>{"cancel"} =
     cancel_::name >> x3::attr(cancel_{});
 
-auto const dump_def =
+auto const dump = x3::rule<dump_class, dump_>{"dump"} =
     dump_::name > space_separator >> dump_args;
 
-auto const quit_def =
+auto const quit = x3::rule<quit_class, quit_>{"quit"} =
     quit_::name >> x3::attr(quit_{});
 
-auto const createCommandSuggestions_def =
-    x3::eps;
-
-auto const command_def =
+auto const command = x3::rule<command_class, command_>{"command"} =
 #if BOOST_VERSION <= 107800
     x3::eps >>
 #endif
@@ -370,24 +349,3 @@
 #if __clang__
 #pragma GCC diagnostic pop
 #endif
-
-BOOST_SPIRIT_DEFINE(set)
-BOOST_SPIRIT_DEFINE(commit)
-BOOST_SPIRIT_DEFINE(get)
-BOOST_SPIRIT_DEFINE(ls)
-BOOST_SPIRIT_DEFINE(discard)
-BOOST_SPIRIT_DEFINE(cd)
-BOOST_SPIRIT_DEFINE(create)
-BOOST_SPIRIT_DEFINE(delete_rule)
-BOOST_SPIRIT_DEFINE(describe)
-BOOST_SPIRIT_DEFINE(help)
-BOOST_SPIRIT_DEFINE(copy)
-BOOST_SPIRIT_DEFINE(move)
-BOOST_SPIRIT_DEFINE(dump)
-BOOST_SPIRIT_DEFINE(prepare)
-BOOST_SPIRIT_DEFINE(exec)
-BOOST_SPIRIT_DEFINE(switch_rule)
-BOOST_SPIRIT_DEFINE(cancel)
-BOOST_SPIRIT_DEFINE(quit)
-BOOST_SPIRIT_DEFINE(command)
-BOOST_SPIRIT_DEFINE(createCommandSuggestions)
diff --git a/src/leaf_data.hpp b/src/leaf_data.hpp
index e945fda..0e0e499 100644
--- a/src/leaf_data.hpp
+++ b/src/leaf_data.hpp
@@ -17,10 +17,6 @@
 template <typename TYPE>
 struct leaf_data_class;
 
-x3::rule<struct leaf_data_class<yang::IdentityRef>, identityRef_> const leaf_data_identityRef = "leaf_data_identityRef";
-x3::rule<struct leaf_data_class<yang::Binary>, binary_> const leaf_data_binary = "leaf_data_binary";
-x3::rule<struct leaf_data_class<yang::String>, std::string> const leaf_data_string = "leaf_data_string";
-
 using x3::char_;
 
 struct bool_symbol_table : x3::symbols<bool> {
@@ -32,14 +28,14 @@
     }
 } const bool_symbols;
 
-auto const leaf_data_string_def =
+auto const leaf_data_string = x3::rule<struct leaf_data_class<yang::String>, std::string>{"leaf_data_string"} =
     '\'' >> *(char_-'\'') >> '\'' |
     '\"' >> *(char_-'\"') >> '\"';
 
-auto const leaf_data_binary_def =
+auto const leaf_data_binary = x3::rule<struct leaf_data_class<yang::Binary>, binary_>{"leaf_data_binary"} =
     as<std::string>[+(x3::alnum | char_('+') | char_('/')) >> -char_('=') >> -char_('=')];
 
-auto const leaf_data_identityRef_def =
+auto const leaf_data_identityRef = x3::rule<struct leaf_data_class<yang::IdentityRef>, identityRef_>{"leaf_data_identityRef"} =
     -module >> node_identifier;
 
 template <typename It, typename Ctx, typename RCtx, typename Attr>
@@ -210,7 +206,3 @@
 };
 
 auto const leaf_data = LeafData();
-
-BOOST_SPIRIT_DEFINE(leaf_data_string)
-BOOST_SPIRIT_DEFINE(leaf_data_binary)
-BOOST_SPIRIT_DEFINE(leaf_data_identityRef)
diff --git a/src/path_parser.hpp b/src/path_parser.hpp
index b561d01..961db96 100644
--- a/src/path_parser.hpp
+++ b/src/path_parser.hpp
@@ -14,21 +14,6 @@
 
 namespace x3 = boost::spirit::x3;
 
-x3::rule<cdPath_class, dataPath_> const cdPath = "cdPath";
-x3::rule<getPath_class, decltype(get_::m_path)::value_type> const getPath = "getPath";
-x3::rule<presenceContainerPath_class, dataPath_> const presenceContainerPath = "presenceContainerPath";
-x3::rule<listInstancePath_class, dataPath_> const listInstancePath = "listInstancePath";
-x3::rule<leafListElementPath_class, dataPath_> const leafListElementPath = "leafListElementPath";
-x3::rule<initializePath_class, x3::unused_type> const initializePath = "initializePath";
-x3::rule<trailingSlash_class, x3::unused_type> const trailingSlash = "trailingSlash";
-x3::rule<absoluteStart_class, Scope> const absoluteStart = "absoluteStart";
-x3::rule<keyValue_class, keyValue_> const keyValue = "keyValue";
-x3::rule<key_identifier_class, std::string> const key_identifier = "key_identifier";
-x3::rule<listSuffix_class, std::vector<keyValue_>> const listSuffix = "listSuffix";
-x3::rule<createKeySuggestions_class, x3::unused_type> const createKeySuggestions = "createKeySuggestions";
-x3::rule<createValueSuggestions_class, x3::unused_type> const createValueSuggestions = "createValueSuggestions";
-x3::rule<suggestKeysEnd_class, x3::unused_type> const suggestKeysEnd = "suggestKeysEnd";
-x3::rule<class leafListValue_class, leaf_data_> const leafListValue = "leafListValue";
 auto pathEnd = x3::rule<class PathEnd>{"pathEnd"} = &space_separator | x3::eoi;
 
 enum class NodeParserMode {
@@ -65,6 +50,44 @@
     Data
 };
 
+auto const createKeySuggestions = x3::rule<createKeySuggestions_class, x3::unused_type>{"createKeySuggestions"} =
+    x3::eps;
+
+auto const key_identifier = x3::rule<key_identifier_class, std::string>{"key_identifier"} =
+    ((x3::alpha | char_("_")) >> *(x3::alnum | char_("_") | char_("-") | char_(".")));
+
+auto const createValueSuggestions = x3::rule<createValueSuggestions_class, x3::unused_type>{"createValueSuggestions"} =
+    x3::eps;
+
+auto const keyValue = x3::rule<keyValue_class, keyValue_>{"keyValue"} =
+    key_identifier > '=' > createValueSuggestions > leaf_data;
+
+auto const suggestKeysEnd = x3::rule<suggestKeysEnd_class, x3::unused_type>{"suggestKeysEnd"} =
+    x3::eps;
+
+auto const keyValueWrapper =
+    '[' > createKeySuggestions > keyValue > suggestKeysEnd > ']';
+
+// even though we don't allow no keys to be supplied, the star allows me to check which keys are missing
+auto const listSuffix = x3::rule<listSuffix_class, std::vector<keyValue_>>{"listSuffix"} =
+    *keyValueWrapper;
+
+struct SuggestLeafListEnd : x3::parser<SuggestLeafListEnd> {
+    using attribute_type = x3::unused_type;
+    template <typename It, typename Ctx, typename RCtx, typename Attr>
+    bool parse(It& begin, It, Ctx const& ctx, RCtx&, Attr&) const
+    {
+        auto& parserContext = x3::get<parser_context_tag>(ctx);
+        parserContext.m_completionIterator = begin;
+        parserContext.m_suggestions = {Completion{"]"}};
+
+        return true;
+    }
+} const suggestLeafListEnd;
+
+auto const leafListValue = x3::rule<class leafListValue_class, leaf_data_>{"leafListValue"} =
+    '[' >> leaf_data >> suggestLeafListEnd >> ']';
+
 template <NodeParserMode PARSER_MODE, CompletionMode COMPLETION_MODE>
 struct NodeParser : x3::parser<NodeParser<PARSER_MODE, COMPLETION_MODE>> {
     using attribute_type = typename ModeToAttribute<PARSER_MODE>::type;
@@ -262,6 +285,16 @@
     using type = dataPath_;
 };
 
+auto const trailingSlash = x3::rule<trailingSlash_class, x3::unused_type>{"trailingSlash"} =
+    x3::omit['/'];
+
+// A "nothing" parser, which is used to indicate we tried to parse a path
+auto const initializePath = x3::rule<initializePath_class, x3::unused_type>{"initializePath"} =
+    x3::eps;
+
+auto const absoluteStart = x3::rule<absoluteStart_class, Scope>{"absoluteStart"} =
+    x3::omit['/'] >> x3::attr(Scope::Absolute);
+
 template <PathParserMode PARSER_MODE, CompletionMode COMPLETION_MODE>
 struct PathParser : x3::parser<PathParser<PARSER_MODE, COMPLETION_MODE>> {
     using attribute_type = typename ModeToAttribute<PARSER_MODE>::type;
@@ -346,50 +379,6 @@
 #pragma GCC diagnostic ignored "-Woverloaded-shift-op-parentheses"
 #endif
 
-struct SuggestLeafListEnd : x3::parser<SuggestLeafListEnd> {
-    using attribute_type = x3::unused_type;
-    template <typename It, typename Ctx, typename RCtx, typename Attr>
-    bool parse(It& begin, It, Ctx const& ctx, RCtx&, Attr&) const
-    {
-        auto& parserContext = x3::get<parser_context_tag>(ctx);
-        parserContext.m_completionIterator = begin;
-        parserContext.m_suggestions = {Completion{"]"}};
-
-        return true;
-    }
-} const suggestLeafListEnd;
-
-auto const leafListValue_def =
-    '[' >> leaf_data >> suggestLeafListEnd >> ']';
-
-auto const key_identifier_def =
-    ((x3::alpha | char_("_")) >> *(x3::alnum | char_("_") | char_("-") | char_(".")));
-
-auto const createKeySuggestions_def =
-    x3::eps;
-
-auto const createValueSuggestions_def =
-    x3::eps;
-
-auto const suggestKeysEnd_def =
-    x3::eps;
-
-auto const keyValue_def =
-    key_identifier > '=' > createValueSuggestions > leaf_data;
-
-auto const keyValueWrapper =
-    '[' > createKeySuggestions > keyValue > suggestKeysEnd > ']';
-
-// even though we don't allow no keys to be supplied, the star allows me to check which keys are missing
-auto const listSuffix_def =
-    *keyValueWrapper;
-
-auto const absoluteStart_def =
-    x3::omit['/'] >> x3::attr(Scope::Absolute);
-
-auto const trailingSlash_def =
-    x3::omit['/'];
-
 auto const filterConfigFalse = [](const Schema& schema, const std::string& path) {
     return schema.isConfig(path);
 };
@@ -469,46 +458,26 @@
     return nodeType != yang::NodeTypes::Rpc && nodeType != yang::NodeTypes::Action;
 };
 
-auto const getPath_def =
+auto const getPath = x3::rule<getPath_class, decltype(get_::m_path)::value_type>{"getPath"} =
     PathParser<PathParserMode::DataPathListEnd, CompletionMode::Data>{noRpcOrAction} |
     (module >> "*");
 
-auto const cdPath_def =
+auto const cdPath = x3::rule<cdPath_class, dataPath_>{"cdPath"} =
     PathParser<PathParserMode::DataPath, CompletionMode::Data>{[] (const Schema& schema, const std::string& path) {
         return noRpcOrAction(schema, path) && schema.nodeType(path) != yang::NodeTypes::Leaf;
     }};
 
-auto const presenceContainerPath_def =
+auto const presenceContainerPath = x3::rule<presenceContainerPath_class, dataPath_>{"presenceContainerPath"} =
     dataPath;
 
-auto const listInstancePath_def =
+auto const listInstancePath = x3::rule<listInstancePath_class, dataPath_>{"listInstancePath"} =
     dataPath;
 
-auto const leafListElementPath_def =
+auto const leafListElementPath = x3::rule<leafListElementPath_class, dataPath_>{"leafListElementPath"} =
     dataPath;
 
-// A "nothing" parser, which is used to indicate we tried to parse a path
-auto const initializePath_def =
-    x3::eps;
-
 
 
 #if __clang__
 #pragma GCC diagnostic pop
 #endif
-
-BOOST_SPIRIT_DEFINE(keyValue)
-BOOST_SPIRIT_DEFINE(key_identifier)
-BOOST_SPIRIT_DEFINE(listSuffix)
-BOOST_SPIRIT_DEFINE(cdPath)
-BOOST_SPIRIT_DEFINE(getPath)
-BOOST_SPIRIT_DEFINE(presenceContainerPath)
-BOOST_SPIRIT_DEFINE(listInstancePath)
-BOOST_SPIRIT_DEFINE(leafListElementPath)
-BOOST_SPIRIT_DEFINE(initializePath)
-BOOST_SPIRIT_DEFINE(createKeySuggestions)
-BOOST_SPIRIT_DEFINE(createValueSuggestions)
-BOOST_SPIRIT_DEFINE(suggestKeysEnd)
-BOOST_SPIRIT_DEFINE(leafListValue)
-BOOST_SPIRIT_DEFINE(absoluteStart)
-BOOST_SPIRIT_DEFINE(trailingSlash)