text: #pragma once
  
  #include "datum.h"
  #include "connection.h"
  #include "protocol_defs.h"
  #include "cursor.h"
  
  namespace RethinkDB {
  
  using TT = Protocol::Term::TermType;
  
  class Term;
  class Var;
  
  // An alias for the Term constructor
  template <class T>
  Term expr(T&&);
  
  int gen_var_id();
  
  // Can be used as the last argument to some ReQL commands that expect named arguments
  using OptArgs = std::map<std::string, Term>;
  
  // Represents a ReQL Term (RethinkDB Query Language)
  // Designed to be used with r-value *this
  class Term {
  public:
      Term(const Term& other) = default;
      Term(Term&& other) = default;
      Term& operator= (const Term& other) = default;
      Term& operator= (Term&& other) = default;
  
      explicit Term(Datum&&);
      explicit Term(const Datum&);
      explicit Term(OptArgs&&);
  
      // Create a copy of the Term
      Term copy() const;
  
      Term(std::function<Term()> f) : datum(Nil()) { set_function<std::function<Term()>>(f); }
      Term(std::function<Term(Var)> f) : datum(Nil()) { set_function<std::function<Term(Var)>, 0>(f); }
      Term(std::function<Term(Var, Var)> f) : datum(Nil()) { set_function<std::function<Term(Var, Var)>, 0, 1>(f); }
      Term(std::function<Term(Var, Var, Var)> f) : datum(Nil()) { set_function<std::function<Term(Var, Var, Var)>, 0, 1, 2>(f); }
      Term(Protocol::Term::TermType type, std::vector<Term>&& args) : datum(Array()) {
          Array dargs;
          for (auto& it : args) {
              dargs.emplace_back(alpha_rename(std::move(it)));
          }
          datum = Datum(Array{ type, std::move(dargs) });
      }
  
      Term(Protocol::Term::TermType type, std::vector<Term>&& args, OptArgs&& optargs) : datum(Array()) {
          Array dargs;
          for (auto& it : args) {
              dargs.emplace_back(alpha_rename(std::move(it)));
          }
          Object oargs;
          for (auto& it : optargs) {
              oargs.emplace(it.first, alpha_rename(std::move(it.second)));
          }
          datum = Array{ type, std::move(dargs), std::move(oargs) };
      }
  
      // Used internally to support row
      static Term func_wrap(Term&&);
      static Term func_wrap(const Term&);
  
  
      // These macros are used to define most ReQL commands
      //  * Cn represents a method with n arguments
      //  * COn represents a method with n arguments and optional named arguments
      //  * C_ represents a method with any number of arguments
      // Each method is implemented twice, once with r-value *this, and once with const *this
      // The third argument, wrap, allows converting arguments into functions if they contain row
  
  #define C0(name, type) \
      Term name() &&      { return Term(TT::type, std::vector<Term>{ std::move(*this) }); } \
      Term name() const & { return Term(TT::type, std::vector<Term>{ *this            }); }
  #define C1(name, type, wrap)                                            \
      template <class T>                                                  \
      Term name(T&& a) && { return Term(TT::type, std::vector<Term>{ std::move(*this), wrap(expr(std::forward<T>(a))) }); } \
      template <class T>                                                  \
      Term name(T&& a) const & { return Term(TT::type, std::vector<Term>{ *this, wrap(expr(std::forward<T>(a))) }); }
  #define C2(name, type)                                                  \
      template <class T, class U> Term name(T&& a, U&& b) && {           \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
                      expr(std::forward<T>(a)), expr(std::forward<U>(b)) }); } \
      template <class T, class U> Term name(T&& a, U&& b) const & {      \
          return Term(TT::type, std::vector<Term>{ *this,        \
                      expr(std::forward<T>(a)), expr(std::forward<U>(b)) }); }
  #define C_(name, type, wrap)                                            \
      template <class ...T> Term name(T&& ...a) && {                     \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
                      wrap(expr(std::forward<T>(a)))... }); }             \
      template <class ...T> Term name(T&& ...a) const & {                \
          return Term(TT::type, std::vector<Term>{ *this,        \
                      wrap(expr(std::forward<T>(a)))... }); }
  #define CO0(name, type)                                                 \
      Term name(OptArgs&& optarg = {}) && {                              \
          return Term(TT::type, std::vector<Term>{ std::move(*this) }, std::move(optarg)); } \
      Term name(OptArgs&& optarg = {}) const & {                         \
          return Term(TT::type, std::vector<Term>{ *this }, std::move(optarg)); }
  #define CO1(name, type, wrap)                                                \
      template <class T> Term name(T&& a, OptArgs&& optarg = {}) && {    \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
                      wrap(expr(std::forward<T>(a))) }, std::move(optarg)); } \
      template <class T> Term name(T&& a, OptArgs&& optarg = {}) const & { \
          return Term(TT::type, std::vector<Term>{ *this,               \
                      wrap(expr(std::forward<T>(a))) }, std::move(optarg)); }
  #define CO2(name, type, wrap)                                           \
      template <class T, class U> Term name(T&& a, U&& b, OptArgs&& optarg = {}) && { \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
                      wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))) }, std::move(optarg)); } \
      template <class T, class U> Term name(T&& a, U&& b, OptArgs&& optarg = {}) const & { \
          return Term(TT::type, std::vector<Term>{ *this,        \
                      wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))) }, std::move(optarg)); }
  #define CO3(name, type, wrap)                                                \
      template <class T, class U, class V> Term name(T&& a, U&& b, V&& c, OptArgs&& optarg = {}) && { \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
                      wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))), \
                      wrap(expr(std::forward<V>(c))) }, std::move(optarg)); } \
      template <class T, class U, class V> Term name(T&& a, U&& b, V&& c, OptArgs&& optarg = {}) const & { \
          return Term(TT::type, std::vector<Term>{ *this,        \
                      wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))), \
                      wrap(expr(std::forward<V>(c)))}, std::move(optarg)); }
  #define CO4(name, type, wrap)                                                \
      template <class T, class U, class V, class W> Term name(T&& a, U&& b, V&& c, W&& d, OptArgs&& optarg = {}) && { \
          return Term(TT::type, std::vector<Term>{ std::move(*this),    \
          wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))), \
          wrap(expr(std::forward<V>(c))), wrap(expr(std::forward<W>(d))) }, std::move(optarg)); } \
      template <class T, class U, class V, class W> Term name(T&& a, U&& b, V&& c, W&& d, OptArgs&& optarg = {}) const & { \
          return Term(TT::type, std::vector<Term>{ *this,        \
          wrap(expr(std::forward<T>(a))), wrap(expr(std::forward<U>(b))), \
          wrap(expr(std::forward<V>(c))), wrap(expr(std::forward<W>(d))) }, std::move(optarg)); }
  #define CO_(name, type, wrap)                                       \
      C_(name, type, wrap)                                            \
      CO0(name, type)                                                 \
      CO1(name, type, wrap)                                           \
      CO2(name, type, wrap)                                           \
      CO3(name, type, wrap)                                           \
      CO4(name, type, wrap)
  #define no_wrap(x) x
  
      CO1(table_create, TABLE_CREATE, no_wrap)
      C1(table_drop, TABLE_DROP, no_wrap)
      C0(table_list, TABLE_LIST)
      CO1(index_create, INDEX_CREATE, no_wrap)
      CO2(index_create, INDEX_CREATE, func_wrap)
      C1(index_drop, INDEX_DROP, no_wrap)
      C0(index_list, INDEX_LIST)
      CO2(index_rename, INDEX_RENAME, no_wrap)
      C_(index_status, INDEX_STATUS, no_wrap)
      C_(index_wait, INDEX_WAIT, no_wrap)
      CO0(changes, CHANGES)
      CO1(insert, INSERT, no_wrap)
      CO1(update, UPDATE, func_wrap)
      CO1(replace, REPLACE, func_wrap)
      CO0(delete_, DELETE)
      C0(sync, SYNC)
      CO1(table, TABLE, no_wrap)
      C1(get, GET, no_wrap)
      CO_(get_all, GET_ALL, no_wrap)
      CO2(between, BETWEEN, no_wrap)
      CO1(filter, FILTER, func_wrap)
      C2(inner_join, INNER_JOIN)
      C2(outer_join, OUTER_JOIN)
      CO2(eq_join, EQ_JOIN, func_wrap)
      C0(zip, ZIP)
      C_(map, MAP, func_wrap)
      C_(with_fields, WITH_FIELDS, no_wrap)
      C1(concat_map, CONCAT_MAP, func_wrap)
      CO_(order_by, ORDER_BY, func_wrap)
      C1(skip, SKIP, no_wrap)
      C1(limit, LIMIT, no_wrap)
      CO1(slice, SLICE, no_wrap)
      CO2(slice, SLICE, no_wrap)
      C1(nth, NTH, no_wrap)
      C1(offsets_of, OFFSETS_OF, func_wrap)
      C0(is_empty, IS_EMPTY)
      CO_(union_, UNION, no_wrap)
      C1(sample, SAMPLE, no_wrap)
      CO_(group, GROUP, func_wrap)
      C0(ungroup, UNGROUP)
      C1(reduce, REDUCE, no_wrap)
      CO2(fold, FOLD, no_wrap)
      C0(count, COUNT)
      C1(count, COUNT, func_wrap)
      C0(sum, SUM)
      C1(sum, SUM, func_wrap)
      C0(avg, AVG)
      C1(avg, AVG, func_wrap)
      C1(min, MIN, func_wrap)
      CO0(min, MIN)
      C1(max, MAX, func_wrap)
      CO0(max, MAX)
      CO0(distinct, DISTINCT)
      C_(contains, CONTAINS, func_wrap)
      C_(pluck, PLUCK, no_wrap)
      C_(without, WITHOUT, no_wrap)
      C_(merge, MERGE, func_wrap)
      C1(append, APPEND, no_wrap)
      C1(prepend, PREPEND, no_wrap)
      C1(difference, DIFFERENCE, no_wrap)
      C1(set_insert, SET_INSERT, no_wrap)
      C1(set_union, SET_UNION, no_wrap)
      C1(set_intersection, SET_INTERSECTION, no_wrap)
      C1(set_difference, SET_DIFFERENCE, no_wrap)
      C1(operator[], BRACKET, no_wrap)
      C1(get_field, GET_FIELD, no_wrap)
      C_(has_fields, HAS_FIELDS, no_wrap)
      C2(insert_at, INSERT_AT)
      C2(splice_at, SPLICE_AT)
      C1(delete_at, DELETE_AT, no_wrap)
      C2(delete_at, DELETE_AT)
      C2(change_at, CHANGE_AT)
      C0(keys, KEYS)
      C1(match, MATCH, no_wrap)
      C0(split, SPLIT)
      C1(split, SPLIT, no_wrap)
      C2(split, SPLIT)
      C0(upcase, UPCASE)
      C0(downcase, DOWNCASE)
      C_(add, ADD, no_wrap)
      C1(operator+, ADD, no_wrap)
      C_(sub, SUB, no_wrap)
      C1(operator-, SUB, no_wrap)
      C_(mul, MUL, no_wrap)
      C1(operator*, MUL, no_wrap)
      C_(div, DIV, no_wrap)
      C1(operator/, DIV, no_wrap)
      C1(mod, MOD, no_wrap)
      C1(operator%, MOD, no_wrap)
      C_(and_, AND, no_wrap)
      C1(operator&&, AND, no_wrap)
      C_(or_, OR, no_wrap)
      C1(operator||, OR, no_wrap)
      C1(eq, EQ, no_wrap)
      C1(operator==, EQ, no_wrap)
      C1(ne, NE, no_wrap)
      C1(operator!=, NE, no_wrap)
      C1(gt, GT, no_wrap)
      C1(operator>, GT, no_wrap)
      C1(ge, GE, no_wrap)
      C1(operator>=, GE, no_wrap)
      C1(lt, LT, no_wrap)
      C1(operator<, LT, no_wrap)
      C1(le, LE, no_wrap)
      C1(operator<=, LE, no_wrap)
      C0(not_, NOT)
      C0(operator!, NOT)
      C1(in_timezone, IN_TIMEZONE, no_wrap)
      C0(timezone, TIMEZONE)
      CO2(during, DURING, no_wrap)
      C0(date, DATE)
      C0(time_of_day, TIME_OF_DAY)
      C0(year, YEAR)
      C0(month, MONTH)
      C0(day, DAY)
      C0(day_of_week, DAY_OF_WEEK)
      C0(day_of_year, DAY_OF_YEAR)
      C0(hours, HOURS)
      C0(minutes, MINUTES)
      C0(seconds, SECONDS)
      C0(to_iso8601, TO_ISO8601)
      C0(to_epoch_time, TO_EPOCH_TIME)
      C1(for_each, FOR_EACH, func_wrap)
      C1(default_, DEFAULT, no_wrap)
      CO1(js, JAVASCRIPT, no_wrap)
      C1(coerce_to, COERCE_TO, no_wrap)
      C0(type_of, TYPE_OF)
      C0(info, INFO)
      C0(to_json, TO_JSON_STRING)
      C0(to_json_string, TO_JSON_STRING)
      C1(distance, DISTANCE, no_wrap)
      C0(fill, FILL)
      C0(to_geojson, TO_GEOJSON)
      CO1(get_intersecting, GET_INTERSECTING, no_wrap)
      CO1(get_nearest, GET_NEAREST, no_wrap)
      C1(includes, INCLUDES, no_wrap)
      C1(intersects, INTERSECTS, no_wrap)
      C1(polygon_sub, POLYGON_SUB, no_wrap)
      C0(config, CONFIG)
      C0(rebalance, REBALANCE)
      CO0(reconfigure, RECONFIGURE)
      C0(status, STATUS)
      CO0(wait, WAIT)
      C0(floor, FLOOR)
      C0(ceil, CEIL)
      C0(round, ROUND)
      C0(values, VALUES)
  
      // The expansion of this macro fails to compile on some versions of GCC and Clang:
      // C_(operator(), FUNCALL, no_wrap)
      // The std::enable_if makes the error go away
  
      // $doc(do)
  
      template <class T, class ...U>
      typename std::enable_if<!std::is_same<T, Var>::value, Term>::type
      operator() (T&& a, U&& ...b) && {
          return Term(TT::FUNCALL, std::vector<Term>{
                  std::move(*this),
                  expr(std::forward<T>(a)),
                  expr(std::forward<U>(b))... });
      }
      template <class T, class ...U>
      typename std::enable_if<!std::is_same<T, Var>::value, Term>::type
      operator() (T&& a, U&& ...b) const & {
          return Term(TT::FUNCALL, std::vector<Term>{
                  *this,
                  expr(std::forward<T>(a)),
                  expr(std::forward<U>(b))... });
      }
  
  #undef C0
  #undef C1
  #undef C2
  #undef C_
  #undef CO0
  #undef CO1
  #undef CO2
  
      // Send the term to the server and return the results.
      // Errors returned by the server are thrown.
      Cursor run(Connection&, OptArgs&& args = {});
  
      // $doc(do)
      template <class ...T>
      Term do_(T&& ...a) && {
          auto list = { std::move(*this), Term::func_wrap(expr(std::forward<T>(a)))... };
          std::vector<Term> args;
          args.reserve(list.size() + 1);
          args.emplace_back(func_wrap(std::move(*(list.end()-1))));
          for (auto it = list.begin(); it + 1 != list.end(); ++it) {
              args.emplace_back(std::move(*it));
          }
          return Term(TT::FUNCALL, std::move(args));
      }
  
      // Adds optargs to an already built term
      Term opt(OptArgs&& optargs) && {
          return Term(std::move(*this), std::move(optargs));
      }
  
      // Used internally to implement object()
      static Term make_object(std::vector<Term>&&);
  
      // Used internally to implement array()
      static Term make_binary(Term&&);
  
      Datum get_datum() const;
  
  private:
      friend class Var;
      friend class Connection;
      friend struct Query;
  
      template <int _>
      Var mkvar(std::vector<int>& vars);
  
      template <class F, int ...N>
      void set_function(F);
  
      Datum alpha_rename(Term&&);
  
      Term(Term&& orig, OptArgs&& optargs);
  
      std::map<int, int*> free_vars;
      Datum datum;
  };
  
  // A term representing null
  Term nil();
  
  template <class T>
  Term expr(T&& a) {
      return Term(std::forward<T>(a));
  }
  
  // Represents a ReQL variable.
  // This type is passed to functions used in ReQL queries.
  class Var {
  public:
      // Convert to a term
      Term operator*() const {
          Term term(TT::VAR, std::vector<Term>{expr(*id)});
          term.free_vars = {{*id, id}};
          return term;
      }
  
      Var(int* id_) : id(id_) { }
  private:
      int* id;
  };
  
  template <int N>
  Var Term::mkvar(std::vector<int>& vars) {
      int id = gen_var_id();
      vars.push_back(id);
      return Var(&*vars.rbegin());
  }
  
  template <class F, int ...N>
  void Term::set_function(F f) {
      std::vector<int> vars;
      vars.reserve(sizeof...(N));
      std::vector<Var> args = { mkvar<N>(vars)... };
      Term body = f(args[N] ...);
  
      int* low = &*vars.begin();
      int* high = &*(vars.end() - 1);
      for (auto it = body.free_vars.begin(); it != body.free_vars.end(); ) {
          if (it->second >= low && it->second <= high) {
              if (it->first != *it->second) {
                  throw Error("Internal error: variable index mis-match");
              }
              ++it;
          } else {
              free_vars.emplace(*it);
              ++it;
          }
      }
      datum = Array{TT::FUNC, Array{Array{TT::MAKE_ARRAY, vars}, body.datum}};
  }
  
  // These macros are similar to those defined above, but for top-level ReQL operations
  
  #define C0(name) Term name();
  #define C0_IMPL(name, type) Term name() { return Term(TT::type, std::vector<Term>{}); }
  #define CO0(name) Term name(OptArgs&& optargs = {});
  #define CO0_IMPL(name, type) Term name(OptArgs&& optargs) { return Term(TT::type, std::vector<Term>{}, std::move(optargs)); }
  #define C1(name, type, wrap) template <class T> Term name(T&& a) {          \
          return Term(TT::type, std::vector<Term>{ wrap(expr(std::forward<T>(a))) }); }
  #define C2(name, type) template <class T, class U> Term name(T&& a, U&& b) { \
          return Term(TT::type, std::vector<Term>{ expr(std::forward<T>(a)), expr(std::forward<U>(b)) }); }
  #define C3(name, type) template <class A, class B, class C>    \
      Term name(A&& a, B&& b, C&& c) { return Term(TT::type, std::vector<Term>{ \
                  expr(std::forward<A>(a)), expr(std::forward<B>(b)), expr(std::forward<C>(c)) }); }
  #define C4(name, type) template <class A, class B, class C, class D>    \
      Term name(A&& a, B&& b, C&& c, D&& d) { return Term(TT::type, std::vector<Term>{ \
                  expr(std::forward<A>(a)), expr(std::forward<B>(b)),     \
                      expr(std::forward<C>(c)), expr(std::forward<D>(d))}); }
  #define C7(name, type) template <class A, class B, class C, class D, class E, class F, class G> \
      Term name(A&& a, B&& b, C&& c, D&& d, E&& e, F&& f, G&& g) { return Term(TT::type, std::vector<Term>{ \
          expr(std::forward<A>(a)), expr(std::forward<B>(b)), expr(std::forward<C>(c)), \
          expr(std::forward<D>(d)), expr(std::forward<E>(e)), expr(std::forward<F>(f)), \
              expr(std::forward<G>(g))}); }
  #define C_(name, type, wrap) template <class ...T> Term name(T&& ...a) {    \
          return Term(TT::type, std::vector<Term>{ wrap(expr(std::forward<T>(a)))... }); }
  #define CO1(name, type, wrap) template <class T> Term name(T&& a, OptArgs&& optarg = {}) {       \
          return Term(TT::type, std::vector<Term>{ wrap(expr(std::forward<T>(a)))}, std::move(optarg)); }
  #define CO2(name, type) template <class T, class U> Term name(T&& a, U&& b, OptArgs&& optarg = {}) { \
          return Term(TT::type, std::vector<Term>{ expr(std::forward<T>(a)), expr(std::forward<U>(b))}, std::move(optarg)); }
  #define func_wrap Term::func_wrap
  
  C1(db_create, DB_CREATE, no_wrap)
  C1(db_drop, DB_DROP, no_wrap)
  C0(db_list)
  CO1(table_create, TABLE_CREATE, no_wrap)
  C1(table_drop, TABLE_DROP, no_wrap)
  C0(table_list)
  C1(db, DB, no_wrap)
  CO1(table, TABLE, no_wrap)
  C_(add, ADD, no_wrap)
  C2(sub, SUB)
  C_(mul, MUL, no_wrap)
  C_(div, DIV, no_wrap)
  C2(mod, MOD)
  C_(and_, AND, no_wrap)
  C_(or_, OR, no_wrap)
  C2(eq, EQ)
  C2(ne, NE)
  C2(gt, GT)
  C2(ge, GE)
  C2(lt, LT)
  C2(le, LE)
  C1(not_, NOT, no_wrap)
  CO0(random)
  CO1(random, RANDOM, no_wrap)
  CO2(random, RANDOM)
  C0(now)
  C4(time, TIME)
  C7(time, TIME)
  C1(epoch_time, EPOCH_TIME, no_wrap)
  CO1(iso8601, ISO8601, no_wrap)
  CO1(js, JAVASCRIPT, no_wrap)
  C1(args, ARGS, no_wrap)
  C_(branch, BRANCH, no_wrap)
  C0(range)
  C1(range, RANGE, no_wrap)
  C2(range, RANGE)
  C0(error)
  C1(error, ERROR, no_wrap)
  C1(json, JSON, no_wrap)
  CO1(http, HTTP, func_wrap)
  C0(uuid)
  C1(uuid, UUID, no_wrap)
  CO2(circle, CIRCLE)
  C1(geojson, GEOJSON, no_wrap)
  C_(line, LINE, no_wrap)
  C2(point, POINT)
  C_(polygon, POLYGON, no_wrap)
  C_(array, MAKE_ARRAY, no_wrap)
  C1(desc, DESC, func_wrap)
  C1(asc, ASC, func_wrap)
  C0(literal)
  C1(literal, LITERAL, no_wrap)
  C1(type_of, TYPE_OF, no_wrap)
  C_(map, MAP, func_wrap)
  C1(floor, FLOOR, no_wrap)
  C1(ceil, CEIL, no_wrap)
  C1(round, ROUND, no_wrap)
  C_(union_, UNION, no_wrap)
  C_(group, GROUP, func_wrap)
  C1(count, COUNT, no_wrap)
  C_(count, COUNT, func_wrap)
  C1(sum, SUM, no_wrap)
  C_(sum, SUM, func_wrap)
  C1(avg, AVG, no_wrap)
  C_(avg, AVG, func_wrap)
  C1(min, MIN, no_wrap)
  C_(min, MIN, func_wrap)
  C1(max, MAX, no_wrap)
  C_(max, MAX, func_wrap)
  C1(distinct, DISTINCT, no_wrap)
  C1(contains, CONTAINS, no_wrap)
  C_(contains, CONTAINS, func_wrap)
  
  #undef C0
  #undef C1
  #undef C2
  #undef C3
  #undef C4
  #undef C7
  #undef C_
  #undef CO1
  #undef CO2
  #undef func_wrap
  
  // $doc(do)
  template <class R, class ...T>
  Term do_(R&& a, T&& ...b) {
      return expr(std::forward<R>(a)).do_(std::forward<T>(b)...);
  }
  
  // $doc(object)
  template <class ...T>
  Term object(T&& ...a) {
      return Term::make_object(std::vector<Term>{ expr(std::forward<T>(a))... });
  }
  
  // $doc(binary)
  template <class T>
  Term binary(T&& a) {
      return Term::make_binary(expr(std::forward<T>(a)));
  }
  
  // Construct an empty optarg
  OptArgs optargs();
  
  // Construct an optarg made out of pairs of arguments
  // For example: optargs("k1", v1, "k2", v2)
  template <class V, class ...T>
  OptArgs optargs(const char* key, V&& val, T&& ...rest) {
      OptArgs opts = optargs(rest...);
      opts.emplace(key, expr(std::forward<V>(val)));
      return opts;
  }
  
  extern Term row;
  extern Term maxval;
  extern Term minval;
  extern Term january;
  extern Term february;
  extern Term march;
  extern Term april;
  extern Term may;
  extern Term june;
  extern Term july;
  extern Term august;
  extern Term september;
  extern Term october;
  extern Term november;
  extern Term december;
  extern Term monday;
  extern Term tuesday;
  extern Term wednesday;
  extern Term thursday;
  extern Term friday;
  extern Term saturday;
  extern Term sunday;
  }
  