...
std::istringstream iss{"E F a > 3"};              // inputs must be wrapped in a stream
ctl::ast_factory factory{};                       // initialize an overridable ast factory
ctl::multi_query_builder builder{};               // initialize an overridable language builder
ctl::scanner scn{iss, std::cerr, &factory};       // initialize the scanner (print errors to cerr)
ctl::parser_args pargs{&scn, &factory, &builder}; // wrap arguments to the parser
ctl::parser p{pargs};                             // initialize the parser
if(p.parse() != 0)                                // parse the expression stream and handle error(s) if they occur
    throw std::logic_error("unable to parse query expression");
auto result = builder.build().queries;            // build and return the queries
for(int i = 0; i < result.size(); i  )            // print the resulting AST(s)
    std::cout << i << " ==> " << result[i] << "\n";
...

#include <overload>  // include yalibs/overload
#include <algorithm> // include std::visit

/* parse an expression (see above example) */
...
auto ast = builder.build().queries;

// Do an action depending on the type of the node
std::visit(ya::overload(
    [&ast](const expr::syntax_tree_t &v)        { }, // See the expr library dependency
    [&ast](const expr::operator_t &v)           { },
    [&ast](const expr::root_t &v)               { },
    [&ast](const expr::symbol_value_t &v)       { },
    [&ast](const ctl::location_t &v)            { },
    [&ast](const ctl::modal_t &v)               { },
    [&ast](const ctl::quantifier_t &v)          { }
), static_cast<ctl::unerlying_syntax_node_t>(ast.node));

for(auto& child : ast.children) {
    // Call a function on children of the tree
}
...