From 46f45a9f8cad31d7eae1fc8d942c5d9d5f5ae20b Mon Sep 17 00:00:00 2001
From: Providence Salumu <smunix@users.noreply.github.com>
Date: Tue, 20 Apr 2021 10:20:05 -0400
Subject: [PATCH 01/40] Avoid std::vector<bool> (#400)

* wrap bool into Bool struct to avoid std::vector<bool>
---
 lib/hobbes/eval/cmodule.C | 772 +++++++++++++++++++++++---------------
 1 file changed, 462 insertions(+), 310 deletions(-)

diff --git a/lib/hobbes/eval/cmodule.C b/lib/hobbes/eval/cmodule.C
index 4d5413041..368decb38 100644
--- a/lib/hobbes/eval/cmodule.C
+++ b/lib/hobbes/eval/cmodule.C
@@ -1,45 +1,53 @@
 
+#include <deque>
+#include <dlfcn.h>
+#include <glob.h>
 #include <hobbes/eval/cc.H>
 #include <hobbes/eval/cmodule.H>
 #include <hobbes/lang/module.H>
+#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/type.H>
 #include <hobbes/lang/typeinf.H>
-#include <hobbes/lang/preds/class.H>
-#include <hobbes/util/str.H>
 #include <hobbes/util/array.H>
+#include <hobbes/util/str.H>
 #include <stdexcept>
-#include <deque>
-#include <dlfcn.h>
-#include <glob.h>
 
 namespace hobbes {
 
-bool fileExists(const std::string& fname) {
+bool fileExists(const std::string &fname) {
   // not the most elegant, but it does the job
-  FILE* f = fopen(fname.c_str(), "r");
-  if (!f) return false;
+  FILE *f = fopen(fname.c_str(), "r");
+  if (!f)
+    return false;
   fclose(f);
   return true;
 }
 
-bool importObject(cc* e, const std::string& sopath) {
+bool importObject(cc *e, const std::string &sopath) {
   if (!fileExists(sopath)) {
     return false;
   } else {
-    void* h = dlopen(sopath.c_str(), RTLD_NOW);
-    if (!h) { throw std::runtime_error(std::string("Failed to load .so file: ") + dlerror()); }
+    void *h = dlopen(sopath.c_str(), RTLD_NOW);
+    if (!h) {
+      throw std::runtime_error(std::string("Failed to load .so file: ") +
+                               dlerror());
+    }
 
-    typedef void (*InitF)(cc*);
+    typedef void (*InitF)(cc *);
     InitF initF = reinterpret_cast<InitF>(dlsym(h, "initialize"));
 
-    if (!initF) { dlclose(h); throw std::runtime_error(std::string("Failed to load .so file init: ") + dlerror()); }
+    if (!initF) {
+      dlclose(h);
+      throw std::runtime_error(std::string("Failed to load .so file init: ") +
+                               dlerror());
+    }
 
     initF(e);
     return true;
   }
 }
 
-bool importScript(cc* e, const std::string& fname) {
+bool importScript(cc *e, const std::string &fname) {
   if (!fileExists(fname)) {
     return false;
   } else {
@@ -49,26 +57,30 @@ bool importScript(cc* e, const std::string& fname) {
 }
 
 typedef std::vector<std::string> ModulePaths;
-static ModulePaths& modulePaths() {
+static ModulePaths &modulePaths() {
   static thread_local ModulePaths mps;
-  if (mps.size()==0) {
+  if (mps.size() == 0) {
     mps.push_back(".");
   }
   return mps;
 }
-void pushModuleDir(const std::string& d) { modulePaths().push_back(d); }
-void popModuleDir() { if (modulePaths().size() > 0) modulePaths().resize(modulePaths().size()-1); }
+void pushModuleDir(const std::string &d) { modulePaths().push_back(d); }
+void popModuleDir() {
+  if (modulePaths().size() > 0)
+    modulePaths().resize(modulePaths().size() - 1);
+}
 
 // import a "module" from a path spec (A.B.C => [.|$MODULEPATH]/A/B/C.*)
-void import(cc* e, const std::string& mname) {
+void import(cc *e, const std::string &mname) {
   for (size_t p = modulePaths().size(); p > 0; --p) {
-    std::string path  = modulePaths()[p-1];
-    std::string mpath = (path.empty() ? "." : path) + "/" + str::replace<char>(mname, ".", "/");
+    std::string path = modulePaths()[p - 1];
+    std::string mpath =
+        (path.empty() ? "." : path) + "/" + str::replace<char>(mname, ".", "/");
 
     if (importObject(e, mpath + ".so")) {
       return;
     } else {
-      for (const auto& p : str::paths(mpath + ".*")) {
+      for (const auto &p : str::paths(mpath + ".*")) {
         if (importScript(e, p)) {
           return;
         }
@@ -78,15 +90,16 @@ void import(cc* e, const std::string& mname) {
   throw std::runtime_error("No such module to load: " + mname);
 }
 
-// replace type variable references with expanded aliases or opaque definitions as necessary
-ExprPtr applyTypeDefns(const ModulePtr&, cc*, const ExprPtr&);
+// replace type variable references with expanded aliases or opaque definitions
+// as necessary
+ExprPtr applyTypeDefns(const ModulePtr &, cc *, const ExprPtr &);
 
 struct appTyDefnF : public switchTyFn {
   ModulePtr m;
-  cc* e;
-  appTyDefnF(const ModulePtr& m, cc* e) : m(m), e(e) { }
-  MonoTypePtr with(const TVar* v) const {
-    const auto& tn = v->name();
+  cc *e;
+  appTyDefnF(const ModulePtr &m, cc *e) : m(m), e(e) {}
+  MonoTypePtr with(const TVar *v) const {
+    const auto &tn = v->name();
 
     if (isPrimName(tn) || e->isTypeAliasName(tn)) {
       return e->replaceTypeAliases(Prim::make(tn));
@@ -97,75 +110,90 @@ struct appTyDefnF : public switchTyFn {
     }
   }
 
-  MonoTypePtr with(const TApp* ap) const {
-    return e->replaceTypeAliases(TApp::make(switchOf(ap->fn(), *this), switchOf(ap->args(), *this)));
+  MonoTypePtr with(const TApp *ap) const {
+    return e->replaceTypeAliases(
+        TApp::make(switchOf(ap->fn(), *this), switchOf(ap->args(), *this)));
   }
 
-  MonoTypePtr with(const TExpr* x) const {
-    return TExpr::make(applyTypeDefns(this->m, this->e, translateExprWithOpts(m->options(), x->expr())));
+  MonoTypePtr with(const TExpr *x) const {
+    return TExpr::make(applyTypeDefns(
+        this->m, this->e, translateExprWithOpts(m->options(), x->expr())));
   }
 };
-MonoTypePtr applyTypeDefns(const ModulePtr& m, cc* e, const MonoTypePtr& t) {
+MonoTypePtr applyTypeDefns(const ModulePtr &m, cc *e, const MonoTypePtr &t) {
   auto ua = e->unappTyDefns.find(t.get());
-  if (ua != e->unappTyDefns.end()) return ua->second;
+  if (ua != e->unappTyDefns.end())
+    return ua->second;
 
   MonoTypePtr r = switchOf(t, appTyDefnF(m, e));
   e->unappTyDefns[t.get()] = r;
   return r;
 }
 
-MonoTypes applyTypeDefns(const ModulePtr& m, cc* e, const MonoTypes& ts) {
+MonoTypes applyTypeDefns(const ModulePtr &m, cc *e, const MonoTypes &ts) {
   MonoTypes r;
-  for (const auto& t : ts) {
+  for (const auto &t : ts) {
     r.push_back(applyTypeDefns(m, e, t));
   }
   return r;
 }
 
-QualTypePtr applyTypeDefns(const ModulePtr& m, cc* e, const QualTypePtr& t) {
+QualTypePtr applyTypeDefns(const ModulePtr &m, cc *e, const QualTypePtr &t) {
   Constraints cs;
-  for (const auto& c : t->constraints()) {
-    cs.push_back(ConstraintPtr(new Constraint(c->name(), applyTypeDefns(m, e, c->arguments()))));
+  for (const auto &c : t->constraints()) {
+    cs.push_back(ConstraintPtr(
+        new Constraint(c->name(), applyTypeDefns(m, e, c->arguments()))));
   }
   return QualTypePtr(new QualType(cs, applyTypeDefns(m, e, t->monoType())));
 }
 
 struct appTyDefnEF : public switchExprTyFn {
   ModulePtr m;
-  cc* e;
-  appTyDefnEF(const ModulePtr& m, cc* e) : m(m), e(e) { }
-  QualTypePtr withTy(const QualTypePtr& t) const { if (t) return applyTypeDefns(this->m, this->e, t); else return t; }
+  cc *e;
+  appTyDefnEF(const ModulePtr &m, cc *e) : m(m), e(e) {}
+  QualTypePtr withTy(const QualTypePtr &t) const {
+    if (t)
+      return applyTypeDefns(this->m, this->e, t);
+    else
+      return t;
+  }
 };
-ExprPtr applyTypeDefns(const ModulePtr& m, cc* e, const ExprPtr& x) {
+ExprPtr applyTypeDefns(const ModulePtr &m, cc *e, const ExprPtr &x) {
   return switchOf(x, appTyDefnEF(m, e));
 }
 
 struct appTyDefnMF : public switchMDefTyFn {
   ModulePtr m;
-  cc* e;
-  appTyDefnMF(const ModulePtr& m, cc* e) : m(m), e(e) { }
-  QualTypePtr withTy(const QualTypePtr& t) const { if (t) return applyTypeDefns(this->m, this->e, t); else return t; }
+  cc *e;
+  appTyDefnMF(const ModulePtr &m, cc *e) : m(m), e(e) {}
+  QualTypePtr withTy(const QualTypePtr &t) const {
+    if (t)
+      return applyTypeDefns(this->m, this->e, t);
+    else
+      return t;
+  }
 };
-ModuleDefPtr applyTypeDefns(const ModulePtr& m, cc* e, const ModuleDefPtr& md) {
+ModuleDefPtr applyTypeDefns(const ModulePtr &m, cc *e, const ModuleDefPtr &md) {
   return switchOf(md, appTyDefnMF(m, e));
 }
 
-ModuleDefs applyTypeDefns(const ModulePtr& m, cc* e, const ModuleDefs& mds) {
+ModuleDefs applyTypeDefns(const ModulePtr &m, cc *e, const ModuleDefs &mds) {
   ModuleDefs r;
-  for (const auto& md : mds) {
+  for (const auto &md : mds) {
     r.push_back(applyTypeDefns(m, e, md));
   }
   return r;
 }
 
-ModulePtr applyTypeDefns(cc* e, const ModulePtr& m) {
-  return ModulePtr(new Module(m->name(), applyTypeDefns(m, e, m->definitions())));
+ModulePtr applyTypeDefns(cc *e, const ModulePtr &m) {
+  return ModulePtr(
+      new Module(m->name(), applyTypeDefns(m, e, m->definitions())));
 }
 
 // index type variables and sanity check names to ensure no duplicates
 typedef std::map<std::string, int> NameIndexing;
 
-NameIndexing nameIndexing(const str::seq& ns) {
+NameIndexing nameIndexing(const str::seq &ns) {
   NameIndexing r;
   for (size_t i = 0; i < ns.size(); ++i) {
     if (r.find(ns[i]) != r.end()) {
@@ -177,11 +205,11 @@ NameIndexing nameIndexing(const str::seq& ns) {
   return r;
 }
 
-NameIndexing nameIndexing(const std::set<std::string>& ns) {
+NameIndexing nameIndexing(const std::set<std::string> &ns) {
   return nameIndexing(str::seq(ns.begin(), ns.end()));
 }
 
-int nameIndex(const NameIndexing& ns, const std::string& vn) {
+int nameIndex(const NameIndexing &ns, const std::string &vn) {
   NameIndexing::const_iterator ni = ns.find(vn);
   if (ni == ns.end()) {
     throw std::runtime_error("Undefined type name, '" + vn + "'");
@@ -190,7 +218,7 @@ int nameIndex(const NameIndexing& ns, const std::string& vn) {
   }
 }
 
-std::vector<int> nameIndex(const NameIndexing& ns, const str::seq& vns) {
+std::vector<int> nameIndex(const NameIndexing &ns, const str::seq &vns) {
   std::vector<int> r;
   for (str::seq::const_iterator vn = vns.begin(); vn != vns.end(); ++vn) {
     r.push_back(nameIndex(ns, *vn));
@@ -198,7 +226,7 @@ std::vector<int> nameIndex(const NameIndexing& ns, const str::seq& vns) {
   return r;
 }
 
-MonoTypeSubst substitution(const NameIndexing& ns) {
+MonoTypeSubst substitution(const NameIndexing &ns) {
   MonoTypeSubst s;
   for (NameIndexing::const_iterator ni = ns.begin(); ni != ns.end(); ++ni) {
     s[ni->first] = MonoTypePtr(TGen::make(ni->second));
@@ -206,7 +234,7 @@ MonoTypeSubst substitution(const NameIndexing& ns) {
   return s;
 }
 
-MonoTypeSubst uvarSubstitution(const NameIndexing& ns) {
+MonoTypeSubst uvarSubstitution(const NameIndexing &ns) {
   MonoTypeSubst s;
   for (NameIndexing::const_iterator ni = ns.begin(); ni != ns.end(); ++ni) {
     s[ni->first] = freshTypeVar();
@@ -215,27 +243,32 @@ MonoTypeSubst uvarSubstitution(const NameIndexing& ns) {
 }
 
 // convert functional dependencies into index form
-void resolveNames(const NameIndexing& ns, const CFunDepDef& nfdep, FunDeps* out) {
+void resolveNames(const NameIndexing &ns, const CFunDepDef &nfdep,
+                  FunDeps *out) {
   VarIDs lhs = nameIndex(ns, nfdep.first);
-  for (str::seq::const_iterator vn = nfdep.second.begin(); vn != nfdep.second.end(); ++vn) {
+  for (str::seq::const_iterator vn = nfdep.second.begin();
+       vn != nfdep.second.end(); ++vn) {
     out->push_back(FunDep(lhs, nameIndex(ns, *vn)));
   }
 }
 
-FunDeps resolveNames(const NameIndexing& ns, const CFunDepDefs& nfdeps) {
+FunDeps resolveNames(const NameIndexing &ns, const CFunDepDefs &nfdeps) {
   FunDeps r;
-  for (CFunDepDefs::const_iterator fd = nfdeps.begin(); fd != nfdeps.end(); ++fd) {
+  for (CFunDepDefs::const_iterator fd = nfdeps.begin(); fd != nfdeps.end();
+       ++fd) {
     resolveNames(ns, *fd, &r);
   }
   return r;
 }
 
 // convert member definitions
-TClass::Members resolveMembers(const MonoTypeSubst& s, const MVarTypeDefs& mvtds) {
+TClass::Members resolveMembers(const MonoTypeSubst &s,
+                               const MVarTypeDefs &mvtds) {
   TClass::Members r;
-  for (const auto& mvtd : mvtds) {
+  for (const auto &mvtd : mvtds) {
     if (r.find(mvtd->varName()) != r.end()) {
-      throw annotated_error(*mvtd, "Duplicate class member name, '" + mvtd->varName() + "'");
+      throw annotated_error(*mvtd, "Duplicate class member name, '" +
+                                       mvtd->varName() + "'");
     } else {
       r[mvtd->varName()] = requireMonotype(substitute(s, mvtd->varType()));
     }
@@ -244,29 +277,36 @@ TClass::Members resolveMembers(const MonoTypeSubst& s, const MVarTypeDefs& mvtds
 }
 
 // make a type class
-void compile(const ModulePtr&, cc* e, const ClassDef* cd) {
+void compile(const ModulePtr &, cc *e, const ClassDef *cd) {
   try {
-    NameIndexing    tns  = nameIndexing(cd->vars());
-    MonoTypeSubst   s    = substitution(tns);
-    Constraints     reqs = substitute(s, cd->constraints());
-    FunDeps         fds  = resolveNames(tns, cd->fundeps());
+    NameIndexing tns = nameIndexing(cd->vars());
+    MonoTypeSubst s = substitution(tns);
+    Constraints reqs = substitute(s, cd->constraints());
+    FunDeps fds = resolveNames(tns, cd->fundeps());
     TClass::Members mems = resolveMembers(s, cd->members());
 
-    e->typeEnv()->bind(cd->name(), UnqualifierPtr(new TClass(reqs, cd->name(), tns.size(), mems, mergeFundeps(inferFundeps(e->typeEnv(), reqs), fds), cd->la())));
-  } catch (std::exception& ex) {
+    e->typeEnv()->bind(
+        cd->name(),
+        UnqualifierPtr(new TClass(
+            reqs, cd->name(), tns.size(), mems,
+            mergeFundeps(inferFundeps(e->typeEnv(), reqs), fds), cd->la())));
+  } catch (std::exception &ex) {
     throw annotated_error(*cd, ex.what());
   }
 }
 
 // compile class instance member definitions
-MemberMapping compileMembers(const ModulePtr& m, MonoTypeUnifier* u, const TClassPtr& c, const MonoTypes& targs, cc* e, const MVarDefs& ds, bool asfn) {
-  // Class X => Instance Y, X unify Y applied to class member types should yield instance member types
-  MonoTypes cargs = freshTypeVars(c->typeVars()); 
+MemberMapping compileMembers(const ModulePtr &m, MonoTypeUnifier *u,
+                             const TClassPtr &c, const MonoTypes &targs, cc *e,
+                             const MVarDefs &ds, bool asfn) {
+  // Class X => Instance Y, X unify Y applied to class member types should yield
+  // instance member types
+  MonoTypes cargs = freshTypeVars(c->typeVars());
   mgu(targs, cargs, u);
 
   // compile each member symbol binding
   MemberMapping ms;
-  for (const auto& d : ds) {
+  for (const auto &d : ds) {
     std::string n = d->varWithArgs()[0];
 
     if (ms.find(n) != ms.end()) {
@@ -284,12 +324,14 @@ MemberMapping compileMembers(const ModulePtr& m, MonoTypeUnifier* u, const TClas
     }
     mexp = translateExprWithOpts(m, mexp);
 
-    // determine how to store this member depending on whether we're making an instance function,
-    // or if we're generating a new function for a ground instance
+    // determine how to store this member depending on whether we're making an
+    // instance function, or if we're generating a new function for a ground
+    // instance
     if (asfn) {
       ms[n] = mexp;
     } else {
-      MonoTypePtr expectedMemberType = instantiate(u->substitute(cargs), c->memberType(n));
+      MonoTypePtr expectedMemberType =
+          instantiate(u->substitute(cargs), c->memberType(n));
 
       if (!gendef) {
         ms[n] = e->normalize(assume(mexp, expectedMemberType, mexp->la()));
@@ -304,56 +346,62 @@ MemberMapping compileMembers(const ModulePtr& m, MonoTypeUnifier* u, const TClas
 }
 
 // make a type class instance
-void compile(const ModulePtr& m, cc* e, const InstanceDef* id) {
+void compile(const ModulePtr &m, cc *e, const InstanceDef *id) {
   try {
     UnqualifierPtr tyc = e->typeEnv()->lookupUnqualifier(id->className());
-    TClassPtr      c   = std::dynamic_pointer_cast<TClass>(tyc);
-    
+    TClassPtr c = std::dynamic_pointer_cast<TClass>(tyc);
+
     if (c.get() == 0) {
-      throw std::runtime_error("Cannot define overload in '" + id->className() + "', class does not exist.");
+      throw std::runtime_error("Cannot define overload in '" + id->className() +
+                               "', class does not exist.");
     }
 
     MonoTypeUnifier u(e->typeEnv());
 
-    NameIndexing  tns   = nameIndexing(tvarNames(id->args()));
-    MonoTypes     targs = id->args();
-    bool          asfn  = id->constraints().size() > 0 || tvarNames(targs).size() > 0;
-    MemberMapping ms    = compileMembers(m, &u, c, targs, e, id->members(), asfn);
+    NameIndexing tns = nameIndexing(tvarNames(id->args()));
+    MonoTypes targs = id->args();
+    bool asfn = id->constraints().size() > 0 || tvarNames(targs).size() > 0;
+    MemberMapping ms = compileMembers(m, &u, c, targs, e, id->members(), asfn);
 
     // is this a ground instance or an instance function?
     if (!asfn) {
       Definitions ds;
       try {
-        c->insert(e->typeEnv(), TCInstancePtr(new TCInstance(id->className(), targs, ms, id->la())), &ds);
+        c->insert(
+            e->typeEnv(),
+            TCInstancePtr(new TCInstance(id->className(), targs, ms, id->la())),
+            &ds);
         e->drainUnqualifyDefs(ds);
       } catch (...) {
         e->drainUnqualifyDefs(ds);
         throw;
       }
     } else {
-      c->insert(TCInstanceFnPtr(new TCInstanceFn(id->className(), id->constraints(), targs, ms, id->la())));
+      c->insert(TCInstanceFnPtr(new TCInstanceFn(
+          id->className(), id->constraints(), targs, ms, id->la())));
     }
-  } catch (annotated_error&) {
+  } catch (annotated_error &) {
     throw;
-  } catch (std::exception& ex) {
+  } catch (std::exception &ex) {
     throw annotated_error(*id, ex.what());
   }
 }
 
 // compile import statements
-void compile(const ModulePtr&, cc* e, const MImport* mimp) {
+void compile(const ModulePtr &, cc *e, const MImport *mimp) {
   pushModuleDir(mimp->path());
   try {
     import(e, mimp->name());
     popModuleDir();
-  } catch (std::exception&) {
+  } catch (std::exception &) {
     popModuleDir();
     throw;
   }
 }
 
 // compile type definitions
-MonoTypePtr forceMonotype(cc* e, const QualTypePtr& qt, const LexicalAnnotation& la) {
+MonoTypePtr forceMonotype(cc *e, const QualTypePtr &qt,
+                          const LexicalAnnotation &la) {
   MonoTypeUnifier u(e->typeEnv());
   Definitions ds;
   while (refine(e->typeEnv(), qt->constraints(), &u, &ds)) {
@@ -372,13 +420,15 @@ MonoTypePtr forceMonotype(cc* e, const QualTypePtr& qt, const LexicalAnnotation&
   }
 }
 
-void compile(const ModulePtr&, cc* e, const MTypeDef* mtd) {
+void compile(const ModulePtr &, cc *e, const MTypeDef *mtd) {
   switch (mtd->visibility()) {
   case MTypeDef::Transparent:
-    e->defineTypeAlias(mtd->name(), mtd->arguments(), forceMonotype(e, mtd->type(), mtd->la()));
+    e->defineTypeAlias(mtd->name(), mtd->arguments(),
+                       forceMonotype(e, mtd->type(), mtd->la()));
     break;
   case MTypeDef::Opaque:
-    e->defineNamedType(mtd->name(), mtd->arguments(), forceMonotype(e, mtd->type(), mtd->la()));
+    e->defineNamedType(mtd->name(), mtd->arguments(),
+                       forceMonotype(e, mtd->type(), mtd->la()));
     break;
   default:
     break;
@@ -386,13 +436,20 @@ void compile(const ModulePtr&, cc* e, const MTypeDef* mtd) {
 }
 
 // compile regular variable definitions
-void compile(const ModulePtr& m, cc* e, const MVarDef* mvd) {
-  ExprPtr vde = translateExprWithOpts(m, (mvd->varWithArgs().size() == 1) ? mvd->varExpr() : ExprPtr(new Fn(Fn::VarNames(mvd->varWithArgs().begin() + 1, mvd->varWithArgs().end()), mvd->varExpr(), mvd->la())));
-
-  // make sure that globals with inaccessible names (evaluated for side-effects) have monomorphic type
-  // (otherwise they'll quietly fail to run)
-  if (mvd->varWithArgs().size() >= 1 && mvd->varWithArgs()[0].size() > 0 && mvd->varWithArgs()[0][0] == '.') {
-    requireMonotype(e->typeEnv(), e->unsweetenExpression(mvd->varWithArgs()[0], vde));
+void compile(const ModulePtr &m, cc *e, const MVarDef *mvd) {
+  ExprPtr vde = translateExprWithOpts(
+      m, (mvd->varWithArgs().size() == 1)
+             ? mvd->varExpr()
+             : ExprPtr(new Fn(Fn::VarNames(mvd->varWithArgs().begin() + 1,
+                                           mvd->varWithArgs().end()),
+                              mvd->varExpr(), mvd->la())));
+
+  // make sure that globals with inaccessible names (evaluated for side-effects)
+  // have monomorphic type (otherwise they'll quietly fail to run)
+  if (mvd->varWithArgs().size() >= 1 && mvd->varWithArgs()[0].size() > 0 &&
+      mvd->varWithArgs()[0][0] == '.') {
+    requireMonotype(e->typeEnv(),
+                    e->unsweetenExpression(mvd->varWithArgs()[0], vde));
   }
 
   // ok we're fine, define this variable
@@ -400,10 +457,10 @@ void compile(const ModulePtr& m, cc* e, const MVarDef* mvd) {
 }
 
 // compile forward-declarations
-void compile(const ModulePtr&, cc* e, const MVarTypeDef* vtd) {
+void compile(const ModulePtr &, cc *e, const MVarTypeDef *vtd) {
   try {
     e->forwardDeclare(vtd->varName(), vtd->varType());
-  } catch (std::exception& ex) {
+  } catch (std::exception &ex) {
     throw annotated_error(*vtd, ex.what());
   }
 }
@@ -413,23 +470,25 @@ struct SafeExpr {
   using Status = SafeSet::Status;
   struct UnsafeDefs {
     UnsafeDefs() = default;
-    UnsafeDefs(std::string const& var, std::string const& fn_) : var(var), fn(fn_), status(Status::UnSafe) {}
-
-    const std::string& varName() const { return var; }
-    const std::string& safeFn() const { return fn; }
-    const std::set<std::string>& unSafeRefs() const { return closure; } 
-    const Status& varStatus() const { return status; }
-    const LexicalAnnotation& la() const { return lexAnno; }
-    const std::string& exprDef() const { return typeDesc; }
-
-    std::string& varName() { return var; }
-    std::set<std::string>& unSafeRefs() { return closure; }
-    Status& varStatus() { return status; }
-    LexicalAnnotation& la() { return lexAnno; }
-    std::string& exprDef() { return typeDesc; }
-
-    friend std::ostream& operator<<(std::ostream& os, const UnsafeDefs& s) {
-      os << s.var << "  " << s.status << "  " << str::show(s.closure) << ". " << s.typeDesc;
+    UnsafeDefs(std::string const &var, std::string const &fn_)
+        : var(var), fn(fn_), status(Status::UnSafe) {}
+
+    const std::string &varName() const { return var; }
+    const std::string &safeFn() const { return fn; }
+    const std::set<std::string> &unSafeRefs() const { return closure; }
+    const Status &varStatus() const { return status; }
+    const LexicalAnnotation &la() const { return lexAnno; }
+    const std::string &exprDef() const { return typeDesc; }
+
+    std::string &varName() { return var; }
+    std::set<std::string> &unSafeRefs() { return closure; }
+    Status &varStatus() { return status; }
+    LexicalAnnotation &la() { return lexAnno; }
+    std::string &exprDef() { return typeDesc; }
+
+    friend std::ostream &operator<<(std::ostream &os, const UnsafeDefs &s) {
+      os << s.var << "  " << s.status << "  " << str::show(s.closure) << ". "
+         << s.typeDesc;
       return os;
     }
 
@@ -442,7 +501,7 @@ struct SafeExpr {
   private:
     std::string var;
     std::string fn;
-    Status status { Status::Undefined };
+    Status status{Status::Undefined};
     std::set<std::string> closure;
     LexicalAnnotation lexAnno;
     std::string typeDesc;
@@ -450,22 +509,26 @@ struct SafeExpr {
 
   using Map = std::map<std::string, UnsafeDefs>;
 
-  static auto with(std::function<void (Map&)> const& mapModifier) -> void {
+  static auto with(std::function<void(Map &)> const &mapModifier) -> void {
     instance()._with(mapModifier);
   };
 
-  template<class R>
-  static auto with(std::string const& n, std::function<R(const SafeExpr::UnsafeDefs&)> const& hit, std::function<R(void)> const& miss) -> R {
+  template <class R>
+  static auto with(std::string const &n,
+                   std::function<R(const SafeExpr::UnsafeDefs &)> const &hit,
+                   std::function<R(void)> const &miss) -> R {
     return instance().template _with(n, hit, miss);
   }
 
 private:
-  auto _with(std::function<void (Map&)> const& mapModifier) -> void {
+  auto _with(std::function<void(Map &)> const &mapModifier) -> void {
     mapModifier(map);
   }
 
-  template<class R>
-  auto _with(std::string const& n, std::function<R(const SafeExpr::UnsafeDefs&)> const& hit, std::function<R(void)> const& miss) -> R {
+  template <class R>
+  auto _with(std::string const &n,
+             std::function<R(const SafeExpr::UnsafeDefs &)> const &hit,
+             std::function<R(void)> const &miss) -> R {
     auto it = map.find(n);
     if (it != std::end(map) && it->second.varStatus() != SafeExpr::Status::Safe)
       return hit(it->second);
@@ -473,13 +536,12 @@ private:
       return miss();
   }
 
-  static auto instance() -> SafeExpr& {
-    thread_local SafeExpr ms {Map{{"element"    , {"element", "elementM"}},
-                                  {"newArray"   , {"newArray", {}}},
-                                  {"newPrim"    , {"newPrim", {}}},
-                                  {"newPrimZ"   , {"newPrimZ", {}}},
-                                  {"unsafeCast" , {"unsafeCast", {}}
-                                }}};
+  static auto instance() -> SafeExpr & {
+    thread_local SafeExpr ms{Map{{"element", {"element", "elementM"}},
+                                 {"newArray", {"newArray", {}}},
+                                 {"newPrim", {"newPrim", {}}},
+                                 {"newPrimZ", {"newPrimZ", {}}},
+                                 {"unsafeCast", {"unsafeCast", {}}}}};
     return ms;
   }
 
@@ -489,137 +551,191 @@ private:
 };
 
 struct UnsafeRefs : public SafeExpr::UnsafeDefs {
-  friend auto operator< (SafeExpr::UnsafeDefs const& l, SafeExpr::UnsafeDefs const& r) -> bool {
+  friend auto operator<(SafeExpr::UnsafeDefs const &l,
+                        SafeExpr::UnsafeDefs const &r) -> bool {
     return l.varName() < r.varName();
   }
 
-  auto stepFn(std::pair<std::deque<std::string>, std::set<std::string>&>& v) -> void {
+  auto stepFn(std::pair<std::deque<std::string>, std::set<std::string> &> &v)
+      -> void {
     if (v.first.empty())
       return;
     auto e = v.first.front();
-    SafeExpr::template with<void>(e, [&](const SafeExpr::UnsafeDefs& unsafeDef) {
-      for (auto &f: unsafeDef.unSafeRefs()) {
-        if (v.second.find(f) == v.second.end()) {
-          v.first.push_back(f);
-        }
-      }
-    }, []() {});
+    SafeExpr::template with<void>(
+        e,
+        [&](const SafeExpr::UnsafeDefs &unsafeDef) {
+          for (auto &f : unsafeDef.unSafeRefs()) {
+            if (v.second.find(f) == v.second.end()) {
+              v.first.push_back(f);
+            }
+          }
+        },
+        []() {});
 
     v.first.pop_front();
     v.second.insert(e);
   }
 
   void stepAll() {
-    auto& var = varName();
-    std::pair<std::deque<std::string>, std::set<std::string>&> r = { { var }, unSafeRefs() };
+    auto &var = varName();
+    std::pair<std::deque<std::string>, std::set<std::string> &> r = {
+        {var}, unSafeRefs()};
     while (not r.first.empty())
       stepFn(r);
     unSafeRefs().erase(var);
-    SafeExpr::template with<void>(var, [&](const SafeExpr::UnsafeDefs& unsafeDef) {
-      la() = unsafeDef.la();
-      exprDef() = unsafeDef.exprDef();
-    }, []() {});
+    SafeExpr::template with<void>(
+        var,
+        [&](const SafeExpr::UnsafeDefs &unsafeDef) {
+          la() = unsafeDef.la();
+          exprDef() = unsafeDef.exprDef();
+        },
+        []() {});
   }
 
-  auto show(std::ostream& os) -> void {
-    os << la().filename() << ", " << la().lineDesc() << ": " << varName() << " is not allowed";
-    if (unSafeRefs().size()>0)
-      os << ", its transitive closure has disabled expressions: " << str::show(unSafeRefs()) ;
+  auto show(std::ostream &os) -> void {
+    os << la().filename() << ", " << la().lineDesc() << ": " << varName()
+       << " is not allowed";
+    if (unSafeRefs().size() > 0)
+      os << ", its transitive closure has disabled expressions: "
+         << str::show(unSafeRefs());
     os << "." << exprDef() << std::endl;
   }
 };
 
-void SafeSet::setUnsafeFn(std::string const& varName) {
-  SafeExpr::with([varName](SafeExpr::Map& m) {
-    auto& v = m[varName];
+void SafeSet::setUnsafeFn(std::string const &varName) {
+  SafeExpr::with([varName](SafeExpr::Map &m) {
+    auto &v = m[varName];
     v.varName() = varName;
     v.varStatus() = SafeExpr::Status::UnSafe;
   });
 }
 
-void SafeSet::setSafeFn(std::string const& varName) {
-  SafeExpr::with([varName](SafeExpr::Map& m) {
-    auto& v = m[varName];
+void SafeSet::setSafeFn(std::string const &varName) {
+  SafeExpr::with([varName](SafeExpr::Map &m) {
+    auto &v = m[varName];
     v.varName() = varName;
     v.varStatus() = SafeExpr::Status::Safe;
   });
 }
 
-void SafeSet::forEach(std::function<void (std::string const& /*var*/, Status const& /*status*/, std::string const& /*desc*/)> const& fn) {
-  SafeExpr::with([&](SafeExpr::Map& m) {
-    for (auto& d : m) {
+void SafeSet::forEach(
+    std::function<void(std::string const & /*var*/, Status const & /*status*/,
+                       std::string const & /*desc*/)> const &fn) {
+  SafeExpr::with([&](SafeExpr::Map &m) {
+    for (auto &d : m) {
       fn(d.second.varName(), d.second.varStatus(), d.second.desc());
     }
   });
 }
-std::string const& SafeSet::get(std::string const& binding) {
-  return SafeExpr::with<std::string const&>(binding,
-                                            [&binding](SafeExpr::UnsafeDefs const& udefs) -> std::string const& {
-                                              return udefs.safeFn().empty() ? binding : udefs.safeFn();
-                                            },
-                                            [&binding]() -> std::string const& {
-                                              return binding;
-                                            });
+std::string const &SafeSet::get(std::string const &binding) {
+  return SafeExpr::with<std::string const &>(
+      binding,
+      [&binding](SafeExpr::UnsafeDefs const &udefs) -> std::string const & {
+        return udefs.safeFn().empty() ? binding : udefs.safeFn();
+      },
+      [&binding]() -> std::string const & { return binding; });
 }
+namespace details {
+struct Bool {
+  static auto mkF() -> Bool { return Bool(0); }
+  static auto mkT() -> Bool { return Bool(1); }
+  Bool(Bool const &) = default;
+  Bool(bool v) : i(v ? 1 : 0) {}
+  auto operator=(Bool const &) -> Bool & = default;
+  auto operator=(bool v) -> Bool & { return (*this = Bool(v)); }
+  operator bool() const { return (i == 0 ? false : true); }
+
+private:
+  Bool(int i) : i(i) {}
+  int i = 0;
+};
+} // namespace details
 
-struct buildTransitiveUnsafePragmaClosure : public switchExprC<bool> {
-  buildTransitiveUnsafePragmaClosure(MVarDef const& mvd) : mvd(mvd) { }
+struct buildTransitiveUnsafePragmaClosure : public switchExprC<details::Bool> {
+  buildTransitiveUnsafePragmaClosure(MVarDef const &mvd) : mvd(mvd) {}
 
   ~buildTransitiveUnsafePragmaClosure() {
-    SafeExpr::with([&](SafeExpr::Map& m) {
+    SafeExpr::with([&](SafeExpr::Map &m) {
       auto iter = m.find(mvd.varWithArgs()[0]);
       if (iter != m.end()) {
-        auto& var = iter->second;
+        auto &var = iter->second;
         std::stringstream ss;
         mvd.show(ss);
         var.exprDef() = ss.str();
       }
-    });  
-  }
-  MVarDef const& mvd;
-
-  virtual bool withConst(const Expr*) const { return true; };
-  virtual bool with(const Var* v) const {
-    return SafeExpr::with<bool>(v->value(), [&](const SafeExpr::UnsafeDefs&) {
-        SafeExpr::with([&](SafeExpr::Map& m) {
-          auto varName=mvd.varWithArgs()[0];
-          auto r = m.insert({varName, {}});
-          auto& var = r.first->second;
-          if (r.second) {
-            var.varName() = varName;
-            var.la() = mvd.la();
-          }
-          auto &status = var.varStatus();
-          if (status != SafeExpr::Status::Safe) {
-            status = SafeExpr::Status::UnSafe;
-            var.unSafeRefs().insert(v->value());
-          }
     });
-        return true; 
-      }, 
-      []() { return false; });
   }
-  virtual bool with     (const Let* v)       const { switchOf(v->varExpr(), *this); switchOf(v->bodyExpr(), *this); return true; }
-  virtual bool with     (const LetRec* v)    const {
+  MVarDef const &mvd;
+
+  virtual details::Bool withConst(const Expr *) const { return true; };
+  virtual details::Bool with(const Var *v) const {
+    return SafeExpr::with<bool>(
+        v->value(),
+        [&](const SafeExpr::UnsafeDefs &) {
+          SafeExpr::with([&](SafeExpr::Map &m) {
+            auto varName = mvd.varWithArgs()[0];
+            auto r = m.insert({varName, {}});
+            auto &var = r.first->second;
+            if (r.second) {
+              var.varName() = varName;
+              var.la() = mvd.la();
+            }
+            auto &status = var.varStatus();
+            if (status != SafeExpr::Status::Safe) {
+              status = SafeExpr::Status::UnSafe;
+              var.unSafeRefs().insert(v->value());
+            }
+          });
+          return true;
+        },
+        []() { return false; });
+  }
+  virtual details::Bool with(const Let *v) const {
+    switchOf(v->varExpr(), *this);
+    switchOf(v->bodyExpr(), *this);
+    return true;
+  }
+  virtual details::Bool with(const LetRec *v) const {
     str::set vns = toSet(v->varNames());
     LetRec::Bindings bs;
-    for (const auto& b : v->bindings()) {
+    for (const auto &b : v->bindings()) {
       switchOf(b.second, *this);
     }
     switchOf(v->bodyExpr(), *this);
     return true;
   }
-  virtual bool with     (const Fn* v)        const { switchOf(v->body(), *this); return true; }
-  virtual bool with     (const App* v)       const { switchOf(v->fn(), *this); switchOf(v->args(), *this); return true; }
-  virtual bool with     (const Assign* v)    const { switchOf(v->left(), *this); switchOf(v->right(), *this); return true; }
-  virtual bool with     (const MkArray* v)   const { switchOf(v->values(), *this); return true; }
-  virtual bool with     (const MkVariant* v) const { switchOf(v->value(), *this); return true; }
-  virtual bool with     (const MkRecord* v)  const { switchOf(v->fields(), *this); return true; }
-  virtual bool with     (const AIndex*) const { return true; }
-  virtual bool with     (const Case* v) const {
-    const Case::Bindings& cbs = v->bindings();
+  virtual details::Bool with(const Fn *v) const {
+    switchOf(v->body(), *this);
+    return true;
+  }
+  virtual details::Bool with(const App *v) const {
+    switchOf(v->fn(), *this);
+    switchOf(v->args(), *this);
+    return true;
+  }
+  virtual details::Bool with(const Assign *v) const {
+    switchOf(v->left(), *this);
+    switchOf(v->right(), *this);
+    return true;
+  }
+  virtual details::Bool with(const MkArray *v) const {
+    switchOf(v->values(), *this);
+    return true;
+  }
+  virtual details::Bool with(const MkVariant *v) const {
+    switchOf(v->value(), *this);
+    return true;
+  }
+  virtual details::Bool with(const MkRecord *v) const {
+    switchOf(v->fields(), *this);
+    return true;
+  }
+  virtual details::Bool with(const AIndex *) const { return true; }
+  virtual details::Bool with(const Case *v) const {
+    const Case::Bindings &cbs = v->bindings();
     Case::Bindings rcbs;
-    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end(); ++cb) {
+    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end();
+         ++cb) {
       switchOf(cb->exp, *this);
     }
     ExprPtr de = v->defaultExpr();
@@ -629,7 +745,7 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<bool> {
     switchOf(v->variant(), *this);
     return true;
   }
-  virtual bool with     (const Switch* v)    const {
+  virtual details::Bool with(const Switch *v) const {
     Switch::Bindings rsbs;
     for (auto sb : v->bindings()) {
       switchOf(sb.exp, *this);
@@ -641,50 +757,64 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<bool> {
     switchOf(v->expr(), *this);
     return true;
   }
-  virtual bool with     (const Proj* v)      const { switchOf(v->record(), *this); return true; }
-  virtual bool with     (const Assump* v)    const { switchOf(v->expr(), *this); return true; }
-  virtual bool with     (const Pack* v)      const { switchOf(v->expr(), *this); return true; }
-  virtual bool with     (const Unpack* v)    const { switchOf(v->package(), *this); switchOf(v->expr(), *this); return true; }
+  virtual details::Bool with(const Proj *v) const {
+    switchOf(v->record(), *this);
+    return true;
+  }
+  virtual details::Bool with(const Assump *v) const {
+    switchOf(v->expr(), *this);
+    return true;
+  }
+  virtual details::Bool with(const Pack *v) const {
+    switchOf(v->expr(), *this);
+    return true;
+  }
+  virtual details::Bool with(const Unpack *v) const {
+    switchOf(v->package(), *this);
+    switchOf(v->expr(), *this);
+    return true;
+  }
 };
 
 // compile pragma defines
-void compile(const ModulePtr&, cc*, const MUnsafePragmaDef* mpd) {
+void compile(const ModulePtr &, cc *, const MUnsafePragmaDef *mpd) {
   SafeSet::setUnsafeFn(mpd->symbolValue());
-  SafeExpr::with([&](SafeExpr::Map& m){
-    auto& v = m[mpd->symbolValue()];
+  SafeExpr::with([&](SafeExpr::Map &m) {
+    auto &v = m[mpd->symbolValue()];
     v.la() = mpd->la();
   });
 }
 
-void compile(const ModulePtr&, cc*, const MSafePragmaDef* mpd) {
+void compile(const ModulePtr &, cc *, const MSafePragmaDef *mpd) {
   SafeSet::setSafeFn(mpd->symbolValue());
-  SafeExpr::with([&](SafeExpr::Map& m){
-    auto& v = m[mpd->symbolValue()];
+  SafeExpr::with([&](SafeExpr::Map &m) {
+    auto &v = m[mpd->symbolValue()];
     v.la() = mpd->la();
   });
 }
 
-// for now, just treat each definition independently and stick it in the input environment
+// for now, just treat each definition independently and stick it in the input
+// environment
 //   (this disallows things like mutual recursion)
-void compile(cc* e, const ModulePtr& m) {
+void compile(cc *e, const ModulePtr &m) {
   for (auto tmd : m->definitions()) {
     auto md = applyTypeDefns(m, e, tmd);
 
-    if (const MImport* imp = is<MImport>(md)) {
+    if (const MImport *imp = is<MImport>(md)) {
       compile(m, e, imp);
-    } else if (const ClassDef* cd = is<ClassDef>(md)) {
+    } else if (const ClassDef *cd = is<ClassDef>(md)) {
       compile(m, e, cd);
-    } else if (const InstanceDef* id = is<InstanceDef>(md)) {
+    } else if (const InstanceDef *id = is<InstanceDef>(md)) {
       compile(m, e, id);
-    } else if (const MTypeDef* td = is<MTypeDef>(md)) {
+    } else if (const MTypeDef *td = is<MTypeDef>(md)) {
       compile(m, e, td);
-    } else if (const MVarDef* vd = is<MVarDef>(md)) {
+    } else if (const MVarDef *vd = is<MVarDef>(md)) {
       compile(m, e, vd);
-    } else if (const MVarTypeDef* vtd = is<MVarTypeDef>(md)) {
+    } else if (const MVarTypeDef *vtd = is<MVarTypeDef>(md)) {
       compile(m, e, vtd);
-    } else if (const MUnsafePragmaDef* vpd = is<MUnsafePragmaDef>(md)) {
+    } else if (const MUnsafePragmaDef *vpd = is<MUnsafePragmaDef>(md)) {
       (void)vpd;
-    } else if (const MSafePragmaDef* vpd = is<MSafePragmaDef>(md)) {
+    } else if (const MSafePragmaDef *vpd = is<MSafePragmaDef>(md)) {
       (void)vpd;
     } else {
       throw std::runtime_error("Cannot compile module definition: " + show(md));
@@ -693,110 +823,121 @@ void compile(cc* e, const ModulePtr& m) {
 
   // compile unsafe pragma
   for (auto tmd : m->definitions()) {
-    if (const MUnsafePragmaDef* vpd = is<MUnsafePragmaDef>(tmd)) {
-      compile(m, e, vpd); 
+    if (const MUnsafePragmaDef *vpd = is<MUnsafePragmaDef>(tmd)) {
+      compile(m, e, vpd);
     }
   }
 
   // compile safe pragma
   for (auto tmd : m->definitions()) {
-    if (const MSafePragmaDef* vpd = is<MSafePragmaDef>(tmd)) {
-      compile(m, e, vpd); 
+    if (const MSafePragmaDef *vpd = is<MSafePragmaDef>(tmd)) {
+      compile(m, e, vpd);
     }
   }
 
   // generate unsafe transitive closure
   for (auto tmd : m->definitions()) {
-    if (const MVarDef* vd = is<MVarDef>(tmd)) {
+    if (const MVarDef *vd = is<MVarDef>(tmd)) {
       switchOf(vd->varExpr(), buildTransitiveUnsafePragmaClosure(*vd));
     }
   }
 }
 
-std::vector<std::string> getDefaultOptions() {
-  return str::strings();
-}
+std::vector<std::string> getDefaultOptions() { return str::strings(); }
 
 // make hobbes run in "safe" mode
 struct makeSafe : public switchExprC<ExprPtr> {
   std::map<std::string, UnsafeRefs> collectUnsafes;
 
-  makeSafe() { }
+  makeSafe() {}
 
   auto show() -> std::string {
     std::stringstream ss;
-    for (auto& kv : collectUnsafes) {
+    for (auto &kv : collectUnsafes) {
       kv.second.show(ss);
     }
     return ss.str();
   }
 
-  ExprPtr withConst(const Expr* v) const { return ExprPtr(v->clone()); }
-
-  ExprPtr with(const Var* v) const {
-    return SafeExpr::template with<ExprPtr>(v->value(), [&, this](const SafeExpr::UnsafeDefs& unsafeDef) {
-      ExprPtr vc(v->clone());
-      if (auto vcc = is<Var>(vc.get())) {
-        if (not unsafeDef.safeFn().empty()) {
-          const_cast<Var *>(vcc)->value(unsafeDef.safeFn());
-        } else {
-          auto& entry = const_cast<makeSafe*>(this)->collectUnsafes[v->value()];
-          if (not v->value().empty()) {
-            entry.varName() = v->value();
-            entry.stepAll();
+  ExprPtr withConst(const Expr *v) const { return ExprPtr(v->clone()); }
+
+  ExprPtr with(const Var *v) const {
+    return SafeExpr::template with<ExprPtr>(
+        v->value(),
+        [&, this](const SafeExpr::UnsafeDefs &unsafeDef) {
+          ExprPtr vc(v->clone());
+          if (auto vcc = is<Var>(vc.get())) {
+            if (not unsafeDef.safeFn().empty()) {
+              const_cast<Var *>(vcc)->value(unsafeDef.safeFn());
+            } else {
+              auto &entry =
+                  const_cast<makeSafe *>(this)->collectUnsafes[v->value()];
+              if (not v->value().empty()) {
+                entry.varName() = v->value();
+                entry.stepAll();
+              }
+            }
           }
-         }
-      }
-      return vc;
-    }, [&]() { return ExprPtr(v->clone()); });
+          return vc;
+        },
+        [&]() { return ExprPtr(v->clone()); });
   }
 
-  ExprPtr with(const Let* v) const {
-    return ExprPtr(new Let(v->var(), switchOf(v->varExpr(), *this), switchOf(v->bodyExpr(), *this), v->la()));
+  ExprPtr with(const Let *v) const {
+    return ExprPtr(new Let(v->var(), switchOf(v->varExpr(), *this),
+                           switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const LetRec* v) const {
+  ExprPtr with(const LetRec *v) const {
     str::set vns = toSet(v->varNames());
     LetRec::Bindings bs;
-    for (const auto& b : v->bindings()) {
+    for (const auto &b : v->bindings()) {
       bs.push_back(LetRec::Binding(b.first, switchOf(b.second, *this)));
     }
     return ExprPtr(new LetRec(bs, switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn *v) const {
     return ExprPtr(new Fn(v->varNames(), switchOf(v->body(), *this), v->la()));
   }
 
-  ExprPtr with(const App* v) const {
-    return ExprPtr(new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
+  ExprPtr with(const App *v) const {
+    return ExprPtr(
+        new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
   }
 
-  ExprPtr with(const Assign* v) const {
-    return ExprPtr(new Assign(switchOf(v->left(), *this), switchOf(v->right(), *this), v->la()));
+  ExprPtr with(const Assign *v) const {
+    return ExprPtr(new Assign(switchOf(v->left(), *this),
+                              switchOf(v->right(), *this), v->la()));
   }
 
-  ExprPtr with(const MkArray* v) const {
+  ExprPtr with(const MkArray *v) const {
     return ExprPtr(new MkArray(switchOf(v->values(), *this), v->la()));
   }
 
-  ExprPtr with(const MkVariant* v) const {
-    return ExprPtr(new MkVariant(v->label(), switchOf(v->value(), *this), v->la()));
+  ExprPtr with(const MkVariant *v) const {
+    return ExprPtr(
+        new MkVariant(v->label(), switchOf(v->value(), *this), v->la()));
   }
-  
-  ExprPtr with(const MkRecord* v) const {
+
+  ExprPtr with(const MkRecord *v) const {
     return ExprPtr(new MkRecord(switchOf(v->fields(), *this), v->la()));
   }
 
-  ExprPtr with(const AIndex* v) const {
-    return fncall(var("atm", v->la()), list(switchOf(v->array(), *this), switchOf(v->index(), *this)), v->la());
+  ExprPtr with(const AIndex *v) const {
+    return fncall(
+        var("atm", v->la()),
+        list(switchOf(v->array(), *this), switchOf(v->index(), *this)),
+        v->la());
   }
 
-  ExprPtr with(const Case* v) const {
-    const Case::Bindings& cbs = v->bindings();
+  ExprPtr with(const Case *v) const {
+    const Case::Bindings &cbs = v->bindings();
     Case::Bindings rcbs;
-    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end(); ++cb) {
-      rcbs.push_back(Case::Binding(cb->selector, cb->vname, switchOf(cb->exp, *this)));
+    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end();
+         ++cb) {
+      rcbs.push_back(
+          Case::Binding(cb->selector, cb->vname, switchOf(cb->exp, *this)));
     }
     ExprPtr de = v->defaultExpr();
     if (de.get()) {
@@ -805,7 +946,7 @@ struct makeSafe : public switchExprC<ExprPtr> {
     return ExprPtr(new Case(switchOf(v->variant(), *this), rcbs, de, v->la()));
   }
 
-  ExprPtr with(const Switch* v) const {
+  ExprPtr with(const Switch *v) const {
     Switch::Bindings rsbs;
     for (auto sb : v->bindings()) {
       rsbs.push_back(Switch::Binding(sb.value, switchOf(sb.exp, *this)));
@@ -817,20 +958,21 @@ struct makeSafe : public switchExprC<ExprPtr> {
     return ExprPtr(new Switch(switchOf(v->expr(), *this), rsbs, de, v->la()));
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj *v) const {
     return ExprPtr(new Proj(switchOf(v->record(), *this), v->field(), v->la()));
   }
 
-  ExprPtr with(const Assump* v) const {
+  ExprPtr with(const Assump *v) const {
     return ExprPtr(new Assump(switchOf(v->expr(), *this), v->ty(), v->la()));
   }
 
-  ExprPtr with(const Pack* v) const {
+  ExprPtr with(const Pack *v) const {
     return ExprPtr(new Pack(switchOf(v->expr(), *this), v->la()));
   }
 
-  ExprPtr with(const Unpack* v) const {
-    return ExprPtr(new Unpack(v->varName(), switchOf(v->package(), *this), switchOf(v->expr(), *this), v->la()));
+  ExprPtr with(const Unpack *v) const {
+    return ExprPtr(new Unpack(v->varName(), switchOf(v->package(), *this),
+                              switchOf(v->expr(), *this), v->la()));
   }
 };
 
@@ -839,7 +981,8 @@ struct makeSafeArrays : public makeSafe {
     using Map = SafeExpr::Map;
 
     static auto with(const Var *v) -> ExprPtr {
-      thread_local Map safeArrayTable{ Map{ { {"element", {"element", "elementM"} } } } };
+      thread_local Map safeArrayTable{
+          Map{{{"element", {"element", "elementM"}}}}};
       ExprPtr vc(v->clone());
       if (auto vcc = is<Var>(vc.get())) {
         auto iter = safeArrayTable.find(v->value());
@@ -851,44 +994,53 @@ struct makeSafeArrays : public makeSafe {
     }
   };
 
-  ExprPtr with(const Var* v) const { return SafeArray::with(v); }
+  ExprPtr with(const Var *v) const { return SafeArray::with(v); }
 };
 
 OptDescs getAllOptions() {
   OptDescs d;
-  d["Safe"]       = "Interpret hobbes in safe mode";
-  d["SafeArrays"] = "Interpret array indexing 'safely' (always bounds-checked and mapped to an optional type in case of out-of-bounds access)";
+  d["Safe"] = "Interpret hobbes in safe mode";
+  d["SafeArrays"] =
+      "Interpret array indexing 'safely' (always bounds-checked and mapped to "
+      "an optional type in case of out-of-bounds access)";
   return d;
 }
 
-ExprPtr translateExprWithOpts(const ModulePtr& m, const ExprPtr& e) {
+ExprPtr translateExprWithOpts(const ModulePtr &m, const ExprPtr &e) {
   return translateExprWithOpts(m->options(), e);
 }
 
-ExprPtr translateExprWithOpts(const std::vector<std::string>& opts, const ExprPtr& e, std::function<void(std::string const&)> const& exceptionFn) {
-  auto dispatch = std::map<std::string, std::function<ExprPtr(std::string const&, const ExprPtr&)>> {
-    { 
-      "Safe", [&exceptionFn](std::string const&, const ExprPtr& e) -> ExprPtr {
-        auto ms = makeSafe();
-        auto r = switchOf(e, ms);
-        if (ms.collectUnsafes.size() != 0) {
-          exceptionFn(ms.show());
-        };
-        return r; 
-      }
-    },
-    { "SafeArrays", [](std::string const&, const ExprPtr& e) -> ExprPtr { return switchOf(e, makeSafeArrays()); } },
-  };
-  thread_local auto ignoreFn = [](std::string const& optName, const ExprPtr& e) -> ExprPtr { 
-    throw std::runtime_error("unsupported option, " + optName); return e; 
+ExprPtr translateExprWithOpts(
+    const std::vector<std::string> &opts, const ExprPtr &e,
+    std::function<void(std::string const &)> const &exceptionFn) {
+  auto dispatch =
+      std::map<std::string,
+               std::function<ExprPtr(std::string const &, const ExprPtr &)>>{
+          {"Safe",
+           [&exceptionFn](std::string const &, const ExprPtr &e) -> ExprPtr {
+             auto ms = makeSafe();
+             auto r = switchOf(e, ms);
+             if (ms.collectUnsafes.size() != 0) {
+               exceptionFn(ms.show());
+             };
+             return r;
+           }},
+          {"SafeArrays",
+           [](std::string const &, const ExprPtr &e) -> ExprPtr {
+             return switchOf(e, makeSafeArrays());
+           }},
+      };
+  thread_local auto ignoreFn = [](std::string const &optName,
+                                  const ExprPtr &e) -> ExprPtr {
+    throw std::runtime_error("unsupported option, " + optName);
+    return e;
   };
 
   ExprPtr r = e;
-  for (const auto& opt : opts) {
+  for (const auto &opt : opts) {
     r = dispatch.insert(std::make_pair(opt, ignoreFn)).first->second(opt, r);
   }
   return r;
 }
 
-}
-
+} // namespace hobbes

From 71d72bcb1d79f048dc70856674641fb700b2a069 Mon Sep 17 00:00:00 2001
From: Providence Salumu <Providence.Salumu@smunix.com>
Date: Wed, 28 Apr 2021 10:06:38 -0400
Subject: [PATCH 02/40] * Support IP binding for RPC * Support LLVM-12

flake.lock: Update

Flake input changes:

* Updated 'flake-utils': 'github:numtide/flake-utils/8088c6dbe86a7e6e6396c83e43020e8a1edb08d5' -> 'github:numtide/flake-utils/2ebf2558e5bf978c7fb8ea927dfaed8fefab2e28'
* Updated 'nixpkgs': 'github:NixOS/nixpkgs/a3ab47ec9067b5f9fccda506fc8641484c3d8e73' -> 'github:NixOS/nixpkgs/267761cf44498f9e1aa81dbdb92d77d5873dd9f6'

llvm12: add infra support

gh actions: run on ubuntu-latest

gh actions: run on ubuntu-latest

gh actions: run on new PR

net: fix tests

net: fix tests

net: throw on socket creation failure
---
 .github/workflows/build.yml |   6 +-
 flake.lock                  |  12 +-
 flake.nix                   |   8 +-
 include/hobbes/eval/jitcc.H |   2 +-
 include/hobbes/ipc/net.H    |   4 +-
 include/hobbes/net.H        |   2 +-
 include/hobbes/util/llvm.H  |   8 +-
 lib/hobbes/eval/jitcc.C     |   2 +-
 lib/hobbes/ipc/net.C        | 337 +++++++++++++++-------------
 test/Net.C                  | 429 +++++++++++++++++++++++++++---------
 10 files changed, 538 insertions(+), 272 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 597783e4e..49b9e7fbc 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,12 +1,12 @@
 name: "Build"
-on: [push]
+on: [push, pull_request]
 jobs:
   linux-clang-build:
     runs-on: ${{matrix.os}}
     strategy:
       matrix:
         os: [ubuntu-20.04]
-        clang: [6, 8, 10, 11]
+        clang: [6, 8, 10, 11, 12]
     steps:
       - uses: actions/checkout@v2
         with:
@@ -32,7 +32,7 @@ jobs:
       matrix:
         os: [ubuntu-20.04]
         gcc: [10]
-        llvm: [6, 8, 10, 11]
+        llvm: [6, 8, 10, 11, 12]
     steps:
       - uses: actions/checkout@v2
         with:
diff --git a/flake.lock b/flake.lock
index b5e53972e..bb7acad89 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "flake-utils": {
       "locked": {
-        "lastModified": 1609935452,
-        "narHash": "sha256-McwA/tAnnS8LaAdEoONBsdKFHuOpHMxKqpMCU1wL7H4=",
+        "lastModified": 1619345332,
+        "narHash": "sha256-qHnQkEp1uklKTpx3MvKtY6xzgcqXDsz5nLilbbuL+3A=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "8088c6dbe86a7e6e6396c83e43020e8a1edb08d5",
+        "rev": "2ebf2558e5bf978c7fb8ea927dfaed8fefab2e28",
         "type": "github"
       },
       "original": {
@@ -17,11 +17,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1609899452,
-        "narHash": "sha256-JXi5v4lygRyZjv238bKoPFrQiTAurwcL3XqOo2ZCOLg=",
+        "lastModified": 1619586859,
+        "narHash": "sha256-8DiULA5rhWipZm0Wc9IjqG03jfYSigWFYZWXUVK1ZSI=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "a3ab47ec9067b5f9fccda506fc8641484c3d8e73",
+        "rev": "267761cf44498f9e1aa81dbdb92d77d5873dd9f6",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index af30ac84d..ffc7d13b6 100644
--- a/flake.nix
+++ b/flake.nix
@@ -11,12 +11,12 @@
             inherit system;
             version = "${nixpkgs.lib.substring 0 8 self.lastModifiedDate}.${self.shortRev or "dirty"}";
             src = self;
-            llvmVersions = [ 6 8 9 10 11 ];
+            llvmVersions = [ 6 8 9 10 11 12 ];
             gccConstraints = [
               { gccVersion = 6; llvmVersions = [ 6 8 9 ]; }
-              { gccVersion = 8; llvmVersions = [ 6 8 9 10 11 ]; }
-              { gccVersion = 9; llvmVersions = [ 6 8 9 10 11 ]; }
-              { gccVersion = 10; llvmVersions = [ 6 8 9 10 11 ]; }
+              { gccVersion = 8; llvmVersions = [ 6 8 9 10 11 12 ]; }
+              { gccVersion = 9; llvmVersions = [ 6 8 9 10 11 12 ]; }
+              { gccVersion = 10; llvmVersions = [ 6 8 9 10 11 12 ]; }
             ];
           })
         ];
diff --git a/include/hobbes/eval/jitcc.H b/include/hobbes/eval/jitcc.H
index c87ae3add..33f64b033 100644
--- a/include/hobbes/eval/jitcc.H
+++ b/include/hobbes/eval/jitcc.H
@@ -126,7 +126,7 @@ private:
   typedef std::vector<llvm::Module*> Modules;
   Modules modules;
 
-#if LLVM_VERSION_MINOR == 6 || LLVM_VERSION_MINOR == 7 || LLVM_VERSION_MINOR == 8 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR <= 11
+#if LLVM_VERSION_MINOR == 6 || LLVM_VERSION_MINOR == 7 || LLVM_VERSION_MINOR == 8 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR <= 12
   llvm::legacy::PassManager* mpm;
 
   // the set of allocated execution engines (each will own a finalized module from the set of modules)
diff --git a/include/hobbes/ipc/net.H b/include/hobbes/ipc/net.H
index 4f8b2a9b6..e2ddcf279 100644
--- a/include/hobbes/ipc/net.H
+++ b/include/hobbes/ipc/net.H
@@ -16,7 +16,7 @@ namespace hobbes {
 int lookupPort(const std::string&);
 
 // create a socket listening on a port
-int allocateServer(int port);
+int allocateServer(int port, const std::string& host = "");
 int allocateServer(const std::string& port);
 
 // connect to a host/port
@@ -46,11 +46,13 @@ struct Server {
 };
 
 int installNetREPL(int port, Server*);
+int installNetREPL(const std::string& host, int port, Server*);
 // install a net repl on a unix domain socket (using file paths)
 int installNetREPL(const std::string& /*filepath*/, Server*);
 
 class cc;
 int installNetREPL(int port, cc*, ReWriteExprFn const& = [](ExprPtr const& e) -> ExprPtr { return e; });
+int installNetREPL(const std::string& host, int port, cc*, ReWriteExprFn const& = [](ExprPtr const& e) -> ExprPtr { return e; });
 // install a net repl on a unix domain socket (using file paths)
 int installNetREPL(const std::string& /*filepath*/, cc*, ReWriteExprFn const& = [](ExprPtr const& e) -> ExprPtr { return e; });
 
diff --git a/include/hobbes/net.H b/include/hobbes/net.H
index 40e6b5bdd..bd7f38ad2 100644
--- a/include/hobbes/net.H
+++ b/include/hobbes/net.H
@@ -162,7 +162,7 @@ inline addrinfo* lookupAddrInfo(const std::string& host, const std::string& port
   h.ai_socktype = SOCK_STREAM;
 
   struct addrinfo* addrs = 0;
-  switch (getaddrinfo(host.c_str(), port.empty() ? 0 : port.c_str(), &h, &addrs)) {
+  switch (getaddrinfo(host.empty()? 0 : host.c_str(), port.empty() ? 0 : port.c_str(), &h, &addrs)) {
   case 0:              return addrs;
   case EAI_ADDRFAMILY: throw std::runtime_error("Cannot make socket connection to " + host + ":" + port);
   case EAI_AGAIN:      throw std::runtime_error(host + ":" + port + " is temporarily unavailable");
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index cf57b8743..0254c508b 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -11,7 +11,7 @@
 
 #include <llvm/Config/llvm-config.h>
 
-#if LLVM_VERSION_MAJOR != 3 && LLVM_VERSION_MAJOR != 4 && LLVM_VERSION_MAJOR != 6 && LLVM_VERSION_MAJOR != 8 && LLVM_VERSION_MAJOR != 9 && LLVM_VERSION_MAJOR != 10 && LLVM_VERSION_MAJOR != 11
+#if LLVM_VERSION_MAJOR != 3 && LLVM_VERSION_MAJOR != 4 && LLVM_VERSION_MAJOR != 6 && LLVM_VERSION_MAJOR != 8 && LLVM_VERSION_MAJOR != 9 && LLVM_VERSION_MAJOR != 10 && LLVM_VERSION_MAJOR != 11 && LLVM_VERSION_MAJOR != 12
 #error "I don't know how to use this version of LLVM"
 #endif
 
@@ -32,7 +32,7 @@
 #if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR <= 8 
 #  include <llvm/Bitcode/BitstreamReader.h>
 #  include <llvm/Bitcode/BitstreamWriter.h>
-#elif  LLVM_VERSION_MAJOR <= 11
+#elif  LLVM_VERSION_MAJOR <= 12
 #  include <llvm/Bitstream/BitstreamReader.h>
 #  include <llvm/Bitstream/BitstreamWriter.h>
 #else
@@ -372,7 +372,7 @@ inline llvm::Value* memCopy(llvm::IRBuilder<>* b, llvm::Value* dst, uint32_t dst
   return b->CreateMemCpy(dst, src, sz, srcAlign);
 #elif LLVM_VERSION_MAJOR <= 9
   return b->CreateMemCpy(dst, dstAlign, src, srcAlign, sz);
-#elif LLVM_VERSION_MAJOR <= 11
+#elif LLVM_VERSION_MAJOR <= 12
   return b->CreateMemCpy(dst, llvm::MaybeAlign(dstAlign), src, llvm::MaybeAlign(srcAlign), sz);
 #endif
 }
@@ -586,7 +586,7 @@ inline llvm::Value* fncall(llvm::IRBuilder<>* b, llvm::Value* vfn, llvm::Type* t
   }
 #elif LLVM_VERSION_MAJOR <= 10
   return b->CreateCall(vfn, args);
-#elif LLVM_VERSION_MAJOR <= 11
+#elif LLVM_VERSION_MAJOR <= 12
   if (auto *ty = llvm::dyn_cast<llvm::FunctionType>(tfn)) {
       return b->CreateCall(ty, vfn, args);
   } else {
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index b4a9bf798..3181d6228 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -498,7 +498,7 @@ llvm::Value* jitcc::loadConstant(const std::string& vn) {
     } else if (llvm::Value* r = refGlobal(vn, cv->second.ref)) {
 #if LLVM_VERSION_MAJOR <= 10
       return hasPointerRep(cv->second.mtype) ? r : builder()->CreateLoad(r);
-#elif LLVM_VERSION_MAJOR <= 11
+#elif LLVM_VERSION_MAJOR <= 12 
       return hasPointerRep(cv->second.mtype) ? r : builder()->CreateAlignedLoad(r->getType()->getPointerElementType(), r, llvm::MaybeAlign(8));
 #endif
     } else {
diff --git a/lib/hobbes/ipc/net.C b/lib/hobbes/ipc/net.C
index 959ed7b3f..c3959e782 100644
--- a/lib/hobbes/ipc/net.C
+++ b/lib/hobbes/ipc/net.C
@@ -1,29 +1,30 @@
 
-#include <hobbes/ipc/net.H>
 #include <hobbes/hobbes.H>
-#include <hobbes/util/str.H>
+#include <hobbes/ipc/net.H>
+#include <hobbes/net.H>
 #include <hobbes/util/codec.H>
+#include <hobbes/util/str.H>
 
 #include <sstream>
 
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <netdb.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
 
 namespace hobbes {
 
 // get the port number associated with a named port
-int lookupPort(const std::string& x) {
+int lookupPort(const std::string &x) {
   if (str::is<int>(x)) {
     return str::to<int>(x);
   } else {
-    struct servent* s = getservbyname(x.c_str(), "tcp");
+    struct servent *s = getservbyname(x.c_str(), "tcp");
     if (s != 0) {
       return ntohs(s->s_port);
     } else {
@@ -32,70 +33,76 @@ int lookupPort(const std::string& x) {
   }
 }
 
-// create a listening socket on a given port
-int allocateServer(int port) {
-  int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (s == -1) {
-    throw std::runtime_error("Unable to allocate socket: " + std::string(strerror(errno)));
-  }
-
-  // make sure that we can quickly restart the server if necessary
-  int ra = 1;
-  setsockopt(s, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&ra), sizeof(ra));
-
-  // bind the new socket to a local address
-  sockaddr_in laddr;
-  memset(&laddr, 0, sizeof(laddr));
-
-  laddr.sin_family      = AF_INET;
-  laddr.sin_port        = htons(port);
-  laddr.sin_addr.s_addr = INADDR_ANY;
-
-  if (bind(s, reinterpret_cast<sockaddr*>(&laddr), sizeof(laddr)) == -1) {
+// create a listening socket on a given port and a given host
+int allocateServer(int port, const std::string &host) {
+  struct addrinfo *addrs = net::lookupAddrInfo(host, std::to_string(port));
+  struct addrinfo *p = NULL;
+  int s;
+  for (p = addrs; p != 0; p = p->ai_next) {
+    if (p->ai_family != AF_INET || p->ai_protocol != IPPROTO_TCP)
+      continue;
+    s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
+
+    if (s == -1) {
+      throw std::runtime_error("Unable to allocate socket: " +
+                               std::string(strerror(errno)));
+    }
+    // make sure that we can quickly restart the server if necessary
+    int ra = 1;
+    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char *>(&ra),
+               sizeof(ra));
+    if (bind(s, p->ai_addr, p->ai_addrlen) == 0)
+      break;
     close(s);
-    throw std::runtime_error("Unable to bind socket to local address: " + std::string(strerror(errno)));
   }
-
+  freeaddrinfo(addrs);
+  if (p == NULL) {
+    throw std::runtime_error("Unable to bind socket to address: " +
+                             std::string(strerror(errno)));
+  }
   // and then start to listen
   if (listen(s, SOMAXCONN) == -1) {
     close(s);
-    throw std::runtime_error("Unable to listen on local address: " + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to listen on address: " +
+                             std::string(strerror(errno)));
   }
-
   return s;
 }
 
-int allocateServer(const std::string& port) {
+int allocateServer(const std::string &port) {
   return allocateServer(lookupPort(port));
 }
 
-int allocateFileSocketServer(const std::string& filepath) {
+int allocateFileSocketServer(const std::string &filepath) {
   int s = socket(AF_UNIX, SOCK_STREAM, 0);
   if (s == -1) {
-    throw std::runtime_error("Unable to allocate socket: " + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to allocate socket: " +
+                             std::string(strerror(errno)));
   }
-  
+
   sockaddr_un addr;
   memset(&addr, 0, sizeof(addr));
   addr.sun_family = AF_UNIX;
   unlink(filepath.c_str());
   snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", filepath.c_str());
 
-  if (bind(s, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == -1) {
+  if (bind(s, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)) == -1) {
     close(s);
-    throw std::runtime_error("Unable to bind socket to file: " + filepath + std::string(" : ") + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to bind socket to file: " + filepath +
+                             std::string(" : ") + std::string(strerror(errno)));
   }
 
   // and then start to listen
   if (listen(s, SOMAXCONN) == -1) {
     close(s);
-    throw std::runtime_error("Unable to listen socket on file: " + filepath + std::string(" : ") + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to listen socket on file: " + filepath +
+                             std::string(" : ") + std::string(strerror(errno)));
   }
 
   return s;
 }
 
-int connectSocket(int r, sockaddr* saddr, size_t len) {
+int connectSocket(int r, sockaddr *saddr, size_t len) {
   if (connect(r, saddr, len) == -1) {
     std::ostringstream ss;
     ss << "Unable to connect socket: " << strerror(errno) << std::flush;
@@ -110,7 +117,8 @@ int connectSocket(int r, sockaddr* saddr, size_t len) {
 
   if (select(r + 1, 0, &wd, 0, 0) == -1) {
     std::ostringstream ss;
-    ss << "Failed to connect socket while waiting for writeability: " << strerror(errno) << std::flush;
+    ss << "Failed to connect socket while waiting for writeability: "
+       << strerror(errno) << std::flush;
     close(r);
     throw std::runtime_error(ss.str());
   }
@@ -120,44 +128,47 @@ int connectSocket(int r, sockaddr* saddr, size_t len) {
 }
 
 // create a connected socket to a remote process
-int connectSocket(hostent* host, int port) {
+int connectSocket(hostent *host, int port) {
   int r = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (r == -1) {
-    throw std::runtime_error("Unable to allocate socket: " + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to allocate socket: " +
+                             std::string(strerror(errno)));
   }
 
   sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
   addr.sin_family = AF_INET;
-  addr.sin_addr   = *reinterpret_cast<in_addr*>(host->h_addr_list[0]);
-  addr.sin_port   = htons(port);
+  addr.sin_addr = *reinterpret_cast<in_addr *>(host->h_addr_list[0]);
+  addr.sin_port = htons(port);
 
-  return connectSocket(r, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
+  return connectSocket(r, reinterpret_cast<sockaddr *>(&addr), sizeof(addr));
 }
 
-int connectFileSocket(const std::string& filepath) {
+int connectFileSocket(const std::string &filepath) {
   int r = socket(AF_UNIX, SOCK_STREAM, 0);
   if (r == -1) {
-    throw std::runtime_error("Unable to allocate socket: " + std::string(strerror(errno)));
+    throw std::runtime_error("Unable to allocate socket: " +
+                             std::string(strerror(errno)));
   }
-  
+
   sockaddr_un addr;
   memset(&addr, 0, sizeof(addr));
   addr.sun_family = AF_UNIX;
   snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", filepath.c_str());
 
-  return connectSocket(r, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
+  return connectSocket(r, reinterpret_cast<sockaddr *>(&addr), sizeof(addr));
 }
 
-int connectSocket(const std::string& host, int port) {
+int connectSocket(const std::string &host, int port) {
   if (host.size() > 0 && str::isDigit(host[0])) {
-    return connectSocket(gethostbyaddr(host.c_str(), host.size(), AF_INET), port);
+    return connectSocket(gethostbyaddr(host.c_str(), host.size(), AF_INET),
+                         port);
   } else {
     return connectSocket(gethostbyname(host.c_str()), port);
   }
 }
-      
-int connectSocket(const std::string& hostport) {
+
+int connectSocket(const std::string &hostport) {
   str::pair p = str::lsplit(hostport, ":");
   if (p.second.size() > 0)
     return connectSocket(p.first, lookupPort(p.second));
@@ -169,10 +180,12 @@ int connectSocket(const std::string& hostport) {
 std::string remoteHostname(int c) {
   struct sockaddr_in sin;
   socklen_t len = sizeof(sin);
-  if (getpeername(c, reinterpret_cast<struct sockaddr*>(&sin), &len) < 0) {
+  if (getpeername(c, reinterpret_cast<struct sockaddr *>(&sin), &len) < 0) {
     throw std::runtime_error("Couldn't get peer name for socket");
   } else {
-    if (struct hostent* host = gethostbyaddr(reinterpret_cast<char*>(&sin.sin_addr), sizeof(sin.sin_addr), AF_INET)) {
+    if (struct hostent *host =
+            gethostbyaddr(reinterpret_cast<char *>(&sin.sin_addr),
+                          sizeof(sin.sin_addr), AF_INET)) {
       return std::string(host->h_name);
     } else {
       throw std::runtime_error("Couldn't get host name for socket");
@@ -184,30 +197,34 @@ std::string remoteHostname(int c) {
 int remotePort(int c) {
   struct sockaddr_in sin;
   socklen_t len = sizeof(sin);
-  if (getpeername(c, reinterpret_cast<struct sockaddr*>(&sin), &len) < 0) {
+  if (getpeername(c, reinterpret_cast<struct sockaddr *>(&sin), &len) < 0) {
     throw std::runtime_error("Couldn't get peer name for socket");
   } else {
     return ntohs(sin.sin_port);
   }
 }
 
-void prepareStrExpr(Server* s, int c, exprid eid, const std::string& expr, const MonoTypes& intys, const MonoTypePtr& outty) {
+void prepareStrExpr(Server *s, int c, exprid eid, const std::string &expr,
+                    const MonoTypes &intys, const MonoTypePtr &outty) {
   auto la = LexicalAnnotation::null();
 
   if (intys.size() == 0 || (intys.size() == 1 && isUnit(intys[0]))) {
-    s->prepare(c, eid, assume(s->readExpr(expr), functy(tuplety(intys), outty), la), tuplety());
+    s->prepare(c, eid,
+               assume(s->readExpr(expr), functy(tuplety(intys), outty), la),
+               tuplety());
   } else {
     ExprPtr f = assume(s->readExpr(expr), functy(intys, outty), la);
     Exprs args;
     for (size_t i = 0; i < intys.size(); ++i) {
-      args.push_back(proj(var("p", la), ".f"+str::from(i), la));
+      args.push_back(proj(var("p", la), ".f" + str::from(i), la));
     }
-    s->prepare(c, eid, fn(str::strings("p"), fncall(f, args, la), la), tuplety(intys));
+    s->prepare(c, eid, fn(str::strings("p"), fncall(f, args, la), la),
+               tuplety(intys));
   }
 }
 
-void evaluateNetREPLRequest(int c, void* d) {
-  Server* s = reinterpret_cast<Server*>(d);
+void evaluateNetREPLRequest(int c, void *d) {
+  Server *s = reinterpret_cast<Server *>(d);
 
   try {
     uint8_t cmd = 0;
@@ -222,23 +239,23 @@ void evaluateNetREPLRequest(int c, void* d) {
 
         std::string expr;
         fdread(c, &expr);
-  
+
         RawData ityd, otyd;
         fdread(c, &ityd);
         fdread(c, &otyd);
 
         MonoTypePtr itye = decode(ityd);
         MonoTypes itys;
-        if (const Record* argl = is<Record>(itye)) {
+        if (const Record *argl = is<Record>(itye)) {
           itys = selectTypes(argl->members());
         } else {
           itys.push_back(itye);
         }
         prepareStrExpr(s, c, eid, expr, itys, decode(otyd));
-  
+
         // if we got this far, we have a successful result
         fdwrite(c, uint8_t(1));
-      } catch (std::exception& ex) {
+      } catch (std::exception &ex) {
         fdwrite(c, uint8_t(0));
         fdwrite(c, std::string(ex.what()));
       }
@@ -252,20 +269,20 @@ void evaluateNetREPLRequest(int c, void* d) {
         fdread(c, &exprd);
         ExprPtr expr;
         decode(exprd, &expr);
-  
+
         RawData tyd;
         fdread(c, &tyd);
         MonoTypePtr ty = decode(tyd);
-  
+
         MonoTypePtr rty = s->prepare(c, eid, expr, ty);
-  
+
         RawData rtyd;
         encode(rty, &rtyd);
-  
+
         // if we got this far, we have a successful result
         fdwrite(c, uint8_t(1));
         fdwrite(c, rtyd);
-      } catch (std::exception& ex) {
+      } catch (std::exception &ex) {
         fdwrite(c, uint8_t(0));
         fdwrite(c, std::string(ex.what()));
       }
@@ -279,7 +296,7 @@ void evaluateNetREPLRequest(int c, void* d) {
     default:
       throw std::runtime_error("protocol violation: cmd=" + str::from(cmd));
     }
-  } catch (std::exception& ex) {
+  } catch (std::exception &ex) {
     // something went wrong, disconnect
     close(c);
     unregisterEventHandler(c);
@@ -287,37 +304,42 @@ void evaluateNetREPLRequest(int c, void* d) {
   }
 }
 
-void registerNetREPL(int s, Server* svr) {
+void registerNetREPL(int s, Server *svr) {
   registerEventHandler(
-    s,
-    [](int s, void* d) {
-      int c = accept(s, 0, 0);
-      if (c != -1) {
-        try {
-          uint32_t version = 0;
-          fdread(c, &version);
-          if (version != 0x00010000) {
+      s,
+      [](int s, void *d) {
+        int c = accept(s, 0, 0);
+        if (c != -1) {
+          try {
+            uint32_t version = 0;
+            fdread(c, &version);
+            if (version != 0x00010000) {
+              close(c);
+            }
+
+            reinterpret_cast<Server *>(d)->connect(c);
+            registerEventHandler(c, &evaluateNetREPLRequest, d);
+          } catch (std::exception &) {
             close(c);
           }
-
-          reinterpret_cast<Server*>(d)->connect(c);
-          registerEventHandler(c, &evaluateNetREPLRequest, d);
-        } catch (std::exception&) {
-          close(c);
         }
-      }
-    },
-    svr
-  );
+      },
+      svr);
 }
 
-int installNetREPL(int port, Server* svr) {
+int installNetREPL(int port, Server *svr) {
   int s = allocateServer(port);
   registerNetREPL(s, svr);
   return s;
 }
 
-int installNetREPL(const std::string& filepath, Server* svr) {
+int installNetREPL(const std::string &host, int port, Server *svr) {
+  int s = allocateServer(port, host);
+  registerNetREPL(s, svr);
+  return s;
+}
+
+int installNetREPL(const std::string &filepath, Server *svr) {
   int s = allocateFileSocketServer(filepath);
   registerNetREPL(s, svr);
   return s;
@@ -325,44 +347,44 @@ int installNetREPL(const std::string& filepath, Server* svr) {
 
 class CCServer : public Server {
 public:
-  CCServer(cc* c, ReWriteExprFn const& wrExprFn) : c(c), wrExprFn(wrExprFn) {
-  }
-  
-  void connect(int) { }
-  
-  ExprPtr readExpr(const std::string& x) {
-    return this->c->readExpr(x);
-  }
+  CCServer(cc *c, ReWriteExprFn const &wrExprFn) : c(c), wrExprFn(wrExprFn) {}
+
+  void connect(int) {}
 
-  MonoTypePtr prepare(int c, exprid eid, const ExprPtr& expr, const MonoTypePtr& inty) {
-    const auto& la = expr->la();
+  ExprPtr readExpr(const std::string &x) { return this->c->readExpr(x); }
+
+  MonoTypePtr prepare(int c, exprid eid, const ExprPtr &expr,
+                      const MonoTypePtr &inty) {
+    const auto &la = expr->la();
 
     // E(readFrom(in)::T) :: ?
     MonoTypePtr rty = requireMonotype(
-      this->c->unsweetenExpression(
-        fncall(
-          wrExprFn(expr),
-          list(assume(fncall(var("readFrom", la), list(constant(static_cast<int>(0), la)), la), inty, la)),
-          la
-        )
-      )->type()
-    );
+        this->c
+            ->unsweetenExpression(fncall(
+                wrExprFn(expr),
+                list(assume(fncall(var("readFrom", la),
+                                   list(constant(static_cast<int>(0), la)), la),
+                            inty, la)),
+                la))
+            ->type());
 
     // let x = readFrom(input) :: T in writeTo(output, E(x))
-    this->cnetFns[c][eid] =
-      this->c->compileFn<void(int)>
-      (
-        ".c",
-        let(".in", assume(fncall(var("readFrom", la), list(var(".c", la)), la), inty, la), fncall(var("writeTo", la), list(var(".c", la),
-          fncall(wrExprFn(expr), list(var(".in", la)), la)), la), la)
-      );
+    this->cnetFns[c][eid] = this->c->compileFn<void(int)>(
+        ".c", let(".in",
+                  assume(fncall(var("readFrom", la), list(var(".c", la)), la),
+                         inty, la),
+                  fncall(var("writeTo", la),
+                         list(var(".c", la),
+                              fncall(wrExprFn(expr), list(var(".in", la)), la)),
+                         la),
+                  la));
 
     return rty;
   }
 
   void evaluate(int c, exprid eid) {
     auto cfns = this->cnetFns[c];
-    auto f    = cfns.find(eid);
+    auto f = cfns.find(eid);
 
     if (f != cfns.end()) {
       // perform the call
@@ -375,9 +397,10 @@ public:
     }
   }
 
-  void disconnect(int) { }
+  void disconnect(int) {}
+
 private:
-  cc* c;
+  cc *c;
 
   typedef void (*NetFn)(int); // socket -> ()
   typedef std::map<exprid, NetFn> NetFns;
@@ -386,28 +409,31 @@ private:
   ReWriteExprFn wrExprFn;
 };
 
-int installNetREPL(int port, cc* c, ReWriteExprFn const& wrExprFn) {
+int installNetREPL(int port, cc *c, ReWriteExprFn const &wrExprFn) {
   return installNetREPL(port, new CCServer(c, wrExprFn));
 }
-int installNetREPL(const std::string& filepath, cc* c, ReWriteExprFn const& wrExprFn) {
+int installNetREPL(const std::string &host, int port, cc *c,
+                   ReWriteExprFn const &wrExprFn) {
+  return installNetREPL(host, port, new CCServer(c, wrExprFn));
+}
+
+int installNetREPL(const std::string &filepath, cc *c,
+                   ReWriteExprFn const &wrExprFn) {
   return installNetREPL(filepath, new CCServer(c, wrExprFn));
 }
 
 // connect to a running net REPL
-Client::Client(const std::string& hostport) : hostport(hostport), eid(0), rbno(0), reno(0) {
+Client::Client(const std::string &hostport)
+    : hostport(hostport), eid(0), rbno(0), reno(0) {
   this->c = connectSocket(hostport);
   fdwrite(this->c, static_cast<uint32_t>(0x00010000));
 }
 
-Client::~Client() {
-  close(this->c);
-}
+Client::~Client() { close(this->c); }
 
-const std::string& Client::remoteHost() const {
-  return this->hostport;
-}
+const std::string &Client::remoteHost() const { return this->hostport; }
 
-exprid Client::remoteExpr(const ExprPtr& expr, const MonoTypePtr& inty) {
+exprid Client::remoteExpr(const ExprPtr &expr, const MonoTypePtr &inty) {
   // have we already exchanged this exprty?
   ExprTy exprty(expr.get(), inty.get());
   auto etid = this->exprTyToID.find(exprty);
@@ -436,9 +462,9 @@ exprid Client::remoteExpr(const ExprPtr& expr, const MonoTypePtr& inty) {
     RawData outtyd;
     fdread(this->c, &outtyd);
 
-    ExprDef& ed = this->exprDefs[rid];
-    ed.expr  = expr;
-    ed.inty  = inty;
+    ExprDef &ed = this->exprDefs[rid];
+    ed.expr = expr;
+    ed.inty = inty;
     ed.outty = decode(outtyd);
 
     this->exprTyToID[exprty] = rid;
@@ -456,7 +482,8 @@ exprid Client::remoteExpr(const ExprPtr& expr, const MonoTypePtr& inty) {
 MonoTypePtr Client::input(exprid ex) const {
   auto ed = this->exprDefs.find(ex);
   if (ed == this->exprDefs.end()) {
-    throw std::runtime_error("Remote process has no compiled expression with id=" + str::from(ex));
+    throw std::runtime_error(
+        "Remote process has no compiled expression with id=" + str::from(ex));
   } else {
     return ed->second.inty;
   }
@@ -465,32 +492,41 @@ MonoTypePtr Client::input(exprid ex) const {
 MonoTypePtr Client::output(exprid ex) const {
   auto ed = this->exprDefs.find(ex);
   if (ed == this->exprDefs.end()) {
-    throw std::runtime_error("Remote process has no compiled expression with id=" + str::from(ex));
+    throw std::runtime_error(
+        "Remote process has no compiled expression with id=" + str::from(ex));
   } else {
     return ed->second.outty;
   }
 }
 
-MonoTypePtr Client::output(const ExprPtr& e, const MonoTypePtr& inty) {
+MonoTypePtr Client::output(const ExprPtr &e, const MonoTypePtr &inty) {
   return output(remoteExpr(e, inty));
 }
 
-void Client::show(std::ostream& out) const {
+void Client::show(std::ostream &out) const {
   out << this->hostport << "\n\n";
   str::seqs cs;
   cs.resize(4);
 
   cs[0].push_back("id");
-  for (const auto& ce : this->exprDefs) { cs[0].push_back(str::from(ce.first)); }
+  for (const auto &ce : this->exprDefs) {
+    cs[0].push_back(str::from(ce.first));
+  }
 
   cs[1].push_back("expr");
-  for (const auto& ce : this->exprDefs) { cs[1].push_back(hobbes::show(ce.second.expr)); }
+  for (const auto &ce : this->exprDefs) {
+    cs[1].push_back(hobbes::show(ce.second.expr));
+  }
 
   cs[2].push_back("input");
-  for (const auto& ce : this->exprDefs) { cs[2].push_back(hobbes::show(ce.second.inty)); }
+  for (const auto &ce : this->exprDefs) {
+    cs[2].push_back(hobbes::show(ce.second.inty));
+  }
 
   cs[3].push_back("output");
-  for (const auto& ce : this->exprDefs) { cs[3].push_back(hobbes::show(ce.second.outty)); }
+  for (const auto &ce : this->exprDefs) {
+    cs[3].push_back(hobbes::show(ce.second.outty));
+  }
 
   str::printRightAlignedTable(out, cs);
 }
@@ -501,7 +537,7 @@ size_t Client::appendReadFn(ReadFn f) {
   return this->reno++;
 }
 
-char* Client::readValue(size_t x) {
+char *Client::readValue(size_t x) {
   if (x < this->rbno) {
     // too late, we've already read past this
     std::cerr << "Can't read remote value out of sequence." << std::endl;
@@ -513,7 +549,7 @@ char* Client::readValue(size_t x) {
       ++this->rbno;
     }
 
-    char* r = this->readFns.front()(this->c);
+    char *r = this->readFns.front()(this->c);
     this->readFns.pop();
     ++this->rbno;
 
@@ -529,12 +565,11 @@ char* Client::readValue(size_t x) {
 }
 
 size_t Client::unsafeAppendReadFn(size_t p, ReadFn f) {
-  return reinterpret_cast<Client*>(p)->appendReadFn(f);
-}
-
-char* Client::unsafeRead(size_t p, size_t x) {
-  return reinterpret_cast<Client*>(p)->readValue(x);
+  return reinterpret_cast<Client *>(p)->appendReadFn(f);
 }
 
+char *Client::unsafeRead(size_t p, size_t x) {
+  return reinterpret_cast<Client *>(p)->readValue(x);
 }
 
+} // namespace hobbes
diff --git a/test/Net.C b/test/Net.C
index d12b74dab..645ac46b8 100644
--- a/test/Net.C
+++ b/test/Net.C
@@ -1,15 +1,18 @@
 
+#include "test.H"
 #include <hobbes/hobbes.H>
 #include <hobbes/ipc/net.H>
 #include <hobbes/net.H>
-#include "test.H"
 
+#include <condition_variable>
 #include <mutex>
 #include <thread>
-#include <condition_variable>
 
 using namespace hobbes;
-static cc& c() { static cc x; return x; }
+static cc &c() {
+  static cc x;
+  return x;
+}
 
 // start a basic server to validate RPC communication
 static int serverPort = -1;
@@ -25,7 +28,8 @@ static void runTestServer(int ps, int pe) {
       lk.unlock();
       serverStartup.notify_one();
       runEventLoop();
-    } catch (std::exception&) {
+      return;
+    } catch (std::exception &) {
       ++serverPort;
     }
   }
@@ -45,167 +49,392 @@ int testServerPort() {
   return serverPort;
 }
 
+// start a basic server with configurable hostname and port to validate RPC
+// communication
+static int serverPortWithHost = -1;
+static std::mutex serverMtxWithHost;
+static std::condition_variable serverWithHostStartup;
+
+static void runTestServerWithHost(int ps, int pe, const std::string &host) {
+  std::unique_lock<std::mutex> lk(serverMtxWithHost);
+  serverPortWithHost = ps;
+  while (serverPortWithHost < pe) {
+    try {
+      installNetREPL(host, serverPortWithHost, &c());
+      lk.unlock();
+      serverWithHostStartup.notify_one();
+      runEventLoop();
+      return;
+    } catch (std::exception &) {
+      ++serverPortWithHost;
+    }
+  }
+  serverPortWithHost = -1;
+}
+
+int testServerWithHostPort(const std::string &host = "") {
+  if (serverPortWithHost < 0) {
+    std::unique_lock<std::mutex> lk(serverMtxWithHost);
+    std::thread serverWithHostProc(
+        std::bind(&runTestServerWithHost, 9501, 10500, host));
+    serverWithHostProc.detach();
+    serverWithHostStartup.wait(lk);
+    if (serverPortWithHost < 0) {
+      throw std::runtime_error("Couldn't allocate port for test server");
+    }
+  }
+  return serverPortWithHost;
+}
 /**************************
  * types/data for net communication
  **************************/
 typedef std::map<std::string, size_t> NameCounts;
-typedef std::pair<std::string,size_t> NC;
-bool operator==(const NameCounts& ncs, const std::vector<NC>& ncsc) {
-  for (const auto& nc : ncsc) { auto i = ncs.find(nc.first); if (i == ncs.end() || i->second != nc.second) { return false; } } return ncs.size() == ncsc.size();
+typedef std::pair<std::string, size_t> NC;
+bool operator==(const NameCounts &ncs, const std::vector<NC> &ncsc) {
+  for (const auto &nc : ncsc) {
+    auto i = ncs.find(nc.first);
+    if (i == ncs.end() || i->second != nc.second) {
+      return false;
+    }
+  }
+  return ncs.size() == ncsc.size();
 }
 
-std::ostream& operator<<(std::ostream& os, const NC& nc) {
+std::ostream &operator<<(std::ostream &os, const NC &nc) {
   os << "(\"" << nc.first << "\", " << nc.second << ")";
   return os;
 }
 template <typename T>
-  std::ostream& operator<<(std::ostream& os, const std::vector<T>& xs) {
-    os << "["; if (xs.size() > 0) { os << xs[0]; for (size_t i = 1; i < xs.size(); ++i) os << ", " << xs[i]; } os << "]";
-    return os;
+std::ostream &operator<<(std::ostream &os, const std::vector<T> &xs) {
+  os << "[";
+  if (xs.size() > 0) {
+    os << xs[0];
+    for (size_t i = 1; i < xs.size(); ++i)
+      os << ", " << xs[i];
+  }
+  os << "]";
+  return os;
+}
+std::ostream &operator<<(std::ostream &os, const NameCounts &ncsc) {
+  os << "{";
+  auto nc = ncsc.begin();
+  if (nc != ncsc.end()) {
+    os << "\"" << nc->first << "\" => " << nc->second;
+    ++nc;
+    for (; nc != ncsc.end(); ++nc)
+      os << ", "
+         << "\"" << nc->first << "\" => " << nc->second;
   }
-std::ostream& operator<<(std::ostream& os, const NameCounts& ncsc) {
-  os << "{"; auto nc = ncsc.begin(); if (nc != ncsc.end()) { os << "\"" << nc->first << "\" => " << nc->second; ++nc; for(;nc != ncsc.end();++nc) os << ", " << "\"" << nc->first << "\" => " << nc->second; } os << "}";
+  os << "}";
   return os;
 }
 
 DEFINE_ENUM(Kid, (Jim), (Bob));
 
-DEFINE_STRUCT(
-  Group,
-  (std::string, id),
-  (Kid,         kid),
-  (double,      aa),
-  (size_t,      bb)
-);
+DEFINE_STRUCT(Group, (std::string, id), (Kid, kid), (double, aa), (size_t, bb));
 typedef std::vector<Group> Groups;
-std::ostream& operator<<(std::ostream& os, const Group& g) { os << "{id=\"" << g.id << "\", kid=" << ((g.kid == Kid::Jim()) ? "|Jim|" : "|Bob|") << ", aa=" << g.aa << ", bb=" << g.bb << "}"; return os; }
+std::ostream &operator<<(std::ostream &os, const Group &g) {
+  os << "{id=\"" << g.id
+     << "\", kid=" << ((g.kid == Kid::Jim()) ? "|Jim|" : "|Bob|")
+     << ", aa=" << g.aa << ", bb=" << g.bb << "}";
+  return os;
+}
 
-DEFINE_VARIANT(
-  V,
-  (Bob,     int),
-  (Frank,   std::string),
-  (Nothing, hobbes::unit)
-);
+DEFINE_VARIANT(V, (Bob, int), (Frank, std::string), (Nothing, hobbes::unit));
 
 // make sure that enums with custom ctor IDs transfer correctly
-enum class CustomIDEnum : uint32_t {
-  Red = 55,
-  Green = 12,
-  Blue  = 257
-};
-std::ostream& operator<<(std::ostream& os, const CustomIDEnum& e) {
+enum class CustomIDEnum : uint32_t { Red = 55, Green = 12, Blue = 257 };
+std::ostream &operator<<(std::ostream &os, const CustomIDEnum &e) {
   switch (e) {
-  case CustomIDEnum::Red:   os << "|Red|";   break;
-  case CustomIDEnum::Green: os << "|Green|"; break;
-  case CustomIDEnum::Blue:  os << "|Blue|";  break;
-  default:                  os << "???";     break;
+  case CustomIDEnum::Red:
+    os << "|Red|";
+    break;
+  case CustomIDEnum::Green:
+    os << "|Green|";
+    break;
+  case CustomIDEnum::Blue:
+    os << "|Blue|";
+    break;
+  default:
+    os << "???";
+    break;
   }
   return os;
 }
 
-namespace hobbes { namespace net {
-template <>
-  struct io<CustomIDEnum> {
-    static const bool can_memcpy = true;
-    static ty::desc type() {
-      ty::Variant::Ctors cs;
-      cs.push_back(ty::Variant::Ctor("Red",   static_cast<uint32_t>(CustomIDEnum::Red),   ty::prim("unit")));
-      cs.push_back(ty::Variant::Ctor("Green", static_cast<uint32_t>(CustomIDEnum::Green), ty::prim("unit")));
-      cs.push_back(ty::Variant::Ctor("Blue",  static_cast<uint32_t>(CustomIDEnum::Blue),  ty::prim("unit")));
-      return ty::variant(cs);
-    }
-    static void write(int s, const CustomIDEnum& x) { io<uint32_t>::write(s, static_cast<uint32_t>(x)); }
-    static void read(int s, CustomIDEnum* x)        { io<uint32_t>::read(s, reinterpret_cast<uint32_t*>(x)); }
+namespace hobbes {
+namespace net {
+template <> struct io<CustomIDEnum> {
+  static const bool can_memcpy = true;
+  static ty::desc type() {
+    ty::Variant::Ctors cs;
+    cs.push_back(ty::Variant::Ctor(
+        "Red", static_cast<uint32_t>(CustomIDEnum::Red), ty::prim("unit")));
+    cs.push_back(ty::Variant::Ctor(
+        "Green", static_cast<uint32_t>(CustomIDEnum::Green), ty::prim("unit")));
+    cs.push_back(ty::Variant::Ctor(
+        "Blue", static_cast<uint32_t>(CustomIDEnum::Blue), ty::prim("unit")));
+    return ty::variant(cs);
+  }
+  static void write(int s, const CustomIDEnum &x) {
+    io<uint32_t>::write(s, static_cast<uint32_t>(x));
+  }
+  static void read(int s, CustomIDEnum *x) {
+    io<uint32_t>::read(s, reinterpret_cast<uint32_t *>(x));
+  }
 
-    typedef io<uint32_t>::async_read_state async_read_state;
-    static void prepare(async_read_state* o) { io<uint32_t>::prepare(o); }
-    static bool accum(int s, async_read_state* o, CustomIDEnum* x) { return io<uint32_t>::accum(s, o, reinterpret_cast<uint32_t*>(x)); }
-  };
-}}
+  typedef io<uint32_t>::async_read_state async_read_state;
+  static void prepare(async_read_state *o) { io<uint32_t>::prepare(o); }
+  static bool accum(int s, async_read_state *o, CustomIDEnum *x) {
+    return io<uint32_t>::accum(s, o, reinterpret_cast<uint32_t *>(x));
+  }
+};
+} // namespace net
+} // namespace hobbes
 
 using rgb_t = int[3];
-DEFINE_STRUCT(
-  RGB,
-  (rgb_t, val)
-);
+DEFINE_STRUCT(RGB, (rgb_t, val));
 
 /**************************
  * the synchronous client networking API
  **************************/
 DEFINE_NET_CLIENT(
-  SyncClient,
-  (add,     int(int,int),                   "\\x y.x+y"),
-  (doit,    std::string(),                  "\\().\"missiles launched\""),
-  (misc,    NameCounts(std::string,size_t), "\\n c.[(n++\"_\"++show(i), i) | i <- [0L..c]]"),
-  (grpv,    V(Group),                       "\\_.|Frank=\"frank\"|"),
-  (nothing, V(),                            "\\_.|Nothing=()|"),
-  (recover, Groups(int,int),                "\\i e.[{id=\"group_\"++show(k),kid=|Jim|,aa=convert(k),bb=convert(k)}|k<-[i..e]]"),
-  (eidv,    CustomIDEnum(CustomIDEnum),     "id"),
-  (inverse, RGB(RGB),                       "\\x.do{saelem(x.val,0L)<-255-saelem(x.val,0L);saelem(x.val,1L)<-255-saelem(x.val,1L);saelem(x.val,2L)<-255-saelem(x.val,2L); return x}")
-);
+    SyncClient, (add, int(int, int), "\\x y.x+y"),
+    (doit, std::string(), "\\().\"missiles launched\""),
+    (misc, NameCounts(std::string, size_t),
+     "\\n c.[(n++\"_\"++show(i), i) | i <- [0L..c]]"),
+    (grpv, V(Group), "\\_.|Frank=\"frank\"|"),
+    (nothing, V(), "\\_.|Nothing=()|"),
+    (recover, Groups(int, int),
+     "\\i "
+     "e.[{id=\"group_\"++show(k),kid=|Jim|,aa=convert(k),bb=convert(k)}|k<-[i.."
+     "e]]"),
+    (eidv, CustomIDEnum(CustomIDEnum), "id"),
+    (inverse, RGB(RGB),
+     "\\x.do{saelem(x.val,0L)<-255-saelem(x.val,0L);saelem(x.val,1L)<-255-"
+     "saelem(x.val,1L);saelem(x.val,2L)<-255-saelem(x.val,2L); return x}"));
 
 TEST(Net, syncClientAPI) {
   SyncClient c("localhost", testServerPort());
-  EXPECT_EQ(c.add(1,2), 3);
+  EXPECT_EQ(c.add(1, 2), 3);
   EXPECT_EQ(c.doit(), "missiles launched");
-  EXPECT_EQ(c.misc("foo", 5), list(NC("foo_0",0),NC("foo_1",1),NC("foo_2",2),NC("foo_3",3),NC("foo_4",4),NC("foo_5",5)));
+  EXPECT_EQ(c.misc("foo", 5),
+            list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2), NC("foo_3", 3),
+                 NC("foo_4", 4), NC("foo_5", 5)));
 
-  Group grp = { "id", Kid::Jim(), 4.2, 42 };
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
   EXPECT_EQ(grp, grp);
   for (size_t i = 0; i < 10; ++i) {
     EXPECT_EQ(c.grpv(grp), V::Frank("frank"));
   }
   EXPECT_EQ(c.nothing(), V::Nothing(hobbes::unit()));
 
-  Groups ros = { {"group_0",Kid::Jim(),0.0,0},{"group_1",Kid::Jim(),1.0,1},{"group_2",Kid::Jim(),2.0,2},{"group_3",Kid::Jim(),3.0,3},{"group_4",Kid::Jim(),4.0,4} };
-  EXPECT_EQ(c.recover(0,4), ros);
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  EXPECT_EQ(c.recover(0, 4), ros);
 
   EXPECT_EQ(c.eidv(CustomIDEnum::Green), CustomIDEnum::Green);
 
-  auto inv = c.inverse(RGB{{0,255,0}});
-  EXPECT_EQ(std::vector<int>(inv.val,inv.val+3), std::vector<int>({255,0,255}));
+  auto inv = c.inverse(RGB{{0, 255, 0}});
+  EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+            std::vector<int>({255, 0, 255}));
 }
 
+TEST(Net, syncClientAPIWithConfiguredHostName) {
+  SyncClient c("localhost", testServerWithHostPort("localhost"));
+  EXPECT_EQ(c.add(1, 2), 3);
+  EXPECT_EQ(c.doit(), "missiles launched");
+  EXPECT_EQ(c.misc("foo", 5),
+            list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2), NC("foo_3", 3),
+                 NC("foo_4", 4), NC("foo_5", 5)));
+
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
+  EXPECT_EQ(grp, grp);
+  for (size_t i = 0; i < 10; ++i) {
+    EXPECT_EQ(c.grpv(grp), V::Frank("frank"));
+  }
+  EXPECT_EQ(c.nothing(), V::Nothing(hobbes::unit()));
+
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  EXPECT_EQ(c.recover(0, 4), ros);
+
+  EXPECT_EQ(c.eidv(CustomIDEnum::Green), CustomIDEnum::Green);
+
+  auto inv = c.inverse(RGB{{0, 255, 0}});
+  EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+            std::vector<int>({255, 0, 255}));
+}
+
+TEST(Net, syncClientAPIWithUnConfiguredHostName) {
+  SyncClient c("localhost", testServerWithHostPort());
+  EXPECT_EQ(c.add(1, 2), 3);
+  EXPECT_EQ(c.doit(), "missiles launched");
+  EXPECT_EQ(c.misc("foo", 5),
+            list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2), NC("foo_3", 3),
+                 NC("foo_4", 4), NC("foo_5", 5)));
+
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
+  EXPECT_EQ(grp, grp);
+  for (size_t i = 0; i < 10; ++i) {
+    EXPECT_EQ(c.grpv(grp), V::Frank("frank"));
+  }
+  EXPECT_EQ(c.nothing(), V::Nothing(hobbes::unit()));
+
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  EXPECT_EQ(c.recover(0, 4), ros);
+
+  EXPECT_EQ(c.eidv(CustomIDEnum::Green), CustomIDEnum::Green);
+
+  auto inv = c.inverse(RGB{{0, 255, 0}});
+  EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+            std::vector<int>({255, 0, 255}));
+}
 /**************************
  * the asynchronous client networking API
  **************************/
 DEFINE_ASYNC_NET_CLIENT(
-  AsyncClient,
-  (add,     int(int,int),                   "\\x y.x+y"),
-  (doit,    std::string(),                  "\\().\"missiles launched\""),
-  (misc,    NameCounts(std::string,size_t), "\\n c.[(n++\"_\"++show(i), i) | i <- [0L..c]]"),
-  (grpv,    V(Group),                       "\\_.|Frank=\"frank\"|"),
-  (nothing, V(),                            "\\().|Nothing=()|"),
-  (recover, Groups(int,int),                "\\i e.[{id=\"group_\"++show(k),kid=|Jim|,aa=convert(k),bb=convert(k)}|k<-[i..e]]"),
-  (eidv,    CustomIDEnum(CustomIDEnum),     "id"),
-  (inverse, RGB(RGB),                       "\\x.do{saelem(x.val,0L)<-255-saelem(x.val,0L);saelem(x.val,1L)<-255-saelem(x.val,1L);saelem(x.val,2L)<-255-saelem(x.val,2L); return x}")
-);
-void stepAsyncClient(int, void* p) { reinterpret_cast<AsyncClient*>(p)->step(); }
+    AsyncClient, (add, int(int, int), "\\x y.x+y"),
+    (doit, std::string(), "\\().\"missiles launched\""),
+    (misc, NameCounts(std::string, size_t),
+     "\\n c.[(n++\"_\"++show(i), i) | i <- [0L..c]]"),
+    (grpv, V(Group), "\\_.|Frank=\"frank\"|"),
+    (nothing, V(), "\\().|Nothing=()|"),
+    (recover, Groups(int, int),
+     "\\i "
+     "e.[{id=\"group_\"++show(k),kid=|Jim|,aa=convert(k),bb=convert(k)}|k<-[i.."
+     "e]]"),
+    (eidv, CustomIDEnum(CustomIDEnum), "id"),
+    (inverse, RGB(RGB),
+     "\\x.do{saelem(x.val,0L)<-255-saelem(x.val,0L);saelem(x.val,1L)<-255-"
+     "saelem(x.val,1L);saelem(x.val,2L)<-255-saelem(x.val,2L); return x}"));
+void stepAsyncClient(int, void *p) {
+  reinterpret_cast<AsyncClient *>(p)->step();
+}
 
 TEST(Net, asyncClientAPI) {
   AsyncClient c("127.0.0.1", "127.0.0.1", testServerPort());
-  c.add(1,2, [](int r) { EXPECT_EQ(r, 3); });
-  c.doit([](const std::string& r) { EXPECT_EQ(r, "missiles launched") });
-  c.misc("foo", 5, [](const NameCounts& ncs) { EXPECT_EQ(ncs, list(NC("foo_0",0),NC("foo_1",1),NC("foo_2",2),NC("foo_3",3),NC("foo_4",4),NC("foo_5",5))); });
+  c.add(1, 2, [](int r) { EXPECT_EQ(r, 3); });
+  c.doit([](const std::string &r) { EXPECT_EQ(r, "missiles launched") });
+  c.misc("foo", 5, [](const NameCounts &ncs) {
+    EXPECT_EQ(ncs, list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2),
+                        NC("foo_3", 3), NC("foo_4", 4), NC("foo_5", 5)));
+  });
 
-  Group grp = { "id", Kid::Jim(), 4.2, 42 };
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
   for (size_t i = 0; i < 1000; ++i) {
-    c.grpv(grp, [](const V& r) { EXPECT_EQ(r, V::Frank("frank")); });
-    c.nothing([](const V& r  ) { EXPECT_EQ(r, V::Nothing(hobbes::unit())); });
+    c.grpv(grp, [](const V &r) { EXPECT_EQ(r, V::Frank("frank")); });
+    c.nothing([](const V &r) { EXPECT_EQ(r, V::Nothing(hobbes::unit())); });
   }
 
-  Groups ros = { {"group_0",Kid::Jim(),0.0,0},{"group_1",Kid::Jim(),1.0,1},{"group_2",Kid::Jim(),2.0,2},{"group_3",Kid::Jim(),3.0,3},{"group_4",Kid::Jim(),4.0,4} };
-  c.recover(0,4, [&](const Groups& r) { EXPECT_EQ(r, ros); });
-  
-  c.eidv(CustomIDEnum::Green, [](const CustomIDEnum& x) { EXPECT_EQ(x, CustomIDEnum::Green); });
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  c.recover(0, 4, [&](const Groups &r) { EXPECT_EQ(r, ros); });
+
+  c.eidv(CustomIDEnum::Green,
+         [](const CustomIDEnum &x) { EXPECT_EQ(x, CustomIDEnum::Green); });
 
-  c.inverse(RGB{{0,255,0}}, [](const RGB& inv) { EXPECT_EQ(std::vector<int>(inv.val,inv.val+3), std::vector<int>({255,0,255})); });
+  c.inverse(RGB{{0, 255, 0}}, [](const RGB &inv) {
+    EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+              std::vector<int>({255, 0, 255}));
+  });
 
-  // run a quick epoll loop to process results asynchronously (expect all results within 30 seconds)
+  // run a quick epoll loop to process results asynchronously (expect all
+  // results within 30 seconds)
   registerEventHandler(c.fd(), &stepAsyncClient, &c);
   for (size_t s = 0; s < 30 && c.pendingRequests() > 0; ++s) {
-    runEventLoop(1000*1000);
+    runEventLoop(1000 * 1000);
   }
   EXPECT_EQ(c.pendingRequests(), size_t(0));
 }
 
+TEST(Net, asyncClientAPIWithConfiguredHostName) {
+  AsyncClient c("127.0.0.1", "127.0.0.1", testServerWithHostPort("127.0.0.1"));
+  c.add(1, 2, [](int r) { EXPECT_EQ(r, 3); });
+  c.doit([](const std::string &r) { EXPECT_EQ(r, "missiles launched") });
+  c.misc("foo", 5, [](const NameCounts &ncs) {
+    EXPECT_EQ(ncs, list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2),
+                        NC("foo_3", 3), NC("foo_4", 4), NC("foo_5", 5)));
+  });
+
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
+  for (size_t i = 0; i < 1000; ++i) {
+    c.grpv(grp, [](const V &r) { EXPECT_EQ(r, V::Frank("frank")); });
+    c.nothing([](const V &r) { EXPECT_EQ(r, V::Nothing(hobbes::unit())); });
+  }
+
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  c.recover(0, 4, [&](const Groups &r) { EXPECT_EQ(r, ros); });
+
+  c.eidv(CustomIDEnum::Green,
+         [](const CustomIDEnum &x) { EXPECT_EQ(x, CustomIDEnum::Green); });
+
+  c.inverse(RGB{{0, 255, 0}}, [](const RGB &inv) {
+    EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+              std::vector<int>({255, 0, 255}));
+  });
+
+  // run a quick epoll loop to process results asynchronously (expect all
+  // results within 30 seconds)
+  registerEventHandler(c.fd(), &stepAsyncClient, &c);
+  for (size_t s = 0; s < 30 && c.pendingRequests() > 0; ++s) {
+    runEventLoop(1000 * 1000);
+  }
+  EXPECT_EQ(c.pendingRequests(), size_t(0));
+}
+
+TEST(Net, asyncClientAPIWithUnConfiguredHostName) {
+  AsyncClient c("127.0.0.1", "127.0.0.1", testServerWithHostPort());
+  c.add(1, 2, [](int r) { EXPECT_EQ(r, 3); });
+  c.doit([](const std::string &r) { EXPECT_EQ(r, "missiles launched") });
+  c.misc("foo", 5, [](const NameCounts &ncs) {
+    EXPECT_EQ(ncs, list(NC("foo_0", 0), NC("foo_1", 1), NC("foo_2", 2),
+                        NC("foo_3", 3), NC("foo_4", 4), NC("foo_5", 5)));
+  });
+
+  Group grp = {"id", Kid::Jim(), 4.2, 42};
+  for (size_t i = 0; i < 1000; ++i) {
+    c.grpv(grp, [](const V &r) { EXPECT_EQ(r, V::Frank("frank")); });
+    c.nothing([](const V &r) { EXPECT_EQ(r, V::Nothing(hobbes::unit())); });
+  }
+
+  Groups ros = {{"group_0", Kid::Jim(), 0.0, 0},
+                {"group_1", Kid::Jim(), 1.0, 1},
+                {"group_2", Kid::Jim(), 2.0, 2},
+                {"group_3", Kid::Jim(), 3.0, 3},
+                {"group_4", Kid::Jim(), 4.0, 4}};
+  c.recover(0, 4, [&](const Groups &r) { EXPECT_EQ(r, ros); });
+
+  c.eidv(CustomIDEnum::Green,
+         [](const CustomIDEnum &x) { EXPECT_EQ(x, CustomIDEnum::Green); });
+
+  c.inverse(RGB{{0, 255, 0}}, [](const RGB &inv) {
+    EXPECT_EQ(std::vector<int>(inv.val, inv.val + 3),
+              std::vector<int>({255, 0, 255}));
+  });
+
+  // run a quick epoll loop to process results asynchronously (expect all
+  // results within 30 seconds)
+  registerEventHandler(c.fd(), &stepAsyncClient, &c);
+  for (size_t s = 0; s < 30 && c.pendingRequests() > 0; ++s) {
+    runEventLoop(1000 * 1000);
+  }
+  EXPECT_EQ(c.pendingRequests(), size_t(0));
+}

From 18850bcd787c849ec0d9c4c2c33d178c9726a0c1 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 16 Jun 2021 09:22:07 +0000
Subject: [PATCH 03/40] add language option "IgnoreUnreachableMatches" (#408)

---
 bin/hi/evaluator.C        | 18 +++++++++++++++++-
 include/hobbes/eval/cc.H  | 17 ++++++++++++++---
 lib/hobbes/eval/cc.C      |  9 +++++++--
 lib/hobbes/eval/cmodule.C |  5 +++++
 lib/hobbes/lang/module.C  |  2 +-
 lib/hobbes/lang/pat/dfa.C | 19 ++++++-------------
 test/Main.C               |  4 ++--
 test/Matching.C           | 23 +++++++++++++++--------
 8 files changed, 67 insertions(+), 30 deletions(-)

diff --git a/bin/hi/evaluator.C b/bin/hi/evaluator.C
index 308ececee..6d944187d 100644
--- a/bin/hi/evaluator.C
+++ b/bin/hi/evaluator.C
@@ -12,6 +12,12 @@
 #include <hobbes/util/time.H>
 #include <iostream>
 
+namespace {
+void defPrintUnreachableMatches(const hobbes::cc::UnreachableMatches& m) {
+  std::cout << "warning: " << m.la.filename() << ':' << m.la.lineDesc() << "    " << m.lines << std::endl;
+}
+} // namespace
+
 namespace hi {
 
 // allocate a string in global memory
@@ -65,11 +71,17 @@ evaluator::evaluator(const Args& args) : silent(args.silent), wwwd(0), opts(args
   bindArguments(this->ctx, args.scriptNameVals);
   bindHiDefs(this->ctx);
 
+  const bool ignoreUM = (std::find(opts.cbegin(), opts.cend(), std::string("IgnoreUnreachableMatches")) != opts.cend());
+  this->ctx.ignoreUnreachableMatches(ignoreUM);
+  if (ignoreUM) {
+    this->ctx.setGatherUnreachableMatchesFn(defPrintUnreachableMatches);
+  }
+
   // start alternate input services if necessary
   if (args.replPort > 0) {
     installNetREPL(args.replPort, &this->ctx, [this](ExprPtr const& e) -> ExprPtr { return hobbes::translateExprWithOpts(this->opts, e); });
   }
-  
+
   if (args.httpdPort > 0) {
     // run a local web server (for diagnostics and alternate queries) if requested
     this->wwwd = new WWWServer(args.httpdPort, &this->ctx);
@@ -314,6 +326,10 @@ void evaluator::searchDefs(const std::string& expr_to_type) {
 
 void evaluator::setOption(const std::string& o) {
   this->opts.push_back(o);
+  if (o == "IgnoreUnreachableMatches") {
+    this->ctx.ignoreUnreachableMatches(true);
+    this->ctx.setGatherUnreachableMatchesFn(defPrintUnreachableMatches);
+  }
 }
 
 hobbes::ExprPtr evaluator::readExpr(const std::string& x) {
diff --git a/include/hobbes/eval/cc.H b/include/hobbes/eval/cc.H
index b786142ea..1982f9946 100644
--- a/include/hobbes/eval/cc.H
+++ b/include/hobbes/eval/cc.H
@@ -101,6 +101,14 @@ public:
   MonoTypePtr readMonoType(const std::string&);
   void setReadExprFn(readExprFn);
 
+  struct UnreachableMatches {
+    LexicalAnnotation la;
+    std::string lines;
+  };
+  typedef void (*gatherUnreachableMatchesFn)(const UnreachableMatches&);
+  void gatherUnreachableMatches(const UnreachableMatches& m);
+  void setGatherUnreachableMatchesFn(gatherUnreachableMatchesFn f);
+
   // search for paths from one type to another
   // (currently just one-step paths, may be useful to consider multi-step paths)
   SearchEntries search(const MonoTypePtr&, const MonoTypePtr&);
@@ -113,6 +121,9 @@ private:
   readModuleFn     readModuleF;
   readExprDefnFn   readExprDefnF;
   readExprFn       readExprF;
+
+  gatherUnreachableMatchesFn gatherUnreachableMatchesF = [](const UnreachableMatches&){};
+
 public:
   // type-safe compilation to C++ function pointers
   template <typename RFn, typename ... NamesAndExpr>
@@ -250,6 +261,8 @@ public:
   bool buildInterpretedMatches() const;
   void requireMatchReachability(bool f);
   bool requireMatchReachability() const;
+  void ignoreUnreachableMatches(bool f);
+  bool ignoreUnreachableMatches() const;
   void alwaysLowerPrimMatchTables(bool);
   bool alwaysLowerPrimMatchTables() const;
   void buildColumnwiseMatches(bool f);
@@ -261,9 +274,6 @@ public:
   void regexDFAOverNFAMaxRatio(int f);
   int  regexDFAOverNFAMaxRatio() const;
 
-  // allow caller to gather a vector of unreachable rows arising from match compilation
-  UnreachableMatchRowsPtr unreachableMatchRowsPtr;
-
   // allow low-level functions to be added
   void bindLLFunc(const std::string&, op*);
 
@@ -290,6 +300,7 @@ private:
   bool runModInlinePass;
   bool genInterpretedMatch;
   bool checkMatchReachability;
+  bool ignoreUnreachablePatternMatchRows = false;
   bool lowerPrimMatchTables;
   bool columnwiseMatches;
   size_t maxExprDFASize={1000};
diff --git a/lib/hobbes/eval/cc.C b/lib/hobbes/eval/cc.C
index 126c83099..03a736179 100644
--- a/lib/hobbes/eval/cc.C
+++ b/lib/hobbes/eval/cc.C
@@ -44,7 +44,6 @@ cc::cc() :
   readExprDefnF(&defReadExprDefn),
   readExprF(&defReadExpr),
   drainingDefs(false),
-  unreachableMatchRowsPtr(nullptr),
   runModInlinePass(true),
   genInterpretedMatch(false),
   checkMatchReachability(true),
@@ -165,6 +164,9 @@ MonoTypePtr cc::readMonoType(const std::string& x) {
   }
 }
 
+void cc::gatherUnreachableMatches(const UnreachableMatches& m) { hlock _; this->gatherUnreachableMatchesF(m); }
+void cc::setGatherUnreachableMatchesFn(gatherUnreachableMatchesFn f) { this->gatherUnreachableMatchesF = f; }
+
 ExprPtr cc::unsweetenExpression(const TEnvPtr& te, const ExprPtr& e) {
   return unsweetenExpression(te, "", e);
 }
@@ -655,6 +657,9 @@ bool cc::buildInterpretedMatches() const { return this->genInterpretedMatch; }
 void cc::requireMatchReachability(bool f) { this->checkMatchReachability = f; }
 bool cc::requireMatchReachability() const { return this->checkMatchReachability; }
 
+void cc::ignoreUnreachableMatches(bool f) { this->ignoreUnreachablePatternMatchRows = f; }
+bool cc::ignoreUnreachableMatches() const { return this->ignoreUnreachablePatternMatchRows; }
+
 void cc::alwaysLowerPrimMatchTables(bool f) { this->lowerPrimMatchTables = f; }
 bool cc::alwaysLowerPrimMatchTables() const { return this->lowerPrimMatchTables; }
 
@@ -663,7 +668,7 @@ bool cc::buildColumnwiseMatches() const { return this->columnwiseMatches; }
 
 void cc::regexMaxExprDFASize(size_t f) { this->maxExprDFASize = f; }
 size_t cc::regexMaxExprDFASize() const { return this->maxExprDFASize; }
-  
+
 void cc::throwOnHugeRegexDFA(bool f) { this->shouldThrowOnHugeRegexDFA = f; }
 bool cc::throwOnHugeRegexDFA() const { return this-> shouldThrowOnHugeRegexDFA; }
 
diff --git a/lib/hobbes/eval/cmodule.C b/lib/hobbes/eval/cmodule.C
index 368decb38..47f879e0e 100644
--- a/lib/hobbes/eval/cmodule.C
+++ b/lib/hobbes/eval/cmodule.C
@@ -1003,6 +1003,7 @@ OptDescs getAllOptions() {
   d["SafeArrays"] =
       "Interpret array indexing 'safely' (always bounds-checked and mapped to "
       "an optional type in case of out-of-bounds access)";
+  d["IgnoreUnreachableMatches"] = "Ignore unreachable pattern match rows";
   return d;
 }
 
@@ -1029,6 +1030,10 @@ ExprPtr translateExprWithOpts(
            [](std::string const &, const ExprPtr &e) -> ExprPtr {
              return switchOf(e, makeSafeArrays());
            }},
+          {"IgnoreUnreachableMatches",
+           [](std::string const &, const ExprPtr &e) -> ExprPtr {
+             return e;
+           }},
       };
   thread_local auto ignoreFn = [](std::string const &optName,
                                   const ExprPtr &e) -> ExprPtr {
diff --git a/lib/hobbes/lang/module.C b/lib/hobbes/lang/module.C
index 1fa80d4b1..61476b017 100644
--- a/lib/hobbes/lang/module.C
+++ b/lib/hobbes/lang/module.C
@@ -20,7 +20,7 @@ void Module::show(std::ostream& out) const {
 }
 
 bool isValidOption(const std::string& o) {
-  return o == "Safe" || o == "SafeArrays";
+  return o == "Safe" || o == "SafeArrays" || o == "IgnoreUnreachableMatches";
 }
 
 void Module::setOption(const std::string& o, const LexicalAnnotation& la) {
diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index d157ff832..5a18ae133 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -1133,29 +1133,22 @@ stateidx_t makeDFA(MDFA* dfa, const PatternRows& ps, const LexicalAnnotation& la
     std::vector<size_t> unreachableRows;
     for (size_t r = 0; r < ps.size(); ++r) {
       size_t fs = finalStates[r];
- 
+
       if (dfa->states[fs]->refs == 0) {
         unreachableRows.push_back(r);
       }
     }
-  
+
     if (unreachableRows.size() > 0) {
       std::ostringstream fss;
       fss << "Unreachable row" << (unreachableRows.size() > 1 ? "s" : "") << " in match expression:\n";
       for (size_t ur : unreachableRows) {
         fss << "  " << show(ps[ur]) << std::endl;
       }
-      throw annotated_error(la, fss.str());
-    }
-  }
-
-  // save unreachable rows for the caller instead of raising an error
-  if (dfa->c->unreachableMatchRowsPtr) {
-    for (size_t r = 0; r < ps.size(); ++r) {
-      size_t fs = finalStates[r];
-
-      if (dfa->states[fs]->refs == 0) {
-        dfa->c->unreachableMatchRowsPtr->push_back(std::make_pair(r, ps[r]));
+      if (dfa->c->ignoreUnreachableMatches()) {
+        dfa->c->gatherUnreachableMatches({.la = la, .lines = fss.str()});
+      } else {
+        throw annotated_error(la, fss.str());
       }
     }
   }
diff --git a/test/Main.C b/test/Main.C
index b6bf3177f..15b37ea50 100644
--- a/test/Main.C
+++ b/test/Main.C
@@ -75,7 +75,7 @@ int TestCoord::runTestGroups(const Args& args) {
   std::cout << "---------------------------------------------------------------------" << std::endl
             << hobbes::describeNanoTime(hobbes::tick()-tt0) << std::endl;
 
-  if (failures.size() > 0) {
+  if (!failures.empty()) {
     std::cout << "\n\nFAILURE" << (failures.size() == 1 ? "" : "S") << ":" << std::endl
               << "---------------------------------------------------------------------" << std::endl;
     for (const auto& failure : failures) {
@@ -83,7 +83,7 @@ int TestCoord::runTestGroups(const Args& args) {
     }
   }
 
-  if (auto path = args.report) {
+  if (const auto* path = args.report) {
     std::ofstream outfile(path, std::ios::out | std::ios::trunc);
     if (outfile) {
       outfile << toJSON();
diff --git a/test/Matching.C b/test/Matching.C
index 8a3e785a0..e3e9bfc8f 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -136,6 +136,11 @@ TEST(Matching, Regex) {
   }
   EXPECT_TRUE(unreachableExn && "failed to determine expected unreachable regex row");
 
+  // verify unreachable rows should not cause error with IgnoreUnreachableMatches option on
+  c().ignoreUnreachableMatches(true);
+  EXPECT_EQ(c().compileFn<int()>("match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1")(), 0);
+  c().ignoreUnreachableMatches(false);
+
   // verify binding in regex matches
   EXPECT_EQ(makeStdString(c().compileFn<const array<char>*()>("match \"foobar\" with | 'f(?<os>o*)bar' -> os | _ -> \"???\"")()), "oo");
 
@@ -163,7 +168,7 @@ TEST(Matching, Tests) {
   // make sure that tests with inaccessible names are rejected
   EXPECT_EXCEPTION(c().compileFn<bool()>("\"JIMMY\" matches JIMMY")());
   EXPECT_EXCEPTION(c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=JIMMY|}]")());
-  
+
   // make sure that tests with inaccessible _ names are allowed
   EXPECT_TRUE(c().compileFn<bool()>("\"JIMMY\" matches _")());
   EXPECT_TRUE(c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=_|}]")());
@@ -196,7 +201,7 @@ TEST(Matching, matchFromStringToBoolIsBool) {
     "| _ _ _ _                 -> false"
   )();
   EXPECT_TRUE(1 == *reinterpret_cast<uint8_t*>(&r));
-  EXPECT_TRUE(r);  
+  EXPECT_TRUE(r);
 }
 #endif
 
@@ -210,7 +215,7 @@ TEST(Matching, matchFromIntToBoolIsBool) {
     "| _ _ _ _ -> false"
   );
   EXPECT_TRUE(1 == *reinterpret_cast<uint8_t*>(&r));
-  EXPECT_TRUE(r);  
+  EXPECT_TRUE(r);
 }
 
 TEST(Matching, matchFromStringToIntIsCorrect) {
@@ -223,7 +228,7 @@ TEST(Matching, matchFromStringToIntIsCorrect) {
     "| _ _ _ _                 -> 0"
   )();
   EXPECT_EQ(uint32_t(86), *reinterpret_cast<uint32_t*>(&r));
-  EXPECT_TRUE(r);  
+  EXPECT_TRUE(r);
 }
 
 TEST(Matching, largeRegexDFAFinishesReasonablyQuickly) {
@@ -266,9 +271,9 @@ TEST(Matching, noRaceInterpMatch) {
     "| _       -> 2"
   );
   size_t wrongMatches = 0;
-  std::vector<std::thread*> ps;
+  std::vector<std::thread> ps;
   for (size_t p = 0; p < 10; ++p) {
-    ps.push_back(new std::thread(([&]() {
+    ps.emplace_back([&]() {
       auto t0 = tick();
       while (wrongMatches == 0 && size_t(tick()-t0) < 1UL*1000*1000*1000) {
         if (f("foo") != 0) {
@@ -279,9 +284,11 @@ TEST(Matching, noRaceInterpMatch) {
         }
         hobbes::resetMemoryPool();
       }
-    })));
+    });
+  }
+  for (auto& p : ps) {
+    p.join();
   }
-  for (auto p : ps) { p->join(); delete p; }
   EXPECT_EQ(wrongMatches, size_t(0));
   c().buildInterpretedMatches(false);
 }

From 36ea90b4d26432629415e10b5d3e8bf184d759d1 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Sat, 19 Jun 2021 09:56:15 +0000
Subject: [PATCH 04/40] fix few typos in documentation (#405)

---
 doc/en/examples/simplerepl.rst   | 6 +++---
 doc/en/language/controlflow.rst  | 4 ++--
 doc/en/language/polymorphism.rst | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/en/examples/simplerepl.rst b/doc/en/examples/simplerepl.rst
index 21f540fce..d59b1cac6 100755
--- a/doc/en/examples/simplerepl.rst
+++ b/doc/en/examples/simplerepl.rst
@@ -25,7 +25,7 @@ Here's the full code listing. Afterwards we'll dig into all the parts one by one
   typedef std::pair<int, const hobbes::array<char>*> Writer;
 
   Writer* getWriter(){
-    return hobbes::make<Writer1>(34, hobbes::makeString("Sam"));
+    return hobbes::make<Writer>(34, hobbes::makeString("Sam"));
   }
 
   hobbes::array<Writer>* getWriters(){
@@ -123,7 +123,7 @@ Binding custom datatypes
     (const hobbes::array<char>*, name)
   );
 
-  typedef std::pair<int, const hobbes::array<char>*> Writer1;
+  typedef std::pair<int, const hobbes::array<char>*> Writer;
 
   Writer* getWriter(){
     return hobbes::make<Writer>(34, hobbes::makeString("Sam"));
@@ -186,7 +186,7 @@ Function pointers
     return pf(x, x);
   }
 
-The basic mechanism by which work is abstracted, and how we can externalise behaviour from Hobbes - allowing us to interact with Hobbes functionality from outside the environment. In this case we expect ``binaryIntFn`` to be called with two items - firstly, a function which takes two ``int``s and returns an ``int``, and secondly an ``int``.
+The basic mechanism by which work is abstracted, and how we can externalise behaviour from Hobbes - allowing us to interact with Hobbes functionality from outside the environment. In this case we expect ``binaryIntFn`` to be called with two items - firstly, a function which takes two ``int``\s and returns an ``int``, and secondly an ``int``.
 
 The result of the application of the function with the second argument twice is then returned to Hobbes as an ``int``.
 
diff --git a/doc/en/language/controlflow.rst b/doc/en/language/controlflow.rst
index d0b950404..c866c5764 100755
--- a/doc/en/language/controlflow.rst
+++ b/doc/en/language/controlflow.rst
@@ -138,7 +138,7 @@ This matching-and-binding logic can be generalised to arrays, too:
 ::
 
   match [("sam", 2013), ("james", 2012), ("stephen", 2010)] with
-  | [_ (n, 2012), _] -> show(n)
+  | [_, (n, 2012), _] -> show(n)
   | _ -> show("none")
 
 And, because of the way character arrays are matched, even to regular expressions:
@@ -367,4 +367,4 @@ Finally, let's wrap all that up with a match and a for comprehension:
 ::
 
   > let start=1; end=4 in match [i | i <- [start..end], i % 2 == 0] with | [2, 4] -> "evens" | _ -> "odds"
-  evens
\ No newline at end of file
+  evens
diff --git a/doc/en/language/polymorphism.rst b/doc/en/language/polymorphism.rst
index 54f221861..4f8ae0ba4 100755
--- a/doc/en/language/polymorphism.rst
+++ b/doc/en/language/polymorphism.rst
@@ -42,7 +42,7 @@ The types of the variables are left out, yet Hobbes will quite happily figure ou
 
   Hobbes has simply inferred this about those types from the context in which they're used. This is in stark contrast to languates where types are restricted on what interfaces they implement. 
 
-Many other type classes are available in the :ref:`Hobbes standard library <standard_library>`. We've already seen an implementation of the equivalence typeclass ``equiv``. Others include ``multiply`` (applied to types which have a ``*``) and ``print`` (for types whose values can be printed).
+Many other type classes are available in the :ref:`Hobbes standard library <standard_library>`. We've already seen an implementation of the equivalence typeclass ``Equiv``. Others include ``Multiply`` (applied to types which have a ``*``) and ``Print`` (for types whose values can be printed).
 
 .. _type_annotations:
 
@@ -120,4 +120,4 @@ We can take this one step further:
 
 Remember that, in our lambda syntax, this can be read as "A function which takes x and returns x.Name" - i.e. the only thing we know about the type of x is that it has a member called Name. Hi will then give names to those two as-yet unnamed types: it calls them 'a' and 'b'.
 
-Note that Hobbes has inferred the type restriction on b: It's whatever type the value of "a.Name" is. This function will work for *any* type that has a member called ``Name``, which can be of any type!
\ No newline at end of file
+Note that Hobbes has inferred the type restriction on b: It's whatever type the value of "a.Name" is. This function will work for *any* type that has a member called ``Name``, which can be of any type!

From 9bd8b61560bd08a45c0f2fca1b3ca4598c5f7638 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 24 Jun 2021 03:26:32 +0000
Subject: [PATCH 05/40] fix missing nix logs when build fail (#409)

---
 .github/workflows/build.yml | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 49b9e7fbc..2cea80578 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -20,8 +20,12 @@ jobs:
       - name: nix build hobbesPackages/clang-${{ matrix.clang }}/hobbes
         run: |
           nix build .#hobbesPackages/clang-${{ matrix.clang }}/hobbes
+      - name: nix log hobbesPackages/clang-${{ matrix.clang }}/hobbes
+        if: ${{ always() }}
+        run: |
           nix log  .#hobbesPackages/clang-${{ matrix.clang }}/hobbes &> ${{ matrix.os }}-clang-${{ matrix.clang }}-hobbes.log
       - name: upload log ${{ matrix.os }}-clang-${{ matrix.clang }}-hobbes.log
+        if: ${{ always() }}
         uses: actions/upload-artifact@v1
         with:
           name: output-log-file
@@ -43,11 +47,15 @@ jobs:
           install_url: https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20201221_9fab14a/install
           extra_nix_config: |
             experimental-features = nix-command flakes ca-references
-      - name: nix build hobbesPackages/clang-${{ matrix.clang }}/hobbes
+      - name: nix build hobbesPackages/gcc-${{ matrix.gcc }}/llvm-${{ matrix.llvm }}/hobbes
         run: |
           nix build .#hobbesPackages/gcc-${{ matrix.gcc }}/llvm-${{ matrix.llvm }}/hobbes
+      - name: nix log hobbesPackages/gcc-${{ matrix.gcc }}/llvm-${{ matrix.llvm }}/hobbes
+        if: ${{ always() }}
+        run: |
           nix log  .#hobbesPackages/gcc-${{ matrix.gcc }}/llvm-${{ matrix.llvm }}/hobbes &> ${{ matrix.os }}-gcc-${{ matrix.gcc }}-llvm-${{ matrix.llvm }}-hobbes.log
       - name: upload log ${{ matrix.os }}-gcc-${{ matrix.gcc }}-llvm-${{ matrix.llvm }}-hobbes.log
+        if: ${{ always() }}
         uses: actions/upload-artifact@v1
         with:
           name: output-log-file

From ba35780ffe0025342c7a5025ab8d275db83060a8 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 24 Jun 2021 05:28:48 +0000
Subject: [PATCH 06/40] Fixes #406 memory leak in varies addEliminator calls
 (#407)

---
 include/hobbes/ipc/process.H          |  3 ++-
 include/hobbes/lang/preds/appendsto.H |  6 ++++--
 include/hobbes/lang/preds/hasctor.H   |  6 ++++--
 include/hobbes/lang/preds/hasfield.H  |  5 +++--
 include/hobbes/lang/preds/subtype.H   |  6 +++---
 lib/hobbes/db/bindings.C              |  2 +-
 lib/hobbes/db/signals.C               |  2 +-
 lib/hobbes/eval/cc.C                  |  2 +-
 lib/hobbes/ipc/process.C              |  7 ++++---
 lib/hobbes/lang/preds/appendsto.C     |  6 +++---
 lib/hobbes/lang/preds/hasctor.C       | 10 ++++++----
 lib/hobbes/lang/preds/hasfield.C      | 19 +++++++++----------
 lib/hobbes/lang/preds/subtype.C       |  4 ++--
 13 files changed, 43 insertions(+), 35 deletions(-)

diff --git a/include/hobbes/ipc/process.H b/include/hobbes/ipc/process.H
index 0fe22a3cc..e7cb621ac 100644
--- a/include/hobbes/ipc/process.H
+++ b/include/hobbes/ipc/process.H
@@ -5,6 +5,7 @@
 #include <hobbes/lang/tyunqualify.H>
 #include <hobbes/ipc/procman.H>
 #include <string>
+#include <memory>
 
 namespace hobbes {
 
@@ -25,7 +26,7 @@ public:
   SymSet      bindings ()                                                                const;
   FunDeps     dependencies(const ConstraintPtr&)                                         const;
 private:
-  ProcManager procman;
+  std::shared_ptr<ProcManager> procman{std::make_shared<ProcManager>()};
 };
 
 }
diff --git a/include/hobbes/lang/preds/appendsto.H b/include/hobbes/lang/preds/appendsto.H
index 88879eb69..3fe8780c9 100644
--- a/include/hobbes/lang/preds/appendsto.H
+++ b/include/hobbes/lang/preds/appendsto.H
@@ -21,6 +21,8 @@ bool dec(const ConstraintPtr&, AppendsTo*);
 
 // an "appendsto eliminator" knows how to resolve an "AppendsTo" constraint at a particular (category of) type
 struct ATEliminator {
+  virtual ~ATEliminator() = default;
+
   // is this AT instance eliminable?
   virtual bool satisfied(const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs, const MonoTypePtr& result) const = 0;
 
@@ -45,7 +47,7 @@ public:
   static std::string constraintName();
 
   // extend the set of 'appendsto' eliminators dynamically (dangerous?)
-  void addEliminator(ATEliminator*);
+  void addEliminator(const std::shared_ptr<ATEliminator>&);
 
   // unqualifier interface
   bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
@@ -57,7 +59,7 @@ public:
   SymSet      bindings ()                                                                  const;
   FunDeps     dependencies(const ConstraintPtr&)                                           const;
 private:
-  typedef std::vector<ATEliminator*> ATEliminators;
+  using ATEliminators = std::vector<std::shared_ptr<ATEliminator>>;
   ATEliminators eliminators;
 
   ATEliminator* findEliminator(const TEnvPtr&, const AppendsTo*) const;
diff --git a/include/hobbes/lang/preds/hasctor.H b/include/hobbes/lang/preds/hasctor.H
index 6b9caf719..8660c4b4f 100644
--- a/include/hobbes/lang/preds/hasctor.H
+++ b/include/hobbes/lang/preds/hasctor.H
@@ -14,6 +14,8 @@ struct HasCtor {
 
 // a "has-ctor eliminator" knows how to resolve a "HasCtor" constraint at a particular (category of) type
 struct HCEliminator {
+  virtual ~HCEliminator() = default;
+
   // is this HC instance eliminable?
   virtual bool satisfied(const TEnvPtr& tenv, const HasCtor&, Definitions*) const = 0;
 
@@ -37,7 +39,7 @@ public:
   static std::string constraintName();
 
   // extend the set of 'hasctor' eliminators dynamically (dangerous?)
-  void addEliminator(HCEliminator*);
+  void addEliminator(const std::shared_ptr<HCEliminator>&);
 
   // unqualifier interface
   bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
@@ -49,7 +51,7 @@ public:
   SymSet      bindings ()                                                                  const;
   FunDeps     dependencies(const ConstraintPtr&)                                           const;
 private:
-  typedef std::vector<HCEliminator*> HCEliminators;
+  using HCEliminators = std::vector<std::shared_ptr<HCEliminator>>;
   HCEliminators eliminators;
   HCEliminator* findEliminator(const TEnvPtr&, const HasCtor&, Definitions*) const;
 
diff --git a/include/hobbes/lang/preds/hasfield.H b/include/hobbes/lang/preds/hasfield.H
index 5492b366a..a474b4c2b 100644
--- a/include/hobbes/lang/preds/hasfield.H
+++ b/include/hobbes/lang/preds/hasfield.H
@@ -3,6 +3,7 @@
 #define HOBBES_LANG_TYPEPREDS_HASFIELD_HPP_INCLUDED
 
 #include <hobbes/lang/tyunqualify.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -56,7 +57,7 @@ public:
   static std::string constraintName();
 
   // extend the set of 'hasfield' eliminators dynamically (dangerous?)
-  void addEliminator(HFEliminator*);
+  void addEliminator(const std::shared_ptr<HFEliminator>&);
 
   // unqualifier interface
   bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
@@ -68,7 +69,7 @@ public:
   SymSet      bindings ()                                                                  const;
   FunDeps     dependencies(const ConstraintPtr&)                                           const;
 private:
-  typedef std::vector<HFEliminator*> HFEliminators;
+  using HFEliminators = std::vector<std::shared_ptr<HFEliminator>>;
   HFEliminators eliminators;
 };
 
diff --git a/include/hobbes/lang/preds/subtype.H b/include/hobbes/lang/preds/subtype.H
index 80586f386..8b5d431d0 100644
--- a/include/hobbes/lang/preds/subtype.H
+++ b/include/hobbes/lang/preds/subtype.H
@@ -15,7 +15,7 @@ bool dec(const ConstraintPtr&, Subtype*);
 
 // a "subtype eliminator" knows how to resolve a "Subtype" constraint at a particular (category of) type
 struct SubtypeEliminator {
-   virtual ~SubtypeEliminator(void) = default;
+  virtual ~SubtypeEliminator() = default;
   // is this instance eliminable?
   virtual bool satisfied(const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs) const = 0;
 
@@ -40,7 +40,7 @@ public:
   static std::string constraintName();
 
   // extend the set of 'subtype' eliminators dynamically (dangerous?)
-  void addEliminator(SubtypeEliminator*);
+  void addEliminator(const std::shared_ptr<SubtypeEliminator>&);
 
   // unqualifier interface
   bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
@@ -52,7 +52,7 @@ public:
   SymSet      bindings ()                                                                  const;
   FunDeps     dependencies(const ConstraintPtr&)                                           const;
 private:
-  typedef std::vector<SubtypeEliminator*> SubtypeEliminators;
+  using SubtypeEliminators = std::vector<std::shared_ptr<SubtypeEliminator>>;
   SubtypeEliminators eliminators;
 
   SubtypeEliminator* findEliminator(const TEnvPtr&, const Subtype&) const;
diff --git a/lib/hobbes/db/bindings.C b/lib/hobbes/db/bindings.C
index 9ff40cef3..a66fe61b5 100644
--- a/lib/hobbes/db/bindings.C
+++ b/lib/hobbes/db/bindings.C
@@ -1106,7 +1106,7 @@ void initStorageFileDefs(FieldVerifier* fv, cc& c) {
   c.typeEnv()->bind("LoadFile", UnqualifierPtr(new LoadFileP()));
 
   // resolve references to values stored in files
-  fv->addEliminator(new DBFieldLookup());
+  fv->addEliminator(std::make_shared<DBFieldLookup>());
 
   // read/write top-level values out-of/into a storage file
   c.bindLLFunc(".DBVLoad",  new dbloadVF());
diff --git a/lib/hobbes/db/signals.C b/lib/hobbes/db/signals.C
index e02c2f562..7c2ccdb92 100644
--- a/lib/hobbes/db/signals.C
+++ b/lib/hobbes/db/signals.C
@@ -525,7 +525,7 @@ void initSignalsDefs(FieldVerifier* fv, cc& c) {
   // add signals for top-level file variables
   c.bind(".addFileSOSignal", &addFileSOSignal);
   c.bindLLFunc("signals", new signalsF());
-  fv->addEliminator(new AddDBFieldSignal());
+  fv->addEliminator(std::make_shared<AddDBFieldSignal>());
 
   c.bind(".addFileSignal", &addFileSignal);
   c.bindLLFunc("addFileSignal", new addFileSignalF());
diff --git a/lib/hobbes/eval/cc.C b/lib/hobbes/eval/cc.C
index 03a736179..3fc8de528 100644
--- a/lib/hobbes/eval/cc.C
+++ b/lib/hobbes/eval/cc.C
@@ -92,7 +92,7 @@ cc::cc() :
 
   // support subtype constraints (including safe upcasting between C++ objects)
   SubtypeUnqualifier* subuq = new SubtypeUnqualifier();
-  subuq->addEliminator(this->objs.get());
+  subuq->addEliminator(this->objs);
   this->tenv->bind(SubtypeUnqualifier::constraintName(), UnqualifierPtr(subuq));
 
   // support constraints on "field projection" (for records, "objects", ...)
diff --git a/lib/hobbes/ipc/process.C b/lib/hobbes/ipc/process.C
index a5113c81d..10dfd2e47 100644
--- a/lib/hobbes/ipc/process.C
+++ b/lib/hobbes/ipc/process.C
@@ -1,13 +1,14 @@
 #include <hobbes/ipc/process.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/lang/preds/class.H>
+#include <memory>
 
 namespace hobbes {
 
 #define PROCESS_SPAWN "spawn"
 
 ProcessP::ProcessP(FieldVerifier* fv) {
-  fv->addEliminator(&this->procman);
+  fv->addEliminator(this->procman);
 }
 
 static bool dec(const ConstraintPtr& c, MonoTypePtr* lhs, MonoTypePtr* rhs) {
@@ -29,7 +30,7 @@ bool ProcessP::refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier*
   MonoTypePtr cmdt, pidt;
   if (dec(cst, &cmdt, &pidt)) {
     if (const TString* cmd = is<TString>(cmdt)) {
-      mgu(pidt, mkPidTy(this->procman.spawnedPid(cmd->value())), u);
+      mgu(pidt, mkPidTy(this->procman->spawnedPid(cmd->value())), u);
     }
   }
   return uc != u->size();
@@ -40,7 +41,7 @@ bool ProcessP::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*)
   if (dec(cst, &cmdt, &pidt)) {
     if (const TString* cmd = is<TString>(cmdt)) {
       if (const TLong* pid = pidTy(pidt)) {
-        return this->procman.isSpawnedPid(cmd->value(), pid->value());
+        return this->procman->isSpawnedPid(cmd->value(), pid->value());
       }
     }
   }
diff --git a/lib/hobbes/lang/preds/appendsto.C b/lib/hobbes/lang/preds/appendsto.C
index 1ed7b52a6..8bab3e614 100644
--- a/lib/hobbes/lang/preds/appendsto.C
+++ b/lib/hobbes/lang/preds/appendsto.C
@@ -23,21 +23,21 @@ bool dec(const ConstraintPtr& c, AppendsTo* r) {
 }
 
 AppendsToUnqualifier::AppendsToUnqualifier() {
-  addEliminator(new ATRecordEliminator());
+  addEliminator(std::make_shared<ATRecordEliminator>());
 }
 
 std::string AppendsToUnqualifier::constraintName() {
   return "AppendsTo";
 }
 
-void AppendsToUnqualifier::addEliminator(ATEliminator* ate) {
+void AppendsToUnqualifier::addEliminator(const std::shared_ptr<ATEliminator>& ate) {
   this->eliminators.push_back(ate);
 }
 
 ATEliminator* AppendsToUnqualifier::findEliminator(const TEnvPtr& tenv, const AppendsTo* at) const {
   for (ATEliminators::const_iterator ate = this->eliminators.begin(); ate != this->eliminators.end(); ++ate) {
     if ((*ate)->satisfiable(tenv, at->leftType, at->rightType, at->resultType)) {
-      return *ate;
+      return ate->get();
     }
   }
   return 0;
diff --git a/lib/hobbes/lang/preds/hasctor.C b/lib/hobbes/lang/preds/hasctor.C
index 8a65eb351..f90272511 100644
--- a/lib/hobbes/lang/preds/hasctor.C
+++ b/lib/hobbes/lang/preds/hasctor.C
@@ -6,6 +6,8 @@
 
 #include <hobbes/lang/preds/hasctor/variant.H>
 
+#include <memory>
+
 namespace hobbes {
 
 #define MSELECT_CTOR_FN "maybeFromCtor"
@@ -14,21 +16,21 @@ namespace hobbes {
 // generic field verification and constraint removal
 /////////////////////////////////////////////////////
 CtorVerifier::CtorVerifier() {
-  this->eliminators.push_back(new HCVariantEliminator());
+  addEliminator(std::make_shared<HCVariantEliminator>());
 }
 
 std::string CtorVerifier::constraintName() {
   return "HasCtor";
 }
 
-void CtorVerifier::addEliminator(HCEliminator* hce) {
+void CtorVerifier::addEliminator(const std::shared_ptr<HCEliminator>& hce) {
   this->eliminators.push_back(hce);
 }
 
 HCEliminator* CtorVerifier::findEliminator(const TEnvPtr& tenv, const HasCtor& hc, Definitions* ds) const {
-  for (auto hce : this->eliminators) {
+  for (const auto& hce : this->eliminators) {
     if (hce->satisfiable(tenv, hc, ds)) {
-      return hce;
+      return hce.get();
     }
   }
   return 0;
diff --git a/lib/hobbes/lang/preds/hasfield.C b/lib/hobbes/lang/preds/hasfield.C
index 33fde9abd..1200e6346 100644
--- a/lib/hobbes/lang/preds/hasfield.C
+++ b/lib/hobbes/lang/preds/hasfield.C
@@ -53,13 +53,13 @@ std::string FieldVerifier::constraintName() {
 }
 
 FieldVerifier::FieldVerifier() {
-  this->eliminators.push_back(new HFRecordEliminator());
-  this->eliminators.push_back(new HFSLookupEliminator());
-  this->eliminators.push_back(new HFLookupEliminator());
-  this->eliminators.push_back(new HFTEnvLookupEliminator());
+  this->eliminators.push_back(std::make_shared<HFRecordEliminator>());
+  this->eliminators.push_back(std::make_shared<HFSLookupEliminator>());
+  this->eliminators.push_back(std::make_shared<HFLookupEliminator>());
+  this->eliminators.push_back(std::make_shared<HFTEnvLookupEliminator>());
 }
 
-void FieldVerifier::addEliminator(HFEliminator* hfe) {
+void FieldVerifier::addEliminator(const std::shared_ptr<HFEliminator>& hfe) {
   this->eliminators.push_back(hfe);
 
   // a hacky way to make sure that the TEnv eliminator is the last one considered, since it's kind of a catch-all
@@ -69,8 +69,7 @@ void FieldVerifier::addEliminator(HFEliminator* hfe) {
 bool FieldVerifier::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions* ds) {
   HasField hf;
   if (dec(cst, &hf)) {
-    for (size_t i = 0; i < this->eliminators.size(); ++i) {
-      auto hfe = this->eliminators[i];
+    for (const auto& hfe : this->eliminators) {
       try {
         if (hfe->satisfiable(tenv, hf, ds) && hfe->refine(tenv, hf, s, ds)) {
           return true;
@@ -85,7 +84,7 @@ bool FieldVerifier::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTy
 bool FieldVerifier::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   HasField hf;
   if (dec(cst, &hf)) {
-    for (auto hfe : this->eliminators) {
+    for (const auto& hfe : this->eliminators) {
       try {
         if (hfe->satisfied(tenv, hf, ds)) {
           return true;
@@ -99,7 +98,7 @@ bool FieldVerifier::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Def
 bool FieldVerifier::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   HasField hf;
   if (dec(cst, &hf)) {
-    for (auto hfe : this->eliminators) {
+    for (const auto& hfe : this->eliminators) {
       try {
         if (hfe->satisfiable(tenv, hf, ds)) {
           return true;
@@ -166,7 +165,7 @@ struct RewriteFnAccess : public switchExprTyFn {
 ExprPtr FieldVerifier::unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const {
   HasField hf;
   if (dec(cst, &hf)) {
-    for (auto hfe : this->eliminators) {
+    for (const auto& hfe : this->eliminators) {
       try {
         if (hfe->satisfied(tenv, hf, ds)) {
           return hfe->unqualify(tenv, cst, switchOf(e, RewriteFnAccess(hf, *hfe, tenv, ds, cst)), ds);
diff --git a/lib/hobbes/lang/preds/subtype.C b/lib/hobbes/lang/preds/subtype.C
index 4e07c7125..1ab6db72e 100644
--- a/lib/hobbes/lang/preds/subtype.C
+++ b/lib/hobbes/lang/preds/subtype.C
@@ -23,14 +23,14 @@ std::string SubtypeUnqualifier::constraintName() {
   return "Subtype";
 }
 
-void SubtypeUnqualifier::addEliminator(SubtypeEliminator* e) {
+void SubtypeUnqualifier::addEliminator(const std::shared_ptr<SubtypeEliminator>& e) {
   this->eliminators.push_back(e);
 }
 
 SubtypeEliminator* SubtypeUnqualifier::findEliminator(const TEnvPtr& tenv, const Subtype& st) const {
   for (SubtypeEliminators::const_iterator e = this->eliminators.begin(); e != this->eliminators.end(); ++e) {
     if ((*e)->satisfiable(tenv, st.lower, st.greater)) {
-      return *e;
+      return e->get();
     }
   }
   return 0;

From 76bc9e4a3965eb5e5376495c23fc8f929416e707 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 21 Jul 2021 16:41:29 +0000
Subject: [PATCH 07/40] make CMakeLists.txt work with user defined LLVM
 location (#411)

---
 CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bf24e5e55..00bde05dc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,7 +14,7 @@ find_package(Curses REQUIRED)
 include_directories(${CURSES_INCLUDE_DIRS})
 
 find_package(LLVM REQUIRED CONFIG)
-include_directories(${LLVM_INCLUDE_DIRS})
+include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
 
 if (${LLVM_PACKAGE_VERSION} VERSION_LESS "10.0")
@@ -29,7 +29,8 @@ else()
   set(jit_lib mcjit)
 endif()
 
-find_program(llvm-config llvm-config PATHS ${LLVM_TOOLS_BINARY_DIR})
+find_program(llvm-config llvm-config PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)
+find_program(llvm-config llvm-config)
 if (${LLVM_PACKAGE_VERSION} VERSION_LESS "4.0")
   execute_process(COMMAND ${llvm-config} --libs x86 ipo ${jit_lib}
                   OUTPUT_VARIABLE llvm_libs

From 98933164814d78b10254d0b1018507bcf0f2b7a5 Mon Sep 17 00:00:00 2001
From: Providence Salumu <smunix@users.noreply.github.com>
Date: Thu, 22 Jul 2021 19:00:08 -0400
Subject: [PATCH 08/40] fix UB introduced by llvm-9+ (#413)

* llvm: fix buggy UB introduced with llvm-9+

* c++: use C++-14 standard
---
 CMakeLists.txt             |   6 +-
 include/hobbes/eval/cc.H   | 420 +++++++++++++++++++----------------
 include/hobbes/util/func.H | 162 +++++++-------
 nix/overlays.nix           | 127 ++++++-----
 test/Matching.C            | 437 +++++++++++++++++++++++--------------
 5 files changed, 673 insertions(+), 479 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 00bde05dc..2f811767a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,11 +17,7 @@ find_package(LLVM REQUIRED CONFIG)
 include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
 
-if (${LLVM_PACKAGE_VERSION} VERSION_LESS "10.0")
-  set(CMAKE_CXX_STANDARD 11)
-else()
-  set(CMAKE_CXX_STANDARD 14)
-endif()
+set(CMAKE_CXX_STANDARD 14)
 
 if (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.6")
   set(jit_lib jit)
diff --git a/include/hobbes/eval/cc.H b/include/hobbes/eval/cc.H
index 1982f9946..18356b21b 100644
--- a/include/hobbes/eval/cc.H
+++ b/include/hobbes/eval/cc.H
@@ -2,80 +2,95 @@
 #ifndef HOBBES_EVAL_CC_HPP_INCLUDED
 #define HOBBES_EVAL_CC_HPP_INCLUDED
 
+#include <hobbes/eval/jitcc.H>
+#include <hobbes/eval/search.H>
 #include <hobbes/lang/expr.H>
-#include <hobbes/lang/type.H>
+#include <hobbes/lang/preds/subtype/obj.H>
 #include <hobbes/lang/tylift.H>
+#include <hobbes/lang/type.H>
 #include <hobbes/lang/typeinf.H>
-#include <hobbes/lang/tyunqualify.H>
-#include <hobbes/lang/preds/subtype/obj.H>
 #include <hobbes/lang/typepreds.H>
+#include <hobbes/lang/tyunqualify.H>
 #include <hobbes/read/parser.H>
-#include <hobbes/eval/jitcc.H>
-#include <hobbes/eval/search.H>
 
 #include <hobbes/util/func.H>
 #include <hobbes/util/llvm.H>
 #include <hobbes/util/str.H>
 
-#include <string>
+#include <iostream>
 #include <map>
-#include <vector>
 #include <stdexcept>
-#include <iostream>
+#include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace hobbes {
 
 // protect access to hobbes/llvm resources between threads
 class hlock {
 public:
-  hlock(); ~hlock();
+  hlock();
+  ~hlock();
 };
 class phlock {
 public:
   phlock();
   void release();
   ~phlock();
+
 private:
   bool f;
 };
 
 // parameter parsing for the 'compileFn' family of functions
-typedef std::function<ExprPtr(const std::string&)> ExprParser;
+typedef std::function<ExprPtr(const std::string &)> ExprParser;
 
-template <typename ... NamesAndExpr>
-  struct PArgl {
-  };
-template <>
-  struct PArgl<ExprPtr> {
-    static str::seq names(const ExprPtr&) { return str::seq(); }
-    static ExprPtr expr(const ExprParser&, const ExprPtr& e) { return e; }
-  };
-template <>
-  struct PArgl<std::string> {
-    static str::seq names(const std::string&) { return str::seq(); }
-    static ExprPtr expr(const ExprParser& p, const std::string& e) { return p(e); }
-  };
-template <>
-  struct PArgl<char*> {
-    static str::seq names(char*) { return str::seq(); }
-    static ExprPtr expr(const ExprParser& p, char* e) { return p(std::string(e)); }
-  };
-template <>
-  struct PArgl<const char*> {
-    static str::seq names(const char*) { return str::seq(); }
-    static ExprPtr expr(const ExprParser& p, const char* e) { return p(std::string(e)); }
-  };
-template <typename ... NamesAndExpr>
-  struct PArgl<const char*, NamesAndExpr...> {
-    static str::seq names(const char* x, const NamesAndExpr& ... args) { str::seq r = PArgl<NamesAndExpr...>::names(args...); r.insert(r.begin(), std::string(x)); return r; }
-    static ExprPtr expr(const ExprParser& p, const char*, const NamesAndExpr& ... args) { return PArgl<NamesAndExpr...>::expr(p, args...); }
-  };
-template <typename ... NamesAndExpr>
-  struct PArgl<std::string, NamesAndExpr...> {
-    static str::seq names(const std::string& x, const NamesAndExpr& ... args) { str::seq r = PArgl<NamesAndExpr...>::names(args...); r.insert(r.begin(), x); return r; }
-    static ExprPtr expr(const ExprParser& p, const std::string&, const NamesAndExpr& ... args) { return PArgl<NamesAndExpr...>::expr(p, args...); }
-  };
+template <typename... NamesAndExpr> struct PArgl {};
+template <> struct PArgl<ExprPtr> {
+  static str::seq names(const ExprPtr &) { return str::seq(); }
+  static ExprPtr expr(const ExprParser &, const ExprPtr &e) { return e; }
+};
+template <> struct PArgl<std::string> {
+  static str::seq names(const std::string &) { return str::seq(); }
+  static ExprPtr expr(const ExprParser &p, const std::string &e) {
+    return p(e);
+  }
+};
+template <> struct PArgl<char *> {
+  static str::seq names(char *) { return str::seq(); }
+  static ExprPtr expr(const ExprParser &p, char *e) {
+    return p(std::string(e));
+  }
+};
+template <> struct PArgl<const char *> {
+  static str::seq names(const char *) { return str::seq(); }
+  static ExprPtr expr(const ExprParser &p, const char *e) {
+    return p(std::string(e));
+  }
+};
+template <typename... NamesAndExpr>
+struct PArgl<const char *, NamesAndExpr...> {
+  static str::seq names(const char *x, const NamesAndExpr &...args) {
+    str::seq r = PArgl<NamesAndExpr...>::names(args...);
+    r.insert(r.begin(), std::string(x));
+    return r;
+  }
+  static ExprPtr expr(const ExprParser &p, const char *,
+                      const NamesAndExpr &...args) {
+    return PArgl<NamesAndExpr...>::expr(p, args...);
+  }
+};
+template <typename... NamesAndExpr> struct PArgl<std::string, NamesAndExpr...> {
+  static str::seq names(const std::string &x, const NamesAndExpr &...args) {
+    str::seq r = PArgl<NamesAndExpr...>::names(args...);
+    r.insert(r.begin(), x);
+    return r;
+  }
+  static ExprPtr expr(const ExprParser &p, const std::string &,
+                      const NamesAndExpr &...args) {
+    return PArgl<NamesAndExpr...>::expr(p, args...);
+  }
+};
 
 // the main compiler
 class cc : public typedb {
@@ -84,175 +99,205 @@ public:
   virtual ~cc();
 
   // parse expressions
-  typedef ModulePtr (*readModuleFileFn)(cc*, const std::string&);
-  ModulePtr readModuleFile(const std::string&);
+  typedef ModulePtr (*readModuleFileFn)(cc *, const std::string &);
+  ModulePtr readModuleFile(const std::string &);
   void setReadModuleFileFn(readModuleFileFn);
 
-  typedef ModulePtr (*readModuleFn)(cc*, const std::string&);
-  ModulePtr readModule(const std::string&);
+  typedef ModulePtr (*readModuleFn)(cc *, const std::string &);
+  ModulePtr readModule(const std::string &);
   void setReadModuleFn(readModuleFn);
 
-  typedef std::pair<std::string, ExprPtr> (*readExprDefnFn)(cc*, const std::string&);
-  std::pair<std::string, ExprPtr> readExprDefn(const std::string&);
+  typedef std::pair<std::string, ExprPtr> (*readExprDefnFn)(
+      cc *, const std::string &);
+  std::pair<std::string, ExprPtr> readExprDefn(const std::string &);
   void setReadExprDefnFn(readExprDefnFn);
 
-  typedef ExprPtr (*readExprFn)(cc*, const std::string&);
-  ExprPtr readExpr(const std::string&);
-  MonoTypePtr readMonoType(const std::string&);
+  typedef ExprPtr (*readExprFn)(cc *, const std::string &);
+  ExprPtr readExpr(const std::string &);
+  MonoTypePtr readMonoType(const std::string &);
   void setReadExprFn(readExprFn);
 
   struct UnreachableMatches {
     LexicalAnnotation la;
     std::string lines;
   };
-  typedef void (*gatherUnreachableMatchesFn)(const UnreachableMatches&);
-  void gatherUnreachableMatches(const UnreachableMatches& m);
+  typedef void (*gatherUnreachableMatchesFn)(const UnreachableMatches &);
+  void gatherUnreachableMatches(const UnreachableMatches &m);
   void setGatherUnreachableMatchesFn(gatherUnreachableMatchesFn f);
 
   // search for paths from one type to another
   // (currently just one-step paths, may be useful to consider multi-step paths)
-  SearchEntries search(const MonoTypePtr&, const MonoTypePtr&);
-  SearchEntries search(const ExprPtr&, const MonoTypePtr&);
-  SearchEntries search(const std::string&, const MonoTypePtr&);
-  SearchEntries search(const std::string&, const std::string&);
+  SearchEntries search(const MonoTypePtr &, const MonoTypePtr &);
+  SearchEntries search(const ExprPtr &, const MonoTypePtr &);
+  SearchEntries search(const std::string &, const MonoTypePtr &);
+  SearchEntries search(const std::string &, const std::string &);
+
 private:
   // parser functions
   readModuleFileFn readModuleFileF;
-  readModuleFn     readModuleF;
-  readExprDefnFn   readExprDefnF;
-  readExprFn       readExprF;
+  readModuleFn readModuleF;
+  readExprDefnFn readExprDefnF;
+  readExprFn readExprF;
 
-  gatherUnreachableMatchesFn gatherUnreachableMatchesF = [](const UnreachableMatches&){};
+  gatherUnreachableMatchesFn gatherUnreachableMatchesF =
+      [](const UnreachableMatches &) {};
 
 public:
   // type-safe compilation to C++ function pointers
-  template <typename RFn, typename ... NamesAndExpr>
-    typename func<RFn>::type compileFn(NamesAndExpr ... args) {
-      static_assert(func<RFn>::arity == sizeof...(NamesAndExpr)-1, "Formal parameter list and expected function type arity mismatch");
-      return rcast<typename func<RFn>::type>(
-        unsafeCompileFn(
-          lift<RFn>::type(*this),
-          PArgl<NamesAndExpr...>::names(args...),
-          PArgl<NamesAndExpr...>::expr([&](const std::string& x){return this->readExpr(x);}, args...)
-        )
-      );
-    }
+  template <typename RFn, typename... NamesAndExpr>
+  typename func<RFn>::type compileFn(NamesAndExpr... args) {
+    static_assert(
+        func<RFn>::arity == sizeof...(NamesAndExpr) - 1,
+        "Formal parameter list and expected function type arity mismatch");
+    return rcast<typename func<RFn>::type>(unsafeCompileFn(
+        lift<RFn>::type(*this), PArgl<NamesAndExpr...>::names(args...),
+        PArgl<NamesAndExpr...>::expr(
+            [&](const std::string &x) { return this->readExpr(x); }, args...)));
+  }
+
+  template <typename RFn, typename... NamesAndExpr>
+  boolSafeFn<RFn> compileSafeFn(NamesAndExpr &&...args) {
+    return {this->template compileFn<RFn>(std::forward<NamesAndExpr>(args)...)};
+  }
 
   // perform type-checking, explicit type annotation, and type class resolution
-  ExprPtr unsweetenExpression(const TEnvPtr& te, const ExprPtr& e);
-  ExprPtr unsweetenExpression(const TEnvPtr& te, const std::string& vname, const ExprPtr& e);
-  ExprPtr unsweetenExpression(const ExprPtr& e);
-  ExprPtr unsweetenExpression(const std::string& vname, const ExprPtr& e);
-  ExprPtr normalize(const ExprPtr& e); // unalias + unsweeten
+  ExprPtr unsweetenExpression(const TEnvPtr &te, const ExprPtr &e);
+  ExprPtr unsweetenExpression(const TEnvPtr &te, const std::string &vname,
+                              const ExprPtr &e);
+  ExprPtr unsweetenExpression(const ExprPtr &e);
+  ExprPtr unsweetenExpression(const std::string &vname, const ExprPtr &e);
+  ExprPtr normalize(const ExprPtr &e); // unalias + unsweeten
 
   // access the LLVM resources
-  llvm::IRBuilder<>*     builder() const;
-  llvm::Module*          module()  const;
+  llvm::IRBuilder<> *builder() const;
+  llvm::Module *module() const;
 
   // dump the contents of the active type environment (useful for debugging)
-  void dumpTypeEnv(std::function<std::string const&(std::string const&)> const& = [](std::string const& binding) -> std::string const& { return binding; }) const;
-  void dumpTypeEnv(str::seq* syms, str::seq* types, std::function<std::string const&(std::string const&)> const& = [](std::string const& binding) -> std::string const& { return binding; }) const;
-  std::string showTypeEnv(std::function<std::string const&(std::string const&)> const& = [](std::string const& binding) -> std::string const& { return binding; }) const;
-
-  const TEnvPtr& typeEnv() const;
+  void
+  dumpTypeEnv(std::function<std::string const &(std::string const &)> const & =
+                  [](std::string const &binding) -> std::string const & {
+    return binding;
+  }) const;
+  void dumpTypeEnv(
+      str::seq *syms, str::seq *types,
+      std::function<std::string const &(std::string const &)> const & =
+          [](std::string const &binding) -> std::string const & {
+        return binding;
+      }) const;
+  std::string
+  showTypeEnv(std::function<std::string const &(std::string const &)> const & =
+                  [](std::string const &binding) -> std::string const & {
+    return binding;
+  }) const;
+
+  const TEnvPtr &typeEnv() const;
 
   // forward-declare a variable binding
-  void forwardDeclare(const std::string& vname, const QualTypePtr& qt);
+  void forwardDeclare(const std::string &vname, const QualTypePtr &qt);
 
   // is a variable merely forward-declared, or does it have a definition?
-  bool hasValueBinding(const std::string& vname);
-  
-  // process and define a set of residual definitions produced by type unqualification
+  bool hasValueBinding(const std::string &vname);
+
+  // process and define a set of residual definitions produced by type
+  // unqualification
   bool drainingDefs;
   LetRec::Bindings drainDefs;
-  void drainUnqualifyDefs(const Definitions& ds);
+  void drainUnqualifyDefs(const Definitions &ds);
 
   // compile an expression and associate it with a name
-  void define(const std::string& vname, const ExprPtr& e);
-  void define(const std::string& vname, const std::string& expr);
+  void define(const std::string &vname, const ExprPtr &e);
+  void define(const std::string &vname, const std::string &expr);
 
   // shorthand for class instance definitions for classes with 0 or 1 members
-  void overload(const std::string&, const MonoTypes&);
-  void overload(const std::string&, const MonoTypes&, const ExprPtr&);
-  void overload(const std::string&, const MonoTypes&, const std::string&);
+  void overload(const std::string &, const MonoTypes &);
+  void overload(const std::string &, const MonoTypes &, const ExprPtr &);
+  void overload(const std::string &, const MonoTypes &, const std::string &);
 
-  // add a type class instance to a known class (wrap up recursive unsweetening/def-draining)
-  void addInstance(const TClassPtr&, const TCInstancePtr&);
+  // add a type class instance to a known class (wrap up recursive
+  // unsweetening/def-draining)
+  void addInstance(const TClassPtr &, const TCInstancePtr &);
 
   // dump the contents of the generated module (useful for debugging)
   void dumpModule();
 
   // get the x86 machine code for an expression (useful for debugging)
   typedef std::vector<unsigned char> bytes;
-  bytes machineCodeForExpr(const std::string& expr);
+  bytes machineCodeForExpr(const std::string &expr);
 
   // keep track of C++ classes so that we can perform upcasts where necessary
-  template <typename T>
-    void addObj() {
-      hlock _;
-      this->objs->add<T>();
-    }
+  template <typename T> void addObj() {
+    hlock _;
+    this->objs->add<T>();
+  }
 
   // convenience method for lifting C++ types
-  template <typename T>
-    PolyTypePtr liftType() {
-      hlock _;
-      return generalize(lift<T>::type(*this));
-    }
+  template <typename T> PolyTypePtr liftType() {
+    hlock _;
+    return generalize(lift<T>::type(*this));
+  }
 
-  template <typename T>
-    MonoTypePtr liftMonoType() {
-      return lift<T>::type(*this);
-    }
+  template <typename T> MonoTypePtr liftMonoType() {
+    return lift<T>::type(*this);
+  }
 
   // bind a C++ value (be sure it stays in scope!)
-  void bind(const PolyTypePtr& tn, const std::string& vn, void* x);
+  void bind(const PolyTypePtr &tn, const std::string &vn, void *x);
 
-  template <typename T>
-    void bind(const std::string& vn, T* x) {
-      hlock _;
-      bind(generalize(liftValue<T*>::type(*this, x)), vn, rcast<void*>(x));
-    }
+  template <typename T> void bind(const std::string &vn, T *x) {
+    hlock _;
+    bind(generalize(liftValue<T *>::type(*this, x)), vn, rcast<void *>(x));
+  }
 
-  template <typename T, int N>
-    void bindArr(const std::string& vn, T x[N]) {
-      hlock _;
-      bind(polytype(qualtype(arrayty(lift<T>::type(*this), N))), vn, rcast<void*>(x));
-    }
+  template <typename T, int N> void bindArr(const std::string &vn, T x[N]) {
+    hlock _;
+    bind(polytype(qualtype(arrayty(lift<T>::type(*this), N))), vn,
+         rcast<void *>(x));
+  }
 
   // simplify binding user functions
-  template <typename R, typename ... Args>
-    void bind(const std::string& fn, R (*pfn)(Args...)) {
-      hlock _;
-      bindExternFunction(fn, lift<R(Args...)>::type(*this), rcast<void*>(pfn));
-    }
+  template <typename R, typename... Args>
+  void bind(const std::string &fn, R (*pfn)(Args...)) {
+    hlock _;
+    bindExternFunction(fn, lift<R(Args...)>::type(*this), rcast<void *>(pfn));
+  }
+
 private:
-  typedef std::pair<str::seq, MonoTypePtr>        TTyDef;
+  typedef std::pair<str::seq, MonoTypePtr> TTyDef;
   typedef std::unordered_map<std::string, TTyDef> TTyDefs;
   TTyDefs ttyDefs;
+
 public:
   // allow the definition of transparent type aliases
-  // ("transparent" in the sense that all other aspects of compilation see the fully expanded type)
-  void defineTypeAlias(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty);
-  bool isTypeAliasName(const std::string& name) const;
-  MonoTypePtr replaceTypeAliases(const MonoTypePtr& ty) const;
+  // ("transparent" in the sense that all other aspects of compilation see the
+  // fully expanded type)
+  void defineTypeAlias(const std::string &name, const str::seq &argNames,
+                       const MonoTypePtr &ty);
+  bool isTypeAliasName(const std::string &name) const;
+  MonoTypePtr replaceTypeAliases(const MonoTypePtr &ty) const;
 
   // typedb interface
-  PolyTypePtr opaquePtrPolyType(const std::type_info& ti, unsigned int sz, bool inStruct);
-  MonoTypePtr opaquePtrMonoType(const std::type_info& ti, unsigned int sz, bool inStruct);
+  PolyTypePtr opaquePtrPolyType(const std::type_info &ti, unsigned int sz,
+                                bool inStruct);
+  MonoTypePtr opaquePtrMonoType(const std::type_info &ti, unsigned int sz,
+                                bool inStruct);
 
-  PolyTypePtr generalize(const MonoTypePtr& mt) const;
+  PolyTypePtr generalize(const MonoTypePtr &mt) const;
 
-  MonoTypePtr defineNamedType(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty);
-  bool isTypeName(const std::string&) const;
-  MonoTypePtr namedTypeRepresentation(const std::string&) const;
+  MonoTypePtr defineNamedType(const std::string &name, const str::seq &argNames,
+                              const MonoTypePtr &ty);
+  bool isTypeName(const std::string &) const;
+  MonoTypePtr namedTypeRepresentation(const std::string &) const;
 
   // an 'unsafe' compilation method
-  //   (the compiled function will conform to the input type description, but this type structure will not be available to C++)
-  void* unsafeCompileFn(const MonoTypePtr& retTy, const str::seq& names, const MonoTypes& argTys, const ExprPtr& exp);
-  void* unsafeCompileFn(const MonoTypePtr& fnTy, const str::seq& names, const ExprPtr& exp);
-  void* unsafeCompileFn(const MonoTypePtr& fnTy, const str::seq& names, const std::string& exp);
-  void releaseMachineCode(void*);
+  //   (the compiled function will conform to the input type description, but
+  //   this type structure will not be available to C++)
+  void *unsafeCompileFn(const MonoTypePtr &retTy, const str::seq &names,
+                        const MonoTypes &argTys, const ExprPtr &exp);
+  void *unsafeCompileFn(const MonoTypePtr &fnTy, const str::seq &names,
+                        const ExprPtr &exp);
+  void *unsafeCompileFn(const MonoTypePtr &fnTy, const str::seq &names,
+                        const std::string &exp);
+  void releaseMachineCode(void *);
 
   // compile/optimization options
   void enableModuleInlining(bool f);
@@ -272,26 +317,29 @@ public:
   void throwOnHugeRegexDFA(bool f);
   bool throwOnHugeRegexDFA() const;
   void regexDFAOverNFAMaxRatio(int f);
-  int  regexDFAOverNFAMaxRatio() const;
+  int regexDFAOverNFAMaxRatio() const;
 
   // allow low-level functions to be added
-  void bindLLFunc(const std::string&, op*);
+  void bindLLFunc(const std::string &, op *);
 
   // bind external functions
-  void bindExternFunction(const std::string& fname, const MonoTypePtr& fty, void* fn);
+  void bindExternFunction(const std::string &fname, const MonoTypePtr &fty,
+                          void *fn);
 
   // allocate global data
-  void* memalloc(size_t, size_t);
-
-  template <typename T>
-    array<T>* makeArray(size_t n) {
-      auto* r = reinterpret_cast<array<T>*>(this->memalloc(sizeof(long) + (sizeof(T) * n), std::max<size_t>(sizeof(long), alignof(T))));
-      r->size = n;
-      if (r->size > 0) {
-        new (r->data) T[r->size];
-      }
-      return r;
+  void *memalloc(size_t, size_t);
+
+  template <typename T> array<T> *makeArray(size_t n) {
+    auto *r = reinterpret_cast<array<T> *>(
+        this->memalloc(sizeof(long) + (sizeof(T) * n),
+                       std::max<size_t>(sizeof(long), alignof(T))));
+    r->size = n;
+    if (r->size > 0) {
+      new (r->data) T[r->size];
     }
+    return r;
+  }
+
 private:
   // cache for expression search results
   SearchCache searchCache;
@@ -303,61 +351,63 @@ private:
   bool ignoreUnreachablePatternMatchRows = false;
   bool lowerPrimMatchTables;
   bool columnwiseMatches;
-  size_t maxExprDFASize={1000};
-  // abort compilation of regexes which translate into huge dfa transition states
+  size_t maxExprDFASize = {1000};
+  // abort compilation of regexes which translate into huge dfa transition
+  // states
   bool shouldThrowOnHugeRegexDFA = false;
-  int  dfaOverNfaMaxRatio        = 4;
+  int dfaOverNfaMaxRatio = 4;
 
   // the bound root type-def environment
   typedef std::map<std::string, PolyTypePtr> TypeAliasMap;
 
-  TEnvPtr      tenv;
+  TEnvPtr tenv;
   TypeAliasMap typeAliases;
 
-  PolyTypePtr lookupVarType(const std::string& vname) const;
+  PolyTypePtr lookupVarType(const std::string &vname) const;
 
   // global variables
-  void definePolyValue(const std::string& vname, const ExprPtr& unsweetExp);
+  void definePolyValue(const std::string &vname, const ExprPtr &unsweetExp);
 
   // track C++ object relationships
   ObjsPtr objs;
 
   // the JIT engine that compiles our monotyped expressions
-  jitcc* jit;
+  jitcc *jit;
+
 public:
   // compiler-local type structure caches for internal use
-  std::unordered_map<MonoType*, MonoTypePtr> unappTyDefns;
+  std::unordered_map<MonoType *, MonoTypePtr> unappTyDefns;
+
 private:
   // disable copying
-  cc(const cc&);
-  void operator=(const cc&);
+  cc(const cc &);
+  void operator=(const cc &);
 };
 
 #define LIFTCTY(cc, e) (cc).liftMonoType<decltype(e)>()
 
-template <typename T>
-  struct rccF {
-    static T compile(cc*, const str::seq&, const std::string&) {
-      throw std::runtime_error("Internal error, unsupported compilation target type");
-    }
-  };
-
-template <typename R, typename ... Args>
-  struct rccF<R(*)(Args...)> {
-    typedef R (*cbF)(Args...);
-    static cbF compile(cc* c, const str::seq& vns, const std::string& expr) {
-      return rcast<cbF>(c->unsafeCompileFn(lift<cbF>::type(*c), vns, expr));
-    }
-  };
+template <typename T> struct rccF {
+  static T compile(cc *, const str::seq &, const std::string &) {
+    throw std::runtime_error(
+        "Internal error, unsupported compilation target type");
+  }
+};
 
-template <typename T>
-  T compileTo(cc* c, const str::seq& vns, const std::string& expr) {
-    return rccF<T>::compile(c, vns, expr);
+template <typename R, typename... Args> struct rccF<R (*)(Args...)> {
+  typedef R (*cbF)(Args...);
+  static cbF compile(cc *c, const str::seq &vns, const std::string &expr) {
+    return rcast<cbF>(c->unsafeCompileFn(lift<cbF>::type(*c), vns, expr));
   }
+};
 
+template <typename T>
+T compileTo(cc *c, const str::seq &vns, const std::string &expr) {
+  return rccF<T>::compile(c, vns, expr);
 }
 
+} // namespace hobbes
+
 // support binding to C++ class member functions
-#define memberfn(e) &hobbes::mfnThunk< decltype(e), decltype(e), e >::fn
+#define memberfn(e) &hobbes::mfnThunk<decltype(e), decltype(e), e>::fn
 
 #endif
diff --git a/include/hobbes/util/func.H b/include/hobbes/util/func.H
index 4c3b15ab2..869665225 100644
--- a/include/hobbes/util/func.H
+++ b/include/hobbes/util/func.H
@@ -2,80 +2,96 @@
 #ifndef HOBBES_UTIL_FUNC_HPP_INCLUDED
 #define HOBBES_UTIL_FUNC_HPP_INCLUDED
 
+#include "ptr.H"
+
 namespace hobbes {
 
-template <typename T>
-  struct func {
-  };
-
-template <typename R, typename ... Args>
-  struct func<R(Args...)> {
-    static const std::size_t arity = sizeof...(Args);
-    typedef R (*type)(Args...);
-    typedef R result_type;
-  };
-
-template <typename R, typename ... Args>
-  struct func<R(*)(Args...)> {
-    static const std::size_t arity = sizeof...(Args);
-    typedef R (*type)(Args...);
-    typedef R result_type;
-  };
-
-template <typename R, typename C, typename ... Args>
-  struct func<R(C::*)(Args...)> {
-    static const std::size_t arity = sizeof...(Args);
-    typedef R (*type)(C*, Args...);
-    typedef R result_type;
-  };
-
-template <typename T>
-  struct mfnTraits {
-  };
-
-template <typename R, typename C, typename ... Args>
-  struct mfnTraits<R(C::*)(Args...)const> {
-    static const int arity = sizeof...(Args);
-    typedef R result_type;
-    typedef C class_type;
-  };
-
-template <typename R, typename C, typename ... Args>
-  struct mfnTraits<R(C::*)(Args...)> {
-    static const int arity = sizeof...(Args);
-    typedef R result_type;
-    typedef C class_type;
-  };
-
-template <typename X, typename T, T f>
-  struct mfnThunk {
-  };
-
-template <typename R, typename C, typename ... Args, typename T, T f>
-  struct mfnThunk<R(C::*)(Args...), T, f> {
-    static R fn(C* c, Args... args) {
-      return (c->*f)(args...);
-    }
-  };
-template <typename R, typename C, typename ... Args, typename T, T f>
-  struct mfnThunk<R(C::*)(Args...)const, T, f> {
-    static R fn(C* c, Args... args) {
-      return (c->*f)(args...);
-    }
-  };
-template <typename C, typename ... Args, typename T, T f>
-  struct mfnThunk<void(C::*)(Args...), T, f> {
-    static void fn(C* c, Args... args) {
-      (c->*f)(args...);
-    }
-  };
-template <typename C, typename ... Args, typename T, T f>
-  struct mfnThunk<void(C::*)(Args...)const, T, f> {
-    static void fn(C* c, Args... args) {
-      (c->*f)(args...);
-    }
-  };
-
-}
+template <typename T> struct func {};
+
+template <typename R, typename... Args> struct func<R(Args...)> {
+  static const std::size_t arity = sizeof...(Args);
+  typedef R (*type)(Args...);
+  typedef R result_type;
+};
+
+template <typename R, typename... Args> struct func<R (*)(Args...)> {
+  static const std::size_t arity = sizeof...(Args);
+  typedef R (*type)(Args...);
+  typedef R result_type;
+};
+
+template <typename R, typename C, typename... Args>
+struct func<R (C::*)(Args...)> {
+  static const std::size_t arity = sizeof...(Args);
+  typedef R (*type)(C *, Args...);
+  typedef R result_type;
+};
+
+template <typename T> struct mfnTraits {};
+
+template <typename R, typename C, typename... Args>
+struct mfnTraits<R (C::*)(Args...) const> {
+  static const int arity = sizeof...(Args);
+  typedef R result_type;
+  typedef C class_type;
+};
+
+template <typename R, typename C, typename... Args>
+struct mfnTraits<R (C::*)(Args...)> {
+  static const int arity = sizeof...(Args);
+  typedef R result_type;
+  typedef C class_type;
+};
+
+template <typename T> struct boolSafeFn : public func<T> {
+  using Type = typename func<T>::type;
+  Type fn = nullptr;
+  boolSafeFn(Type fn) : fn(fn) {}
+  template <class... Args> auto operator()(Args &&...args) -> decltype(auto) {
+    return fn(std::forward<Args>(args)...);
+  }
+};
+
+// smunix: avoid undefined behavior introduced by llvm-9+
+// https://godbolt.org/z/nWWT9jY63
+// https://bugs.llvm.org/show_bug.cgi?id=51163
+
+template <typename... Args>
+struct boolSafeFn<bool(Args...)> : public func<bool(Args...)> {
+  using Type = typename func<bool(Args...)>::type;
+  Type fn = nullptr;
+  boolSafeFn(Type fn) : fn(fn) {}
+  auto operator()(Args &&...args) -> decltype(auto) {
+    const bool r = (fn)(std::forward<Args>(args)...);
+    return (0x00 | *rcast<std::uint8_t const *>(&r));
+  }
+};
+
+template <typename... Args>
+struct boolSafeFn<bool (*)(Args...)> : public boolSafeFn<bool(Args...)> {
+  using Type = typename func<bool(Args...)>::type;
+  boolSafeFn(Type fn) : boolSafeFn<bool(Args...)>(fn) {}
+};
+
+template <typename X, typename T, T f> struct mfnThunk {};
+
+template <typename R, typename C, typename... Args, typename T, T f>
+struct mfnThunk<R (C::*)(Args...), T, f> {
+  static R fn(C *c, Args... args) { return (c->*f)(args...); }
+};
+template <typename R, typename C, typename... Args, typename T, T f>
+struct mfnThunk<R (C::*)(Args...) const, T, f> {
+  static R fn(C *c, Args... args) { return (c->*f)(args...); }
+};
+template <typename C, typename... Args, typename T, T f>
+struct mfnThunk<void (C::*)(Args...), T, f> {
+  static void fn(C *c, Args... args) { (c->*f)(args...); }
+};
+template <typename C, typename... Args, typename T, T f>
+struct mfnThunk<void (C::*)(Args...) const, T, f> {
+  static void fn(C *c, Args... args) { (c->*f)(args...); }
+};
+
+} // namespace hobbes
 
 #endif
diff --git a/nix/overlays.nix b/nix/overlays.nix
index 3a2d1d3e3..813e97a95 100644
--- a/nix/overlays.nix
+++ b/nix/overlays.nix
@@ -1,82 +1,93 @@
-{ src,
-  version,
-  llvmVersions,
-  gccConstraints,
-  system,
-  debug ? false,
-}: final: prev:
+{ src, version, llvmVersions, gccConstraints, system, debug ? false, }:
+final: prev:
 with final;
 let
-  dbg = if debug == true
-        then enableDebugging
-        else (x: x);
-  
+  dbg = if debug == true then enableDebugging else (x: x);
+
   nativeBuildInputs = [ cmake ninja python27 ];
-  
+
   buildInputs = [ ncurses readline zlib python27 ];
-  
+
   doCheck = true;
-  
+
   doTarget = "test";
-  
+
   dontStrip = debug;
-  
+
   separateDebugInfo = debug;
-  
+
   meta = with stdenv.lib; {
     description = "A language and an embedded JIT compiler";
     longDescription = ''
-                  Hobbes is a language, embedded compiler, and runtime for efficient
-                  dynamic expression evalution, data storage and analysis.
-                '';
+      Hobbes is a language, embedded compiler, and runtime for efficient
+      dynamic expression evalution, data storage and analysis.
+    '';
     license = licenses.asl20;
     maintainers = with maintainers; [ kthielen thmzlt smunix ];
   };
 
-  darwinOnly = v : if system == "x86_64-darwin" then v else {};
+  darwinOnly = v: if system == "x86_64-darwin" then v else { };
+
+  linuxOnly = v: if system == "x86_64-linux" then v else { };
+
+  when = c: m: if c then m else { };
 
-  linuxOnly = v : if system == "x86_64-linux" then v else {};
-  
-  when = c: m: if c then m else {};
-  
   withGCC = { gccVersion ? 10 }:
-    let gccPkgs = { gccVersion }: builtins.getAttr ("gcc" + (toString gccVersion) + "Stdenv") final;
-        llvmPkgs = { llvmVersion }: builtins.getAttr ("llvmPackages_" + (toString llvmVersion)) final;                    
-    in makeOverridable ({ llvmVersion, stdenv ? (gccPkgs { inherit gccVersion; }) } : stdenv.mkDerivation {
-      pname = "hobbes-gcc-" + toString gccVersion + "-llvm-" + toString llvmVersion;
-      inherit version src meta doCheck doTarget dontStrip;
-      nativeBuildInputs = nativeBuildInputs;
-      buildInputs = buildInputs ++ [ (llvmPkgs { inherit llvmVersion; }).llvm ];
-      postPatch = ''
-                  substituteInPlace CMakeLists.txt \
-                     --replace "\''${CMAKE_SOURCE_DIR}" "${src}"
-                '';
-    });
-  
-  withCLANG =
-    let llvmPkgs = { llvmVersion }: builtins.getAttr ("llvmPackages_" + (toString llvmVersion)) final;
-    in makeOverridable ({ llvmVersion, stdenv ? (llvmPkgs { inherit llvmVersion; }).stdenv } : stdenv.mkDerivation {
+    let
+      gccPkgs = { gccVersion }:
+        builtins.getAttr ("gcc" + (toString gccVersion) + "Stdenv") final;
+      llvmPkgs = { llvmVersion }:
+        builtins.getAttr ("llvmPackages_" + (toString llvmVersion)) final;
+    in makeOverridable
+    ({ llvmVersion, stdenv ? (gccPkgs { inherit gccVersion; }) }:
+      stdenv.mkDerivation {
+        pname = "hobbes-gcc-" + toString gccVersion + "-llvm-"
+          + toString llvmVersion;
+        inherit version src meta doCheck doTarget dontStrip;
+        nativeBuildInputs = nativeBuildInputs;
+        buildInputs = buildInputs
+          ++ [ (llvmPkgs { inherit llvmVersion; }).llvm ];
+        postPatch = ''
+          substituteInPlace CMakeLists.txt \
+             --replace "\''${CMAKE_SOURCE_DIR}" "${src}"
+        '';
+      });
+
+  withCLANG = let
+    llvmPkgs = { llvmVersion }:
+      builtins.getAttr ("llvmPackages_" + (toString llvmVersion)) final;
+  in makeOverridable
+  ({ llvmVersion, stdenv ? (llvmPkgs { inherit llvmVersion; }).stdenv }:
+    stdenv.mkDerivation {
       pname = "hobbes-clang-" + (toString llvmVersion);
       inherit version src meta doCheck doTarget dontStrip;
       nativeBuildInputs = nativeBuildInputs;
       buildInputs = buildInputs ++ [ (llvmPkgs { inherit llvmVersion; }).llvm ];
       postPatch = ''
-                  substituteInPlace CMakeLists.txt \
-                     --replace "\''${CMAKE_SOURCE_DIR}" "${src}"
-                '';
+        substituteInPlace CMakeLists.txt \
+           --replace "\''${CMAKE_SOURCE_DIR}" "${src}"
+      '';
     });
 
-in { hobbesPackages = when stdenv.isLinux (recurseIntoAttrs (builtins.listToAttrs (builtins.map (gccConstraint: {
-       name = "gcc-" + toString gccConstraint.gccVersion;
-       value = recurseIntoAttrs (builtins.listToAttrs (builtins.map (llvmVersion: {
-         name = "llvm-" + toString llvmVersion;
-         value = recurseIntoAttrs ({ hobbes = dbg (callPackage (withGCC { inherit (gccConstraint) gccVersion; }) { inherit llvmVersion; }); });
-       }) gccConstraint.llvmVersions));
-     }) gccConstraints)))
-     // recurseIntoAttrs (builtins.listToAttrs (
-       builtins.map
-         (llvmVersion: { name="clang-" + toString llvmVersion;
-                         value = recurseIntoAttrs ({ hobbes = dbg (callPackage withCLANG { inherit llvmVersion; }); });
-                       })
-         llvmVersions));
-   }
+in {
+  hobbesPackages = when stdenv.isLinux (recurseIntoAttrs (builtins.listToAttrs
+    (builtins.map (gccConstraint: {
+      name = "gcc-" + toString gccConstraint.gccVersion;
+      value = recurseIntoAttrs (builtins.listToAttrs (builtins.map
+        (llvmVersion: {
+          name = "llvm-" + toString llvmVersion;
+          value = recurseIntoAttrs ({
+            hobbes = dbg
+              (callPackage (withGCC { inherit (gccConstraint) gccVersion; }) {
+                inherit llvmVersion;
+              });
+          });
+        }) gccConstraint.llvmVersions));
+    }) gccConstraints))) // recurseIntoAttrs (builtins.listToAttrs (builtins.map
+      (llvmVersion: {
+        name = "clang-" + toString llvmVersion;
+        value = recurseIntoAttrs ({
+          hobbes = dbg (callPackage withCLANG { inherit llvmVersion; });
+        });
+      }) llvmVersions));
+}
diff --git a/test/Matching.C b/test/Matching.C
index e3e9bfc8f..e5ece1fef 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -1,161 +1,287 @@
 
+#include "test.H"
 #include <hobbes/hobbes.H>
 #include <hobbes/util/perf.H>
 #include <thread>
-#include "test.H"
 
 using namespace hobbes;
-static cc& c() { static cc x; return x; }
+static cc &c() {
+  static cc x;
+  return x;
+}
 
 TEST(Matching, Basic) {
-  EXPECT_EQ(c().compileFn<int()>("match 1 2 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match 2 2 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match 2 3 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(), 3);
-  EXPECT_EQ(c().compileFn<int()>("match 2 9 with | 1 2 -> 1 | 2 x -> x | _ _ -> 3")(), 9);
+  EXPECT_EQ(
+      c().compileFn<int()>("match 1 2 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(),
+      1);
+  EXPECT_EQ(
+      c().compileFn<int()>("match 2 2 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(),
+      2);
+  EXPECT_EQ(
+      c().compileFn<int()>("match 2 3 with | 1 2 -> 1 | _ 2 -> 2 | _ _ -> 3")(),
+      3);
+  EXPECT_EQ(
+      c().compileFn<int()>("match 2 9 with | 1 2 -> 1 | 2 x -> x | _ _ -> 3")(),
+      9);
 
   EXPECT_EQ(c().compileFn<int()>("match (+) 1 2 with | f x y -> f(x,y)")(), 3);
   EXPECT_EQ(c().compileFn<int()>("let (x, y) = (1, 2) in x + y")(), 3);
 }
 
 TEST(Matching, Strings) {
-  EXPECT_EQ(c().compileFn<int()>("match \"foo\" with | \"fox\" -> 1 | \"for\" -> 2 | _ -> 3")(), 3);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match \"foo\" with | \"fox\" -> 1 | \"for\" -> 2 | _ -> 3")(),
+            3);
 
   // verify matching in std::string values (array matching should be overloaded)
   static std::string stdpatstr = "hello";
   c().bind("stdpatstr", &stdpatstr);
-  EXPECT_EQ(c().compileFn<int()>("match stdpatstr with | \"hello\" -> 0 | _ -> 9")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match stdpatstr with | \"hell\" -> 0 | _ -> 9")(), 9);
-
-  EXPECT_EQ(c().compileFn<int()>("match \"abc\" 2 with | _ 2 -> 1 | \"abc\" _ -> 2 | _ 3 -> 3 | _ _ -> 4")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"abc\" 3 with | _ 2 -> 1 | \"abc\" _ -> 2 | _ 3 -> 3 | _ _ -> 4")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match \"abd\" 3 with | _ 2 -> 1 | \"abc\" _ -> 2 | _ 3 -> 3 | _ _ -> 4")(), 3);
-  EXPECT_EQ(c().compileFn<int()>("match \"abd\" 4 with | _ 2 -> 1 | \"abc\" _ -> 2 | _ 3 -> 3 | _ _ -> 4")(), 4);
-
   EXPECT_EQ(
-    c().compileFn<int()>(
-      "match \"abc\" \"three\" with | _ \"two\" -> 1 | \"abc\" _ -> 2 | _ \"three\" -> 3 | _ _ -> 4"
-    )(),
-    2
-  );
-
-  EXPECT_TRUE(
-    c().compileFn<bool()>(
-      "let f = (\\x y z.match x y z with | \"aaa\" \"bbb\" _ -> 0 | \"aaa\" \"bbc\" \"ccc\" -> 1 | _ _ _ -> 2) :: ([char],[char],[char])->int in "
-      "(f(\"aaa\",\"bbb\",\"ccc\") == 0 and f(\"aaa\",\"bbc\",\"ccc\") == 1 and f(\"aaa\",\"bbc\",\"ccd\") == 2 and f(\"aba\",\"bbb\",\"ccdaa\") == 2)"
-    )()
-  );
+      c().compileFn<int()>("match stdpatstr with | \"hello\" -> 0 | _ -> 9")(),
+      0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match stdpatstr with | \"hell\" -> 0 | _ -> 9")(),
+      9);
+
+  EXPECT_EQ(c().compileFn<int()>("match \"abc\" 2 with | _ 2 -> 1 | \"abc\" _ "
+                                 "-> 2 | _ 3 -> 3 | _ _ -> 4")(),
+            1);
+  EXPECT_EQ(c().compileFn<int()>("match \"abc\" 3 with | _ 2 -> 1 | \"abc\" _ "
+                                 "-> 2 | _ 3 -> 3 | _ _ -> 4")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>("match \"abd\" 3 with | _ 2 -> 1 | \"abc\" _ "
+                                 "-> 2 | _ 3 -> 3 | _ _ -> 4")(),
+            3);
+  EXPECT_EQ(c().compileFn<int()>("match \"abd\" 4 with | _ 2 -> 1 | \"abc\" _ "
+                                 "-> 2 | _ 3 -> 3 | _ _ -> 4")(),
+            4);
 
   EXPECT_EQ(
-    c().compileFn<int()>(
-      "((\\a b c.match a b c with | \"aaa\" \"bbb\" \"ccc\" -> 0 | \"aaa\" _ \"ccc\" -> 1 | _ _ _ -> -1) :: ([char],[char],[char]) -> int)(\"aaa\", \"ddd\", \"ccc\")"
-    )(),
-    1
-  );
+      c().compileFn<int()>("match \"abc\" \"three\" with | _ \"two\" -> 1 | "
+                           "\"abc\" _ -> 2 | _ \"three\" -> 3 | _ _ -> 4")(),
+      2);
+
+  EXPECT_TRUE(c().compileFn<bool()>(
+      "let f = (\\x y z.match x y z with | \"aaa\" \"bbb\" _ -> 0 | \"aaa\" "
+      "\"bbc\" \"ccc\" -> 1 | _ _ _ -> 2) :: ([char],[char],[char])->int in "
+      "(f(\"aaa\",\"bbb\",\"ccc\") == 0 and f(\"aaa\",\"bbc\",\"ccc\") == 1 "
+      "and f(\"aaa\",\"bbc\",\"ccd\") == 2 and f(\"aba\",\"bbb\",\"ccdaa\") == "
+      "2)")());
+
+  EXPECT_EQ(c().compileFn<int()>(
+                "((\\a b c.match a b c with | \"aaa\" \"bbb\" \"ccc\" -> 0 | "
+                "\"aaa\" _ \"ccc\" -> 1 | _ _ _ -> -1) :: "
+                "([char],[char],[char]) -> int)(\"aaa\", \"ddd\", \"ccc\")")(),
+            1);
 }
 
 TEST(Matching, Arrays) {
-  EXPECT_EQ(c().compileFn<int()>("match [1,2,3] with | [1,2,_] -> 1 | [1,2] -> 2 | _ -> 3")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match [[1],[2]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match [[1],[3]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match [[3],[3]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(), 2);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match [1,2,3] with | [1,2,_] -> 1 | [1,2] -> 2 | _ -> 3")(),
+            1);
+  EXPECT_EQ(
+      c().compileFn<int()>(
+          "match [[1],[2]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(),
+      0);
+  EXPECT_EQ(
+      c().compileFn<int()>(
+          "match [[1],[3]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(),
+      1);
+  EXPECT_EQ(
+      c().compileFn<int()>(
+          "match [[3],[3]] with | [_,[2]] -> 0 | [[1],_] -> 1 | _ -> 2")(),
+      2);
 }
 
 TEST(Matching, Struct) {
-  EXPECT_EQ(c().compileFn<int()>("match (2,2) with | (1,2) -> 1 | (_,2) -> 2 | _ -> 3")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match ([1,2],\"foo\") 2 with | _ 1 -> 1 | ([3,4],_) _ -> 2 | ([_,2],\"foo\") 2 -> 3 | _ _ -> 4")(), 3);
-
-  EXPECT_EQ(c().compileFn<int()>("match (\"abc\", 2) with | (_, 2) -> 1 | (\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match (\"abc\", 3) with | (_, 2) -> 1 | (\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match (\"abd\", 3) with | (_, 2) -> 1 | (\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(), 3);
-  EXPECT_EQ(c().compileFn<int()>("match (\"abd\", 4) with | (_, 2) -> 1 | (\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(), 4);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match (2,2) with | (1,2) -> 1 | (_,2) -> 2 | _ -> 3")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match ([1,2],\"foo\") 2 with | _ 1 -> 1 | ([3,4],_) _ -> 2 | "
+                "([_,2],\"foo\") 2 -> 3 | _ _ -> 4")(),
+            3);
+
+  EXPECT_EQ(c().compileFn<int()>("match (\"abc\", 2) with | (_, 2) -> 1 | "
+                                 "(\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(),
+            1);
+  EXPECT_EQ(c().compileFn<int()>("match (\"abc\", 3) with | (_, 2) -> 1 | "
+                                 "(\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>("match (\"abd\", 3) with | (_, 2) -> 1 | "
+                                 "(\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(),
+            3);
+  EXPECT_EQ(c().compileFn<int()>("match (\"abd\", 4) with | (_, 2) -> 1 | "
+                                 "(\"abc\", _) -> 2 | (_, 3) -> 3 | _ -> 4")(),
+            4);
 }
 
 TEST(Matching, Variant) {
-  EXPECT_EQ(c().compileFn<int()>("match (|0=(1,2,3)| :: (int*int*int)+int) with | |0=(x,y,z)| -> x+y+z | |1=y| -> y")(), 6);
-  EXPECT_EQ(c().compileFn<int()>("match (|bob=3|::|bob:int,frank:[char]|) with | |frank=_| -> 9 | _ -> 2")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match (|bob=3|::|bob:int,frank:[char]|) with | |bob=_| -> 9 | _ -> 2")(), 9);
-
-  EXPECT_EQ(c().compileFn<int()>("match |foo=(\"abc\", 2)| with | |foo=(_, 2)| -> 1 | |foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match |foo=(\"abc\", 3)| with | |foo=(_, 2)| -> 1 | |foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match |foo=(\"abd\", 3)| with | |foo=(_, 2)| -> 1 | |foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(), 3);
-  EXPECT_EQ(c().compileFn<int()>("match |foo=(\"abd\", 4)| with | |foo=(_, 2)| -> 1 | |foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(), 4);
+  EXPECT_EQ(c().compileFn<int()>("match (|0=(1,2,3)| :: (int*int*int)+int) "
+                                 "with | |0=(x,y,z)| -> x+y+z | |1=y| -> y")(),
+            6);
+  EXPECT_EQ(c().compileFn<int()>("match (|bob=3|::|bob:int,frank:[char]|) with "
+                                 "| |frank=_| -> 9 | _ -> 2")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>("match (|bob=3|::|bob:int,frank:[char]|) with "
+                                 "| |bob=_| -> 9 | _ -> 2")(),
+            9);
+
+  EXPECT_EQ(c().compileFn<int()>(
+                "match |foo=(\"abc\", 2)| with | |foo=(_, 2)| -> 1 | "
+                "|foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(),
+            1);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match |foo=(\"abc\", 3)| with | |foo=(_, 2)| -> 1 | "
+                "|foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match |foo=(\"abd\", 3)| with | |foo=(_, 2)| -> 1 | "
+                "|foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(),
+            3);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match |foo=(\"abd\", 4)| with | |foo=(_, 2)| -> 1 | "
+                "|foo=(\"abc\", _)| -> 2 | |foo=(_, 3)| -> 3 | |foo=_| -> 4")(),
+            4);
 
   // ensure match preserves variant constructor order
   // and that unit matches drive type inference
-  EXPECT_EQ(c().compileFn<int()>("(\\v.match v with | |S|->0 | |F=x|->x)(|F=42|)")(), 42);
+  EXPECT_EQ(
+      c().compileFn<int()>("(\\v.match v with | |S|->0 | |F=x|->x)(|F=42|)")(),
+      42);
 }
 
 TEST(Matching, Efficiency) {
-  // make sure that we don't produce insane code for reasonable pattern-match expressions
-  EXPECT_TRUE(c().machineCodeForExpr("(\\xs.match xs with | [1,2,3] -> 1 | [1,2,y] -> y | [] -> 9 | _ -> 10) :: [int] -> int").size() < 150);
+  // make sure that we don't produce insane code for reasonable pattern-match
+  // expressions
+  EXPECT_TRUE(
+      c().machineCodeForExpr("(\\xs.match xs with | [1,2,3] -> 1 | [1,2,y] -> "
+                             "y | [] -> 9 | _ -> 10) :: [int] -> int")
+          .size() < 150);
 }
 
 TEST(Matching, Guards) {
-  EXPECT_EQ(c().compileFn<int()>("match 1 2 3 with | 1 2 3 -> 0 | 1 2 y where y < 5 -> 1 | _ _ _ -> 2")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match 1 2 4 with | 1 2 3 -> 0 | 1 2 y where y < 5 -> 1 | _ _ _ -> 2")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match 1 2 5 with | 1 2 3 -> 0 | 1 2 y where y < 5 -> 1 | _ _ _ -> 2")(), 2);
-
-  EXPECT_EQ(c().compileFn<int()>("match 1 2 5 with | 1 2 3 -> 0 | 1 x y where (x + y) == 7 -> 1 | _ _ _ -> 2")(), 1);
+  EXPECT_EQ(c().compileFn<int()>("match 1 2 3 with | 1 2 3 -> 0 | 1 2 y where "
+                                 "y < 5 -> 1 | _ _ _ -> 2")(),
+            0);
+  EXPECT_EQ(c().compileFn<int()>("match 1 2 4 with | 1 2 3 -> 0 | 1 2 y where "
+                                 "y < 5 -> 1 | _ _ _ -> 2")(),
+            1);
+  EXPECT_EQ(c().compileFn<int()>("match 1 2 5 with | 1 2 3 -> 0 | 1 2 y where "
+                                 "y < 5 -> 1 | _ _ _ -> 2")(),
+            2);
+
+  EXPECT_EQ(c().compileFn<int()>("match 1 2 5 with | 1 2 3 -> 0 | 1 x y where "
+                                 "(x + y) == 7 -> 1 | _ _ _ -> 2")(),
+            1);
 }
 
 TEST(Matching, Regex) {
   // verify basic regex patterns
-  EXPECT_EQ(c().compileFn<int()>("match \"foo\"  with | 'fo*'   -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"foo\"  with | '(fo)*' -> 0 | _ -> 1")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"fofo\" with | '(fo)*' -> 0 | _ -> 1")(), 0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"foo\"  with | 'fo*'   -> 0 | _ -> 1")(), 0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"foo\"  with | '(fo)*' -> 0 | _ -> 1")(), 1);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"fofo\" with | '(fo)*' -> 0 | _ -> 1")(), 0);
 
   // verify regex patterns within structures
-  EXPECT_EQ((c().compileFn<int()>("match (\"jimmy\", \"chicken\") with | ('jimmy*', 'ab*') -> 0 | _ -> 1")()), 1);
-  EXPECT_EQ((c().compileFn<int()>("match (\"jimmy\", \"chicken\") with | ('jimmy*', 'ab*') -> 0 | ('j*i*m*y*', 'chicken*') -> 42 | _ -> 1")()), 42);
+  EXPECT_EQ((c().compileFn<int()>("match (\"jimmy\", \"chicken\") with | "
+                                  "('jimmy*', 'ab*') -> 0 | _ -> 1")()),
+            1);
+  EXPECT_EQ((c().compileFn<int()>(
+                "match (\"jimmy\", \"chicken\") with | ('jimmy*', 'ab*') -> 0 "
+                "| ('j*i*m*y*', 'chicken*') -> 42 | _ -> 1")()),
+            42);
 
   // verify various features of regex syntax
-  EXPECT_EQ(c().compileFn<int()>("match \"aa\" with | 'a?a?' -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"aa\" with | 'a?\\\\' -> 0 | _ -> 1")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"a\\\\\" with | 'a?\\\\' -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"a\\n\" with | 'a?\\\\' -> 0 | _ -> 1")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"a\\n\" with | 'a?\\n' -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"a\\n\" with | '[a-z]\\n' -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"a\\n\" with | '[^a-z]\\n' -> 0 | _ -> 1")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"0\\n\" with | '[^a-z]\\n' -> 0 | _ -> 1")(), 0);
-  EXPECT_EQ(c().compileFn<int()>("match \"8675309\" with | '[0-9]+' -> 0 | _ -> 1")(), 0);
+  EXPECT_EQ(c().compileFn<int()>("match \"aa\" with | 'a?a?' -> 0 | _ -> 1")(),
+            0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"aa\" with | 'a?\\\\' -> 0 | _ -> 1")(), 1);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"a\\\\\" with | 'a?\\\\' -> 0 | _ -> 1")(),
+      0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"a\\n\" with | 'a?\\\\' -> 0 | _ -> 1")(),
+      1);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"a\\n\" with | 'a?\\n' -> 0 | _ -> 1")(), 0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"a\\n\" with | '[a-z]\\n' -> 0 | _ -> 1")(),
+      0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"a\\n\" with | '[^a-z]\\n' -> 0 | _ -> 1")(),
+      1);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"0\\n\" with | '[^a-z]\\n' -> 0 | _ -> 1")(),
+      0);
+  EXPECT_EQ(
+      c().compileFn<int()>("match \"8675309\" with | '[0-9]+' -> 0 | _ -> 1")(),
+      0);
   EXPECT_TRUE(c().compileFn<bool()>("\"b\" matches 'a(z)|b'")());
 
   // verify correct match/fallback logic with regexes and multiple columns
-  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 1 with | 'a(b|c)' 1 -> 1 | 'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(), 1);
-  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 2 with | 'a(b|c)' 1 -> 1 | 'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(), 2);
-  EXPECT_EQ(c().compileFn<int()>("match \"ac\" 3 with | 'a(b|c)' 1 -> 1 | 'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(), 3);
-  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 3 with | 'a(b|c)' 1 -> 1 | 'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(), 4);
-  EXPECT_EQ(c().compileFn<int()>("match \"foo\" 42 with | 'a(b|c)' 1 -> 1 | 'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(), 4);
+  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 1 with | 'a(b|c)' 1 -> 1 | 'ab' "
+                                 "2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(),
+            1);
+  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 2 with | 'a(b|c)' 1 -> 1 | 'ab' "
+                                 "2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(),
+            2);
+  EXPECT_EQ(c().compileFn<int()>("match \"ac\" 3 with | 'a(b|c)' 1 -> 1 | 'ab' "
+                                 "2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(),
+            3);
+  EXPECT_EQ(c().compileFn<int()>("match \"ab\" 3 with | 'a(b|c)' 1 -> 1 | 'ab' "
+                                 "2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(),
+            4);
+  EXPECT_EQ(c().compileFn<int()>("match \"foo\" 42 with | 'a(b|c)' 1 -> 1 | "
+                                 "'ab' 2 -> 2 | 'ac' 3 -> 3 | _ _ -> 4")(),
+            4);
 
   // verify unreachable row determination
   bool unreachableExn = false;
   try {
-    c().compileFn<int()>("match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1");
-  } catch (std::exception&) {
+    c().compileFn<int()>(
+        "match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1");
+  } catch (std::exception &) {
     unreachableExn = true;
   }
-  EXPECT_TRUE(unreachableExn && "failed to determine expected unreachable regex row");
+  EXPECT_TRUE(unreachableExn &&
+              "failed to determine expected unreachable regex row");
 
-  // verify unreachable rows should not cause error with IgnoreUnreachableMatches option on
+  // verify unreachable rows should not cause error with
+  // IgnoreUnreachableMatches option on
   c().ignoreUnreachableMatches(true);
-  EXPECT_EQ(c().compileFn<int()>("match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1")(), 0);
+  EXPECT_EQ(c().compileFn<int()>("match \"foo123ooo\" with | '123|foo.*' -> 0 "
+                                 "| 'foo.*' -> 1 | _ -> -1")(),
+            0);
   c().ignoreUnreachableMatches(false);
 
   // verify binding in regex matches
-  EXPECT_EQ(makeStdString(c().compileFn<const array<char>*()>("match \"foobar\" with | 'f(?<os>o*)bar' -> os | _ -> \"???\"")()), "oo");
+  EXPECT_EQ(
+      makeStdString(c().compileFn<const array<char> *()>(
+          "match \"foobar\" with | 'f(?<os>o*)bar' -> os | _ -> \"???\"")()),
+      "oo");
 
   // verify misc expressions
-  EXPECT_EQ(c().compileFn<int()>("match \"Roba\" with | 'Ka|Roba|Raa' -> 1 | _ -> 0")(), 1);
+  EXPECT_EQ(c().compileFn<int()>(
+                "match \"Roba\" with | 'Ka|Roba|Raa' -> 1 | _ -> 0")(),
+            1);
 
   // verify regex-as-fn translation
   EXPECT_TRUE(c().compileFn<bool()>("'fo*bar'(\"foobar\")")());
   EXPECT_TRUE(!c().compileFn<bool()>("'fo*bar'(\"foobaz\")")());
-  EXPECT_EQ(makeStdString(c().compileFn<const array<char>*()>("either('f(?<os>o*)bar'(\"foobar\"),\"\",.os)")()), "oo");
-  EXPECT_EQ(makeStdString(c().compileFn<const array<char>*()>("either('f(?<os>o*)bar'(\"foobaz\"),\"\",.os)")()), "");
+  EXPECT_EQ(makeStdString(c().compileFn<const array<char> *()>(
+                "either('f(?<os>o*)bar'(\"foobar\"),\"\",.os)")()),
+            "oo");
+  EXPECT_EQ(makeStdString(c().compileFn<const array<char> *()>(
+                "either('f(?<os>o*)bar'(\"foobaz\"),\"\",.os)")()),
+            "");
 }
 
 TEST(Matching, Support) {
-  // we now have some support functions that could be used when compiling pattern match expressions and we need to make sure they're correct
+  // we now have some support functions that could be used when compiling
+  // pattern match expressions and we need to make sure they're correct
   EXPECT_EQ(c().compileFn<long()>("bsearch([1,3],id,2)")(), 2);
   EXPECT_EQ(c().compileFn<long()>("bsearch([9,10],id,2)")(), 2);
   EXPECT_EQ(c().compileFn<long()>("bsearch([1,2,3,4],id,3)")(), 2);
@@ -167,17 +293,23 @@ TEST(Matching, Tests) {
 
   // make sure that tests with inaccessible names are rejected
   EXPECT_EXCEPTION(c().compileFn<bool()>("\"JIMMY\" matches JIMMY")());
-  EXPECT_EXCEPTION(c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=JIMMY|}]")());
+  EXPECT_EXCEPTION(
+      c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=JIMMY|}]")());
 
   // make sure that tests with inaccessible _ names are allowed
   EXPECT_TRUE(c().compileFn<bool()>("\"JIMMY\" matches _")());
-  EXPECT_TRUE(c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=_|}]")());
+  EXPECT_TRUE(
+      c().compileFn<bool()>("[{x=just(\"JIMMY\")}] matches [{x=|1=_|}]")());
 }
 
 TEST(Matching, Functions) {
   // support irrefutable pattern matches in function heads
-  EXPECT_EQ(c().compileFn<int()>("(\\(a,b) (c,d).a+b+c+d)((1, 2), (3, 4))")(), 10);
-  EXPECT_EQ(c().compileFn<int()>("(\\{bob=a, frank=b} {chicken=c, jimmy=d}.a+b+c+d)({frank=1, bob=2}, {jimmy=3, chicken=4})")(), 10);
+  EXPECT_EQ(c().compileFn<int()>("(\\(a,b) (c,d).a+b+c+d)((1, 2), (3, 4))")(),
+            10);
+  EXPECT_EQ(c().compileFn<int()>(
+                "(\\{bob=a, frank=b} {chicken=c, jimmy=d}.a+b+c+d)({frank=1, "
+                "bob=2}, {jimmy=3, chicken=4})")(),
+            10);
 
   // support refutable pattern matches in function heads
   EXPECT_TRUE(c().compileFn<bool()>("(\\[1,2,x].x+7)([1,2,3]) === |1=10|")());
@@ -186,96 +318,86 @@ TEST(Matching, Functions) {
 
 TEST(Matching, Monadic) {
   // support irrefutable matching in monadic 'do' sequences
-  EXPECT_EQ(c().compileFn<int()>("do { {x=x, y=y} = {x=1+2, y=3+4}; return x+y }")(), 10);
+  EXPECT_EQ(
+      c().compileFn<int()>("do { {x=x, y=y} = {x=1+2, y=3+4}; return x+y }")(),
+      10);
 }
 
-#if 0
-// todo: smunix: breaks on LLVM 9,10,11
 TEST(Matching, matchFromStringToBoolIsBool) {
-  bool r = c().compileFn<bool()>(
-    "match \"1\" \"2\" \"3\" \"4\" with\n"
-    "| \"1\" \"2\" \"3\" \"4\" -> true\n"
-    "| \"1\" \"2\" \"3\" _     -> true\n"
-    "| \"1\" \"2\" _ _         -> true\n"
-    "| \"1\" _ _ _             -> true\n"
-    "| _ _ _ _                 -> false"
-  )();
-  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t*>(&r));
+  bool r = c().compileSafeFn<bool()>("match \"1\" \"2\" \"3\" \"4\" with\n"
+                                     "| \"1\" \"2\" \"3\" \"4\" -> true\n"
+                                     "| \"1\" \"2\" \"3\" _     -> true\n"
+                                     "| \"1\" \"2\" _ _         -> true\n"
+                                     "| \"1\" _ _ _             -> true\n"
+                                     "| _ _ _ _                 -> false")();
+  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t *>(&r));
   EXPECT_TRUE(r);
 }
-#endif
 
 TEST(Matching, matchFromIntToBoolIsBool) {
-  bool r = c().compileFn<bool()>(
-    "match 1 2 3 4 with\n"
-    "| 1 2 3 4 -> true\n"
-    "| 1 2 3 _ -> true\n"
-    "| 1 2 _ _ -> true\n"
-    "| 1 _ _ _ -> true\n"
-    "| _ _ _ _ -> false"
-  );
-  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t*>(&r));
+  bool r = c().compileSafeFn<bool()>("match 1 2 3 4 with\n"
+                                     "| 1 2 3 4 -> true\n"
+                                     "| 1 2 3 _ -> true\n"
+                                     "| 1 2 _ _ -> true\n"
+                                     "| 1 _ _ _ -> true\n"
+                                     "| _ _ _ _ -> false")();
+  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t *>(&r));
   EXPECT_TRUE(r);
 }
 
 TEST(Matching, matchFromStringToIntIsCorrect) {
-  int r = c().compileFn<int()>(
-    "match \"1\" \"2\" \"3\" \"4\" with\n"
-    "| \"1\" \"2\" \"3\" \"4\" -> 86\n"
-    "| \"1\" \"2\" \"3\" _     -> 75\n"
-    "| \"1\" \"2\" _ _         -> 30\n"
-    "| \"1\" _ _ _             -> 9\n"
-    "| _ _ _ _                 -> 0"
-  )();
-  EXPECT_EQ(uint32_t(86), *reinterpret_cast<uint32_t*>(&r));
+  int r = c().compileFn<int()>("match \"1\" \"2\" \"3\" \"4\" with\n"
+                               "| \"1\" \"2\" \"3\" \"4\" -> 86\n"
+                               "| \"1\" \"2\" \"3\" _     -> 75\n"
+                               "| \"1\" \"2\" _ _         -> 30\n"
+                               "| \"1\" _ _ _             -> 9\n"
+                               "| _ _ _ _                 -> 0")();
+  EXPECT_EQ(uint32_t(86), *reinterpret_cast<uint32_t *>(&r));
   EXPECT_TRUE(r);
 }
 
 TEST(Matching, largeRegexDFAFinishesReasonablyQuickly) {
   auto t0 = tick();
-  c().compileFn<void()>(
-    "match \"a\" with\n"
-    "| '.*MOGUSJGTCA' where false -> ()\n"
-    "| '.+' where false -> ()\n"
-    "| '..........' where false -> ()\n"
-    "| '..AP.+' where false -> ()\n"
-    "| '..GU.+' where false -> ()\n"
-    "| '.?%.+' where false -> ()\n"
-    "| '.?%..AP.+' where false -> ()\n"
-    "| '.?%..GU.+' where false -> ()\n"
-    "| '.?%ME.+' where false -> ()\n"
-    "| '.?&.+' where false -> ()\n"
-    "| '.?&..AP.+' where false -> ()\n"
-    "| '.?&..GU.+' where false -> ()\n"
-    "| '.?&ME.+' where false -> ()\n"
-    "| '.?[%&].+' where false -> ()\n"
-    "| '.?[%&].+1==.?[%&].+' where false -> ()\n"
-    "| '05DVAAAB9' where false -> ()\n"
-    "| 'IMEAT_AXXBCD_ZM_ABCDEF' where false -> ()\n"
-    "| 'IMEAT_AXX_UVW_ABCDEF' where false -> ()\n"
-    "| 'IMEAT_AXXDCB_DE_ABCDEF' where false -> ()\n"
-    "| 'IMEAT_JWEWQP_DE_ABCDEF' where false -> ()\n"
-    "| _ -> ()\n"
-  )();
-
-  EXPECT_TRUE(size_t(tick()-t0) < 1UL*60*60*1000*1000*1000);
+  c().compileFn<void()>("match \"a\" with\n"
+                        "| '.*MOGUSJGTCA' where false -> ()\n"
+                        "| '.+' where false -> ()\n"
+                        "| '..........' where false -> ()\n"
+                        "| '..AP.+' where false -> ()\n"
+                        "| '..GU.+' where false -> ()\n"
+                        "| '.?%.+' where false -> ()\n"
+                        "| '.?%..AP.+' where false -> ()\n"
+                        "| '.?%..GU.+' where false -> ()\n"
+                        "| '.?%ME.+' where false -> ()\n"
+                        "| '.?&.+' where false -> ()\n"
+                        "| '.?&..AP.+' where false -> ()\n"
+                        "| '.?&..GU.+' where false -> ()\n"
+                        "| '.?&ME.+' where false -> ()\n"
+                        "| '.?[%&].+' where false -> ()\n"
+                        "| '.?[%&].+1==.?[%&].+' where false -> ()\n"
+                        "| '05DVAAAB9' where false -> ()\n"
+                        "| 'IMEAT_AXXBCD_ZM_ABCDEF' where false -> ()\n"
+                        "| 'IMEAT_AXX_UVW_ABCDEF' where false -> ()\n"
+                        "| 'IMEAT_AXXDCB_DE_ABCDEF' where false -> ()\n"
+                        "| 'IMEAT_JWEWQP_DE_ABCDEF' where false -> ()\n"
+                        "| _ -> ()\n")();
+
+  EXPECT_TRUE(size_t(tick() - t0) < 1UL * 60 * 60 * 1000 * 1000 * 1000);
 }
 
 TEST(Matching, noRaceInterpMatch) {
   c().alwaysLowerPrimMatchTables(true);
   c().buildInterpretedMatches(true);
-  auto f = c().compileFn<int(const std::string&)>("x",
-    "match x with\n"
-    "| \"foo\" -> 0\n"
-    "| \"bar\" -> 1\n"
-    "| _       -> 2"
-  );
+  auto f = c().compileFn<int(const std::string &)>("x", "match x with\n"
+                                                        "| \"foo\" -> 0\n"
+                                                        "| \"bar\" -> 1\n"
+                                                        "| _       -> 2");
   size_t wrongMatches = 0;
   std::vector<std::thread> ps;
   for (size_t p = 0; p < 10; ++p) {
     ps.emplace_back([&]() {
       auto t0 = tick();
-      while (wrongMatches == 0 && size_t(tick()-t0) < 1UL*1000*1000*1000) {
+      while (wrongMatches == 0 &&
+             size_t(tick() - t0) < 1UL * 1000 * 1000 * 1000) {
         if (f("foo") != 0) {
           ++wrongMatches;
         }
@@ -286,10 +408,9 @@ TEST(Matching, noRaceInterpMatch) {
       }
     });
   }
-  for (auto& p : ps) {
+  for (auto &p : ps) {
     p.join();
   }
   EXPECT_EQ(wrongMatches, size_t(0));
   c().buildInterpretedMatches(false);
 }
-

From 3b1d99f246bcdd131ed953c0555da28456b9f0f2 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Tue, 27 Jul 2021 22:27:00 +0000
Subject: [PATCH 09/40] replace mcjit by orcjit to generate binary code (#414)

* Update .gitlab-ci.yml file

* Revert "Update .gitlab-ci.yml file"

This reverts commit 2f9b62e7ade6de9dea333393f1b577fc1fb6e573

* add ORCJIT, still have unresolved in process symbols

* put lock around every explicit getContext() use

* module pointers in jitcc might be dangling

* add Providence's ci file

* logs: add llerrs(x) macros for logging

* add missing header for llerr

* lock guard IRBuilder access

All IRBuilder in llvm.H are input parameters, they are locked on the
caller side

* redraft globals && fix invalid Value* in vtenv

* can see prompt of hi

* remove all llerrs except for IR dump

* minor refactoring on Globals ConstantList VTEnv

* remove dead code & renaming

* make every jitcc::module() access locked by withContext

tried to add a interface jitcc::withModuleDo, which just make things
hard to understand, withModuleDo and withContext does the same thing
internally, but with different interfaces, really cumbersome to use

* fix duplicate definitions error caused by same .patfs.X name used in multiple module with ExternalLinkage

make .patfs.X functions InternalLinkage, since they doesn't seem to be referenced across modules

* remove dummy function stubs in jitcc::constants.

Functions will be looked up in vtenv and globals anyway, this logic
probably never get used

* remove dangling Instruction generated by toLLVMConstant

* Function should be considered as a Constant like the original logic. for
now

* minir test fix, missing a pair of parens, function never gets called

* fix boolean related failure for llvm >= 9

* change from compileSafeFn -> compileFn as boolean failure has been resolved

* some cleanup

* fix llvm12 test/Compiler.C crash

* ExecutionSession::endSession doesn't exist pre-llvm12, so more ifdef

Co-authored-by: Providence Salumu <providence.salumu@smunix.com>
---
 .gitlab-ci.yml                 |  76 ++++
 CMakeLists.txt                 |   4 +-
 include/hobbes/eval/jitcc.H    |  56 ++-
 include/hobbes/eval/orcjitcc.H |  55 +++
 include/hobbes/hobbes.H        |  97 +++---
 include/hobbes/util/llvm.H     | 230 +++++++++++-
 lib/hobbes/db/bindings.C       | 210 ++++++-----
 lib/hobbes/db/signals.C        |   6 +-
 lib/hobbes/eval/cc.C           |   2 +
 lib/hobbes/eval/cexpr.C        | 374 +++++++++++---------
 lib/hobbes/eval/func.C         | 372 ++++++++++----------
 lib/hobbes/eval/jitcc.C        | 615 +++++++++++++++++++++++++++++----
 lib/hobbes/eval/orcjitcc.C     |  96 +++++
 lib/hobbes/lang/pat/dfa.C      |  42 ++-
 test/Arrays.C                  |   2 +-
 test/Matching.C                |  28 +-
 16 files changed, 1701 insertions(+), 564 deletions(-)
 create mode 100644 .gitlab-ci.yml
 create mode 100644 include/hobbes/eval/orcjitcc.H
 create mode 100644 lib/hobbes/eval/orcjitcc.C

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 000000000..ca1887ebf
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,76 @@
+# This file is a template, and might need editing before it works on your project.
+# To contribute improvements to CI/CD templates, please follow the Development guide at:
+# https://docs.gitlab.com/ee/development/cicd/templates.html
+# This specific template is located at:
+# https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Getting-Started.gitlab-ci.yml
+
+# This is a sample GitLab CI/CD configuration file that should run without any modifications.
+# It demonstrates a basic 3 stage CI/CD pipeline. Instead of real tests or scripts,
+# it uses echo commands to simulate the pipeline execution.
+#
+# A pipeline is composed of independent jobs that run scripts, grouped into stages.
+# Stages run in sequential order, but jobs within stages run in parallel.
+#
+# For more information, see: https://docs.gitlab.com/ee/ci/yaml/README.html#stages
+image: nixpkgs/nix-flakes:latest
+stages:          # List of stages for jobs, and their order of execution
+  - build
+  - test
+  - deploy
+
+build-job-gcc10-llvm11:       # This job runs in the build stage, which runs first.
+  stage: build
+  script:
+    - echo "Compiling the code..."
+    - nix build .#hobbesPackages/gcc-10/llvm-11/hobbes 
+    - echo "Compile complete."
+  after_script:
+    - echo "nix log .#hobbesPackages/gcc-10/llvm-11/hobbes..."
+    - mkdir -pv log-job-gcc10-llvm11
+    - nix log .#hobbesPackages/gcc-10/llvm-11/hobbes > log-job-gcc10-llvm11/nix.log
+    - echo "nix log .#hobbesPackages/gcc-10/llvm-11/hobbes complete."
+  artifacts:
+    name: "$CI_COMMIT_REF_SLUG"
+    paths:
+      - log-job-gcc10-llvm11/
+    expire_in: 1 week
+    when: always
+
+build-job-clang11:       # This job runs in the build stage, which runs first.
+  stage: build
+  script:
+    - mkdir -pv log-clang-11    
+    - echo "Compiling the code..."
+    - nix build .#hobbesPackages/clang-11/hobbes; nix log .#hobbesPackages/clang-11/hobbes > log-job-clang-11/nix.log
+    - echo "Compile complete."
+  after_script:
+    - echo "nix log .#hobbesPackages/clang-11/hobbes..."
+    - mkdir -pv log-job-clang-11
+    - nix log .#hobbesPackages/clang-11/hobbes > log-job-clang-11/nix.log
+    - echo "nix log .#hobbesPackages/clang-11/hobbes complete."    
+  artifacts:
+    name: "$CI_COMMIT_REF_SLUG"
+    paths:
+      - log-job-clang-11/
+    expire_in: 1 week
+    when: always
+
+unit-test-job-gcc:   # This job runs in the test stage.
+  stage: test    # It only starts when the job in the build stage completes successfully.
+  script:
+    - echo "Running unit tests... This will take about 60 seconds."
+    - sleep 60
+    - echo "Code coverage is 90%"
+
+lint-test-job:   # This job also runs in the test stage.
+  stage: test    # It can run at the same time as unit-test-job (in parallel).
+  script:
+    - echo "Linting code... This will take about 10 seconds."
+    - sleep 10
+    - echo "No lint issues found."
+
+deploy-job:      # This job runs in the deploy stage.
+  stage: deploy  # It only runs when *both* jobs in the test stage complete successfully.
+  script:
+    - echo "Deploying application..."
+    - echo "Application successfully deployed."
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2f811767a..dc8b250d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,8 +21,10 @@ set(CMAKE_CXX_STANDARD 14)
 
 if (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.6")
   set(jit_lib jit)
-else()
+elseif(${LLVM_PACKAGE_VERSION} VERSION_LESS "11.0")
   set(jit_lib mcjit)
+else()
+  set(jit_lib mcjit orcjit)
 endif()
 
 find_program(llvm-config llvm-config PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)
diff --git a/include/hobbes/eval/jitcc.H b/include/hobbes/eval/jitcc.H
index 33f64b033..d75a28e4c 100644
--- a/include/hobbes/eval/jitcc.H
+++ b/include/hobbes/eval/jitcc.H
@@ -10,10 +10,17 @@
 #include <hobbes/eval/func.H>
 #include <hobbes/eval/ctype.H>
 
+#if LLVM_VERSION_MAJOR >= 11
+#include <llvm/IR/ValueHandle.h>
+#endif
 #include <map>
 #include <string>
 #include <vector>
 
+namespace llvm {
+class GlobalVariable;
+}
+
 namespace hobbes {
 
 // an operation, which can emit some specialized assembly code
@@ -29,6 +36,13 @@ struct op {
   virtual llvm::Value* apply(jitcc* ev, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) = 0;
 };
 
+#if LLVM_VERSION_MAJOR >= 11
+class ORCJIT;
+class Globals;
+class VTEnv;
+class ConstantList;
+#endif
+
 // a JIT compiler for monotyped expressions
 class jitcc {
 public:
@@ -42,14 +56,16 @@ public:
   // get the address of a bound symbol
   void* getSymbolAddress(const std::string&);
 
+#if LLVM_VERSION_MAJOR < 11
   // print all module contents
   void dump() const;
+#endif
 
   // define a global from a primitive expression
   void defineGlobal(const std::string& vname, const ExprPtr& unsweetExp);
 
   // define a global on some existing memory
-  void bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* v);
+  void bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x);
 
   // is there a definition of the named symbol?
   bool isDefined(const std::string&) const;
@@ -115,17 +131,26 @@ private:
   TEnvPtr tenv;
 
   // produce some machine code for a compiled function
-  void* getMachineCode(llvm::Function*, llvm::JITEventListener* listener = 0);
+  void* getMachineCode(llvm::Function*, llvm::JITEventListener* listener = nullptr);
 
+#if LLVM_VERSION_MAJOR >= 11
+  std::unique_ptr<llvm::Module> currentModule;
+#else
   // the current non-finalized module
   // (new definitions will be accumulated here)
   // (may be null, to lazily allocate modules)
-  llvm::Module* currentModule;
+  llvm::Module* currentModule = nullptr;
+#endif
 
+#if LLVM_VERSION_MAJOR < 11
   // the set of allocated modules
   typedef std::vector<llvm::Module*> Modules;
   Modules modules;
+#endif
 
+#if LLVM_VERSION_MAJOR >= 11
+
+#else
 #if LLVM_VERSION_MINOR == 6 || LLVM_VERSION_MINOR == 7 || LLVM_VERSION_MINOR == 8 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR <= 12
   llvm::legacy::PassManager* mpm;
 
@@ -142,19 +167,24 @@ private:
   llvm::legacy::FunctionPassManager* fpm;
 #else
 #error "This version of LLVM is not supported"
+#endif
 #endif
 
   // support incremental construction of LLVM assembly sequences
-  llvm::IRBuilder<>* irbuilder;
+  std::unique_ptr<llvm::IRBuilder<>> irbuilder;
 
   // the bound root function environment
   typedef std::map<std::string, op*> FuncEnv;
   FuncEnv fenv;
 
   // keep track of variables and local scopes during compilation
+#if LLVM_VERSION_MAJOR >= 11
+  std::unique_ptr<VTEnv> vtenv;
+#else
   typedef std::map<std::string, llvm::Value*> VarBindings;
   typedef std::vector<VarBindings>            VarBindingStack;
   VarBindingStack vtenv;
+#endif
   bool ignoreLocalScope;
 
   // compile sets of mutually-recursive functions (as a special case, single-function compilation)
@@ -173,6 +203,9 @@ private:
   void unsafeCompileFunctions(UCFS*);
 
   // keep track of global variables
+#if LLVM_VERSION_MAJOR >= 11
+  std::unique_ptr<Globals> globals;
+#else
   struct Global {
     MonoTypePtr           type;
     void*                 value;
@@ -183,6 +216,7 @@ private:
   };
   typedef std::map<std::string, Global> Globals;
   Globals globals;
+#endif
 
   // keep track of global data (in case we need to dynamically allocate global variables of any type)
   region globalData;
@@ -190,6 +224,9 @@ private:
   void popGlobalRegion(size_t x);
 
   // keep track of global constants
+#if LLVM_VERSION_MAJOR >= 11
+  std::unique_ptr<ConstantList> constants;
+#else
   struct Constant {
     llvm::Constant*       value;
     llvm::Type*           type;
@@ -198,24 +235,35 @@ private:
   };
   typedef std::map<std::string, Constant> Constants;
   Constants constants;
+#endif
   llvm::Value* loadConstant(const std::string&);
 
   // keep some interned strings, helpful for global constants and debug info
   typedef std::unordered_map<std::string, std::string> InternConstVars;
   InternConstVars internConstVars;
 
+#if LLVM_VERSION_MAJOR >= 11
+  llvm::GlobalVariable* lookupGlobalVar(const std::string&);
+#else
   // try to load a symbol as a global (may return nullptr if this can't be done)
   llvm::GlobalVariable* maybeRefGlobal(const std::string&);
   llvm::GlobalVariable* refGlobal(const std::string&, llvm::GlobalVariable*);
+#endif
 
+#if LLVM_VERSION_MAJOR < 11
   // pass through a value if it's not a global or if it's a global in the current module
   // else wrap it in an extern decl
   llvm::Value* maybeRefGlobalV(llvm::Value*);
+#endif
 
   // keep track of monotyped definitions as expressions
   // (in case we want to inline them later)
   typedef std::map<std::string, ExprPtr> GlobalExprs;
   GlobalExprs globalExprs;
+
+#if LLVM_VERSION_MAJOR >= 11
+  std::unique_ptr<ORCJIT> orcjit;
+#endif
 };
 
 // shorthand for compilation over a sequence of expressions
diff --git a/include/hobbes/eval/orcjitcc.H b/include/hobbes/eval/orcjitcc.H
new file mode 100644
index 000000000..57debbf4f
--- /dev/null
+++ b/include/hobbes/eval/orcjitcc.H
@@ -0,0 +1,55 @@
+#ifndef HOBBES_EVAL_ORCJITCC_HPP_INCLUDED
+#define HOBBES_EVAL_ORCJITCC_HPP_INCLUDED
+
+#include <llvm/Config/llvm-config.h>
+
+#if LLVM_VERSION_MAJOR >= 11
+#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
+#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
+#include <llvm/ExecutionEngine/Orc/IRTransformLayer.h>
+#include <llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h>
+#include <llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h>
+#include <llvm/ExecutionEngine/JITSymbol.h>
+#include <memory>
+
+namespace hobbes {
+
+class ORCJIT {
+public:
+  ORCJIT(std::unique_ptr<llvm::TargetMachine> tm, const llvm::DataLayout& dl);
+  ORCJIT(const ORCJIT&) = delete;
+  ORCJIT(ORCJIT&&) = delete;
+  ORCJIT& operator=(const ORCJIT&) = delete;
+  ORCJIT& operator=(ORCJIT&&) = delete;
+  ~ORCJIT();
+
+  static llvm::Expected<std::unique_ptr<ORCJIT>> create();
+
+  llvm::Error addModule(std::unique_ptr<llvm::Module> m);
+
+  llvm::Expected<llvm::JITEvaluatedSymbol> lookup(llvm::StringRef name);
+
+  llvm::Error addExternalSymbol(llvm::StringRef name, void* ptr);
+
+private:
+  std::unique_ptr<llvm::TargetMachine> targetMachine;
+
+  llvm::orc::ExecutionSession execSession;
+
+  llvm::DataLayout dataLayout;
+  llvm::orc::MangleAndInterner mangle;
+
+  llvm::orc::RTDyldObjectLinkingLayer objectLayer;
+  llvm::orc::IRCompileLayer compileLayer;
+  llvm::orc::IRTransformLayer optLayer;
+
+  llvm::orc::JITDylib& mainJD;
+
+  static llvm::Expected<llvm::orc::ThreadSafeModule>
+  optimizeModule(llvm::orc::ThreadSafeModule tsm, const llvm::orc::MaterializationResponsibility&);
+
+};
+} // namespace hobbes
+
+#endif
+#endif
diff --git a/include/hobbes/hobbes.H b/include/hobbes/hobbes.H
index b42f203b7..8019945e0 100644
--- a/include/hobbes/hobbes.H
+++ b/include/hobbes/hobbes.H
@@ -2,24 +2,41 @@
 #ifndef HOBBES_MAIN_HPP_INCLUDED
 #define HOBBES_MAIN_HPP_INCLUDED
 
-#include <hobbes/reflect.H>
 #include <hobbes/eval/cc.H>
 #include <hobbes/eval/cmodule.H>
-#include <hobbes/lang/tylift.H>
-#include <hobbes/read/parser.H>
 #include <hobbes/events/events.H>
 #include <hobbes/ipc/prepl.H>
-#include <hobbes/util/region.H>
+#include <hobbes/lang/tylift.H>
+#include <hobbes/read/parser.H>
+#include <hobbes/reflect.H>
 #include <hobbes/util/ptr.H>
+#include <hobbes/util/region.H>
+
+#include <llvm/ADT/SmallString.h>
+#include <llvm/ADT/StringMap.h>
+#include <llvm/Support/FormatVariadic.h>
+
+#define llerrs(x)                                                              \
+  do {                                                                         \
+    llvm::errs() << "file:" << __FILE__ << "(" << __LINE__ << ")"              \
+                 << ", func:" << __PRETTY_FUNCTION__ << ": " << x << '\n';     \
+  } while (false)
 
 namespace hobbes {
 
+LLVM_NODISCARD inline std::string createUniqueName(llvm::StringRef prefix) {
+  static llvm::StringMap<std::atomic_int> m;
+  return llvm::formatv("{0}{1}", prefix, llvm::to_string(m[prefix]++));
+}
+
 // type aliases for common types
 DEFINE_TYPE_ALIAS_AS(timespanT, timespan, int64_t);
 
-inline uint64_t microseconds(const timespanT& ts) { return ts.value; }
-inline uint64_t milliseconds(const timespanT& ts) { return microseconds(ts) / 1000; }
-inline uint64_t seconds     (const timespanT& ts) { return milliseconds(ts) / 1000; }
+inline uint64_t microseconds(const timespanT &ts) { return ts.value; }
+inline uint64_t milliseconds(const timespanT &ts) {
+  return microseconds(ts) / 1000;
+}
+inline uint64_t seconds(const timespanT &ts) { return milliseconds(ts) / 1000; }
 
 DEFINE_TYPE_ALIAS_AS(timeT, time, int64_t);
 DEFINE_TYPE_ALIAS_AS(datetimeT, datetime, int64_t);
@@ -31,50 +48,50 @@ datetimeT datetimeAt(datetimeT, timeT);
 timespanT gmtoffset(datetimeT);
 
 // allocate some memory in the calling thread's memory pool
-char* memalloc(size_t, size_t);
+char *memalloc(size_t, size_t);
 
 // string representations, I/O
-const array<char>* makeString(const std::string& x);
-std::string makeStdString(const array<char>* x);
+const array<char> *makeString(const std::string &x);
+std::string makeStdString(const array<char> *x);
 
-const array<char>* makeString(region& m, const char* s);
-const array<char>* makeString(region& m, const std::string& s);
-const array<char>* makeString(region& m, const char* s, size_t len);
-const array<char>* makeString(const char* s, size_t len);
+const array<char> *makeString(region &m, const char *s);
+const array<char> *makeString(region &m, const std::string &s);
+const array<char> *makeString(region &m, const char *s, size_t len);
+const array<char> *makeString(const char *s, size_t len);
 
-inline std::ostream& operator<<(std::ostream& out, const array<char>* x) {
+inline std::ostream &operator<<(std::ostream &out, const array<char> *x) {
   out.write(x->data, x->size);
   return out;
 }
 
 // allocate an array at some type, with some length
-template <typename T>
-  array<T>* defInitArray(array<T>* xs) {
-    if (xs->size > 0) {
-      new (xs->data) T[xs->size];
-    }
-    return xs;
+template <typename T> array<T> *defInitArray(array<T> *xs) {
+  if (xs->size > 0) {
+    new (xs->data) T[xs->size];
   }
+  return xs;
+}
 
-template <typename T>
-  array<T>* makeArray(region& m, long n) {
-    array<T>* r = reinterpret_cast<array<T>*>(m.malloc(sizeof(long) + (sizeof(T) * n), std::max<size_t>(sizeof(long), alignof(T))));
-    r->size = n;
-    return defInitArray<T>(r);
-  }
+template <typename T> array<T> *makeArray(region &m, long n) {
+  array<T> *r = reinterpret_cast<array<T> *>(
+      m.malloc(sizeof(long) + (sizeof(T) * n),
+               std::max<size_t>(sizeof(long), alignof(T))));
+  r->size = n;
+  return defInitArray<T>(r);
+}
 
-template <typename T>
-  array<T>* makeArray(long n) {
-    array<T>* r = reinterpret_cast<array<T>*>(memalloc(sizeof(long) + (sizeof(T) * n), std::max<size_t>(sizeof(long), alignof(T))));
-    r->size = n;
-    return defInitArray<T>(r);
-  }
+template <typename T> array<T> *makeArray(long n) {
+  array<T> *r = reinterpret_cast<array<T> *>(
+      memalloc(sizeof(long) + (sizeof(T) * n),
+               std::max<size_t>(sizeof(long), alignof(T))));
+  r->size = n;
+  return defInitArray<T>(r);
+}
 
 // allocate ... something
-template <typename T, typename ... Args>
-  T* make(const Args& ... args) {
-    return new (memalloc(sizeof(T), alignof(T))) T(args...);
-  }
+template <typename T, typename... Args> T *make(const Args &...args) {
+  return new (memalloc(sizeof(T), alignof(T))) T(args...);
+}
 
 // resets the thread-local memory pool for expressions
 //   (subsequent allocations will reuse previously-used memory)
@@ -90,11 +107,11 @@ public:
 std::string showMemoryPool();
 
 // control the set of regions used for dynamic allocation
-size_t addThreadRegion(const std::string&, region*);
-size_t findThreadRegion(const std::string&);
+size_t addThreadRegion(const std::string &, region *);
+size_t findThreadRegion(const std::string &);
 void removeThreadRegion(size_t);
 size_t setThreadRegion(size_t);
 
-}
+} // namespace hobbes
 
 #endif
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index 0254c508b..771aec681 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -3,6 +3,9 @@
 #define HOBBES_UTIL_LLVM_HPP_INCLUDED
 
 #include <hobbes/util/array.H>
+#if LLVM_VERSION_MAJOR >= 11
+#include <hobbes/lang/type.H>
+#endif
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
@@ -29,7 +32,7 @@
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Support/TargetRegistry.h>
 #include <llvm/Support/Signals.h>
-#if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR <= 8 
+#if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR <= 8
 #  include <llvm/Bitcode/BitstreamReader.h>
 #  include <llvm/Bitcode/BitstreamWriter.h>
 #elif  LLVM_VERSION_MAJOR <= 12
@@ -54,12 +57,228 @@
 #  include <llvm/Object/ELFObjectFile.h>
 #endif
 
+#if LLVM_VERSION_MAJOR >= 11
+#  include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
+#endif
+
 #pragma GCC diagnostic pop
 
 namespace hobbes {
 
 typedef __int128 int128_t;
 
+
+#if LLVM_VERSION_MAJOR >= 11
+inline llvm::orc::ThreadSafeContext& threadSafeContext() {
+  static auto c = llvm::orc::ThreadSafeContext(std::make_unique<llvm::LLVMContext>());
+  return c;
+}
+
+template <typename Fn> auto withContext(Fn fn) -> decltype(auto) {
+  auto lk = threadSafeContext().getLock();
+  return fn(*threadSafeContext().getContext());
+}
+
+typedef std::vector<llvm::Type*>     Types;
+typedef std::vector<llvm::Constant*> Constants;
+typedef std::vector<llvm::Value*>    Values;
+
+// type utilities
+inline llvm::Type* voidType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getVoidTy(c); });
+}
+
+inline llvm::Type* boolType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getInt1Ty(c); });
+}
+
+inline llvm::Type* charType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getInt8Ty(c); });
+}
+
+inline llvm::Type* byteType() {
+  return charType();
+}
+
+inline llvm::Type* shortType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getInt16Ty(c); });
+}
+
+inline llvm::Type* intType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getInt32Ty(c); });
+}
+
+inline llvm::Type* longType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getInt64Ty(c); });
+}
+
+inline llvm::Type* int128Type() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getIntNTy(c, 128); });
+}
+
+inline llvm::Type* floatType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getFloatTy(c); });
+}
+
+inline llvm::Type* doubleType() {
+  return withContext([](llvm::LLVMContext& c) { return llvm::Type::getDoubleTy(c); });
+}
+
+inline llvm::PointerType* ptrType(llvm::Type* ty) {
+  return llvm::PointerType::getUnqual(ty);
+}
+
+inline llvm::ArrayType* arrayType(llvm::Type* ty, size_t sz) {
+  // we can be a little dishonest in describing the type of arrays of unit, since LLVM barfs on arrays of unit
+  // and we should never need to look at the "data" in an array of unit values _anyway_!
+  return llvm::ArrayType::get(ty->isVoidTy() ? boolType() : ty, static_cast<uint64_t>(sz));
+}
+
+inline llvm::StructType* packedRecordType(const Types& tys) {
+  return withContext([&tys](llvm::LLVMContext& c) { return llvm::StructType::get(c, tys, true); });
+}
+
+inline llvm::StructType* recordType(const Types& tys) {
+  return withContext([&tys](llvm::LLVMContext& c) { return llvm::StructType::get(c, tys); });
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0) {
+  return recordType(list(t0));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1) {
+  return recordType(list(t0, t1));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1, llvm::Type* t2) {
+  return recordType(list(t0, t1, t2));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1, llvm::Type* t2, llvm::Type* t3) {
+  return recordType(list(t0, t1, t2, t3));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1, llvm::Type* t2, llvm::Type* t3, llvm::Type* t4) {
+  return recordType(list(t0, t1, t2, t3, t4));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1, llvm::Type* t2, llvm::Type* t3, llvm::Type* t4, llvm::Type* t5) {
+  return recordType(list(t0, t1, t2, t3, t4, t5));
+}
+
+inline llvm::StructType* recordType(llvm::Type* t0, llvm::Type* t1, llvm::Type* t2, llvm::Type* t3, llvm::Type* t4, llvm::Type* t5, llvm::Type* t6) {
+  return recordType(list(t0, t1, t2, t3, t4, t5, t6));
+}
+
+inline llvm::FunctionType* functionType(const Types& argTys, llvm::Type* rty) {
+  return llvm::FunctionType::get(rty, argTys, false);
+}
+
+inline llvm::StructType* varArrayType(llvm::Type* elemty, size_t sz = 1) {
+  return recordType(longType(), arrayType(elemty, sz));
+}
+
+// casting
+inline llvm::Value* cast(llvm::IRBuilder<>* b, llvm::Type* ty, llvm::Value* v) {
+  return b->CreateBitCast(v, ty);
+}
+
+inline llvm::Constant* ccast(llvm::Type* ty, llvm::Constant* v) {
+  return llvm::ConstantExpr::getBitCast(v, ty);
+}
+
+// constant utilities
+inline llvm::Constant* cvalue(bool x) {
+  return llvm::Constant::getIntegerValue(boolType(), llvm::APInt(1, x ? 1 : 0, false));
+}
+
+inline llvm::Constant* cvalue(char x) {
+  return llvm::Constant::getIntegerValue(charType(), llvm::APInt(8, x, true));
+}
+
+inline llvm::Constant* cvalue(unsigned char x) {
+  return llvm::Constant::getIntegerValue(charType(), llvm::APInt(8, x, false));
+}
+
+inline llvm::Constant* cvalue(short x) {
+  return llvm::Constant::getIntegerValue(shortType(), llvm::APInt(16, x, false));
+}
+
+inline llvm::Constant* cvalue(int x) {
+  return llvm::Constant::getIntegerValue(intType(), llvm::APInt(32, x, true));
+}
+
+inline llvm::Constant* cvalue(unsigned int x) {
+  return llvm::Constant::getIntegerValue(intType(), llvm::APInt(32, x, true));
+}
+
+inline llvm::Constant* cvalue(long x) {
+  return llvm::Constant::getIntegerValue(longType(), llvm::APInt(64, x, true));
+}
+
+inline llvm::Constant* cvalue(int128_t x) {
+  return llvm::Constant::getIntegerValue(int128Type(), llvm::APInt(128, x, true));
+}
+
+inline llvm::Constant* cvalue(float x) {
+  return withContext(
+      [x](llvm::LLVMContext& c) { return llvm::ConstantFP::get(c, llvm::APFloat(x)); });
+}
+
+inline llvm::Constant* cvalue(double x) {
+  return withContext(
+      [x](llvm::LLVMContext& c) { return llvm::ConstantFP::get(c, llvm::APFloat(x)); });
+}
+
+// constant int utilities (different than constants to LLVM!)
+inline llvm::ConstantInt* civalue(bool x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 1), static_cast<uint64_t>(x ? 1 : 0));
+  });
+}
+
+inline llvm::ConstantInt* civalue(char x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 8), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(unsigned char x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 8), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(short x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 16), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(int x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 32), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(unsigned int x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 32), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(long x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 64), static_cast<uint64_t>(x));
+  });
+}
+
+inline llvm::ConstantInt* civalue(int128_t x) {
+  return withContext([x](llvm::LLVMContext& c) {
+    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 128), x); // static_cast<uint64_t>(x));
+  });
+}
+#else
 // keep one context per thread to avoid global locking
 // NOTE: temporarily reverting to one global context
 //       this is because we have some cases where we partially compile in one thread and then resume compiling in another thread
@@ -69,6 +288,10 @@ inline llvm::LLVMContext& context() {
   return ctx;
 }
 
+template <typename Fn> auto withContext(Fn fn) -> decltype(auto) {
+  return fn(context());
+}
+
 typedef std::vector<llvm::Type*>     Types;
 typedef std::vector<llvm::Constant*> Constants;
 typedef std::vector<llvm::Value*>    Values;
@@ -251,6 +474,7 @@ inline llvm::ConstantInt* civalue(int128_t x) {
   return llvm::ConstantInt::get(llvm::IntegerType::get(context(), 128), x); //static_cast<uint64_t>(x));
 }
 
+#endif
 // an intermediate representation for records
 typedef std::pair<std::string, llvm::Value*> FieldValue;
 typedef std::vector<FieldValue>              RecordValue;
@@ -530,6 +754,7 @@ inline llvm::ExecutionEngine* makeExecutionEngine(llvm::Module* m, llvm::Section
 }
 #endif
 
+#if LLVM_VERSION_MAJOR < 11
 inline llvm::Function* externDecl(llvm::Function* remoteFn, llvm::Module* thisModule) {
   if (llvm::Function* ef = thisModule->getFunction(remoteFn->getName())) {
     return ef;
@@ -537,7 +762,9 @@ inline llvm::Function* externDecl(llvm::Function* remoteFn, llvm::Module* thisMo
     return llvm::Function::Create(remoteFn->getFunctionType(), llvm::Function::ExternalLinkage, remoteFn->getName(), thisModule);
   }
 }
+#endif
 
+#if LLVM_VERSION_MAJOR < 11
 const size_t FUNCTION_SIZE_THRESHOLD = 64;
 inline llvm::Function* cloneFunction(llvm::Function *f, llvm::Module *targetMod) {
   using namespace llvm;
@@ -568,6 +795,7 @@ inline llvm::Function* cloneFunction(llvm::Function *f, llvm::Module *targetMod)
   CloneFunctionInto(newF, f, vmap, false, returns);
   return newF;
 }
+#endif
 
 inline llvm::Value* fncall(llvm::IRBuilder<>* b, llvm::Value* vfn, llvm::Type* tfn, const Values& args) {
     (void)tfn;
diff --git a/lib/hobbes/db/bindings.C b/lib/hobbes/db/bindings.C
index a66fe61b5..448f223c3 100644
--- a/lib/hobbes/db/bindings.C
+++ b/lib/hobbes/db/bindings.C
@@ -189,13 +189,15 @@ class dbloadVF : public op {
     llvm::Function* f = c->lookupFunction(".dbloado");
     if (!f) { throw std::runtime_error("Expected 'dbloado' function as call"); }
 
-    llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
+    return withContext([&](auto&) -> llvm::Value* {
+      llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
 
-    if (hasPointerRep(rty)) {
-      return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
-    } else {
-      return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
-    }
+      if (hasPointerRep(rty)) {
+        return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
+      } else {
+        return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
+      }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -223,19 +225,21 @@ class dbstoreVF : public op {
     llvm::Function* f = c->lookupFunction(".dbloado");
     if (!f) { throw std::runtime_error("Expected 'dbloado' function as call"); }
 
-    llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
+    return withContext([&](auto&) -> llvm::Value* {
+      llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
 
-    if (hasPointerRep(sty)) {
-      allocv = c->builder()->CreateBitCast(allocv, toLLVM(sty, true));
-    } else {
-      allocv = c->builder()->CreateBitCast(allocv, ptrType(toLLVM(sty, true)));
-    }
+      if (hasPointerRep(sty)) {
+        allocv = c->builder()->CreateBitCast(allocv, toLLVM(sty, true));
+      } else {
+        allocv = c->builder()->CreateBitCast(allocv, ptrType(toLLVM(sty, true)));
+      }
 
-    if (isLargeType(sty)) {
-      return memCopy(c->builder(), allocv, 8, outv, 8, sizeOf(sty));
-    } else {
-      return c->builder()->CreateStore(outv, allocv);
-    }
+      if (isLargeType(sty)) {
+        return memCopy(c->builder(), allocv, 8, outv, 8, sizeOf(sty));
+      } else {
+        return c->builder()->CreateStore(outv, allocv);
+      }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -260,29 +264,31 @@ struct dbloadF : public op {
       return cvalue(true);
     }
 
-    // are we loading an array or a non-array?
-    if (storedAsDArray(rty)) {
-      llvm::Function* f = c->lookupFunction(".dbloaddarr");
-      if (!f) { throw std::runtime_error("Expected 'dbloaddarr' function as call"); }
+    return withContext([&](auto&) -> llvm::Value* {
+      // are we loading an array or a non-array?
+      if (storedAsDArray(rty)) {
+        llvm::Function* f = c->lookupFunction(".dbloaddarr");
+        if (!f) { throw std::runtime_error("Expected 'dbloaddarr' function as call"); }
 
-      return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off)), toLLVM(rty, true));
-    } else if (const Array* t = storedAsArray(rty)) {
-      llvm::Function* f = c->lookupFunction(".dbloadarr");
-      if (!f) { throw std::runtime_error("Expected 'dbloadarr' function as call"); }
+        return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off)), toLLVM(rty, true));
+      } else if (const Array* t = storedAsArray(rty)) {
+        llvm::Function* f = c->lookupFunction(".dbloadarr");
+        if (!f) { throw std::runtime_error("Expected 'dbloadarr' function as call"); }
 
-      return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(t->type()))))), toLLVM(rty, true));
-    } else {
-      llvm::Function* f = c->lookupFunction(".dbloadv");
-      if (!f) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
+        return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(t->type()))))), toLLVM(rty, true));
+      } else {
+        llvm::Function* f = c->lookupFunction(".dbloadv");
+        if (!f) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
-      llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(rty)))));
+        llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(rty)))));
 
-      if (hasPointerRep(rty)) {
-        return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
-      } else {
-        return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
+        if (hasPointerRep(rty)) {
+          return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
+        } else {
+          return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
+        }
       }
-    }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -303,29 +309,31 @@ struct dbloadPF : public op {
       return cvalue(true);
     }
 
-    // are we loading an array or a non-array?
-    if (storedAsDArray(rty)) {
-      llvm::Function* f = c->lookupFunction(".dbloaddarr");
-      if (!f) { throw std::runtime_error("Expected 'dbloaddarr' function as call"); }
+    return withContext([&](auto&) -> llvm::Value* {
+      // are we loading an array or a non-array?
+      if (storedAsDArray(rty)) {
+        llvm::Function* f = c->lookupFunction(".dbloaddarr");
+        if (!f) { throw std::runtime_error("Expected 'dbloaddarr' function as call"); }
 
-      return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off)), toLLVM(rty, true));
-    } else if (const Array* a = storedAsArray(rty)) {
-      llvm::Function* f = c->lookupFunction(".dbloadarr");
-      if (!f) { throw std::runtime_error("Expected 'dbloadarr' function as call"); }
+        return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off)), toLLVM(rty, true));
+      } else if (const Array* a = storedAsArray(rty)) {
+        llvm::Function* f = c->lookupFunction(".dbloadarr");
+        if (!f) { throw std::runtime_error("Expected 'dbloadarr' function as call"); }
 
-      return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(a->type()))))), toLLVM(rty, true));
-    } else {
-      llvm::Function* f = c->lookupFunction(".dbloadv");
-      if (!f) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
+        return c->builder()->CreateBitCast(fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(a->type()))))), toLLVM(rty, true));
+      } else {
+        llvm::Function* f = c->lookupFunction(".dbloadv");
+        if (!f) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
-      llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(rty)))));
+        llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(storageSizeOf(rty)))));
 
-      if (hasPointerRep(rty)) {
-        return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
-      } else {
-        return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
+        if (hasPointerRep(rty)) {
+          return c->builder()->CreateBitCast(allocv, toLLVM(rty, true));
+        } else {
+          return c->builder()->CreateLoad(c->builder()->CreateBitCast(allocv, ptrType(toLLVM(rty, true))));
+        }
       }
-    }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -376,32 +384,34 @@ void dbunloadarr(long db, long ptr, long sz) {
 struct dbunloadF : public op {
   llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
     llvm::Value* db  = c->compile(es[0]);
-    llvm::Value* val = c->builder()->CreatePtrToInt(c->compile(es[1]), toLLVM(primty("long"), true));
+    return withContext([&](auto&) -> llvm::Value* {
+      llvm::Value* val = c->builder()->CreatePtrToInt(c->compile(es[1]), toLLVM(primty("long"), true));
 
-    // sure you can unload a unit value ...
-    if (isUnit(tys[1])) {
-      return cvalue(true);
-    }
+      // sure you can unload a unit value ...
+      if (isUnit(tys[1])) {
+        return cvalue(true);
+      }
 
-    // are we unloading an array or a non-array?
-    if (storedAsDArray(tys[1])) {
-      llvm::Function* f = c->lookupFunction(".dbunloaddarr");
-      if (!f) { throw std::runtime_error("Expected 'dbunloaddarr' function as call"); }
+      // are we unloading an array or a non-array?
+      if (storedAsDArray(tys[1])) {
+        llvm::Function* f = c->lookupFunction(".dbunloaddarr");
+        if (!f) { throw std::runtime_error("Expected 'dbunloaddarr' function as call"); }
 
-      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val));
-    } else if (const Array* a = storedAsArray(tys[1])) {
-      llvm::Function* f = c->lookupFunction(".dbunloadarr");
-      if (!f) { throw std::runtime_error("Expected 'dbunloadarr' function as call"); }
+        return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val));
+      } else if (const Array* a = storedAsArray(tys[1])) {
+        llvm::Function* f = c->lookupFunction(".dbunloadarr");
+        if (!f) { throw std::runtime_error("Expected 'dbunloadarr' function as call"); }
 
-      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val, cvalue(static_cast<long>(storageSizeOf(a->type())))));
-    } else if (!hasPointerRep(tys[1])) {
-      return cvalue(true);
-    } else {
-      llvm::Function* f = c->lookupFunction(".dbunloadv");
-      if (!f) { throw std::runtime_error("Expected 'dbunloadv' function as call"); }
+        return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val, cvalue(static_cast<long>(storageSizeOf(a->type())))));
+      } else if (!hasPointerRep(tys[1])) {
+        return cvalue(true);
+      } else {
+        llvm::Function* f = c->lookupFunction(".dbunloadv");
+        if (!f) { throw std::runtime_error("Expected 'dbunloadv' function as call"); }
 
-      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val, cvalue(static_cast<long>(storageSizeOf(tys[1])))));
-    }
+        return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, val, cvalue(static_cast<long>(storageSizeOf(tys[1])))));
+      }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -428,7 +438,9 @@ struct dballocF : public op {
     if (!f) { throw std::runtime_error("Expected 'dballoc' function as call"); }
 
     size_t sz = storageSizeOf(frefType(rty));
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -454,14 +466,16 @@ struct dbstoreF : public op {
       if (!dblf) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
       size_t sz = storageSizeOf(frefType(rty));
-      llvm::Value* id = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
+      return withContext([&](auto&) {
+        llvm::Value* id = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
 
-      if (!isUnit(tys[0])) {
-        llvm::Value* p = fncall(c->builder(), dblf, dblf->getFunctionType(), list<llvm::Value*>(db, id, cvalue(static_cast<long>(sz))));
-        memCopy(c->builder(), p, 8, c->builder()->CreateBitCast(v, ptrType(charType())), 8, sz);
-      }
+        if (!isUnit(tys[0])) {
+          llvm::Value* p = fncall(c->builder(), dblf, dblf->getFunctionType(), list<llvm::Value*>(db, id, cvalue(static_cast<long>(sz))));
+          memCopy(c->builder(), p, 8, c->builder()->CreateBitCast(v, ptrType(charType())), 8, sz);
+        }
 
-      return id;
+        return id;
+      });
     }
   }
 
@@ -488,14 +502,16 @@ struct dbstorePF : public op {
       if (!dblf) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
       size_t sz = storageSizeOf(frefType(rty));
-      llvm::Value* id = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
+      return withContext([&](auto&) {
+        llvm::Value* id = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(sz)), cvalue(static_cast<long>(alignment(frefType(rty))))));
 
-      if (!isUnit(tys[1])) {
-        llvm::Value* p = fncall(c->builder(), dblf, dblf->getFunctionType(), list<llvm::Value*>(db, id, cvalue(static_cast<long>(sz))));
-        memCopy(c->builder(), p, 8, c->builder()->CreateBitCast(v, ptrType(charType())), 8, sz);
-      }
+        if (!isUnit(tys[1])) {
+          llvm::Value* p = fncall(c->builder(), dblf, dblf->getFunctionType(), list<llvm::Value*>(db, id, cvalue(static_cast<long>(sz))));
+          memCopy(c->builder(), p, 8, c->builder()->CreateBitCast(v, ptrType(charType())), 8, sz);
+        }
 
-      return id;
+        return id;
+      });
     }
   }
 
@@ -523,7 +539,9 @@ struct dballocArrF : public op {
     if (!f) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
 
     size_t elemsz = storageSizeOf(arrType(frt.first));
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), len));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), len));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -543,7 +561,9 @@ struct dballocArrPF : public op {
     if (!f) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
 
     size_t elemsz = storageSizeOf(arrType(frefType(rty)));
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), len));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), len));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -570,7 +590,9 @@ struct dbarrCapacityF : public op {
     if (!f) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
 
     size_t elemsz = storageSizeOf(darrType(frt.first));
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), off));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), off));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -590,7 +612,9 @@ struct dbarrCapacityPF : public op {
     if (!f) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
 
     size_t elemsz = storageSizeOf(darrType(frefType(tys[1])));
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), off));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, cvalue(static_cast<long>(elemsz)), off));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -635,7 +659,9 @@ struct signalUpdateF : public op {
     llvm::Function* f = c->lookupFunction(".dbsignalupdate");
     if (!f) { throw std::runtime_error("Expected 'dbsignalupdate' function as call"); }
 
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
diff --git a/lib/hobbes/db/signals.C b/lib/hobbes/db/signals.C
index 7c2ccdb92..1509f63cf 100644
--- a/lib/hobbes/db/signals.C
+++ b/lib/hobbes/db/signals.C
@@ -266,12 +266,14 @@ struct addFileSignalF : public op {
 
     if (isDArr) {
       sz  = sizeof(long);
-      off = c->builder()->CreateAdd(off, cvalue(static_cast<long>(sizeof(long))));
+      off = withContext([c, off](auto&) { return c->builder()->CreateAdd(off, cvalue(static_cast<long>(sizeof(long)))); });
     } else {
       sz = storageSizeOf(refty);
     }
 
-    return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(sz)), cvalue(static_cast<uint8_t>(isDArr ? BROffsetType::DArray : BROffsetType::Value)), sfn));
+    return withContext([&](auto&) {
+      return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off, cvalue(static_cast<long>(sz)), cvalue(static_cast<uint8_t>(isDArr ? BROffsetType::DArray : BROffsetType::Value)), sfn));
+    });
   }
 
   PolyTypePtr type(typedb&) const {
diff --git a/lib/hobbes/eval/cc.C b/lib/hobbes/eval/cc.C
index 3fc8de528..3c8ece766 100644
--- a/lib/hobbes/eval/cc.C
+++ b/lib/hobbes/eval/cc.C
@@ -557,8 +557,10 @@ const TEnvPtr& cc::typeEnv() const {
 }
 
 void cc::dumpModule() {
+#if LLVM_VERSION_MAJOR < 11
   hlock _;
   this->jit->dump();
+#endif
 }
 
 cc::bytes cc::machineCodeForExpr(const std::string& expr) {
diff --git a/lib/hobbes/eval/cexpr.C b/lib/hobbes/eval/cexpr.C
index 812fea360..1e94f0352 100644
--- a/lib/hobbes/eval/cexpr.C
+++ b/lib/hobbes/eval/cexpr.C
@@ -6,6 +6,8 @@
 #include <hobbes/lang/type.H>
 #include <hobbes/util/llvm.H>
 #include <hobbes/util/perf.H>
+#include <llvm/IR/Instruction.h>
+#include <llvm/IR/LLVMContext.h>
 
 namespace hobbes {
 
@@ -144,10 +146,12 @@ public:
     }
 
     // it's a standard function call, invoke it in the standard way
-    return fncall(builder(),
-                  compile(v->fn()),
-                  toLLVM(requireMonotype(this->c->typeEnv(), v->fn())),
-                  compileArgs(this->c, v->args()));
+    return withContext([this, v](auto&) {
+      return fncall(builder(),
+                    compile(v->fn()),
+                    toLLVM(requireMonotype(this->c->typeEnv(), v->fn())),
+                    compileArgs(this->c, v->args()));
+    });
   }
 
   llvm::Value* with(const Assign* v) const {
@@ -158,11 +162,13 @@ public:
       llvm::Value* lhs = compileRef(v->left());
       llvm::Value* rhs = compile(v->right());
 
-      if (isLargeType(rty)) {
-        memCopy(builder(), lhs, 8, rhs, 8, sizeOf(rty));
-      } else {
-        builder()->CreateStore(rhs, lhs);
-      }
+      withContext([&](auto&) {
+        if (isLargeType(rty)) {
+          memCopy(builder(), lhs, 8, rhs, 8, sizeOf(rty));
+        } else {
+          builder()->CreateStore(rhs, lhs);
+        }
+      });
 
       return with(rcast<const Unit*>(0));
     } else {
@@ -186,26 +192,28 @@ public:
       llvm::Type*  elemTy      = toLLVM(aty->type(), isStoredPtr);
       llvm::Value* p           = compileAllocStmt(sizeof(long) + sizeOf(aty->type()) * vs.size(), std::max<size_t>(sizeof(long), alignment(aty->type())), ptrType(llvmVarArrType(elemTy)));
 
-      // store the array length
-      llvm::Value* alenp = structOffset(builder(), p, 0);
-      builder()->CreateStore(llvm::Constant::getIntegerValue(longType(), llvm::APInt(64, vs.size(), true)), alenp);
-
-      // store the array contents
-      if (!isUnit(aty->type())) {
-        llvm::Value* adatap = structOffset(builder(), p, 1);
-  
-        for (size_t i = 0; i < vs.size(); ++i) {
-          llvm::Value* ev = vs[i];
-          llvm::Value* ap = offset(builder(), adatap, 0, i);
-
-          // we only memcopy into an array if the data is large and isn't an opaque pointer (always write opaque pointers as pointers)
-          if (!isStoredPtr && isLargeType(aty->type())) {
-            memCopy(builder(), ap, 8, ev, 8, sizeOf(aty->type()));
-          } else {
-            builder()->CreateStore(ev, ap);
+      withContext([&](auto&) {
+        // store the array length
+        llvm::Value* alenp = structOffset(builder(), p, 0);
+        builder()->CreateStore(llvm::Constant::getIntegerValue(longType(), llvm::APInt(64, vs.size(), true)), alenp);
+
+        // store the array contents
+        if (!isUnit(aty->type())) {
+          llvm::Value* adatap = structOffset(builder(), p, 1);
+
+          for (size_t i = 0; i < vs.size(); ++i) {
+            llvm::Value* ev = vs[i];
+            llvm::Value* ap = offset(builder(), adatap, 0, i);
+
+            // we only memcopy into an array if the data is large and isn't an opaque pointer (always write opaque pointers as pointers)
+            if (!isStoredPtr && isLargeType(aty->type())) {
+              memCopy(builder(), ap, 8, ev, 8, sizeOf(aty->type()));
+            } else {
+              builder()->CreateStore(ev, ap);
+            }
           }
         }
-      }
+      });
 
       return p;
     }
@@ -220,24 +228,26 @@ public:
     llvm::Value* tg = cvalue(vty->id(v->label()));
     llvm::Value* tv = compile(v->value());
 
-    // store the variant tag
-    builder()->CreateStore(tg, builder()->CreateBitCast(p, ptrType(intType())));
+    return withContext([&](auto&) {
+      // store the variant tag
+      builder()->CreateStore(tg, builder()->CreateBitCast(p, ptrType(intType())));
 
-    // store the variant value
-    MonoTypePtr  valty = requireMonotype(v->value()->type());
-    llvm::Value* pp    = offset(builder(), p, vty->payloadOffset());
+      // store the variant value
+      MonoTypePtr  valty = requireMonotype(v->value()->type());
+      llvm::Value* pp    = offset(builder(), p, vty->payloadOffset());
 
-    if (isLargeType(valty)) {
-      memCopy(builder(), pp, 8, tv, 8, sizeOf(valty));
-    } else if (isUnit(valty)) {
-      // don't store unit values
-    } else {
-      // store data for this case inline in the variant
-      // (functions should be stored as pointers)
-      builder()->CreateStore(tv, builder()->CreateBitCast(pp, ptrType(toLLVM(valty, is<Func>(valty)))));
-    }
+      if (isLargeType(valty)) {
+        memCopy(builder(), pp, 8, tv, 8, sizeOf(valty));
+      } else if (isUnit(valty)) {
+        // don't store unit values
+      } else {
+        // store data for this case inline in the variant
+        // (functions should be stored as pointers)
+        builder()->CreateStore(tv, builder()->CreateBitCast(pp, ptrType(toLLVM(valty, is<Func>(valty)))));
+      }
 
-    return builder()->CreateBitCast(p, toLLVM(mvty, true));
+      return builder()->CreateBitCast(p, toLLVM(mvty, true));
+    });
   }
 
   llvm::Value* with(const MkRecord* v) const {
@@ -262,11 +272,13 @@ public:
         llvm::Value* fp  = structFieldPtr(p, rty->alignedIndex(rv->first));
         MonoTypePtr  fty = rty->member(rv->first);
 
-        if (isLargeType(fty)) {
-          memCopy(builder(), fp, 8, fv, 8, sizeOf(fty));
-        } else {
-          builder()->CreateStore(fv, fp);
-        }
+        withContext([&](auto&) {
+          if (isLargeType(fty)) {
+            memCopy(builder(), fp, 8, fv, 8, sizeOf(fty));
+          } else {
+            builder()->CreateStore(fv, fp);
+          }
+        });
       }
 
       return p;
@@ -281,14 +293,16 @@ public:
       return with(rcast<const Unit*>(0));
     }
 
-    llvm::Value* ard = structOffset(builder(), ar, 1); // get the array's data pointer
-    llvm::Value* p   = offset(builder(), ard, 0, ir);  // and index into it
+    return withContext([&](auto&) -> llvm::Value* {
+      llvm::Value* ard = structOffset(builder(), ar, 1); // get the array's data pointer
+      llvm::Value* p   = offset(builder(), ard, 0, ir);  // and index into it
 
-    if (isLargeType(aity)) {
-      return p;
-    } else {
-      return builder()->CreateLoad(p, false);
-    }
+      if (isLargeType(aity)) {
+        return p;
+      } else {
+        return builder()->CreateLoad(p, false);
+      }
+    });
   }
 
   // apply a case expression's default expression across every constructor not accounted for
@@ -315,18 +329,24 @@ public:
 
     // compile the variant and pull out the tag and value
     llvm::Value* var  = compile(v->variant());
-    llvm::Value* ptag = builder()->CreateBitCast(var, ptrType(intType()));
-    llvm::Value* tag  = builder()->CreateLoad(ptag, false);
+    llvm::Value* ptag = withContext([this, var](auto&) { return builder()->CreateBitCast(var, ptrType(intType())); });
+    llvm::Value* tag  = withContext([this, ptag](auto&) { return builder()->CreateLoad(ptag, false); });
 
     std::vector<llvm::Value*> idxs;
     idxs.push_back(cvalue(0));
     idxs.push_back(cvalue(vty->payloadOffset()));
-    llvm::Value* pval = builder()->CreateGEP(var, idxs);
-
-    llvm::Function*   thisFn     = builder()->GetInsertBlock()->getParent();
-    llvm::BasicBlock* failBlock  = llvm::BasicBlock::Create(context(), "casefail", thisFn);
-    llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(context(), "casemerge", thisFn);
-    llvm::SwitchInst* s          = builder()->CreateSwitch(tag, failBlock, v->bindings().size());
+    llvm::Value* pval = withContext([&, this](auto&) { return builder()->CreateGEP(var, idxs); });
+
+    llvm::Function*   thisFn     = withContext([this](auto&) { return builder()->GetInsertBlock()->getParent(); });
+    llvm::BasicBlock* failBlock  = withContext([thisFn](llvm::LLVMContext& c) {
+      return llvm::BasicBlock::Create(c, "casefail", thisFn);
+    });
+    llvm::BasicBlock* mergeBlock = withContext([thisFn](llvm::LLVMContext& c) {
+      return llvm::BasicBlock::Create(c, "casemerge", thisFn);
+    });
+    llvm::SwitchInst* s          = withContext([&](auto&) {
+      return builder()->CreateSwitch(tag, failBlock, v->bindings().size());
+    });
 
     typedef std::pair<llvm::Value*, llvm::BasicBlock*> MergeLink;
     typedef std::vector<MergeLink> MergeLinks;
@@ -334,34 +354,37 @@ public:
 
     for (Case::Bindings::const_iterator b = v->bindings().begin(); b != v->bindings().end(); ++b) {
       unsigned int      caseID    = vty->id(b->selector);
-      llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(context(), "case_" + str::from(caseID), thisFn);
+      withContext([&](llvm::LLVMContext& c) {
+        llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(c, "case_" + str::from(caseID), thisFn);
 
-      builder()->SetInsertPoint(caseBlock);
-      try {
-        MonoTypePtr valty = vty->payload(b->selector);
+        builder()->SetInsertPoint(caseBlock);
+        try {
+          MonoTypePtr valty = vty->payload(b->selector);
 
-        if (isUnit(valty)) {
-          beginScope(b->vname, cvalue(true)); // this is unit, so should never be looked at
-        } else {
-          // otherwise the data here is available inline
-          // (and functions are stored as pointers)
-          llvm::Type*  lty      = toLLVM(valty, is<Func>(valty));
-          llvm::Value* pointval = builder()->CreateBitCast(pval, ptrType(lty));
-          llvm::Value* val      = isLargeType(valty) ? pointval : builder()->CreateLoad(pointval, false);
+          if (isUnit(valty)) {
+            beginScope(b->vname, cvalue(true)); // this is unit, so should never be looked at
+          } else {
+            // otherwise the data here is available inline
+            // (and functions are stored as pointers)
+            llvm::Type*  lty      = toLLVM(valty, is<Func>(valty));
+            llvm::Value* pointval = builder()->CreateBitCast(pval, ptrType(lty));
+            llvm::Value* val      = isLargeType(valty) ? pointval : builder()->CreateLoad(pointval, false);
 
-          beginScope(b->vname, val);
-        }
+            beginScope(b->vname, val);
+          }
 
-        llvm::Value* caseValue = switchOf(b->exp, compileExpF("", this->c));
-        mergeLinks.push_back(MergeLink(caseValue, builder()->GetInsertBlock()));
-        builder()->CreateBr(mergeBlock);
-        endScope();
-      } catch (...) {
-        endScope();
-        throw;
-      }
+          llvm::Value* caseValue = switchOf(b->exp, compileExpF("", this->c));
+          mergeLinks.push_back(MergeLink(caseValue, builder()->GetInsertBlock()));
+          builder()->CreateBr(mergeBlock);
+          endScope();
+        } catch (...) {
+          endScope();
+          throw;
+        }
 
-      s->addCase(llvm::ConstantInt::get(llvm::IntegerType::get(context(), 32), scast<uint64_t>(caseID)), caseBlock);
+        s->addCase(llvm::ConstantInt::get(llvm::IntegerType::get(c, 32),
+                                          scast<uint64_t>(caseID)), caseBlock);
+      });
     }
 
     // fill in the default (failure) target for variant matching
@@ -371,26 +394,28 @@ public:
     auto ltxts = v->la().lines(v->la().p0.first-1, v->la().p1.first);
     auto ltxt  = ltxts.size() > 0 ? ltxts[0] : "???";
 
-    builder()->SetInsertPoint(failBlock);
-    fncall(builder(), f, f->getFunctionType(), list(
-      this->c->internConstString(v->la().filename()),
-      cvalue(scast<long>(v->la().p0.first)),
-      this->c->internConstString(ltxt),
-      builder()->CreateBitCast(var, ptrType(charType()))
-    ));
-    builder()->CreateUnreachable();
-
-    // now if the result type is unit, it can be trivially constructed, else merge potential branch results
-    builder()->SetInsertPoint(mergeBlock);
-    if (isUnit(casety)) {
-      return cvalue(true);
-    } else {
-      llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
-      for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
-        pn->addIncoming(ml->first, ml->second);
+    return withContext([&](auto&) -> llvm::Value* {
+      builder()->SetInsertPoint(failBlock);
+      fncall(builder(), f, f->getFunctionType(), list(
+        this->c->internConstString(v->la().filename()),
+        cvalue(scast<long>(v->la().p0.first)),
+        this->c->internConstString(ltxt),
+        builder()->CreateBitCast(var, ptrType(charType()))
+      ));
+      builder()->CreateUnreachable();
+
+      // now if the result type is unit, it can be trivially constructed, else merge potential branch results
+      builder()->SetInsertPoint(mergeBlock);
+      if (isUnit(casety)) {
+        return cvalue(true);
+      } else {
+        llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
+        for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
+          pn->addIncoming(ml->first, ml->second);
+        }
+        return pn;
       }
-      return pn;
-    }
+    });
   }
 
   llvm::Value* with(const Switch* v) const {
@@ -399,49 +424,59 @@ public:
     // prepare to switch on the discriminant
     llvm::Value* e = compile(v->expr());
 
-    llvm::Function*   thisFn     = builder()->GetInsertBlock()->getParent();
-    llvm::BasicBlock* failBlock  = llvm::BasicBlock::Create(context(), "casefail", thisFn);
-    llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(context(), "casemerge", thisFn);
-    llvm::SwitchInst* s          = builder()->CreateSwitch(e, failBlock, v->bindings().size());
+    llvm::Function*   thisFn     = withContext([this](auto&) {
+      return builder()->GetInsertBlock()->getParent();
+    });
+    llvm::BasicBlock* failBlock  = withContext([thisFn](llvm::LLVMContext& c) {
+      return llvm::BasicBlock::Create(c, "casefail", thisFn);
+    });
+    llvm::BasicBlock* mergeBlock = withContext([thisFn](llvm::LLVMContext& c) {
+      return llvm::BasicBlock::Create(c, "casemerge", thisFn);
+    });
+    llvm::SwitchInst* s          = withContext([&](auto&) {
+      return builder()->CreateSwitch(e, failBlock, v->bindings().size());
+    });
 
     typedef std::pair<llvm::Value*, llvm::BasicBlock*> MergeLink;
     typedef std::vector<MergeLink> MergeLinks;
     MergeLinks mergeLinks;
 
-    size_t i = 0;
-    for (auto b : v->bindings()) {
-      size_t caseID = i++;
-      llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(context(), "case_" + str::from(caseID), thisFn);
+    return withContext([&](auto& c) -> llvm::Value* {
+      size_t i = 0;
+      for (auto b : v->bindings()) {
+        size_t caseID = i++;
+        llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(c, "case_" + str::from(caseID), thisFn);
 
-      builder()->SetInsertPoint(caseBlock);
-      llvm::Value* caseValue = compile(b.exp);
-      mergeLinks.push_back(MergeLink(caseValue, builder()->GetInsertBlock()));
-      builder()->CreateBr(mergeBlock);
+        builder()->SetInsertPoint(caseBlock);
+        llvm::Value* caseValue = compile(b.exp);
+        mergeLinks.push_back(MergeLink(caseValue, builder()->GetInsertBlock()));
+        builder()->CreateBr(mergeBlock);
 
-      s->addCase(toLLVMConstantInt(b.value), caseBlock);
-    }
+        s->addCase(toLLVMConstantInt(b.value), caseBlock);
+      }
 
-    // fill in the default (failure) target
-    if (v->defaultExpr()) {
-      builder()->SetInsertPoint(failBlock);
-      llvm::Value* defValue = compile(v->defaultExpr());
-      mergeLinks.push_back(MergeLink(defValue, builder()->GetInsertBlock()));
-      builder()->CreateBr(mergeBlock);
-    } else {
-      builder()->CreateUnreachable();
-    }
+      // fill in the default (failure) target
+      if (v->defaultExpr()) {
+        builder()->SetInsertPoint(failBlock);
+        llvm::Value* defValue = compile(v->defaultExpr());
+        mergeLinks.push_back(MergeLink(defValue, builder()->GetInsertBlock()));
+        builder()->CreateBr(mergeBlock);
+      } else {
+        builder()->CreateUnreachable();
+      }
 
-    // now just merge each of the case blocks to a final value
-    builder()->SetInsertPoint(mergeBlock);
-    if (isUnit(casety)) {
-      return cvalue(true);
-    } else {
-      llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
-      for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
-        pn->addIncoming(ml->first, ml->second);
+      // now just merge each of the case blocks to a final value
+      builder()->SetInsertPoint(mergeBlock);
+      if (isUnit(casety)) {
+        return cvalue(true);
+      } else {
+        llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
+        for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
+          pn->addIncoming(ml->first, ml->second);
+        }
+        return pn;
       }
-      return pn;
-    }
+    });
   }
 
   llvm::Value* with(const Proj* v) const {
@@ -461,17 +496,19 @@ public:
     // switched to using packed records and manually-determined padding
     llvm::Value* rp = structFieldPtr(rec, rty->alignedIndex(v->field()));
 
-    if (OpaquePtr* op = is<OpaquePtr>(fty)) {
-      if (op->storedContiguously()) {
-        return builder()->CreateBitCast(rp, ptrType(byteType()));
+    return withContext([&](auto&) -> llvm::Value* {
+      if (OpaquePtr* op = is<OpaquePtr>(fty)) {
+        if (op->storedContiguously()) {
+          return builder()->CreateBitCast(rp, ptrType(byteType()));
+        } else {
+          return builder()->CreateLoad(rp, false);
+        }
+      } else if (isLargeType(fty)) {
+        return rp;
       } else {
         return builder()->CreateLoad(rp, false);
       }
-    } else if (isLargeType(fty)) {
-      return rp;
-    } else {
-      return builder()->CreateLoad(rp, false);
-    }
+    });
   }
 
   llvm::Value* with(const Assump* v) const {
@@ -483,7 +520,7 @@ public:
     llvm::Value* ev = compile(v->expr());
     llvm::Type*  et = toLLVM(requireMonotype(v->type()), true);
 
-    return builder()->CreateBitCast(ev, et);
+    return withContext([&](auto&) { return builder()->CreateBitCast(ev, et); });
   }
 
   llvm::Value* with(const Unpack* v) const {
@@ -507,11 +544,16 @@ private:
 
   llvm::Value* compileConstArray(const MonoTypePtr& ty, const Values& vs) const {
     auto elemTy = is<Func>(ty) ? ptrType(toLLVM(ty)) : toLLVM(ty);
-    return tryMkConstVarArray(builder(), this->c->module(), elemTy, vs, is<Array>(ty)); // take care to refer to global array constants by reference (a bit awkward!)
+    return withContext([&](auto&) {
+       // take care to refer to global array constants by reference (a bit awkward!)
+       return tryMkConstVarArray(builder(), this->c->module(), elemTy, vs, is<Array>(ty));
+    });
   }
 
   llvm::Value* compileConstRecord(const RecordValue& vs, const Record* rty) const {
-    return tryMkConstRecord(builder(), this->c->module(), vs, rty);
+    return withContext([&](auto&) {
+      return tryMkConstRecord(builder(), this->c->module(), vs, rty);
+    });
   }
 
   llvm::Value* compile(const ExprPtr& e) const {
@@ -544,7 +586,7 @@ private:
   }
 
   llvm::Value* structFieldPtr(llvm::Value* r, unsigned int i) const {
-    return structOffset(builder(), r, i);
+    return withContext([=](auto&) { return structOffset(builder(), r, i); });
   }
 
   RecordValue compileRecordFields(const MkRecord::FieldDefs& fs) const {
@@ -573,14 +615,18 @@ private:
         throw annotated_error(*e, "Failed to get reference to global variable: " + gv->value());
       }
 
-      return isLargeType(vty) ? builder()->CreateLoad(vl) : vl;
+      return withContext([&](auto&) { return isLargeType(vty) ? builder()->CreateLoad(vl) : vl; });
     } else if (const AIndex* ai = is<AIndex>(e)) {
       MonoTypePtr  aity = requireMonotype(ai->type());
       llvm::Value* ar   = compile(ai->array());
       llvm::Value* ir   = compile(ai->index());
 
-      llvm::Value* ard = structOffset(builder(), ar, 1); // get the array's 'data' pointer
-      llvm::Value* p   = offset(builder(), ard, 0, ir);  // and index into it
+      llvm::Value* ard = withContext([this, ar](auto&) {
+        return structOffset(builder(), ar, 1); // get the array's 'data' pointer
+      });
+      llvm::Value* p   = withContext([&](auto&) {
+        return offset(builder(), ard, 0, ir);  // and index into it
+      });
 
       return p;
     } else if (const Proj* rp = is<Proj>(e)) {
@@ -597,8 +643,10 @@ private:
 
       if (OpaquePtr* op = is<OpaquePtr>(fty)) {
         if (op->storedContiguously()) {
-          llvm::PointerType* bty = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(context()));
-          return builder()->CreateBitCast(p, bty);
+          return withContext([&](llvm::LLVMContext& c) {
+            llvm::PointerType* bty = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(c));
+            return builder()->CreateBitCast(p, bty);
+          });
         }
       }
 
@@ -609,7 +657,7 @@ private:
           llvm::Value* ar = compile(ap->args()[0]);
           llvm::Value* i  = compile(ap->args()[1]);
 
-          return offset(builder(), ar, 0, i);
+          return withContext([&](auto&) { return offset(builder(), ar, 0, i); });
         }
       }
     }
@@ -645,7 +693,14 @@ public:
   llvm::Constant* with(const Double* v) const { return cvalue(v->value()); }
 
   llvm::Constant* with(const Var* v) const {
-    return llvm::dyn_cast<llvm::Constant>(this->c->lookupVar(v->value(), requireMonotype(v->type())));
+    // possible instructions created during compilation
+    // remove them otherwise they may become dangling instructions
+    llvm::Value* x = this->c->lookupVar(v->value(), requireMonotype(v->type()));
+    if (auto* inst = llvm::dyn_cast<llvm::Instruction>(x)) {
+      inst->eraseFromParent();
+      return nullptr;
+    }
+    return llvm::dyn_cast<llvm::Constant>(x);
   }
 
   llvm::Constant* with(const Let*) const {
@@ -695,8 +750,8 @@ public:
     llvm::StructType* saty = varArrayType(elemTy, cs.size());
     llvm::StructType* caty = varArrayType(elemTy);
     
-    return
-      ccast(ptrType(caty),
+    return withContext([&](auto&) {
+      return ccast(ptrType(caty),
         new llvm::GlobalVariable(
           *this->c->module(),
           saty,
@@ -705,6 +760,7 @@ public:
           constArray(this->c->module(), cs, elemTy)
         )
       );
+    });
   }
 
   llvm::Constant* with(const MkVariant*) const {
@@ -724,7 +780,7 @@ public:
         return 0;
       }
     }
-    return constantRecord(this->c->module(), rcs, rty);
+    return withContext([&](auto&) { return constantRecord(this->c->module(), rcs, rty); });
   }
 
   llvm::Constant* with(const AIndex*) const {
diff --git a/lib/hobbes/eval/func.C b/lib/hobbes/eval/func.C
index 10da22bde..a399bbdc0 100644
--- a/lib/hobbes/eval/func.C
+++ b/lib/hobbes/eval/func.C
@@ -15,7 +15,7 @@ namespace hobbes {
   public: \
     llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) { \
       llvm::Value* x = c->compile(es[0]); \
-      return c->builder()->mem(x, "t"); \
+      return withContext([&](auto&) { return c->builder()->mem(x, "t"); }); \
     } \
     PolyTypePtr type(typedb&) const { \
       return polytype(prim<rty(aty0)>()); \
@@ -28,7 +28,7 @@ namespace hobbes {
     llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) { \
       llvm::Value* left  = c->compile(es[0]); \
       llvm::Value* right = c->compile(es[1]); \
-      return c->builder()->mem(left, right, "t"); \
+      return withContext([&](auto&) { return c->builder()->mem(left, right, "t"); }); \
     } \
     PolyTypePtr type(typedb&) const { \
       return polytype(prim<rty(aty0,aty1)>()); \
@@ -40,7 +40,7 @@ namespace hobbes {
   public: \
     llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) { \
       llvm::Value* e = c->compile(es[0]); \
-      return c->builder()->CreateCast(cflag, e, toLLVM(prim<outty>()), "t"); \
+      return withContext([&](auto&) { return c->builder()->CreateCast(cflag, e, toLLVM(prim<outty>()), "t"); }); \
     } \
     PolyTypePtr type(typedb&) const { \
       return polytype(prim<outty(inty)>()); \
@@ -52,7 +52,7 @@ namespace hobbes {
   public: \
     llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) { \
       llvm::Value* x = c->compile(es[0]); \
-      return c->builder()->mem(x, a0, "t"); \
+      return withContext([&](auto&) { return c->builder()->mem(x, a0, "t"); }); \
     } \
     PolyTypePtr type(typedb&) const { \
       return polytype(prim<outty(inty)>()); \
@@ -64,7 +64,7 @@ namespace hobbes {
   public: \
     llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) { \
       llvm::Value* x = c->compile(es[0]); \
-      return c->builder()->mem(x, a0, a1, "t"); \
+      return withContext([&](auto&) { return c->builder()->mem(x, a0, a1, "t"); }); \
     } \
     PolyTypePtr type(typedb&) const { \
       return polytype(prim<outty(inty)>()); \
@@ -224,45 +224,47 @@ BOP(dgte, CreateFCmpOGE, double, double, bool);
 class ifexp : public op {
 public:
   llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
-    llvm::Function* thisFn = c->builder()->GetInsertBlock()->getParent();
-    llvm::Value*    cond   = c->compile(es[0]);
+    return withContext([&](llvm::LLVMContext& ctx) -> llvm::Value* {
+      llvm::Function* thisFn = c->builder()->GetInsertBlock()->getParent();
+      llvm::Value*    cond   = c->compile(es[0]);
 
-    // for a condition, we need a 'then' branch, an 'else' branch, and a 'merge' block joining the two
-    llvm::BasicBlock* thenBlock  = llvm::BasicBlock::Create(context(), "then", thisFn);
-    llvm::BasicBlock* elseBlock  = llvm::BasicBlock::Create(context(), "else");
-    llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(context(), "ifmerge");
+      // for a condition, we need a 'then' branch, an 'else' branch, and a 'merge' block joining the two
+      llvm::BasicBlock* thenBlock  = llvm::BasicBlock::Create(ctx, "then", thisFn);
+      llvm::BasicBlock* elseBlock  = llvm::BasicBlock::Create(ctx, "else");
+      llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(ctx, "ifmerge");
 
-    // compile 'then' branch flowing to 'merge' block
-    c->builder()->CreateCondBr(cond, thenBlock, elseBlock);
-    c->builder()->SetInsertPoint(thenBlock);
+      // compile 'then' branch flowing to 'merge' block
+      c->builder()->CreateCondBr(cond, thenBlock, elseBlock);
+      c->builder()->SetInsertPoint(thenBlock);
 
-    llvm::Value* thenExp = c->compile(es[1]);
-    c->builder()->CreateBr(mergeBlock);
-    thenBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'then' expression changed the active block
+      llvm::Value* thenExp = c->compile(es[1]);
+      c->builder()->CreateBr(mergeBlock);
+      thenBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'then' expression changed the active block
 
-    // compile the 'else' branch
-    thisFn->getBasicBlockList().push_back(elseBlock);
-    c->builder()->SetInsertPoint(elseBlock);
+      // compile the 'else' branch
+      thisFn->getBasicBlockList().push_back(elseBlock);
+      c->builder()->SetInsertPoint(elseBlock);
 
-    llvm::Value* elseExp = c->compile(es[2]);
-    c->builder()->CreateBr(mergeBlock);
-    elseBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'else' expression changed the active block
+      llvm::Value* elseExp = c->compile(es[2]);
+      c->builder()->CreateBr(mergeBlock);
+      elseBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'else' expression changed the active block
 
-    // finally, merge blocks
-    thisFn->getBasicBlockList().push_back(mergeBlock);
-    c->builder()->SetInsertPoint(mergeBlock);
+      // finally, merge blocks
+      thisFn->getBasicBlockList().push_back(mergeBlock);
+      c->builder()->SetInsertPoint(mergeBlock);
 
-    // and the final value is the phi merge of the two possible branches
-    //   (unless we're returning unit)
-    if (isUnit(tys[1])) {
-      return cvalue(true);
-    } else {
-      llvm::PHINode* pn = c->builder()->CreatePHI(toLLVM(tys[1], true), 2);
-      pn->addIncoming(thenExp, thenBlock);
-      pn->addIncoming(elseExp, elseBlock);
+      // and the final value is the phi merge of the two possible branches
+      //   (unless we're returning unit)
+      if (isUnit(tys[1])) {
+        return cvalue(true);
+      } else {
+        llvm::PHINode* pn = c->builder()->CreatePHI(toLLVM(tys[1], true), 2);
+        pn->addIncoming(thenExp, thenBlock);
+        pn->addIncoming(elseExp, elseBlock);
 
-      return pn;
-    }
+        return pn;
+      }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -276,7 +278,9 @@ public:
 class alenexp : public op {
 public:
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    return c->builder()->CreateLoad(structOffset(c->builder(), c->compile(es[0]), 0), false, "at");
+    return withContext([c, &es](auto&) {
+      return c->builder()->CreateLoad(structOffset(c->builder(), c->compile(es[0]), 0), false, "at");
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -293,32 +297,34 @@ class aconcatexp : public op {
 public:
   llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
     Array* aty = is<Array>(tys[0]);
-    if (aty == 0) {
+    if (aty == nullptr) {
       throw annotated_error(*es[0], "Internal compiler error -- can't make array out of non-array type: " + show(tys[0]));
     }
 
-    llvm::Value* a0 = c->compile(es[0]);
-    llvm::Value* c0 = c->builder()->CreateLoad(structOffset(c->builder(), a0, 0));
-    llvm::Value* d0 = structOffset(c->builder(), a0, 1);
-    llvm::Value* a1 = c->compile(es[1]);
-    llvm::Value* c1 = c->builder()->CreateLoad(structOffset(c->builder(), a1, 0));
-    llvm::Value* d1 = structOffset(c->builder(), a1, 1);
+    return withContext([&](auto&) {
+      llvm::Value* a0 = c->compile(es[0]);
+      llvm::Value* c0 = c->builder()->CreateLoad(structOffset(c->builder(), a0, 0));
+      llvm::Value* d0 = structOffset(c->builder(), a0, 1);
+      llvm::Value* a1 = c->compile(es[1]);
+      llvm::Value* c1 = c->builder()->CreateLoad(structOffset(c->builder(), a1, 0));
+      llvm::Value* d1 = structOffset(c->builder(), a1, 1);
 
-    llvm::Value* aclen = c->builder()->CreateAdd(c0, c1);
-    llvm::Value* mlen  = c->builder()->CreateAdd(cvalue(static_cast<long>(sizeof(long))), c->builder()->CreateMul(aclen, cvalue(static_cast<long>(sizeOf(aty->type())))));
+      llvm::Value* aclen = c->builder()->CreateAdd(c0, c1);
+      llvm::Value* mlen  = c->builder()->CreateAdd(cvalue(static_cast<long>(sizeof(long))), c->builder()->CreateMul(aclen, cvalue(static_cast<long>(sizeOf(aty->type())))));
 
-    llvm::Value* cmdata = c->compileAllocStmt(mlen, cvalue(std::max<long>(sizeof(long), alignment(aty->type()))), toLLVM(tys[0]));
-    c->builder()->CreateStore(aclen, structOffset(c->builder(), cmdata, 0));
+      llvm::Value* cmdata = c->compileAllocStmt(mlen, cvalue(std::max<long>(sizeof(long), alignment(aty->type()))), toLLVM(tys[0]));
+      c->builder()->CreateStore(aclen, structOffset(c->builder(), cmdata, 0));
 
-    if (!isUnit(aty->type())) {
-      // hack to acknowledge the fact that opaque pointers are stored as pointers within arrays
-      long elemSize = is<OpaquePtr>(aty->type()) ? sizeof(void*) : static_cast<long>(sizeOf(aty->type()));
+      if (!isUnit(aty->type())) {
+        // hack to acknowledge the fact that opaque pointers are stored as pointers within arrays
+        long elemSize = is<OpaquePtr>(aty->type()) ? sizeof(void*) : static_cast<long>(sizeOf(aty->type()));
 
-      llvm::Value* od = structOffset(c->builder(), cmdata, 1);
-      memCopy(c->builder(), offset(c->builder(), od, 0), 8, d0, 8, c->builder()->CreateMul(c0, cvalue(elemSize)));
-      memCopy(c->builder(), offset(c->builder(), od, c0), 8, d1, 8, c->builder()->CreateMul(c1, cvalue(elemSize)));
-    }
-    return cmdata;
+        llvm::Value* od = structOffset(c->builder(), cmdata, 1);
+        memCopy(c->builder(), offset(c->builder(), od, 0), 8, d0, 8, c->builder()->CreateMul(c0, cvalue(elemSize)));
+        memCopy(c->builder(), offset(c->builder(), od, c0), 8, d1, 8, c->builder()->CreateMul(c1, cvalue(elemSize)));
+      }
+      return cmdata;
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -340,7 +346,7 @@ class asetlen : public op {
 
     llvm::Value* av = c->compile(es[0]);
     llvm::Value* nc = c->compile(es[1]);
-    c->builder()->CreateStore(nc, structOffset(c->builder(), av, 0));
+    withContext([&](auto&) { c->builder()->CreateStore(nc, structOffset(c->builder(), av, 0)); });
     return cvalue(true);
   }
 
@@ -380,13 +386,15 @@ class saelem : public op {
       return cvalue(true);
     }
 
-    llvm::Value* p = offset(c->builder(), c->compile(es[0]), 0, c->compile(es[1]));
+    return withContext([&](auto&) -> llvm::Value* {
+      llvm::Value* p = offset(c->builder(), c->compile(es[0]), 0, c->compile(es[1]));
 
-    if (isLargeType(rty)) {
-      return p;
-    } else {
-      return c->builder()->CreateLoad(p, false);
-    }
+      if (isLargeType(rty)) {
+        return p;
+      } else {
+        return c->builder()->CreateLoad(p, false);
+      }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -407,12 +415,14 @@ class saacopy : public op {
     llvm::Value* farr = c->compile(es[0]);
 
     llvm::Value* varr = c->compile(es[1]);
-    llvm::Value* vard = structOffset(c->builder(), varr, 1); // get the var-length array's 'data' pointer
+    withContext([&](auto&) {
+      llvm::Value* vard = structOffset(c->builder(), varr, 1); // get the var-length array's 'data' pointer
 
-    llvm::Value* len  = c->compile(es[2]);
-    llvm::Value* lenb = c->builder()->CreateMul(len, cvalue(static_cast<long>(sizeOf(aty->type()))));
+      llvm::Value* len  = c->compile(es[2]);
+      llvm::Value* lenb = c->builder()->CreateMul(len, cvalue(static_cast<long>(sizeOf(aty->type()))));
 
-    memCopy(c->builder(), farr, 8, vard, 8, lenb);
+      memCopy(c->builder(), farr, 8, vard, 8, lenb);
+    });
     return cvalue(true);
   }
 
@@ -491,7 +501,9 @@ public:
     if (isUnit(rty)) {
       return cvalue(true);
     } else {
-      return c->builder()->CreateBitCast(r, toLLVM(rty, true));
+      return withContext([&](auto&) {
+        return c->builder()->CreateBitCast(r, toLLVM(rty, true));
+      });
     }
   }
 
@@ -513,7 +525,9 @@ public:
     if (isUnit(rty)) {
       return cvalue(true);
     } else if (!hasPointerRep(rty)) {
-      return c->builder()->CreateLoad(c->compileAllocStmt(sizeOf(rty), alignment(rty), ptrType(toLLVM(rty, true)), this->zeroMem));
+      return withContext([&](auto&) {
+        return c->builder()->CreateLoad(c->compileAllocStmt(sizeOf(rty), alignment(rty), ptrType(toLLVM(rty, true)), this->zeroMem));
+      });
     } else {
       return c->compileAllocStmt(sizeOf(rty), alignment(rty), toLLVM(rty, true), this->zeroMem);
     }
@@ -537,9 +551,11 @@ public:
     }
 
     llvm::Value* aclen  = c->compile(es[0]);
-    llvm::Value* mlen   = c->builder()->CreateAdd(cvalue(static_cast<long>(sizeof(long))), c->builder()->CreateMul(aclen, cvalue(static_cast<long>(sizeOf(aty->type())))));
+    llvm::Value* mlen   = withContext([&](auto&) {
+      return c->builder()->CreateAdd(cvalue(static_cast<long>(sizeof(long))), c->builder()->CreateMul(aclen, cvalue(static_cast<long>(sizeOf(aty->type())))));
+    });
     llvm::Value* cmdata = c->compileAllocStmt(mlen, cvalue(std::max<long>(sizeof(long), alignment(aty->type()))), toLLVM(rty));
-    c->builder()->CreateStore(aclen, structOffset(c->builder(), cmdata, 0));
+    withContext([&](auto&) { c->builder()->CreateStore(aclen, structOffset(c->builder(), cmdata, 0)); });
 
     return cmdata;
   }
@@ -558,7 +574,7 @@ public:
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
     llvm::Value* p = c->compile(es[0]);
     llvm::Value* o = c->compile(es[1]);
-    return c->builder()->CreateGEP(p, o);
+    return withContext([&](auto&) { return c->builder()->CreateGEP(p, o); });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -573,16 +589,14 @@ public:
 class adjvtblptr : public op {
 public:
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    llvm::Type* tppchar =
-      llvm::PointerType::getUnqual(
-        llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(context()))
-      );
+    llvm::Type* tppchar = llvm::PointerType::getUnqual(llvm::PointerType::getUnqual(
+        withContext([](llvm::LLVMContext& ctx) { return llvm::Type::getInt8Ty(ctx); })));
 
     llvm::Value* p = c->compile(es[0]);
     llvm::Value* o = c->compile(es[1]);
 
-    return
-      c->builder()->CreateGEP(
+    return withContext([&](auto&) {
+      return c->builder()->CreateGEP(
         p,
         c->builder()->CreateLoad(
           c->builder()->CreateGEP(
@@ -593,6 +607,7 @@ public:
           )
         )
       );
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -761,13 +776,15 @@ public:
   }
 
   static llvm::Value* payloadValue(jitcc* c, const MonoTypePtr& mty, llvm::Value* pval) {
-    if (isUnit(mty)) {
-      return cvalue(true);
-    } else if (isLargeType(mty)) {
-      return c->builder()->CreateBitCast(pval, toLLVM(mty, true));
-    } else {
-      return c->builder()->CreateLoad(c->builder()->CreateBitCast(pval, llvm::PointerType::getUnqual(toLLVM(mty, true))), false);
-    }
+    return withContext([&](auto&) -> llvm::Value* {
+      if (isUnit(mty)) {
+        return cvalue(true);
+      } else if (isLargeType(mty)) {
+        return c->builder()->CreateBitCast(pval, toLLVM(mty, true));
+      } else {
+        return c->builder()->CreateLoad(c->builder()->CreateBitCast(pval, llvm::PointerType::getUnqual(toLLVM(mty, true))), false);
+      }
+    });
   }
 
   llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
@@ -789,72 +806,74 @@ public:
     // compile the variant, head-handler and tail-handler
     llvm::Value* var = c->compile(es[0]);
 
-    // if the tail is 0, we can only possibly match the head
-    if (isVoid(vty->tailType())) {
-      // get an offset to the payload data
-      std::vector<llvm::Value*> idxs;
-      idxs.push_back(cvalue(0));
-      idxs.push_back(cvalue(vty->payloadOffset()));
-      llvm::Value* pval = c->builder()->CreateGEP(var, idxs);
+    return withContext([&](llvm::LLVMContext& ctx) -> llvm::Value* {
+      // if the tail is 0, we can only possibly match the head
+      if (isVoid(vty->tailType())) {
+        // get an offset to the payload data
+        std::vector<llvm::Value*> idxs;
+        idxs.push_back(cvalue(0));
+        idxs.push_back(cvalue(vty->payloadOffset()));
+        llvm::Value* pval = c->builder()->CreateGEP(var, idxs);
+
+        // invoke the head case function with the payload value
+        return callWith(c, es[1], vheadm.type, payloadValue(c, vheadm.type, pval));
+      } else {
+        // pull out the variant tag
+        llvm::Value* ptag = c->builder()->CreateBitCast(var, ptrType(intType()));
+        llvm::Value* tag  = c->builder()->CreateLoad(ptag, false);
 
-      // invoke the head case function with the payload value
-      return callWith(c, es[1], vheadm.type, payloadValue(c, vheadm.type, pval));
-    } else {
-      // pull out the variant tag
-      llvm::Value* ptag = c->builder()->CreateBitCast(var, ptrType(intType()));
-      llvm::Value* tag  = c->builder()->CreateLoad(ptag, false);
+        // compare the tag data to the head tag id
+        llvm::Value* htagv  = cvalue(static_cast<int>(vheadm.id));
+        llvm::Value* ishtag = c->builder()->CreateICmpEQ(tag, htagv);
 
-      // compare the tag data to the head tag id
-      llvm::Value* htagv  = cvalue(static_cast<int>(vheadm.id));
-      llvm::Value* ishtag = c->builder()->CreateICmpEQ(tag, htagv);
+        // get an offset to the payload data
+        std::vector<llvm::Value*> idxs;
+        idxs.push_back(cvalue(0));
+        idxs.push_back(cvalue(vty->payloadOffset()));
+        llvm::Value* pval = c->builder()->CreateGEP(var, idxs);
 
-      // get an offset to the payload data
-      std::vector<llvm::Value*> idxs;
-      idxs.push_back(cvalue(0));
-      idxs.push_back(cvalue(vty->payloadOffset()));
-      llvm::Value* pval = c->builder()->CreateGEP(var, idxs);
+        // either invoke the head case function, or the tail case function
+        llvm::Function* thisFn = c->builder()->GetInsertBlock()->getParent();
 
-      // either invoke the head case function, or the tail case function
-      llvm::Function* thisFn = c->builder()->GetInsertBlock()->getParent();
+        // for a condition, we need a 'then' branch, an 'else' branch, and a 'merge' block joining the two
+        llvm::BasicBlock* thenBlock  = llvm::BasicBlock::Create(ctx, "then", thisFn);
+        llvm::BasicBlock* elseBlock  = llvm::BasicBlock::Create(ctx, "else");
+        llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(ctx, "ifmerge");
 
-      // for a condition, we need a 'then' branch, an 'else' branch, and a 'merge' block joining the two
-      llvm::BasicBlock* thenBlock  = llvm::BasicBlock::Create(context(), "then", thisFn);
-      llvm::BasicBlock* elseBlock  = llvm::BasicBlock::Create(context(), "else");
-      llvm::BasicBlock* mergeBlock = llvm::BasicBlock::Create(context(), "ifmerge");
+        // compile 'then' branch flowing to 'merge' block
+        c->builder()->CreateCondBr(ishtag, thenBlock, elseBlock);
+        c->builder()->SetInsertPoint(thenBlock);
 
-      // compile 'then' branch flowing to 'merge' block
-      c->builder()->CreateCondBr(ishtag, thenBlock, elseBlock);
-      c->builder()->SetInsertPoint(thenBlock);
+        llvm::Value* thenExp = callWith(c, es[1], vheadm.type, payloadValue(c, vheadm.type, pval));
 
-      llvm::Value* thenExp = callWith(c, es[1], vheadm.type, payloadValue(c, vheadm.type, pval));
+        c->builder()->CreateBr(mergeBlock);
+        thenBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'then' expression changed the active block
 
-      c->builder()->CreateBr(mergeBlock);
-      thenBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'then' expression changed the active block
+        // compile the 'else' branch
+        thisFn->getBasicBlockList().push_back(elseBlock);
+        c->builder()->SetInsertPoint(elseBlock);
 
-      // compile the 'else' branch
-      thisFn->getBasicBlockList().push_back(elseBlock);
-      c->builder()->SetInsertPoint(elseBlock);
+        llvm::Value* elseExp = callWith(c, es[2], vty->tailType(), var);
+        c->builder()->CreateBr(mergeBlock);
+        elseBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'else' expression changed the active block
 
-      llvm::Value* elseExp = callWith(c, es[2], vty->tailType(), var);
-      c->builder()->CreateBr(mergeBlock);
-      elseBlock = c->builder()->GetInsertBlock(); // reset block pointer, in case compiling 'else' expression changed the active block
+        // finally, merge blocks
+        thisFn->getBasicBlockList().push_back(mergeBlock);
+        c->builder()->SetInsertPoint(mergeBlock);
 
-      // finally, merge blocks
-      thisFn->getBasicBlockList().push_back(mergeBlock);
-      c->builder()->SetInsertPoint(mergeBlock);
-
-      // and the final value is the phi merge of the two possible branches
-      // (if it's a non-trivial type)
-      if (isUnit(resultType)) {
-        return cvalue(true);
-      } else {
-        llvm::PHINode* pn = c->builder()->CreatePHI(toLLVM(resultType, true), 2);
-        pn->addIncoming(thenExp, thenBlock);
-        pn->addIncoming(elseExp, elseBlock);
+        // and the final value is the phi merge of the two possible branches
+        // (if it's a non-trivial type)
+        if (isUnit(resultType)) {
+          return cvalue(true);
+        } else {
+          llvm::PHINode* pn = c->builder()->CreatePHI(toLLVM(resultType, true), 2);
+          pn->addIncoming(thenExp, thenBlock);
+          pn->addIncoming(elseExp, elseBlock);
 
-        return pn;
+          return pn;
+        }
       }
-    }
+    });
   }
 
   PolyTypePtr type(typedb&) const {
@@ -905,17 +924,19 @@ char   stdstrelem(const std::string& x, size_t i) { return x[i]; }
 
 class packLongF : public op {
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    llvm::Value* c0 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[0]), longType(), false), 56);
-    llvm::Value* c1 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[1]), longType(), false), 48);
-    llvm::Value* c2 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[2]), longType(), false), 40);
-    llvm::Value* c3 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[3]), longType(), false), 32);
-    llvm::Value* c4 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[4]), longType(), false), 24);
-    llvm::Value* c5 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[5]), longType(), false), 16);
-    llvm::Value* c6 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[6]), longType(), false), 8);
-    llvm::Value* c7 = c->builder()->CreateIntCast(c->compile(es[7]), longType(), false);
-
-    return
-      c->builder()->CreateOr(c0,c->builder()->CreateOr(c1,c->builder()->CreateOr(c2,c->builder()->CreateOr(c3,c->builder()->CreateOr(c4,c->builder()->CreateOr(c5,c->builder()->CreateOr(c6,c7)))))));
+    return withContext([&](auto&) {
+      llvm::Value* c0 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[0]), longType(), false), 56);
+      llvm::Value* c1 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[1]), longType(), false), 48);
+      llvm::Value* c2 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[2]), longType(), false), 40);
+      llvm::Value* c3 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[3]), longType(), false), 32);
+      llvm::Value* c4 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[4]), longType(), false), 24);
+      llvm::Value* c5 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[5]), longType(), false), 16);
+      llvm::Value* c6 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[6]), longType(), false), 8);
+      llvm::Value* c7 = c->builder()->CreateIntCast(c->compile(es[7]), longType(), false);
+
+      return
+        c->builder()->CreateOr(c0,c->builder()->CreateOr(c1,c->builder()->CreateOr(c2,c->builder()->CreateOr(c3,c->builder()->CreateOr(c4,c->builder()->CreateOr(c5,c->builder()->CreateOr(c6,c7)))))));
+    });
   }
 
   PolyTypePtr type(typedb& db) const {
@@ -926,22 +947,24 @@ class packLongF : public op {
 
 class packIntF : public op {
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), intType(), false);
-    llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), intType(), false);
-    llvm::Value* c2 = c->builder()->CreateIntCast(c->compile(es[2]), intType(), false);
-    llvm::Value* c3 = c->builder()->CreateIntCast(c->compile(es[3]), intType(), false);
-
-    return
-      c->builder()->CreateOr(
-        c->builder()->CreateShl(c0, 24),
+    return withContext([&](auto&) {
+      llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), intType(), false);
+      llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), intType(), false);
+      llvm::Value* c2 = c->builder()->CreateIntCast(c->compile(es[2]), intType(), false);
+      llvm::Value* c3 = c->builder()->CreateIntCast(c->compile(es[3]), intType(), false);
+
+      return
         c->builder()->CreateOr(
-          c->builder()->CreateShl(c1, 16),
+          c->builder()->CreateShl(c0, 24),
           c->builder()->CreateOr(
-            c->builder()->CreateShl(c2, 8),
-            c3
+            c->builder()->CreateShl(c1, 16),
+            c->builder()->CreateOr(
+              c->builder()->CreateShl(c2, 8),
+              c3
+            )
           )
-        )
-      );
+        );
+    });
   }
 
   PolyTypePtr type(typedb& db) const {
@@ -952,14 +975,16 @@ class packIntF : public op {
 
 class packShortF : public op {
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), shortType(), false);
-    llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), shortType(), false);
+    return withContext([&](auto&) {
+      llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), shortType(), false);
+      llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), shortType(), false);
 
-    return
-      c->builder()->CreateOr(
-        c->builder()->CreateShl(c0, 8),
-        c1
-      );
+      return
+        c->builder()->CreateOr(
+          c->builder()->CreateShl(c0, 8),
+          c1
+        );
+    });
   }
 
   PolyTypePtr type(typedb& db) const {
@@ -970,11 +995,10 @@ class packShortF : public op {
 
 class cptrrefbyF : public op {
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    return
-      c->builder()->CreateLoad(
-        offset(c->builder(), c->compile(es[0]), c->compile(es[1])),
-        false
-      );
+    return withContext([&](auto&) {
+      return c->builder()->CreateLoad(
+          offset(c->builder(), c->compile(es[0]), c->compile(es[1])), false);
+    });
   }
 
   PolyTypePtr type(typedb& db) const {
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index 3181d6228..263e41793 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -2,12 +2,25 @@
 #include <hobbes/hobbes.H>
 #include <hobbes/eval/jitcc.H>
 #include <hobbes/eval/cexpr.H>
+#include <llvm/IR/Attributes.h>
+#include <llvm/IR/Constant.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/GlobalVariable.h>
+#include <llvm/IR/Value.h>
+#include <llvm/IR/ValueHandle.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Target/TargetMachine.h>
+#include <stdexcept>
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
 
+#if LLVM_VERSION_MAJOR >= 11
+#include <hobbes/eval/orcjitcc.H>
+#else
 #if LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
 #include "llvm/ExecutionEngine/JIT.h"
 #else
@@ -21,6 +34,7 @@
 #if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6
 #include "llvm/Transforms/Scalar/GVN.h"
 #endif
+#endif
 
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
@@ -28,23 +42,262 @@
 #pragma GCC diagnostic pop
 
 namespace hobbes {
+#if LLVM_VERSION_MAJOR >= 11
+class ConstantList {
+  using VarFnTy = std::function<llvm::GlobalVariable*(llvm::Module&)>;
+  struct Constant {
+    MonoTypePtr mtype;
+    variant<llvm::WeakTrackingVH, llvm::Constant*> varOrFunc;
+    VarFnTy fn;
+  };
+  llvm::StringMap<Constant> constants;
+
+public:
+  ConstantList() = default;
+  ConstantList(const ConstantList&) = delete;
+  ConstantList(ConstantList&&) = delete;
+  ConstantList& operator=(const ConstantList&) = delete;
+  ConstantList& operator=(ConstantList&&) = delete;
+  ~ConstantList() = default;
+
+  LLVM_NODISCARD bool contains(llvm::StringRef name) const {
+    return constants.find(name) != constants.end();
+  }
+
+  /// Creates const global variable definition
+  ///
+  /// \p initVal is the initializer for this constant, must not be null
+  ///    or it can be a function
+  void createDefinition(const std::string& name, llvm::Module& m, llvm::Constant* initVal,
+                        const MonoTypePtr& mtype);
+
+  /// Gets constant by generating load inst or possibly recreating decl
+  LLVM_NODISCARD llvm::Value* loadConstant(llvm::StringRef name, llvm::Module& m,
+                                           llvm::IRBuilder<>& builder);
+};
+
+void ConstantList::createDefinition(const std::string& name, llvm::Module& m,
+                                    llvm::Constant* initVal, const MonoTypePtr& mtype) {
+  assert(!contains(name));
+
+  llvm::Type* type = toLLVM(mtype);
+  if (is<Func>(mtype) != nullptr) {
+    constants[name] = Constant{.mtype = mtype, .varOrFunc = initVal, .fn = VarFnTy()};
+  } else {
+    constants[name] = Constant{
+        .mtype = mtype,
+        .varOrFunc = llvm::WeakTrackingVH(new llvm::GlobalVariable(
+            m, type, /*isConstant=*/true, llvm::GlobalVariable::ExternalLinkage, initVal, name)),
+        .fn = [&, type, name](llvm::Module& m) -> llvm::GlobalVariable* {
+          return prepgv(new llvm::GlobalVariable(m, type, /*isConstant=*/true,
+                                                 llvm::GlobalVariable::ExternalLinkage,
+                                                 /*initializer=*/nullptr, name));
+        }};
+  }
+}
+
+llvm::Value* ConstantList::loadConstant(llvm::StringRef name, llvm::Module& m,
+                                        llvm::IRBuilder<>& builder) {
+  auto it = constants.find(name);
+  if (it == constants.end()) {
+    return nullptr;
+  }
+
+  if (is<Func>(it->second.mtype) != nullptr) {
+    return *it->second.varOrFunc.get<llvm::Constant*>();
+  }
+
+  return withContext([&](auto&) -> llvm::Value* {
+    if (!it->second.varOrFunc.get<llvm::WeakTrackingVH>()->pointsToAliveValue()) {
+      it->second.varOrFunc = llvm::WeakTrackingVH(it->second.fn(m));
+    }
+
+    auto* g = llvm::cast<llvm::GlobalVariable>(
+        static_cast<llvm::Value*>(*it->second.varOrFunc.get<llvm::WeakTrackingVH>()));
+
+    if (is<Array>(it->second.mtype) != nullptr) {
+      return builder.CreateLoad(g);
+    }
+    if (hasPointerRep(it->second.mtype)) {
+      return g;
+    }
+    return builder.CreateAlignedLoad(g->getType()->getPointerElementType(), g, llvm::MaybeAlign(8));
+  });
+}
+
+class VTEnv {
+public:
+  using FunFnTy = std::function<llvm::Function*(llvm::Module&)>;
+
+private:
+  using VarBindings = llvm::StringMap<llvm::WeakTrackingVH>;
+  using VarBindingStack = llvm::SmallVector<VarBindings, 8>;
+  VarBindingStack vtenv;
+  llvm::StringMap<FunFnTy> vtenvFuns;
+
+public:
+  VTEnv() = default;
+  VTEnv(const VTEnv&) = delete;
+  VTEnv(VTEnv&&) = delete;
+  VTEnv& operator=(const VTEnv&) = delete;
+  VTEnv& operator=(VTEnv&&) = delete;
+  ~VTEnv() = default;
+
+  LLVM_NODISCARD bool contains(llvm::StringRef name) const {
+    return std::any_of(vtenv.rbegin(), vtenv.rend(),
+                       [name](const auto& vb) { return vb.find(name) != vb.end(); });
+  }
+
+  /// Gets \p name by looking up from inner to outer scope
+  ///
+  /// Possibly recreating decl
+  LLVM_NODISCARD llvm::Value* getOrCreateDecl(llvm::StringRef name, llvm::Module& m);
+
+  /// Adds variable \p name to current scope
+  void add(llvm::StringRef name, llvm::Value* v) {
+    this->vtenv.back()[name] = v;
+  }
+
+  /// Adds function \p name to current scope
+  ///
+  /// It stores function prototype for decl recreating
+  void add(llvm::StringRef name, FunFnTy f, llvm::Function* fp) {
+    this->vtenv.back()[name] = fp;
+    vtenvFuns[name] = std::move(f);
+  }
+
+  /// Create a new inner scope
+  void pushScope() {
+    vtenv.push_back(VarBindings());
+  }
+
+  /// Destroys the inner scope
+  void popScope() {
+    vtenv.pop_back();
+  }
+};
+
+llvm::Value* VTEnv::getOrCreateDecl(llvm::StringRef name, llvm::Module& m) {
+  for (auto vb = vtenv.rbegin(); vb != vtenv.rend(); ++vb) {
+    auto it = vb->find(name);
+    if (it == vb->end()) {
+      continue;
+    }
+    if (!it->second.pointsToAliveValue()) {
+      assert(vtenvFuns.find(name) != vtenvFuns.end());
+      it->second = vtenvFuns[name](m);
+    }
+    return it->second;
+  }
+  return nullptr;
+}
+
+class Globals {
+private:
+  using FunFnTy = std::function<llvm::Function*(llvm::Module&)>;
+  using VarFnTy = std::function<llvm::GlobalVariable*(llvm::Module&)>;
+  struct Global {
+    variant<FunFnTy, VarFnTy> protoTypes;
+    llvm::WeakTrackingVH handle;
+  };
+  llvm::StringMap<Global> globals;
+  LLVM_NODISCARD bool isFunc(decltype(globals)::iterator it) const {
+    return it->second.protoTypes.get<FunFnTy>() != nullptr;
+  }
+
+public:
+  Globals() = default;
+  Globals(const Globals&) = delete;
+  Globals(Globals&&) = delete;
+  Globals& operator=(const Globals&) = delete;
+  Globals& operator=(Globals&&) = delete;
+  ~Globals() = default;
+
+  LLVM_NODISCARD bool contains(llvm::StringRef name) const {
+    return globals.find(name) != globals.end();
+  }
+
+  /// Gets a global variable \p name by possibly recreating decl in current module
+  LLVM_NODISCARD llvm::GlobalVariable* getOrCreateVarDecl(llvm::StringRef name, llvm::Module& m);
+  /// Gets a global function \p name by possibly recreating decl in current module
+  LLVM_NODISCARD llvm::Function* getOrCreateFuncDecl(llvm::StringRef name, llvm::Module& m);
+
+  /// Creates a global variable decl for \p name with type \p ty
+  ///
+  /// It stores variable prototype for decl recreating
+  void add(const std::string& name, llvm::Module& m, llvm::Type* ty);
+  /// Creates a global function decl for \p name with type \p ty if \p existingF is null
+  ///
+  /// It stores function prototype for decl recreating
+  void add(const std::string& name, llvm::Module& m, llvm::FunctionType* ty,
+           llvm::Function* existingF);
+};
+
+llvm::GlobalVariable* Globals::getOrCreateVarDecl(llvm::StringRef name, llvm::Module& m) {
+  auto it = globals.find(name);
+  if (it == globals.end() || isFunc(it)) {
+    return nullptr;
+  }
+  if (!it->second.handle.pointsToAliveValue()) {
+    it->second.handle = (*it->second.protoTypes.get<VarFnTy>())(m);
+  }
+  return llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Value*>(it->second.handle));
+}
+
+llvm::Function* Globals::getOrCreateFuncDecl(llvm::StringRef name, llvm::Module& m) {
+  auto it = globals.find(name);
+  if (it == globals.end() || !isFunc(it)) {
+    return nullptr;
+  }
+  if (!it->second.handle.pointsToAliveValue()) {
+    it->second.handle = (*it->second.protoTypes.get<FunFnTy>())(m);
+  }
+  return llvm::cast<llvm::Function>(static_cast<llvm::Value*>(it->second.handle));
+}
+
+void Globals::add(const std::string& name, llvm::Module& m, llvm::Type* ty) {
+  Global g;
+  g.protoTypes = VarFnTy([ty, name](llvm::Module& m) {
+    return prepgv(new llvm::GlobalVariable(m, ty, /*isConstant=*/false,
+                                           llvm::GlobalValue::ExternalLinkage,
+                                           /*initializer=*/nullptr, name),
+                  sizeof(void*));
+  });
+  g.handle = (*g.protoTypes.get<VarFnTy>())(m);
+  globals[name] = g;
+}
+
+void Globals::add(const std::string& name, llvm::Module& m, llvm::FunctionType* ty,
+                  llvm::Function* existingF) {
+  Global g;
+  g.protoTypes = FunFnTy([ty, name](llvm::Module& m) {
+    return llvm::Function::Create(ty, llvm::Function::ExternalLinkage, name, m);
+  });
+  if (existingF != nullptr) {
+    g.handle = existingF;
+  } else {
+    g.handle = (*g.protoTypes.get<FunFnTy>())(m);
+  }
+  globals[name] = g;
+}
+#endif
 
 // this should be moved out of here eventually
 bool isFileType(const MonoTypePtr&);
 
-#if LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR >= 8
+#if (LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR >= 8) && LLVM_VERSION_MAJOR < 11
 class jitmm : public llvm::SectionMemoryManager {
 public:
-  jitmm(jitcc* jit) : jit(jit) { }
+  explicit jitmm(jitcc* jit) : jit(jit) { }
 
   // link symbols across modules :T
   uint64_t getSymbolAddress(const std::string& n) override {
     if (uint64_t laddr = reinterpret_cast<uint64_t>(this->jit->getSymbolAddress(n))) {
       return laddr;
     }
-    if (n.size() > 0 && n[0] == '_') {
+    if (!n.empty() && n[0] == '_') {
       uint64_t sv = reinterpret_cast<uint64_t>(this->jit->getSymbolAddress(n.substr(1)));
-      if (sv) return sv;
+      if (sv != 0U) return sv;
     }
     if (uint64_t baddr = llvm::SectionMemoryManager::getSymbolAddress(n)) {
       return baddr;
@@ -57,8 +310,38 @@ private:
 };
 #endif
 
+#if LLVM_VERSION_MAJOR >= 11
+jitcc::jitcc(const TEnvPtr& tenv)
+    : tenv(tenv), vtenv(std::make_unique<VTEnv>()), ignoreLocalScope(false),
+      globals(std::make_unique<Globals>()), globalData(32768 /* min global page size = 32K */),
+      constants(std::make_unique<ConstantList>()) {
+  llvm::InitializeNativeTarget();
+  llvm::InitializeNativeTargetAsmParser();
+  llvm::InitializeNativeTargetAsmPrinter();
+
+  this->orcjit = llvm::cantFail(ORCJIT::create(), "orcjit init failed");
+
+  // allocate an IR builder with an initial dummy basic-block to write into
+  this->irbuilder = withContext([](llvm::LLVMContext& c) {
+      auto r = std::make_unique<llvm::IRBuilder<>>(c);
+      r->SetInsertPoint(llvm::BasicBlock::Create(c, "dummy"));
+      return r;
+  });
+
+  // make sure we've always got one frame for variable defs
+  this->pushScope();
+}
+
+jitcc::~jitcc() {
+  // release low-level functions
+  for (auto f : this->fenv) {
+    delete f.second;
+  }
+}
+#else
+
 jitcc::jitcc(const TEnvPtr& tenv) :
-  tenv(tenv), currentModule(0), irbuilder(0),
+  tenv(tenv),
   ignoreLocalScope(false),
   globalData(32768 /* min global page size = 32K */)
 {
@@ -67,8 +350,11 @@ jitcc::jitcc(const TEnvPtr& tenv) :
   llvm::InitializeNativeTargetAsmPrinter();
 
   // allocate an IR builder with an initial dummy basic-block to write into
-  this->irbuilder = new llvm::IRBuilder<>(context());
-  this->irbuilder->SetInsertPoint(llvm::BasicBlock::Create(context(), "dummy"));
+  this->irbuilder = withContext([](llvm::LLVMContext& c) {
+      auto r = std::make_unique<llvm::IRBuilder<>>(c);
+      r->SetInsertPoint(llvm::BasicBlock::Create(c, "dummy"));
+      return r;
+  });
 
   // make sure we've always got one frame for variable defs
   this->vtenv.push_back(VarBindings());
@@ -120,26 +406,67 @@ jitcc::~jitcc() {
 #elif LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
   delete this->eengine;
 #endif
-
-  delete this->irbuilder;
 }
+#endif
 
 const TEnvPtr& jitcc::typeEnv() const {
   return this->tenv;
 }
 
 llvm::IRBuilder<>* jitcc::builder() const {
-  return this->irbuilder;
+  return this->irbuilder.get();
 }
 
+#if LLVM_VERSION_MAJOR >= 11
 llvm::Module* jitcc::module() {
-  if (!this->currentModule) {
-    this->currentModule = new llvm::Module("jitModule" + str::from(this->modules.size()), context());
+  if (this->currentModule == nullptr) {
+    this->currentModule = withContext([](llvm::LLVMContext& c) {
+      auto m = std::make_unique<llvm::Module>(createUniqueName("jitModule"), c);
+      return m;
+    });
+  }
+  return this->currentModule.get();
+}
+#else
+llvm::Module* jitcc::module() {
+  if (this->currentModule == nullptr) {
+    this->currentModule = withContext([this](llvm::LLVMContext& c) {
+      return new llvm::Module("jitModule" + str::from(this->modules.size()), c);
+    });
     this->modules.push_back(this->currentModule);
   }
   return this->currentModule;
 }
+#endif
+
+#if LLVM_VERSION_MAJOR >= 11
+void* jitcc::getMachineCode(llvm::Function* f, llvm::JITEventListener* /*listener*/) {
+  const std::string fname = f->getName().str();
+  auto sym = orcjit->lookup(fname);
+  if (auto e = sym.takeError()) {
+    llvm::consumeError(std::move(e));
+  } else {
+    return llvm::jitTargetAddressToPointer<void*>(sym->getAddress());
+  }
+
+  withContext([&](auto&) {
+    const std::string name = this->currentModule->getName().str();
+    if (auto e = orcjit->addModule(std::move(this->currentModule))) {
+      llvm::logAllUnhandledErrors(std::move(e), llvm::errs());
+      throw std::runtime_error("cannot add module " + name);
+    }
+  });
 
+  sym = orcjit->lookup(fname);
+  if (auto e = sym.takeError()) {
+    logAllUnhandledErrors(std::move(e), llvm::errs());
+    throw std::runtime_error(
+        "Internal compiler error, no current module and no machine code for (" + fname + ")");
+  }
+
+  return llvm::jitTargetAddressToPointer<void*>(sym->getAddress());
+}
+#else
 void* jitcc::getSymbolAddress(const std::string& vn) {
   // do we have a global with this name?
   auto gd = this->globals.find(vn);
@@ -156,7 +483,7 @@ void* jitcc::getSymbolAddress(const std::string& vn) {
       }
     }
   }
-#elif LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4 
+#elif LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4
   for (auto ee : this->eengines) {
     if (uint64_t faddr = ee->getFunctionAddress(vn)) {
       return reinterpret_cast<void*>(faddr);
@@ -275,6 +602,7 @@ void* jitcc::getMachineCode(llvm::Function* f, llvm::JITEventListener* listener)
   }
 #endif
 }
+#endif
 
 #if LLVM_VERSION_MINOR >= 7 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR >= 8
 // get the machine code produced for a given expression
@@ -283,7 +611,7 @@ class LenWatch : public llvm::JITEventListener {
 public:
   std::string fname;
   size_t sz;
-  LenWatch(const std::string& fname) : fname(fname), sz(0) { }
+  explicit LenWatch(const std::string& fname) : fname(fname), sz(0) { }
   size_t size() const { return this->sz; }
   void NotifyObjectEmitted(const llvm::object::ObjectFile& o, const llvm::RuntimeDyld::LoadedObjectInfo&) {
     for (auto s : o.symbols()) {
@@ -353,6 +681,23 @@ jitcc::bytes jitcc::machineCodeForExpr(const ExprPtr& e) {
   return r;
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+bool jitcc::isDefined(const std::string& vn) const {
+  if (this->globals->contains(vn)) {
+    return true;
+  }
+  if (this->constants->contains(vn)) {
+    return true;
+  }
+  if (lookupOp(vn) != nullptr) {
+    return true;
+  }
+  if (this->vtenv->contains(vn)) {
+    return true;
+  }
+  return false;
+}
+#else
 bool jitcc::isDefined(const std::string& vn) const {
   if (this->globals.find(vn) != this->globals.end()) {
     return true;
@@ -369,6 +714,7 @@ bool jitcc::isDefined(const std::string& vn) const {
     return false;
   }
 }
+#endif
 
 llvm::Value* jitcc::compile(const ExprPtr& exp) {
   return toLLVM(this, exp);
@@ -387,6 +733,30 @@ op* jitcc::lookupOp(const std::string& vn) const {
   return (f == this->fenv.end()) ? 0 : f->second;
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+void jitcc::bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x) {
+  assert(not this->globals->contains(vn));
+
+  void* value = x;
+  if (is<Func>(ty) != nullptr) {
+    withContext([&](auto&) {
+      this->globals->add(vn, *this->module(),
+                         llvm::cast<llvm::FunctionType>(toLLVM(ty, /*asArg=*/false)),
+                         /*existingF=*/nullptr);
+    });
+  } else {
+    if (hasPointerRep(ty) || isFileType(ty)) {
+      void** p = reinterpret_cast<void**>(this->globalData.malloc(sizeof(void*)));
+      *p = x;
+      value = p;
+    }
+
+    withContext(
+        [&](auto&) { return this->globals->add(vn, *this->module(), toLLVM(ty, /*asArg=*/true)); });
+  }
+  llvm::cantFail(orcjit->addExternalSymbol(vn, value));
+}
+#else
 void jitcc::bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x) {
   Global g;
   g.type  = ty;
@@ -419,14 +789,16 @@ void jitcc::bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x) {
                          vn
                        ),
                        sizeof(void*));
-    
+
 #if LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
   this->eengine->addGlobalMapping(g.ref.var, g.value);
 #endif
   }
   this->globals[vn] = g;
 }
+#endif
 
+#if LLVM_VERSION_MAJOR < 11
 llvm::Value* jitcc::maybeRefGlobalV(llvm::Value* v) {
   llvm::Module* thisMod = module();
 
@@ -448,7 +820,13 @@ llvm::Value* jitcc::maybeRefGlobalV(llvm::Value* v) {
     return v;
   }
 }
+#endif
 
+#if LLVM_VERSION_MAJOR >= 11
+llvm::GlobalVariable* jitcc::lookupGlobalVar(const std::string& vn) {
+  return withContext([&](auto&) { return this->globals->getOrCreateVarDecl(vn, *this->module()); });
+}
+#else
 llvm::GlobalVariable* jitcc::maybeRefGlobal(const std::string& vn) {
   auto gv = this->globals.find(vn);
   if (gv != this->globals.end() && !is<Func>(gv->second.type)) {
@@ -456,7 +834,9 @@ llvm::GlobalVariable* jitcc::maybeRefGlobal(const std::string& vn) {
   }
   return 0;
 }
+#endif
 
+#if LLVM_VERSION_MAJOR < 11
 llvm::GlobalVariable* jitcc::refGlobal(const std::string& vn, llvm::GlobalVariable* gv) {
   llvm::Module* mod = module();
 
@@ -477,41 +857,60 @@ llvm::GlobalVariable* jitcc::refGlobal(const std::string& vn, llvm::GlobalVariab
                   sizeof(void*));
   }
 }
+#endif
 
 llvm::GlobalVariable* jitcc::lookupVarRef(const std::string& vn) {
   // if any local variables shadow this global, hide it
+#if LLVM_VERSION_MAJOR >= 11
+  if (this->vtenv->contains(vn)) {
+    return nullptr;
+  }
+#else
   for (auto vbs : this->vtenv) {
     if (vbs.find(vn) != vbs.end()) {
       return 0;
     }
   }
+#endif
 
   // now if we've got a global with this name, we can get a pointer to it
+#if LLVM_VERSION_MAJOR >= 11
+  return lookupGlobalVar(vn);
+#else
   return maybeRefGlobal(vn);
+#endif
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+llvm::Value* jitcc::loadConstant(const std::string& vn) {
+  return withContext(
+      [&](auto&) { return this->constants->loadConstant(vn, *this->module(), *builder()); });
+}
+#else
 llvm::Value* jitcc::loadConstant(const std::string& vn) {
   auto cv = this->constants.find(vn);
   if (cv != this->constants.end()) {
-    if (is<Array>(cv->second.mtype)) {
-      return builder()->CreateLoad(refGlobal(vn, cv->second.ref));
-    } else if (llvm::Value* r = refGlobal(vn, cv->second.ref)) {
-#if LLVM_VERSION_MAJOR <= 10
-      return hasPointerRep(cv->second.mtype) ? r : builder()->CreateLoad(r);
+    return withContext([&](auto&) -> llvm::Value* {
+      if (is<Array>(cv->second.mtype)) {
+        return builder()->CreateLoad(refGlobal(vn, cv->second.ref));
+      } else if (llvm::Value* r = refGlobal(vn, cv->second.ref)) {
+#if   LLVM_VERSION_MAJOR <= 10
+        return hasPointerRep(cv->second.mtype) ? r : builder()->CreateLoad(r);
 #elif LLVM_VERSION_MAJOR <= 12 
-      return hasPointerRep(cv->second.mtype) ? r : builder()->CreateAlignedLoad(r->getType()->getPointerElementType(), r, llvm::MaybeAlign(8));
+        return hasPointerRep(cv->second.mtype) ? r : builder()->CreateAlignedLoad(r->getType()->getPointerElementType(), r, llvm::MaybeAlign(8));
 #endif
-    } else {
-      return cv->second.value;
-    }
+      } else {
+        return cv->second.value;
+      }
+    });
   }
-  return 0;
+  return nullptr;
 }
+#endif
 
 void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
   std::string vname = vn.empty() ? (".global" + freshName()) : vn;
   this->globalExprs[vn] = ue;
-
   typedef void (*Thunk)();
   MonoTypePtr uety = requireMonotype(this->tenv, ue);
 
@@ -523,6 +922,10 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
     resetMemoryPool();
   } else if (llvm::Constant* c = toLLVMConstant(this, vname, ue)) {
     // make a global constant ...
+#if LLVM_VERSION_MAJOR >= 11
+    withContext(
+        [&](auto&) { return this->constants->createDefinition(vname, *module(), c, uety); });
+#else
     Constant& cv = this->constants[vname];
     cv.value = c;
     cv.type  = toLLVM(uety);
@@ -534,6 +937,7 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
     } else {
       cv.ref = new llvm::GlobalVariable(*module(), cv.type, true, llvm::GlobalVariable::ExternalLinkage, c, vname);
     }
+#endif
   } else {
     // make some space for this global data ...
     if (isLargeType(uety)) {
@@ -545,16 +949,18 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
     }
 
     // compile an initializer function for this expression
-    llvm::BasicBlock* ibb = this->builder()->GetInsertBlock();
+    llvm::BasicBlock* ibb = withContext([this](auto&) { return this->builder()->GetInsertBlock(); });
     llvm::Function* initfn = allocFunction("." + vname + "_init", MonoTypes(), primty("unit"));
-    if (initfn == 0) {
+    if (initfn == nullptr) {
       throw annotated_error(*ue, "Failed to allocate initializer function for '" + vname + "'.");
     }
-    llvm::BasicBlock* bb = llvm::BasicBlock::Create(context(), "entry", initfn);
-    this->builder()->SetInsertPoint(bb);
+    withContext([&](llvm::LLVMContext& c) {
+      llvm::BasicBlock* bb = llvm::BasicBlock::Create(c, "entry", initfn);
+      this->builder()->SetInsertPoint(bb);
 
-    compile(assign(var(vname, uety, ue->la()), ue, ue->la()));
-    this->builder()->CreateRetVoid();
+      compile(assign(var(vname, uety, ue->la()), ue, ue->la()));
+      this->builder()->CreateRetVoid();
+    });
 
     // compile and run this function, it should then perform the global variable assignment
     // (make sure that any allocation happens in the global context iff we need it)
@@ -571,8 +977,10 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
 
     // clean up
     releaseMachineCode(reinterpret_cast<void*>(f));
-    this->builder()->SetInsertPoint(ibb);
+    withContext([this, ibb](auto&) { this->builder()->SetInsertPoint(ibb); });
+#if LLVM_VERSION_MAJOR < 11
     initfn->eraseFromParent();
+#endif
   }
 }
 
@@ -603,6 +1011,14 @@ llvm::Value* jitcc::lookupVar(const std::string& vn, const MonoTypePtr& vty) {
   }
 
   // try to find this variable up the local variable stack (unless we're ignoring local scope)
+#if LLVM_VERSION_MAJOR >= 11
+  if (!this->ignoreLocalScope) {
+    if (auto* fn =
+            withContext([&](auto&) { return this->vtenv->getOrCreateDecl(vn, *this->module()); })) {
+      return fn;
+    }
+  }
+#else
   if (!this->ignoreLocalScope) {
     for (size_t i = 0; i < this->vtenv.size(); ++i) {
       const VarBindings& vbs = this->vtenv[this->vtenv.size() - (i + 1)];
@@ -612,10 +1028,15 @@ llvm::Value* jitcc::lookupVar(const std::string& vn, const MonoTypePtr& vty) {
       }
     }
   }
+#endif
 
   // try to find this variable as a global
+#if LLVM_VERSION_MAJOR >= 11
+  if (llvm::GlobalVariable* gv = lookupGlobalVar(vn)) {
+#else
   if (llvm::GlobalVariable* gv = maybeRefGlobal(vn)) {
-    return builder()->CreateLoad(gv);
+#endif
+    return withContext([this, gv](auto&) { return builder()->CreateLoad(gv); });
   }
 
   // maybe it's a function?
@@ -647,6 +1068,19 @@ llvm::Value* jitcc::internConstString(const std::string& x) {
   return lookupVar(vn, arrayty(primty("char")));
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+void jitcc::pushScope() {
+  this->vtenv->pushScope();
+}
+
+void jitcc::bindScope(const std::string& vn, llvm::Value* v) {
+  this->vtenv->add(vn, v);
+}
+
+void jitcc::popScope() {
+  this->vtenv->popScope();
+}
+#else
 void jitcc::pushScope() {
   this->vtenv.push_back(VarBindings());
 }
@@ -658,6 +1092,7 @@ void jitcc::bindScope(const std::string& vn, llvm::Value* v) {
 void jitcc::popScope() {
   this->vtenv.pop_back();
 }
+#endif
 
 llvm::Value* jitcc::compileAtGlobalScope(const ExprPtr& exp) {
   this->ignoreLocalScope = true;
@@ -671,10 +1106,17 @@ llvm::Value* jitcc::compileAtGlobalScope(const ExprPtr& exp) {
   }
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+llvm::Function* jitcc::lookupFunction(const std::string& fn) {
+  return withContext(
+      [&](auto&) { return this->globals->getOrCreateFuncDecl(fn, *this->module()); });
+}
+#else
 llvm::Function* jitcc::lookupFunction(const std::string& fn) {
   llvm::Module* thisMod = module();
 
-  for (auto m : this->modules) {
+  for (size_t i = 0; i<this->modules.size(); ++i) {
+    auto m = this->modules[i];
     if (llvm::Function* f = m->getFunction(fn)) {
       if (m == thisMod) {
         return f;
@@ -685,7 +1127,7 @@ llvm::Function* jitcc::lookupFunction(const std::string& fn) {
   }
   return 0;
 }
-
+#endif
 llvm::Function* jitcc::compileFunction(const std::string& name, const str::seq& argns, const MonoTypes& argtys, const ExprPtr& exp) {
   UCFS fs;
   fs.push_back(UCF(name, argns, argtys, exp));
@@ -726,7 +1168,7 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
   UCFS& fs = *ufs;
 
   // save our current write context to restore later
-  llvm::BasicBlock* ibb = this->builder()->GetInsertBlock();
+  llvm::BasicBlock* ibb = withContext([this](auto&) { return this->builder()->GetInsertBlock(); });
 
   // prepare the environment for these mutually-recursive definitions
   for (size_t f = 0; f < fs.size(); ++f) {
@@ -735,7 +1177,11 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
       throw std::runtime_error("Failed to allocate function");
     }
 
+#if LLVM_VERSION_MAJOR >= 11
+    this->bindScope(fs[f].name, fval);
+#else
     this->vtenv.back()[fs[f].name] = fval;
+#endif
     fs[f].result = fval;
   }
 
@@ -744,57 +1190,76 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
     llvm::Function*   fval = fs[f].result;
     const UCF&        ucf  = fs[f];
     MonoTypePtr       rty  = requireMonotype(this->tenv, ucf.exp);
-    llvm::BasicBlock* bb   = llvm::BasicBlock::Create(context(), "entry", fval);
+    llvm::BasicBlock* bb = withContext(
+        [fval](llvm::LLVMContext& c) { return llvm::BasicBlock::Create(c, "entry", fval); });
 
-    this->builder()->SetInsertPoint(bb);
+    withContext([this, bb](auto&) { return this->builder()->SetInsertPoint(bb); });
 
     // set argument names for safe referencing here
+#if LLVM_VERSION_MAJOR >= 11
+    this->pushScope();
+#else
     this->vtenv.push_back(VarBindings());
+#endif
 
     llvm::Function::arg_iterator a = fval->arg_begin();
     for (unsigned int i = 0; i < ucf.argns.size(); ++i) {
       if (isUnit(ucf.argtys[i])) {
+#if LLVM_VERSION_MAJOR >= 11
+        this->bindScope(ucf.argns[i], cvalue(true)); // this should never even be seen
+#else
         this->vtenv.back()[ucf.argns[i]] = cvalue(true); // this should never even be seen
+#endif
       } else {
         a->setName(ucf.argns[i]);
 
         llvm::Value* argv = &*a;
         if (is<FixedArray>(ucf.argtys[i])) {
-          argv = cast(this->builder(), ptrType(toLLVM(ucf.argtys[i], false)), argv);
+          argv = withContext([&](auto&) {
+            return cast(this->builder(), ptrType(toLLVM(ucf.argtys[i], false)), argv);
+          });
         }
+#if LLVM_VERSION_MAJOR >= 11
+        this->bindScope(ucf.argns[i], argv);
+#else
         this->vtenv.back()[ucf.argns[i]] = argv;
+#endif
         ++a;
       }
     }
 
-    try {
-      // compile the function body
-      llvm::Value* cexp = compile(ucf.exp);
-      if (isUnit(rty)) {
-        this->builder()->CreateRetVoid();
-      } else {
-        this->builder()->CreateRet(cexp);
-      }
+    withContext([&](auto&) {
+      try {
+        // compile the function body
+        llvm::Value* cexp = compile(ucf.exp);
+        if (isUnit(rty)) {
+          this->builder()->CreateRetVoid();
+        } else {
+          this->builder()->CreateRet(cexp);
+        }
 
 #if LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
       this->fpm->run(*fval);
 #endif
 
-      // and we're done
-      this->vtenv.pop_back();
-      if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
-    } catch (...) {
-      if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
-      this->vtenv.pop_back();
-      throw;
-    }
+        // and we're done
+        this->popScope();
+        if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
+      } catch (...) {
+        if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
+        this->popScope();
+        throw;
+      }
+    });
   }
 }
 
 llvm::Value* jitcc::compileAllocStmt(llvm::Value* sz, llvm::Value* asz, llvm::Type* mty, bool zeroMem) {
   llvm::Function* f = lookupFunction(zeroMem ? "mallocz" : "malloc");
   if (!f) throw std::runtime_error("Expected heap allocation function as call.");
-  return builder()->CreateBitCast(fncall(builder(), f, f->getFunctionType(), list(sz, asz)), mty);
+  return withContext([&](auto&) {
+    return builder()->CreateBitCast(fncall(builder(), f, f->getFunctionType(), list(sz, asz)), mty);
+  });
 }
 
 llvm::Value* jitcc::compileAllocStmt(size_t sz, size_t asz, llvm::Type* mty, bool zeroMem) {
@@ -804,6 +1269,37 @@ llvm::Value* jitcc::compileAllocStmt(size_t sz, size_t asz, llvm::Type* mty, boo
 void jitcc::releaseMachineCode(void*) {
 }
 
+#if LLVM_VERSION_MAJOR >= 11
+llvm::Function* jitcc::allocFunction(const std::string& fname, const MonoTypes& argl, const MonoTypePtr& rty) {
+  const auto f = [=](llvm::Module& m) {
+    llvm::Type* retType = toLLVM(rty, true);
+    auto* f = llvm::Function::Create(
+        llvm::FunctionType::get(retType, toLLVM(argl, true), false),
+        fname.find(".patfs.") == 0 ? llvm::Function::InternalLinkage
+                                   : llvm::Function::ExternalLinkage,
+        fname, m);
+    // https://bugs.llvm.org/show_bug.cgi?id=51163
+    // for a llvm version >=9, zeroext has to be added to functions return boolean
+    // otherwise, 255 will be returned as true
+    if (retType == boolType()) {
+      f->addAttribute(llvm::AttributeList::ReturnIndex, llvm::Attribute::ZExt);
+    }
+    return f;
+  };
+  llvm::Function* ret = withContext([&](auto&) { return f(*this->module()); });
+
+  if (fname.find(".rfn.t") != std::string::npos) {
+    this->vtenv->add(fname, f, ret);
+  } else if (!this->globals->contains(fname)) {
+    withContext([&](auto&) {
+      return this->globals->add(
+          fname, *this->module(),
+          llvm::FunctionType::get(toLLVM(rty, true), toLLVM(argl, true), false), ret);
+    });
+  }
+  return ret;
+}
+#else
 llvm::Function* jitcc::allocFunction(const std::string& fname, const MonoTypes& argl, const MonoTypePtr& rty) {
   return
     llvm::Function::Create(
@@ -813,6 +1309,7 @@ llvm::Function* jitcc::allocFunction(const std::string& fname, const MonoTypes&
       module()
     );
 }
+#endif
 
 void* jitcc::reifyMachineCodeForFn(const MonoTypePtr&, const str::seq& names, const MonoTypes& tys, const ExprPtr& exp) {
   return getMachineCode(compileFunction("", names, tys, exp));
@@ -841,7 +1338,9 @@ Values compileArgs(jitcc* c, const Exprs& es) {
 
     if (is<Array>(et)) {
       // variable-length arrays need to be cast to a single type to pass LLVM's check
-      r.push_back(c->builder()->CreateBitCast(ev, toLLVM(et)));
+      r.push_back(withContext([&](auto&) {
+          return c->builder()->CreateBitCast(ev, toLLVM(et));
+      }));
     } else if (isUnit(et)) {
       // no need to pass unit anywhere
     } else {
diff --git a/lib/hobbes/eval/orcjitcc.C b/lib/hobbes/eval/orcjitcc.C
new file mode 100644
index 000000000..b21082863
--- /dev/null
+++ b/lib/hobbes/eval/orcjitcc.C
@@ -0,0 +1,96 @@
+#include <hobbes/eval/orcjitcc.H>
+
+#include <llvm/Config/llvm-config.h>
+
+#if LLVM_VERSION_MAJOR >= 11
+#include <hobbes/hobbes.H>
+#include <hobbes/util/llvm.H>
+
+#include <llvm/ExecutionEngine/Orc/CompileUtils.h>
+
+namespace hobbes {
+
+ORCJIT::ORCJIT(std::unique_ptr<llvm::TargetMachine> tm,
+               const llvm::DataLayout &dl)
+    : targetMachine(std::move(tm)), dataLayout(dl),
+      mangle(execSession, dataLayout),
+      objectLayer(
+          execSession,
+          []() { return std::make_unique<llvm::SectionMemoryManager>(); }),
+      compileLayer(execSession, objectLayer,
+                   std::make_unique<llvm::orc::SimpleCompiler>(*targetMachine)),
+      optLayer(execSession, compileLayer, optimizeModule),
+      mainJD(execSession.createBareJITDylib(createUniqueName("main"))) {
+  mainJD.addGenerator(
+      cantFail(llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+          dataLayout.getGlobalPrefix())));
+}
+
+#if LLVM_VERSION_MAJOR >= 12
+ORCJIT::~ORCJIT() {
+  // https://repo.hca.bsc.es/gitlab/rferrer/llvm-epi/-/commit/0aec49c8531bc5282b095730d34681455826bc2c
+  // newly added in llvm12, has to be called to destroy objectLayer associated memory manager
+  llvm::cantFail(execSession.endSession());
+}
+#else
+ORCJIT::~ORCJIT() = default;
+#endif
+
+llvm::Expected<std::unique_ptr<ORCJIT>> ORCJIT::create() {
+  auto jtmb = llvm::orc::JITTargetMachineBuilder::detectHost();
+  if (!jtmb) {
+    return jtmb.takeError();
+  }
+
+  auto tm = jtmb->createTargetMachine();
+  if (!tm) {
+    return tm.takeError();
+  }
+
+  auto dl = jtmb->getDefaultDataLayoutForTarget();
+  if (!dl) {
+    return dl.takeError();
+  }
+
+  return std::make_unique<ORCJIT>(std::move(*tm), *dl);
+}
+
+llvm::Error ORCJIT::addModule(std::unique_ptr<llvm::Module> m) {
+  return withContext([&](auto&) {
+    m->setDataLayout(dataLayout);
+    return optLayer.add(mainJD, llvm::orc::ThreadSafeModule(std::move(m), threadSafeContext()));
+  });
+}
+
+llvm::Expected<llvm::JITEvaluatedSymbol> ORCJIT::lookup(llvm::StringRef name) {
+  return execSession.lookup({&mainJD}, mangle(name.str()));
+}
+
+llvm::Error ORCJIT::addExternalSymbol(llvm::StringRef name, void *ptr) {
+  return mainJD.define(llvm::orc::absoluteSymbols(
+      {{mangle(name), llvm::JITEvaluatedSymbol::fromPointer(ptr)}}));
+}
+
+llvm::Expected<llvm::orc::ThreadSafeModule>
+ORCJIT::optimizeModule(llvm::orc::ThreadSafeModule tsm,
+                       const llvm::orc::MaterializationResponsibility &) {
+  tsm.withModuleDo([](llvm::Module &m) {
+    auto fpm = llvm::legacy::FunctionPassManager(&m);
+    fpm.add(llvm::createReassociatePass());
+    fpm.add(llvm::createNewGVNPass());
+    fpm.add(llvm::createCFGSimplificationPass());
+    fpm.add(llvm::createTailCallEliminationPass());
+    fpm.doInitialization();
+    for (auto &f : m) {
+      fpm.run(f);
+    }
+
+    auto mpm = llvm::legacy::PassManager();
+    mpm.add(llvm::createFunctionInliningPass());
+    mpm.run(m);
+  });
+
+  return tsm;
+}
+} // namespace hobbes
+#endif
diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index 5a18ae133..b4da60eec 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -1,4 +1,5 @@
-
+#include <hobbes/hobbes.H>
+#include <hobbes/util/llvm.H>
 #include <hobbes/lang/pat/dfa.H>
 #include <hobbes/lang/pat/regex.H>
 #include <hobbes/lang/pat/print.H>
@@ -1411,14 +1412,18 @@ struct makePrimDFASF : public switchMState<UnitV> {
     }
 
     if (x->jumps().size() > 0 && is<Double>(x->jumps().begin()->first)) {
-      llvm::SwitchInst* s = this->dfa->c->builder()->CreateSwitch(this->dfa->c->builder()->CreateBitCast(arg(x->switchVar()), longType()), blockForState(x->defaultState()), x->jumps().size());
+      llvm::SwitchInst* s = withContext([&](auto&) {
+        return this->dfa->c->builder()->CreateSwitch(this->dfa->c->builder()->CreateBitCast(arg(x->switchVar()), longType()), blockForState(x->defaultState()), x->jumps().size());
+      });
       for (const auto& jmp : x->jumps()) {
         if (const Double* d = is<Double>(jmp.first)) {
           s->addCase(civalue(asLongRep(d->value())), blockForState(jmp.second));
         }
       }
     } else {
-      llvm::SwitchInst* s = this->dfa->c->builder()->CreateSwitch(arg(x->switchVar()), blockForState(x->defaultState()), x->jumps().size());
+      llvm::SwitchInst* s = withContext([&](auto&) {
+        return this->dfa->c->builder()->CreateSwitch(arg(x->switchVar()), blockForState(x->defaultState()), x->jumps().size());
+      });
       for (const auto& jmp : x->jumps()) {
         s->addCase(toLLVMConstantInt(jmp.first), blockForState(jmp.second));
       }
@@ -1431,11 +1436,11 @@ struct makePrimDFASF : public switchMState<UnitV> {
     if (ei == this->dfa->exprIdxs.end()) {
       throw std::runtime_error("Internal error, primitive match DFA returns non-indexed expression");
     } else {
-      this->dfa->c->builder()->CreateRet(cvalue(static_cast<int>(ei->second)));
+      withContext([&](auto&) { this->dfa->c->builder()->CreateRet(cvalue(static_cast<int>(ei->second))); });
     }
     return unitv;
   }
-  
+
   UnitV with(const LoadVars*) const {
     throw std::runtime_error("Internal error, not a primitive match table (load vars)");
   }
@@ -1449,13 +1454,15 @@ struct makePrimDFASF : public switchMState<UnitV> {
     if (b != this->branches->end()) {
       return b->second;
     } else {
-      llvm::BasicBlock* obb = this->dfa->c->builder()->GetInsertBlock();
-      llvm::BasicBlock* bb  = llvm::BasicBlock::Create(context(), ".pmst" + freshName(), obb->getParent());
-      this->dfa->c->builder()->SetInsertPoint(bb);
-      switchOf(this->dfa->states[s], *this);
-      (*this->branches)[s] = bb;
-      this->dfa->c->builder()->SetInsertPoint(obb);
-      return bb;
+      return withContext([&](llvm::LLVMContext& ctx) {
+        llvm::BasicBlock* obb = this->dfa->c->builder()->GetInsertBlock();
+        llvm::BasicBlock* bb = llvm::BasicBlock::Create(ctx, ".pmst" + freshName(), obb->getParent());
+        this->dfa->c->builder()->SetInsertPoint(bb);
+        switchOf(this->dfa->states[s], *this);
+        (*this->branches)[s] = bb;
+        this->dfa->c->builder()->SetInsertPoint(obb);
+        return bb;
+      });
     }
   }
 };
@@ -1468,10 +1475,13 @@ llvm::Function* makePrimMatchDFAFunc(const std::string& fname, MDFA* dfa, statei
     }
   }
 
-  llvm::Function*   result = llvm::Function::Create(llvm::FunctionType::get(intType(), atys, false), llvm::Function::ExternalLinkage, fname, dfa->c->module());
-  llvm::BasicBlock* bb     = llvm::BasicBlock::Create(context(), "entry", result);
+  llvm::Function* result   = withContext([&](auto&) {
+    return llvm::Function::Create(llvm::FunctionType::get(intType(), atys, false),
+                                  llvm::Function::ExternalLinkage, fname, dfa->c->module());
+  });
+  llvm::BasicBlock* bb     = withContext([result](llvm::LLVMContext& ctx) { return llvm::BasicBlock::Create(ctx, "entry", result); });
 
-  dfa->c->builder()->SetInsertPoint(bb);
+  withContext([dfa, bb](auto&) { dfa->c->builder()->SetInsertPoint(bb); });
 
   Args fargs;
   llvm::Function::arg_iterator a = result->arg_begin();
@@ -1506,7 +1516,7 @@ public:
   }
 
   llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
-    return fncall(c->builder(), this->vfn, this->vfn->getFunctionType(), compileArgs(c, es));
+    return withContext([&](auto&) { return fncall(c->builder(), this->vfn, this->vfn->getFunctionType(), compileArgs(c, es)); });
   }
 
   PolyTypePtr type(typedb&) const {
diff --git a/test/Arrays.C b/test/Arrays.C
index 2568ad8fa..bcb5ee57f 100644
--- a/test/Arrays.C
+++ b/test/Arrays.C
@@ -46,7 +46,7 @@ TEST(Arrays, Streams) {
   ));
   EXPECT_TRUE((c().compileFn<bool()>(
     "takeS(10, [s | |even='12(?<s>[4-9]+)'| <- [if (x%2 == 0) then |even=show(x)| else |odd=x|::|even:[char],odd:int| | x <- [0..], x > 20]]) == [\"4\", \"6\", \"8\", \"44\", \"46\", \"48\", \"54\", \"56\", \"58\", \"64\"]"
-  )));
+  )()));
 }
 
 TEST(Arrays, WithStdVector) {
diff --git a/test/Matching.C b/test/Matching.C
index e5ece1fef..b5205b71e 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -324,25 +324,21 @@ TEST(Matching, Monadic) {
 }
 
 TEST(Matching, matchFromStringToBoolIsBool) {
-  bool r = c().compileSafeFn<bool()>("match \"1\" \"2\" \"3\" \"4\" with\n"
-                                     "| \"1\" \"2\" \"3\" \"4\" -> true\n"
-                                     "| \"1\" \"2\" \"3\" _     -> true\n"
-                                     "| \"1\" \"2\" _ _         -> true\n"
-                                     "| \"1\" _ _ _             -> true\n"
-                                     "| _ _ _ _                 -> false")();
-  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t *>(&r));
-  EXPECT_TRUE(r);
+  EXPECT_TRUE(c().compileFn<bool()>("match \"1\" \"2\" \"3\" \"4\" with\n"
+                                    "| \"1\" \"2\" \"3\" \"4\" -> true\n"
+                                    "| \"1\" \"2\" \"3\" _     -> true\n"
+                                    "| \"1\" \"2\" _ _         -> true\n"
+                                    "| \"1\" _ _ _             -> true\n"
+                                    "| _ _ _ _                 -> false"));
 }
 
 TEST(Matching, matchFromIntToBoolIsBool) {
-  bool r = c().compileSafeFn<bool()>("match 1 2 3 4 with\n"
-                                     "| 1 2 3 4 -> true\n"
-                                     "| 1 2 3 _ -> true\n"
-                                     "| 1 2 _ _ -> true\n"
-                                     "| 1 _ _ _ -> true\n"
-                                     "| _ _ _ _ -> false")();
-  EXPECT_TRUE(1 == *reinterpret_cast<uint8_t *>(&r));
-  EXPECT_TRUE(r);
+  EXPECT_TRUE(c().compileFn<bool()>("match 1 2 3 4 with\n"
+                                    "| 1 2 3 4 -> true\n"
+                                    "| 1 2 3 _ -> true\n"
+                                    "| 1 2 _ _ -> true\n"
+                                    "| 1 _ _ _ -> true\n"
+                                    "| _ _ _ _ -> false"));
 }
 
 TEST(Matching, matchFromStringToIntIsCorrect) {

From e00dab5471108e99d354ee2a1eca3e3bb466369c Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 4 Aug 2021 18:41:51 +0000
Subject: [PATCH 10/40] instead of reinterpret_cast, memcpy/alignas should be
 used to get proper type punning and alignment (#415)

---
 include/hobbes/db/series.H |  4 ++--
 include/hobbes/mc/encode.H | 11 ++++++-----
 include/hobbes/reflect.H   |  5 +++--
 lib/hobbes/lang/type.C     |  5 +++--
 4 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/include/hobbes/db/series.H b/include/hobbes/db/series.H
index 48f82acd5..4c7c274f4 100644
--- a/include/hobbes/db/series.H
+++ b/include/hobbes/db/series.H
@@ -170,8 +170,8 @@ public:
 private:
   StorageMode sm;
   union {
-    char rss[sizeof(RawStoredSeries)];
-    char css[sizeof(CompressedStoredSeries)];
+    alignas(RawStoredSeries) char rss[sizeof(RawStoredSeries)];
+    alignas(CompressedStoredSeries) char css[sizeof(CompressedStoredSeries)];
   } storage;
 };
 
diff --git a/include/hobbes/mc/encode.H b/include/hobbes/mc/encode.H
index afd72930f..c3ae43c21 100644
--- a/include/hobbes/mc/encode.H
+++ b/include/hobbes/mc/encode.H
@@ -55,7 +55,7 @@
 
 #include <sys/mman.h>
 #include <unistd.h>
-#include <string.h>
+#include <cstring>
 #include <math.h>
 
 namespace hobbes { namespace mc {
@@ -143,7 +143,7 @@ public:
   // add a label reference at the current write position (assuming a 32-bit displacement)
   void addLabelRef(const std::string& lbl) {
     this->labelRefs[lbl].push_back(this->sz);
-    *reinterpret_cast<uint32_t*>(allocate(sizeof(uint32_t))) = 0;
+    std::memset(allocate(sizeof(uint32_t)), 0, sizeof(uint32_t));
   }
 
   // define a label at the current write position
@@ -230,7 +230,8 @@ private:
         if (!canLowerTo<int32_t>(dist)) {
           throw std::runtime_error("Can't resolve label reference to '" + d->first + "' in program with jump distance greater than 32-bits");
         }
-        *reinterpret_cast<int32_t*>(this->mem + pc) = static_cast<int32_t>(dist);
+        const auto dist32 = static_cast<int32_t>(dist);
+        std::memcpy(this->mem + pc, &dist32, sizeof(dist32));
       }
     }
   }
@@ -1550,7 +1551,7 @@ inline void emitValue(buffer* b, const MODRMCode& modrm) {
   if (O == 1) {
     *b->allocate(1) = static_cast<int8_t>(modrm.disp);
   } else if (O == 2 || (O == 0 && thd_233(modrm.modrm) == 5) || (O == 0 && hasSIB && thd_233(modrm.sib) == 5)) {
-    *reinterpret_cast<int32_t*>(b->allocate(4)) = modrm.disp;
+    std::memcpy(b->allocate(4), &modrm.disp, sizeof(modrm.disp));
   }
 }
 
@@ -1622,7 +1623,7 @@ public:
           // mov rax, faddr
           (*b)[0] = REXW().byte;
           (*b)[1] = 0xb8;
-          *reinterpret_cast<const void**>(&(*b)[2]) = faddr;
+          std::memcpy(&(*b)[2], &faddr, sizeof(faddr));
 
           // call rax
           Reg<X86Reg> rax;
diff --git a/include/hobbes/reflect.H b/include/hobbes/reflect.H
index 2a150be62..b575156cf 100644
--- a/include/hobbes/reflect.H
+++ b/include/hobbes/reflect.H
@@ -18,7 +18,7 @@
 #include <map>
 #include <iostream>
 #include <sstream>
-#include <string.h>
+#include <cstring>
 #include <assert.h>
 #include <stdexcept>
 #include <type_traits>
@@ -1362,7 +1362,8 @@ inline bool operator!=(const desc& t0, const desc& t1) {
 template <typename T>
   T readValue(const bytes& bs, size_t* i) {
     assert((bs.size() >= (*i + sizeof(T))) && "Invalid type encoding, expected data not available");
-    T result = *reinterpret_cast<const T*>(&bs[*i]);
+    T result;
+    std::memcpy(&result, &bs[*i], sizeof(T));
     *i += sizeof(T);
     return result;
   }
diff --git a/lib/hobbes/lang/type.C b/lib/hobbes/lang/type.C
index 02d34d29d..f1d8acc09 100644
--- a/lib/hobbes/lang/type.C
+++ b/lib/hobbes/lang/type.C
@@ -10,7 +10,7 @@
 #include <hobbes/util/perf.H>
 #include <sstream>
 #include <stdexcept>
-#include <string.h>
+#include <cstring>
 #include <unordered_map>
 #include <atomic>
 
@@ -2362,7 +2362,8 @@ template <typename T>
 template <typename T>
   struct readF {
     static T read(const bytes& in, unsigned int* n) {
-      T r = *reinterpret_cast<const T*>(&(in[*n]));
+      T r;
+      std::memcpy(&r, &in[*n], sizeof(T));
       *n += sizeof(T);
       return r;
     }

From 30574be2455852c3d9d98d1e554873e61481d7b7 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 4 Aug 2021 18:46:00 +0000
Subject: [PATCH 11/40] Make jit lazy (#416)

* enable concurrent compilation inside LLJIT

* add lazy jit

* make function calls and declaration which return bool consistent with definitions (zeroext)

* use angle brackets on include headers
---
 include/hobbes/eval/orcjitcc.H |  54 ++---
 include/hobbes/util/llvm.H     |   6 +-
 lib/hobbes/eval/jitcc.C        | 392 +++++++++++++++++++--------------
 lib/hobbes/eval/orcjitcc.C     | 141 ++++++------
 4 files changed, 330 insertions(+), 263 deletions(-)

diff --git a/include/hobbes/eval/orcjitcc.H b/include/hobbes/eval/orcjitcc.H
index 57debbf4f..8a5b9b937 100644
--- a/include/hobbes/eval/orcjitcc.H
+++ b/include/hobbes/eval/orcjitcc.H
@@ -4,50 +4,44 @@
 #include <llvm/Config/llvm-config.h>
 
 #if LLVM_VERSION_MAJOR >= 11
-#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
-#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
-#include <llvm/ExecutionEngine/Orc/IRTransformLayer.h>
-#include <llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h>
-#include <llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h>
+#include <llvm/ADT/Optional.h>
 #include <llvm/ExecutionEngine/JITSymbol.h>
+#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>
+#include <llvm/Support/Error.h>
+
 #include <memory>
 
+namespace llvm {
+class Module;
+namespace orc {
+class LLLazyJIT;
+class MaterializationResponsibility;
+class MangleAndInterner;
+} // namespace orc
+} // namespace llvm
+
 namespace hobbes {
 
 class ORCJIT {
 public:
-  ORCJIT(std::unique_ptr<llvm::TargetMachine> tm, const llvm::DataLayout& dl);
-  ORCJIT(const ORCJIT&) = delete;
-  ORCJIT(ORCJIT&&) = delete;
-  ORCJIT& operator=(const ORCJIT&) = delete;
-  ORCJIT& operator=(ORCJIT&&) = delete;
+  ORCJIT();
+  ORCJIT(const ORCJIT &) = delete;
+  ORCJIT(ORCJIT &&) = delete;
+  ORCJIT &operator=(const ORCJIT &) = delete;
+  ORCJIT &operator=(ORCJIT &&) = delete;
   ~ORCJIT();
 
-  static llvm::Expected<std::unique_ptr<ORCJIT>> create();
-
   llvm::Error addModule(std::unique_ptr<llvm::Module> m);
 
-  llvm::Expected<llvm::JITEvaluatedSymbol> lookup(llvm::StringRef name);
+  LLVM_NODISCARD llvm::Expected<llvm::JITEvaluatedSymbol>
+  lookup(llvm::StringRef name);
 
-  llvm::Error addExternalSymbol(llvm::StringRef name, void* ptr);
+  llvm::Error addExternalNonCallableSymbol(llvm::StringRef name, void *ptr);
+  llvm::Error addExternalCallableSymbol(llvm::StringRef name, void *ptr);
 
 private:
-  std::unique_ptr<llvm::TargetMachine> targetMachine;
-
-  llvm::orc::ExecutionSession execSession;
-
-  llvm::DataLayout dataLayout;
-  llvm::orc::MangleAndInterner mangle;
-
-  llvm::orc::RTDyldObjectLinkingLayer objectLayer;
-  llvm::orc::IRCompileLayer compileLayer;
-  llvm::orc::IRTransformLayer optLayer;
-
-  llvm::orc::JITDylib& mainJD;
-
-  static llvm::Expected<llvm::orc::ThreadSafeModule>
-  optimizeModule(llvm::orc::ThreadSafeModule tsm, const llvm::orc::MaterializationResponsibility&);
-
+  std::unique_ptr<llvm::orc::LLLazyJIT> jit;
+  std::unique_ptr<llvm::orc::MangleAndInterner> mangle;
 };
 } // namespace hobbes
 
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index 771aec681..70f58688f 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -816,7 +816,11 @@ inline llvm::Value* fncall(llvm::IRBuilder<>* b, llvm::Value* vfn, llvm::Type* t
   return b->CreateCall(vfn, args);
 #elif LLVM_VERSION_MAJOR <= 12
   if (auto *ty = llvm::dyn_cast<llvm::FunctionType>(tfn)) {
-      return b->CreateCall(ty, vfn, args);
+    auto *inst =  b->CreateCall(ty, vfn, args);
+    if (ty->getReturnType() == boolType()) {
+      inst->addAttribute(llvm::AttributeList::ReturnIndex, llvm::Attribute::ZExt);
+    }
+    return inst;
   } else {
     throw std::runtime_error("fncall(...) invoked on non-function type (internal error)");
   }
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index 263e41793..6bc76d480 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -1,17 +1,23 @@
 
-#include <hobbes/hobbes.H>
-#include <hobbes/eval/jitcc.H>
+#include <hobbes/eval/func.H>
+#include <hobbes/util/llvm.H>
 #include <hobbes/eval/cexpr.H>
+#include <hobbes/eval/jitcc.H>
+#include <hobbes/hobbes.H>
 #include <llvm/IR/Attributes.h>
 #include <llvm/IR/Constant.h>
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/GlobalVariable.h>
+#include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Value.h>
 #include <llvm/IR/ValueHandle.h>
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/Compiler.h>
 #include <llvm/Support/Error.h>
 #include <llvm/Target/TargetMachine.h>
 #include <stdexcept>
+#include <utility>
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
@@ -22,263 +28,310 @@
 #include <hobbes/eval/orcjitcc.H>
 #else
 #if LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
-#include "llvm/ExecutionEngine/JIT.h"
+#include <llvm/ExecutionEngine/JIT.h>
 #else
-#include "llvm/ExecutionEngine/MCJIT.h"
+#include <llvm/ExecutionEngine/MCJIT.h>
 #endif
 
 #if LLVM_VERSION_MINOR >= 8 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6
-#include "llvm/Analysis/BasicAliasAnalysis.h"
+#include <llvm/Analysis/BasicAliasAnalysis.h>
 #endif
 
 #if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6
-#include "llvm/Transforms/Scalar/GVN.h"
+#include <llvm/Transforms/Scalar/GVN.h>
 #endif
 #endif
 
-#include "llvm/Object/ELFObjectFile.h"
-#include "llvm/ExecutionEngine/JITEventListener.h"
+#include <llvm/Object/ELFObjectFile.h>
+#include <llvm/ExecutionEngine/JITEventListener.h>
 
 #pragma GCC diagnostic pop
 
+#if LLVM_VERSION_MAJOR >= 11
+namespace {
+LLVM_NODISCARD llvm::Function *createFnDecl(llvm::Function *f, llvm::Module &m,
+                                            llvm::StringRef name) {
+  if (f->getReturnType() == hobbes::boolType()) {
+    f->addAttribute(llvm::AttributeList::ReturnIndex, llvm::Attribute::ZExt);
+  }
+  if (f->getName() != name) {
+    f->eraseFromParent();
+    return m.getFunction(name);
+  }
+  return f;
+}
+
+LLVM_NODISCARD llvm::GlobalVariable *
+createGVDecl(llvm::GlobalVariable *gv, llvm::Module &m, llvm::StringRef name) {
+  if (gv->getName() != name) {
+    gv->eraseFromParent();
+    return m.getGlobalVariable(name);
+  }
+  return gv;
+}
+} // namespace
+#endif
+
 namespace hobbes {
 #if LLVM_VERSION_MAJOR >= 11
 class ConstantList {
-  using VarFnTy = std::function<llvm::GlobalVariable*(llvm::Module&)>;
+  using VarDeclFnTy = std::function<llvm::GlobalVariable *(llvm::Module &)>;
+  enum class Ty : std::int8_t {
+    Function,
+    GlobalVar,
+    Array,
+    HasPointerRep,
+    Other,
+  };
   struct Constant {
-    MonoTypePtr mtype;
-    variant<llvm::WeakTrackingVH, llvm::Constant*> varOrFunc;
-    VarFnTy fn;
+    // function is a constant
+    // globalvariable returned by a function
+    variant<VarDeclFnTy, llvm::Constant *> value;
+    Ty ty = Ty::Other;
   };
   llvm::StringMap<Constant> constants;
 
 public:
   ConstantList() = default;
-  ConstantList(const ConstantList&) = delete;
-  ConstantList(ConstantList&&) = delete;
-  ConstantList& operator=(const ConstantList&) = delete;
-  ConstantList& operator=(ConstantList&&) = delete;
+  ConstantList(const ConstantList &) = delete;
+  ConstantList(ConstantList &&) = delete;
+  ConstantList &operator=(const ConstantList &) = delete;
+  ConstantList &operator=(ConstantList &&) = delete;
   ~ConstantList() = default;
 
   LLVM_NODISCARD bool contains(llvm::StringRef name) const {
     return constants.find(name) != constants.end();
   }
 
-  /// Creates const global variable definition
-  ///
-  /// \p initVal is the initializer for this constant, must not be null
-  ///    or it can be a function
-  void createDefinition(const std::string& name, llvm::Module& m, llvm::Constant* initVal,
-                        const MonoTypePtr& mtype);
+  void storeFnAddr(const std::string &name, llvm::Constant *funcAddr);
+  void createGVDef(const std::string &name, llvm::Module &m,
+                   llvm::Constant *initVal, const MonoTypePtr &mtype);
 
   /// Gets constant by generating load inst or possibly recreating decl
-  LLVM_NODISCARD llvm::Value* loadConstant(llvm::StringRef name, llvm::Module& m,
-                                           llvm::IRBuilder<>& builder);
+  LLVM_NODISCARD llvm::Value *loadConstant(llvm::StringRef name,
+                                           llvm::Module &m,
+                                           llvm::IRBuilder<> &builder);
 };
 
-void ConstantList::createDefinition(const std::string& name, llvm::Module& m,
-                                    llvm::Constant* initVal, const MonoTypePtr& mtype) {
-  assert(!contains(name));
+void ConstantList::storeFnAddr(const std::string &name,
+                               llvm::Constant *funcAddr) {
+  constants[name] = Constant{.value = funcAddr, .ty = Ty::Function};
+}
+
+void ConstantList::createGVDef(const std::string &name, llvm::Module &m,
+                               llvm::Constant *initVal,
+                               const MonoTypePtr &mtype) {
+  llvm::Type *type = toLLVM(mtype);
+  new llvm::GlobalVariable(m, type, /*isConstant=*/true,
+                           llvm::GlobalVariable::ExternalLinkage, initVal,
+                           name);
+
+  const auto vf = [&, type, name](llvm::Module &m) -> llvm::GlobalVariable * {
+    return createGVDecl(
+        prepgv(new llvm::GlobalVariable(m, type, /*isConstant=*/true,
+                                        llvm::GlobalVariable::ExternalLinkage,
+                                        /*initializer=*/nullptr, name)),
+        m, name);
+  };
+  const auto tf = [&mtype] {
+    if (is<Array>(mtype) != nullptr) {
+      return Ty::Array;
+    }
+    if (hasPointerRep(mtype)) {
+      return Ty::HasPointerRep;
+    }
+    return Ty::Other;
+  };
 
-  llvm::Type* type = toLLVM(mtype);
-  if (is<Func>(mtype) != nullptr) {
-    constants[name] = Constant{.mtype = mtype, .varOrFunc = initVal, .fn = VarFnTy()};
-  } else {
-    constants[name] = Constant{
-        .mtype = mtype,
-        .varOrFunc = llvm::WeakTrackingVH(new llvm::GlobalVariable(
-            m, type, /*isConstant=*/true, llvm::GlobalVariable::ExternalLinkage, initVal, name)),
-        .fn = [&, type, name](llvm::Module& m) -> llvm::GlobalVariable* {
-          return prepgv(new llvm::GlobalVariable(m, type, /*isConstant=*/true,
-                                                 llvm::GlobalVariable::ExternalLinkage,
-                                                 /*initializer=*/nullptr, name));
-        }};
-  }
+  constants[name] = Constant{
+      .value = VarDeclFnTy(vf),
+      .ty = tf(),
+  };
 }
 
-llvm::Value* ConstantList::loadConstant(llvm::StringRef name, llvm::Module& m,
-                                        llvm::IRBuilder<>& builder) {
-  auto it = constants.find(name);
+llvm::Value *ConstantList::loadConstant(llvm::StringRef name, llvm::Module &m,
+                                        llvm::IRBuilder<> &builder) {
+  const auto it = constants.find(name);
   if (it == constants.end()) {
     return nullptr;
   }
 
-  if (is<Func>(it->second.mtype) != nullptr) {
-    return *it->second.varOrFunc.get<llvm::Constant*>();
+  if (it->second.ty == Ty::Function) {
+    return *it->second.value.get<llvm::Constant *>();
   }
 
-  return withContext([&](auto&) -> llvm::Value* {
-    if (!it->second.varOrFunc.get<llvm::WeakTrackingVH>()->pointsToAliveValue()) {
-      it->second.varOrFunc = llvm::WeakTrackingVH(it->second.fn(m));
-    }
-
-    auto* g = llvm::cast<llvm::GlobalVariable>(
-        static_cast<llvm::Value*>(*it->second.varOrFunc.get<llvm::WeakTrackingVH>()));
+  return withContext([&](auto &) -> llvm::Value * {
+    auto *g = llvm::cast<llvm::GlobalVariable>(
+        static_cast<llvm::Value *>((*it->second.value.get<VarDeclFnTy>())(m)));
 
-    if (is<Array>(it->second.mtype) != nullptr) {
+    switch (it->second.ty) {
+    case Ty::Array:
       return builder.CreateLoad(g);
-    }
-    if (hasPointerRep(it->second.mtype)) {
+    case Ty::HasPointerRep:
       return g;
+    default:
+      return builder.CreateAlignedLoad(g->getType()->getPointerElementType(), g,
+                                       llvm::MaybeAlign(8));
     }
-    return builder.CreateAlignedLoad(g->getType()->getPointerElementType(), g, llvm::MaybeAlign(8));
   });
 }
 
 class VTEnv {
 public:
-  using FunFnTy = std::function<llvm::Function*(llvm::Module&)>;
+  using FnDeclFnTy = std::function<llvm::Function *(llvm::Module &)>;
 
 private:
-  using VarBindings = llvm::StringMap<llvm::WeakTrackingVH>;
-  using VarBindingStack = llvm::SmallVector<VarBindings, 8>;
+  using ValOrFnTy = variant<FnDeclFnTy, llvm::WeakTrackingVH>;
+  using VarBindingStack = llvm::SmallVector<llvm::StringMap<ValOrFnTy>, 8>;
   VarBindingStack vtenv;
-  llvm::StringMap<FunFnTy> vtenvFuns;
 
 public:
   VTEnv() = default;
-  VTEnv(const VTEnv&) = delete;
-  VTEnv(VTEnv&&) = delete;
-  VTEnv& operator=(const VTEnv&) = delete;
-  VTEnv& operator=(VTEnv&&) = delete;
+  VTEnv(const VTEnv &) = delete;
+  VTEnv(VTEnv &&) = delete;
+  VTEnv &operator=(const VTEnv &) = delete;
+  VTEnv &operator=(VTEnv &&) = delete;
   ~VTEnv() = default;
 
   LLVM_NODISCARD bool contains(llvm::StringRef name) const {
-    return std::any_of(vtenv.rbegin(), vtenv.rend(),
-                       [name](const auto& vb) { return vb.find(name) != vb.end(); });
+    return std::any_of(vtenv.rbegin(), vtenv.rend(), [name](const auto &vb) {
+      return vb.find(name) != vb.end();
+    });
   }
 
   /// Gets \p name by looking up from inner to outer scope
   ///
   /// Possibly recreating decl
-  LLVM_NODISCARD llvm::Value* getOrCreateDecl(llvm::StringRef name, llvm::Module& m);
-
-  /// Adds variable \p name to current scope
-  void add(llvm::StringRef name, llvm::Value* v) {
-    this->vtenv.back()[name] = v;
+  LLVM_NODISCARD llvm::Value *getOrCreateDecl(llvm::StringRef name,
+                                              llvm::Module &m);
+
+  /// Adds \p name to current scope
+  void add(llvm::StringRef name, llvm::Value *v) {
+    // do not allow value overwritten function prototype
+    // otherwise some decls will not created correctly
+    if (this->vtenv.back().find(name) == this->vtenv.back().end()) {
+      this->vtenv.back()[name] = llvm::WeakTrackingVH(v);
+    }
   }
 
   /// Adds function \p name to current scope
   ///
   /// It stores function prototype for decl recreating
-  void add(llvm::StringRef name, FunFnTy f, llvm::Function* fp) {
-    this->vtenv.back()[name] = fp;
-    vtenvFuns[name] = std::move(f);
+  void add(const std::string &name, FnDeclFnTy f) {
+    this->vtenv.back()[name] = FnDeclFnTy(
+        [name, f = std::move(f)](llvm::Module &m) -> llvm::Function * {
+          return createFnDecl(f(m), m, name);
+        });
   }
 
   /// Create a new inner scope
-  void pushScope() {
-    vtenv.push_back(VarBindings());
-  }
+  void pushScope() { vtenv.emplace_back(); }
 
   /// Destroys the inner scope
-  void popScope() {
-    vtenv.pop_back();
-  }
+  void popScope() { vtenv.pop_back(); }
 };
 
-llvm::Value* VTEnv::getOrCreateDecl(llvm::StringRef name, llvm::Module& m) {
+llvm::Value *VTEnv::getOrCreateDecl(llvm::StringRef name, llvm::Module &m) {
   for (auto vb = vtenv.rbegin(); vb != vtenv.rend(); ++vb) {
-    auto it = vb->find(name);
+    const auto it = vb->find(name);
     if (it == vb->end()) {
       continue;
     }
-    if (!it->second.pointsToAliveValue()) {
-      assert(vtenvFuns.find(name) != vtenvFuns.end());
-      it->second = vtenvFuns[name](m);
+
+    if (auto *const f = it->second.get<FnDeclFnTy>()) {
+      return (*f)(m);
     }
-    return it->second;
+
+    auto *p = it->second.get<llvm::WeakTrackingVH>();
+    if (!p->pointsToAliveValue()) {
+      throw std::runtime_error((name + " has been invalidated").str());
+    }
+    return *p;
   }
   return nullptr;
 }
 
 class Globals {
 private:
-  using FunFnTy = std::function<llvm::Function*(llvm::Module&)>;
-  using VarFnTy = std::function<llvm::GlobalVariable*(llvm::Module&)>;
-  struct Global {
-    variant<FunFnTy, VarFnTy> protoTypes;
-    llvm::WeakTrackingVH handle;
-  };
-  llvm::StringMap<Global> globals;
+  using FnDeclFnTy = std::function<llvm::Function *(llvm::Module &)>;
+  using VarDeclFnTy = std::function<llvm::GlobalVariable *(llvm::Module &)>;
+  llvm::StringMap<variant<FnDeclFnTy, VarDeclFnTy>> globals;
+
   LLVM_NODISCARD bool isFunc(decltype(globals)::iterator it) const {
-    return it->second.protoTypes.get<FunFnTy>() != nullptr;
+    return it->second.get<FnDeclFnTy>() != nullptr;
   }
 
 public:
   Globals() = default;
-  Globals(const Globals&) = delete;
-  Globals(Globals&&) = delete;
-  Globals& operator=(const Globals&) = delete;
-  Globals& operator=(Globals&&) = delete;
+  Globals(const Globals &) = delete;
+  Globals(Globals &&) = delete;
+  Globals &operator=(const Globals &) = delete;
+  Globals &operator=(Globals &&) = delete;
   ~Globals() = default;
 
   LLVM_NODISCARD bool contains(llvm::StringRef name) const {
     return globals.find(name) != globals.end();
   }
 
-  /// Gets a global variable \p name by possibly recreating decl in current module
-  LLVM_NODISCARD llvm::GlobalVariable* getOrCreateVarDecl(llvm::StringRef name, llvm::Module& m);
-  /// Gets a global function \p name by possibly recreating decl in current module
-  LLVM_NODISCARD llvm::Function* getOrCreateFuncDecl(llvm::StringRef name, llvm::Module& m);
+  /// Gets a global variable \p name by possibly recreating decl in current
+  /// module
+  LLVM_NODISCARD llvm::GlobalVariable *getOrCreateVarDecl(llvm::StringRef name,
+                                                          llvm::Module &m);
+  /// Gets a global function \p name by possibly recreating decl in current
+  /// module
+  LLVM_NODISCARD llvm::Function *getOrCreateFuncDecl(llvm::StringRef name,
+                                                     llvm::Module &m);
 
   /// Creates a global variable decl for \p name with type \p ty
   ///
   /// It stores variable prototype for decl recreating
-  void add(const std::string& name, llvm::Module& m, llvm::Type* ty);
-  /// Creates a global function decl for \p name with type \p ty if \p existingF is null
+  void add(const std::string &name, llvm::Type *ty);
+  /// Creates a global function decl for \p name with type \p ty if \p existingF
+  /// is null
   ///
   /// It stores function prototype for decl recreating
-  void add(const std::string& name, llvm::Module& m, llvm::FunctionType* ty,
-           llvm::Function* existingF);
+  void add(const std::string &name, llvm::FunctionType *ty);
 };
 
-llvm::GlobalVariable* Globals::getOrCreateVarDecl(llvm::StringRef name, llvm::Module& m) {
-  auto it = globals.find(name);
+llvm::GlobalVariable *Globals::getOrCreateVarDecl(llvm::StringRef name,
+                                                  llvm::Module &m) {
+  const auto it = globals.find(name);
   if (it == globals.end() || isFunc(it)) {
     return nullptr;
   }
-  if (!it->second.handle.pointsToAliveValue()) {
-    it->second.handle = (*it->second.protoTypes.get<VarFnTy>())(m);
-  }
-  return llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Value*>(it->second.handle));
+
+  auto *p = (*it->second.get<VarDeclFnTy>())(m);
+  return llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Value *>(p));
 }
 
-llvm::Function* Globals::getOrCreateFuncDecl(llvm::StringRef name, llvm::Module& m) {
-  auto it = globals.find(name);
+llvm::Function *Globals::getOrCreateFuncDecl(llvm::StringRef name,
+                                             llvm::Module &m) {
+  const auto it = globals.find(name);
   if (it == globals.end() || !isFunc(it)) {
     return nullptr;
   }
-  if (!it->second.handle.pointsToAliveValue()) {
-    it->second.handle = (*it->second.protoTypes.get<FunFnTy>())(m);
-  }
-  return llvm::cast<llvm::Function>(static_cast<llvm::Value*>(it->second.handle));
+
+  auto *p = (*it->second.get<FnDeclFnTy>())(m);
+  return llvm::cast<llvm::Function>(static_cast<llvm::Value *>(p));
 }
 
-void Globals::add(const std::string& name, llvm::Module& m, llvm::Type* ty) {
-  Global g;
-  g.protoTypes = VarFnTy([ty, name](llvm::Module& m) {
-    return prepgv(new llvm::GlobalVariable(m, ty, /*isConstant=*/false,
-                                           llvm::GlobalValue::ExternalLinkage,
-                                           /*initializer=*/nullptr, name),
-                  sizeof(void*));
+void Globals::add(const std::string &name, llvm::Type *ty) {
+  globals[name] = VarDeclFnTy([ty, name](llvm::Module &m) {
+    return createGVDecl(
+        prepgv(new llvm::GlobalVariable(m, ty, /*isConstant=*/false,
+                                        llvm::GlobalValue::ExternalLinkage,
+                                        /*initializer=*/nullptr, name),
+               sizeof(void *)),
+        m, name);
   });
-  g.handle = (*g.protoTypes.get<VarFnTy>())(m);
-  globals[name] = g;
 }
 
-void Globals::add(const std::string& name, llvm::Module& m, llvm::FunctionType* ty,
-                  llvm::Function* existingF) {
-  Global g;
-  g.protoTypes = FunFnTy([ty, name](llvm::Module& m) {
-    return llvm::Function::Create(ty, llvm::Function::ExternalLinkage, name, m);
+void Globals::add(const std::string &name, llvm::FunctionType *ty) {
+  globals[name] = FnDeclFnTy([ty, name](llvm::Module &m) {
+    return createFnDecl(
+        llvm::Function::Create(ty, llvm::Function::ExternalLinkage, name, m), m,
+        name);
   });
-  if (existingF != nullptr) {
-    g.handle = existingF;
-  } else {
-    g.handle = (*g.protoTypes.get<FunFnTy>())(m);
-  }
-  globals[name] = g;
 }
 #endif
 
@@ -288,7 +341,7 @@ bool isFileType(const MonoTypePtr&);
 #if (LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR >= 8) && LLVM_VERSION_MAJOR < 11
 class jitmm : public llvm::SectionMemoryManager {
 public:
-  explicit jitmm(jitcc* jit) : jit(jit) { }
+  explicit jitmm(jitcc * jit) : jit(jit) {}
 
   // link symbols across modules :T
   uint64_t getSymbolAddress(const std::string& n) override {
@@ -305,6 +358,7 @@ public:
       throw std::runtime_error("Internal error, can't resolve symbol: " + n);
     }
   }
+
 private:
   jitcc* jit;
 };
@@ -319,7 +373,7 @@ jitcc::jitcc(const TEnvPtr& tenv)
   llvm::InitializeNativeTargetAsmParser();
   llvm::InitializeNativeTargetAsmPrinter();
 
-  this->orcjit = llvm::cantFail(ORCJIT::create(), "orcjit init failed");
+  this->orcjit = std::make_unique<ORCJIT>();
 
   // allocate an IR builder with an initial dummy basic-block to write into
   this->irbuilder = withContext([](llvm::LLVMContext& c) {
@@ -421,8 +475,7 @@ llvm::IRBuilder<>* jitcc::builder() const {
 llvm::Module* jitcc::module() {
   if (this->currentModule == nullptr) {
     this->currentModule = withContext([](llvm::LLVMContext& c) {
-      auto m = std::make_unique<llvm::Module>(createUniqueName("jitModule"), c);
-      return m;
+      return std::make_unique<llvm::Module>(createUniqueName("jitModule"), c);
     });
   }
   return this->currentModule.get();
@@ -611,7 +664,7 @@ class LenWatch : public llvm::JITEventListener {
 public:
   std::string fname;
   size_t sz;
-  explicit LenWatch(const std::string& fname) : fname(fname), sz(0) { }
+  explicit LenWatch(const std::string &fname) : fname(fname), sz(0) {}
   size_t size() const { return this->sz; }
   void NotifyObjectEmitted(const llvm::object::ObjectFile& o, const llvm::RuntimeDyld::LoadedObjectInfo&) {
     for (auto s : o.symbols()) {
@@ -734,27 +787,27 @@ op* jitcc::lookupOp(const std::string& vn) const {
 }
 
 #if LLVM_VERSION_MAJOR >= 11
-void jitcc::bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x) {
-  assert(not this->globals->contains(vn));
-
-  void* value = x;
+void jitcc::bindGlobal(const std::string &vn, const MonoTypePtr &ty, void *x) {
+  void *value = x;
   if (is<Func>(ty) != nullptr) {
-    withContext([&](auto&) {
-      this->globals->add(vn, *this->module(),
-                         llvm::cast<llvm::FunctionType>(toLLVM(ty, /*asArg=*/false)),
-                         /*existingF=*/nullptr);
+    withContext([&](auto &) {
+      this->globals->add(
+          vn, llvm::cast<llvm::FunctionType>(toLLVM(ty, /*asArg=*/false)));
     });
+    llvm::cantFail(orcjit->addExternalCallableSymbol(vn, value));
   } else {
     if (hasPointerRep(ty) || isFileType(ty)) {
-      void** p = reinterpret_cast<void**>(this->globalData.malloc(sizeof(void*)));
+      void **p =
+          reinterpret_cast<void **>(this->globalData.malloc(sizeof(void *)));
       *p = x;
       value = p;
     }
 
-    withContext(
-        [&](auto&) { return this->globals->add(vn, *this->module(), toLLVM(ty, /*asArg=*/true)); });
+    withContext([&](auto &) {
+      return this->globals->add(vn, toLLVM(ty, /*asArg=*/true));
+    });
+    llvm::cantFail(orcjit->addExternalNonCallableSymbol(vn, value));
   }
-  llvm::cantFail(orcjit->addExternalSymbol(vn, value));
 }
 #else
 void jitcc::bindGlobal(const std::string& vn, const MonoTypePtr& ty, void* x) {
@@ -811,7 +864,8 @@ llvm::Value* jitcc::maybeRefGlobalV(llvm::Value* v) {
   } else if (auto gv = llvm::dyn_cast<llvm::GlobalVariable>(v)) {
     if (gv->getParent() == thisMod) {
       return v;
-    } else if (llvm::GlobalVariable* rgv = thisMod->getGlobalVariable(gv->getName())) {
+    } else if (llvm::GlobalVariable *rgv =
+                   thisMod->getGlobalVariable(gv->getName())) {
       return rgv;
     } else {
       return new llvm::GlobalVariable(*thisMod, gv->getType()->getElementType(), gv->isConstant(), llvm::GlobalVariable::ExternalLinkage, 0, gv->getName());
@@ -844,7 +898,7 @@ llvm::GlobalVariable* jitcc::refGlobal(const std::string& vn, llvm::GlobalVariab
     return 0;
   } else if (gv->getParent() == mod) {
     return gv;
-  } else if (llvm::GlobalVariable* rgv = mod->getGlobalVariable(vn)) {
+  } else if (llvm::GlobalVariable *rgv = mod->getGlobalVariable(vn)) {
     return rgv;
   } else {
     return prepgv(new llvm::GlobalVariable(
@@ -920,11 +974,17 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
     f();
     releaseMachineCode(reinterpret_cast<void*>(f));
     resetMemoryPool();
-  } else if (llvm::Constant* c = toLLVMConstant(this, vname, ue)) {
+  } else if (llvm::Constant *c = toLLVMConstant(this, vname, ue)) {
     // make a global constant ...
 #if LLVM_VERSION_MAJOR >= 11
-    withContext(
-        [&](auto&) { return this->constants->createDefinition(vname, *module(), c, uety); });
+    if (is<Func>(uety) != nullptr) {
+      withContext(
+          [&](auto &) { return this->constants->storeFnAddr(vname, c); });
+    } else {
+      withContext([&](auto &) {
+        return this->constants->createGVDef(vname, *module(), c, uety);
+      });
+    }
 #else
     Constant& cv = this->constants[vname];
     cv.value = c;
@@ -1289,12 +1349,12 @@ llvm::Function* jitcc::allocFunction(const std::string& fname, const MonoTypes&
   llvm::Function* ret = withContext([&](auto&) { return f(*this->module()); });
 
   if (fname.find(".rfn.t") != std::string::npos) {
-    this->vtenv->add(fname, f, ret);
+    this->vtenv->add(fname, f);
   } else if (!this->globals->contains(fname)) {
-    withContext([&](auto&) {
+    withContext([&](auto &) {
       return this->globals->add(
-          fname, *this->module(),
-          llvm::FunctionType::get(toLLVM(rty, true), toLLVM(argl, true), false), ret);
+          fname, llvm::FunctionType::get(toLLVM(rty, true), toLLVM(argl, true),
+                                         false));
     });
   }
   return ret;
@@ -1362,4 +1422,4 @@ ExprPtr jitcc::inlineGlobals(const ExprPtr& e) {
 
 op::~op() { }
 
-}
+} // namespace hobbes
diff --git a/lib/hobbes/eval/orcjitcc.C b/lib/hobbes/eval/orcjitcc.C
index b21082863..332f0f0e0 100644
--- a/lib/hobbes/eval/orcjitcc.C
+++ b/lib/hobbes/eval/orcjitcc.C
@@ -6,74 +6,20 @@
 #include <hobbes/hobbes.H>
 #include <hobbes/util/llvm.H>
 
+#include <llvm/ExecutionEngine/JITSymbol.h>
 #include <llvm/ExecutionEngine/Orc/CompileUtils.h>
-
-namespace hobbes {
-
-ORCJIT::ORCJIT(std::unique_ptr<llvm::TargetMachine> tm,
-               const llvm::DataLayout &dl)
-    : targetMachine(std::move(tm)), dataLayout(dl),
-      mangle(execSession, dataLayout),
-      objectLayer(
-          execSession,
-          []() { return std::make_unique<llvm::SectionMemoryManager>(); }),
-      compileLayer(execSession, objectLayer,
-                   std::make_unique<llvm::orc::SimpleCompiler>(*targetMachine)),
-      optLayer(execSession, compileLayer, optimizeModule),
-      mainJD(execSession.createBareJITDylib(createUniqueName("main"))) {
-  mainJD.addGenerator(
-      cantFail(llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
-          dataLayout.getGlobalPrefix())));
-}
-
-#if LLVM_VERSION_MAJOR >= 12
-ORCJIT::~ORCJIT() {
-  // https://repo.hca.bsc.es/gitlab/rferrer/llvm-epi/-/commit/0aec49c8531bc5282b095730d34681455826bc2c
-  // newly added in llvm12, has to be called to destroy objectLayer associated memory manager
-  llvm::cantFail(execSession.endSession());
-}
-#else
-ORCJIT::~ORCJIT() = default;
-#endif
-
-llvm::Expected<std::unique_ptr<ORCJIT>> ORCJIT::create() {
-  auto jtmb = llvm::orc::JITTargetMachineBuilder::detectHost();
-  if (!jtmb) {
-    return jtmb.takeError();
-  }
-
-  auto tm = jtmb->createTargetMachine();
-  if (!tm) {
-    return tm.takeError();
-  }
-
-  auto dl = jtmb->getDefaultDataLayoutForTarget();
-  if (!dl) {
-    return dl.takeError();
-  }
-
-  return std::make_unique<ORCJIT>(std::move(*tm), *dl);
-}
-
-llvm::Error ORCJIT::addModule(std::unique_ptr<llvm::Module> m) {
-  return withContext([&](auto&) {
-    m->setDataLayout(dataLayout);
-    return optLayer.add(mainJD, llvm::orc::ThreadSafeModule(std::move(m), threadSafeContext()));
-  });
-}
-
-llvm::Expected<llvm::JITEvaluatedSymbol> ORCJIT::lookup(llvm::StringRef name) {
-  return execSession.lookup({&mainJD}, mangle(name.str()));
-}
-
-llvm::Error ORCJIT::addExternalSymbol(llvm::StringRef name, void *ptr) {
-  return mainJD.define(llvm::orc::absoluteSymbols(
-      {{mangle(name), llvm::JITEvaluatedSymbol::fromPointer(ptr)}}));
-}
-
+#include <llvm/ExecutionEngine/Orc/Core.h>
+#include <llvm/ExecutionEngine/Orc/LLJIT.h>
+#include <llvm/Support/AllocatorBase.h>
+#include <llvm/Support/Compiler.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/Host.h>
+#include <llvm/Support/Process.h>
+
+namespace {
 llvm::Expected<llvm::orc::ThreadSafeModule>
-ORCJIT::optimizeModule(llvm::orc::ThreadSafeModule tsm,
-                       const llvm::orc::MaterializationResponsibility &) {
+optimizeModule(llvm::orc::ThreadSafeModule tsm,
+               const llvm::orc::MaterializationResponsibility &) {
   tsm.withModuleDo([](llvm::Module &m) {
     auto fpm = llvm::legacy::FunctionPassManager(&m);
     fpm.add(llvm::createReassociatePass());
@@ -92,5 +38,68 @@ ORCJIT::optimizeModule(llvm::orc::ThreadSafeModule tsm,
 
   return tsm;
 }
+} // namespace
+
+namespace hobbes {
+
+ORCJIT::ORCJIT() {
+  // this is for testing
+  // by default, no threading is enabled
+  const auto tn = [] {
+    const auto clamp = [](int v, int lo, int hi) -> int {
+      return v < lo ? lo : (hi < v ? hi : v);
+    };
+    if (const auto n = llvm::sys::Process::GetEnv("HOBBES_COMPILE_THREADS")) {
+      const int i = std::atoi(n->c_str());
+      return static_cast<unsigned int>(
+          clamp(i, 0, static_cast<int>(std::thread::hardware_concurrency())));
+    }
+    return 0U;
+  }();
+
+  llvm::orc::LLLazyJITBuilder jitBuilder;
+  jit = llvm::cantFail(
+      jitBuilder
+          .setJITTargetMachineBuilder(
+              llvm::cantFail(llvm::orc::JITTargetMachineBuilder::detectHost()))
+          .setNumCompileThreads(tn)
+          .setLazyCompileFailureAddr(llvm::pointerToJITTargetAddress(+[] {
+            throw std::runtime_error("exiting on lazy call through failure");
+          }))
+          .create());
+  jit->getIRTransformLayer().setTransform(optimizeModule);
+  jit->getMainJITDylib().addGenerator(
+      cantFail(llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
+          jit->getDataLayout().getGlobalPrefix())));
+
+  mangle = std::make_unique<llvm::orc::MangleAndInterner>(
+      jit->getExecutionSession(), jit->getDataLayout());
+}
+
+ORCJIT::~ORCJIT() = default;
+
+llvm::Error ORCJIT::addModule(std::unique_ptr<llvm::Module> m) {
+  return withContext([&, this](auto &) {
+    return jit->addLazyIRModule(
+        llvm::orc::ThreadSafeModule(std::move(m), threadSafeContext()));
+  });
+}
+
+llvm::Expected<llvm::JITEvaluatedSymbol> ORCJIT::lookup(llvm::StringRef name) {
+  return jit->lookup(name);
+}
+
+llvm::Error ORCJIT::addExternalCallableSymbol(llvm::StringRef name, void *ptr) {
+  return jit->getMainJITDylib().define(llvm::orc::absoluteSymbols(
+      {{(*mangle)(name), llvm::JITEvaluatedSymbol::fromPointer(
+                             ptr, llvm::JITSymbolFlags::Exported |
+                                      llvm::JITSymbolFlags::Callable)}}));
+}
+
+llvm::Error ORCJIT::addExternalNonCallableSymbol(llvm::StringRef name,
+                                                 void *ptr) {
+  return jit->getMainJITDylib().define(llvm::orc::absoluteSymbols(
+      {{(*mangle)(name), llvm::JITEvaluatedSymbol::fromPointer(ptr)}}));
+}
 } // namespace hobbes
 #endif

From 0b8a1ca81310b8a33634690888917743783f472a Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 11 Aug 2021 02:23:50 +0000
Subject: [PATCH 12/40] bump up pattern matching parameters to 20 (#418)

* bump up pattern matching parameters to 20

* use newer bison and fix some indentation warning
---
 include/hobbes/read/pgen/hexpr.parse.H |    6 +-
 lib/hobbes/read/pgen/hexpr.lex.C       |   90 +-
 lib/hobbes/read/pgen/hexpr.parse.C     | 3821 ++++++++++++------------
 lib/hobbes/read/pgen/hexpr.y           |    9 +
 4 files changed, 2013 insertions(+), 1913 deletions(-)

diff --git a/include/hobbes/read/pgen/hexpr.parse.H b/include/hobbes/read/pgen/hexpr.parse.H
index f5e8e6e79..facf0b124 100644
--- a/include/hobbes/read/pgen/hexpr.parse.H
+++ b/include/hobbes/read/pgen/hexpr.parse.H
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.7.4.  */
+/* A Bison parser, made by GNU Bison 3.7.6.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
    Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -16,7 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
diff --git a/lib/hobbes/read/pgen/hexpr.lex.C b/lib/hobbes/read/pgen/hexpr.lex.C
index d681ef9f4..019a10e9c 100644
--- a/lib/hobbes/read/pgen/hexpr.lex.C
+++ b/lib/hobbes/read/pgen/hexpr.lex.C
@@ -1,6 +1,6 @@
-#line 1 "hexpr.lex.C"
+#line 2 "hexpr.lex.C"
 
-#line 3 "hexpr.lex.C"
+#line 4 "hexpr.lex.C"
 
 #define  YY_INT_ALIGNED short int
 
@@ -789,9 +789,9 @@ std::string* identifier(const char* b, const char* e) {
     return hobbes::autorelease(new std::string(b, e));
   }
 }
-#line 792 "hexpr.lex.C"
+#line 793 "hexpr.lex.C"
 
-#line 794 "hexpr.lex.C"
+#line 795 "hexpr.lex.C"
 
 #define INITIAL 0
 #define BLOCK_COMMENT 1
@@ -978,43 +978,43 @@ extern int yylex (void);
  */
 YY_DECL
 {
-    yy_state_type yy_current_state;
-    char *yy_cp, *yy_bp;
-    int yy_act;
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
     
-    if ( !(yy_init) )
-    {
-        (yy_init) = 1;
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
 
 #ifdef YY_USER_INIT
-        YY_USER_INIT;
+		YY_USER_INIT;
 #endif
 
-        /* Create the reject buffer large enough to save one state per allowed character. */
-        if ( ! (yy_state_buf) )
-            (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
-        if ( ! (yy_state_buf) )
-            YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+    /* Create the reject buffer large enough to save one state per allowed character. */
+    if ( ! (yy_state_buf) )
+      (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
+    if ( ! (yy_state_buf) )
+      YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
 
-        if ( ! (yy_start) )
-            (yy_start) = 1;     /* first start state */
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
 
-        if ( ! yyin )
-            yyin = stdin;
+		if ( ! yyin )
+			yyin = stdin;
 
-        if ( ! yyout )
-            yyout = stdout;
+		if ( ! yyout )
+			yyout = stdout;
 
-        if ( ! YY_CURRENT_BUFFER ) {
-            yyensure_buffer_stack ();
-            YY_CURRENT_BUFFER_LVALUE =
-                yy_create_buffer( yyin, YY_BUF_SIZE );
-        }
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+		}
 
-        yy_load_buffer_state(  );
-    }
+		yy_load_buffer_state(  );
+		}
 
-    {
+	{
 #line 71 "hexpr.l"
 
 
@@ -1028,7 +1028,7 @@ YY_DECL
   }
 
 
-#line 1031 "hexpr.lex.C"
+#line 1032 "hexpr.lex.C"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1730,7 +1730,7 @@ YY_RULE_SETUP
 #line 214 "hexpr.l"
 ECHO;
 	YY_BREAK
-#line 1733 "hexpr.lex.C"
+#line 1734 "hexpr.lex.C"
 			case YY_STATE_EOF(INITIAL):
 			case YY_STATE_EOF(BLOCK_COMMENT):
 				yyterminate();
@@ -2013,21 +2013,21 @@ static int yy_get_next_buffer (void)
  */
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
 {
-    int yy_is_jam;
+	int yy_is_jam;
     
-    YY_CHAR yy_c = 1;
-    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-    {
-        yy_current_state = (int) yy_def[yy_current_state];
-        if ( yy_current_state >= 281 )
-            yy_c = yy_meta[yy_c];
-    }
-    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-    yy_is_jam = (yy_current_state == 280);
-    if ( ! yy_is_jam )
-        *(yy_state_ptr)++ = yy_current_state;
+	YY_CHAR yy_c = 1;
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 281 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 280);
+	if ( ! yy_is_jam )
+		*(yy_state_ptr)++ = yy_current_state;
 
-    return yy_is_jam ? 0 : yy_current_state;
+	return yy_is_jam ? 0 : yy_current_state;
 }
 
 #ifndef YY_NO_UNPUT
diff --git a/lib/hobbes/read/pgen/hexpr.parse.C b/lib/hobbes/read/pgen/hexpr.parse.C
index 3711da4f6..d1c6f5a18 100644
--- a/lib/hobbes/read/pgen/hexpr.parse.C
+++ b/lib/hobbes/read/pgen/hexpr.parse.C
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.7.4.  */
+/* A Bison parser, made by GNU Bison 3.7.6.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
    Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -16,7 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -46,10 +46,10 @@
    USER NAME SPACE" below.  */
 
 /* Identify Bison output, and Bison version.  */
-#define YYBISON 30704
+#define YYBISON 30706
 
 /* Bison version string.  */
-#define YYBISON_VERSION "3.7.4"
+#define YYBISON_VERSION "3.7.6"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -574,6 +574,18 @@ typedef int_least16_t yytype_int16;
 typedef short yytype_int16;
 #endif
 
+/* Work around bug in HP-UX 11.23, which defines these macros
+   incorrectly for preprocessor constants.  This workaround can likely
+   be removed in 2023, as HPE has promised support for HP-UX 11.23
+   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
+   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
+#ifdef __hpux
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
+#endif
+
 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
@@ -671,9 +683,9 @@ typedef int yy_state_fast_t;
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
+# define YY_USE(E) ((void) (E))
 #else
-# define YYUSE(E) /* empty */
+# define YY_USE(E) /* empty */
 #endif
 
 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
@@ -843,16 +855,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  74
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   2999
+#define YYLAST   3078
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  98
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  82
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  357
+#define YYNRULES  366
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  782
+#define YYNSTATES  809
 
 /* YYMAXUTOK -- Last valid token kind.  */
 #define YYMAXUTOK   352
@@ -914,39 +926,40 @@ static const yytype_int16 yyrline[] =
        0,   488,   488,   489,   490,   491,   494,   495,   496,   498,
      499,   500,   502,   503,   504,   505,   506,   507,   509,   510,
      511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     523,   526,   529,   530,   531,   534,   535,   538,   540,   543,
-     544,   545,   546,   547,   548,   549,   550,   552,   553,   555,
-     557,   558,   560,   563,   564,   565,   566,   568,   569,   571,
-     574,   576,   578,   579,   581,   583,   585,   586,   587,   588,
-     589,   590,   591,   592,   593,   594,   595,   596,   597,   598,
-     599,   600,   601,   602,   603,   605,   606,   608,   609,   612,
-     613,   614,   615,   617,   618,   619,   620,   621,   622,   624,
-     625,   627,   628,   629,   630,   631,   632,   633,   634,   635,
-     637,   638,   639,   640,   641,   643,   644,   645,   646,   648,
-     651,   652,   655,   658,   661,   673,   674,   677,   679,   680,
-     682,   684,   685,   687,   688,   690,   691,   693,   694,   696,
-     697,   700,   701,   704,   705,   706,   707,   708,   709,   710,
-     711,   712,   715,   716,   717,   718,   719,   722,   723,   724,
-     727,   730,   733,   734,   737,   738,   739,   740,   741,   742,
-     743,   744,   745,   746,   747,   748,   749,   750,   753,   756,
-     757,   758,   759,   760,   761,   762,   763,   764,   765,   766,
-     767,   768,   769,   770,   771,   772,   773,   776,   778,   779,
-     781,   783,   784,   786,   788,   789,   791,   792,   794,   795,
-     796,   798,   799,   801,   802,   804,   805,   807,   808,   811,
-     812,   814,   815,   816,   817,   818,   819,   820,   821,   822,
+     521,   522,   523,   524,   525,   526,   527,   528,   529,   532,
+     535,   538,   539,   540,   543,   544,   547,   549,   552,   553,
+     554,   555,   556,   557,   558,   559,   561,   562,   564,   566,
+     567,   569,   572,   573,   574,   575,   577,   578,   580,   583,
+     585,   587,   588,   590,   592,   594,   595,   596,   597,   598,
+     599,   600,   601,   602,   603,   604,   605,   606,   607,   608,
+     609,   610,   611,   612,   614,   615,   617,   618,   621,   622,
+     623,   624,   626,   627,   628,   629,   630,   631,   633,   634,
+     636,   637,   638,   639,   640,   641,   642,   643,   644,   646,
+     647,   648,   649,   650,   652,   653,   654,   655,   657,   660,
+     661,   664,   667,   670,   682,   683,   686,   688,   689,   691,
+     693,   694,   696,   697,   699,   700,   702,   703,   705,   706,
+     709,   710,   713,   714,   715,   716,   717,   718,   719,   720,
+     721,   724,   725,   726,   727,   728,   731,   732,   733,   736,
+     739,   742,   743,   746,   747,   748,   749,   750,   751,   752,
+     753,   754,   755,   756,   757,   758,   759,   762,   765,   766,
+     767,   768,   769,   770,   771,   772,   773,   774,   775,   776,
+     777,   778,   779,   780,   781,   782,   785,   787,   788,   790,
+     792,   793,   795,   797,   798,   800,   801,   803,   804,   805,
+     807,   808,   810,   811,   813,   814,   816,   817,   820,   821,
      823,   824,   825,   826,   827,   828,   829,   830,   831,   832,
-     833,   834,   835,   836,   837,   839,   840,   841,   842,   843,
-     845,   847,   848,   850,   851,   853,   854,   856,   858,   859,
-     860,   862,   863,   864,   865,   866,   867,   868,   869,   870,
-     871,   872,   873,   874,   875,   876,   882,   883,   884,   885,
-     887,   888,   890,   891,   892,   894,   895,   896,   898,   899,
-     902,   904,   905,   907,   908,   909,   910,   911,   912,   913,
-     914,   915,   916,   918,   919,   920,   921,   923,   924,   925,
-     926,   928,   929,   930,   932,   933,   935,   936,   938,   939,
-     940,   942,   943,   944,   945,   946,   947,   948,   949,   950,
-     951,   952,   953,   954,   955,   956,   957,   958,   959,   961,
-     962,   964,   965,   967,   968,   970,   971,   973,   974,   976,
-     977,   979,   980,   982,   983,   984,   985,   987
+     833,   834,   835,   836,   837,   838,   839,   840,   841,   842,
+     843,   844,   845,   846,   848,   849,   850,   851,   852,   854,
+     856,   857,   859,   860,   862,   863,   865,   867,   868,   869,
+     871,   872,   873,   874,   875,   876,   877,   878,   879,   880,
+     881,   882,   883,   884,   885,   891,   892,   893,   894,   896,
+     897,   899,   900,   901,   903,   904,   905,   907,   908,   911,
+     913,   914,   916,   917,   918,   919,   920,   921,   922,   923,
+     924,   925,   927,   928,   929,   930,   932,   933,   934,   935,
+     937,   938,   939,   941,   942,   944,   945,   947,   948,   949,
+     951,   952,   953,   954,   955,   956,   957,   958,   959,   960,
+     961,   962,   963,   964,   965,   966,   967,   968,   970,   971,
+     973,   974,   976,   977,   979,   980,   982,   983,   985,   986,
+     988,   989,   991,   992,   993,   994,   996
 };
 #endif
 
@@ -1020,12 +1033,12 @@ static const yytype_int16 yytoknum[] =
 };
 #endif
 
-#define YYPACT_NINF (-597)
+#define YYPACT_NINF (-590)
 
 #define yypact_value_is_default(Yyn) \
   ((Yyn) == YYPACT_NINF)
 
-#define YYTABLE_NINF (-357)
+#define YYTABLE_NINF (-366)
 
 #define yytable_value_is_error(Yyn) \
   0
@@ -1034,85 +1047,87 @@ static const yytype_int16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-     356,  1283,  2038,  2038,    33,   127,   127,   127,    42,    42,
-     105,   105,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,   501,
-      67,  2038,  2818,    11,  2818,   127,   141,  1487,  2038,   501,
-     197,  2038,   -42,  -597,  1406,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,   195,  -597,   175,   177,     7,   188,  2584,  2428,
-    2038,  1570,  2919,  2919,  -597,   111,   200,   317,   422,   432,
-    -597,   217,  -597,  -597,  -597,  1283,   301,   355,  -597,   928,
-     155,  -597,  -597,   156,  1311,   307,    42,   351,  1842,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  2919,   127,    64,  -597,   383,
-    -597,   372,   194,  2740,   127,   194,   410,  2116,   378,   380,
-    2506,   384,   385,   391,   501,   392,   398,   403,   412,   413,
-     415,   416,   418,  2272,   419,   420,   421,  -597,  -597,   423,
-    -597,   -26,   295,   248,   329,   461,   464,    30,   414,   127,
-     127,   411,  -597,  1920,  1920,  2919,  2038,  1804,     7,  -597,
-    -597,   501,  2038,    25,  -597,  -597,   448,   378,   380,  2506,
-     384,   385,   391,   392,   398,   403,   413,   415,   416,   418,
-     419,   420,   421,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  2919,  2919,   127,   225,
-     177,   845,  -597,  -597,  -597,  2887,  2350,  2350,  2350,  2350,
-    2428,  2584,  2584,  2584,  2584,  2584,  2584,  2584,  2584,  2584,
-    2584,  2584,  2662,  2662,  2662,  2038,  -597,  1406,   127,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  1920,  -597,  1920,  -597,
-    -597,  -597,   127,   127,   227,   260,  1998,  1998,   127,  2038,
-     191,  -597,   119,  1998,   127,    26,    42,   928,   127,   227,
-     127,   127,    22,  -597,    13,   483,   474,   477,  -597,  -597,
-     304,   438,   350,  -597,   482,  2038,    54,  2428,   444,   445,
-     194,    20,  -597,   491,  2818,  1648,   501,   447,  1726,  -597,
-     492,   494,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  2038,  2919,  1882,  -597,  -597,   992,  2038,  2038,
-    2038,  -597,  -597,  -597,  -597,  -597,   676,  -597,   503,  -597,
-    -597,  -597,   309,   456,  2038,   139,  -597,  -597,  2038,   186,
-    2038,   311,   321,   353,   499,   152,  2038,  -597,  2038,   173,
-     453,   453,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  1406,
-    -597,  -597,  -597,   493,    89,   465,  -597,   362,  -597,    29,
-    1842,  -597,  1148,   227,    68,   364,   508,   110,   210,   128,
-     497,   452,  -597,  1311,   298,  1998,  1998,   501,  1998,  1998,
-    1998,  1194,  1998,   457,    42,   532,   127,   127,  1842,   466,
-     515,   516,   539,  -597,  1998,  1998,  1998,  1998,  -597,   479,
-    2919,  -597,    34,  2919,  -597,  2038,  -597,  -597,   267,  2919,
-     445,  -597,  -597,  -597,  -597,   187,  -597,  -597,  -597,  -597,
-    -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  -597,  1648,
-    2194,   501,   337,   177,  -597,   482,  -597,  2038,  -597,  -597,
-    2038,  -597,  -597,   326,   520,  -597,   480,  -597,   522,  -597,
-     478,   481,   227,    36,  1842,  -597,  -597,   486,  1960,  -597,
-    -597,  2038,   206,   496,  -597,   490,  -597,   498,  -597,    46,
-    2919,  2919,  -597,  -597,  -597,  1998,  -597,  -597,  -597,  -597,
-    1998,   488,  -597,  1998,  -597,   127,  1842,  1998,  1842,  -597,
-     127,  1842,  1998,  -597,  -597,  1998,  1998,  1998,     2,    39,
-     373,   457,   457,   457,  -597,   457,   457,    27,    42,   532,
-    -597,    23,  -597,   240,  -597,  -597,   123,  1842,  1842,  1842,
-      42,   539,  -597,   457,   457,   457,   457,  -597,  -597,  -597,
-    -597,  -597,  -597,   535,   336,  -597,   366,  2852,  -597,   502,
-    -597,    40,  2818,   538,   166,   504,   506,  -597,  2919,  2038,
-    -597,  2038,  -597,  -597,  -597,  -597,  -597,   507,  -597,  2038,
-     216,  2038,  -597,  -597,  -597,   510,   511,   457,   189,   371,
-     244,   547,  -597,    79,   132,   512,   552,   514,    62,   457,
-      96,    97,   561,   103,   562,  1998,  1998,  1998,  1998,  1998,
-     532,   127,  -597,  -597,   532,   127,   127,  -597,   539,  -597,
-     318,  -597,  -597,   569,  -597,   127,   550,   267,   127,  2038,
-    2038,  2038,  -597,  -597,  -597,  2038,  -597,  -597,   575,   194,
-    2194,  2194,  -597,  -597,  -597,  -597,   529,  -597,  -597,  -597,
-    2038,   246,  -597,  -597,  -597,   573,  -597,   578,  -597,   581,
-    1842,  1998,   582,   584,  1842,   585,  1998,  1998,  1998,  1998,
-    1998,  1998,   457,   457,   457,   457,   457,   532,    24,   532,
-    -597,   127,   539,  -597,  1842,  2038,   583,  2038,  -597,   587,
-    -597,   593,  -597,  -597,   548,   272,  2350,  -597,  2038,   251,
-    1998,   551,  1998,  -597,   245,  1998,  1998,  -597,  1998,   263,
-     218,   256,   140,   265,   112,   532,  -597,  -597,  2038,  -597,
-    2038,  2038,  -597,  -597,  -597,   173,   549,  -597,  2038,   274,
-     457,  -597,   457,   591,   457,   457,   457,   595,  -597,  -597,
-    1998,  -597,  1998,   532,  -597,  -597,  -597,  2350,  -597,  2038,
-     283,  1998,  1998,   270,   275,   173,  -597,  2038,   292,   457,
-     457,  -597,  -597,  -597,  2038,   293,  -597,  2038,   596,  -597,
-    2038,  -597
+     385,  1512,  2283,  2283,   159,    28,    28,    28,    53,    53,
+     131,   131,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,    93,
+     121,  2283,  2985,   -32,  2985,    28,   185,  1732,  2283,    93,
+     137,  2283,   376,  -590,   959,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,   260,  -590,   263,   301,    21,   273,  2751,  2595,
+    2283,  1815,  1690,  1690,  -590,   176,   272,   399,   364,   412,
+    -590,   321,  -590,  -590,  -590,  1512,   365,   373,  -590,  2981,
+     179,  -590,  -590,   218,   868,   409,    53,   445,  1177,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  1690,    28,   -14,  -590,   353,
+    -590,   430,   259,  2907,    28,   259,   480,  2361,   444,   446,
+    2673,   448,   449,   450,    93,   451,   452,   454,   455,   456,
+     457,   461,   465,  1611,   466,   468,   469,  -590,  -590,   470,
+    -590,   203,   -29,   117,   343,   490,   500,    99,   458,    28,
+      28,   460,  -590,  1276,  1276,  1690,  2283,  2049,    21,  -590,
+    -590,    93,  2283,   230,  -590,  -590,   481,   444,   446,  2673,
+     448,   449,   450,   451,   452,   454,   456,   457,   461,   465,
+     466,   468,   469,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  1690,  1690,    28,   383,
+     301,  1096,  -590,  -590,  -590,  1535,  2517,  2517,  2517,  2517,
+    2595,  2751,  2751,  2751,  2751,  2751,  2751,  2751,  2751,  2751,
+    2751,  2751,  2829,  2829,  2829,  2283,  -590,   959,    28,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  1276,  -590,  1276,  -590,
+    -590,  -590,    28,    28,   459,   155,  1399,  1399,    28,  2283,
+     345,  -590,   138,  1399,    28,    29,    53,  2981,    28,   459,
+      28,    28,    34,  -590,    41,   516,   514,   517,  -590,  -590,
+     346,   483,   358,  -590,   523,  2283,    66,  2595,   485,   486,
+     259,    19,  -590,   530,  2985,  1893,    93,   487,  1971,  -590,
+     532,   533,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  2283,  1690,  2127,  -590,  -590,   403,  2283,  2283,
+    2283,  -590,  -590,  -590,  -590,  -590,   527,  -590,   540,  -590,
+    -590,  -590,   350,   499,  2283,   124,  -590,  -590,  2283,   234,
+    2283,   359,   233,   435,   537,   196,  2283,  -590,  2283,     1,
+     495,   495,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,   959,
+    -590,  -590,  -590,   535,   354,   507,  -590,   548,  -590,     0,
+    1177,  -590,   684,   459,    46,   436,   551,   120,   400,   116,
+     544,   494,  -590,   868,   184,  1399,  1399,    93,  1399,  1399,
+    1399,   800,  1399,   503,    53,   582,    28,    28,  1177,   519,
+     563,   570,   592,  -590,  1399,  1399,  1399,  1399,  -590,   534,
+    1690,  -590,    45,  1690,  -590,  2283,  -590,  -590,   434,  1690,
+     486,  -590,  -590,  -590,  -590,   205,  -590,  -590,  -590,  -590,
+    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  1893,
+    2439,    93,   453,   301,  -590,   523,  -590,  2283,  -590,  -590,
+    2283,  -590,  -590,    -1,   574,  -590,   536,  -590,   573,  -590,
+     538,   541,   459,   178,  1177,  -590,  -590,   539,  2205,  -590,
+    -590,  2283,   255,   547,  -590,   542,  -590,   543,  -590,    52,
+    1690,  1690,  -590,  -590,  -590,  1399,  -590,  -590,  -590,  -590,
+    1399,   545,  -590,  1399,  -590,    28,  1177,  1399,  1177,  -590,
+      28,  1177,  1399,  -590,  -590,  1399,  1399,  1399,   114,   112,
+     304,   503,   503,   503,  -590,   503,   503,    37,    53,   582,
+    -590,    26,  -590,   351,  -590,  -590,   195,  1177,  1177,  1177,
+      53,   592,  -590,   503,   503,   503,   503,  -590,  -590,  -590,
+    -590,  -590,  -590,   578,   410,  -590,   433,   828,  -590,   549,
+    -590,    47,  2985,   589,   211,   552,   550,  -590,  1690,  2283,
+    -590,  2283,  -590,  -590,  -590,  -590,  -590,   553,  -590,  2283,
+     270,  2283,  -590,  -590,  -590,   554,   556,   503,   225,   463,
+      54,   599,  -590,     7,   298,   561,   608,   564,    42,   503,
+     166,   201,   611,   126,   612,  1399,  1399,  1399,  1399,  1399,
+     582,    28,  -590,  -590,   582,    28,    28,  -590,   592,  -590,
+     391,  -590,  -590,   609,  -590,    28,   593,   434,    28,  2283,
+    2283,  2283,  -590,  -590,  -590,  2283,  -590,  -590,   616,   259,
+    2439,  2439,  -590,  -590,  -590,  -590,   571,  -590,  -590,  -590,
+    2283,   278,  -590,  -590,  -590,   615,  -590,   620,  -590,   617,
+    1177,  1399,   618,   621,  1177,   622,  1399,  1399,  1399,  1399,
+    1399,  1399,   503,   503,   503,   503,   503,   582,    30,   582,
+    -590,    28,   592,  -590,  1177,  2283,   619,  2283,  -590,   624,
+    -590,   626,  -590,  -590,   584,    55,  2517,  -590,  2283,   292,
+    1399,   587,  1399,  -590,   236,  1399,  1399,  -590,  1399,   305,
+     243,   282,   209,   307,   172,   582,  -590,  -590,  2283,  -590,
+    2283,  2283,  -590,  -590,  -590,     1,   585,  -590,  2283,   296,
+     503,  -590,   503,   627,   503,   503,   503,   629,  -590,  -590,
+    1399,  -590,  1399,   582,  -590,  -590,  -590,  2517,  -590,  2283,
+     300,  1399,  1399,   283,   329,     1,  -590,  2283,   311,   503,
+     503,  -590,  -590,  -590,  2283,   319,  -590,  2283,   320,  -590,
+    2283,   322,  -590,  2283,   325,  -590,  2283,   326,  -590,  2283,
+     327,  -590,  2283,   330,  -590,  2283,   341,  -590,  2283,   342,
+    -590,  2283,   344,  -590,  2283,   630,  -590,  2283,  -590
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1121,104 +1136,106 @@ static const yytype_int16 yypact[] =
 static const yytype_int16 yydefact[] =
 {
        0,     9,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   357,   174,   161,   211,   176,   177,   279,     0,
-       0,     0,     0,     0,     0,     0,     0,   285,   285,   258,
+       0,     0,   173,   174,   175,   176,   177,   178,   179,   180,
+     181,   182,   366,   183,   170,   220,   185,   186,   288,     0,
+       0,     0,     0,     0,     0,     0,     0,   294,   294,   267,
        0,     0,     0,     2,     8,    10,    12,    17,    13,    14,
-      15,    16,     0,    30,   119,   175,   160,   142,     0,     0,
-       0,   285,     0,     0,     4,    92,    98,   100,   109,   114,
-     118,   142,     5,   142,     1,     9,     0,    31,   341,     0,
-       0,    62,    64,     0,     0,     0,     0,     0,     0,   269,
-     264,   268,   263,   262,   265,   266,   274,   275,   267,   270,
-     271,   272,   273,   278,   261,   252,     0,     0,   129,     0,
-     245,     0,   214,     0,     0,   162,     0,     0,     0,     0,
-       0,     0,     0,     0,    69,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    68,    71,     0,
-     286,     0,   286,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    11,     0,     0,     0,   285,     0,   159,   212,
-     277,     0,     0,     0,   113,    93,     0,     0,     0,     0,
+      15,    16,     0,    39,   128,   184,   169,   151,     0,     0,
+       0,   294,     0,     0,     4,   101,   107,   109,   118,   123,
+     127,   151,     5,   151,     1,     9,     0,    40,   350,     0,
+       0,    71,    73,     0,     0,     0,     0,     0,     0,   278,
+     273,   277,   272,   271,   274,   275,   283,   284,   276,   279,
+     280,   281,   282,   287,   270,   261,     0,     0,   138,     0,
+     254,     0,   223,     0,     0,   171,     0,     0,     0,     0,
+       0,     0,     0,     0,    78,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    77,    80,     0,
+     295,     0,   295,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    11,     0,     0,     0,   294,     0,   168,   221,
+     286,     0,     0,     0,   122,   102,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   221,   222,   223,   229,   224,   225,   226,
-     227,   228,   230,   234,   232,   233,   252,   252,     0,     0,
-     231,     0,   250,   220,   244,     0,     0,     0,     0,     0,
+       0,     0,     0,   230,   231,   232,   238,   233,   234,   235,
+     236,   237,   239,   243,   241,   242,   261,   261,     0,     0,
+     240,     0,   259,   229,   253,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     6,     9,     0,    79,
-      80,    81,    82,    83,    84,    69,    73,    72,    70,    74,
-      75,    76,    77,    66,    67,    78,     0,    63,     0,   332,
-     331,   337,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   291,     0,   321,     0,    43,    60,    64,     0,     0,
-       0,     0,    53,    87,   347,     0,   319,   320,   321,   254,
-       0,   251,     0,   256,     0,     0,     0,     0,     0,     0,
-     213,     0,   199,     0,     0,   252,   258,     0,     0,   132,
-       0,   142,   179,   180,   181,   182,   183,   184,   187,   186,
-     185,   188,   189,   192,   190,   191,   196,   193,   194,   195,
-      65,   178,     0,     0,     0,   146,   157,     0,     0,     0,
-       0,   154,   197,    33,    34,    32,     0,    37,     0,   289,
-     127,   123,     0,   176,     0,     0,   276,    18,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   219,     0,    91,
-      94,    95,    96,    97,   103,   102,   101,   104,   105,   106,
-     107,   108,   112,   110,   111,   115,   116,   117,     3,     7,
-     342,    35,    36,     0,     0,     0,   330,     0,   317,   347,
-       0,   323,     0,     0,     0,     0,   321,     0,     0,   321,
-       0,     0,   290,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   293,   314,     0,     0,     0,     0,     0,   317,
-       0,   356,     0,    88,     0,     0,     0,     0,   246,     0,
-       0,   248,     0,     0,   120,     0,   128,   130,     0,     0,
-     122,   216,   124,   198,   205,     0,   164,   165,   166,   167,
-     168,   169,   170,   171,   173,   174,   161,   176,   177,   252,
-     252,   258,     0,   175,   142,     0,   134,     0,   125,   131,
-       0,   287,   140,     0,     0,   144,     0,   158,     0,   259,
-       0,     0,     0,   347,     0,   141,   147,     0,     0,   148,
-      19,     0,     0,     0,   240,     0,   235,     0,   242,     0,
-       0,     0,   237,    89,    90,     0,   322,   326,   327,   316,
-       0,     0,   324,     0,   328,     0,     0,     0,     0,   329,
-       0,     0,     0,   338,   292,     0,     0,     0,     0,     0,
-       0,   294,   296,   295,   335,   334,   315,    39,     0,    45,
-      50,    44,    47,     0,    85,    61,    54,     0,     0,     0,
-       0,    55,    57,   349,   318,   348,   350,   247,   253,   249,
-     255,   257,   121,     0,     0,   280,     0,     0,   215,   200,
-     202,     0,     0,     0,     0,     0,     0,   145,     0,     0,
-     143,     0,   153,   152,   288,   151,   150,     0,    20,     0,
-       0,     0,   241,   236,   243,     0,     0,   333,     0,     0,
-       0,     0,   352,   347,     0,     0,   354,   355,   347,   336,
-       0,     0,   321,     0,   321,     0,     0,     0,     0,     0,
-       0,     0,    52,    51,     0,     0,     0,    86,     0,   345,
-       0,   355,    59,     0,    58,     0,   155,     0,     0,     0,
-       0,     0,   205,   210,   209,     0,   204,   207,   208,   163,
-       0,     0,   154,   126,   133,   139,   138,   260,   149,    21,
-       0,     0,    99,   239,   238,     0,   340,     0,   339,     0,
+       0,     0,     0,     0,     0,     0,     6,     9,     0,    88,
+      89,    90,    91,    92,    93,    78,    82,    81,    79,    83,
+      84,    85,    86,    75,    76,    87,     0,    72,     0,   341,
+     340,   346,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   300,     0,   330,     0,    52,    69,    73,     0,     0,
+       0,     0,    62,    96,   356,     0,   328,   329,   330,   263,
+       0,   260,     0,   265,     0,     0,     0,     0,     0,     0,
+     222,     0,   208,     0,     0,   261,   267,     0,     0,   141,
+       0,   151,   188,   189,   190,   191,   192,   193,   196,   195,
+     194,   197,   198,   201,   199,   200,   205,   202,   203,   204,
+      74,   187,     0,     0,     0,   155,   166,     0,     0,     0,
+       0,   163,   206,    42,    43,    41,     0,    46,     0,   298,
+     136,   132,     0,   185,     0,     0,   285,    18,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   228,     0,   100,
+     103,   104,   105,   106,   112,   111,   110,   113,   114,   115,
+     116,   117,   121,   119,   120,   124,   125,   126,     3,     7,
+     351,    44,    45,     0,     0,     0,   339,     0,   326,   356,
+       0,   332,     0,     0,     0,     0,   330,     0,     0,   330,
+       0,     0,   299,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   302,   323,     0,     0,     0,     0,     0,   326,
+       0,   365,     0,    97,     0,     0,     0,     0,   255,     0,
+       0,   257,     0,     0,   129,     0,   137,   139,     0,     0,
+     131,   225,   133,   207,   214,     0,   173,   174,   175,   176,
+     177,   178,   179,   180,   182,   183,   170,   185,   186,   261,
+     261,   267,     0,   184,   151,     0,   143,     0,   134,   140,
+       0,   296,   149,     0,     0,   153,     0,   167,     0,   268,
+       0,     0,     0,   356,     0,   150,   156,     0,     0,   157,
+      19,     0,     0,     0,   249,     0,   244,     0,   251,     0,
+       0,     0,   246,    98,    99,     0,   331,   335,   336,   325,
+       0,     0,   333,     0,   337,     0,     0,     0,     0,   338,
+       0,     0,     0,   347,   301,     0,     0,     0,     0,     0,
+       0,   303,   305,   304,   344,   343,   324,    48,     0,    54,
+      59,    53,    56,     0,    94,    70,    63,     0,     0,     0,
+       0,    64,    66,   358,   327,   357,   359,   256,   262,   258,
+     264,   266,   130,     0,     0,   289,     0,     0,   224,   209,
+     211,     0,     0,     0,     0,     0,     0,   154,     0,     0,
+     152,     0,   162,   161,   297,   160,   159,     0,    20,     0,
+       0,     0,   250,   245,   252,     0,     0,   342,     0,     0,
+       0,     0,   361,   356,     0,     0,   363,   364,   356,   345,
+       0,     0,   330,     0,   330,     0,     0,     0,     0,     0,
+       0,     0,    61,    60,     0,     0,     0,    95,     0,   354,
+       0,   364,    68,     0,    67,     0,   164,     0,     0,     0,
+       0,     0,   214,   219,   218,     0,   213,   216,   217,   172,
+       0,     0,   163,   135,   142,   148,   147,   269,   158,    21,
+       0,     0,   108,   248,   247,     0,   349,     0,   348,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   313,   306,   305,   304,   303,    41,    40,    46,
-      48,    49,    56,   344,     0,     0,     0,     0,   281,     0,
-     282,     0,   217,   201,     0,     0,     0,    22,     0,     0,
-       0,     0,     0,   351,     0,     0,     0,   353,     0,   349,
-       0,     0,     0,     0,     0,     0,   346,    38,     0,   156,
-       0,     0,   203,   206,   208,   136,   137,    23,     0,     0,
-     302,   325,   300,     0,   308,   312,   311,     0,   299,   297,
-       0,   307,     0,    42,   284,   283,   218,     0,    24,     0,
-       0,     0,     0,     0,     0,   135,    25,     0,     0,   301,
-     310,   298,   309,    26,     0,     0,    27,     0,     0,    28,
-       0,    29
+       0,     0,   322,   315,   314,   313,   312,    50,    49,    55,
+      57,    58,    65,   353,     0,     0,     0,     0,   290,     0,
+     291,     0,   226,   210,     0,     0,     0,    22,     0,     0,
+       0,     0,     0,   360,     0,     0,     0,   362,     0,   358,
+       0,     0,     0,     0,     0,     0,   355,    47,     0,   165,
+       0,     0,   212,   215,   217,   145,   146,    23,     0,     0,
+     311,   334,   309,     0,   317,   321,   320,     0,   308,   306,
+       0,   316,     0,    51,   293,   292,   227,     0,    24,     0,
+       0,     0,     0,     0,     0,   144,    25,     0,     0,   310,
+     319,   307,   318,    26,     0,     0,    27,     0,     0,    28,
+       0,     0,    29,     0,     0,    30,     0,     0,    31,     0,
+       0,    32,     0,     0,    33,     0,     0,    34,     0,     0,
+      35,     0,     0,    36,     0,     0,    37,     0,    38
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -597,  -597,   560,   409,   -29,  -597,  -597,  -597,  -597,   102,
-    -597,  -597,    21,    28,  -596,  -517,  -597,    18,  -528,  -389,
-     365,     1,   374,    31,   229,    -2,  -202,   -39,   388,   -32,
-     261,    16,  -597,   368,  -597,   352,  -597,    73,  -597,   -20,
-    -597,   361,  -597,    14,  -597,  -597,   -46,   823,  -597,  -597,
-     215,   -50,  -597,   -96,   -19,  -178,  -597,  -182,  -391,  -597,
-     -27,   -51,  -597,    41,   -30,  -127,   440,  -597,   257,  -597,
-     406,   -77,   733,  -597,   424,  -597,  -597,  -597,  -597,  -597,
-    -597,   417
+    -590,  -590,   596,   462,   -26,  -590,  -590,  -590,  -590,   134,
+    -590,  -590,    59,    56,  -589,  -515,  -590,    57,  -519,  -387,
+     498,     4,   415,    58,   265,    -2,  -198,   -39,   284,   -28,
+     281,    18,  -590,   401,  -590,   388,  -590,   110,  -590,   -17,
+    -590,   405,  -590,    48,  -590,  -590,   -13,   -58,  -590,  -590,
+     251,   -47,  -590,   -91,   -56,  -174,  -590,  -173,  -376,  -590,
+      -8,   -51,  -590,    63,   -24,  -126,   502,  -590,   291,  -590,
+     447,   -86,   984,  -590,   464,  -590,  -590,  -590,  -590,  -590,
+    -590,   668
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,     4,    43,    44,    45,    46,    47,   151,    48,    49,
+       0,     4,    43,    44,    45,    46,    47,   151,    48,    49,
      632,    50,   541,   542,   539,   540,    51,   551,   552,   265,
      266,    52,   139,   543,   272,   140,    65,    66,    67,    68,
       69,    70,   107,   108,   298,   299,   736,   472,   473,    54,
@@ -1234,610 +1251,626 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-      64,    72,   103,   158,   359,   360,   361,   362,   143,    81,
-      81,   273,   112,   205,   115,   152,   353,    53,   351,   352,
-     165,   300,   623,   634,   687,   537,   164,   340,   689,   111,
-     422,   624,   725,    74,   415,   620,   142,   249,   160,   148,
-     615,   560,   250,   203,   203,    22,  -343,    22,   251,   321,
-      22,   149,   150,   161,   424,   322,   643,   252,   166,    22,
-      53,   158,  -343,   348,   158,    22,   644,    22,   330,  -343,
-     424,    22,   510,   253,   404,   616,   405,   424,   617,    22,
-     406,   247,   407,   408,   247,   409,   410,    81,   164,   114,
-     411,    53,    22,   290,   165,  -343,   269,   103,   255,   442,
-     270,   411,   271,   676,   625,   625,   416,   621,   560,   258,
-     331,   513,  -343,   559,   259,   297,    79,   411,   645,   381,
-     424,   382,   671,   435,   411,   594,   342,   411,   105,   753,
-      22,   628,   106,   285,   346,   228,   341,   164,   249,   677,
-     678,   105,   506,   250,   680,   106,   286,   206,    22,   251,
-     411,   517,    22,   752,   518,   345,   411,   404,   252,   405,
-     347,   633,   521,   406,   634,   407,   408,   411,   409,   410,
-     623,   363,   623,   488,   253,   207,   208,   388,   388,    84,
-      22,    22,   357,   750,   411,   411,   357,   372,   373,   374,
-     501,   411,   419,   246,   248,   423,   209,   269,   411,   255,
-     411,   270,   300,   271,   651,   159,    28,   411,  -356,  -356,
-     258,    22,   672,    22,   154,   259,   489,   146,    28,   117,
-     411,    29,    22,   378,   491,    28,   162,   -64,   411,    79,
-      79,    22,   502,    29,   153,   155,   623,   207,   208,   158,
-      29,    22,   249,    53,   589,   354,   652,   250,   437,   156,
-      22,   157,    22,   251,   660,   225,   572,   401,   209,   419,
-     385,   156,   252,   157,   665,    22,   402,   247,   156,   210,
-     157,    22,   403,   626,   445,   249,    22,   411,   253,   353,
-     250,   351,   352,   434,   708,    22,   251,   563,   643,   738,
-     519,   520,    22,   748,   390,   252,   297,    22,   644,    22,
-     478,   269,   386,   255,   474,   270,   411,   271,    22,   227,
-     509,   253,   759,   511,   258,   509,   388,    22,    22,   259,
-     471,   767,   476,   669,   743,   325,   479,   480,   481,   322,
-     774,   777,   411,   411,   269,   749,   255,   391,   270,   264,
-     271,   273,   487,   747,   411,   751,   490,   258,   493,   771,
-     152,   411,   259,   411,   503,   772,   504,   573,   411,     1,
-       2,     3,    22,   411,   211,   212,   213,   214,   215,   216,
-     217,   218,   525,    80,    83,   323,   526,   249,   527,   428,
-     530,   324,   250,   268,   485,   429,   494,    22,   251,   567,
-     322,   666,   495,   693,   158,    53,    22,   252,   496,   694,
-     638,   228,   497,   577,   639,   419,   578,   584,   326,   618,
-     327,   558,   619,   253,   561,    81,   636,   637,    57,    71,
-     203,   287,    75,    76,    78,    82,    82,    86,    88,   431,
-     143,   432,   498,   562,   499,   288,   269,   508,   255,   602,
-     270,   605,   271,   514,   607,   515,   104,   110,   294,   258,
-      85,    87,   116,   302,   259,   303,   104,   147,   142,   305,
-     306,    57,   219,   220,   221,   575,   307,   308,   576,   423,
-     629,   602,   631,   309,   163,   222,   223,   224,   310,   204,
-     204,   595,   596,   375,   376,   377,   587,   311,   312,   588,
-     313,   314,    57,   315,   317,   318,   319,    82,   320,   328,
-      82,   263,   329,   267,   735,   278,   332,   335,    89,    90,
-      91,    92,    93,    94,    95,   350,   425,   426,   427,   430,
-     433,    96,   204,   284,   438,   439,    22,    97,   444,   466,
-     470,   293,  -245,   486,   301,   484,    98,   500,   209,   505,
-     507,   104,   516,   522,   523,   411,   538,   547,   357,   548,
-     549,    81,   649,   550,   557,   765,   579,   580,   582,   474,
-     581,   583,    99,   585,   591,   592,   333,   334,   599,   635,
-     278,   278,   204,   100,   101,   593,   650,   656,   104,   657,
-     349,   670,   642,   653,   658,   102,   674,   659,   654,   662,
-     663,   664,   673,   713,   675,   679,   681,   717,   158,   364,
-     365,   366,   367,   368,   369,   370,   371,   695,   697,   705,
-     706,   710,   711,   204,   204,   284,   355,   726,   204,   712,
-     715,   728,   204,   716,   718,   730,   731,   732,   741,   761,
-     757,   595,   596,   762,   780,   226,   379,   700,   701,   702,
-     622,   417,   688,   704,    57,   380,   692,   546,   480,   481,
-     469,   655,   443,   690,   436,   568,   703,   691,   707,   733,
-     524,   392,     0,   278,     0,   278,     0,     0,     0,   383,
-      78,   278,   278,   396,   399,   400,     0,   384,   698,     0,
-     278,   414,     0,    82,     0,   418,   278,   420,   421,   278,
-       0,   249,     0,   727,     0,   729,   250,     0,     0,     0,
-       0,    22,   251,   110,     0,     0,   737,     0,   293,   385,
-       0,   252,   464,   465,     0,   301,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   754,   253,   755,   756,
-       0,     0,     0,     0,     0,     0,   758,     0,     0,     0,
-     204,     0,     0,     0,   104,     0,     0,     0,     0,     0,
-     482,   386,   255,   263,   256,     0,   257,   766,     0,     0,
-       0,     0,     0,   258,     0,   773,   492,     0,   259,     0,
-       0,     0,   776,     0,     0,   779,     0,     0,   781,     0,
+      64,    72,   273,   158,   200,   200,   203,   203,   359,   360,
+     361,   362,    81,    81,   143,   112,   205,   115,   152,    53,
+     165,   103,   351,   352,   623,   353,   300,   537,   340,   111,
+     164,   687,   634,  -352,   624,   689,   142,   415,   725,   148,
+    -352,   424,   422,   510,    22,   620,   114,   200,   424,   249,
+     671,   323,   160,    22,   250,   285,   560,   324,   166,    22,
+     251,   158,    53,   643,   158,   207,   208,   161,   286,   252,
+      22,   643,    22,   644,  -352,  -352,   577,    22,    22,   578,
+      22,   644,   424,   676,   247,   253,   209,   247,   411,   513,
+      81,    22,   164,    53,   165,   411,   290,   200,   442,   341,
+      89,    90,    91,    92,    93,    94,    95,   625,   269,   416,
+     255,   625,   270,    96,   271,   297,   103,   621,    22,    97,
+     381,   258,   382,   560,   559,   645,   259,    79,    98,   411,
+     411,   594,   342,   669,   411,   435,   753,   330,   200,   200,
+     105,   164,   411,   200,   106,   357,    22,   200,   616,   357,
+     521,   617,   615,   346,    99,   345,    22,   146,   488,    74,
+     347,   517,    22,   633,   518,   100,   101,   680,   388,   388,
+     249,   363,   623,   634,   623,   250,   404,   102,   405,   331,
+      22,   251,   406,   419,   407,   408,   423,   409,   410,   390,
+     252,   372,   373,   374,   325,   105,  -365,  -365,   322,   106,
+     411,   489,   411,   628,    22,    84,   253,   300,   411,   677,
+     249,  -352,   206,   752,   411,   250,   404,   246,   405,   424,
+      22,   251,   406,   378,   407,   408,   411,   409,   410,   269,
+     252,   255,   391,   270,   501,   271,    28,   463,   623,   158,
+     207,   208,   258,    22,   678,    53,   253,   259,   437,   651,
+     419,    29,   750,    79,   411,    22,   248,   401,   525,    22,
+     411,   209,   526,   117,   527,   200,   411,   474,   348,   269,
+     247,   255,   491,   270,   572,   271,   502,   445,   321,   156,
+      22,   157,   258,   434,   322,   351,   352,   259,   353,   411,
+      28,   652,    79,   589,    28,    22,   297,   411,    22,   153,
+     665,   509,   154,    22,   511,    29,   509,   388,   660,    29,
+     496,   162,   -73,   411,   497,   743,   708,    22,   748,   478,
+     471,    22,   476,   155,   411,    22,   479,   480,   481,   159,
+     738,   411,   273,   156,   759,   157,    22,   156,   767,   157,
+     618,   210,   487,   619,    22,    22,   490,    22,   493,   774,
+      22,    22,    22,   152,   503,    22,   504,   777,   780,   225,
+     783,   749,   771,   786,   789,   792,    22,    22,   795,    22,
+     411,   411,   200,   227,   558,   200,    22,   561,   672,   798,
+     801,   200,   804,   203,   626,   747,   411,   751,     1,     2,
+       3,   287,   567,   411,   158,   411,   419,    53,   584,   530,
+     228,   463,   463,   354,   219,   220,   221,   506,    22,   772,
+      89,    90,    91,    92,    93,    94,    95,   411,    81,   228,
+     402,   428,   326,    96,   327,   485,   403,   429,    22,    97,
+     602,   322,   605,   562,   494,   607,   143,   431,    98,   432,
+     495,   264,   200,   200,   595,   596,   211,   212,   213,   214,
+     215,   216,   217,   218,   563,   222,   223,   224,   142,    22,
+     423,   629,   602,   631,    99,   575,   693,   638,   576,   149,
+     150,   639,   694,   573,   249,   100,   101,   268,    22,   250,
+     519,   520,   477,   666,    22,   251,   587,   102,    22,   588,
+     636,   637,   385,   288,   252,   364,   365,   366,   367,   368,
+     369,   370,   371,   375,   376,   377,    80,    83,   735,   200,
+     253,   357,    85,    87,   498,   514,   499,   515,   294,   302,
+     200,   303,   474,   305,   306,   307,   308,   309,   328,   310,
+     311,   312,   313,   269,   386,   255,   314,   270,   329,   271,
+     315,   317,   249,   318,   319,   320,   258,   250,   350,   425,
+     332,   259,    22,   251,    81,   649,   335,   426,   427,   765,
+     385,   433,   252,   249,   430,   438,   439,   444,   250,   466,
+     470,  -254,   484,    22,   251,   500,   486,   656,   253,   657,
+     209,   505,   507,   252,   713,   516,   523,   659,   717,   662,
+     522,   411,   463,   463,   595,   596,   538,   548,   158,   253,
+     547,   482,   386,   255,   549,   256,   550,   257,   726,   557,
+     579,   581,   635,   580,   258,   591,   585,   592,   582,   259,
+     593,   583,   269,   508,   255,   599,   270,   650,   271,   642,
+     658,   653,   654,   670,   663,   258,   664,   700,   701,   702,
+     259,   673,   674,   704,   675,   679,   681,   695,   480,   481,
+     705,   697,   706,   710,   711,   712,   715,   728,   707,   731,
+     716,   718,   730,   732,   741,   761,   757,   762,   807,    57,
+      71,   226,   622,    75,    76,    78,    82,    82,    86,    88,
+     688,   690,   417,   546,   691,   692,   469,   436,   655,   379,
+     703,   568,   733,   727,   524,   729,   443,   104,   110,   249,
+     698,     0,   392,   116,   250,     0,   737,   104,   147,    22,
+     251,     0,    57,     0,     0,     0,     0,   384,     0,   252,
+       0,     0,     0,     0,     0,   163,   754,     0,   755,   756,
+     204,   204,     0,     0,     0,   253,   758,     0,     0,     0,
+       0,     0,     0,    57,     0,     0,     0,     0,    82,     0,
+       0,    82,   263,     0,   267,     0,   278,   766,   269,     0,
+     255,   512,   270,     0,   271,   773,     0,     0,     0,     0,
+       0,   258,   776,   204,   284,   779,   259,     0,   782,     0,
+       0,   785,   293,     0,   788,   301,     0,   791,     0,     0,
+     794,     0,   104,   797,     0,     0,   800,     0,     0,   803,
+       0,     0,   806,     0,     0,   808,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   249,     0,   333,   334,     0,
+     250,   278,   278,   204,     0,    22,   251,     0,     0,   104,
+       0,   349,     0,     0,     0,   252,   640,     0,     0,     0,
+       0,     0,     0,   183,   184,   185,   186,   187,   188,   189,
+     190,   253,   191,    22,   192,   193,    25,   194,   195,     0,
+       0,   641,     0,     0,   204,   204,   284,   355,     0,   204,
+       0,     0,     0,   204,   393,     0,   255,     0,   270,     0,
+     271,     0,     0,   249,     0,     0,     0,   258,   250,     0,
+     534,     0,   259,    22,   251,    57,   380,     0,     0,     0,
+       0,     0,   196,   252,   197,     0,   198,     0,   199,     0,
+       0,     0,     0,     0,   278,     0,   278,     0,     0,   253,
+     383,    78,   278,   278,   396,   399,   400,     0,     0,     0,
+       0,   278,   414,     0,    82,     0,   418,   278,   420,   421,
+     278,     0,   254,     0,   255,     0,   256,     0,   257,     0,
+       0,     0,     0,     0,   110,   258,     0,     0,     0,   293,
+     259,     0,     0,   464,   465,     0,   301,     0,     7,     8,
+       9,    10,    11,     0,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,   204,     0,     0,     0,   104,     0,     0,     0,     0,
+       0,     0,     0,     0,   263,    29,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    30,    31,   492,    32,     0,
+      33,     0,     0,     0,     0,     0,     0,     0,     0,    34,
+      35,    36,     0,    37,     0,    38,     0,    39,     0,    40,
+       0,     0,     0,     0,     0,     0,     0,    57,     0,     0,
+       0,    41,     0,     0,    42,   278,     0,     0,   278,     0,
+     278,   278,     0,     0,     0,     0,     0,     0,   262,     0,
+       0,   263,     0,   278,   278,   104,   278,   278,   278,   278,
+     278,     0,   267,     0,   544,   545,   278,     0,     0,     0,
+       0,     0,   278,   278,   278,   278,     0,     0,   204,     0,
+     284,   204,     0,     0,     0,     0,   566,   204,     0,     0,
+       0,   183,   184,   185,   186,   187,   188,   189,   190,     0,
+     191,    22,   192,   193,    25,   194,   195,   464,   464,   465,
+     574,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   356,     0,     0,     0,     0,     0,     0,     0,
+     278,     0,   278,     0,     0,     0,     0,     0,     0,     0,
+     590,     0,     0,     0,     0,     0,     0,   284,   204,   204,
+     196,     0,   197,   278,   198,     0,   199,     0,   278,     0,
+       0,   278,     0,   601,   278,   278,   278,     0,   606,   278,
+     278,     0,   249,   278,   612,   614,     0,   250,     0,     0,
+       0,     0,    22,   251,     0,     0,    82,     0,     0,     0,
+       0,   627,   252,     0,   278,   278,   278,   278,   267,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   253,     0,
+       0,     0,     0,     0,     0,   204,     0,     0,   389,   648,
+     394,   397,     0,     0,     0,     0,   204,   413,     0,     0,
+       0,   269,     0,   255,     0,   270,     0,   271,   661,     0,
+       0,     0,     0,     0,   258,     0,     0,   668,     0,   259,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    57,     0,     0,     0,
-       0,     0,     0,     0,   278,     0,     0,   278,     0,   278,
-     278,     0,     0,     0,     0,     0,     0,   262,     0,     0,
-     263,     0,   278,   278,   104,   278,   278,   278,   278,   278,
-       0,   267,     0,   544,   545,   278,     0,     0,     0,     0,
-       0,   278,   278,   278,   278,     0,     0,   204,     0,   284,
-     204,     0,     0,     0,     0,   566,   204,     0,     0,     0,
-     183,   184,   185,   186,   187,   188,   189,   190,     0,   191,
-      22,   192,   193,    25,   194,   195,   464,   464,   465,   574,
-       0,     0,     0,     0,     0,   200,   200,     0,     0,     0,
-       0,   356,     0,     0,     0,     0,     0,     0,     0,   278,
-       0,   278,     0,     0,     0,     0,     0,     0,     0,   590,
-       0,     0,     0,     0,     0,     0,   284,   204,   204,   196,
-       0,   197,   278,   198,     0,   199,     0,   278,   200,     0,
-     278,     0,   601,   278,   278,   278,     0,   606,   278,   278,
-       0,     0,   278,   612,   614,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    82,     0,     0,     0,     0,
-     627,     0,     0,   278,   278,   278,   278,   267,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   200,   239,
-     240,   241,   242,     0,   204,     0,     0,   389,   648,   394,
-     397,     0,   243,   244,     0,   204,   413,   245,     0,    89,
-      90,    91,    92,    93,    94,    95,     0,   661,     0,     0,
-       0,     0,    96,   137,     0,     0,   668,    22,    97,   200,
-     200,     0,     0,     0,   200,   138,     0,    98,   200,     0,
-       0,     0,   278,   278,   278,   278,   278,     0,   544,     0,
-       0,     0,   544,   544,     0,     0,     0,     0,     0,     0,
-       0,     0,   696,    99,   566,   699,     0,     0,     0,     0,
-       0,     0,     0,     0,   100,   101,     0,   464,   464,   483,
-       0,   477,     0,     0,     0,     0,   102,     0,   709,     0,
-       0,     0,     0,     0,     0,     0,     0,   278,   278,     0,
-       0,   278,     0,   278,   278,   278,   278,   278,   278,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   627,     0,
-       0,   278,     0,     0,     0,     0,     0,     0,   463,     0,
-       0,     0,   734,     0,     0,     0,   739,   278,     0,   278,
-       0,     0,   278,   278,     0,   278,   262,     0,   528,   529,
-       0,   531,   532,   533,   535,   536,   200,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   760,   553,   554,   555,
-     556,     0,     0,   249,     0,     0,     0,   278,   250,   278,
-       0,     0,     0,    22,   251,     0,     0,   768,   278,   278,
-       0,     0,     0,   252,     0,   775,     0,     0,     0,     0,
-       0,     0,   778,     0,     0,     0,     0,     0,     0,   253,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   249,
-       0,     0,     0,     0,   250,   389,     0,     0,     0,    22,
-     251,     0,   269,     0,   255,   512,   270,     0,   271,   252,
-       0,     0,     0,     0,     0,   258,     0,     0,   597,     0,
-     259,     0,     0,   598,     0,   253,   600,     0,     0,   603,
-     604,     0,     0,   200,   608,   609,   200,     0,   610,   611,
-     613,     0,   200,     0,     0,     0,     0,     0,   393,     0,
-     255,     0,   270,     0,   271,     0,     0,     0,     0,     0,
-       0,   258,   463,   463,   534,     0,   259,     0,     0,     5,
-       6,     0,     7,     8,     9,    10,    11,     0,    12,    13,
+       0,     0,     0,   278,   278,   278,   278,   278,     0,   544,
+       0,   249,     0,   544,   544,     0,   250,     0,     0,     0,
+       0,    22,   251,   696,     0,   566,   699,     0,     0,     0,
+       0,   252,     0,     0,     0,     0,     0,     0,   464,   464,
+     483,     0,     0,     0,     0,     0,     0,   253,     0,   709,
+       0,     0,     0,     0,     0,     0,     0,     0,   278,   278,
+       0,     0,   278,     0,   278,   278,   278,   278,   278,   278,
+     336,     0,   255,     0,   270,     0,   271,     0,     0,   627,
+       0,     0,   278,   258,     0,     0,     0,     0,   259,     0,
+       0,     0,     0,   734,     0,     0,     0,   739,   278,     0,
+     278,     0,     0,   278,   278,     0,   278,   262,     0,   528,
+     529,     0,   531,   532,   533,   535,   536,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   760,   553,   554,
+     555,   556,     0,     0,   249,     0,     0,     0,   278,   250,
+     278,     0,     0,     0,    22,   251,     0,     0,   768,   278,
+     278,     0,     0,     0,   252,     0,   775,     0,     0,     0,
+       0,     0,     0,   778,     0,     0,   781,     0,     0,   784,
+     253,     0,   787,     0,     0,   790,     0,     0,   793,     0,
+       0,   796,     0,     0,   799,     0,   389,   802,     0,     0,
+     805,     0,     0,   393,     0,   255,     0,   270,     0,   271,
+       0,     0,     0,     0,     0,     0,   258,     0,     0,   597,
+       0,   259,     0,     0,   598,     0,     0,   600,     0,     0,
+     603,   604,     0,     0,     0,   608,   609,     0,     0,   610,
+     611,   613,     0,     0,     0,     0,     0,     0,     5,     6,
+       0,     7,     8,     9,    10,    11,     0,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,     0,     0,     0,     0,     0,     0,
+     183,   184,   185,   186,   187,   188,   189,   190,    29,   191,
+      22,   192,   193,    25,   194,   195,     0,     0,    30,    31,
+       0,    32,     0,    33,     0,     0,     0,     0,     0,     0,
+       0,   358,    34,    35,    36,     0,    37,     0,    38,     0,
+      39,     0,    40,     0,     0,     0,     0,     0,     0,   682,
+     683,   684,   685,   686,    41,     0,     0,    42,     0,   196,
+       0,   197,     0,   198,     0,   199,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    58,     0,   714,     0,    29,     0,     0,
+     719,   720,   721,   722,   723,   724,     0,    30,    31,     0,
+      32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
+       0,    34,    35,    36,     0,    61,   316,    38,     0,    39,
+       0,    40,     0,     0,   740,     0,   742,     0,     0,   744,
+     745,     0,   746,    41,     0,   183,   184,   185,   186,   187,
+     188,   189,   190,     0,   191,    22,   192,   193,    25,   194,
+     195,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   763,     0,   764,     0,     0,     0,
+       0,     0,     0,     0,     0,   769,   770,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,   196,     0,   197,     0,   198,     0,
+     199,     0,   118,   119,   120,   121,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,    30,    31,
+       0,    32,     0,    33,     0,     0,   134,   135,    60,     0,
+       0,   136,    34,    35,    36,     0,    61,     0,    38,     0,
+      39,     0,    40,     0,     0,    62,    63,   137,     0,     0,
+       0,     0,     0,     0,    41,     0,     0,     0,     0,   138,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
+       0,     0,     0,     0,     0,   167,   168,   169,   170,   171,
+     172,    29,   173,   174,   175,   128,   176,   177,   178,   179,
+     133,    30,    31,     0,    32,     0,    33,     0,     0,   180,
+     181,    60,     0,     0,   182,    34,    35,    36,     0,    61,
+       0,    38,     0,    39,     0,    40,     0,     0,    62,    63,
+       0,     0,     0,     0,     0,     0,     0,    41,   446,   447,
+     448,   449,   450,   451,   452,   453,    20,   454,    22,   455,
+     456,    25,   457,   458,    28,     0,     0,     0,     0,     0,
+       0,     0,     0,   167,   168,   169,   170,   171,   172,    29,
+     173,   174,   175,   128,   176,   177,   178,   179,   133,    30,
+      31,     0,    32,     0,    33,     0,     0,   180,   181,    60,
+       0,     0,   182,    34,    35,    36,     0,   459,     0,   460,
+       0,   461,     0,   462,     0,     0,    62,    63,     0,     0,
+       0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
+       0,     0,     0,     0,     0,     0,    59,    30,    31,     0,
+      32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
+       0,    34,    35,    36,   467,   295,     0,    38,     0,   296,
+     468,    40,     0,     0,    62,    63,     0,     0,     0,     0,
+       0,     0,     0,    41,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,   343,    27,
+      28,     0,     0,   344,     0,     0,     0,     0,     0,     0,
+       0,    58,     0,     0,     0,    29,     0,     0,     0,     0,
+       0,     0,     0,     0,    59,    30,    31,     0,    32,     0,
+      33,     0,     0,     0,     0,    60,     0,     0,     0,    34,
+      35,    36,     0,    61,     0,    38,     0,    39,     0,    40,
+       0,     0,    62,    63,     0,     0,     0,     0,     0,     0,
+       0,    41,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    58,
+       0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
+       0,     0,    59,    30,    31,     0,    32,     0,    33,     0,
+       0,     0,     0,    60,     0,     0,     0,    34,    35,    36,
+       0,    61,     0,    38,   475,    39,     0,    40,     0,     0,
+      62,    63,     0,     0,     0,     0,     0,     0,     0,    41,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    58,     0,     0,
+       0,    29,     0,     0,     0,     0,     0,     0,     0,     0,
+      59,    30,    31,     0,    32,     0,    33,     0,     0,     0,
+       0,    60,     0,     0,     0,    34,    35,    36,     0,    61,
+       0,    38,   586,    39,     0,    40,     0,     0,    62,    63,
+       0,     0,     0,     0,     0,     0,     0,    41,    12,    13,
       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
       24,    25,    26,    27,    28,     0,     0,     0,     0,     0,
-       0,     0,     0,   200,   200,     0,   249,     0,     0,    29,
-       0,   250,     0,     0,     0,     0,    22,   251,     0,    30,
-      31,     0,    32,     0,    33,     0,   252,     0,   682,   683,
-     684,   685,   686,    34,    35,    36,     0,    37,     0,    38,
-       0,    39,   253,    40,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    41,     0,     0,    42,     0,
-       0,     0,     0,     0,     0,   254,     0,   255,     0,   256,
-     200,   257,     0,     0,     0,     0,     0,     0,   258,     0,
-       0,   200,     0,   259,   714,     0,     0,     0,     0,   719,
-     720,   721,   722,   723,   724,     7,     8,     9,    10,    11,
-       0,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,     0,     0,
-       0,     0,     0,   740,     0,   742,     0,     0,   744,   745,
-       0,   746,    29,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    30,    31,     0,    32,     0,    33,     0,     0,
-       0,     0,     0,   463,   463,     0,    34,    35,    36,     0,
-      37,     0,    38,   763,    39,   764,    40,     0,     0,     0,
-       0,     0,     0,     0,   769,   770,     0,     0,    41,     0,
-       0,    42,    12,    13,    14,    15,    16,    17,    18,    19,
+       0,     0,     0,     0,     0,    58,     0,     0,     0,    29,
+       0,     0,     0,     0,     0,     0,     0,     0,    59,    30,
+      31,     0,    32,     0,    33,     0,     0,     0,     0,    60,
+       0,     0,     0,    34,    35,    36,     0,    61,     0,    38,
+       0,    39,     0,    40,     0,     0,    62,    63,     0,     0,
+       0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
+       0,     0,     0,     0,     0,     0,    59,    30,    31,     0,
+      32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
+       0,    34,    35,    36,     0,   295,     0,    38,     0,   296,
+       0,    40,     0,     0,    62,    63,     0,     0,     0,     0,
+       0,     0,     0,    41,   446,   447,   448,   449,   450,   451,
+     452,   453,    20,   454,    22,   455,   456,    25,   457,   458,
+      28,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    58,     0,     0,     0,    29,     0,     0,     0,     0,
+       0,     0,     0,     0,    59,    30,    31,     0,    32,     0,
+      33,     0,     0,     0,     0,    60,     0,     0,     0,    34,
+      35,    36,     0,   459,     0,   460,     0,   461,     0,   462,
+       0,     0,    62,    63,     0,     0,     0,     0,     0,     0,
+       0,    41,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
-       0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,    30,    31,     0,    32,     0,    33,     0,
-       0,   134,   135,    60,     0,     0,   136,    34,    35,    36,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    58,
+       0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
+       0,     0,    59,    30,    31,     0,    32,     0,    33,     0,
+       0,     0,     0,    60,     0,     0,     0,    34,    35,    36,
        0,    61,     0,    38,     0,    39,     0,    40,     0,     0,
-      62,    63,   137,     0,     0,     0,     0,     0,     0,    41,
-       0,     0,     0,     0,   138,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,     0,     0,     0,     0,     0,     0,     0,     0,
-     167,   168,   169,   170,   171,   172,    29,   173,   174,   175,
-     128,   176,   177,   178,   179,   133,    30,    31,     0,    32,
-       0,    33,     0,     0,   180,   181,    60,     0,     0,   182,
-      34,    35,    36,     0,    61,     0,    38,     0,    39,     0,
-      40,     0,     0,    62,    63,     0,     0,     0,     0,     0,
-       0,     0,    41,   446,   447,   448,   449,   450,   451,   452,
-     453,    20,   454,    22,   455,   456,    25,   457,   458,    28,
-       0,     0,     0,     0,     0,     0,     0,     0,   167,   168,
-     169,   170,   171,   172,    29,   173,   174,   175,   128,   176,
-     177,   178,   179,   133,    30,    31,     0,    32,     0,    33,
-       0,     0,   180,   181,    60,     0,     0,   182,    34,    35,
-      36,     0,   459,     0,   460,     0,   461,     0,   462,     0,
-       0,    62,    63,     0,     0,     0,     0,     0,     0,     0,
-      41,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    58,     0,
-       0,     0,    29,     0,     0,     0,     0,     0,     0,     0,
-       0,    59,    30,    31,     0,    32,     0,    33,     0,     0,
-       0,     0,    60,     0,     0,     0,    34,    35,    36,   467,
-     295,     0,    38,     0,   296,   468,    40,     0,     0,    62,
-      63,     0,     0,     0,     0,     0,     0,     0,    41,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,   343,    27,    28,     0,     0,   344,     0,
-       0,     0,     0,     0,     0,     0,    58,     0,     0,     0,
-      29,     0,     0,     0,     0,     0,     0,   249,     0,    59,
-      30,    31,   250,    32,     0,    33,     0,    22,   251,     0,
-      60,     0,     0,     0,    34,    35,    36,   252,    61,     0,
-      38,     0,    39,     0,    40,     0,     0,    62,    63,     0,
-       0,     0,     0,   253,     0,     0,    41,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,     0,     0,   269,     0,   255,     0,
-     270,     0,   271,     0,    58,     0,     0,     0,    29,   258,
-       0,     0,     0,     0,   259,   249,     0,    59,    30,    31,
-     250,    32,     0,    33,     0,    22,   251,     0,    60,     0,
-       0,     0,    34,    35,    36,   252,    61,     0,    38,   475,
-      39,     0,    40,     0,     0,    62,    63,     0,     0,     0,
-       0,   253,     0,     0,    41,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,     0,     0,   336,     0,   255,     0,   270,     0,
-     271,     0,    58,     0,     0,     0,    29,   258,     0,     0,
-       0,     0,   259,   249,     0,    59,    30,    31,   250,    32,
-       0,    33,     0,    22,   251,     0,    60,     0,     0,     0,
-      34,    35,    36,   252,    61,     0,    38,   586,    39,     0,
-      40,     0,     0,    62,    63,     0,     0,     0,     0,   253,
-       0,     0,    41,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-       0,     0,   393,     0,   255,     0,   270,     0,   271,     0,
-      58,     0,     0,     0,    29,   258,     0,     0,     0,     0,
-     259,     0,     0,    59,    30,    31,     0,    32,     0,    33,
-       0,     0,     0,     0,    60,     0,     0,     0,    34,    35,
-      36,     0,    61,     0,    38,     0,    39,     0,    40,     0,
-       0,    62,    63,     0,     0,     0,     0,     0,     0,     0,
-      41,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    58,     0,
-       0,     0,    29,     0,     0,     0,     0,     0,     0,     0,
-       0,    59,    30,    31,     0,    32,     0,    33,     0,     0,
-       0,     0,    60,     0,     0,     0,    34,    35,    36,     0,
-     295,     0,    38,     0,   296,     0,    40,     0,     0,    62,
-      63,     0,     0,     0,     0,     0,     0,     0,    41,   446,
-     447,   448,   449,   450,   451,   452,   453,    20,   454,    22,
-     455,   456,    25,   457,   458,    28,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    58,     0,     0,     0,
-      29,     0,     0,     0,     0,     0,     0,     0,     0,    59,
-      30,    31,     0,    32,     0,    33,     0,     0,     0,     0,
-      60,     0,     0,     0,    34,    35,    36,     0,   459,     0,
-     460,     0,   461,     0,   462,     0,     0,    62,    63,     0,
-       0,     0,     0,     0,     0,     0,    41,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    58,     0,     0,     0,    29,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    30,    31,
-       0,    32,     0,    33,     0,     0,     0,     0,    60,     0,
-       0,     0,    34,    35,    36,     0,    61,   316,    38,     0,
-      39,     0,    40,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    41,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    58,     0,     0,     0,    29,     0,     0,     0,
-       0,     0,     0,     0,     0,    59,    30,    31,     0,    32,
-       0,    33,     0,     0,     0,     0,    60,     0,     0,     0,
-      34,    35,    36,     0,    61,     0,    38,     0,    39,     0,
-      40,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    41,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      58,     0,     0,     0,    29,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    30,    31,     0,    32,     0,    33,
-       0,     0,     0,     0,    60,     0,     0,     0,    34,    35,
-      36,     0,    61,     0,    38,     0,    39,     0,    40,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      41,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    58,     0,
-       0,     0,    29,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    30,    31,     0,    32,     0,    33,     0,     0,
-       0,     0,     0,     0,     0,     0,    34,    35,    36,     0,
-      61,   304,    38,     0,    39,     0,    40,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    41,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    58,     0,     0,     0,
-      29,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      30,    31,     0,    32,     0,    33,     0,     0,     0,     0,
-       0,     0,     0,     0,    34,    35,    36,     0,    61,     0,
-      38,     0,    39,     0,    40,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    41,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    29,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    30,    31,
-       0,    32,     0,    33,     0,     0,     0,     0,     0,     0,
-       0,     0,    34,    35,    36,     0,    61,     0,    38,     0,
-      39,     0,    40,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    41,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    29,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    31,     0,     0,
-       0,     0,   289,     0,     0,     0,     0,     0,     0,     0,
-      34,    35,     0,     0,    61,     0,    38,     0,    39,     0,
-      40,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    41,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     640,     0,     0,     0,    29,     0,     0,   183,   184,   185,
-     186,   187,   188,   189,   190,    31,   191,    22,   192,   193,
-      25,   194,   195,     0,     0,   641,     0,     0,    34,    35,
-       0,     0,    61,     0,    38,     0,    39,     0,    40,     0,
-       0,     0,   183,   184,   185,   186,   187,   188,   189,   190,
-      41,   191,    22,   192,   193,    25,   194,   195,     0,     0,
-       0,     0,     0,     0,     0,     0,   196,     0,   197,     0,
-     198,     0,   199,   358,   183,   184,   185,   186,   187,   188,
-     189,   190,     0,   191,    22,   192,   193,    25,   194,   195,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   196,     0,   197,     0,   198,     0,   199,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    41,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    58,     0,     0,
+       0,    29,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    30,    31,     0,    32,     0,    33,     0,     0,     0,
+       0,    60,     0,     0,     0,    34,    35,    36,     0,    61,
+       0,    38,     0,    39,     0,    40,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    41,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    58,     0,     0,     0,    29,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    30,
+      31,     0,    32,     0,    33,     0,     0,     0,     0,     0,
+       0,     0,     0,    34,    35,    36,     0,    61,   304,    38,
+       0,    39,     0,    40,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    30,    31,     0,
+      32,     0,    33,     0,     0,     0,     0,     0,     0,     0,
+       0,    34,    35,    36,     0,    61,     0,    38,     0,    39,
+       0,    40,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    41,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    29,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    30,    31,     0,    32,     0,
+      33,     0,     0,     0,     0,     0,     0,     0,     0,    34,
+      35,    36,     0,    61,     0,    38,     0,    39,     0,    40,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    41,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   196,     0,   197,     0,   198,     0,   199
+       0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    31,     0,     0,     0,     0,   289,
+       0,     0,     0,     0,     0,     0,     0,    34,    35,     0,
+       0,    61,     0,    38,     0,    39,     0,    40,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    41,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
+       0,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,    29,   239,   240,   241,   242,     0,     0,     0,     0,
+       0,     0,    31,     0,     0,   243,   244,     0,     0,     0,
+     245,     0,     0,     0,     0,    34,    35,     0,     0,    61,
+       0,    38,     0,    39,     0,    40,   137,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    41,   138
 };
 
 static const yytype_int16 yycheck[] =
 {
-       2,     3,    29,    54,   206,   207,   208,   209,    38,     8,
-       9,    88,    32,    63,    34,    44,   198,     1,   196,   197,
-      59,   117,   539,   551,   620,   414,    58,   154,   624,    31,
-       8,     8,     8,     0,     8,     8,    38,    15,    31,    41,
-      38,   432,    20,    62,    63,    25,    33,    25,    26,    75,
-      25,    93,    94,    46,    41,    81,    16,    35,    60,    25,
-      44,   112,    33,    38,   115,    25,    26,    25,    38,    33,
-      41,    25,    43,    51,    38,    36,    40,    41,    39,    25,
-      44,    80,    46,    47,    83,    49,    50,    86,   120,    78,
-      88,    75,    25,   113,   133,    33,    74,   124,    76,    79,
-      78,    88,    80,    41,    81,    81,    80,    80,   499,    87,
-      80,    43,    33,    79,    92,   117,    74,    88,    78,   246,
-      41,   248,    43,    69,    88,    79,   156,    88,    74,   725,
-      25,     8,    78,    69,   161,    46,   155,   169,    15,    43,
-      43,    74,    53,    20,    41,    78,    82,    36,    25,    26,
-      88,    41,    25,    41,    44,   157,    88,    38,    35,    40,
-     162,   550,    34,    44,   692,    46,    47,    88,    49,    50,
-     687,   210,   689,    34,    51,    64,    65,   254,   255,    74,
-      25,    25,   201,    43,    88,    88,   205,   219,   220,   221,
-      38,    88,   269,    38,    38,   272,    85,    74,    88,    76,
-      88,    78,   298,    80,    38,    28,    31,    88,    80,    81,
-      87,    25,    80,    25,    39,    92,    77,    20,    31,    78,
-      88,    46,    25,   225,    38,    31,    38,    39,    88,    74,
-      74,    25,    80,    46,    39,    60,   753,    64,    65,   290,
-      46,    25,    15,   227,    38,    20,    80,    20,   287,    74,
-      25,    76,    25,    26,    38,    38,    69,   259,    85,   336,
-      33,    74,    35,    76,    75,    25,    75,   266,    74,    69,
-      76,    25,    81,    33,   294,    15,    25,    88,    51,   461,
-      20,   459,   460,   285,    38,    25,    26,    20,    16,    38,
-      80,    81,    25,    75,    34,    35,   298,    25,    26,    25,
-     327,    74,    75,    76,   323,    78,    88,    80,    25,     8,
-     387,    51,    38,   390,    87,   392,   393,    25,    25,    92,
-     322,    38,   324,    79,    79,    77,   328,   329,   330,    81,
-      38,    38,    88,    88,    74,    79,    76,    77,    78,    32,
-      80,   418,   344,    80,    88,    80,   348,    87,   350,    79,
-     379,    88,    92,    88,   356,    80,   358,    20,    88,     3,
-       4,     5,    25,    88,    47,    48,    49,    50,    51,    52,
-      53,    54,    74,     8,     9,    80,    78,    15,    80,    75,
-     407,    86,    20,    32,    75,    81,    75,    25,    26,   439,
-      81,    20,    81,    75,   445,   379,    25,    35,    77,    81,
-      34,    46,    81,    77,    38,   482,    80,   484,    79,    36,
-      81,   430,    39,    51,   433,   414,    80,    81,     1,     2,
-     439,    38,     5,     6,     7,     8,     9,    10,    11,    79,
-     460,    81,    79,   435,    81,    63,    74,    75,    76,   516,
-      78,   518,    80,    79,   521,    81,    29,    30,    38,    87,
-      10,    11,    35,    75,    92,    75,    39,    40,   460,    75,
-      75,    44,    40,    41,    42,   467,    75,    75,   470,   546,
-     547,   548,   549,    75,    57,    43,    44,    45,    75,    62,
-      63,   500,   501,   222,   223,   224,   488,    75,    75,   491,
-      75,    75,    75,    75,    75,    75,    75,    80,    75,    38,
-      83,    84,    38,    86,   706,    88,    92,    96,     7,     8,
-       9,    10,    11,    12,    13,    67,    33,    43,    41,    81,
-      38,    20,   105,   106,    80,    80,    25,    26,    37,    82,
-      38,   114,    38,    77,   117,    32,    35,    38,    85,    46,
-      75,   124,    34,    46,    92,    88,    14,    81,   567,    34,
-      34,   550,   572,    14,    75,   757,    36,    77,    80,   578,
-      38,    80,    61,    77,    68,    75,   149,   150,    80,    34,
-     153,   154,   155,    72,    73,    77,    38,   579,   161,   581,
-     163,    34,    80,    79,    77,    84,    34,   589,    82,   591,
-      80,    80,    80,   670,    80,    34,    34,   674,   649,   211,
-     212,   213,   214,   215,   216,   217,   218,    38,    58,    34,
-      81,    38,    34,   196,   197,   198,   199,   694,   201,    38,
-      38,    38,   205,    39,    39,    38,    33,    79,    77,    38,
-      81,   650,   651,    38,    38,    75,   227,   639,   640,   641,
-     538,   267,   621,   645,   227,   228,   628,   418,   650,   651,
-     298,   578,   291,   625,   286,   440,   642,   626,   660,   705,
-     403,   255,    -1,   246,    -1,   248,    -1,    -1,    -1,   252,
-     253,   254,   255,   256,   257,   258,    -1,   253,   637,    -1,
-     263,   264,    -1,   266,    -1,   268,   269,   270,   271,   272,
-      -1,    15,    -1,   695,    -1,   697,    20,    -1,    -1,    -1,
-      -1,    25,    26,   286,    -1,    -1,   708,    -1,   291,    33,
-      -1,    35,   295,   296,    -1,   298,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   728,    51,   730,   731,
-      -1,    -1,    -1,    -1,    -1,    -1,   738,    -1,    -1,    -1,
-     323,    -1,    -1,    -1,   327,    -1,    -1,    -1,    -1,    -1,
-      74,    75,    76,   336,    78,    -1,    80,   759,    -1,    -1,
-      -1,    -1,    -1,    87,    -1,   767,   349,    -1,    92,    -1,
-      -1,    -1,   774,    -1,    -1,   777,    -1,    -1,   780,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   379,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   387,    -1,    -1,   390,    -1,   392,
-     393,    -1,    -1,    -1,    -1,    -1,    -1,    84,    -1,    -1,
-     403,    -1,   405,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,    -1,   416,   417,   418,    -1,    -1,    -1,    -1,
-      -1,   424,   425,   426,   427,    -1,    -1,   430,    -1,   432,
-     433,    -1,    -1,    -1,    -1,   438,   439,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    -1,    24,
-      25,    26,    27,    28,    29,    30,   459,   460,   461,   462,
-      -1,    -1,    -1,    -1,    -1,    62,    63,    -1,    -1,    -1,
-      -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   482,
-      -1,   484,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   492,
-      -1,    -1,    -1,    -1,    -1,    -1,   499,   500,   501,    74,
-      -1,    76,   505,    78,    -1,    80,    -1,   510,   105,    -1,
-     513,    -1,   515,   516,   517,   518,    -1,   520,   521,   522,
-      -1,    -1,   525,   526,   527,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   538,    -1,    -1,    -1,    -1,
-     543,    -1,    -1,   546,   547,   548,   549,   550,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,   155,    51,
-      52,    53,    54,    -1,   567,    -1,    -1,   254,   571,   256,
-     257,    -1,    64,    65,    -1,   578,   263,    69,    -1,     7,
-       8,     9,    10,    11,    12,    13,    -1,   590,    -1,    -1,
-      -1,    -1,    20,    85,    -1,    -1,   599,    25,    26,   196,
-     197,    -1,    -1,    -1,   201,    97,    -1,    35,   205,    -1,
-      -1,    -1,   615,   616,   617,   618,   619,    -1,   621,    -1,
-      -1,    -1,   625,   626,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   635,    61,   637,   638,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    72,    73,    -1,   650,   651,   336,
-      -1,    79,    -1,    -1,    -1,    -1,    84,    -1,   661,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   670,   671,    -1,
-      -1,   674,    -1,   676,   677,   678,   679,   680,   681,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   691,    -1,
-      -1,   694,    -1,    -1,    -1,    -1,    -1,    -1,   295,    -1,
-      -1,    -1,   705,    -1,    -1,    -1,   709,   710,    -1,   712,
-      -1,    -1,   715,   716,    -1,   718,   403,    -1,   405,   406,
-      -1,   408,   409,   410,   411,   412,   323,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   739,   424,   425,   426,
-     427,    -1,    -1,    15,    -1,    -1,    -1,   750,    20,   752,
-      -1,    -1,    -1,    25,    26,    -1,    -1,   760,   761,   762,
-      -1,    -1,    -1,    35,    -1,   768,    -1,    -1,    -1,    -1,
-      -1,    -1,   775,    -1,    -1,    -1,    -1,    -1,    -1,    51,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    15,
-      -1,    -1,    -1,    -1,    20,   482,    -1,    -1,    -1,    25,
-      26,    -1,    74,    -1,    76,    77,    78,    -1,    80,    35,
-      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,   505,    -1,
-      92,    -1,    -1,   510,    -1,    51,   513,    -1,    -1,   516,
-     517,    -1,    -1,   430,   521,   522,   433,    -1,   525,   526,
-     527,    -1,   439,    -1,    -1,    -1,    -1,    -1,    74,    -1,
-      76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,   459,   460,    90,    -1,    92,    -1,    -1,     6,
-       7,    -1,     9,    10,    11,    12,    13,    -1,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   500,   501,    -1,    15,    -1,    -1,    46,
-      -1,    20,    -1,    -1,    -1,    -1,    25,    26,    -1,    56,
-      57,    -1,    59,    -1,    61,    -1,    35,    -1,   615,   616,
-     617,   618,   619,    70,    71,    72,    -1,    74,    -1,    76,
-      -1,    78,    51,    80,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    92,    -1,    -1,    95,    -1,
-      -1,    -1,    -1,    -1,    -1,    74,    -1,    76,    -1,    78,
-     567,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
-      -1,   578,    -1,    92,   671,    -1,    -1,    -1,    -1,   676,
-     677,   678,   679,   680,   681,     9,    10,    11,    12,    13,
-      -1,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,   710,    -1,   712,    -1,    -1,   715,   716,
-      -1,   718,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    56,    57,    -1,    59,    -1,    61,    -1,    -1,
-      -1,    -1,    -1,   650,   651,    -1,    70,    71,    72,    -1,
-      74,    -1,    76,   750,    78,   752,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   761,   762,    -1,    -1,    92,    -1,
-      -1,    95,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    -1,    59,    -1,    61,    -1,
-      -1,    64,    65,    66,    -1,    -1,    69,    70,    71,    72,
-      -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
-      83,    84,    85,    -1,    -1,    -1,    -1,    -1,    -1,    92,
-      -1,    -1,    -1,    -1,    97,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
-      -1,    61,    -1,    -1,    64,    65,    66,    -1,    -1,    69,
-      70,    71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,
-      80,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    92,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    -1,    59,    -1,    61,
-      -1,    -1,    64,    65,    66,    -1,    -1,    69,    70,    71,
-      72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      92,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,
+       2,     3,    88,    54,    62,    63,    62,    63,   206,   207,
+     208,   209,     8,     9,    38,    32,    63,    34,    44,     1,
+      59,    29,   196,   197,   539,   198,   117,   414,   154,    31,
+      58,   620,   551,    33,     8,   624,    38,     8,     8,    41,
+      33,    41,     8,    43,    25,     8,    78,   105,    41,    15,
+      43,    80,    31,    25,    20,    69,   432,    86,    60,    25,
+      26,   112,    44,    16,   115,    64,    65,    46,    82,    35,
+      25,    16,    25,    26,    33,    33,    77,    25,    25,    80,
+      25,    26,    41,    41,    80,    51,    85,    83,    88,    43,
+      86,    25,   120,    75,   133,    88,   113,   155,    79,   155,
+       7,     8,     9,    10,    11,    12,    13,    81,    74,    80,
+      76,    81,    78,    20,    80,   117,   124,    80,    25,    26,
+     246,    87,   248,   499,    79,    78,    92,    74,    35,    88,
+      88,    79,   156,    79,    88,    69,   725,    38,   196,   197,
+      74,   169,    88,   201,    78,   201,    25,   205,    36,   205,
+      34,    39,    38,   161,    61,   157,    25,    20,    34,     0,
+     162,    41,    25,   550,    44,    72,    73,    41,   254,   255,
+      15,   210,   687,   692,   689,    20,    38,    84,    40,    80,
+      25,    26,    44,   269,    46,    47,   272,    49,    50,    34,
+      35,   219,   220,   221,    77,    74,    80,    81,    81,    78,
+      88,    77,    88,     8,    25,    74,    51,   298,    88,    43,
+      15,    33,    36,    41,    88,    20,    38,    38,    40,    41,
+      25,    26,    44,   225,    46,    47,    88,    49,    50,    74,
+      35,    76,    77,    78,    38,    80,    31,   295,   753,   290,
+      64,    65,    87,    25,    43,   227,    51,    92,   287,    38,
+     336,    46,    43,    74,    88,    25,    38,   259,    74,    25,
+      88,    85,    78,    78,    80,   323,    88,   323,    38,    74,
+     266,    76,    38,    78,    69,    80,    80,   294,    75,    74,
+      25,    76,    87,   285,    81,   459,   460,    92,   461,    88,
+      31,    80,    74,    38,    31,    25,   298,    88,    25,    39,
+      75,   387,    39,    25,   390,    46,   392,   393,    38,    46,
+      77,    38,    39,    88,    81,    79,    38,    25,    75,   327,
+     322,    25,   324,    60,    88,    25,   328,   329,   330,    28,
+      38,    88,   418,    74,    38,    76,    25,    74,    38,    76,
+      36,    69,   344,    39,    25,    25,   348,    25,   350,    38,
+      25,    25,    25,   379,   356,    25,   358,    38,    38,    38,
+      38,    79,    79,    38,    38,    38,    25,    25,    38,    25,
+      88,    88,   430,     8,   430,   433,    25,   433,    80,    38,
+      38,   439,    38,   439,    33,    80,    88,    80,     3,     4,
+       5,    38,   439,    88,   445,    88,   482,   379,   484,   407,
+      46,   459,   460,    20,    40,    41,    42,    53,    25,    80,
+       7,     8,     9,    10,    11,    12,    13,    88,   414,    46,
+      75,    75,    79,    20,    81,    75,    81,    81,    25,    26,
+     516,    81,   518,   435,    75,   521,   460,    79,    35,    81,
+      81,    32,   500,   501,   500,   501,    47,    48,    49,    50,
+      51,    52,    53,    54,    20,    43,    44,    45,   460,    25,
+     546,   547,   548,   549,    61,   467,    75,    34,   470,    93,
+      94,    38,    81,    20,    15,    72,    73,    32,    25,    20,
+      80,    81,    79,    20,    25,    26,   488,    84,    25,   491,
+      80,    81,    33,    63,    35,   211,   212,   213,   214,   215,
+     216,   217,   218,   222,   223,   224,     8,     9,   706,   567,
+      51,   567,    10,    11,    79,    79,    81,    81,    38,    75,
+     578,    75,   578,    75,    75,    75,    75,    75,    38,    75,
+      75,    75,    75,    74,    75,    76,    75,    78,    38,    80,
+      75,    75,    15,    75,    75,    75,    87,    20,    67,    33,
+      92,    92,    25,    26,   550,   572,    96,    43,    41,   757,
+      33,    38,    35,    15,    81,    80,    80,    37,    20,    82,
+      38,    38,    32,    25,    26,    38,    77,   579,    51,   581,
+      85,    46,    75,    35,   670,    34,    92,   589,   674,   591,
+      46,    88,   650,   651,   650,   651,    14,    34,   649,    51,
+      81,    74,    75,    76,    34,    78,    14,    80,   694,    75,
+      36,    38,    34,    77,    87,    68,    77,    75,    80,    92,
+      77,    80,    74,    75,    76,    80,    78,    38,    80,    80,
+      77,    79,    82,    34,    80,    87,    80,   639,   640,   641,
+      92,    80,    34,   645,    80,    34,    34,    38,   650,   651,
+      34,    58,    81,    38,    34,    38,    38,    38,   660,    33,
+      39,    39,    38,    79,    77,    38,    81,    38,    38,     1,
+       2,    75,   538,     5,     6,     7,     8,     9,    10,    11,
+     621,   625,   267,   418,   626,   628,   298,   286,   578,   227,
+     642,   440,   705,   695,   403,   697,   291,    29,    30,    15,
+     637,    -1,   255,    35,    20,    -1,   708,    39,    40,    25,
+      26,    -1,    44,    -1,    -1,    -1,    -1,   253,    -1,    35,
+      -1,    -1,    -1,    -1,    -1,    57,   728,    -1,   730,   731,
+      62,    63,    -1,    -1,    -1,    51,   738,    -1,    -1,    -1,
+      -1,    -1,    -1,    75,    -1,    -1,    -1,    -1,    80,    -1,
+      -1,    83,    84,    -1,    86,    -1,    88,   759,    74,    -1,
+      76,    77,    78,    -1,    80,   767,    -1,    -1,    -1,    -1,
+      -1,    87,   774,   105,   106,   777,    92,    -1,   780,    -1,
+      -1,   783,   114,    -1,   786,   117,    -1,   789,    -1,    -1,
+     792,    -1,   124,   795,    -1,    -1,   798,    -1,    -1,   801,
+      -1,    -1,   804,    -1,    -1,   807,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    15,    -1,   149,   150,    -1,
+      20,   153,   154,   155,    -1,    25,    26,    -1,    -1,   161,
+      -1,   163,    -1,    -1,    -1,    35,     8,    -1,    -1,    -1,
+      -1,    -1,    -1,    15,    16,    17,    18,    19,    20,    21,
+      22,    51,    24,    25,    26,    27,    28,    29,    30,    -1,
+      -1,    33,    -1,    -1,   196,   197,   198,   199,    -1,   201,
+      -1,    -1,    -1,   205,    74,    -1,    76,    -1,    78,    -1,
+      80,    -1,    -1,    15,    -1,    -1,    -1,    87,    20,    -1,
+      90,    -1,    92,    25,    26,   227,   228,    -1,    -1,    -1,
+      -1,    -1,    74,    35,    76,    -1,    78,    -1,    80,    -1,
+      -1,    -1,    -1,    -1,   246,    -1,   248,    -1,    -1,    51,
+     252,   253,   254,   255,   256,   257,   258,    -1,    -1,    -1,
+      -1,   263,   264,    -1,   266,    -1,   268,   269,   270,   271,
+     272,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
+      -1,    -1,    -1,    -1,   286,    87,    -1,    -1,    -1,   291,
+      92,    -1,    -1,   295,   296,    -1,   298,    -1,     9,    10,
+      11,    12,    13,    -1,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,   323,    -1,    -1,    -1,   327,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   336,    46,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    56,    57,   349,    59,    -1,
+      61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,    -1,    -1,
+      -1,    92,    -1,    -1,    95,   387,    -1,    -1,   390,    -1,
+     392,   393,    -1,    -1,    -1,    -1,    -1,    -1,    84,    -1,
+      -1,   403,    -1,   405,   406,   407,   408,   409,   410,   411,
+     412,    -1,   414,    -1,   416,   417,   418,    -1,    -1,    -1,
+      -1,    -1,   424,   425,   426,   427,    -1,    -1,   430,    -1,
+     432,   433,    -1,    -1,    -1,    -1,   438,   439,    -1,    -1,
+      -1,    15,    16,    17,    18,    19,    20,    21,    22,    -1,
+      24,    25,    26,    27,    28,    29,    30,   459,   460,   461,
+     462,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,
-      -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,    73,
-      74,    -1,    76,    -1,    78,    79,    80,    -1,    -1,    83,
-      84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    -1,    -1,    34,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,
-      46,    -1,    -1,    -1,    -1,    -1,    -1,    15,    -1,    55,
-      56,    57,    20,    59,    -1,    61,    -1,    25,    26,    -1,
-      66,    -1,    -1,    -1,    70,    71,    72,    35,    74,    -1,
-      76,    -1,    78,    -1,    80,    -1,    -1,    83,    84,    -1,
-      -1,    -1,    -1,    51,    -1,    -1,    92,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    -1,    -1,    74,    -1,    76,    -1,
-      78,    -1,    80,    -1,    42,    -1,    -1,    -1,    46,    87,
-      -1,    -1,    -1,    -1,    92,    15,    -1,    55,    56,    57,
-      20,    59,    -1,    61,    -1,    25,    26,    -1,    66,    -1,
-      -1,    -1,    70,    71,    72,    35,    74,    -1,    76,    77,
-      78,    -1,    80,    -1,    -1,    83,    84,    -1,    -1,    -1,
-      -1,    51,    -1,    -1,    92,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    -1,    74,    -1,    76,    -1,    78,    -1,
-      80,    -1,    42,    -1,    -1,    -1,    46,    87,    -1,    -1,
-      -1,    -1,    92,    15,    -1,    55,    56,    57,    20,    59,
-      -1,    61,    -1,    25,    26,    -1,    66,    -1,    -1,    -1,
-      70,    71,    72,    35,    74,    -1,    76,    77,    78,    -1,
-      80,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    51,
-      -1,    -1,    92,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      -1,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      42,    -1,    -1,    -1,    46,    87,    -1,    -1,    -1,    -1,
-      92,    -1,    -1,    55,    56,    57,    -1,    59,    -1,    61,
-      -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,
-      72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      92,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,
-      -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,
-      -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,    -1,
-      74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,    83,
-      84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,
-      46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,
-      56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,
-      66,    -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,
-      76,    -1,    78,    -1,    80,    -1,    -1,    83,    84,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,
-      -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,
-      -1,    -1,    70,    71,    72,    -1,    74,    75,    76,    -1,
-      78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    55,    56,    57,    -1,    59,
-      -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,
-      70,    71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    92,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+     482,    -1,   484,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     492,    -1,    -1,    -1,    -1,    -1,    -1,   499,   500,   501,
+      74,    -1,    76,   505,    78,    -1,    80,    -1,   510,    -1,
+      -1,   513,    -1,   515,   516,   517,   518,    -1,   520,   521,
+     522,    -1,    15,   525,   526,   527,    -1,    20,    -1,    -1,
+      -1,    -1,    25,    26,    -1,    -1,   538,    -1,    -1,    -1,
+      -1,   543,    35,    -1,   546,   547,   548,   549,   550,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,
+      -1,    -1,    -1,    -1,    -1,   567,    -1,    -1,   254,   571,
+     256,   257,    -1,    -1,    -1,    -1,   578,   263,    -1,    -1,
+      -1,    74,    -1,    76,    -1,    78,    -1,    80,   590,    -1,
+      -1,    -1,    -1,    -1,    87,    -1,    -1,   599,    -1,    92,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    56,    57,    -1,    59,    -1,    61,
-      -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,
-      72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      92,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,
-      -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    56,    57,    -1,    59,    -1,    61,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    -1,
-      74,    75,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,
-      46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,
-      76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,
+      -1,    -1,    -1,   615,   616,   617,   618,   619,    -1,   621,
+      -1,    15,    -1,   625,   626,    -1,    20,    -1,    -1,    -1,
+      -1,    25,    26,   635,    -1,   637,   638,    -1,    -1,    -1,
+      -1,    35,    -1,    -1,    -1,    -1,    -1,    -1,   650,   651,
+     336,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,   661,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   670,   671,
+      -1,    -1,   674,    -1,   676,   677,   678,   679,   680,   681,
+      74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,   691,
+      -1,    -1,   694,    87,    -1,    -1,    -1,    -1,    92,    -1,
+      -1,    -1,    -1,   705,    -1,    -1,    -1,   709,   710,    -1,
+     712,    -1,    -1,   715,   716,    -1,   718,   403,    -1,   405,
+     406,    -1,   408,   409,   410,   411,   412,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   739,   424,   425,
+     426,   427,    -1,    -1,    15,    -1,    -1,    -1,   750,    20,
+     752,    -1,    -1,    -1,    25,    26,    -1,    -1,   760,   761,
+     762,    -1,    -1,    -1,    35,    -1,   768,    -1,    -1,    -1,
+      -1,    -1,    -1,   775,    -1,    -1,   778,    -1,    -1,   781,
+      51,    -1,   784,    -1,    -1,   787,    -1,    -1,   790,    -1,
+      -1,   793,    -1,    -1,   796,    -1,   482,   799,    -1,    -1,
+     802,    -1,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
+      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,   505,
+      -1,    92,    -1,    -1,   510,    -1,    -1,   513,    -1,    -1,
+     516,   517,    -1,    -1,    -1,   521,   522,    -1,    -1,   525,
+     526,   527,    -1,    -1,    -1,    -1,    -1,    -1,     6,     7,
+      -1,     9,    10,    11,    12,    13,    -1,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,
+      15,    16,    17,    18,    19,    20,    21,    22,    46,    24,
+      25,    26,    27,    28,    29,    30,    -1,    -1,    56,    57,
       -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    -1,    74,    -1,    76,    -1,
-      78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
-      -1,    -1,    62,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    -1,    -1,    74,    -1,    76,    -1,    78,    -1,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    92,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-       8,    -1,    -1,    -1,    46,    -1,    -1,    15,    16,    17,
-      18,    19,    20,    21,    22,    57,    24,    25,    26,    27,
-      28,    29,    30,    -1,    -1,    33,    -1,    -1,    70,    71,
-      -1,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
-      92,    24,    25,    26,    27,    28,    29,    30,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    74,    -1,    76,    -1,
-      78,    -1,    80,    46,    15,    16,    17,    18,    19,    20,
-      21,    22,    -1,    24,    25,    26,    27,    28,    29,    30,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    46,    70,    71,    72,    -1,    74,    -1,    76,    -1,
+      78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,   615,
+     616,   617,   618,   619,    92,    -1,    -1,    95,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    42,    -1,   671,    -1,    46,    -1,    -1,
+     676,   677,   678,   679,   680,   681,    -1,    56,    57,    -1,
+      59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,
+      -1,    70,    71,    72,    -1,    74,    75,    76,    -1,    78,
+      -1,    80,    -1,    -1,   710,    -1,   712,    -1,    -1,   715,
+     716,    -1,   718,    92,    -1,    15,    16,    17,    18,    19,
+      20,    21,    22,    -1,    24,    25,    26,    27,    28,    29,
+      30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   750,    -1,   752,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   761,   762,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    74,    -1,    76,    -1,    78,    -1,
+      80,    -1,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      -1,    59,    -1,    61,    -1,    -1,    64,    65,    66,    -1,
+      -1,    69,    70,    71,    72,    -1,    74,    -1,    76,    -1,
+      78,    -1,    80,    -1,    -1,    83,    84,    85,    -1,    -1,
+      -1,    -1,    -1,    -1,    92,    -1,    -1,    -1,    -1,    97,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    64,
+      65,    66,    -1,    -1,    69,    70,    71,    72,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    -1,    -1,    83,    84,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    -1,    59,    -1,    61,    -1,    -1,    64,    65,    66,
+      -1,    -1,    69,    70,    71,    72,    -1,    74,    -1,    76,
+      -1,    78,    -1,    80,    -1,    -1,    83,    84,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    55,    56,    57,    -1,
+      59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,
+      -1,    70,    71,    72,    73,    74,    -1,    76,    -1,    78,
+      79,    80,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    92,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    55,    56,    57,    -1,    59,    -1,
+      61,    -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    70,
+      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
+      -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    92,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
+      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,
+      -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,
+      -1,    74,    -1,    76,    77,    78,    -1,    80,    -1,    -1,
+      83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,
+      -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,
+      -1,    66,    -1,    -1,    -1,    70,    71,    72,    -1,    74,
+      -1,    76,    77,    78,    -1,    80,    -1,    -1,    83,    84,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    46,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    56,
+      57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    66,
+      -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,    76,
+      -1,    78,    -1,    80,    -1,    -1,    83,    84,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    55,    56,    57,    -1,
+      59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,
+      -1,    70,    71,    72,    -1,    74,    -1,    76,    -1,    78,
+      -1,    80,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    92,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    55,    56,    57,    -1,    59,    -1,
+      61,    -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    70,
+      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
+      -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    92,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
+      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,
+      -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,
       -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,
+      -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,
+      -1,    66,    -1,    -1,    -1,    70,    71,    72,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    46,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,
+      57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    72,    -1,    74,    75,    76,
+      -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,    -1,
+      59,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    70,    71,    72,    -1,    74,    -1,    76,    -1,    78,
+      -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    92,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    56,    57,    -1,    59,    -1,
+      61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    92,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    74,    -1,    76,    -1,    78,    -1,    80
+      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    62,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    -1,
+      -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
+      -1,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    46,    51,    52,    53,    54,    -1,    -1,    -1,    -1,
+      -1,    -1,    57,    -1,    -1,    64,    65,    -1,    -1,    -1,
+      69,    -1,    -1,    -1,    -1,    70,    71,    -1,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    85,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    97
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1922,7 +1955,9 @@ static const yytype_uint8 yystos[] =
       43,    80,    41,   112,   123,   123,   123,    81,   123,    38,
      179,    38,    38,   170,   170,   124,   123,    38,   179,   170,
      170,    79,    80,   123,    38,   179,   123,    38,   179,   123,
-      38,   123
+      38,   179,   123,    38,   179,   123,    38,   179,   123,    38,
+     179,   123,    38,   179,   123,    38,   179,   123,    38,   179,
+     123,    38,   179,   123,    38,   179,   123,    38,   123
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
@@ -1931,39 +1966,40 @@ static const yytype_uint8 yyr1[] =
        0,    98,    99,    99,    99,    99,   100,   100,   100,   101,
      101,   101,   102,   102,   102,   102,   102,   102,   102,   102,
      102,   102,   102,   102,   102,   102,   102,   102,   102,   102,
-     102,   103,   104,   105,   105,   106,   106,   107,   108,   109,
-     109,   109,   109,   109,   109,   109,   109,   110,   110,   111,
-     112,   112,   113,   114,   114,   114,   114,   115,   115,   116,
-     117,   117,   118,   118,   119,   119,   120,   120,   120,   120,
+     102,   102,   102,   102,   102,   102,   102,   102,   102,   102,
+     103,   104,   105,   105,   106,   106,   107,   108,   109,   109,
+     109,   109,   109,   109,   109,   109,   110,   110,   111,   112,
+     112,   113,   114,   114,   114,   114,   115,   115,   116,   117,
+     117,   118,   118,   119,   119,   120,   120,   120,   120,   120,
      120,   120,   120,   120,   120,   120,   120,   120,   120,   120,
-     120,   120,   120,   120,   120,   121,   121,   122,   122,   123,
-     123,   123,   123,   124,   124,   124,   124,   124,   124,   125,
-     125,   126,   126,   126,   126,   126,   126,   126,   126,   126,
-     127,   127,   127,   127,   127,   128,   128,   128,   128,   129,
-     129,   129,   129,   129,   129,   129,   129,   129,   130,   130,
-     131,   132,   132,   133,   133,   134,   134,   135,   135,   136,
-     136,   137,   137,   137,   137,   137,   137,   137,   137,   137,
+     120,   120,   120,   120,   121,   121,   122,   122,   123,   123,
+     123,   123,   124,   124,   124,   124,   124,   124,   125,   125,
+     126,   126,   126,   126,   126,   126,   126,   126,   126,   127,
+     127,   127,   127,   127,   128,   128,   128,   128,   129,   129,
+     129,   129,   129,   129,   129,   129,   129,   130,   130,   131,
+     132,   132,   133,   133,   134,   134,   135,   135,   136,   136,
      137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
      137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
      137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
      137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
-     137,   137,   137,   137,   137,   137,   137,   137,   138,   138,
-     139,   140,   140,   141,   142,   142,   143,   143,   144,   144,
-     144,   145,   145,   146,   146,   147,   147,   148,   148,   149,
-     149,   150,   150,   150,   150,   150,   150,   150,   150,   150,
+     137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
+     137,   137,   137,   137,   137,   137,   137,   138,   138,   139,
+     140,   140,   141,   142,   142,   143,   143,   144,   144,   144,
+     145,   145,   146,   146,   147,   147,   148,   148,   149,   149,
+     150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
      150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
-     150,   150,   150,   150,   150,   151,   151,   151,   151,   151,
-     152,   153,   153,   154,   154,   155,   155,   156,   157,   157,
-     157,   158,   158,   158,   158,   158,   158,   158,   158,   158,
-     158,   158,   158,   158,   158,   158,   159,   159,   159,   159,
-     160,   160,   161,   161,   161,   162,   162,   162,   163,   163,
-     164,   165,   165,   166,   166,   166,   166,   166,   166,   166,
+     150,   150,   150,   150,   151,   151,   151,   151,   151,   152,
+     153,   153,   154,   154,   155,   155,   156,   157,   157,   157,
+     158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
+     158,   158,   158,   158,   158,   159,   159,   159,   159,   160,
+     160,   161,   161,   161,   162,   162,   162,   163,   163,   164,
+     165,   165,   166,   166,   166,   166,   166,   166,   166,   166,
      166,   166,   166,   166,   166,   166,   166,   166,   166,   166,
-     166,   166,   166,   166,   167,   167,   168,   168,   169,   169,
-     169,   170,   170,   170,   170,   170,   170,   170,   170,   170,
-     170,   170,   170,   170,   170,   170,   170,   170,   170,   171,
-     171,   172,   172,   173,   173,   174,   174,   175,   175,   176,
-     176,   177,   177,   178,   178,   178,   178,   179
+     166,   166,   166,   167,   167,   168,   168,   169,   169,   169,
+     170,   170,   170,   170,   170,   170,   170,   170,   170,   170,
+     170,   170,   170,   170,   170,   170,   170,   170,   171,   171,
+     172,   172,   173,   173,   174,   174,   175,   175,   176,   176,
+     177,   177,   178,   178,   178,   178,   179
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -1972,39 +2008,40 @@ static const yytype_int8 yyr2[] =
        0,     2,     2,     4,     2,     2,     3,     4,     1,     0,
        1,     2,     1,     1,     1,     1,     1,     1,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-       1,     2,     3,     2,     2,     4,     4,     3,     3,     5,
-       7,     7,     9,     3,     5,     5,     7,     1,     3,     3,
-       1,     2,     2,     3,     5,     5,     7,     1,     2,     2,
-       1,     3,     1,     2,     1,     3,     1,     1,     1,     1,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,     1,
+       2,     3,     2,     2,     4,     4,     3,     3,     5,     7,
+       7,     9,     3,     5,     5,     7,     1,     3,     3,     1,
+       2,     2,     3,     5,     5,     7,     1,     2,     2,     1,
+       3,     1,     2,     1,     3,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     2,     1,     2,     4,
-       4,     3,     1,     2,     3,     3,     3,     3,     1,     6,
-       1,     3,     3,     3,     3,     3,     3,     3,     3,     1,
-       3,     3,     3,     2,     1,     3,     3,     3,     1,     1,
-       4,     5,     4,     3,     4,     4,     6,     3,     3,     1,
-       3,     2,     1,     4,     2,     3,     1,     5,     3,     3,
-       1,     4,     1,     5,     4,     5,     3,     4,     4,     6,
-       5,     5,     5,     5,     3,     6,     8,     3,     4,     2,
-       1,     1,     2,     6,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     3,     3,
+       1,     1,     1,     1,     1,     2,     1,     2,     4,     4,
+       3,     1,     2,     3,     3,     3,     3,     1,     6,     1,
+       3,     3,     3,     3,     3,     3,     3,     3,     1,     3,
+       3,     3,     2,     1,     3,     3,     3,     1,     1,     4,
+       5,     4,     3,     4,     4,     6,     3,     3,     1,     3,
+       2,     1,     4,     2,     3,     1,     5,     3,     3,     1,
+       4,     1,     5,     4,     5,     3,     4,     4,     6,     5,
+       5,     5,     5,     3,     6,     8,     3,     4,     2,     1,
+       1,     2,     6,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     3,     3,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     2,     1,
-       3,     3,     1,     4,     2,     0,     3,     1,     1,     1,
-       1,     1,     2,     2,     1,     2,     1,     4,     6,     2,
+       3,     3,     3,     3,     3,     3,     3,     2,     1,     3,
+       3,     1,     4,     2,     0,     3,     1,     1,     1,     1,
+       1,     2,     2,     1,     2,     1,     4,     6,     2,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     3,     4,     3,     5,     5,
-       3,     4,     3,     4,     1,     1,     3,     4,     3,     4,
-       1,     1,     0,     3,     1,     3,     1,     3,     0,     3,
-       5,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     3,     2,     2,     1,
-       1,     3,     3,     5,     5,     0,     1,     3,     3,     1,
-       3,     1,     3,     2,     3,     3,     3,     7,     9,     7,
-       7,     9,     7,     5,     5,     5,     5,     7,     7,     9,
-       9,     7,     7,     5,     1,     2,     2,     1,     3,     1,
-       1,     1,     3,     2,     3,     7,     3,     3,     3,     3,
-       2,     1,     1,     4,     3,     3,     4,     1,     3,     1,
-       1,     1,     3,     1,     5,     1,     3,     1,     3,     3,
-       3,     5,     3,     5,     3,     3,     1,     1
+       1,     1,     1,     1,     3,     4,     3,     5,     5,     3,
+       4,     3,     4,     1,     1,     3,     4,     3,     4,     1,
+       1,     0,     3,     1,     3,     1,     3,     0,     3,     5,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     3,     2,     2,     1,     1,
+       3,     3,     5,     5,     0,     1,     3,     3,     1,     3,
+       1,     3,     2,     3,     3,     3,     7,     9,     7,     7,
+       9,     7,     5,     5,     5,     5,     7,     7,     9,     9,
+       7,     7,     5,     1,     2,     2,     1,     3,     1,     1,
+       1,     3,     2,     3,     7,     3,     3,     3,     3,     2,
+       1,     1,     4,     3,     3,     4,     1,     3,     1,     1,
+       1,     3,     1,     5,     1,     3,     1,     3,     3,     3,
+       5,     3,     5,     3,     3,     1,     1
 };
 
 
@@ -2148,8 +2185,8 @@ yy_symbol_value_print (FILE *yyo,
                        yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
 {
   FILE *yyoutput = yyo;
-  YYUSE (yyoutput);
-  YYUSE (yylocationp);
+  YY_USE (yyoutput);
+  YY_USE (yylocationp);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
@@ -2157,7 +2194,7 @@ yy_symbol_value_print (FILE *yyo,
     YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
 # endif
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YYUSE (yykind);
+  YY_USE (yykind);
   YY_IGNORE_MAYBE_UNINITIALIZED_END
 }
 
@@ -2542,14 +2579,14 @@ static void
 yydestruct (const char *yymsg,
             yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
 {
-  YYUSE (yyvaluep);
-  YYUSE (yylocationp);
+  YY_USE (yyvaluep);
+  YY_USE (yylocationp);
   if (!yymsg)
     yymsg = "Deleting";
   YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YYUSE (yykind);
+  YY_USE (yykind);
   YY_IGNORE_MAYBE_UNINITIALIZED_END
 }
 
@@ -2840,737 +2877,791 @@ yyreduce:
   case 2: /* s: "domodule" module  */
 #line 488 "hexpr.y"
                             { yyParsedModule = (yyvsp[0].module);                     }
-#line 2844 "hexpr.parse.C"
+#line 2881 "hexpr.parse.C"
     break;
 
   case 3: /* s: "dodefn" id "=" l0expr  */
 #line 489 "hexpr.y"
                             { yyParsedVar    = *(yyvsp[-2].string); yyParsedExpr = (yyvsp[0].exp); }
-#line 2850 "hexpr.parse.C"
+#line 2887 "hexpr.parse.C"
     break;
 
   case 4: /* s: "dodefn" l0expr  */
 #line 490 "hexpr.y"
                             { yyParsedVar    = "";  yyParsedExpr = (yyvsp[0].exp); }
-#line 2856 "hexpr.parse.C"
+#line 2893 "hexpr.parse.C"
     break;
 
   case 5: /* s: "doexpr" l0expr  */
 #line 491 "hexpr.y"
                             { yyParsedExpr   = (yyvsp[0].exp);                     }
-#line 2862 "hexpr.parse.C"
+#line 2899 "hexpr.parse.C"
     break;
 
   case 6: /* module: "option" id module  */
 #line 494 "hexpr.y"
                                  { (yyval.module) = (yyvsp[0].module); (yyval.module)->setOption(*(yyvsp[-1].string), m((yylsp[-2]))); }
-#line 2868 "hexpr.parse.C"
+#line 2905 "hexpr.parse.C"
     break;
 
   case 7: /* module: "module" id "where" defs  */
 #line 495 "hexpr.y"
                                  { (yyval.module) = new Module(*(yyvsp[-2].string), *(yyvsp[0].mdefs)); }
-#line 2874 "hexpr.parse.C"
+#line 2911 "hexpr.parse.C"
     break;
 
   case 8: /* module: defs  */
 #line 496 "hexpr.y"
                                  { (yyval.module) = new Module(freshName(), *(yyvsp[0].mdefs)); }
-#line 2880 "hexpr.parse.C"
+#line 2917 "hexpr.parse.C"
     break;
 
   case 9: /* defs: %empty  */
 #line 498 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); }
-#line 2886 "hexpr.parse.C"
+#line 2923 "hexpr.parse.C"
     break;
 
   case 10: /* defs: def  */
 #line 499 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2892 "hexpr.parse.C"
+#line 2929 "hexpr.parse.C"
     break;
 
   case 11: /* defs: defs def  */
 #line 500 "hexpr.y"
                     { (yyval.mdefs) = (yyvsp[-1].mdefs);                            (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2898 "hexpr.parse.C"
+#line 2935 "hexpr.parse.C"
     break;
 
   case 12: /* def: importdef  */
 #line 502 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2904 "hexpr.parse.C"
+#line 2941 "hexpr.parse.C"
     break;
 
   case 13: /* def: tydef  */
 #line 503 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2910 "hexpr.parse.C"
+#line 2947 "hexpr.parse.C"
     break;
 
   case 14: /* def: vartybind  */
 #line 504 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mvtydef); }
-#line 2916 "hexpr.parse.C"
+#line 2953 "hexpr.parse.C"
     break;
 
   case 15: /* def: classdef  */
 #line 505 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2922 "hexpr.parse.C"
+#line 2959 "hexpr.parse.C"
     break;
 
   case 16: /* def: instdef  */
 #line 506 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2928 "hexpr.parse.C"
+#line 2965 "hexpr.parse.C"
     break;
 
   case 17: /* def: pragmadef  */
 #line 507 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2934 "hexpr.parse.C"
+#line 2971 "hexpr.parse.C"
     break;
 
   case 18: /* def: id "=" l0expr  */
 #line 509 "hexpr.y"
                    { (yyval.mdef) = new MVarDef(list(*(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 2940 "hexpr.parse.C"
+#line 2977 "hexpr.parse.C"
     break;
 
   case 19: /* def: id id "=" l0expr  */
 #line 510 "hexpr.y"
                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 2946 "hexpr.parse.C"
+#line 2983 "hexpr.parse.C"
     break;
 
   case 20: /* def: id id id "=" l0expr  */
 #line 511 "hexpr.y"
                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 2952 "hexpr.parse.C"
+#line 2989 "hexpr.parse.C"
     break;
 
   case 21: /* def: id id id id "=" l0expr  */
 #line 512 "hexpr.y"
                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 2958 "hexpr.parse.C"
+#line 2995 "hexpr.parse.C"
     break;
 
   case 22: /* def: id id id id id "=" l0expr  */
 #line 513 "hexpr.y"
                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-6]), (yylsp[0]))); }
-#line 2964 "hexpr.parse.C"
+#line 3001 "hexpr.parse.C"
     break;
 
   case 23: /* def: id id id id id id "=" l0expr  */
 #line 514 "hexpr.y"
                                   { (yyval.mdef) = new MVarDef(list(*(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 2970 "hexpr.parse.C"
+#line 3007 "hexpr.parse.C"
     break;
 
   case 24: /* def: id id id id id id id "=" l0expr  */
 #line 515 "hexpr.y"
                                      { (yyval.mdef) = new MVarDef(list(*(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-8]), (yylsp[0]))); }
-#line 2976 "hexpr.parse.C"
+#line 3013 "hexpr.parse.C"
     break;
 
   case 25: /* def: id id id id id id id id "=" l0expr  */
 #line 516 "hexpr.y"
                                         { (yyval.mdef) = new MVarDef(list(*(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-9]), (yylsp[0]))); }
-#line 2982 "hexpr.parse.C"
+#line 3019 "hexpr.parse.C"
     break;
 
   case 26: /* def: id id id id id id id id id "=" l0expr  */
 #line 517 "hexpr.y"
                                            { (yyval.mdef) = new MVarDef(list(*(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-10]), (yylsp[0]))); }
-#line 2988 "hexpr.parse.C"
+#line 3025 "hexpr.parse.C"
     break;
 
   case 27: /* def: id id id id id id id id id id "=" l0expr  */
 #line 518 "hexpr.y"
                                               { (yyval.mdef) = new MVarDef(list(*(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-11]), (yylsp[0]))); }
-#line 2994 "hexpr.parse.C"
+#line 3031 "hexpr.parse.C"
     break;
 
   case 28: /* def: id id id id id id id id id id id "=" l0expr  */
 #line 519 "hexpr.y"
                                                  { (yyval.mdef) = new MVarDef(list(*(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-12]), (yylsp[0]))); }
-#line 3000 "hexpr.parse.C"
+#line 3037 "hexpr.parse.C"
     break;
 
   case 29: /* def: id id id id id id id id id id id id "=" l0expr  */
 #line 520 "hexpr.y"
                                                     { (yyval.mdef) = new MVarDef(list(*(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-13]), (yylsp[0]))); }
-#line 3006 "hexpr.parse.C"
+#line 3043 "hexpr.parse.C"
+    break;
+
+  case 30: /* def: id id id id id id id id id id id id id "=" l0expr  */
+#line 521 "hexpr.y"
+                                                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-14]), (yylsp[0]))); }
+#line 3049 "hexpr.parse.C"
+    break;
+
+  case 31: /* def: id id id id id id id id id id id id id id "=" l0expr  */
+#line 522 "hexpr.y"
+                                                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-15]), (yylsp[0]))); }
+#line 3055 "hexpr.parse.C"
     break;
 
-  case 30: /* def: l5expr  */
+  case 32: /* def: id id id id id id id id id id id id id id id "=" l0expr  */
 #line 523 "hexpr.y"
-            { (yyval.mdef) = new MVarDef(list(freshName()), let(freshName(), ExprPtr((yyvsp[0].exp)), mktunit(m((yylsp[0]))), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3012 "hexpr.parse.C"
+                                                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-16]), (yylsp[0]))); }
+#line 3061 "hexpr.parse.C"
     break;
 
-  case 31: /* importdef: "import" cppid  */
+  case 33: /* def: id id id id id id id id id id id id id id id id "=" l0expr  */
+#line 524 "hexpr.y"
+                                                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-17]), (yylsp[0]))); }
+#line 3067 "hexpr.parse.C"
+    break;
+
+  case 34: /* def: id id id id id id id id id id id id id id id id id "=" l0expr  */
+#line 525 "hexpr.y"
+                                                                   { (yyval.mdef) = new MVarDef(list(*(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-18]), (yylsp[0]))); }
+#line 3073 "hexpr.parse.C"
+    break;
+
+  case 35: /* def: id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 526 "hexpr.y"
-                          { (yyval.mdef) = new MImport(yyModulePath, *(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3018 "hexpr.parse.C"
+                                                                      { (yyval.mdef) = new MVarDef(list(*(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-19]), (yylsp[0]))); }
+#line 3079 "hexpr.parse.C"
+    break;
+
+  case 36: /* def: id id id id id id id id id id id id id id id id id id id "=" l0expr  */
+#line 527 "hexpr.y"
+                                                                         { (yyval.mdef) = new MVarDef(list(*(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-20]), (yylsp[0]))); }
+#line 3085 "hexpr.parse.C"
+    break;
+
+  case 37: /* def: id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
+#line 528 "hexpr.y"
+                                                                            { (yyval.mdef) = new MVarDef(list(*(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-21]), (yylsp[0]))); }
+#line 3091 "hexpr.parse.C"
     break;
 
-  case 32: /* pragmadef: "{-#" pragmaty "#-}"  */
+  case 38: /* def: id id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 529 "hexpr.y"
+                                                                               { (yyval.mdef) = new MVarDef(list(*(yyvsp[-22].string), *(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-22]), (yylsp[0]))); }
+#line 3097 "hexpr.parse.C"
+    break;
+
+  case 39: /* def: l5expr  */
+#line 532 "hexpr.y"
+            { (yyval.mdef) = new MVarDef(list(freshName()), let(freshName(), ExprPtr((yyvsp[0].exp)), mktunit(m((yylsp[0]))), m((yylsp[0]))), m((yylsp[0]))); }
+#line 3103 "hexpr.parse.C"
+    break;
+
+  case 40: /* importdef: "import" cppid  */
+#line 535 "hexpr.y"
+                          { (yyval.mdef) = new MImport(yyModulePath, *(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
+#line 3109 "hexpr.parse.C"
+    break;
+
+  case 41: /* pragmadef: "{-#" pragmaty "#-}"  */
+#line 538 "hexpr.y"
                                 { (yyval.mdef) = (yyvsp[-1].mdef); }
-#line 3024 "hexpr.parse.C"
+#line 3115 "hexpr.parse.C"
     break;
 
-  case 33: /* pragmaty: "UNSAFE" id  */
-#line 530 "hexpr.y"
+  case 42: /* pragmaty: "UNSAFE" id  */
+#line 539 "hexpr.y"
                       { (yyval.mdef) = new MUnsafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3030 "hexpr.parse.C"
+#line 3121 "hexpr.parse.C"
     break;
 
-  case 34: /* pragmaty: "SAFE" id  */
-#line 531 "hexpr.y"
+  case 43: /* pragmaty: "SAFE" id  */
+#line 540 "hexpr.y"
                     { (yyval.mdef) = new MSafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3036 "hexpr.parse.C"
+#line 3127 "hexpr.parse.C"
     break;
 
-  case 35: /* tydef: "type" nameseq "=" qtype  */
-#line 534 "hexpr.y"
+  case 44: /* tydef: "type" nameseq "=" qtype  */
+#line 543 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Transparent, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3042 "hexpr.parse.C"
+#line 3133 "hexpr.parse.C"
     break;
 
-  case 36: /* tydef: "data" nameseq "=" qtype  */
-#line 535 "hexpr.y"
+  case 45: /* tydef: "data" nameseq "=" qtype  */
+#line 544 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Opaque, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3048 "hexpr.parse.C"
+#line 3139 "hexpr.parse.C"
     break;
 
-  case 37: /* vartybind: name "::" qtype  */
-#line 538 "hexpr.y"
+  case 46: /* vartybind: name "::" qtype  */
+#line 547 "hexpr.y"
                            { (yyval.mvtydef) = new MVarTypeDef(*(yyvsp[-2].string), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3054 "hexpr.parse.C"
+#line 3145 "hexpr.parse.C"
     break;
 
-  case 38: /* vardef: names "=" l0expr  */
-#line 540 "hexpr.y"
+  case 47: /* vardef: names "=" l0expr  */
+#line 549 "hexpr.y"
                          { (yyval.mvdef) = new MVarDef(*(yyvsp[-2].strings), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3060 "hexpr.parse.C"
+#line 3151 "hexpr.parse.C"
     break;
 
-  case 39: /* classdef: "class" cst "=>" id names  */
-#line 543 "hexpr.y"
+  case 48: /* classdef: "class" cst "=>" id names  */
+#line 552 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-3].tconstraints), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3066 "hexpr.parse.C"
+#line 3157 "hexpr.parse.C"
     break;
 
-  case 40: /* classdef: "class" cst "=>" id names "|" fundeps  */
-#line 544 "hexpr.y"
+  case 49: /* classdef: "class" cst "=>" id names "|" fundeps  */
+#line 553 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-6]), (yylsp[0]))); wantIndent(false); }
-#line 3072 "hexpr.parse.C"
+#line 3163 "hexpr.parse.C"
     break;
 
-  case 41: /* classdef: "class" cst "=>" id names "where" cmembers  */
-#line 545 "hexpr.y"
+  case 50: /* classdef: "class" cst "=>" id names "where" cmembers  */
+#line 554 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3078 "hexpr.parse.C"
+#line 3169 "hexpr.parse.C"
     break;
 
-  case 42: /* classdef: "class" cst "=>" id names "|" fundeps "where" cmembers  */
-#line 546 "hexpr.y"
+  case 51: /* classdef: "class" cst "=>" id names "|" fundeps "where" cmembers  */
+#line 555 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-7].tconstraints), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-8]), (yylsp[0])));            wantIndent(false); }
-#line 3084 "hexpr.parse.C"
+#line 3175 "hexpr.parse.C"
     break;
 
-  case 43: /* classdef: "class" id names  */
-#line 547 "hexpr.y"
+  case 52: /* classdef: "class" id names  */
+#line 556 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3090 "hexpr.parse.C"
+#line 3181 "hexpr.parse.C"
     break;
 
-  case 44: /* classdef: "class" id names "|" fundeps  */
-#line 548 "hexpr.y"
+  case 53: /* classdef: "class" id names "|" fundeps  */
+#line 557 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3096 "hexpr.parse.C"
+#line 3187 "hexpr.parse.C"
     break;
 
-  case 45: /* classdef: "class" id names "where" cmembers  */
-#line 549 "hexpr.y"
+  case 54: /* classdef: "class" id names "where" cmembers  */
+#line 558 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-4]), (yylsp[0])));            wantIndent(false); }
-#line 3102 "hexpr.parse.C"
+#line 3193 "hexpr.parse.C"
     break;
 
-  case 46: /* classdef: "class" id names "|" fundeps "where" cmembers  */
-#line 550 "hexpr.y"
+  case 55: /* classdef: "class" id names "|" fundeps "where" cmembers  */
+#line 559 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3108 "hexpr.parse.C"
+#line 3199 "hexpr.parse.C"
     break;
 
-  case 47: /* fundeps: fundep  */
-#line 552 "hexpr.y"
+  case 56: /* fundeps: fundep  */
+#line 561 "hexpr.y"
                             { (yyval.fundeps) = autorelease(new CFunDepDefs()); (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3114 "hexpr.parse.C"
+#line 3205 "hexpr.parse.C"
     break;
 
-  case 48: /* fundeps: fundeps "," fundep  */
-#line 553 "hexpr.y"
+  case 57: /* fundeps: fundeps "," fundep  */
+#line 562 "hexpr.y"
                             { (yyval.fundeps) = (yyvsp[-2].fundeps);                             (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3120 "hexpr.parse.C"
+#line 3211 "hexpr.parse.C"
     break;
 
-  case 49: /* fundep: idseq "->" idseq  */
-#line 555 "hexpr.y"
+  case 58: /* fundep: idseq "->" idseq  */
+#line 564 "hexpr.y"
                          { (yyval.fundep) = autorelease(new CFunDepDef(*(yyvsp[-2].strings), *(yyvsp[0].strings))); }
-#line 3126 "hexpr.parse.C"
+#line 3217 "hexpr.parse.C"
     break;
 
-  case 50: /* cmembers: cmember  */
-#line 557 "hexpr.y"
+  case 59: /* cmembers: cmember  */
+#line 566 "hexpr.y"
                            { (yyval.mvtydefs) = autorelease(new MVarTypeDefs()); (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3132 "hexpr.parse.C"
+#line 3223 "hexpr.parse.C"
     break;
 
-  case 51: /* cmembers: cmembers cmember  */
-#line 558 "hexpr.y"
+  case 60: /* cmembers: cmembers cmember  */
+#line 567 "hexpr.y"
                            { (yyval.mvtydefs) = (yyvsp[-1].mvtydefs);                              (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3138 "hexpr.parse.C"
+#line 3229 "hexpr.parse.C"
     break;
 
-  case 52: /* cmember: "indent" vartybind  */
-#line 560 "hexpr.y"
+  case 61: /* cmember: "indent" vartybind  */
+#line 569 "hexpr.y"
                             { (yyval.mvtydef) = (yyvsp[0].mvtydef); }
-#line 3144 "hexpr.parse.C"
+#line 3235 "hexpr.parse.C"
     break;
 
-  case 53: /* instdef: "instance" id types  */
-#line 563 "hexpr.y"
+  case 62: /* instdef: "instance" id types  */
+#line 572 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3150 "hexpr.parse.C"
+#line 3241 "hexpr.parse.C"
     break;
 
-  case 54: /* instdef: "instance" cst "=>" id types  */
-#line 564 "hexpr.y"
+  case 63: /* instdef: "instance" cst "=>" id types  */
+#line 573 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-3].tconstraints),           *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3156 "hexpr.parse.C"
+#line 3247 "hexpr.parse.C"
     break;
 
-  case 55: /* instdef: "instance" id types "where" imembers  */
-#line 565 "hexpr.y"
+  case 64: /* instdef: "instance" id types "where" imembers  */
+#line 574 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-4]), (yylsp[0])));        wantIndent(false); }
-#line 3162 "hexpr.parse.C"
+#line 3253 "hexpr.parse.C"
     break;
 
-  case 56: /* instdef: "instance" cst "=>" id types "where" imembers  */
-#line 566 "hexpr.y"
+  case 65: /* instdef: "instance" cst "=>" id types "where" imembers  */
+#line 575 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-5].tconstraints),           *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-6]), (yylsp[0])));        wantIndent(false); }
-#line 3168 "hexpr.parse.C"
+#line 3259 "hexpr.parse.C"
     break;
 
-  case 57: /* imembers: imember  */
-#line 568 "hexpr.y"
+  case 66: /* imembers: imember  */
+#line 577 "hexpr.y"
                            { (yyval.mvdefs) = autorelease(new MVarDefs()); (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3174 "hexpr.parse.C"
+#line 3265 "hexpr.parse.C"
     break;
 
-  case 58: /* imembers: imembers imember  */
-#line 569 "hexpr.y"
+  case 67: /* imembers: imembers imember  */
+#line 578 "hexpr.y"
                            { (yyval.mvdefs) = (yyvsp[-1].mvdefs);                          (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3180 "hexpr.parse.C"
+#line 3271 "hexpr.parse.C"
     break;
 
-  case 59: /* imember: "indent" vardef  */
-#line 571 "hexpr.y"
+  case 68: /* imember: "indent" vardef  */
+#line 580 "hexpr.y"
                          { (yyval.mvdef) = (yyvsp[0].mvdef); }
-#line 3186 "hexpr.parse.C"
+#line 3277 "hexpr.parse.C"
     break;
 
-  case 60: /* names: nameseq  */
-#line 574 "hexpr.y"
+  case 69: /* names: nameseq  */
+#line 583 "hexpr.y"
                { (yyval.strings) = (yyvsp[0].strings); }
-#line 3192 "hexpr.parse.C"
+#line 3283 "hexpr.parse.C"
     break;
 
-  case 61: /* names: id opname id  */
-#line 576 "hexpr.y"
+  case 70: /* names: id opname id  */
+#line 585 "hexpr.y"
                     { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[-1].string)); (yyval.strings)->push_back(*(yyvsp[-2].string)); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3198 "hexpr.parse.C"
+#line 3289 "hexpr.parse.C"
     break;
 
-  case 62: /* nameseq: name  */
-#line 578 "hexpr.y"
+  case 71: /* nameseq: name  */
+#line 587 "hexpr.y"
                       { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3204 "hexpr.parse.C"
+#line 3295 "hexpr.parse.C"
     break;
 
-  case 63: /* nameseq: nameseq name  */
-#line 579 "hexpr.y"
+  case 72: /* nameseq: nameseq name  */
+#line 588 "hexpr.y"
                       { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3210 "hexpr.parse.C"
+#line 3301 "hexpr.parse.C"
     break;
 
-  case 64: /* name: id  */
-#line 581 "hexpr.y"
+  case 73: /* name: id  */
+#line 590 "hexpr.y"
          { (yyval.string) = (yyvsp[0].string); }
-#line 3216 "hexpr.parse.C"
+#line 3307 "hexpr.parse.C"
     break;
 
-  case 65: /* name: "(" opname ")"  */
-#line 583 "hexpr.y"
+  case 74: /* name: "(" opname ")"  */
+#line 592 "hexpr.y"
                      { (yyval.string) = (yyvsp[-1].string); }
-#line 3222 "hexpr.parse.C"
+#line 3313 "hexpr.parse.C"
     break;
 
-  case 66: /* opname: "and"  */
-#line 585 "hexpr.y"
+  case 75: /* opname: "and"  */
+#line 594 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("and")); }
-#line 3228 "hexpr.parse.C"
+#line 3319 "hexpr.parse.C"
     break;
 
-  case 67: /* opname: "or"  */
-#line 586 "hexpr.y"
+  case 76: /* opname: "or"  */
+#line 595 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("or")); }
-#line 3234 "hexpr.parse.C"
+#line 3325 "hexpr.parse.C"
     break;
 
-  case 68: /* opname: "o"  */
-#line 587 "hexpr.y"
+  case 77: /* opname: "o"  */
+#line 596 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3240 "hexpr.parse.C"
+#line 3331 "hexpr.parse.C"
     break;
 
-  case 69: /* opname: "."  */
-#line 588 "hexpr.y"
+  case 78: /* opname: "."  */
+#line 597 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3246 "hexpr.parse.C"
+#line 3337 "hexpr.parse.C"
     break;
 
-  case 70: /* opname: "~"  */
-#line 589 "hexpr.y"
+  case 79: /* opname: "~"  */
+#line 598 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("~")); }
-#line 3252 "hexpr.parse.C"
+#line 3343 "hexpr.parse.C"
     break;
 
-  case 71: /* opname: "=~"  */
-#line 590 "hexpr.y"
+  case 80: /* opname: "=~"  */
+#line 599 "hexpr.y"
                { (yyval.string) = autorelease(new std::string("=~")); }
-#line 3258 "hexpr.parse.C"
+#line 3349 "hexpr.parse.C"
     break;
 
-  case 72: /* opname: "==="  */
-#line 591 "hexpr.y"
+  case 81: /* opname: "==="  */
+#line 600 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("===")); }
-#line 3264 "hexpr.parse.C"
+#line 3355 "hexpr.parse.C"
     break;
 
-  case 73: /* opname: "=="  */
-#line 592 "hexpr.y"
+  case 82: /* opname: "=="  */
+#line 601 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("==")); }
-#line 3270 "hexpr.parse.C"
+#line 3361 "hexpr.parse.C"
     break;
 
-  case 74: /* opname: "<"  */
-#line 593 "hexpr.y"
+  case 83: /* opname: "<"  */
+#line 602 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<")); }
-#line 3276 "hexpr.parse.C"
+#line 3367 "hexpr.parse.C"
     break;
 
-  case 75: /* opname: "<="  */
-#line 594 "hexpr.y"
+  case 84: /* opname: "<="  */
+#line 603 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<=")); }
-#line 3282 "hexpr.parse.C"
+#line 3373 "hexpr.parse.C"
     break;
 
-  case 76: /* opname: ">"  */
-#line 595 "hexpr.y"
+  case 85: /* opname: ">"  */
+#line 604 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">")); }
-#line 3288 "hexpr.parse.C"
+#line 3379 "hexpr.parse.C"
     break;
 
-  case 77: /* opname: ">="  */
-#line 596 "hexpr.y"
+  case 86: /* opname: ">="  */
+#line 605 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">=")); }
-#line 3294 "hexpr.parse.C"
+#line 3385 "hexpr.parse.C"
     break;
 
-  case 78: /* opname: "in"  */
-#line 597 "hexpr.y"
+  case 87: /* opname: "in"  */
+#line 606 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("in")); }
-#line 3300 "hexpr.parse.C"
+#line 3391 "hexpr.parse.C"
     break;
 
-  case 79: /* opname: "++"  */
-#line 598 "hexpr.y"
+  case 88: /* opname: "++"  */
+#line 607 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("append")); }
-#line 3306 "hexpr.parse.C"
+#line 3397 "hexpr.parse.C"
     break;
 
-  case 80: /* opname: "+"  */
-#line 599 "hexpr.y"
+  case 89: /* opname: "+"  */
+#line 608 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("+")); }
-#line 3312 "hexpr.parse.C"
+#line 3403 "hexpr.parse.C"
     break;
 
-  case 81: /* opname: "-"  */
-#line 600 "hexpr.y"
+  case 90: /* opname: "-"  */
+#line 609 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("-")); }
-#line 3318 "hexpr.parse.C"
+#line 3409 "hexpr.parse.C"
     break;
 
-  case 82: /* opname: "*"  */
-#line 601 "hexpr.y"
+  case 91: /* opname: "*"  */
+#line 610 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("*")); }
-#line 3324 "hexpr.parse.C"
+#line 3415 "hexpr.parse.C"
     break;
 
-  case 83: /* opname: "/"  */
-#line 602 "hexpr.y"
+  case 92: /* opname: "/"  */
+#line 611 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("/")); }
-#line 3330 "hexpr.parse.C"
+#line 3421 "hexpr.parse.C"
     break;
 
-  case 84: /* opname: "%"  */
-#line 603 "hexpr.y"
+  case 93: /* opname: "%"  */
+#line 612 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("%")); }
-#line 3336 "hexpr.parse.C"
+#line 3427 "hexpr.parse.C"
     break;
 
-  case 85: /* idseq: id  */
-#line 605 "hexpr.y"
+  case 94: /* idseq: id  */
+#line 614 "hexpr.y"
                 { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3342 "hexpr.parse.C"
+#line 3433 "hexpr.parse.C"
     break;
 
-  case 86: /* idseq: idseq id  */
-#line 606 "hexpr.y"
+  case 95: /* idseq: idseq id  */
+#line 615 "hexpr.y"
                 { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3348 "hexpr.parse.C"
+#line 3439 "hexpr.parse.C"
     break;
 
-  case 87: /* types: l0mtype  */
-#line 608 "hexpr.y"
+  case 96: /* types: l0mtype  */
+#line 617 "hexpr.y"
                      { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3354 "hexpr.parse.C"
+#line 3445 "hexpr.parse.C"
     break;
 
-  case 88: /* types: types l0mtype  */
-#line 609 "hexpr.y"
+  case 97: /* types: types l0mtype  */
+#line 618 "hexpr.y"
                      { (yyval.mtypes) = (yyvsp[-1].mtypes);                           (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3360 "hexpr.parse.C"
+#line 3451 "hexpr.parse.C"
     break;
 
-  case 89: /* l0expr: "\\" patterns "." l0expr  */
-#line 612 "hexpr.y"
+  case 98: /* l0expr: "\\" patterns "." l0expr  */
+#line 621 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3366 "hexpr.parse.C"
+#line 3457 "hexpr.parse.C"
     break;
 
-  case 90: /* l0expr: "fn" patterns "." l0expr  */
-#line 613 "hexpr.y"
+  case 99: /* l0expr: "fn" patterns "." l0expr  */
+#line 622 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3372 "hexpr.parse.C"
+#line 3463 "hexpr.parse.C"
     break;
 
-  case 91: /* l0expr: lhexpr "<-" lhexpr  */
-#line 614 "hexpr.y"
+  case 100: /* l0expr: lhexpr "<-" lhexpr  */
+#line 623 "hexpr.y"
                                  { (yyval.exp) = new Assign(ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3378 "hexpr.parse.C"
+#line 3469 "hexpr.parse.C"
     break;
 
-  case 92: /* l0expr: lhexpr  */
-#line 615 "hexpr.y"
+  case 101: /* l0expr: lhexpr  */
+#line 624 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3384 "hexpr.parse.C"
+#line 3475 "hexpr.parse.C"
     break;
 
-  case 93: /* lhexpr: "!" l1expr  */
-#line 617 "hexpr.y"
+  case 102: /* lhexpr: "!" l1expr  */
+#line 626 "hexpr.y"
                                  { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), (yyvsp[0].exp), m((yylsp[-1]),(yylsp[0]))); }
-#line 3390 "hexpr.parse.C"
+#line 3481 "hexpr.parse.C"
     break;
 
-  case 94: /* lhexpr: lhexpr "and" lhexpr  */
-#line 618 "hexpr.y"
+  case 103: /* lhexpr: lhexpr "and" lhexpr  */
+#line 627 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("and",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3396 "hexpr.parse.C"
+#line 3487 "hexpr.parse.C"
     break;
 
-  case 95: /* lhexpr: lhexpr "or" lhexpr  */
-#line 619 "hexpr.y"
+  case 104: /* lhexpr: lhexpr "or" lhexpr  */
+#line 628 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("or",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3402 "hexpr.parse.C"
+#line 3493 "hexpr.parse.C"
     break;
 
-  case 96: /* lhexpr: lhexpr "o" lhexpr  */
-#line 620 "hexpr.y"
+  case 105: /* lhexpr: lhexpr "o" lhexpr  */
+#line 629 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("compose",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3408 "hexpr.parse.C"
+#line 3499 "hexpr.parse.C"
     break;
 
-  case 97: /* lhexpr: l1expr "in" l1expr  */
-#line 621 "hexpr.y"
+  case 106: /* lhexpr: l1expr "in" l1expr  */
+#line 630 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("in",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3414 "hexpr.parse.C"
+#line 3505 "hexpr.parse.C"
     break;
 
-  case 98: /* lhexpr: l1expr  */
-#line 622 "hexpr.y"
+  case 107: /* lhexpr: l1expr  */
+#line 631 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3420 "hexpr.parse.C"
+#line 3511 "hexpr.parse.C"
     break;
 
-  case 99: /* l1expr: "if" l0expr "then" l0expr "else" l0expr  */
-#line 624 "hexpr.y"
+  case 108: /* l1expr: "if" l0expr "then" l0expr "else" l0expr  */
+#line 633 "hexpr.y"
                                                 { (yyval.exp) = TAPP3(var("if",m((yylsp[-5]))), (yyvsp[-4].exp), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-5]), (yylsp[0]))); }
-#line 3426 "hexpr.parse.C"
+#line 3517 "hexpr.parse.C"
     break;
 
-  case 100: /* l1expr: l2expr  */
-#line 625 "hexpr.y"
+  case 109: /* l1expr: l2expr  */
+#line 634 "hexpr.y"
                                                 { (yyval.exp) = (yyvsp[0].exp); }
-#line 3432 "hexpr.parse.C"
+#line 3523 "hexpr.parse.C"
     break;
 
-  case 101: /* l2expr: l2expr "~" l2expr  */
-#line 627 "hexpr.y"
+  case 110: /* l2expr: l2expr "~" l2expr  */
+#line 636 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("~",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3438 "hexpr.parse.C"
+#line 3529 "hexpr.parse.C"
     break;
 
-  case 102: /* l2expr: l2expr "===" l2expr  */
-#line 628 "hexpr.y"
+  case 111: /* l2expr: l2expr "===" l2expr  */
+#line 637 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("===",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3444 "hexpr.parse.C"
+#line 3535 "hexpr.parse.C"
     break;
 
-  case 103: /* l2expr: l2expr "==" l2expr  */
-#line 629 "hexpr.y"
+  case 112: /* l2expr: l2expr "==" l2expr  */
+#line 638 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3450 "hexpr.parse.C"
+#line 3541 "hexpr.parse.C"
     break;
 
-  case 104: /* l2expr: l2expr "!=" l2expr  */
-#line 630 "hexpr.y"
+  case 113: /* l2expr: l2expr "!=" l2expr  */
+#line 639 "hexpr.y"
                             { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))), m((yylsp[-2]),(yylsp[0]))); }
-#line 3456 "hexpr.parse.C"
+#line 3547 "hexpr.parse.C"
     break;
 
-  case 105: /* l2expr: l2expr "<" l2expr  */
-#line 631 "hexpr.y"
+  case 114: /* l2expr: l2expr "<" l2expr  */
+#line 640 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3462 "hexpr.parse.C"
+#line 3553 "hexpr.parse.C"
     break;
 
-  case 106: /* l2expr: l2expr "<=" l2expr  */
-#line 632 "hexpr.y"
+  case 115: /* l2expr: l2expr "<=" l2expr  */
+#line 641 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3468 "hexpr.parse.C"
+#line 3559 "hexpr.parse.C"
     break;
 
-  case 107: /* l2expr: l2expr ">" l2expr  */
-#line 633 "hexpr.y"
+  case 116: /* l2expr: l2expr ">" l2expr  */
+#line 642 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3474 "hexpr.parse.C"
+#line 3565 "hexpr.parse.C"
     break;
 
-  case 108: /* l2expr: l2expr ">=" l2expr  */
-#line 634 "hexpr.y"
+  case 117: /* l2expr: l2expr ">=" l2expr  */
+#line 643 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3480 "hexpr.parse.C"
+#line 3571 "hexpr.parse.C"
     break;
 
-  case 109: /* l2expr: l3expr  */
-#line 635 "hexpr.y"
+  case 118: /* l2expr: l3expr  */
+#line 644 "hexpr.y"
                             { (yyval.exp) = (yyvsp[0].exp); }
-#line 3486 "hexpr.parse.C"
+#line 3577 "hexpr.parse.C"
     break;
 
-  case 110: /* l3expr: l3expr "+" l3expr  */
-#line 637 "hexpr.y"
+  case 119: /* l3expr: l3expr "+" l3expr  */
+#line 646 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("+",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3492 "hexpr.parse.C"
+#line 3583 "hexpr.parse.C"
     break;
 
-  case 111: /* l3expr: l3expr "-" l3expr  */
-#line 638 "hexpr.y"
+  case 120: /* l3expr: l3expr "-" l3expr  */
+#line 647 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("-",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3498 "hexpr.parse.C"
+#line 3589 "hexpr.parse.C"
     break;
 
-  case 112: /* l3expr: l3expr "++" l3expr  */
-#line 639 "hexpr.y"
+  case 121: /* l3expr: l3expr "++" l3expr  */
+#line 648 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("append",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3504 "hexpr.parse.C"
+#line 3595 "hexpr.parse.C"
     break;
 
-  case 113: /* l3expr: "-" l3expr  */
-#line 640 "hexpr.y"
+  case 122: /* l3expr: "-" l3expr  */
+#line 649 "hexpr.y"
                            { (yyval.exp) = TAPP1(var("neg",m((yylsp[-1]))), ExprPtr((yyvsp[0].exp)), m((yylsp[-1]),(yylsp[0]))); }
-#line 3510 "hexpr.parse.C"
+#line 3601 "hexpr.parse.C"
     break;
 
-  case 114: /* l3expr: l4expr  */
-#line 641 "hexpr.y"
+  case 123: /* l3expr: l4expr  */
+#line 650 "hexpr.y"
                            { (yyval.exp) = (yyvsp[0].exp); }
-#line 3516 "hexpr.parse.C"
+#line 3607 "hexpr.parse.C"
     break;
 
-  case 115: /* l4expr: l4expr "*" l4expr  */
-#line 643 "hexpr.y"
+  case 124: /* l4expr: l4expr "*" l4expr  */
+#line 652 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("*", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3522 "hexpr.parse.C"
+#line 3613 "hexpr.parse.C"
     break;
 
-  case 116: /* l4expr: l4expr "/" l4expr  */
-#line 644 "hexpr.y"
+  case 125: /* l4expr: l4expr "/" l4expr  */
+#line 653 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("/", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3528 "hexpr.parse.C"
+#line 3619 "hexpr.parse.C"
     break;
 
-  case 117: /* l4expr: l4expr "%" l4expr  */
-#line 645 "hexpr.y"
+  case 126: /* l4expr: l4expr "%" l4expr  */
+#line 654 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("%", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3534 "hexpr.parse.C"
+#line 3625 "hexpr.parse.C"
     break;
 
-  case 118: /* l4expr: l5expr  */
-#line 646 "hexpr.y"
+  case 127: /* l4expr: l5expr  */
+#line 655 "hexpr.y"
                           { (yyval.exp) = (yyvsp[0].exp); }
-#line 3540 "hexpr.parse.C"
+#line 3631 "hexpr.parse.C"
     break;
 
-  case 119: /* l5expr: l6expr  */
-#line 648 "hexpr.y"
+  case 128: /* l5expr: l6expr  */
+#line 657 "hexpr.y"
                { (yyval.exp) = (yyvsp[0].exp); }
-#line 3546 "hexpr.parse.C"
+#line 3637 "hexpr.parse.C"
     break;
 
-  case 120: /* l5expr: "let" letbindings "in" l0expr  */
-#line 651 "hexpr.y"
+  case 129: /* l5expr: "let" letbindings "in" l0expr  */
+#line 660 "hexpr.y"
                                       { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-2].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3552 "hexpr.parse.C"
+#line 3643 "hexpr.parse.C"
     break;
 
-  case 121: /* l5expr: "let" letbindings ";" "in" l0expr  */
-#line 652 "hexpr.y"
+  case 130: /* l5expr: "let" letbindings ";" "in" l0expr  */
+#line 661 "hexpr.y"
                                           { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]),(yylsp[0])))->clone(); }
-#line 3558 "hexpr.parse.C"
+#line 3649 "hexpr.parse.C"
     break;
 
-  case 122: /* l5expr: "match" l6exprs "with" patternexps  */
-#line 655 "hexpr.y"
+  case 131: /* l5expr: "match" l6exprs "with" patternexps  */
+#line 664 "hexpr.y"
                                            { (yyval.exp) = compileMatch(yyParseCC, *(yyvsp[-2].exps), normPatternRules(*(yyvsp[0].patternexps), m((yylsp[-3]),(yylsp[0]))), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3564 "hexpr.parse.C"
+#line 3655 "hexpr.parse.C"
     break;
 
-  case 123: /* l5expr: l6expr "matches" pattern  */
-#line 658 "hexpr.y"
+  case 132: /* l5expr: l6expr "matches" pattern  */
+#line 667 "hexpr.y"
                                  { (yyval.exp) = compileMatchTest(yyParseCC, ExprPtr((yyvsp[-2].exp)), PatternPtr((yyvsp[0].pattern)), m((yylsp[-2]),(yylsp[0])))->clone(); }
-#line 3570 "hexpr.parse.C"
+#line 3661 "hexpr.parse.C"
     break;
 
-  case 124: /* l5expr: "parse" "{" prules "}"  */
-#line 661 "hexpr.y"
+  case 133: /* l5expr: "parse" "{" prules "}"  */
+#line 670 "hexpr.y"
                                {
         try {
           (yyval.exp) = makeParser(yyParseCC, *(yyvsp[-1].prules), m((yylsp[-3]),(yylsp[0])))->clone();
@@ -3581,1407 +3672,1407 @@ yyreduce:
           throw annotated_error(m((yylsp[-3]),(yylsp[0])), ss.str());
         }
       }
-#line 3585 "hexpr.parse.C"
+#line 3676 "hexpr.parse.C"
     break;
 
-  case 125: /* l5expr: "do" "{" dobindings "}"  */
-#line 673 "hexpr.y"
+  case 134: /* l5expr: "do" "{" dobindings "}"  */
+#line 682 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-1].letbindings), ExprPtr(new Unit(m((yylsp[-3]),(yylsp[0])))), m((yylsp[-3]),(yylsp[0]))); }
-#line 3591 "hexpr.parse.C"
+#line 3682 "hexpr.parse.C"
     break;
 
-  case 126: /* l5expr: "do" "{" dobindings "return" l0expr "}"  */
-#line 674 "hexpr.y"
+  case 135: /* l5expr: "do" "{" dobindings "return" l0expr "}"  */
+#line 683 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[-1].exp)), m((yylsp[-5]),(yylsp[0]))); }
-#line 3597 "hexpr.parse.C"
+#line 3688 "hexpr.parse.C"
     break;
 
-  case 127: /* l5expr: l6expr "::" qtype  */
-#line 677 "hexpr.y"
+  case 136: /* l5expr: l6expr "::" qtype  */
+#line 686 "hexpr.y"
                                 { (yyval.exp) = new Assump(ExprPtr((yyvsp[-2].exp)), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]),(yylsp[0]))); }
-#line 3603 "hexpr.parse.C"
+#line 3694 "hexpr.parse.C"
     break;
 
-  case 128: /* letbindings: letbindings ";" letbinding  */
-#line 679 "hexpr.y"
+  case 137: /* letbindings: letbindings ";" letbinding  */
+#line 688 "hexpr.y"
                                         { (yyvsp[-2].letbindings)->push_back(*(yyvsp[0].letbinding)); (yyval.letbindings) = (yyvsp[-2].letbindings); }
-#line 3609 "hexpr.parse.C"
+#line 3700 "hexpr.parse.C"
     break;
 
-  case 129: /* letbindings: letbinding  */
-#line 680 "hexpr.y"
+  case 138: /* letbindings: letbinding  */
+#line 689 "hexpr.y"
                                         { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3615 "hexpr.parse.C"
+#line 3706 "hexpr.parse.C"
     break;
 
-  case 130: /* letbinding: irrefutablep "=" l1expr  */
-#line 682 "hexpr.y"
+  case 139: /* letbinding: irrefutablep "=" l1expr  */
+#line 691 "hexpr.y"
                                     { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-2].pattern)), ExprPtr((yyvsp[0].exp)))); }
-#line 3621 "hexpr.parse.C"
+#line 3712 "hexpr.parse.C"
     break;
 
-  case 131: /* dobindings: dobindings dobinding  */
-#line 684 "hexpr.y"
+  case 140: /* dobindings: dobindings dobinding  */
+#line 693 "hexpr.y"
                                  { (yyval.letbindings) = (yyvsp[-1].letbindings); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3627 "hexpr.parse.C"
+#line 3718 "hexpr.parse.C"
     break;
 
-  case 132: /* dobindings: dobinding  */
-#line 685 "hexpr.y"
+  case 141: /* dobindings: dobinding  */
+#line 694 "hexpr.y"
                                  { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3633 "hexpr.parse.C"
+#line 3724 "hexpr.parse.C"
     break;
 
-  case 133: /* dobinding: irrefutablep "=" l0expr ";"  */
-#line 687 "hexpr.y"
+  case 142: /* dobinding: irrefutablep "=" l0expr ";"  */
+#line 696 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-3].pattern)), ExprPtr((yyvsp[-1].exp)))); }
-#line 3639 "hexpr.parse.C"
+#line 3730 "hexpr.parse.C"
     break;
 
-  case 134: /* dobinding: l0expr ";"  */
-#line 688 "hexpr.y"
+  case 143: /* dobinding: l0expr ";"  */
+#line 697 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr(new MatchAny("_",m((yylsp[-1])))), ExprPtr((yyvsp[-1].exp)))); }
-#line 3645 "hexpr.parse.C"
+#line 3736 "hexpr.parse.C"
     break;
 
-  case 135: /* cselconds: cselconds "," lhexpr  */
-#line 690 "hexpr.y"
+  case 144: /* cselconds: cselconds "," lhexpr  */
+#line 699 "hexpr.y"
                                 { (yyval.exps) = (yyvsp[-2].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3651 "hexpr.parse.C"
+#line 3742 "hexpr.parse.C"
     break;
 
-  case 136: /* cselconds: lhexpr  */
-#line 691 "hexpr.y"
+  case 145: /* cselconds: lhexpr  */
+#line 700 "hexpr.y"
                                 { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3657 "hexpr.parse.C"
+#line 3748 "hexpr.parse.C"
     break;
 
-  case 137: /* cselection: pattern "<-" l0expr "," cselconds  */
-#line 693 "hexpr.y"
+  case 146: /* cselection: pattern "<-" l0expr "," cselconds  */
+#line 702 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-4].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[-2].exp)); (yyval.cselection)->conds = *(yyvsp[0].exps); }
-#line 3663 "hexpr.parse.C"
+#line 3754 "hexpr.parse.C"
     break;
 
-  case 138: /* cselection: pattern "<-" l0expr  */
-#line 694 "hexpr.y"
+  case 147: /* cselection: pattern "<-" l0expr  */
+#line 703 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-2].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[0].exp)); }
-#line 3669 "hexpr.parse.C"
+#line 3760 "hexpr.parse.C"
     break;
 
-  case 139: /* cselections: cselections "|" cselection  */
-#line 696 "hexpr.y"
+  case 148: /* cselections: cselections "|" cselection  */
+#line 705 "hexpr.y"
                                         { (yyval.cselections) = (yyvsp[-2].cselections); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3675 "hexpr.parse.C"
+#line 3766 "hexpr.parse.C"
     break;
 
-  case 140: /* cselections: cselection  */
-#line 697 "hexpr.y"
+  case 149: /* cselections: cselection  */
+#line 706 "hexpr.y"
                                         { (yyval.cselections) = autorelease(new CSelections()); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3681 "hexpr.parse.C"
+#line 3772 "hexpr.parse.C"
     break;
 
-  case 141: /* l6expr: l6expr "(" cargs ")"  */
-#line 700 "hexpr.y"
+  case 150: /* l6expr: l6expr "(" cargs ")"  */
+#line 709 "hexpr.y"
                                 { (yyval.exp) = new App(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].exps), m((yylsp[-3]), (yylsp[0]))); }
-#line 3687 "hexpr.parse.C"
+#line 3778 "hexpr.parse.C"
     break;
 
-  case 142: /* l6expr: id  */
-#line 701 "hexpr.y"
+  case 151: /* l6expr: id  */
+#line 710 "hexpr.y"
                                 { (yyval.exp) = varCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 3693 "hexpr.parse.C"
+#line 3784 "hexpr.parse.C"
     break;
 
-  case 143: /* l6expr: "[" l0expr ".." l0expr "]"  */
-#line 704 "hexpr.y"
+  case 152: /* l6expr: "[" l0expr ".." l0expr "]"  */
+#line 713 "hexpr.y"
                                                           { (yyval.exp) = new App(var("range", m((yylsp[-2]))), list(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3699 "hexpr.parse.C"
+#line 3790 "hexpr.parse.C"
     break;
 
-  case 144: /* l6expr: "[" l0expr ".." "]"  */
-#line 705 "hexpr.y"
+  case 153: /* l6expr: "[" l0expr ".." "]"  */
+#line 714 "hexpr.y"
                                                           { (yyval.exp) = new App(var("iterateS", m((yylsp[-1]))), list(ExprPtr((yyvsp[-2].exp)), fn(str::strings(".x"), fncall(var("+", m((yylsp[-1]))), list(var(".x", m((yylsp[-1]))), ExprPtr(new Int(1, m((yylsp[-1]))))), m((yylsp[-1]))), m((yylsp[-1])))), m((yylsp[-3]), (yylsp[0]))); }
-#line 3705 "hexpr.parse.C"
+#line 3796 "hexpr.parse.C"
     break;
 
-  case 145: /* l6expr: "[" l0expr "|" cselections "]"  */
-#line 706 "hexpr.y"
+  case 154: /* l6expr: "[" l0expr "|" cselections "]"  */
+#line 715 "hexpr.y"
                                                           { (yyval.exp) = desugarComprehension(yyParseCC, ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].cselections), m((yylsp[-4]), (yylsp[0]))); }
-#line 3711 "hexpr.parse.C"
+#line 3802 "hexpr.parse.C"
     break;
 
-  case 146: /* l6expr: "[" cargs "]"  */
-#line 707 "hexpr.y"
+  case 155: /* l6expr: "[" cargs "]"  */
+#line 716 "hexpr.y"
                                                           { (yyval.exp) = new MkArray(*(yyvsp[-1].exps), m((yylsp[-2]), (yylsp[0]))); }
-#line 3717 "hexpr.parse.C"
+#line 3808 "hexpr.parse.C"
     break;
 
-  case 147: /* l6expr: l6expr "[" "timeV" "]"  */
-#line 708 "hexpr.y"
+  case 156: /* l6expr: l6expr "[" "timeV" "]"  */
+#line 717 "hexpr.y"
                                                           { (yyval.exp) = maybeArraySliceWithTime(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].string), m((yylsp[-3]), (yylsp[0]))); }
-#line 3723 "hexpr.parse.C"
+#line 3814 "hexpr.parse.C"
     break;
 
-  case 148: /* l6expr: l6expr "[" l0expr "]"  */
-#line 709 "hexpr.y"
+  case 157: /* l6expr: l6expr "[" l0expr "]"  */
+#line 718 "hexpr.y"
                                                           { (yyval.exp) = mkAIndex(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3729 "hexpr.parse.C"
+#line 3820 "hexpr.parse.C"
     break;
 
-  case 149: /* l6expr: l6expr "[" l0expr ":" l0expr "]"  */
-#line 710 "hexpr.y"
+  case 158: /* l6expr: l6expr "[" l0expr ":" l0expr "]"  */
+#line 719 "hexpr.y"
                                                           { (yyval.exp) = new App(var("slice", m((yylsp[-2]))), list(ExprPtr((yyvsp[-5].exp)), ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-5]), (yylsp[0]))); }
-#line 3735 "hexpr.parse.C"
+#line 3826 "hexpr.parse.C"
     break;
 
-  case 150: /* l6expr: l6expr "[" l0expr ":" "]"  */
-#line 711 "hexpr.y"
+  case 159: /* l6expr: l6expr "[" l0expr ":" "]"  */
+#line 720 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-1]))), list(var(vn,m((yylsp[-4]))), ExprPtr((yyvsp[-2].exp)), fncall(var("size",m((yylsp[-1]))), list(var(vn,m((yylsp[-4])))),m((yylsp[-4])))),m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3741 "hexpr.parse.C"
+#line 3832 "hexpr.parse.C"
     break;
 
-  case 151: /* l6expr: l6expr "[" ":" l0expr "]"  */
-#line 712 "hexpr.y"
+  case 160: /* l6expr: l6expr "[" ":" l0expr "]"  */
+#line 721 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-2]))), list(var(vn,m((yylsp[-4]))), fncall(var("size",m((yylsp[-2]))), list(var(vn,m((yylsp[-2])))),m((yylsp[-4]))), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3747 "hexpr.parse.C"
+#line 3838 "hexpr.parse.C"
     break;
 
-  case 152: /* l6expr: "|" id "=" l0expr "|"  */
-#line 715 "hexpr.y"
+  case 161: /* l6expr: "|" id "=" l0expr "|"  */
+#line 724 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-3].string), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3753 "hexpr.parse.C"
+#line 3844 "hexpr.parse.C"
     break;
 
-  case 153: /* l6expr: "|" "intV" "=" l0expr "|"  */
-#line 716 "hexpr.y"
+  case 162: /* l6expr: "|" "intV" "=" l0expr "|"  */
+#line 725 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(".f" + str::from((yyvsp[-3].intv)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3759 "hexpr.parse.C"
+#line 3850 "hexpr.parse.C"
     break;
 
-  case 154: /* l6expr: "|" id "|"  */
-#line 717 "hexpr.y"
+  case 163: /* l6expr: "|" id "|"  */
+#line 726 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-1].string), ExprPtr(new Unit(m((yylsp[-1])))), m((yylsp[-2]), (yylsp[0]))); }
-#line 3765 "hexpr.parse.C"
+#line 3856 "hexpr.parse.C"
     break;
 
-  case 155: /* l6expr: "case" l0expr "of" "|" varfields "|"  */
-#line 718 "hexpr.y"
+  case 164: /* l6expr: "case" l0expr "of" "|" varfields "|"  */
+#line 727 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-4].exp)), *(yyvsp[-1].vfields), m((yylsp[-5]), (yylsp[0]))); }
-#line 3771 "hexpr.parse.C"
+#line 3862 "hexpr.parse.C"
     break;
 
-  case 156: /* l6expr: "case" l0expr "of" "|" varfields "|" "default" l0expr  */
-#line 719 "hexpr.y"
+  case 165: /* l6expr: "case" l0expr "of" "|" varfields "|" "default" l0expr  */
+#line 728 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-6].exp)), *(yyvsp[-3].vfields), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 3777 "hexpr.parse.C"
+#line 3868 "hexpr.parse.C"
     break;
 
-  case 157: /* l6expr: "{" recfields "}"  */
-#line 722 "hexpr.y"
+  case 166: /* l6expr: "{" recfields "}"  */
+#line 731 "hexpr.y"
                               { if ((yyvsp[-1].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-1].rfields), m((yylsp[-2]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-2]), (yylsp[0]))); } }
-#line 3783 "hexpr.parse.C"
+#line 3874 "hexpr.parse.C"
     break;
 
-  case 158: /* l6expr: "{" recfields "," "}"  */
-#line 723 "hexpr.y"
+  case 167: /* l6expr: "{" recfields "," "}"  */
+#line 732 "hexpr.y"
                               { if ((yyvsp[-2].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-2].rfields), m((yylsp[-3]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-3]), (yylsp[0]))); } }
-#line 3789 "hexpr.parse.C"
+#line 3880 "hexpr.parse.C"
     break;
 
-  case 159: /* l6expr: l6expr recfieldpath  */
-#line 724 "hexpr.y"
+  case 168: /* l6expr: l6expr recfieldpath  */
+#line 733 "hexpr.y"
                               { (yyval.exp) = makeProjSeq((yyvsp[-1].exp), *(yyvsp[0].strings), m((yylsp[-1]), (yylsp[0]))); }
-#line 3795 "hexpr.parse.C"
+#line 3886 "hexpr.parse.C"
     break;
 
-  case 160: /* l6expr: recfieldpath  */
-#line 727 "hexpr.y"
+  case 169: /* l6expr: recfieldpath  */
+#line 736 "hexpr.y"
                      { (yyval.exp) = new Fn(str::strings("x"), proj(var("x", m((yylsp[0]))), *(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3801 "hexpr.parse.C"
+#line 3892 "hexpr.parse.C"
     break;
 
-  case 161: /* l6expr: "regexV"  */
-#line 730 "hexpr.y"
+  case 170: /* l6expr: "regexV"  */
+#line 739 "hexpr.y"
                  { (yyval.exp) = compileRegexFn(yyParseCC, std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0])))->clone(); }
-#line 3807 "hexpr.parse.C"
+#line 3898 "hexpr.parse.C"
     break;
 
-  case 162: /* l6expr: "pack" l6expr  */
-#line 733 "hexpr.y"
+  case 171: /* l6expr: "pack" l6expr  */
+#line 742 "hexpr.y"
                                            { (yyval.exp) = new Pack(ExprPtr((yyvsp[0].exp)), m((yylsp[-1]), (yylsp[0]))); }
-#line 3813 "hexpr.parse.C"
+#line 3904 "hexpr.parse.C"
     break;
 
-  case 163: /* l6expr: "unpack" id "=" l6expr "in" l6expr  */
-#line 734 "hexpr.y"
+  case 172: /* l6expr: "unpack" id "=" l6expr "in" l6expr  */
+#line 743 "hexpr.y"
                                            { (yyval.exp) = new Unpack(*(yyvsp[-4].string), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 3819 "hexpr.parse.C"
+#line 3910 "hexpr.parse.C"
     break;
 
-  case 164: /* l6expr: "boolV"  */
-#line 737 "hexpr.y"
+  case 173: /* l6expr: "boolV"  */
+#line 746 "hexpr.y"
                     { (yyval.exp) = new Bool((yyvsp[0].boolv), m((yylsp[0]))); }
-#line 3825 "hexpr.parse.C"
+#line 3916 "hexpr.parse.C"
     break;
 
-  case 165: /* l6expr: "charV"  */
-#line 738 "hexpr.y"
+  case 174: /* l6expr: "charV"  */
+#line 747 "hexpr.y"
                     { (yyval.exp) = new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3831 "hexpr.parse.C"
+#line 3922 "hexpr.parse.C"
     break;
 
-  case 166: /* l6expr: "byteV"  */
-#line 739 "hexpr.y"
+  case 175: /* l6expr: "byteV"  */
+#line 748 "hexpr.y"
                     { (yyval.exp) = new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3837 "hexpr.parse.C"
+#line 3928 "hexpr.parse.C"
     break;
 
-  case 167: /* l6expr: "bytesV"  */
-#line 740 "hexpr.y"
+  case 176: /* l6expr: "bytesV"  */
+#line 749 "hexpr.y"
                     { (yyval.exp) = mkarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3843 "hexpr.parse.C"
+#line 3934 "hexpr.parse.C"
     break;
 
-  case 168: /* l6expr: "shortV"  */
-#line 741 "hexpr.y"
+  case 177: /* l6expr: "shortV"  */
+#line 750 "hexpr.y"
                     { (yyval.exp) = new Short((yyvsp[0].shortv), m((yylsp[0]))); }
-#line 3849 "hexpr.parse.C"
+#line 3940 "hexpr.parse.C"
     break;
 
-  case 169: /* l6expr: "intV"  */
-#line 742 "hexpr.y"
+  case 178: /* l6expr: "intV"  */
+#line 751 "hexpr.y"
                     { (yyval.exp) = new Int((yyvsp[0].intv), m((yylsp[0]))); }
-#line 3855 "hexpr.parse.C"
+#line 3946 "hexpr.parse.C"
     break;
 
-  case 170: /* l6expr: "longV"  */
-#line 743 "hexpr.y"
+  case 179: /* l6expr: "longV"  */
+#line 752 "hexpr.y"
                     { (yyval.exp) = new Long((yyvsp[0].longv), m((yylsp[0]))); }
-#line 3861 "hexpr.parse.C"
+#line 3952 "hexpr.parse.C"
     break;
 
-  case 171: /* l6expr: "int128V"  */
-#line 744 "hexpr.y"
+  case 180: /* l6expr: "int128V"  */
+#line 753 "hexpr.y"
                     { (yyval.exp) = new Int128((yyvsp[0].int128v), m((yylsp[0]))); }
-#line 3867 "hexpr.parse.C"
+#line 3958 "hexpr.parse.C"
     break;
 
-  case 172: /* l6expr: "floatV"  */
-#line 745 "hexpr.y"
+  case 181: /* l6expr: "floatV"  */
+#line 754 "hexpr.y"
                     { (yyval.exp) = new Float((yyvsp[0].floatv), m((yylsp[0]))); }
-#line 3873 "hexpr.parse.C"
+#line 3964 "hexpr.parse.C"
     break;
 
-  case 173: /* l6expr: "doubleV"  */
-#line 746 "hexpr.y"
+  case 182: /* l6expr: "doubleV"  */
+#line 755 "hexpr.y"
                     { (yyval.exp) = new Double((yyvsp[0].doublev), m((yylsp[0]))); }
-#line 3879 "hexpr.parse.C"
+#line 3970 "hexpr.parse.C"
     break;
 
-  case 174: /* l6expr: "stringV"  */
-#line 747 "hexpr.y"
+  case 183: /* l6expr: "stringV"  */
+#line 756 "hexpr.y"
                     { (yyval.exp) = mkarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 3885 "hexpr.parse.C"
+#line 3976 "hexpr.parse.C"
     break;
 
-  case 175: /* l6expr: tsseq  */
-#line 748 "hexpr.y"
+  case 184: /* l6expr: tsseq  */
+#line 757 "hexpr.y"
                     { (yyval.exp) = mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0])))->clone(); }
-#line 3891 "hexpr.parse.C"
+#line 3982 "hexpr.parse.C"
     break;
 
-  case 176: /* l6expr: "timeV"  */
-#line 749 "hexpr.y"
+  case 185: /* l6expr: "timeV"  */
+#line 758 "hexpr.y"
                     { (yyval.exp) = mkTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 3897 "hexpr.parse.C"
+#line 3988 "hexpr.parse.C"
     break;
 
-  case 177: /* l6expr: "dateTimeV"  */
-#line 750 "hexpr.y"
+  case 186: /* l6expr: "dateTimeV"  */
+#line 759 "hexpr.y"
                     { (yyval.exp) = mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 3903 "hexpr.parse.C"
+#line 3994 "hexpr.parse.C"
     break;
 
-  case 178: /* l6expr: "(" cargs ")"  */
-#line 753 "hexpr.y"
+  case 187: /* l6expr: "(" cargs ")"  */
+#line 762 "hexpr.y"
                       { (yyval.exp) = pickNestedExp((yyvsp[-1].exps), m((yylsp[-2]),(yylsp[0]))); }
-#line 3909 "hexpr.parse.C"
+#line 4000 "hexpr.parse.C"
     break;
 
-  case 179: /* l6expr: "(" "++" ")"  */
-#line 756 "hexpr.y"
+  case 188: /* l6expr: "(" "++" ")"  */
+#line 765 "hexpr.y"
                       { (yyval.exp) = new Var("append", m((yylsp[-1]))); }
-#line 3915 "hexpr.parse.C"
+#line 4006 "hexpr.parse.C"
     break;
 
-  case 180: /* l6expr: "(" "+" ")"  */
-#line 757 "hexpr.y"
+  case 189: /* l6expr: "(" "+" ")"  */
+#line 766 "hexpr.y"
                       { (yyval.exp) = new Var("+",      m((yylsp[-1]))); }
-#line 3921 "hexpr.parse.C"
+#line 4012 "hexpr.parse.C"
     break;
 
-  case 181: /* l6expr: "(" "-" ")"  */
-#line 758 "hexpr.y"
+  case 190: /* l6expr: "(" "-" ")"  */
+#line 767 "hexpr.y"
                       { (yyval.exp) = new Var("-",      m((yylsp[-1]))); }
-#line 3927 "hexpr.parse.C"
+#line 4018 "hexpr.parse.C"
     break;
 
-  case 182: /* l6expr: "(" "*" ")"  */
-#line 759 "hexpr.y"
+  case 191: /* l6expr: "(" "*" ")"  */
+#line 768 "hexpr.y"
                       { (yyval.exp) = new Var("*",      m((yylsp[-1]))); }
-#line 3933 "hexpr.parse.C"
+#line 4024 "hexpr.parse.C"
     break;
 
-  case 183: /* l6expr: "(" "/" ")"  */
-#line 760 "hexpr.y"
+  case 192: /* l6expr: "(" "/" ")"  */
+#line 769 "hexpr.y"
                       { (yyval.exp) = new Var("/",      m((yylsp[-1]))); }
-#line 3939 "hexpr.parse.C"
+#line 4030 "hexpr.parse.C"
     break;
 
-  case 184: /* l6expr: "(" "%" ")"  */
-#line 761 "hexpr.y"
+  case 193: /* l6expr: "(" "%" ")"  */
+#line 770 "hexpr.y"
                       { (yyval.exp) = new Var("%",      m((yylsp[-1]))); }
-#line 3945 "hexpr.parse.C"
+#line 4036 "hexpr.parse.C"
     break;
 
-  case 185: /* l6expr: "(" "~" ")"  */
-#line 762 "hexpr.y"
+  case 194: /* l6expr: "(" "~" ")"  */
+#line 771 "hexpr.y"
                       { (yyval.exp) = new Var("~",      m((yylsp[-1]))); }
-#line 3951 "hexpr.parse.C"
+#line 4042 "hexpr.parse.C"
     break;
 
-  case 186: /* l6expr: "(" "===" ")"  */
-#line 763 "hexpr.y"
+  case 195: /* l6expr: "(" "===" ")"  */
+#line 772 "hexpr.y"
                       { (yyval.exp) = new Var("===",    m((yylsp[-1]))); }
-#line 3957 "hexpr.parse.C"
+#line 4048 "hexpr.parse.C"
     break;
 
-  case 187: /* l6expr: "(" "==" ")"  */
-#line 764 "hexpr.y"
+  case 196: /* l6expr: "(" "==" ")"  */
+#line 773 "hexpr.y"
                       { (yyval.exp) = new Var("==",     m((yylsp[-1]))); }
-#line 3963 "hexpr.parse.C"
+#line 4054 "hexpr.parse.C"
     break;
 
-  case 188: /* l6expr: "(" "!=" ")"  */
-#line 765 "hexpr.y"
+  case 197: /* l6expr: "(" "!=" ")"  */
+#line 774 "hexpr.y"
                       { (yyval.exp) = new Var("!=",     m((yylsp[-1]))); }
-#line 3969 "hexpr.parse.C"
+#line 4060 "hexpr.parse.C"
     break;
 
-  case 189: /* l6expr: "(" "<" ")"  */
-#line 766 "hexpr.y"
+  case 198: /* l6expr: "(" "<" ")"  */
+#line 775 "hexpr.y"
                       { (yyval.exp) = new Var("<",      m((yylsp[-1]))); }
-#line 3975 "hexpr.parse.C"
+#line 4066 "hexpr.parse.C"
     break;
 
-  case 190: /* l6expr: "(" ">" ")"  */
-#line 767 "hexpr.y"
+  case 199: /* l6expr: "(" ">" ")"  */
+#line 776 "hexpr.y"
                       { (yyval.exp) = new Var(">",      m((yylsp[-1]))); }
-#line 3981 "hexpr.parse.C"
+#line 4072 "hexpr.parse.C"
     break;
 
-  case 191: /* l6expr: "(" ">=" ")"  */
-#line 768 "hexpr.y"
+  case 200: /* l6expr: "(" ">=" ")"  */
+#line 777 "hexpr.y"
                       { (yyval.exp) = new Var(">=",     m((yylsp[-1]))); }
-#line 3987 "hexpr.parse.C"
+#line 4078 "hexpr.parse.C"
     break;
 
-  case 192: /* l6expr: "(" "<=" ")"  */
-#line 769 "hexpr.y"
+  case 201: /* l6expr: "(" "<=" ")"  */
+#line 778 "hexpr.y"
                       { (yyval.exp) = new Var("<=",     m((yylsp[-1]))); }
-#line 3993 "hexpr.parse.C"
+#line 4084 "hexpr.parse.C"
     break;
 
-  case 193: /* l6expr: "(" "and" ")"  */
-#line 770 "hexpr.y"
+  case 202: /* l6expr: "(" "and" ")"  */
+#line 779 "hexpr.y"
                       { (yyval.exp) = new Var("and",    m((yylsp[-1]))); }
-#line 3999 "hexpr.parse.C"
+#line 4090 "hexpr.parse.C"
     break;
 
-  case 194: /* l6expr: "(" "or" ")"  */
-#line 771 "hexpr.y"
+  case 203: /* l6expr: "(" "or" ")"  */
+#line 780 "hexpr.y"
                       { (yyval.exp) = new Var("or",     m((yylsp[-1]))); }
-#line 4005 "hexpr.parse.C"
+#line 4096 "hexpr.parse.C"
     break;
 
-  case 195: /* l6expr: "(" "in" ")"  */
-#line 772 "hexpr.y"
+  case 204: /* l6expr: "(" "in" ")"  */
+#line 781 "hexpr.y"
                       { (yyval.exp) = new Var("in",     m((yylsp[-1]))); }
-#line 4011 "hexpr.parse.C"
+#line 4102 "hexpr.parse.C"
     break;
 
-  case 196: /* l6expr: "(" "!" ")"  */
-#line 773 "hexpr.y"
+  case 205: /* l6expr: "(" "!" ")"  */
+#line 782 "hexpr.y"
                       { (yyval.exp) = new Var("not",    m((yylsp[-1]))); }
-#line 4017 "hexpr.parse.C"
+#line 4108 "hexpr.parse.C"
     break;
 
-  case 197: /* l6expr: "`" l0expr "`"  */
-#line 776 "hexpr.y"
+  case 206: /* l6expr: "`" l0expr "`"  */
+#line 785 "hexpr.y"
                        { (yyval.exp) = new Assump(fncall(var("unsafeCast", m((yylsp[-1]))), list(mktunit(m((yylsp[-1])))), m((yylsp[-1]))), qualtype(tapp(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp)))))), m((yylsp[-1]))); }
-#line 4023 "hexpr.parse.C"
+#line 4114 "hexpr.parse.C"
     break;
 
-  case 198: /* prules: prules prule  */
-#line 778 "hexpr.y"
+  case 207: /* prules: prules prule  */
+#line 787 "hexpr.y"
                      { (yyval.prules) = (yyvsp[-1].prules); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4029 "hexpr.parse.C"
+#line 4120 "hexpr.parse.C"
     break;
 
-  case 199: /* prules: prule  */
-#line 779 "hexpr.y"
+  case 208: /* prules: prule  */
+#line 788 "hexpr.y"
                      { (yyval.prules) = autorelease(new Grammar()); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4035 "hexpr.parse.C"
+#line 4126 "hexpr.parse.C"
     break;
 
-  case 200: /* prule: id ":=" prdefs  */
-#line 781 "hexpr.y"
+  case 209: /* prule: id ":=" prdefs  */
+#line 790 "hexpr.y"
                       { (yyval.prule) = autorelease(new Grammar::value_type(*(yyvsp[-2].string), *(yyvsp[0].prdefs))); }
-#line 4041 "hexpr.parse.C"
+#line 4132 "hexpr.parse.C"
     break;
 
-  case 201: /* prdefs: prdefs "|" prdef  */
-#line 783 "hexpr.y"
+  case 210: /* prdefs: prdefs "|" prdef  */
+#line 792 "hexpr.y"
                          { (yyval.prdefs) = (yyvsp[-2].prdefs); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4047 "hexpr.parse.C"
+#line 4138 "hexpr.parse.C"
     break;
 
-  case 202: /* prdefs: prdef  */
-#line 784 "hexpr.y"
+  case 211: /* prdefs: prdef  */
+#line 793 "hexpr.y"
                          { (yyval.prdefs) = autorelease(new GrammarRules()); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4053 "hexpr.parse.C"
+#line 4144 "hexpr.parse.C"
     break;
 
-  case 203: /* prdef: pbelems "{" l0expr "}"  */
-#line 786 "hexpr.y"
+  case 212: /* prdef: pbelems "{" l0expr "}"  */
+#line 795 "hexpr.y"
                               { (yyval.prdef) = autorelease(new GrammarRule(*(yyvsp[-3].pbelems), ExprPtr((yyvsp[-1].exp)))); }
-#line 4059 "hexpr.parse.C"
+#line 4150 "hexpr.parse.C"
     break;
 
-  case 204: /* pbelems: pbelems pbelem  */
-#line 788 "hexpr.y"
+  case 213: /* pbelems: pbelems pbelem  */
+#line 797 "hexpr.y"
                         { (yyval.pbelems) = (yyvsp[-1].pbelems); (yyval.pbelems)->push_back(*(yyvsp[0].pbelem)); }
-#line 4065 "hexpr.parse.C"
+#line 4156 "hexpr.parse.C"
     break;
 
-  case 205: /* pbelems: %empty  */
-#line 789 "hexpr.y"
+  case 214: /* pbelems: %empty  */
+#line 798 "hexpr.y"
                         { (yyval.pbelems) = autorelease(new BoundGrammarValues()); }
-#line 4071 "hexpr.parse.C"
+#line 4162 "hexpr.parse.C"
     break;
 
-  case 206: /* pbelem: id ":" pvalue  */
-#line 791 "hexpr.y"
+  case 215: /* pbelem: id ":" pvalue  */
+#line 800 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue(*(yyvsp[-2].string), GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4077 "hexpr.parse.C"
+#line 4168 "hexpr.parse.C"
     break;
 
-  case 207: /* pbelem: pvalue  */
-#line 792 "hexpr.y"
+  case 216: /* pbelem: pvalue  */
+#line 801 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue("_", GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4083 "hexpr.parse.C"
+#line 4174 "hexpr.parse.C"
     break;
 
-  case 208: /* pvalue: id  */
-#line 794 "hexpr.y"
+  case 217: /* pvalue: id  */
+#line 803 "hexpr.y"
                       { (yyval.pvalue) = new GSymRef(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4089 "hexpr.parse.C"
+#line 4180 "hexpr.parse.C"
     break;
 
-  case 209: /* pvalue: "stringV"  */
-#line 795 "hexpr.y"
+  case 218: /* pvalue: "stringV"  */
+#line 804 "hexpr.y"
                       { (yyval.pvalue) = new GStr(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4095 "hexpr.parse.C"
+#line 4186 "hexpr.parse.C"
     break;
 
-  case 210: /* pvalue: "charV"  */
-#line 796 "hexpr.y"
+  case 219: /* pvalue: "charV"  */
+#line 805 "hexpr.y"
                       { (yyval.pvalue) = new GStr(std::string(1, str::readCharDef(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4101 "hexpr.parse.C"
+#line 4192 "hexpr.parse.C"
     break;
 
-  case 211: /* tsseq: "timespanV"  */
-#line 798 "hexpr.y"
+  case 220: /* tsseq: "timespanV"  */
+#line 807 "hexpr.y"
                          { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4107 "hexpr.parse.C"
+#line 4198 "hexpr.parse.C"
     break;
 
-  case 212: /* tsseq: tsseq "timespanV"  */
-#line 799 "hexpr.y"
+  case 221: /* tsseq: tsseq "timespanV"  */
+#line 808 "hexpr.y"
                          { (yyval.strings) = (yyvsp[-1].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4113 "hexpr.parse.C"
+#line 4204 "hexpr.parse.C"
     break;
 
-  case 213: /* l6exprs: l6exprs l6expr  */
-#line 801 "hexpr.y"
+  case 222: /* l6exprs: l6exprs l6expr  */
+#line 810 "hexpr.y"
                         { (yyval.exps) = (yyvsp[-1].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4119 "hexpr.parse.C"
+#line 4210 "hexpr.parse.C"
     break;
 
-  case 214: /* l6exprs: l6expr  */
-#line 802 "hexpr.y"
+  case 223: /* l6exprs: l6expr  */
+#line 811 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4125 "hexpr.parse.C"
+#line 4216 "hexpr.parse.C"
     break;
 
-  case 215: /* patternexps: patternexps patternexp  */
-#line 804 "hexpr.y"
+  case 224: /* patternexps: patternexps patternexp  */
+#line 813 "hexpr.y"
                                     { (yyval.patternexps) = (yyvsp[-1].patternexps); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4131 "hexpr.parse.C"
+#line 4222 "hexpr.parse.C"
     break;
 
-  case 216: /* patternexps: patternexp  */
-#line 805 "hexpr.y"
+  case 225: /* patternexps: patternexp  */
+#line 814 "hexpr.y"
                                     { (yyval.patternexps) = autorelease(new PatternRows()); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4137 "hexpr.parse.C"
+#line 4228 "hexpr.parse.C"
     break;
 
-  case 217: /* patternexp: "|" patterns "->" l0expr  */
-#line 807 "hexpr.y"
+  case 226: /* patternexp: "|" patterns "->" l0expr  */
+#line 816 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)))); }
-#line 4143 "hexpr.parse.C"
+#line 4234 "hexpr.parse.C"
     break;
 
-  case 218: /* patternexp: "|" patterns "where" l0expr "->" l0expr  */
-#line 808 "hexpr.y"
+  case 227: /* patternexp: "|" patterns "where" l0expr "->" l0expr  */
+#line 817 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-4].patterns), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)))); }
-#line 4149 "hexpr.parse.C"
+#line 4240 "hexpr.parse.C"
     break;
 
-  case 219: /* patterns: patterns pattern  */
-#line 811 "hexpr.y"
+  case 228: /* patterns: patterns pattern  */
+#line 820 "hexpr.y"
                            { (yyval.patterns) = (yyvsp[-1].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4155 "hexpr.parse.C"
+#line 4246 "hexpr.parse.C"
     break;
 
-  case 220: /* patterns: pattern  */
-#line 812 "hexpr.y"
+  case 229: /* patterns: pattern  */
+#line 821 "hexpr.y"
                            { (yyval.patterns) = autorelease(new Patterns()); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4161 "hexpr.parse.C"
+#line 4252 "hexpr.parse.C"
     break;
 
-  case 221: /* refutablep: "boolV"  */
-#line 814 "hexpr.y"
+  case 230: /* refutablep: "boolV"  */
+#line 823 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Bool((yyvsp[0].boolv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4167 "hexpr.parse.C"
+#line 4258 "hexpr.parse.C"
     break;
 
-  case 222: /* refutablep: "charV"  */
-#line 815 "hexpr.y"
+  case 231: /* refutablep: "charV"  */
+#line 824 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4173 "hexpr.parse.C"
+#line 4264 "hexpr.parse.C"
     break;
 
-  case 223: /* refutablep: "byteV"  */
-#line 816 "hexpr.y"
+  case 232: /* refutablep: "byteV"  */
+#line 825 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4179 "hexpr.parse.C"
+#line 4270 "hexpr.parse.C"
     break;
 
-  case 224: /* refutablep: "shortV"  */
-#line 817 "hexpr.y"
+  case 233: /* refutablep: "shortV"  */
+#line 826 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Short((yyvsp[0].shortv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4185 "hexpr.parse.C"
+#line 4276 "hexpr.parse.C"
     break;
 
-  case 225: /* refutablep: "intV"  */
-#line 818 "hexpr.y"
+  case 234: /* refutablep: "intV"  */
+#line 827 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int((yyvsp[0].intv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4191 "hexpr.parse.C"
+#line 4282 "hexpr.parse.C"
     break;
 
-  case 226: /* refutablep: "longV"  */
-#line 819 "hexpr.y"
+  case 235: /* refutablep: "longV"  */
+#line 828 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Long((yyvsp[0].longv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4197 "hexpr.parse.C"
+#line 4288 "hexpr.parse.C"
     break;
 
-  case 227: /* refutablep: "int128V"  */
-#line 820 "hexpr.y"
+  case 236: /* refutablep: "int128V"  */
+#line 829 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int128((yyvsp[0].int128v), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4203 "hexpr.parse.C"
+#line 4294 "hexpr.parse.C"
     break;
 
-  case 228: /* refutablep: "doubleV"  */
-#line 821 "hexpr.y"
+  case 237: /* refutablep: "doubleV"  */
+#line 830 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Double((yyvsp[0].doublev), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4209 "hexpr.parse.C"
+#line 4300 "hexpr.parse.C"
     break;
 
-  case 229: /* refutablep: "bytesV"  */
-#line 822 "hexpr.y"
+  case 238: /* refutablep: "bytesV"  */
+#line 831 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 4215 "hexpr.parse.C"
+#line 4306 "hexpr.parse.C"
     break;
 
-  case 230: /* refutablep: "stringV"  */
-#line 823 "hexpr.y"
+  case 239: /* refutablep: "stringV"  */
+#line 832 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4221 "hexpr.parse.C"
+#line 4312 "hexpr.parse.C"
     break;
 
-  case 231: /* refutablep: tsseq  */
-#line 824 "hexpr.y"
+  case 240: /* refutablep: tsseq  */
+#line 833 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimespanPrim(*(yyvsp[0].strings), m((yylsp[0]))), mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4227 "hexpr.parse.C"
+#line 4318 "hexpr.parse.C"
     break;
 
-  case 232: /* refutablep: "timeV"  */
-#line 825 "hexpr.y"
+  case 241: /* refutablep: "timeV"  */
+#line 834 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4233 "hexpr.parse.C"
+#line 4324 "hexpr.parse.C"
     break;
 
-  case 233: /* refutablep: "dateTimeV"  */
-#line 826 "hexpr.y"
+  case 242: /* refutablep: "dateTimeV"  */
+#line 835 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkDateTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4239 "hexpr.parse.C"
+#line 4330 "hexpr.parse.C"
     break;
 
-  case 234: /* refutablep: "regexV"  */
-#line 827 "hexpr.y"
+  case 243: /* refutablep: "regexV"  */
+#line 836 "hexpr.y"
                                        { (yyval.pattern) = new MatchRegex(std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0]))); }
-#line 4245 "hexpr.parse.C"
+#line 4336 "hexpr.parse.C"
     break;
 
-  case 235: /* refutablep: "[" patternseq "]"  */
-#line 828 "hexpr.y"
+  case 244: /* refutablep: "[" patternseq "]"  */
+#line 837 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4251 "hexpr.parse.C"
+#line 4342 "hexpr.parse.C"
     break;
 
-  case 236: /* refutablep: "[" patternseq "," "]"  */
-#line 829 "hexpr.y"
+  case 245: /* refutablep: "[" patternseq "," "]"  */
+#line 838 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4257 "hexpr.parse.C"
+#line 4348 "hexpr.parse.C"
     break;
 
-  case 237: /* refutablep: "|" id "|"  */
-#line 830 "hexpr.y"
+  case 246: /* refutablep: "|" id "|"  */
+#line 839 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-1].string), PatternPtr(new MatchLiteral(PrimitivePtr(new Unit(m((yylsp[-1])))), m((yylsp[-1])))), m((yylsp[-2]),(yylsp[0]))); }
-#line 4263 "hexpr.parse.C"
+#line 4354 "hexpr.parse.C"
     break;
 
-  case 238: /* refutablep: "|" id "=" pattern "|"  */
-#line 831 "hexpr.y"
+  case 247: /* refutablep: "|" id "=" pattern "|"  */
+#line 840 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-3].string), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4269 "hexpr.parse.C"
+#line 4360 "hexpr.parse.C"
     break;
 
-  case 239: /* refutablep: "|" "intV" "=" pattern "|"  */
-#line 832 "hexpr.y"
+  case 248: /* refutablep: "|" "intV" "=" pattern "|"  */
+#line 841 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(".f" + str::from((yyvsp[-3].intv)), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4275 "hexpr.parse.C"
+#line 4366 "hexpr.parse.C"
     break;
 
-  case 240: /* refutablep: "(" patternseq ")"  */
-#line 833 "hexpr.y"
+  case 249: /* refutablep: "(" patternseq ")"  */
+#line 842 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4281 "hexpr.parse.C"
+#line 4372 "hexpr.parse.C"
     break;
 
-  case 241: /* refutablep: "(" patternseq "," ")"  */
-#line 834 "hexpr.y"
+  case 250: /* refutablep: "(" patternseq "," ")"  */
+#line 843 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4287 "hexpr.parse.C"
+#line 4378 "hexpr.parse.C"
     break;
 
-  case 242: /* refutablep: "{" recpatfields "}"  */
-#line 835 "hexpr.y"
+  case 251: /* refutablep: "{" recpatfields "}"  */
+#line 844 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4293 "hexpr.parse.C"
+#line 4384 "hexpr.parse.C"
     break;
 
-  case 243: /* refutablep: "{" recpatfields "," "}"  */
-#line 836 "hexpr.y"
+  case 252: /* refutablep: "{" recpatfields "," "}"  */
+#line 845 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4299 "hexpr.parse.C"
+#line 4390 "hexpr.parse.C"
     break;
 
-  case 244: /* refutablep: id  */
-#line 837 "hexpr.y"
+  case 253: /* refutablep: id  */
+#line 846 "hexpr.y"
                                        { (yyval.pattern) = patVarCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4305 "hexpr.parse.C"
+#line 4396 "hexpr.parse.C"
     break;
 
-  case 245: /* irrefutablep: id  */
-#line 839 "hexpr.y"
+  case 254: /* irrefutablep: id  */
+#line 848 "hexpr.y"
                                        { (yyval.pattern) = new MatchAny(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4311 "hexpr.parse.C"
+#line 4402 "hexpr.parse.C"
     break;
 
-  case 246: /* irrefutablep: "(" patternseq ")"  */
-#line 840 "hexpr.y"
+  case 255: /* irrefutablep: "(" patternseq ")"  */
+#line 849 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4317 "hexpr.parse.C"
+#line 4408 "hexpr.parse.C"
     break;
 
-  case 247: /* irrefutablep: "(" patternseq "," ")"  */
-#line 841 "hexpr.y"
+  case 256: /* irrefutablep: "(" patternseq "," ")"  */
+#line 850 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4323 "hexpr.parse.C"
+#line 4414 "hexpr.parse.C"
     break;
 
-  case 248: /* irrefutablep: "{" recpatfields "}"  */
-#line 842 "hexpr.y"
+  case 257: /* irrefutablep: "{" recpatfields "}"  */
+#line 851 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4329 "hexpr.parse.C"
+#line 4420 "hexpr.parse.C"
     break;
 
-  case 249: /* irrefutablep: "{" recpatfields "," "}"  */
-#line 843 "hexpr.y"
+  case 258: /* irrefutablep: "{" recpatfields "," "}"  */
+#line 852 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4335 "hexpr.parse.C"
+#line 4426 "hexpr.parse.C"
     break;
 
-  case 250: /* pattern: refutablep  */
-#line 845 "hexpr.y"
+  case 259: /* pattern: refutablep  */
+#line 854 "hexpr.y"
                     { (yyval.pattern) = (yyvsp[0].pattern); }
-#line 4341 "hexpr.parse.C"
+#line 4432 "hexpr.parse.C"
     break;
 
-  case 251: /* patternseq: patternseqn  */
-#line 847 "hexpr.y"
+  case 260: /* patternseq: patternseqn  */
+#line 856 "hexpr.y"
                           { (yyval.patterns) = (yyvsp[0].patterns); }
-#line 4347 "hexpr.parse.C"
+#line 4438 "hexpr.parse.C"
     break;
 
-  case 252: /* patternseq: %empty  */
-#line 848 "hexpr.y"
+  case 261: /* patternseq: %empty  */
+#line 857 "hexpr.y"
                           { (yyval.patterns) = new Patterns(); }
-#line 4353 "hexpr.parse.C"
+#line 4444 "hexpr.parse.C"
     break;
 
-  case 253: /* patternseqn: patternseqn "," pattern  */
-#line 850 "hexpr.y"
+  case 262: /* patternseqn: patternseqn "," pattern  */
+#line 859 "hexpr.y"
                                      { (yyval.patterns) = (yyvsp[-2].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4359 "hexpr.parse.C"
+#line 4450 "hexpr.parse.C"
     break;
 
-  case 254: /* patternseqn: pattern  */
-#line 851 "hexpr.y"
+  case 263: /* patternseqn: pattern  */
+#line 860 "hexpr.y"
                                      { (yyval.patterns) = new Patterns(); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4365 "hexpr.parse.C"
+#line 4456 "hexpr.parse.C"
     break;
 
-  case 255: /* recpatfields: recpatfields "," recpatfield  */
-#line 853 "hexpr.y"
+  case 264: /* recpatfields: recpatfields "," recpatfield  */
+#line 862 "hexpr.y"
                                            { (yyval.recpatfields) = (yyvsp[-2].recpatfields); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4371 "hexpr.parse.C"
+#line 4462 "hexpr.parse.C"
     break;
 
-  case 256: /* recpatfields: recpatfield  */
-#line 854 "hexpr.y"
+  case 265: /* recpatfields: recpatfield  */
+#line 863 "hexpr.y"
                                            { (yyval.recpatfields) = new MatchRecord::Fields(); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4377 "hexpr.parse.C"
+#line 4468 "hexpr.parse.C"
     break;
 
-  case 257: /* recpatfield: id "=" pattern  */
-#line 856 "hexpr.y"
+  case 266: /* recpatfield: id "=" pattern  */
+#line 865 "hexpr.y"
                             { (yyval.recpatfield) = new MatchRecord::Field(*(yyvsp[-2].string), PatternPtr((yyvsp[0].pattern))); }
-#line 4383 "hexpr.parse.C"
+#line 4474 "hexpr.parse.C"
     break;
 
-  case 258: /* recfields: %empty  */
-#line 858 "hexpr.y"
+  case 267: /* recfields: %empty  */
+#line 867 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); }
-#line 4389 "hexpr.parse.C"
+#line 4480 "hexpr.parse.C"
     break;
 
-  case 259: /* recfields: recfieldname "=" l0expr  */
-#line 859 "hexpr.y"
+  case 268: /* recfields: recfieldname "=" l0expr  */
+#line 868 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4395 "hexpr.parse.C"
+#line 4486 "hexpr.parse.C"
     break;
 
-  case 260: /* recfields: recfields "," recfieldname "=" l0expr  */
-#line 860 "hexpr.y"
+  case 269: /* recfields: recfields "," recfieldname "=" l0expr  */
+#line 869 "hexpr.y"
                                                  { (yyval.rfields) = (yyvsp[-4].rfields);                                     (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4401 "hexpr.parse.C"
+#line 4492 "hexpr.parse.C"
     break;
 
-  case 261: /* recfieldname: id  */
-#line 862 "hexpr.y"
+  case 270: /* recfieldname: id  */
+#line 871 "hexpr.y"
                          { (yyval.string) = (yyvsp[0].string); }
-#line 4407 "hexpr.parse.C"
+#line 4498 "hexpr.parse.C"
     break;
 
-  case 262: /* recfieldname: "data"  */
-#line 863 "hexpr.y"
+  case 271: /* recfieldname: "data"  */
+#line 872 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("data")); }
-#line 4413 "hexpr.parse.C"
+#line 4504 "hexpr.parse.C"
     break;
 
-  case 263: /* recfieldname: "type"  */
-#line 864 "hexpr.y"
+  case 272: /* recfieldname: "type"  */
+#line 873 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("type")); }
-#line 4419 "hexpr.parse.C"
+#line 4510 "hexpr.parse.C"
     break;
 
-  case 264: /* recfieldname: "where"  */
-#line 865 "hexpr.y"
+  case 273: /* recfieldname: "where"  */
+#line 874 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("where")); }
-#line 4425 "hexpr.parse.C"
+#line 4516 "hexpr.parse.C"
     break;
 
-  case 265: /* recfieldname: "class"  */
-#line 866 "hexpr.y"
+  case 274: /* recfieldname: "class"  */
+#line 875 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("class")); wantIndent(false); }
-#line 4431 "hexpr.parse.C"
+#line 4522 "hexpr.parse.C"
     break;
 
-  case 266: /* recfieldname: "instance"  */
-#line 867 "hexpr.y"
+  case 275: /* recfieldname: "instance"  */
+#line 876 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("instance")); wantIndent(false); }
-#line 4437 "hexpr.parse.C"
+#line 4528 "hexpr.parse.C"
     break;
 
-  case 267: /* recfieldname: "exists"  */
-#line 868 "hexpr.y"
+  case 276: /* recfieldname: "exists"  */
+#line 877 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("exists")); }
-#line 4443 "hexpr.parse.C"
+#line 4534 "hexpr.parse.C"
     break;
 
-  case 268: /* recfieldname: "import"  */
-#line 869 "hexpr.y"
+  case 277: /* recfieldname: "import"  */
+#line 878 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("import")); }
-#line 4449 "hexpr.parse.C"
+#line 4540 "hexpr.parse.C"
     break;
 
-  case 269: /* recfieldname: "module"  */
-#line 870 "hexpr.y"
+  case 278: /* recfieldname: "module"  */
+#line 879 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("module")); }
-#line 4455 "hexpr.parse.C"
+#line 4546 "hexpr.parse.C"
     break;
 
-  case 270: /* recfieldname: "parse"  */
-#line 871 "hexpr.y"
+  case 279: /* recfieldname: "parse"  */
+#line 880 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("parse")); }
-#line 4461 "hexpr.parse.C"
+#line 4552 "hexpr.parse.C"
     break;
 
-  case 271: /* recfieldname: "do"  */
-#line 872 "hexpr.y"
+  case 280: /* recfieldname: "do"  */
+#line 881 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("do")); }
-#line 4467 "hexpr.parse.C"
+#line 4558 "hexpr.parse.C"
     break;
 
-  case 272: /* recfieldname: "return"  */
-#line 873 "hexpr.y"
+  case 281: /* recfieldname: "return"  */
+#line 882 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("return")); }
-#line 4473 "hexpr.parse.C"
+#line 4564 "hexpr.parse.C"
     break;
 
-  case 273: /* recfieldname: "fn"  */
-#line 874 "hexpr.y"
+  case 282: /* recfieldname: "fn"  */
+#line 883 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("fn")); }
-#line 4479 "hexpr.parse.C"
+#line 4570 "hexpr.parse.C"
     break;
 
-  case 274: /* recfieldname: "intV"  */
-#line 875 "hexpr.y"
+  case 283: /* recfieldname: "intV"  */
+#line 884 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string(".f" + str::from((yyvsp[0].intv)))); }
-#line 4485 "hexpr.parse.C"
+#line 4576 "hexpr.parse.C"
     break;
 
-  case 275: /* recfieldname: "stringV"  */
-#line 876 "hexpr.y"
+  case 284: /* recfieldname: "stringV"  */
+#line 885 "hexpr.y"
                          { std::string stringField = str::unescape(str::trimq(*(yyvsp[0].string)));
                            if (stringField.size() > 0 && stringField[0] == '.' ) {
                              throw annotated_error(m((yylsp[0])), "Cannot define record string label with leading '.'");
                            }
                            (yyval.string) = autorelease(new std::string(str::unescape(str::trimq(*(yyvsp[0].string))))); }
-#line 4495 "hexpr.parse.C"
+#line 4586 "hexpr.parse.C"
     break;
 
-  case 276: /* recfieldpath: recfieldpath "." recfieldname  */
-#line 882 "hexpr.y"
+  case 285: /* recfieldpath: recfieldpath "." recfieldname  */
+#line 891 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-2].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4501 "hexpr.parse.C"
+#line 4592 "hexpr.parse.C"
     break;
 
-  case 277: /* recfieldpath: recfieldpath "tupSection"  */
-#line 883 "hexpr.y"
+  case 286: /* recfieldpath: recfieldpath "tupSection"  */
+#line 892 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-1].strings); str::seq x = tupSectionFields(*(yyvsp[0].string)); (yyval.strings)->insert((yyval.strings)->end(), x.begin(), x.end()); }
-#line 4507 "hexpr.parse.C"
+#line 4598 "hexpr.parse.C"
     break;
 
-  case 278: /* recfieldpath: "." recfieldname  */
-#line 884 "hexpr.y"
+  case 287: /* recfieldpath: "." recfieldname  */
+#line 893 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4513 "hexpr.parse.C"
+#line 4604 "hexpr.parse.C"
     break;
 
-  case 279: /* recfieldpath: "tupSection"  */
-#line 885 "hexpr.y"
+  case 288: /* recfieldpath: "tupSection"  */
+#line 894 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); *(yyval.strings) = tupSectionFields(*(yyvsp[0].string)); }
-#line 4519 "hexpr.parse.C"
+#line 4610 "hexpr.parse.C"
     break;
 
-  case 280: /* varfields: varbind  */
-#line 887 "hexpr.y"
+  case 289: /* varfields: varbind  */
+#line 896 "hexpr.y"
                                  { (yyval.vfields) = autorelease(new Case::Bindings()); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4525 "hexpr.parse.C"
+#line 4616 "hexpr.parse.C"
     break;
 
-  case 281: /* varfields: varfields "," varbind  */
-#line 888 "hexpr.y"
+  case 290: /* varfields: varfields "," varbind  */
+#line 897 "hexpr.y"
                                  { (yyval.vfields) = (yyvsp[-2].vfields); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4531 "hexpr.parse.C"
+#line 4622 "hexpr.parse.C"
     break;
 
-  case 282: /* varbind: id "=" l0expr  */
-#line 890 "hexpr.y"
+  case 291: /* varbind: id "=" l0expr  */
+#line 899 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-2].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4537 "hexpr.parse.C"
+#line 4628 "hexpr.parse.C"
     break;
 
-  case 283: /* varbind: id ":" id "=" l0expr  */
-#line 891 "hexpr.y"
+  case 292: /* varbind: id ":" id "=" l0expr  */
+#line 900 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-4].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4543 "hexpr.parse.C"
+#line 4634 "hexpr.parse.C"
     break;
 
-  case 284: /* varbind: "intV" ":" id "=" l0expr  */
-#line 892 "hexpr.y"
+  case 293: /* varbind: "intV" ":" id "=" l0expr  */
+#line 901 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(".f" + str::from((yyvsp[-4].intv)), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4549 "hexpr.parse.C"
+#line 4640 "hexpr.parse.C"
     break;
 
-  case 285: /* cargs: %empty  */
-#line 894 "hexpr.y"
+  case 294: /* cargs: %empty  */
+#line 903 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); }
-#line 4555 "hexpr.parse.C"
+#line 4646 "hexpr.parse.C"
     break;
 
-  case 286: /* cargs: l0expr  */
-#line 895 "hexpr.y"
+  case 295: /* cargs: l0expr  */
+#line 904 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4561 "hexpr.parse.C"
+#line 4652 "hexpr.parse.C"
     break;
 
-  case 287: /* cargs: cargs "," l0expr  */
-#line 896 "hexpr.y"
+  case 296: /* cargs: cargs "," l0expr  */
+#line 905 "hexpr.y"
                         { (yyvsp[-2].exps)->push_back(ExprPtr((yyvsp[0].exp))); (yyval.exps) = (yyvsp[-2].exps); }
-#line 4567 "hexpr.parse.C"
+#line 4658 "hexpr.parse.C"
     break;
 
-  case 288: /* qtype: cst "=>" l0mtype  */
-#line 898 "hexpr.y"
+  case 297: /* qtype: cst "=>" l0mtype  */
+#line 907 "hexpr.y"
                          { (yyval.qualtype) = new QualType(*(yyvsp[-2].tconstraints), *(yyvsp[0].mtype)); }
-#line 4573 "hexpr.parse.C"
+#line 4664 "hexpr.parse.C"
     break;
 
-  case 289: /* qtype: l0mtype  */
-#line 899 "hexpr.y"
+  case 298: /* qtype: l0mtype  */
+#line 908 "hexpr.y"
                          { (yyval.qualtype) = new QualType(Constraints(), *(yyvsp[0].mtype)); }
-#line 4579 "hexpr.parse.C"
+#line 4670 "hexpr.parse.C"
     break;
 
-  case 290: /* cst: "(" tpreds ")"  */
-#line 902 "hexpr.y"
+  case 299: /* cst: "(" tpreds ")"  */
+#line 911 "hexpr.y"
                     { (yyval.tconstraints) = (yyvsp[-1].tconstraints); }
-#line 4585 "hexpr.parse.C"
+#line 4676 "hexpr.parse.C"
     break;
 
-  case 291: /* tpreds: tpred  */
-#line 904 "hexpr.y"
+  case 300: /* tpreds: tpred  */
+#line 913 "hexpr.y"
                          { (yyval.tconstraints) = autorelease(new Constraints()); (yyval.tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); }
-#line 4591 "hexpr.parse.C"
+#line 4682 "hexpr.parse.C"
     break;
 
-  case 292: /* tpreds: tpreds "," tpred  */
-#line 905 "hexpr.y"
+  case 301: /* tpreds: tpreds "," tpred  */
+#line 914 "hexpr.y"
                          { (yyvsp[-2].tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); (yyval.tconstraints) = (yyvsp[-2].tconstraints); }
-#line 4597 "hexpr.parse.C"
+#line 4688 "hexpr.parse.C"
     break;
 
-  case 293: /* tpred: id l1mtargl  */
-#line 907 "hexpr.y"
+  case 302: /* tpred: id l1mtargl  */
+#line 916 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(*(yyvsp[-1].string), *(yyvsp[0].mtypes)); }
-#line 4603 "hexpr.parse.C"
+#line 4694 "hexpr.parse.C"
     break;
 
-  case 294: /* tpred: l1mtype "==" l1mtype  */
-#line 908 "hexpr.y"
+  case 303: /* tpred: l1mtype "==" l1mtype  */
+#line 917 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(EqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4609 "hexpr.parse.C"
+#line 4700 "hexpr.parse.C"
     break;
 
-  case 295: /* tpred: l1mtype "!=" l1mtype  */
-#line 909 "hexpr.y"
+  case 304: /* tpred: l1mtype "!=" l1mtype  */
+#line 918 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(NotEqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4615 "hexpr.parse.C"
+#line 4706 "hexpr.parse.C"
     break;
 
-  case 296: /* tpred: l1mtype "~" l1mtype  */
-#line 910 "hexpr.y"
+  case 305: /* tpred: l1mtype "~" l1mtype  */
+#line 919 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(FixIsoRecur::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4621 "hexpr.parse.C"
+#line 4712 "hexpr.parse.C"
     break;
 
-  case 297: /* tpred: l1mtype "=" "{" l1mtype "*" l1mtype "}"  */
-#line 911 "hexpr.y"
+  case 306: /* tpred: l1mtype "=" "{" l1mtype "*" l1mtype "}"  */
+#line 920 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4627 "hexpr.parse.C"
+#line 4718 "hexpr.parse.C"
     break;
 
-  case 298: /* tpred: l1mtype "=" "{" id ":" l1mtype "*" l1mtype "}"  */
-#line 912 "hexpr.y"
+  case 307: /* tpred: l1mtype "=" "{" id ":" l1mtype "*" l1mtype "}"  */
+#line 921 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4633 "hexpr.parse.C"
+#line 4724 "hexpr.parse.C"
     break;
 
-  case 299: /* tpred: l1mtype "=" "(" l1mtype "*" l1mtype ")"  */
-#line 913 "hexpr.y"
+  case 308: /* tpred: l1mtype "=" "(" l1mtype "*" l1mtype ")"  */
+#line 922 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4639 "hexpr.parse.C"
+#line 4730 "hexpr.parse.C"
     break;
 
-  case 300: /* tpred: "{" l1mtype "*" l1mtype "}" "=" l1mtype  */
-#line 914 "hexpr.y"
+  case 309: /* tpred: "{" l1mtype "*" l1mtype "}" "=" l1mtype  */
+#line 923 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4645 "hexpr.parse.C"
+#line 4736 "hexpr.parse.C"
     break;
 
-  case 301: /* tpred: "{" id ":" l1mtype "*" l1mtype "}" "=" l1mtype  */
-#line 915 "hexpr.y"
+  case 310: /* tpred: "{" id ":" l1mtype "*" l1mtype "}" "=" l1mtype  */
+#line 924 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4651 "hexpr.parse.C"
+#line 4742 "hexpr.parse.C"
     break;
 
-  case 302: /* tpred: "(" l1mtype "*" l1mtype ")" "=" l1mtype  */
-#line 916 "hexpr.y"
+  case 311: /* tpred: "(" l1mtype "*" l1mtype ")" "=" l1mtype  */
+#line 925 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(1), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4657 "hexpr.parse.C"
+#line 4748 "hexpr.parse.C"
     break;
 
-  case 303: /* tpred: l1mtype "." recfieldname "::" l1mtype  */
-#line 918 "hexpr.y"
+  case 312: /* tpred: l1mtype "." recfieldname "::" l1mtype  */
+#line 927 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4663 "hexpr.parse.C"
+#line 4754 "hexpr.parse.C"
     break;
 
-  case 304: /* tpred: l1mtype "." recfieldname "<-" l1mtype  */
-#line 919 "hexpr.y"
+  case 313: /* tpred: l1mtype "." recfieldname "<-" l1mtype  */
+#line 928 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4669 "hexpr.parse.C"
+#line 4760 "hexpr.parse.C"
     break;
 
-  case 305: /* tpred: l1mtype "/" l1mtype "::" l1mtype  */
-#line 920 "hexpr.y"
+  case 314: /* tpred: l1mtype "/" l1mtype "::" l1mtype  */
+#line 929 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4675 "hexpr.parse.C"
+#line 4766 "hexpr.parse.C"
     break;
 
-  case 306: /* tpred: l1mtype "/" l1mtype "<-" l1mtype  */
-#line 921 "hexpr.y"
+  case 315: /* tpred: l1mtype "/" l1mtype "<-" l1mtype  */
+#line 930 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4681 "hexpr.parse.C"
+#line 4772 "hexpr.parse.C"
     break;
 
-  case 307: /* tpred: l1mtype "=" "|" l1mtype "+" l1mtype "|"  */
-#line 923 "hexpr.y"
+  case 316: /* tpred: l1mtype "=" "|" l1mtype "+" l1mtype "|"  */
+#line 932 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4687 "hexpr.parse.C"
+#line 4778 "hexpr.parse.C"
     break;
 
-  case 308: /* tpred: "|" l1mtype "+" l1mtype "|" "=" l1mtype  */
-#line 924 "hexpr.y"
+  case 317: /* tpred: "|" l1mtype "+" l1mtype "|" "=" l1mtype  */
+#line 933 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4693 "hexpr.parse.C"
+#line 4784 "hexpr.parse.C"
     break;
 
-  case 309: /* tpred: l1mtype "=" "|" id ":" l1mtype "+" l1mtype "|"  */
-#line 925 "hexpr.y"
+  case 318: /* tpred: l1mtype "=" "|" id ":" l1mtype "+" l1mtype "|"  */
+#line 934 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4699 "hexpr.parse.C"
+#line 4790 "hexpr.parse.C"
     break;
 
-  case 310: /* tpred: "|" id ":" l1mtype "+" l1mtype "|" "=" l1mtype  */
-#line 926 "hexpr.y"
+  case 319: /* tpred: "|" id ":" l1mtype "+" l1mtype "|" "=" l1mtype  */
+#line 935 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4705 "hexpr.parse.C"
+#line 4796 "hexpr.parse.C"
     break;
 
-  case 311: /* tpred: "|" id ":" l0mtype "|" "::" l1mtype  */
-#line 928 "hexpr.y"
+  case 320: /* tpred: "|" id ":" l0mtype "|" "::" l1mtype  */
+#line 937 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), TString::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype))); }
-#line 4711 "hexpr.parse.C"
+#line 4802 "hexpr.parse.C"
     break;
 
-  case 312: /* tpred: "|" l1mtype "/" l0mtype "|" "::" l1mtype  */
-#line 929 "hexpr.y"
+  case 321: /* tpred: "|" l1mtype "/" l0mtype "|" "::" l1mtype  */
+#line 938 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), *(yyvsp[-5].mtype),                *(yyvsp[-3].mtype))); }
-#line 4717 "hexpr.parse.C"
+#line 4808 "hexpr.parse.C"
     break;
 
-  case 313: /* tpred: l1mtype "++" l1mtype "=" l1mtype  */
-#line 930 "hexpr.y"
+  case 322: /* tpred: l1mtype "++" l1mtype "=" l1mtype  */
+#line 939 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(AppendsToUnqualifier::constraintName(), list(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4723 "hexpr.parse.C"
+#line 4814 "hexpr.parse.C"
     break;
 
-  case 314: /* l1mtargl: l1mtype  */
-#line 932 "hexpr.y"
+  case 323: /* l1mtargl: l1mtype  */
+#line 941 "hexpr.y"
                            { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4729 "hexpr.parse.C"
+#line 4820 "hexpr.parse.C"
     break;
 
-  case 315: /* l1mtargl: l1mtargl l1mtype  */
-#line 933 "hexpr.y"
+  case 324: /* l1mtargl: l1mtargl l1mtype  */
+#line 942 "hexpr.y"
                            { (yyvsp[-1].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 4735 "hexpr.parse.C"
+#line 4826 "hexpr.parse.C"
     break;
 
-  case 316: /* ltmtype: ltmtype l0mtype  */
-#line 935 "hexpr.y"
+  case 325: /* ltmtype: ltmtype l0mtype  */
+#line 944 "hexpr.y"
                           { (yyval.mtypes) = (yyvsp[-1].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4741 "hexpr.parse.C"
+#line 4832 "hexpr.parse.C"
     break;
 
-  case 317: /* ltmtype: l0mtype  */
-#line 936 "hexpr.y"
+  case 326: /* ltmtype: l0mtype  */
+#line 945 "hexpr.y"
                           { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4747 "hexpr.parse.C"
+#line 4838 "hexpr.parse.C"
     break;
 
-  case 318: /* l0mtype: l0mtargl "->" l1mtype  */
-#line 938 "hexpr.y"
+  case 327: /* l0mtype: l0mtargl "->" l1mtype  */
+#line 947 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(Func::make(tuplety(*(yyvsp[-2].mtypes)), *(yyvsp[0].mtype)))); }
-#line 4753 "hexpr.parse.C"
+#line 4844 "hexpr.parse.C"
     break;
 
-  case 319: /* l0mtype: mtuplist  */
-#line 939 "hexpr.y"
+  case 328: /* l0mtype: mtuplist  */
+#line 948 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeTupleType(*(yyvsp[0].mtypes)))); }
-#line 4759 "hexpr.parse.C"
+#line 4850 "hexpr.parse.C"
     break;
 
-  case 320: /* l0mtype: msumlist  */
-#line 940 "hexpr.y"
+  case 329: /* l0mtype: msumlist  */
+#line 949 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeSumType(*(yyvsp[0].mtypes)))); }
-#line 4765 "hexpr.parse.C"
+#line 4856 "hexpr.parse.C"
     break;
 
-  case 321: /* l1mtype: id  */
-#line 942 "hexpr.y"
+  case 330: /* l1mtype: id  */
+#line 951 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(monoTypeByName(*(yyvsp[0].string)))); }
-#line 4771 "hexpr.parse.C"
+#line 4862 "hexpr.parse.C"
     break;
 
-  case 322: /* l1mtype: "<" cppid ">"  */
-#line 943 "hexpr.y"
+  case 331: /* l1mtype: "<" cppid ">"  */
+#line 952 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(OpaquePtr::make(str::replace<char>(*(yyvsp[-1].string), ".", "::"), 0, false))); }
-#line 4777 "hexpr.parse.C"
+#line 4868 "hexpr.parse.C"
     break;
 
-  case 323: /* l1mtype: "[" "]"  */
-#line 944 "hexpr.y"
+  case 332: /* l1mtype: "[" "]"  */
+#line 953 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("[]"))); }
-#line 4783 "hexpr.parse.C"
+#line 4874 "hexpr.parse.C"
     break;
 
-  case 324: /* l1mtype: "[" ltmtype "]"  */
-#line 945 "hexpr.y"
+  case 333: /* l1mtype: "[" ltmtype "]"  */
+#line 954 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(Array::make(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4789 "hexpr.parse.C"
+#line 4880 "hexpr.parse.C"
     break;
 
-  case 325: /* l1mtype: "[" ":" l0mtype "|" tyind ":" "]"  */
-#line 946 "hexpr.y"
+  case 334: /* l1mtype: "[" ":" l0mtype "|" tyind ":" "]"  */
+#line 955 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(FixedArray::make(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype)))); }
-#line 4795 "hexpr.parse.C"
+#line 4886 "hexpr.parse.C"
     break;
 
-  case 326: /* l1mtype: "(" "->" ")"  */
-#line 947 "hexpr.y"
+  case 335: /* l1mtype: "(" "->" ")"  */
+#line 956 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("->"))); }
-#line 4801 "hexpr.parse.C"
+#line 4892 "hexpr.parse.C"
     break;
 
-  case 327: /* l1mtype: "(" ltmtype ")"  */
-#line 948 "hexpr.y"
+  case 336: /* l1mtype: "(" ltmtype ")"  */
+#line 957 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(clone(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4807 "hexpr.parse.C"
+#line 4898 "hexpr.parse.C"
     break;
 
-  case 328: /* l1mtype: "{" mreclist "}"  */
-#line 949 "hexpr.y"
+  case 337: /* l1mtype: "{" mreclist "}"  */
+#line 958 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeRecType(*(yyvsp[-1].mreclist)))); }
-#line 4813 "hexpr.parse.C"
+#line 4904 "hexpr.parse.C"
     break;
 
-  case 329: /* l1mtype: "|" mvarlist "|"  */
-#line 950 "hexpr.y"
+  case 338: /* l1mtype: "|" mvarlist "|"  */
+#line 959 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeVarType(*(yyvsp[-1].mvarlist)))); }
-#line 4819 "hexpr.parse.C"
+#line 4910 "hexpr.parse.C"
     break;
 
-  case 330: /* l1mtype: "(" ")"  */
-#line 951 "hexpr.y"
+  case 339: /* l1mtype: "(" ")"  */
+#line 960 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("unit"))); }
-#line 4825 "hexpr.parse.C"
+#line 4916 "hexpr.parse.C"
     break;
 
-  case 331: /* l1mtype: "intV"  */
-#line 952 "hexpr.y"
+  case 340: /* l1mtype: "intV"  */
+#line 961 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(((yyvsp[0].intv) == 0) ? Prim::make("void") : TLong::make((yyvsp[0].intv)))); }
-#line 4831 "hexpr.parse.C"
+#line 4922 "hexpr.parse.C"
     break;
 
-  case 332: /* l1mtype: "boolV"  */
-#line 953 "hexpr.y"
+  case 341: /* l1mtype: "boolV"  */
+#line 962 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr((yyvsp[0].boolv) ? TLong::make(1) : TLong::make(0))); }
-#line 4837 "hexpr.parse.C"
+#line 4928 "hexpr.parse.C"
     break;
 
-  case 333: /* l1mtype: "exists" id "." l1mtype  */
-#line 954 "hexpr.y"
+  case 342: /* l1mtype: "exists" id "." l1mtype  */
+#line 963 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Exists::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4843 "hexpr.parse.C"
+#line 4934 "hexpr.parse.C"
     break;
 
-  case 334: /* l1mtype: l1mtype "@" l1mtype  */
-#line 955 "hexpr.y"
+  case 343: /* l1mtype: l1mtype "@" l1mtype  */
+#line 964 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype), *(yyvsp[0].mtype)))); }
-#line 4849 "hexpr.parse.C"
+#line 4940 "hexpr.parse.C"
     break;
 
-  case 335: /* l1mtype: l1mtype "@" "?"  */
-#line 956 "hexpr.y"
+  case 344: /* l1mtype: l1mtype "@" "?"  */
+#line 965 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype)))); }
-#line 4855 "hexpr.parse.C"
+#line 4946 "hexpr.parse.C"
     break;
 
-  case 336: /* l1mtype: "^" id "." l1mtype  */
-#line 957 "hexpr.y"
+  case 345: /* l1mtype: "^" id "." l1mtype  */
+#line 966 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Recursive::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4861 "hexpr.parse.C"
+#line 4952 "hexpr.parse.C"
     break;
 
-  case 337: /* l1mtype: "stringV"  */
-#line 958 "hexpr.y"
+  case 346: /* l1mtype: "stringV"  */
+#line 967 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TString::make(str::unescape(str::trimq(*(yyvsp[0].string)))))); }
-#line 4867 "hexpr.parse.C"
+#line 4958 "hexpr.parse.C"
     break;
 
-  case 338: /* l1mtype: "`" l0expr "`"  */
-#line 959 "hexpr.y"
+  case 347: /* l1mtype: "`" l0expr "`"  */
+#line 968 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TApp::make(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp))))))); }
-#line 4873 "hexpr.parse.C"
+#line 4964 "hexpr.parse.C"
     break;
 
-  case 339: /* tyind: id  */
-#line 961 "hexpr.y"
+  case 348: /* tyind: id  */
+#line 970 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TVar::make(*(yyvsp[0].string)))); }
-#line 4879 "hexpr.parse.C"
+#line 4970 "hexpr.parse.C"
     break;
 
-  case 340: /* tyind: "intV"  */
-#line 962 "hexpr.y"
+  case 349: /* tyind: "intV"  */
+#line 971 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TLong::make((yyvsp[0].intv)))); }
-#line 4885 "hexpr.parse.C"
+#line 4976 "hexpr.parse.C"
     break;
 
-  case 341: /* cppid: id  */
-#line 964 "hexpr.y"
+  case 350: /* cppid: id  */
+#line 973 "hexpr.y"
                     { (yyval.string) = (yyvsp[0].string); }
-#line 4891 "hexpr.parse.C"
+#line 4982 "hexpr.parse.C"
     break;
 
-  case 342: /* cppid: cppid "." id  */
-#line 965 "hexpr.y"
+  case 351: /* cppid: cppid "." id  */
+#line 974 "hexpr.y"
                     { (yyval.string) = (yyvsp[-2].string); *(yyval.string) += "."; *(yyval.string) += *(yyvsp[0].string); }
-#line 4897 "hexpr.parse.C"
+#line 4988 "hexpr.parse.C"
     break;
 
-  case 343: /* l0mtargl: l1mtype  */
-#line 967 "hexpr.y"
+  case 352: /* l0mtargl: l1mtype  */
+#line 976 "hexpr.y"
                                         { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4903 "hexpr.parse.C"
+#line 4994 "hexpr.parse.C"
     break;
 
-  case 344: /* l0mtargl: "(" l0mtype "," l0mtarglt ")"  */
-#line 968 "hexpr.y"
+  case 353: /* l0mtargl: "(" l0mtype "," l0mtarglt ")"  */
+#line 977 "hexpr.y"
                                         { (yyvsp[-1].mtypes)->insert((yyvsp[-1].mtypes)->begin(), *(yyvsp[-3].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 4909 "hexpr.parse.C"
+#line 5000 "hexpr.parse.C"
     break;
 
-  case 345: /* l0mtarglt: l0mtype  */
-#line 970 "hexpr.y"
+  case 354: /* l0mtarglt: l0mtype  */
+#line 979 "hexpr.y"
                                  { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4915 "hexpr.parse.C"
+#line 5006 "hexpr.parse.C"
     break;
 
-  case 346: /* l0mtarglt: l0mtarglt "," l0mtype  */
-#line 971 "hexpr.y"
+  case 355: /* l0mtarglt: l0mtarglt "," l0mtype  */
+#line 980 "hexpr.y"
                                  { (yyvsp[-2].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-2].mtypes); }
-#line 4921 "hexpr.parse.C"
+#line 5012 "hexpr.parse.C"
     break;
 
-  case 347: /* mtuplist: l1mtype  */
-#line 973 "hexpr.y"
+  case 356: /* mtuplist: l1mtype  */
+#line 982 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4927 "hexpr.parse.C"
+#line 5018 "hexpr.parse.C"
     break;
 
-  case 348: /* mtuplist: mtuplist "*" l1mtype  */
-#line 974 "hexpr.y"
+  case 357: /* mtuplist: mtuplist "*" l1mtype  */
+#line 983 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4933 "hexpr.parse.C"
+#line 5024 "hexpr.parse.C"
     break;
 
-  case 349: /* msumlist: l1mtype "+" l1mtype  */
-#line 976 "hexpr.y"
+  case 358: /* msumlist: l1mtype "+" l1mtype  */
+#line 985 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[-2].mtype)); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4939 "hexpr.parse.C"
+#line 5030 "hexpr.parse.C"
     break;
 
-  case 350: /* msumlist: msumlist "+" l1mtype  */
-#line 977 "hexpr.y"
+  case 359: /* msumlist: msumlist "+" l1mtype  */
+#line 986 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4945 "hexpr.parse.C"
+#line 5036 "hexpr.parse.C"
     break;
 
-  case 351: /* mreclist: mreclist "," id ":" l0mtype  */
-#line 979 "hexpr.y"
+  case 360: /* mreclist: mreclist "," id ":" l0mtype  */
+#line 988 "hexpr.y"
                                       { (yyval.mreclist) = (yyvsp[-4].mreclist);                                 (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 4951 "hexpr.parse.C"
+#line 5042 "hexpr.parse.C"
     break;
 
-  case 352: /* mreclist: id ":" l0mtype  */
-#line 980 "hexpr.y"
+  case 361: /* mreclist: id ":" l0mtype  */
+#line 989 "hexpr.y"
                                       { (yyval.mreclist) = autorelease(new Record::Members()); (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 4957 "hexpr.parse.C"
+#line 5048 "hexpr.parse.C"
     break;
 
-  case 353: /* mvarlist: mvarlist "," id ":" l0mtype  */
-#line 982 "hexpr.y"
+  case 362: /* mvarlist: mvarlist "," id ":" l0mtype  */
+#line 991 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-4].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 4963 "hexpr.parse.C"
+#line 5054 "hexpr.parse.C"
     break;
 
-  case 354: /* mvarlist: mvarlist "," id  */
-#line 983 "hexpr.y"
+  case 363: /* mvarlist: mvarlist "," id  */
+#line 992 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-2].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 4969 "hexpr.parse.C"
+#line 5060 "hexpr.parse.C"
     break;
 
-  case 355: /* mvarlist: id ":" l0mtype  */
-#line 984 "hexpr.y"
+  case 364: /* mvarlist: id ":" l0mtype  */
+#line 993 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 4975 "hexpr.parse.C"
+#line 5066 "hexpr.parse.C"
     break;
 
-  case 356: /* mvarlist: id  */
-#line 985 "hexpr.y"
+  case 365: /* mvarlist: id  */
+#line 994 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 4981 "hexpr.parse.C"
+#line 5072 "hexpr.parse.C"
     break;
 
 
-#line 4985 "hexpr.parse.C"
+#line 5076 "hexpr.parse.C"
 
       default: break;
     }
@@ -5211,7 +5302,7 @@ yyreturn:
   return yyresult;
 }
 
-#line 989 "hexpr.y"
+#line 998 "hexpr.y"
 
 #pragma GCC diagnostic pop
 
diff --git a/lib/hobbes/read/pgen/hexpr.y b/lib/hobbes/read/pgen/hexpr.y
index 4cbfe7bce..6284c0a4d 100644
--- a/lib/hobbes/read/pgen/hexpr.y
+++ b/lib/hobbes/read/pgen/hexpr.y
@@ -518,6 +518,15 @@ def: importdef { $$ = $1; }
    | id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10), ExprPtr($12), m(@1, @12)); }
    | id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11), ExprPtr($13), m(@1, @13)); }
    | id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12), ExprPtr($14), m(@1, @14)); }
+   | id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13), ExprPtr($15), m(@1, @15)); }
+   | id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14), ExprPtr($16), m(@1, @16)); }
+   | id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15), ExprPtr($17), m(@1, @17)); }
+   | id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16), ExprPtr($18), m(@1, @18)); }
+   | id id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16, *$17), ExprPtr($19), m(@1, @19)); }
+   | id id id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16, *$17, *$18), ExprPtr($20), m(@1, @20)); }
+   | id id id id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16, *$17, *$18, *$19), ExprPtr($21), m(@1, @21)); }
+   | id id id id id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16, *$17, *$18, *$19, *$20), ExprPtr($22), m(@1, @22)); }
+   | id id id id id id id id id id id id id id id id id id id id id "=" l0expr { $$ = new MVarDef(list(*$1, *$2, *$3, *$4, *$5, *$6, *$7, *$8, *$9, *$10, *$11, *$12, *$13, *$14, *$15, *$16, *$17, *$18, *$19, *$20, *$21), ExprPtr($23), m(@1, @23)); }
 
    // evaluate an expression just for side-effects, then discard it
    | l5expr { $$ = new MVarDef(list(freshName()), let(freshName(), ExprPtr($1), mktunit(m(@1)), m(@1)), m(@1)); }

From d3e2a51e12fbed2c37da4f063ed2603806ab279e Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 11 Aug 2021 19:38:36 +0000
Subject: [PATCH 13/40] add address and undefined sanitizers to github action
 (#417)

* add address and undefined sanitizers to github action

* fix Python.C failed under sanitizers check

* get sanitizers check clang build only

* minor fixes in build files

* suppress reflect.H ubsan error

* disable implicit-signed-integer-truncation check, integaral promotion causes too many failures in current code base

* get address of a null pointer is not allowed, using offsetof instead

* replace hobbes::variant in jitcc.C
---
 .github/workflows/build.yml |  29 ++++++
 CMakeLists.txt              |  15 ++-
 flake.nix                   |   4 +-
 include/hobbes/fregion.H    |   3 +
 lib/hobbes/eval/jitcc.C     | 188 +++++++++++++++++++++++++++++++++++-
 nix/overlays.nix            |  36 ++++++-
 nix/ubsan_supp.patch        |  24 +++++
 test/Structs.C              |   9 +-
 8 files changed, 299 insertions(+), 9 deletions(-)
 create mode 100644 nix/ubsan_supp.patch

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 2cea80578..c9dfc1de8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,35 @@
 name: "Build"
 on: [push, pull_request]
 jobs:
+  linux-clang-ASanAndUBSan-build:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ubuntu-20.04]
+        clang: [8]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+            # Nix Flakes doesn't work on shallow clones
+            fetch-depth: 0
+      - uses: cachix/install-nix-action@v12
+        with:
+          install_url: https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20201221_9fab14a/install
+          extra_nix_config: |
+            experimental-features = nix-command flakes ca-references
+      - name: nix build hobbesPackages/clang-${{ matrix.clang }}-ASanAndUBSan/hobbes
+        run: |
+          nix build .#hobbesPackages/clang-${{ matrix.clang }}-ASanAndUBSan/hobbes
+      - name: nix log hobbesPackages/clang-${{ matrix.clang }}-ASanAndUBSan/hobbes
+        if: ${{ always() }}
+        run: |
+          nix log  .#hobbesPackages/clang-${{ matrix.clang }}-ASanAndUBSan/hobbes &> ${{ matrix.os }}-clang-${{ matrix.clang }}-ASanAndUBSan-hobbes.log
+      - name: upload log ${{ matrix.os }}-clang-${{ matrix.clang }}-ASanAndUBSan-hobbes.log
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v1
+        with:
+          name: output-log-file
+          path: ${{ matrix.os }}-clang-${{ matrix.clang }}-ASanAndUBSan-hobbes.log
   linux-clang-build:
     runs-on: ${{matrix.os}}
     strategy:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dc8b250d6..10b30a169 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -81,6 +81,19 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flags}")
 set(CMAKE_CXX_FLAGS_DEBUG "-g")
 set(CMAKE_CXX_FLAGS_RELEASE "-O2")
 
+option(USE_ASAN_UBSAN "Use address,undefined sanitizers" OFF)
+if(USE_ASAN_AND_UBSAN)
+  # _FORTIFY_SOURCE doesn't play well with asan
+  # https://github.com/google/sanitizers/issues/247
+  add_definitions(-U_FORTIFY_SOURCE)
+  add_compile_options("-fno-omit-frame-pointer;-fsanitize=address,undefined;-fno-optimize-sibling-calls;-fno-sanitize-recover=all")
+  add_link_options("-fsanitize=address,undefined;-fno-optimize-sibling-calls;-fno-sanitize-recover=all")
+  add_compile_options("$<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-fsanitize=local-bounds,float-divide-by-zero,nullability,signed-integer-overflow,shift,integer-divide-by-zero>")
+  add_link_options("$<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-fsanitize=local-bounds,float-divide-by-zero,nullability,signed-integer-overflow,shift,integer-divide-by-zero>")
+  add_compile_options("$<$<CXX_COMPILER_ID:GNU>:--param=max-vartrack-size=60000000>")
+  message(STATUS "address and undefined sanitizers enabled")
+endif()
+
 add_library(hobbes STATIC ${lib_files})
 target_link_libraries(hobbes PUBLIC ${llvm_ldflags} ${llvm_libs} ${ZLIB_LIBRARIES} ${CURSES_LIBRARIES} ${sys_libs})
 add_library(hobbes-pic STATIC ${lib_files})
@@ -96,7 +109,7 @@ enable_testing()
 add_executable(hobbes-test ${test_files})
 target_link_libraries(hobbes-test PRIVATE hobbes)
 add_test(hobbes-test hobbes-test)
-include(FindPythonInterp)
+find_package(PythonInterp 2.7 REQUIRED)
 set_property(TARGET hobbes-test PROPERTY COMPILE_FLAGS "-DPYTHON_EXECUTABLE=\"${PYTHON_EXECUTABLE}\" -DSCRIPT_DIR=\"${CMAKE_SOURCE_DIR}/scripts/\"")
 
 install(TARGETS hobbes hobbes-pic DESTINATION "lib")
diff --git a/flake.nix b/flake.nix
index ffc7d13b6..8b9ab9903 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,6 +1,6 @@
 {
   description = "A language and an embedded JIT compiler";
-  
+
   inputs.flake-utils.url = "github:numtide/flake-utils";
 
   outputs = { self, nixpkgs, flake-utils }:
@@ -20,7 +20,7 @@
             ];
           })
         ];
-        
+
         pkgs = import nixpkgs {
           inherit system overlays;
         };
diff --git a/include/hobbes/fregion.H b/include/hobbes/fregion.H
index 24a4b8988..b507fd0c8 100644
--- a/include/hobbes/fregion.H
+++ b/include/hobbes/fregion.H
@@ -262,6 +262,9 @@ template <typename T>
   }
 template <typename TIter>
   inline void writes(imagefile* f, TIter begin, TIter end) {
+    if (begin == end) {
+      return;
+    }
     fdwrite(f, reinterpret_cast<const char*>(&(*begin)), (end - begin) * sizeof(*begin));
   }
 inline void write(imagefile* f, const std::string& x) {
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index 6bc76d480..e8caf497a 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -26,6 +26,13 @@
 
 #if LLVM_VERSION_MAJOR >= 11
 #include <hobbes/eval/orcjitcc.H>
+
+#include <cstdio>
+#include <cassert>
+#include <type_traits>
+#include <new>
+#include <memory>
+#include <limits>
 #else
 #if LLVM_VERSION_MINOR == 3 or LLVM_VERSION_MINOR == 5
 #include <llvm/ExecutionEngine/JIT.h>
@@ -49,6 +56,181 @@
 
 #if LLVM_VERSION_MAJOR >= 11
 namespace {
+template <typename T, typename... Ts> struct hasType {
+  static constexpr bool value = false;
+};
+
+template <typename T, typename H, typename... Ts> struct hasType<T, H, Ts...> {
+  static constexpr bool value =
+      std::is_same<T, H>::value || hasType<T, Ts...>::value;
+};
+
+template <typename... Ts> struct hasDuplication {
+  static constexpr bool value = false;
+};
+
+template <typename T, typename... Ts> struct hasDuplication<T, Ts...> {
+  static constexpr bool value =
+      hasType<T, Ts...>::value || hasDuplication<Ts...>::value;
+};
+
+template <typename T, typename... Ts> struct IndexByType;
+
+template <typename T, typename... Ts> struct IndexByType<T, T, Ts...> {
+  static constexpr int value = 0;
+};
+
+template <typename T, typename U, typename... Ts>
+struct IndexByType<T, U, Ts...> {
+  static constexpr int value = 1 + IndexByType<T, Ts...>::value;
+};
+
+template <typename U, typename... Ts> struct VariantLiteTypeMatch {
+  static bool act(std::size_t, std::size_t) { return false; }
+};
+
+template <typename U, typename T, typename... Ts>
+struct VariantLiteTypeMatch<U, T, Ts...> {
+  static bool act(std::size_t N, std::size_t tag) {
+    if (tag == (N - sizeof...(Ts) - 1U)) {
+      return std::is_same<U, T>::value;
+    } else {
+      return VariantLiteTypeMatch<U, Ts...>::act(N, tag);
+    }
+  }
+};
+
+template <typename... Ts> struct VariantLiteDeletor {
+  static void act(std::size_t, std::size_t, void *) {}
+};
+
+template <typename T, typename... Ts> struct VariantLiteDeletor<T, Ts...> {
+  static void act(std::size_t N, std::size_t tag, void *storage) {
+    if (tag == (N - sizeof...(Ts) - 1)) {
+      reinterpret_cast<T *>(storage)->~T();
+    } else {
+      VariantLiteDeletor<Ts...>::act(N, tag, storage);
+    }
+  }
+};
+
+template <typename... Ts> struct VariantLiteCopyCreator {
+  static void act(std::size_t, std::size_t, void *, const void *) {}
+};
+
+template <typename T, typename... Ts> struct VariantLiteCopyCreator<T, Ts...> {
+  static void act(std::size_t N, std::size_t other_tag, void *this_storage,
+                  const void *other_storage) {
+    if (other_tag == (N - sizeof...(Ts) - 1)) {
+      new (this_storage) T(*reinterpret_cast<const T *>(other_storage));
+    } else {
+      VariantLiteCopyCreator<Ts...>::act(N, other_tag, this_storage,
+                                         other_storage);
+    }
+  }
+};
+
+template <typename... Ts> struct VariantLiteMoveCreator {
+  static void act(std::size_t, std::size_t, void *, const void *) {}
+};
+
+template <typename T, typename... Ts> struct VariantLiteMoveCreator<T, Ts...> {
+  static void act(std::size_t N, std::size_t other_tag, void *this_storage,
+                  const void *other_storage) {
+    if (other_tag == (N - sizeof...(Ts) - 1)) {
+      new (this_storage)
+          T(std::move(*reinterpret_cast<const T *>(other_storage)));
+    } else {
+      VariantLiteMoveCreator<Ts...>::act(N, other_tag, this_storage,
+                                         other_storage);
+    }
+  }
+};
+
+template <typename... Ts> struct VariantLite {
+  static constexpr std::size_t N = sizeof...(Ts);
+
+  static_assert(N > 0, "");
+  static_assert(not hasDuplication<Ts...>::value, "");
+
+  VariantLite() = default;
+
+  template <typename T> VariantLite(T t) {
+    static_assert(hasType<T, Ts...>::value, "");
+    new (&storage) T(std::move(t));
+    tag = IndexByType<T, Ts...>::value;
+  }
+
+  VariantLite(const VariantLite &rhs) {
+    tag = rhs.tag;
+    if (isValid()) {
+      VariantLiteCopyCreator<Ts...>::act(N, rhs.tag, &storage, &rhs.storage);
+    }
+  }
+
+  VariantLite &operator=(const VariantLite &rhs) & {
+    if (isValid()) {
+      VariantLiteDeletor<Ts...>::act(N, tag, &storage);
+    }
+    tag = rhs.tag;
+    if (isValid()) {
+      VariantLiteCopyCreator<Ts...>::act(N, rhs.tag, &storage, &rhs.storage);
+    }
+    return *this;
+  }
+
+  VariantLite(VariantLite &&rhs) {
+    tag = rhs.tag;
+    if (isValid()) {
+      VariantLiteMoveCreator<Ts...>::act(N, rhs.tag, &storage, &rhs.storage);
+    }
+  }
+
+  VariantLite &operator=(VariantLite &&rhs) & {
+    if (isValid()) {
+      VariantLiteDeletor<Ts...>::act(N, tag, &storage);
+    }
+    tag = rhs.tag;
+    if (isValid()) {
+      VariantLiteMoveCreator<Ts...>::act(N, rhs.tag, &storage, &rhs.storage);
+    }
+    return *this;
+  }
+
+  template <typename T> VariantLite &operator=(T t) {
+    static_assert(hasType<T, Ts...>::value, "");
+    if (isValid()) {
+      VariantLiteDeletor<Ts...>::act(N, tag, &storage);
+    }
+    new (&storage) T(std::move(t));
+    tag = IndexByType<T, Ts...>::value;
+    return *this;
+  }
+
+  ~VariantLite() {
+    if (isValid()) {
+      VariantLiteDeletor<Ts...>::act(N, tag, &storage);
+    }
+  }
+
+  bool isValid() const { return tag != InvalidTag; }
+
+  template <typename T> T *get() {
+    static_assert(hasType<T, Ts...>::value, "");
+    if (isValid() && VariantLiteTypeMatch<T, Ts...>::act(N, tag)) {
+      return reinterpret_cast<T *>(&storage);
+    }
+    return nullptr;
+  }
+
+private:
+  static constexpr std::size_t InvalidTag =
+      std::numeric_limits<std::size_t>::max();
+
+  std::aligned_union_t<0, Ts...> storage;
+  std::size_t tag = InvalidTag;
+};
+
 LLVM_NODISCARD llvm::Function *createFnDecl(llvm::Function *f, llvm::Module &m,
                                             llvm::StringRef name) {
   if (f->getReturnType() == hobbes::boolType()) {
@@ -86,7 +268,7 @@ class ConstantList {
   struct Constant {
     // function is a constant
     // globalvariable returned by a function
-    variant<VarDeclFnTy, llvm::Constant *> value;
+    VariantLite<VarDeclFnTy, llvm::Constant *> value;
     Ty ty = Ty::Other;
   };
   llvm::StringMap<Constant> constants;
@@ -181,7 +363,7 @@ public:
   using FnDeclFnTy = std::function<llvm::Function *(llvm::Module &)>;
 
 private:
-  using ValOrFnTy = variant<FnDeclFnTy, llvm::WeakTrackingVH>;
+  using ValOrFnTy = VariantLite<FnDeclFnTy, llvm::WeakTrackingVH>;
   using VarBindingStack = llvm::SmallVector<llvm::StringMap<ValOrFnTy>, 8>;
   VarBindingStack vtenv;
 
@@ -255,7 +437,7 @@ class Globals {
 private:
   using FnDeclFnTy = std::function<llvm::Function *(llvm::Module &)>;
   using VarDeclFnTy = std::function<llvm::GlobalVariable *(llvm::Module &)>;
-  llvm::StringMap<variant<FnDeclFnTy, VarDeclFnTy>> globals;
+  llvm::StringMap<VariantLite<FnDeclFnTy, VarDeclFnTy>> globals;
 
   LLVM_NODISCARD bool isFunc(decltype(globals)::iterator it) const {
     return it->second.get<FnDeclFnTy>() != nullptr;
diff --git a/nix/overlays.nix b/nix/overlays.nix
index 813e97a95..0061ae020 100644
--- a/nix/overlays.nix
+++ b/nix/overlays.nix
@@ -16,7 +16,7 @@ let
 
   separateDebugInfo = debug;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A language and an embedded JIT compiler";
     longDescription = ''
       Hobbes is a language, embedded compiler, and runtime for efficient
@@ -69,6 +69,34 @@ let
       '';
     });
 
+  withCLANGAsanAndUBSan = let
+    llvmPkgs = { llvmVersion }:
+      builtins.getAttr ("llvmPackages_" + (toString llvmVersion)) final;
+  in makeOverridable
+  ({ llvmVersion, stdenv ? (llvmPkgs { inherit llvmVersion; }).stdenv }:
+    stdenv.mkDerivation {
+      pname = "hobbes-clang-" + (toString llvmVersion) + "-ASanAndUBSan";
+      inherit version src meta doCheck doTarget;
+
+      patches = [ ./ubsan_supp.patch ];
+
+      dontStrip = true;
+      cmakeBuildType="Debug";
+      cmakeFlags = [
+        "-DUSE_ASAN_AND_UBSAN:BOOL=ON"
+      ];
+      ninjaFlags = [ "-v" ];
+      UBSAN_OPTIONS="print_stacktrace=1";
+      ASAN_OPTIONS="detect_leaks=0:strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1:use_odr_indicator=1";
+
+      nativeBuildInputs = nativeBuildInputs;
+      buildInputs = buildInputs ++ [ (llvmPkgs { inherit llvmVersion; }).llvm ];
+      postPatch = ''
+        substituteInPlace CMakeLists.txt \
+           --replace "\''${CMAKE_SOURCE_DIR}" "${src}"
+      '';
+    });
+
 in {
   hobbesPackages = when stdenv.isLinux (recurseIntoAttrs (builtins.listToAttrs
     (builtins.map (gccConstraint: {
@@ -89,5 +117,11 @@ in {
         value = recurseIntoAttrs ({
           hobbes = dbg (callPackage withCLANG { inherit llvmVersion; });
         });
+      }) llvmVersions)) // recurseIntoAttrs (builtins.listToAttrs (builtins.map
+      (llvmVersion: {
+        name = "clang-" + toString llvmVersion + "-ASanAndUBSan";
+        value = recurseIntoAttrs ({
+          hobbes = (callPackage withCLANGAsanAndUBSan { inherit llvmVersion; });
+        });
       }) llvmVersions));
 }
diff --git a/nix/ubsan_supp.patch b/nix/ubsan_supp.patch
new file mode 100644
index 000000000..dd5ca200b
--- /dev/null
+++ b/nix/ubsan_supp.patch
@@ -0,0 +1,24 @@
+diff --git a/include/hobbes/reflect.H b/include/hobbes/reflect.H
+index b575156..1b1132d 100644
+--- a/include/hobbes/reflect.H
++++ b/include/hobbes/reflect.H
+@@ -526,6 +526,9 @@ template <template <size_t,class,class> class F, typename U, typename ... Ctors,
+       if (init) return fvec; // <-- pointless, but prevents an unused variable error
+     }
+ 
++#if defined(__clang__)
++    __attribute__((no_sanitize("function")))
++#endif
+     static void apply(uint32_t id, void* payload, Args... args) {
+       fns()[id](payload, args...);
+     }
+@@ -541,6 +544,9 @@ template <typename R, template <size_t,class,class> class F, typename U, typenam
+       if (init) return fvec; // <-- pointless, but prevents an unused variable error
+     }
+ 
++#if defined(__clang__)
++    __attribute__((no_sanitize("function")))
++#endif
+     static R apply(uint32_t id, void* payload, Args... args) {
+       return fns()[id](payload, args...);
+     }
diff --git a/test/Structs.C b/test/Structs.C
index 42ad6bcce..e37e65606 100644
--- a/test/Structs.C
+++ b/test/Structs.C
@@ -2,6 +2,9 @@
 #include <hobbes/hobbes.H>
 #include "test.H"
 
+#include <cstddef>
+#include <type_traits>
+
 using namespace hobbes;
 
 DEFINE_STRUCT(
@@ -208,9 +211,11 @@ TEST(Structs, Alignment) {
   c().bind("makeAT", &makeAT);
   EXPECT_TRUE(true);
 
+  static_assert(std::is_standard_layout<PadTest>::value, "must be standard layout to use offsetof");
+
   Record::Members ms;
-  ms.push_back(Record::Member("x", lift<int>::type(c()), 0));
-  ms.push_back(Record::Member("y", lift<long>::type(c()), static_cast<int>(reinterpret_cast<size_t>(&reinterpret_cast<PadTest*>(0)->y))));
+  ms.push_back(Record::Member("x", lift<int>::type(c()), offsetof(PadTest, x)));
+  ms.push_back(Record::Member("y", lift<long>::type(c()), offsetof(PadTest, y)));
   MonoTypePtr pty(Record::make(Record::withExplicitPadding(ms)));
 
   PadTest p;

From b5958a70e2829e52c971126c68aefd91910de8a8 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Fri, 13 Aug 2021 02:54:44 +0000
Subject: [PATCH 14/40] Accessing hobbes::variant by type or by tag depends
 upon its number of occurrences in variant (#419)

* limit hobbes::variant::get access to variants have no duplicated types

* rename variant::visit to variant::get
---
 include/hobbes/reflect.H | 52 ++++++++++++++++++++++++++++++++++------
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/include/hobbes/reflect.H b/include/hobbes/reflect.H
index b575156cf..d94b5078b 100644
--- a/include/hobbes/reflect.H
+++ b/include/hobbes/reflect.H
@@ -567,6 +567,34 @@ template <size_t, typename T, typename U>
     }
   };
 
+namespace detail {
+template <typename Fn, typename... Ts> struct variantVisitorByTag {
+  static void visit(std::size_t, std::size_t, Fn &&, void *) {}
+};
+
+template <typename Fn, typename T, typename... Ts>
+struct variantVisitorByTag<Fn, T, Ts...> {
+  static void visit(std::size_t count, std::size_t tag, Fn &&fn,
+                    void *storage) {
+    if (tag == (count - sizeof...(Ts) - 1)) {
+      std::forward<Fn>(fn)(storage);
+    } else {
+      variantVisitorByTag<Fn, Ts...>::visit(count, tag, fn, storage);
+    }
+  }
+};
+
+template <typename T, typename... Ts> struct CountType {
+  static constexpr std::size_t value = 0;
+};
+
+template <typename T, typename U, typename... Ts>
+struct CountType<T, U, Ts...> {
+  static constexpr std::size_t value =
+      (std::is_same<T, U>::value ? 1 : 0) + CountType<T, Ts...>::value;
+};
+} // namespace detail
+
 template <typename ... Ctors>
   class variant {
   public:
@@ -599,11 +627,23 @@ template <typename ... Ctors>
       return *this;
     }
 
-    template <typename T>
+    // This function is only instantiated when T is unique in Ctors
+    template <typename T, typename = std::enable_if_t<detail::CountType<T, Ctors...>::value == 1>>
       T* get() { return findByCtor<T>(); }
-    template <typename T>
+    template <typename T, typename = std::enable_if_t<detail::CountType<T, Ctors...>::value == 1>>
       const T* get() const { return findByCtor<T>(); }
 
+    // This function is only instantiated in case of having a type like variant<char, int, char>
+    // and tring to access the char
+    //
+    // \p fn should be void(void*) alike
+    template <typename T, typename Fn,
+              std::enable_if_t<(detail::CountType<T, Ctors...>::value > 1)>>
+    void get(uint32_t t, Fn &&fn) {
+      detail::variantVisitorByTag<Fn, Ctors...>::visit(
+          count, t, std::forward<Fn>(fn), this->storage);
+    }
+
     template <typename R, template <size_t,class,class> class F, typename U, typename ... Args>
       R apply(Args... args) {
         return variantApp<R, F, U, tuple<Ctors...>, Args...>::apply(this->tag, this->storage, args...);
@@ -624,10 +664,8 @@ template <typename ... Ctors>
       typename maximum<TAlignOfF, Ctors...>::type maxAlignedT;
     };
 
-    template <typename T>
+    template <typename T, typename = std::enable_if_t<detail::CountType<T, Ctors...>::value == 1>>
       T* findByCtor() const {
-        static_assert(CtorIndexOf<T, Ctors...>::value < sizeof...(Ctors), "Constructor type isn't part of variant");
-
         if (this->tag == CtorIndexOf<T, Ctors...>::value) {
           return const_cast<T*>(reinterpret_cast<const T*>(this->storage));
         } else {
@@ -640,11 +678,11 @@ template <typename ... Ctors>
     return lhs.unsafeTag() == rhs.unsafeTag() &&
            variantApp<bool, variantPayloadEq, void, tuple<Ctors...>, const void*>::apply(lhs.unsafeTag(), const_cast<void*>(reinterpret_cast<const void*>(lhs.unsafePayload())), reinterpret_cast<const void*>(rhs.unsafePayload()));
   }
-template <typename T, typename ... Ctors>
+template <typename T, typename ... Ctors, typename = std::enable_if_t<detail::CountType<T, Ctors...>::value == 1>>
   T* get(variant<Ctors...>& v) {
     return v.template get<T>();
   }
-template <typename T, typename ... Ctors>
+template <typename T, typename ... Ctors, typename = std::enable_if_t<detail::CountType<T, Ctors...>::value == 1>>
   const T* get(const variant<Ctors...>& v) {
     return v.template get<T>();
   }

From cf29002cc23f2a3fdcd022303a46ed882d16a462 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Mon, 16 Aug 2021 09:58:53 +0000
Subject: [PATCH 15/40] new Fn -> Fn local value (#420)

---
 lib/hobbes/lang/closcvt.C | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/hobbes/lang/closcvt.C b/lib/hobbes/lang/closcvt.C
index 5afc8e136..d9a3786a9 100644
--- a/lib/hobbes/lang/closcvt.C
+++ b/lib/hobbes/lang/closcvt.C
@@ -98,7 +98,8 @@ struct ClosureConvertF : public switchExprTyFn {
 
   ExprPtr with(const Fn* v) const {
     ExprPtr nbody = switchOf(v->body(), ClosureConvertF(fnFrame(this->tenv, v->varNames()), this->roots));
-    return makeClosureOver(new Fn(v->varNames(), nbody, v->la()), excludeRootVars(setDifference(freeVars(nbody), toSet(v->varNames()))));
+    const Fn fn(v->varNames(), nbody, v->la());
+    return makeClosureOver(&fn, excludeRootVars(setDifference(freeVars(nbody), toSet(v->varNames()))));
   }
 
   ExprPtr with(const Let* v) const {

From e69bc90a2456b2d4b1f12832adf18b05fd27b6e7 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 26 Aug 2021 22:15:56 +0000
Subject: [PATCH 16/40] fix invalidated iterator after map erase (#422)

---
 include/hobbes/util/ptr.H | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/hobbes/util/ptr.H b/include/hobbes/util/ptr.H
index 6ec06ff01..4385c2378 100644
--- a/include/hobbes/util/ptr.H
+++ b/include/hobbes/util/ptr.H
@@ -33,7 +33,7 @@ template <typename T, typename ... Args>
       std::lock_guard<std::recursive_mutex> lock(mutex);
       for (typename Values::iterator v = this->values.begin(); v != this->values.end();) {
         if (v->second.use_count() == 1) {
-          this->values.erase(v++);
+          v = this->values.erase(v);
           ++c;
         } else {
           ++v;

From 8a1af17316c3f55272595c41197914ae6fa284e2 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 23 Sep 2021 05:51:05 +0000
Subject: [PATCH 17/40] move llvm include to end of search path to prevent
 cxxabi.h conflicts (#425)

---
 CMakeLists.txt | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 10b30a169..714e13445 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,7 +14,13 @@ find_package(Curses REQUIRED)
 include_directories(${CURSES_INCLUDE_DIRS})
 
 find_package(LLVM REQUIRED CONFIG)
-include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+if (CMAKE_COMPILER_IS_GNUCXX)
+  # if libc++abi is installed, cxxabi.h in llvm path will be used
+  # have to lower llvm include path search order
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -idirafter ${LLVM_INCLUDE_DIRS}")
+else()
+  include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+endif()
 add_definitions(${LLVM_DEFINITIONS})
 
 set(CMAKE_CXX_STANDARD 14)

From 3b99d1d830f68402c1748df3a586498a275ea611 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 23 Sep 2021 05:53:51 +0000
Subject: [PATCH 18/40] refactor size_t -> int when size_t is 2^64-1 (#423)

---
 lib/hobbes/lang/type.C | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/lib/hobbes/lang/type.C b/lib/hobbes/lang/type.C
index f1d8acc09..95dd1592c 100644
--- a/lib/hobbes/lang/type.C
+++ b/lib/hobbes/lang/type.C
@@ -774,17 +774,16 @@ inline bool isHiddenCtor(const Variant::Member& m) {
   return isHiddenCtorName(m.selector);
 }
 
-int findHiddenMember(int i, const std::string& lbl, const Variant::Members& ms) {
-  std::string hlbl = ".p" + lbl;
-  while (i >= 0 && ms[i].selector != hlbl) {
-    --i;
-  }
-  return i;
+int findHiddenMember(const std::string& lbl, const Variant::Members& ms) {
+  const auto it = std::find_if(
+      ms.crbegin(), ms.crend(),
+      [hlbl = ".p" + lbl](const auto &m) { return m.selector == hlbl; });
+  return std::distance(it, ms.crend()) - 1;
 }
 
 Variant::Members consMember(const std::string& lbl, const MonoTypePtr& hty, const Variant::Members& tty) {
   // try to find a place to insert this type, otherwise insert it at the head
-  int slot = findHiddenMember(tty.size() - 1, lbl, tty);
+  const int slot = findHiddenMember(lbl, tty);
 
   Variant::Members r;
   if (slot < 0) {
@@ -1076,12 +1075,11 @@ unsigned int nextVisibleMember(unsigned int i, const Record::Members& ms) {
   return i;
 }
 
-int findHiddenMember(int i, const std::string& lbl, const Record::Members& ms) {
-  std::string hlbl = ".p" + lbl;
-  while (i >= 0 && ms[i].field != hlbl) {
-    --i;
-  }
-  return i;
+int findHiddenMember(const std::string& lbl, const Record::Members& ms) {
+  const auto it = std::find_if(
+      ms.crbegin(), ms.crend(),
+      [hlbl = ".p" + lbl](const auto &m) { return m.field == hlbl; });
+  return std::distance(it, ms.crend()) - 1;
 }
 
 static void resetFieldOffsets(Record::Members* ms) {
@@ -1092,7 +1090,7 @@ static void resetFieldOffsets(Record::Members* ms) {
 
 Record::Members consMember(const std::string& lbl, const MonoTypePtr& hty, const Record::Members& tty) {
   // try to find a place to insert this type, otherwise insert it at the head
-  int slot = findHiddenMember(tty.size() - 1, lbl, tty);
+  const int slot = findHiddenMember(lbl, tty);
 
   Record::Members r;
   if (slot < 0) {

From 8195bddc1ef8890a65b2dcdc4f3eab6ea7e72d5e Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 23 Sep 2021 15:11:42 +0000
Subject: [PATCH 19/40] Add support for  show(penum char |....|) (#424)

* penum show & <- support

* fix hexpr misindentation

* unsafeCast conversion fails if src/dst width don't match if llvm>=11

* add one more test for PEnumChar

* penum can either have all or none user defined values

* add more penum check & tests

* show values if penum is not continious or not starting from zero

* minor refactoring

* support |A|::((penum char |...|))

* refactor naming and penum parser rules
---
 include/hobbes/boot/gen/bootdata.H          |  952 +++---
 include/hobbes/hobbes.H                     |    6 -
 include/hobbes/lang/preds/hasctor/variant.H |    2 +
 include/hobbes/lang/tylift.H                |    5 +-
 include/hobbes/read/pgen/hexpr.parse.H      |    5 +-
 lib/hobbes/boot/show.hob                    |    2 +
 lib/hobbes/eval/cexpr.C                     |   17 +-
 lib/hobbes/eval/func.C                      |   68 +
 lib/hobbes/lang/preds/hasctor/variant.C     |   25 +-
 lib/hobbes/lang/type.C                      |   22 +-
 lib/hobbes/read/pgen/hexpr.lex.C            |   14 +-
 lib/hobbes/read/pgen/hexpr.parse.C          | 2982 ++++++++++---------
 lib/hobbes/read/pgen/hexpr.y                |   46 +
 lib/hobbes/read/pgen/pgen.sh                |    1 +
 test/Variants.C                             |  141 +
 test/test.H                                 |   23 +
 16 files changed, 2362 insertions(+), 1949 deletions(-)

diff --git a/include/hobbes/boot/gen/bootdata.H b/include/hobbes/boot/gen/bootdata.H
index 430b7a882..7a4feeb0e 100644
--- a/include/hobbes/boot/gen/bootdata.H
+++ b/include/hobbes/boot/gen/bootdata.H
@@ -6629,495 +6629,499 @@ unsigned char __show_hob[] = {
   0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x20, 0x77, 0x68, 0x65, 0x72,
   0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x65, 0x20, 0x3d,
   0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b,
-  0x45, 0x6e, 0x75, 0x6d, 0x28, 0x65, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f,
-  0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-  0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
-  0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x73, 0x20, 0x63, 0x68, 0x61,
-  0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x63,
+  0x45, 0x6e, 0x75, 0x6d, 0x28, 0x65, 0x29, 0x29, 0x0a, 0x69, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x28,
+  0x28, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x61, 0x20, 0x76, 0x29, 0x29,
+  0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f,
+  0x77, 0x20, 0x3d, 0x20, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x53, 0x68, 0x6f,
+  0x77, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
+  0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20,
+  0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63,
+  0x73, 0x20, 0x63, 0x68, 0x61, 0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53,
+  0x68, 0x6f, 0x77, 0x20, 0x63, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
+  0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x63, 0x73, 0x20, 0x3d,
+  0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x63, 0x73, 0x5b, 0x30, 0x3a, 0x5d,
+  0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
+  0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x62, 0x73, 0x20, 0x62, 0x79, 0x74,
+  0x65, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x62,
   0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68,
-  0x6f, 0x77, 0x20, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77,
-  0x28, 0x63, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73,
-  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79,
-  0x20, 0x62, 0x73, 0x20, 0x62, 0x79, 0x74, 0x65, 0x29, 0x20, 0x3d, 0x3e,
-  0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x62, 0x73, 0x20, 0x77, 0x68, 0x65,
-  0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x62, 0x73,
-  0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x62, 0x73, 0x5b, 0x30,
-  0x3a, 0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
-  0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e,
-  0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x5b, 0x61, 0x5d, 0x20, 0x77, 0x68,
-  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78,
-  0x73, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x28, 0x5b,
-  0x22, 0x5b, 0x22, 0x2c, 0x20, 0x63, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x28,
-  0x6d, 0x61, 0x70, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x2c, 0x78, 0x73, 0x29,
-  0x2c, 0x20, 0x22, 0x2c, 0x20, 0x22, 0x29, 0x2c, 0x20, 0x22, 0x5d, 0x22,
-  0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
-  0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x73, 0x20, 0x61, 0x2c,
-  0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20,
-  0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72,
-  0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x73, 0x20,
-  0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x78, 0x73, 0x5b, 0x30, 0x3a,
-  0x5d, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61,
-  0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72,
-  0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x2d, 0x6c, 0x65, 0x6e, 0x67, 0x74,
-  0x68, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x0a, 0x63, 0x6c, 0x61,
-  0x73, 0x73, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64,
-  0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x65, 0x20, 0x6e, 0x20, 0x77, 0x68,
-  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x46, 0x41,
-  0x20, 0x3a, 0x3a, 0x20, 0x28, 0x5b, 0x3a, 0x65, 0x7c, 0x6e, 0x3a, 0x5d,
-  0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67,
-  0x29, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x0a,
-  0x0a, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53, 0x74,
-  0x72, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x5b, 0x3a, 0x63, 0x68, 0x61, 0x72,
-  0x7c, 0x6e, 0x3a, 0x5d, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20,
-  0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d,
-  0x29, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x0a,
-  0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53, 0x74, 0x72,
-  0x20, 0x63, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20, 0x72, 0x20, 0x3d, 0x0a,
-  0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x20, 0x3d, 0x3d, 0x20, 0x65,
-  0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-  0x0a, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x28,
-  0x73, 0x61, 0x65, 0x6c, 0x65, 0x6d, 0x28, 0x63, 0x73, 0x2c, 0x20, 0x69,
-  0x29, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x5c, 0x30, 0x27, 0x29, 0x20, 0x74,
-  0x68, 0x65, 0x6e, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-  0x20, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x53, 0x65, 0x74, 0x4c, 0x65,
-  0x6e, 0x67, 0x74, 0x68, 0x28, 0x72, 0x2c, 0x20, 0x69, 0x29, 0x3b, 0x0a,
-  0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72,
-  0x0a, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x64, 0x6f,
-  0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x5b, 0x69, 0x5d, 0x20,
-  0x3c, 0x2d, 0x20, 0x73, 0x61, 0x65, 0x6c, 0x65, 0x6d, 0x28, 0x63, 0x73,
-  0x2c, 0x20, 0x69, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-  0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41,
-  0x54, 0x6f, 0x53, 0x74, 0x72, 0x28, 0x63, 0x73, 0x2c, 0x20, 0x69, 0x2b,
-  0x31, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x72, 0x29, 0x0a, 0x20, 0x20, 0x7d,
-  0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x55, 0x4e, 0x53, 0x41, 0x46, 0x45, 0x20,
-  0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53, 0x74, 0x72,
-  0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
-  0x63, 0x65, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64,
-  0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x63, 0x68, 0x61, 0x72, 0x20, 0x6e,
+  0x6f, 0x77, 0x20, 0x62, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77,
+  0x28, 0x62, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20,
+  0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x5b,
+  0x61, 0x5d, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73,
+  0x68, 0x6f, 0x77, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6e,
+  0x63, 0x61, 0x74, 0x28, 0x5b, 0x22, 0x5b, 0x22, 0x2c, 0x20, 0x63, 0x64,
+  0x65, 0x6c, 0x69, 0x6d, 0x28, 0x6d, 0x61, 0x70, 0x28, 0x73, 0x68, 0x6f,
+  0x77, 0x2c, 0x78, 0x73, 0x29, 0x2c, 0x20, 0x22, 0x2c, 0x20, 0x22, 0x29,
+  0x2c, 0x20, 0x22, 0x5d, 0x22, 0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20,
+  0x61, 0x73, 0x20, 0x61, 0x2c, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61,
+  0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x73,
   0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f,
-  0x77, 0x46, 0x41, 0x20, 0x63, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20, 0x3d,
-  0x20, 0x22, 0x5c, 0x22, 0x22, 0x20, 0x2b, 0x2b, 0x20, 0x66, 0x69, 0x78,
-  0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x28, 0x63, 0x73,
-  0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x6e, 0x65, 0x77, 0x41,
-  0x72, 0x72, 0x61, 0x79, 0x28, 0x65, 0x29, 0x29, 0x20, 0x2b, 0x2b, 0x20,
-  0x22, 0x5c, 0x22, 0x22, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41,
-  0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x61, 0x20,
-  0x2d, 0x3e, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x2c, 0x20, 0x5b,
-  0x3a, 0x61, 0x7c, 0x6e, 0x3a, 0x5d, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67,
-  0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x5b, 0x5b, 0x63, 0x68,
-  0x61, 0x72, 0x5d, 0x5d, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x5b, 0x63,
-  0x68, 0x61, 0x72, 0x5d, 0x5d, 0x0a, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41,
-  0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x66, 0x20,
-  0x78, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20, 0x72, 0x20, 0x3d, 0x0a, 0x20,
-  0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x20, 0x3d, 0x3d, 0x20, 0x65, 0x29,
-  0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x0a,
-  0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x0a,
-  0x20, 0x20, 0x20, 0x20, 0x72, 0x5b, 0x69, 0x5d, 0x20, 0x3c, 0x2d, 0x20,
-  0x73, 0x68, 0x6f, 0x77, 0x66, 0x28, 0x73, 0x61, 0x65, 0x6c, 0x65, 0x6d,
-  0x28, 0x78, 0x73, 0x2c, 0x20, 0x69, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-  0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x68, 0x6f,
-  0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x28, 0x73, 0x68, 0x6f,
-  0x77, 0x66, 0x2c, 0x20, 0x78, 0x73, 0x2c, 0x20, 0x69, 0x2b, 0x31, 0x2c,
-  0x20, 0x65, 0x2c, 0x20, 0x72, 0x29, 0x0a, 0x20, 0x20, 0x7d, 0x0a, 0x7b,
-  0x2d, 0x23, 0x20, 0x55, 0x4e, 0x53, 0x41, 0x46, 0x45, 0x20, 0x73, 0x68,
-  0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x23, 0x2d,
-  0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
-  0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64, 0x41, 0x72, 0x72,
-  0x4f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6e, 0x20, 0x77, 0x68,
+  0x77, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x28,
+  0x78, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20,
+  0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x2d,
+  0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
+  0x73, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x53, 0x68, 0x6f, 0x77,
+  0x46, 0x69, 0x78, 0x65, 0x64, 0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x65,
+  0x20, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73,
+  0x68, 0x6f, 0x77, 0x46, 0x41, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x5b, 0x3a,
+  0x65, 0x7c, 0x6e, 0x3a, 0x5d, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c,
+  0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63,
+  0x68, 0x61, 0x72, 0x5d, 0x0a, 0x0a, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43,
+  0x41, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x5b,
+  0x3a, 0x63, 0x68, 0x61, 0x72, 0x7c, 0x6e, 0x3a, 0x5d, 0x2c, 0x20, 0x6c,
+  0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x5b,
+  0x63, 0x68, 0x61, 0x72, 0x5d, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63,
+  0x68, 0x61, 0x72, 0x5d, 0x0a, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41,
+  0x54, 0x6f, 0x53, 0x74, 0x72, 0x20, 0x63, 0x73, 0x20, 0x69, 0x20, 0x65,
+  0x20, 0x72, 0x20, 0x3d, 0x0a, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69,
+  0x20, 0x3d, 0x3d, 0x20, 0x65, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x72, 0x0a, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65,
+  0x20, 0x69, 0x66, 0x20, 0x28, 0x73, 0x61, 0x65, 0x6c, 0x65, 0x6d, 0x28,
+  0x63, 0x73, 0x2c, 0x20, 0x69, 0x29, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x5c,
+  0x30, 0x27, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x64, 0x6f, 0x20,
+  0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65,
+  0x53, 0x65, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x28, 0x72, 0x2c,
+  0x20, 0x69, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
+  0x75, 0x72, 0x6e, 0x20, 0x72, 0x0a, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c,
+  0x73, 0x65, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x72, 0x5b, 0x69, 0x5d, 0x20, 0x3c, 0x2d, 0x20, 0x73, 0x61, 0x65, 0x6c,
+  0x65, 0x6d, 0x28, 0x63, 0x73, 0x2c, 0x20, 0x69, 0x29, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x69,
+  0x78, 0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x28, 0x63,
+  0x73, 0x2c, 0x20, 0x69, 0x2b, 0x31, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x72,
+  0x29, 0x0a, 0x20, 0x20, 0x7d, 0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x55, 0x4e,
+  0x53, 0x41, 0x46, 0x45, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41,
+  0x54, 0x6f, 0x53, 0x74, 0x72, 0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a, 0x69,
+  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x53, 0x68, 0x6f, 0x77,
+  0x46, 0x69, 0x78, 0x65, 0x64, 0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x63,
+  0x68, 0x61, 0x72, 0x20, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
+  0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x46, 0x41, 0x20, 0x63, 0x73, 0x20,
+  0x69, 0x20, 0x65, 0x20, 0x3d, 0x20, 0x22, 0x5c, 0x22, 0x22, 0x20, 0x2b,
+  0x2b, 0x20, 0x66, 0x69, 0x78, 0x65, 0x64, 0x43, 0x41, 0x54, 0x6f, 0x53,
+  0x74, 0x72, 0x28, 0x63, 0x73, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65, 0x2c,
+  0x20, 0x6e, 0x65, 0x77, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x65, 0x29,
+  0x29, 0x20, 0x2b, 0x2b, 0x20, 0x22, 0x5c, 0x22, 0x22, 0x0a, 0x0a, 0x73,
+  0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x3a,
+  0x3a, 0x20, 0x28, 0x61, 0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63, 0x68, 0x61,
+  0x72, 0x5d, 0x2c, 0x20, 0x5b, 0x3a, 0x61, 0x7c, 0x6e, 0x3a, 0x5d, 0x2c,
+  0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x2c,
+  0x20, 0x5b, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x5d, 0x29, 0x20, 0x2d,
+  0x3e, 0x20, 0x5b, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x5d, 0x0a, 0x73,
+  0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x73,
+  0x68, 0x6f, 0x77, 0x66, 0x20, 0x78, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20,
+  0x72, 0x20, 0x3d, 0x0a, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x20,
+  0x3d, 0x3d, 0x20, 0x65, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x72, 0x0a, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20,
+  0x64, 0x6f, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x5b, 0x69,
+  0x5d, 0x20, 0x3c, 0x2d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x66, 0x28, 0x73,
+  0x61, 0x65, 0x6c, 0x65, 0x6d, 0x28, 0x78, 0x73, 0x2c, 0x20, 0x69, 0x29,
+  0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
+  0x6e, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67,
+  0x65, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x66, 0x2c, 0x20, 0x78, 0x73, 0x2c,
+  0x20, 0x69, 0x2b, 0x31, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x72, 0x29, 0x0a,
+  0x20, 0x20, 0x7d, 0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x55, 0x4e, 0x53, 0x41,
+  0x46, 0x45, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e,
+  0x67, 0x65, 0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x63, 0x65, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78,
+  0x65, 0x64, 0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65,
+  0x20, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73,
+  0x68, 0x6f, 0x77, 0x46, 0x41, 0x20, 0x62, 0x73, 0x20, 0x69, 0x20, 0x65,
+  0x20, 0x3d, 0x20, 0x22, 0x30, 0x78, 0x22, 0x20, 0x2b, 0x2b, 0x20, 0x63,
+  0x6f, 0x6e, 0x63, 0x61, 0x74, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41,
+  0x52, 0x61, 0x6e, 0x67, 0x65, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x42, 0x79,
+  0x74, 0x65, 0x56, 0x2c, 0x20, 0x62, 0x73, 0x2c, 0x20, 0x69, 0x2c, 0x20,
+  0x65, 0x2c, 0x20, 0x6e, 0x65, 0x77, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28,
+  0x65, 0x29, 0x29, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
+  0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20,
+  0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64,
+  0x41, 0x72, 0x72, 0x4f, 0x66, 0x20, 0x61, 0x20, 0x6e, 0x20, 0x77, 0x68,
   0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x46, 0x41,
-  0x20, 0x62, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20, 0x3d, 0x20, 0x22, 0x30,
-  0x78, 0x22, 0x20, 0x2b, 0x2b, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74,
-  0x28, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67, 0x65,
-  0x28, 0x73, 0x68, 0x6f, 0x77, 0x42, 0x79, 0x74, 0x65, 0x56, 0x2c, 0x20,
-  0x62, 0x73, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x6e, 0x65,
-  0x77, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x65, 0x29, 0x29, 0x29, 0x0a,
-  0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53,
-  0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68,
-  0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64, 0x41, 0x72, 0x72, 0x4f, 0x66,
-  0x20, 0x61, 0x20, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x73, 0x68, 0x6f, 0x77, 0x46, 0x41, 0x20, 0x63, 0x73, 0x20, 0x69,
-  0x20, 0x65, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x28,
-  0x5b, 0x22, 0x5b, 0x3a, 0x22, 0x2c, 0x20, 0x63, 0x64, 0x65, 0x6c, 0x69,
-  0x6d, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x53, 0x41, 0x52, 0x61, 0x6e, 0x67,
-  0x65, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x2c, 0x20, 0x63, 0x73, 0x2c, 0x20,
-  0x69, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x6e, 0x65, 0x77, 0x41, 0x72, 0x72,
-  0x61, 0x79, 0x28, 0x65, 0x29, 0x29, 0x2c, 0x20, 0x22, 0x2c, 0x20, 0x22,
-  0x29, 0x2c, 0x20, 0x22, 0x3a, 0x5d, 0x22, 0x5d, 0x29, 0x0a, 0x0a, 0x69,
-  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f,
-  0x77, 0x46, 0x69, 0x78, 0x65, 0x64, 0x41, 0x72, 0x72, 0x4f, 0x66, 0x20,
-  0x61, 0x20, 0x6e, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77,
-  0x20, 0x5b, 0x3a, 0x61, 0x7c, 0x6e, 0x3a, 0x5d, 0x20, 0x77, 0x68, 0x65,
-  0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x73,
-  0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x46, 0x41, 0x28, 0x78, 0x73,
-  0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20, 0x73, 0x61, 0x6c, 0x65, 0x6e, 0x67,
-  0x74, 0x68, 0x28, 0x78, 0x73, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20,
-  0x73, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x0a, 0x69,
-  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f,
-  0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77,
-  0x20, 0x28, 0x5e, 0x78, 0x2e, 0x28, 0x28, 0x29, 0x2b, 0x28, 0x61, 0x2a,
-  0x78, 0x29, 0x29, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x63,
-  0x61, 0x73, 0x65, 0x20, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x28, 0x78,
-  0x73, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x7c, 0x30, 0x3a, 0x5f, 0x3d, 0x22,
-  0x5b, 0x5d, 0x22, 0x2c, 0x20, 0x31, 0x3a, 0x70, 0x3d, 0x73, 0x68, 0x6f,
-  0x77, 0x28, 0x70, 0x2e, 0x30, 0x29, 0x2b, 0x2b, 0x22, 0x3a, 0x22, 0x2b,
-  0x2b, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x70, 0x2e, 0x31, 0x29, 0x7c, 0x0a,
-  0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x72, 0x65, 0x63,
-  0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73,
-  0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6f, 0x6e,
-  0x65, 0x2d, 0x73, 0x74, 0x65, 0x70, 0x20, 0x75, 0x6e, 0x72, 0x6f, 0x6c,
-  0x6c, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x77,
-  0x61, 0x62, 0x6c, 0x65, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x28, 0x61, 0x20, 0x7e, 0x20, 0x62, 0x2c, 0x20, 0x53, 0x68,
-  0x6f, 0x77, 0x20, 0x62, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f,
-  0x77, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20,
-  0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f,
-  0x77, 0x28, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x28, 0x78, 0x29, 0x29,
-  0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x68,
-  0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x72,
-  0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x0a, 0x69, 0x6e,
-  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f, 0x77,
-  0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20,
-  0x61, 0x40, 0x66, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20,
-  0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f,
-  0x77, 0x28, 0x6c, 0x6f, 0x61, 0x64, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a,
-  0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69,
-  0x63, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x0a, 0x20,
-  0x2a, 0x2f, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x3a, 0x3a, 0x20, 0x61, 0x20,
-  0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x28, 0x29,
-  0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69,
-  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e,
-  0x74, 0x20, 0x5b, 0x62, 0x79, 0x74, 0x65, 0x5d, 0x20, 0x77, 0x68, 0x65,
-  0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62,
-  0x73, 0x20, 0x3d, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x73,
-  0x68, 0x6f, 0x77, 0x28, 0x62, 0x73, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f,
-  0x20, 0x77, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6c, 0x61, 0x74,
-  0x65, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x68, 0x6f,
-  0x77, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x79,
-  0x70, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x61,
-  0x62, 0x6c, 0x65, 0x73, 0x0a, 0x2f, 0x2f, 0x20, 0x61, 0x74, 0x20, 0x6c,
-  0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20,
-  0x74, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x20,
-  0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x70,
-  0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73,
-  0x2c, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64,
-  0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x73, 0x20, 0x74, 0x61, 0x62, 0x6c,
-  0x65, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20,
-  0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x20, 0x61, 0x73, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-  0x73, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x72, 0x69, 0x6e,
-  0x74, 0x61, 0x62, 0x6c, 0x65, 0x41, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65,
-  0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x20,
+  0x20, 0x63, 0x73, 0x20, 0x69, 0x20, 0x65, 0x20, 0x3d, 0x20, 0x63, 0x6f,
+  0x6e, 0x63, 0x61, 0x74, 0x28, 0x5b, 0x22, 0x5b, 0x3a, 0x22, 0x2c, 0x20,
+  0x63, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x53,
+  0x41, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x2c,
+  0x20, 0x63, 0x73, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65, 0x2c, 0x20, 0x6e,
+  0x65, 0x77, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x65, 0x29, 0x29, 0x2c,
+  0x20, 0x22, 0x2c, 0x20, 0x22, 0x29, 0x2c, 0x20, 0x22, 0x3a, 0x5d, 0x22,
+  0x5d, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
+  0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x46, 0x69, 0x78, 0x65, 0x64, 0x41,
+  0x72, 0x72, 0x4f, 0x66, 0x20, 0x61, 0x20, 0x6e, 0x29, 0x20, 0x3d, 0x3e,
+  0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x5b, 0x3a, 0x61, 0x7c, 0x6e, 0x3a,
+  0x5d, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68,
+  0x6f, 0x77, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77,
+  0x46, 0x41, 0x28, 0x78, 0x73, 0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20, 0x73,
+  0x61, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x28, 0x78, 0x73, 0x29, 0x29,
+  0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x69,
+  0x73, 0x74, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
+  0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e,
+  0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x28, 0x5e, 0x78, 0x2e, 0x28, 0x28,
+  0x29, 0x2b, 0x28, 0x61, 0x2a, 0x78, 0x29, 0x29, 0x29, 0x20, 0x77, 0x68,
+  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78,
+  0x73, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x75, 0x6e, 0x72,
+  0x6f, 0x6c, 0x6c, 0x28, 0x78, 0x73, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x7c,
+  0x30, 0x3a, 0x5f, 0x3d, 0x22, 0x5b, 0x5d, 0x22, 0x2c, 0x20, 0x31, 0x3a,
+  0x70, 0x3d, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x70, 0x2e, 0x30, 0x29, 0x2b,
+  0x2b, 0x22, 0x3a, 0x22, 0x2b, 0x2b, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x70,
+  0x2e, 0x31, 0x29, 0x7c, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x68, 0x6f,
+  0x77, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x20,
+  0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65,
+  0x69, 0x72, 0x20, 0x6f, 0x6e, 0x65, 0x2d, 0x73, 0x74, 0x65, 0x70, 0x20,
+  0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x73,
+  0x20, 0x73, 0x68, 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x69, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x61, 0x20, 0x7e, 0x20,
+  0x62, 0x2c, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x62, 0x29, 0x20, 0x3d,
+  0x3e, 0x20, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65,
+  0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x20,
+  0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x75, 0x6e, 0x72, 0x6f, 0x6c,
+  0x6c, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x68,
+  0x6f, 0x77, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x66,
+  0x69, 0x6c, 0x65, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+  0x65, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
+  0x28, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20,
+  0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x40, 0x66, 0x20, 0x77, 0x68, 0x65,
+  0x72, 0x65, 0x0a, 0x20, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x20, 0x78, 0x20,
+  0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x6c, 0x6f, 0x61, 0x64, 0x28,
+  0x78, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x69, 0x6e, 0x67, 0x0a, 0x20, 0x2a, 0x2f, 0x0a, 0x63, 0x6c, 0x61, 0x73,
+  0x73, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68,
+  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20,
   0x3a, 0x3a, 0x20, 0x61, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a,
-  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x41, 0x73, 0x54, 0x61, 0x62,
-  0x6c, 0x65, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x41, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x0a, 0x2f,
-  0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61,
-  0x79, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
-  0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x20, 0x28, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
+  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x5f, 0x20, 0x3d, 0x20,
+  0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
+  0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x5b, 0x62, 0x79, 0x74, 0x65,
+  0x5d, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72,
+  0x69, 0x6e, 0x74, 0x20, 0x62, 0x73, 0x20, 0x3d, 0x20, 0x70, 0x75, 0x74,
+  0x53, 0x74, 0x72, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x62, 0x73, 0x29,
+  0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x77, 0x65, 0x20, 0x77, 0x69, 0x6c,
+  0x6c, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69,
+  0x6e, 0x65, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61,
+  0x69, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6e,
+  0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x20,
+  0x61, 0x73, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x0a, 0x2f, 0x2f,
+  0x20, 0x61, 0x74, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x6e,
+  0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x63,
+  0x61, 0x73, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f, 0x76,
+  0x65, 0x72, 0x6c, 0x61, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61,
+  0x72, 0x72, 0x61, 0x79, 0x73, 0x2c, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x65,
+  0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x79,
+  0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x73,
+  0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6f,
+  0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20,
+  0x74, 0x6f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x73, 0x20,
+  0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73,
+  0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x41, 0x73,
+  0x54, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72,
+  0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x54,
+  0x61, 0x62, 0x6c, 0x65, 0x20, 0x3a, 0x3a, 0x20, 0x61, 0x20, 0x2d, 0x3e,
+  0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
+  0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65,
+  0x41, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x61, 0x29, 0x20, 0x3d,
+  0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68,
+  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20,
+  0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x54, 0x61, 0x62,
+  0x6c, 0x65, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x5b,
+  0x63, 0x68, 0x61, 0x72, 0x5d, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
+  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x73, 0x20, 0x3d,
+  0x20, 0x64, 0x6f, 0x20, 0x7b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
+  0x28, 0x22, 0x5c, 0x22, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53,
+  0x74, 0x72, 0x28, 0x63, 0x73, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53,
+  0x74, 0x72, 0x28, 0x22, 0x5c, 0x22, 0x22, 0x29, 0x3b, 0x20, 0x7d, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72,
+  0x72, 0x61, 0x79, 0x20, 0x63, 0x73, 0x20, 0x63, 0x68, 0x61, 0x72, 0x29,
+  0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x73,
   0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x64, 0x6f, 0x20, 0x7b,
-  0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5c, 0x22, 0x22,
-  0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x63, 0x73,
-  0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5c,
-  0x22, 0x22, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63,
-  0x73, 0x20, 0x63, 0x68, 0x61, 0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50,
-  0x72, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72,
-  0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x73,
-  0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x63, 0x73, 0x5b,
-  0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x62, 0x73, 0x20,
-  0x62, 0x79, 0x74, 0x65, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x62, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
-  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62, 0x73, 0x20, 0x3d,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x62, 0x73, 0x5b, 0x30, 0x3a,
-  0x5d, 0x29, 0x0a, 0x0a, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x72, 0x72,
-  0x61, 0x79, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74,
-  0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x28, 0x5b, 0x61, 0x5d, 0x2c,
-  0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29,
-  0x0a, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20,
-  0x78, 0x73, 0x20, 0x69, 0x20, 0x3d, 0x0a, 0x20, 0x20, 0x69, 0x66, 0x20,
-  0x28, 0x69, 0x20, 0x3d, 0x3d, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68,
-  0x28, 0x78, 0x73, 0x29, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
-  0x20, 0x20, 0x20, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65,
-  0x0a, 0x20, 0x20, 0x20, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x20, 0x70, 0x75,
-  0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x2c, 0x20, 0x22, 0x29, 0x3b, 0x20,
-  0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x78, 0x73, 0x5b, 0x69, 0x5d, 0x29,
-  0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79,
-  0x28, 0x78, 0x73, 0x2c, 0x20, 0x69, 0x2b, 0x31, 0x4c, 0x29, 0x3b, 0x20,
-  0x7d, 0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x55, 0x4e, 0x53, 0x41, 0x46, 0x45,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20,
-  0x23, 0x2d, 0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x73, 0x20,
-  0x61, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20,
-  0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x73, 0x20,
-  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e,
-  0x74, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x6e,
-  0x3d, 0x73, 0x69, 0x7a, 0x65, 0x28, 0x78, 0x73, 0x29, 0x20, 0x69, 0x6e,
-  0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x3d, 0x3d, 0x30, 0x29, 0x20, 0x74,
-  0x68, 0x65, 0x6e, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22,
-  0x5b, 0x5d, 0x22, 0x29, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x64, 0x6f,
-  0x20, 0x7b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5b,
-  0x22, 0x29, 0x3b, 0x20, 0x61, 0x78, 0x73, 0x3d, 0x65, 0x6c, 0x65, 0x6d,
-  0x65, 0x6e, 0x74, 0x73, 0x28, 0x78, 0x73, 0x2c, 0x20, 0x30, 0x4c, 0x2c,
-  0x20, 0x6e, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x61,
-  0x78, 0x73, 0x5b, 0x30, 0x5d, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e,
-  0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x61, 0x78, 0x73, 0x2c, 0x20,
-  0x31, 0x4c, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28,
-  0x22, 0x5d, 0x22, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x0a, 0x2f, 0x2f, 0x20,
-  0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x20,
-  0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x0a, 0x69, 0x6e,
-  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e,
+  0x6e, 0x74, 0x20, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x28, 0x63, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x69, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61,
+  0x79, 0x20, 0x62, 0x73, 0x20, 0x62, 0x79, 0x74, 0x65, 0x29, 0x20, 0x3d,
+  0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62, 0x73, 0x20, 0x77,
+  0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x62, 0x73, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28,
+  0x62, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x0a, 0x70, 0x72, 0x69,
+  0x6e, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x3a, 0x3a, 0x20, 0x28,
+  0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20,
+  0x28, 0x5b, 0x61, 0x5d, 0x2c, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x29, 0x20,
+  0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41,
+  0x72, 0x72, 0x61, 0x79, 0x20, 0x78, 0x73, 0x20, 0x69, 0x20, 0x3d, 0x0a,
+  0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x20, 0x3d, 0x3d, 0x20, 0x6c,
+  0x65, 0x6e, 0x67, 0x74, 0x68, 0x28, 0x78, 0x73, 0x29, 0x29, 0x20, 0x74,
+  0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x28, 0x29, 0x0a, 0x20,
+  0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x64, 0x6f,
+  0x20, 0x7b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x2c,
+  0x20, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x78,
+  0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x78, 0x73, 0x2c, 0x20, 0x69, 0x2b,
+  0x31, 0x4c, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x55,
+  0x4e, 0x53, 0x41, 0x46, 0x45, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41,
+  0x72, 0x72, 0x61, 0x79, 0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a, 0x69, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61,
+  0x79, 0x20, 0x61, 0x73, 0x20, 0x61, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e,
   0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e,
-  0x74, 0x20, 0x28, 0x5e, 0x78, 0x2e, 0x28, 0x28, 0x29, 0x2b, 0x28, 0x61,
-  0x2a, 0x78, 0x29, 0x29, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
-  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x73, 0x20, 0x3d,
-  0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c,
-  0x28, 0x78, 0x73, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x7c, 0x30, 0x3a, 0x5f,
-  0x3d, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5b, 0x5d, 0x22,
-  0x29, 0x2c, 0x20, 0x31, 0x3a, 0x70, 0x3d, 0x6c, 0x65, 0x74, 0x20, 0x5f,
-  0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x70, 0x2e, 0x30,
-  0x29, 0x3b, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74,
-  0x72, 0x28, 0x22, 0x3a, 0x22, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x28, 0x70, 0x2e, 0x31, 0x29, 0x7c, 0x0a, 0x0a, 0x2f,
-  0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f,
-  0x72, 0x64, 0x73, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x52, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
+  0x74, 0x20, 0x61, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
+  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x73, 0x20, 0x3d, 0x20,
+  0x6c, 0x65, 0x74, 0x20, 0x6e, 0x3d, 0x73, 0x69, 0x7a, 0x65, 0x28, 0x78,
+  0x73, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x3d,
+  0x3d, 0x30, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x70, 0x75, 0x74,
+  0x53, 0x74, 0x72, 0x28, 0x22, 0x5b, 0x5d, 0x22, 0x29, 0x20, 0x65, 0x6c,
+  0x73, 0x65, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x20, 0x70, 0x75, 0x74, 0x53,
+  0x74, 0x72, 0x28, 0x22, 0x5b, 0x22, 0x29, 0x3b, 0x20, 0x61, 0x78, 0x73,
+  0x3d, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x28, 0x78, 0x73,
+  0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20, 0x6e, 0x29, 0x3b, 0x20, 0x70, 0x72,
+  0x69, 0x6e, 0x74, 0x28, 0x61, 0x78, 0x73, 0x5b, 0x30, 0x5d, 0x29, 0x3b,
+  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28,
+  0x61, 0x78, 0x73, 0x2c, 0x20, 0x31, 0x4c, 0x29, 0x3b, 0x20, 0x70, 0x75,
+  0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5d, 0x22, 0x29, 0x3b, 0x20, 0x7d,
+  0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x6c,
+  0x69, 0x73, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x6e,
+  0x67, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
+  0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e,
+  0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x28, 0x5e, 0x78, 0x2e, 0x28,
+  0x28, 0x29, 0x2b, 0x28, 0x61, 0x2a, 0x78, 0x29, 0x29, 0x29, 0x20, 0x77,
+  0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x75,
+  0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x28, 0x78, 0x73, 0x29, 0x20, 0x6f, 0x66,
+  0x20, 0x7c, 0x30, 0x3a, 0x5f, 0x3d, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
+  0x28, 0x22, 0x5b, 0x5d, 0x22, 0x29, 0x2c, 0x20, 0x31, 0x3a, 0x70, 0x3d,
+  0x6c, 0x65, 0x74, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x28, 0x70, 0x2e, 0x30, 0x29, 0x3b, 0x20, 0x5f, 0x20, 0x3d, 0x20,
+  0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x3a, 0x22, 0x29, 0x20,
+  0x69, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x70, 0x2e, 0x31,
+  0x29, 0x7c, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x0a, 0x63, 0x6c, 0x61,
+  0x73, 0x73, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20, 0x61, 0x20,
+  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x72, 0x65, 0x63, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x62, 0x6f, 0x6f,
+  0x6c, 0x2c, 0x61, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x52, 0x20, 0x28, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
   0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x72, 0x65, 0x63, 0x20,
-  0x3a, 0x3a, 0x20, 0x28, 0x62, 0x6f, 0x6f, 0x6c, 0x2c, 0x61, 0x29, 0x20,
-  0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20, 0x28,
-  0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x72, 0x65, 0x63, 0x20, 0x5f, 0x20, 0x5f, 0x20, 0x3d,
-  0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x28, 0x72, 0x3d, 0x7b, 0x61, 0x2a, 0x72, 0x72, 0x7d, 0x2c,
-  0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x2c, 0x20, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x52, 0x20, 0x72, 0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20,
-  0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20, 0x72, 0x20, 0x77, 0x68, 0x65,
-  0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x72, 0x65,
-  0x63, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x72, 0x20, 0x3d, 0x20,
-  0x64, 0x6f, 0x7b, 0x69, 0x66, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20,
-  0x74, 0x68, 0x65, 0x6e, 0x20, 0x28, 0x29, 0x20, 0x65, 0x6c, 0x73, 0x65,
-  0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x2c, 0x20, 0x22,
-  0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x72, 0x65,
-  0x63, 0x6f, 0x72, 0x64, 0x48, 0x65, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65,
-  0x6c, 0x28, 0x72, 0x29, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74,
-  0x72, 0x28, 0x22, 0x3d, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e,
-  0x74, 0x28, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x65, 0x61, 0x64,
-  0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x72, 0x29, 0x29, 0x3b, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x72, 0x65, 0x63, 0x28, 0x66, 0x61, 0x6c, 0x73,
-  0x65, 0x2c, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x54, 0x61, 0x69,
-  0x6c, 0x28, 0x72, 0x29, 0x29, 0x3b, 0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73,
-  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74,
-  0x52, 0x20, 0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e,
-  0x74, 0x20, 0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20,
-  0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x64, 0x6f,
-  0x7b, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x7b, 0x22, 0x29,
-  0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x72, 0x65, 0x63, 0x28, 0x74,
-  0x72, 0x75, 0x65, 0x2c, 0x20, 0x78, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74,
-  0x53, 0x74, 0x72, 0x28, 0x22, 0x7d, 0x22, 0x29, 0x3b, 0x7d, 0x0a, 0x0a,
-  0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x74, 0x75, 0x70,
-  0x6c, 0x65, 0x73, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x54, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
-  0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x74, 0x75, 0x70, 0x20,
-  0x3a, 0x3a, 0x20, 0x28, 0x62, 0x6f, 0x6f, 0x6c, 0x2c, 0x61, 0x29, 0x20,
-  0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x20, 0x28,
-  0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x74, 0x75, 0x70, 0x20, 0x5f, 0x20, 0x5f, 0x20, 0x3d,
-  0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x28, 0x70, 0x3d, 0x28, 0x61, 0x2a, 0x74, 0x29, 0x2c, 0x20,
-  0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x2c, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x54, 0x20, 0x74, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x54, 0x20, 0x70, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
+  0x5f, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x72, 0x3d, 0x7b, 0x61,
+  0x2a, 0x72, 0x72, 0x7d, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20,
+  0x61, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20, 0x72, 0x72,
+  0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20,
+  0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72,
+  0x69, 0x6e, 0x74, 0x72, 0x65, 0x63, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74,
+  0x20, 0x72, 0x20, 0x3d, 0x20, 0x64, 0x6f, 0x7b, 0x69, 0x66, 0x20, 0x66,
+  0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x28, 0x29,
+  0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
+  0x28, 0x22, 0x2c, 0x20, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53,
+  0x74, 0x72, 0x28, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x48, 0x65, 0x61,
+  0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x28, 0x72, 0x29, 0x29, 0x3b, 0x20,
+  0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x3d, 0x22, 0x29, 0x3b,
+  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x72, 0x65, 0x63, 0x6f, 0x72,
+  0x64, 0x48, 0x65, 0x61, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x72,
+  0x29, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x72, 0x65, 0x63,
+  0x28, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x63, 0x6f,
+  0x72, 0x64, 0x54, 0x61, 0x69, 0x6c, 0x28, 0x72, 0x29, 0x29, 0x3b, 0x7d,
+  0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
+  0x50, 0x72, 0x69, 0x6e, 0x74, 0x52, 0x20, 0x72, 0x29, 0x20, 0x3d, 0x3e,
+  0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x72, 0x20, 0x77, 0x68, 0x65,
+  0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78,
+  0x20, 0x3d, 0x20, 0x64, 0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
+  0x28, 0x22, 0x7b, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x72, 0x65, 0x63, 0x28, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x78, 0x29,
+  0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x7d, 0x22,
+  0x29, 0x3b, 0x7d, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x20, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x0a, 0x63, 0x6c, 0x61,
+  0x73, 0x73, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x20, 0x61, 0x20,
+  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x74, 0x75, 0x70, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x62, 0x6f, 0x6f,
+  0x6c, 0x2c, 0x61, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x54, 0x20, 0x28, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
   0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x74, 0x75, 0x70, 0x20,
-  0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x20, 0x3d, 0x20, 0x64, 0x6f,
-  0x7b, 0x69, 0x66, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x68,
-  0x65, 0x6e, 0x20, 0x28, 0x29, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x70,
-  0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x2c, 0x20, 0x22, 0x29, 0x3b,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x70, 0x2e, 0x30, 0x29, 0x3b,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x74, 0x75, 0x70, 0x28, 0x66, 0x61,
-  0x6c, 0x73, 0x65, 0x2c, 0x20, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x54, 0x61,
-  0x69, 0x6c, 0x28, 0x70, 0x29, 0x29, 0x3b, 0x7d, 0x0a, 0x0a, 0x69, 0x6e,
-  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e,
-  0x74, 0x54, 0x20, 0x70, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x70, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x70, 0x20, 0x3d, 0x20, 0x64,
-  0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x28, 0x22,
-  0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x74, 0x75, 0x70, 0x28,
-  0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x70, 0x29, 0x3b, 0x20, 0x70, 0x75,
-  0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x29, 0x22, 0x29, 0x3b, 0x7d, 0x0a,
-  0x0a, 0x2f, 0x2f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x27, 0x6d, 0x61, 0x79,
-  0x62, 0x65, 0x27, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2c, 0x20, 0x77,
-  0x65, 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64,
-  0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20,
-  0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x72, 0x75,
-  0x63, 0x74, 0x75, 0x72, 0x65, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
-  0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29,
-  0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x28, 0x28,
-  0x29, 0x2b, 0x61, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
-  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x63,
-  0x61, 0x73, 0x65, 0x20, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x7c, 0x30, 0x3a,
-  0x5f, 0x3d, 0x28, 0x29, 0x2c, 0x31, 0x3a, 0x78, 0x3d, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x28, 0x78, 0x29, 0x7c, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74,
-  0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72,
-  0x69, 0x63, 0x20, 0x63, 0x61, 0x73, 0x65, 0x0a, 0x63, 0x6c, 0x61, 0x73,
-  0x73, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61,
-  0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72,
-  0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72,
-  0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x3a, 0x3a, 0x20, 0x61,
-  0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72,
-  0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x28, 0x29, 0x20, 0x77,
-  0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
-  0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x3d,
-  0x20, 0x69, 0x64, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
-  0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d,
-  0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61,
-  0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72,
-  0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72,
-  0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x78, 0x20, 0x3d, 0x20,
-  0x64, 0x6f, 0x20, 0x7b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28,
-  0x22, 0x3d, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28,
-  0x78, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x28, 0x76, 0x3d, 0x7c, 0x68, 0x2b, 0x30, 0x7c,
-  0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x68, 0x29, 0x20, 0x3d,
-  0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x20, 0x77, 0x68,
+  0x5f, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x28, 0x29, 0x0a, 0x0a, 0x69, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x70, 0x3d, 0x28, 0x61,
+  0x2a, 0x74, 0x29, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61,
+  0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x20, 0x74, 0x29, 0x20,
+  0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x20, 0x70, 0x20,
+  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x74, 0x75, 0x70, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70,
+  0x20, 0x3d, 0x20, 0x64, 0x6f, 0x7b, 0x69, 0x66, 0x20, 0x66, 0x69, 0x72,
+  0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x28, 0x29, 0x20, 0x65,
+  0x6c, 0x73, 0x65, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22,
+  0x2c, 0x20, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28,
+  0x70, 0x2e, 0x30, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x74,
+  0x75, 0x70, 0x28, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x20, 0x74, 0x75,
+  0x70, 0x6c, 0x65, 0x54, 0x61, 0x69, 0x6c, 0x28, 0x70, 0x29, 0x29, 0x3b,
+  0x7d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
+  0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x20, 0x70, 0x29, 0x20, 0x3d,
+  0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x70, 0x20, 0x77, 0x68,
   0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20,
-  0x76, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x53,
-  0x70, 0x6c, 0x69, 0x74, 0x28, 0x76, 0x2c, 0x20, 0x5c, 0x68, 0x2e, 0x64,
-  0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x7c, 0x22,
-  0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x76, 0x61,
-  0x72, 0x69, 0x61, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x4c, 0x61, 0x62,
-  0x65, 0x6c, 0x28, 0x76, 0x29, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e,
-  0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x28,
-  0x68, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22,
-  0x7c, 0x22, 0x29, 0x3b, 0x7d, 0x2c, 0x20, 0x74, 0x6f, 0x43, 0x6c, 0x6f,
-  0x73, 0x75, 0x72, 0x65, 0x28, 0x5c, 0x5f, 0x2e, 0x28, 0x29, 0x29, 0x29,
-  0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
-  0x76, 0x3d, 0x7c, 0x68, 0x2b, 0x74, 0x7c, 0x2c, 0x20, 0x50, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x68, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20,
-  0x74, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20,
-  0x76, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x20, 0x76, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x72, 0x69,
-  0x61, 0x6e, 0x74, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x28, 0x76, 0x2c, 0x20,
-  0x5c, 0x68, 0x2e, 0x64, 0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
-  0x28, 0x22, 0x7c, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74,
-  0x72, 0x28, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x48, 0x65, 0x61,
-  0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x28, 0x76, 0x29, 0x29, 0x3b, 0x20,
+  0x70, 0x20, 0x3d, 0x20, 0x64, 0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74,
+  0x72, 0x28, 0x22, 0x28, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x74, 0x75, 0x70, 0x28, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x70,
+  0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x29,
+  0x22, 0x29, 0x3b, 0x7d, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x66, 0x6f, 0x72,
+  0x20, 0x27, 0x6d, 0x61, 0x79, 0x62, 0x65, 0x27, 0x20, 0x74, 0x79, 0x70,
+  0x65, 0x73, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74,
+  0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x65,
+  0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74,
+  0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x0a, 0x69,
+  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x20, 0x28, 0x28, 0x29, 0x2b, 0x61, 0x29, 0x20, 0x77, 0x68,
+  0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20,
+  0x6d, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6d, 0x20, 0x6f,
+  0x66, 0x20, 0x7c, 0x30, 0x3a, 0x5f, 0x3d, 0x28, 0x29, 0x2c, 0x31, 0x3a,
+  0x78, 0x3d, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x78, 0x29, 0x7c, 0x0a,
+  0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x61,
+  0x72, 0x69, 0x61, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20,
+  0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x63, 0x61, 0x73, 0x65,
+  0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74,
+  0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61,
+  0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69,
+  0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
+  0x20, 0x3a, 0x3a, 0x20, 0x61, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
+  0x20, 0x28, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20,
   0x70, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c,
-  0x6f, 0x61, 0x64, 0x28, 0x68, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53,
-  0x74, 0x72, 0x28, 0x22, 0x7c, 0x22, 0x29, 0x3b, 0x7d, 0x2c, 0x20, 0x74,
-  0x6f, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x28, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65,
-  0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68,
-  0x65, 0x69, 0x72, 0x20, 0x6f, 0x6e, 0x65, 0x2d, 0x73, 0x74, 0x65, 0x70,
-  0x20, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x69,
-  0x73, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x0a,
-  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x61, 0x20,
-  0x7e, 0x20, 0x62, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62,
-  0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61,
+  0x6f, 0x61, 0x64, 0x20, 0x3d, 0x20, 0x69, 0x64, 0x0a, 0x69, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74,
+  0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61,
   0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
-  0x28, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x28, 0x78, 0x29, 0x29, 0x0a,
-  0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x70, 0x72,
-  0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65,
-  0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x0a,
-  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x20, 0x61, 0x40, 0x66, 0x20, 0x77, 0x68, 0x65, 0x72,
-  0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x20,
-  0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x6c, 0x6f, 0x61, 0x64,
+  0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
+  0x20, 0x78, 0x20, 0x3d, 0x20, 0x64, 0x6f, 0x20, 0x7b, 0x20, 0x70, 0x75,
+  0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x3d, 0x22, 0x29, 0x3b, 0x20, 0x70,
+  0x72, 0x69, 0x6e, 0x74, 0x28, 0x78, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x76, 0x3d,
+  0x7c, 0x68, 0x2b, 0x30, 0x7c, 0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x68, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74,
+  0x20, 0x76, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70,
+  0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x72,
+  0x69, 0x61, 0x6e, 0x74, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x28, 0x76, 0x2c,
+  0x20, 0x5c, 0x68, 0x2e, 0x64, 0x6f, 0x7b, 0x70, 0x75, 0x74, 0x53, 0x74,
+  0x72, 0x28, 0x22, 0x7c, 0x22, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74, 0x53,
+  0x74, 0x72, 0x28, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x48, 0x65,
+  0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x28, 0x76, 0x29, 0x29, 0x3b,
+  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x50, 0x61, 0x79,
+  0x6c, 0x6f, 0x61, 0x64, 0x28, 0x68, 0x29, 0x3b, 0x20, 0x70, 0x75, 0x74,
+  0x53, 0x74, 0x72, 0x28, 0x22, 0x7c, 0x22, 0x29, 0x3b, 0x7d, 0x2c, 0x20,
+  0x74, 0x6f, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x28, 0x5c, 0x5f,
+  0x2e, 0x28, 0x29, 0x29, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x63, 0x65, 0x20, 0x28, 0x76, 0x3d, 0x7c, 0x68, 0x2b, 0x74, 0x7c,
+  0x2c, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x68, 0x2c, 0x20, 0x50,
+  0x72, 0x69, 0x6e, 0x74, 0x20, 0x74, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50,
+  0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
+  0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x20, 0x3d,
+  0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x53, 0x70, 0x6c, 0x69,
+  0x74, 0x28, 0x76, 0x2c, 0x20, 0x5c, 0x68, 0x2e, 0x64, 0x6f, 0x7b, 0x70,
+  0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x7c, 0x22, 0x29, 0x3b, 0x20,
+  0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x76, 0x61, 0x72, 0x69, 0x61,
+  0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x28,
+  0x76, 0x29, 0x29, 0x3b, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x56, 0x61,
+  0x72, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x28, 0x68, 0x29, 0x3b,
+  0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x7c, 0x22, 0x29,
+  0x3b, 0x7d, 0x2c, 0x20, 0x74, 0x6f, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72,
+  0x65, 0x28, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x29, 0x29, 0x0a, 0x0a, 0x2f,
+  0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x63, 0x75,
+  0x72, 0x73, 0x69, 0x76, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20,
+  0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6f, 0x6e, 0x65,
+  0x2d, 0x73, 0x74, 0x65, 0x70, 0x20, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c,
+  0x69, 0x6e, 0x67, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x61, 0x62, 0x6c, 0x65, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
+  0x65, 0x20, 0x28, 0x61, 0x20, 0x7e, 0x20, 0x62, 0x2c, 0x20, 0x50, 0x72,
+  0x69, 0x6e, 0x74, 0x20, 0x62, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72,
+  0x69, 0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
+  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20,
+  0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c,
   0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x62, 0x69, 0x74, 0x20, 0x76, 0x65, 0x63, 0x74, 0x6f,
-  0x72, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20,
-  0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62, 0x69, 0x74, 0x76, 0x65, 0x63,
+  0x6e, 0x74, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x61, 0x62, 0x6c, 0x65,
+  0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65,
+  0x6e, 0x63, 0x65, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
+  0x65, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20,
+  0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x40, 0x66,
   0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69,
-  0x6e, 0x74, 0x20, 0x62, 0x76, 0x20, 0x3d, 0x20, 0x62, 0x76, 0x50, 0x72,
-  0x69, 0x6e, 0x74, 0x54, 0x28, 0x62, 0x76, 0x2c, 0x20, 0x30, 0x4c, 0x2c,
-  0x20, 0x62, 0x76, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x28, 0x62, 0x76,
-  0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
-  0x20, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c,
-  0x73, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x73, 0x68,
-  0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29,
-  0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x20,
-  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e,
-  0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
-  0x28, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a, 0x2f,
-  0x2f, 0x20, 0x77, 0x65, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x20, 0x75, 0x70,
-  0x20, 0x64, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20,
-  0x73, 0x75, 0x72, 0x70, 0x72, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x79,
-  0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x0a, 0x70, 0x72, 0x69, 0x6e, 0x74,
-  0x6c, 0x6e, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x50, 0x72, 0x69, 0x6e, 0x74,
-  0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x61, 0x20, 0x2d, 0x3e, 0x20,
-  0x28, 0x29, 0x0a, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x6c, 0x6e, 0x20, 0x78,
-  0x20, 0x3d, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x70,
-  0x72, 0x69, 0x6e, 0x74, 0x28, 0x78, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x70,
-  0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5c, 0x6e, 0x22, 0x29, 0x0a,
-  0x0a, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x4c, 0x6e, 0x20, 0x3a, 0x3a,
-  0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x20, 0x2d, 0x3e, 0x20, 0x28,
-  0x29, 0x0a, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x4c, 0x6e, 0x20, 0x78,
-  0x20, 0x3d, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x5f, 0x20, 0x3d, 0x20, 0x70,
-  0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x78, 0x29, 0x20, 0x69, 0x6e, 0x20,
-  0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x5c, 0x6e, 0x22, 0x29,
-  0x0a, 0x0a, 0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x67, 0x65, 0x6e, 0x65,
-  0x72, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a,
-  0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x6f,
-  0x72, 0x6d, 0x61, 0x74, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73,
-  0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x3a, 0x20, 0x60, 0x78, 0x20, 0x3d,
-  0x20, 0x24, 0x78, 0x60, 0x20, 0x3d, 0x3e, 0x20, 0x22, 0x78, 0x20, 0x3d,
-  0x20, 0x22, 0x20, 0x2b, 0x2b, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-  0x28, 0x78, 0x29, 0x29, 0x0a, 0x20, 0x2a, 0x2f, 0x0a, 0x63, 0x6c, 0x61,
-  0x73, 0x73, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x20,
-  0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d,
-  0x61, 0x74, 0x20, 0x3a, 0x3a, 0x20, 0x61, 0x20, 0x2d, 0x3e, 0x20, 0x5b,
-  0x63, 0x68, 0x61, 0x72, 0x5d, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
-  0x6e, 0x63, 0x65, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x5b,
-  0x63, 0x68, 0x61, 0x72, 0x5d, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
-  0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x69,
-  0x64, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
-  0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x73, 0x20, 0x63, 0x68, 0x61,
-  0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-  0x20, 0x63, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20,
-  0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x63, 0x73, 0x20, 0x3d, 0x20,
-  0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28, 0x63, 0x73, 0x5b, 0x30, 0x3a,
-  0x5d, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
-  0x20, 0x28, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x29, 0x20,
-  0x3d, 0x3e, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x40,
-  0x66, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f,
-  0x72, 0x6d, 0x61, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x66, 0x6f, 0x72,
-  0x6d, 0x61, 0x74, 0x28, 0x6c, 0x6f, 0x61, 0x64, 0x28, 0x78, 0x29, 0x29,
-  0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
-  0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e,
-  0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x28, 0x28, 0x29, 0x2b,
-  0x61, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x66,
-  0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x6d, 0x78, 0x20, 0x3d, 0x20, 0x6d,
-  0x61, 0x74, 0x63, 0x68, 0x20, 0x6d, 0x78, 0x20, 0x77, 0x69, 0x74, 0x68,
-  0x20, 0x7c, 0x20, 0x7c, 0x31, 0x3d, 0x78, 0x7c, 0x20, 0x2d, 0x3e, 0x20,
-  0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28, 0x78, 0x29, 0x20, 0x7c, 0x20,
-  0x5f, 0x20, 0x2d, 0x3e, 0x20, 0x22, 0x22, 0x0a, 0x0a, 0x69, 0x6e, 0x73,
-  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68, 0x6f, 0x77, 0x20,
+  0x6e, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74,
+  0x28, 0x6c, 0x6f, 0x61, 0x64, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a, 0x2f,
+  0x2f, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62, 0x69, 0x74, 0x20,
+  0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x0a, 0x69, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x63, 0x65, 0x20, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62,
+  0x69, 0x74, 0x76, 0x65, 0x63, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a,
+  0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x62, 0x76, 0x20, 0x3d,
+  0x20, 0x62, 0x76, 0x50, 0x72, 0x69, 0x6e, 0x74, 0x54, 0x28, 0x62, 0x76,
+  0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20, 0x62, 0x76, 0x4c, 0x65, 0x6e, 0x67,
+  0x74, 0x68, 0x28, 0x62, 0x76, 0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20,
+  0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69,
+  0x6e, 0x67, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74,
+  0x27, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x53, 0x68,
+  0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x50, 0x72, 0x69,
+  0x6e, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
+  0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x70,
+  0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x73, 0x68, 0x6f, 0x77, 0x28, 0x78,
+  0x29, 0x29, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x77, 0x65, 0x20, 0x77, 0x69,
+  0x6e, 0x64, 0x20, 0x75, 0x70, 0x20, 0x64, 0x6f, 0x69, 0x6e, 0x67, 0x20,
+  0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x75, 0x72, 0x70, 0x72, 0x69, 0x73,
+  0x69, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x0a,
+  0x70, 0x72, 0x69, 0x6e, 0x74, 0x6c, 0x6e, 0x20, 0x3a, 0x3a, 0x20, 0x28,
+  0x50, 0x72, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20,
+  0x61, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x70, 0x72, 0x69, 0x6e,
+  0x74, 0x6c, 0x6e, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x6c, 0x65, 0x74, 0x20,
+  0x5f, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x28, 0x78, 0x29,
+  0x20, 0x69, 0x6e, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22,
+  0x5c, 0x6e, 0x22, 0x29, 0x0a, 0x0a, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72,
+  0x4c, 0x6e, 0x20, 0x3a, 0x3a, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d,
+  0x20, 0x2d, 0x3e, 0x20, 0x28, 0x29, 0x0a, 0x70, 0x75, 0x74, 0x53, 0x74,
+  0x72, 0x4c, 0x6e, 0x20, 0x78, 0x20, 0x3d, 0x20, 0x6c, 0x65, 0x74, 0x20,
+  0x5f, 0x20, 0x3d, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x78,
+  0x29, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28,
+  0x22, 0x5c, 0x6e, 0x22, 0x29, 0x0a, 0x0a, 0x2f, 0x2a, 0x0a, 0x20, 0x2a,
+  0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72,
+  0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66,
+  0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x73, 0x74,
+  0x72, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x3a,
+  0x20, 0x60, 0x78, 0x20, 0x3d, 0x20, 0x24, 0x78, 0x60, 0x20, 0x3d, 0x3e,
+  0x20, 0x22, 0x78, 0x20, 0x3d, 0x20, 0x22, 0x20, 0x2b, 0x2b, 0x20, 0x66,
+  0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x20, 0x2a,
+  0x2f, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x46, 0x6f, 0x72, 0x6d,
+  0x61, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
+  0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3a, 0x3a, 0x20, 0x61,
+  0x20, 0x2d, 0x3e, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x0a, 0x0a,
+  0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x46, 0x6f, 0x72,
+  0x6d, 0x61, 0x74, 0x20, 0x5b, 0x63, 0x68, 0x61, 0x72, 0x5d, 0x20, 0x77,
+  0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61,
+  0x74, 0x20, 0x3d, 0x20, 0x69, 0x64, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x63, 0x65, 0x20, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63,
+  0x73, 0x20, 0x63, 0x68, 0x61, 0x72, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x46,
+  0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x63, 0x73, 0x20, 0x77, 0x68, 0x65,
+  0x72, 0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20,
+  0x63, 0x73, 0x20, 0x3d, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28,
+  0x63, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x46, 0x6f, 0x72, 0x6d, 0x61,
+  0x74, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x46, 0x6f, 0x72, 0x6d,
+  0x61, 0x74, 0x20, 0x61, 0x40, 0x66, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
+  0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x78, 0x20,
+  0x3d, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28, 0x6c, 0x6f, 0x61,
+  0x64, 0x28, 0x78, 0x29, 0x29, 0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x63, 0x65, 0x20, 0x28, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20,
   0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-  0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x66,
-  0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x6f, 0x77,
-  0x0a, 0x0a
+  0x20, 0x28, 0x28, 0x29, 0x2b, 0x61, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72,
+  0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x6d,
+  0x78, 0x20, 0x3d, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6d, 0x78,
+  0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x7c, 0x20, 0x7c, 0x31, 0x3d, 0x78,
+  0x7c, 0x20, 0x2d, 0x3e, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28,
+  0x78, 0x29, 0x20, 0x7c, 0x20, 0x5f, 0x20, 0x2d, 0x3e, 0x20, 0x22, 0x22,
+  0x0a, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28,
+  0x53, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x46,
+  0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x20, 0x77, 0x68, 0x65, 0x72,
+  0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d,
+  0x20, 0x73, 0x68, 0x6f, 0x77, 0x0a, 0x0a
 };
-unsigned int __show_hob_len = 8642;
+unsigned int __show_hob_len = 8695;
 unsigned char __sort_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x61, 0x20, 0x62, 0x61, 0x73, 0x69,
   0x63, 0x20, 0x69, 0x6e, 0x2d, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x71,
diff --git a/include/hobbes/hobbes.H b/include/hobbes/hobbes.H
index 8019945e0..6899be9b6 100644
--- a/include/hobbes/hobbes.H
+++ b/include/hobbes/hobbes.H
@@ -16,12 +16,6 @@
 #include <llvm/ADT/StringMap.h>
 #include <llvm/Support/FormatVariadic.h>
 
-#define llerrs(x)                                                              \
-  do {                                                                         \
-    llvm::errs() << "file:" << __FILE__ << "(" << __LINE__ << ")"              \
-                 << ", func:" << __PRETTY_FUNCTION__ << ": " << x << '\n';     \
-  } while (false)
-
 namespace hobbes {
 
 LLVM_NODISCARD inline std::string createUniqueName(llvm::StringRef prefix) {
diff --git a/include/hobbes/lang/preds/hasctor/variant.H b/include/hobbes/lang/preds/hasctor/variant.H
index 7c4b1d13f..fc59b53c5 100644
--- a/include/hobbes/lang/preds/hasctor/variant.H
+++ b/include/hobbes/lang/preds/hasctor/variant.H
@@ -14,6 +14,8 @@ struct HCVariantEliminator : public HCEliminator {
   std::string name() const;
 };
 
+const Variant* isVariantPEnum(const MonoTypePtr& e);
+
 }
 
 #endif
diff --git a/include/hobbes/lang/tylift.H b/include/hobbes/lang/tylift.H
index fd2486c8a..3dcdc2a22 100644
--- a/include/hobbes/lang/tylift.H
+++ b/include/hobbes/lang/tylift.H
@@ -16,6 +16,8 @@
 #include <chrono>
 #include <stdexcept>
 
+extern hobbes::MonoTypePtr makePVarType(const hobbes::Variant::Members &vms);
+
 namespace hobbes {
 
 /*********
@@ -410,7 +412,8 @@ template <typename T, typename R = uint32_t>
       if (sizeof(R) == sizeof(uint32_t)) {
         return Variant::make(vms);
       } else {
-        return tapp(primty("penum", tabs(str::strings("r", "v"), tvar("r"))), list(lift<R>::type(tenv), Variant::make(vms)));
+        return tapp(primty("penum", tabs(str::strings("r", "v"), tvar("r"))),
+                    list(lift<R>::type(tenv), makePVarType(vms)));
       }
     }
   };
diff --git a/include/hobbes/read/pgen/hexpr.parse.H b/include/hobbes/read/pgen/hexpr.parse.H
index facf0b124..c87cd911d 100644
--- a/include/hobbes/read/pgen/hexpr.parse.H
+++ b/include/hobbes/read/pgen/hexpr.parse.H
@@ -156,7 +156,7 @@ extern int yydebug;
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 union YYSTYPE
 {
-#line 262 "hexpr.y"
+#line 295 "hexpr.y"
 
   hobbes::Module*              module;
   hobbes::ModuleDefs*          mdefs;
@@ -197,6 +197,7 @@ union YYSTYPE
   hobbes::MonoTypes*           mtypes;
   hobbes::Record::Members*     mreclist;
   hobbes::Variant::Members*    mvarlist;
+  hobbes::Variant::Member*     mpvar;
 
   std::string*                            string;
   bool                                    boolv;
@@ -216,7 +217,7 @@ union YYSTYPE
   hobbes::BoundGrammarValue*   pbelem;
   hobbes::GrammarValue*        pvalue;
 
-#line 220 "hexpr.parse.H"
+#line 221 "hexpr.parse.H"
 
 };
 typedef union YYSTYPE YYSTYPE;
diff --git a/lib/hobbes/boot/show.hob b/lib/hobbes/boot/show.hob
index 2c1f81537..3b4c8a473 100644
--- a/lib/hobbes/boot/show.hob
+++ b/lib/hobbes/boot/show.hob
@@ -119,6 +119,8 @@ instance (Ord t t) => Ord (penum t v) (penum t v) where
   x >= y = x.t >= y.t
 instance (UnpackEnum t v, Show v) => Show t where
   show e = show(unpackEnum(e))
+instance Show ((penum a v)) where
+  show = penumShow
 
 // serialization for arrays
 instance (Array cs char) => Show cs where
diff --git a/lib/hobbes/eval/cexpr.C b/lib/hobbes/eval/cexpr.C
index 1e94f0352..1a1124b01 100644
--- a/lib/hobbes/eval/cexpr.C
+++ b/lib/hobbes/eval/cexpr.C
@@ -1,11 +1,12 @@
 
+#include "hobbes/reflect.H"
 #include <hobbes/eval/jitcc.H>
 #include <hobbes/eval/cexpr.H>
 #include <hobbes/eval/ctype.H>
 #include <hobbes/lang/expr.H>
 #include <hobbes/lang/type.H>
 #include <hobbes/util/llvm.H>
-#include <hobbes/util/perf.H>
+#include <hobbes/lang/preds/hasctor/variant.H>
 #include <llvm/IR/Instruction.h>
 #include <llvm/IR/LLVMContext.h>
 
@@ -221,8 +222,18 @@ public:
 
   llvm::Value* with(const MkVariant* v) const {
     MonoTypePtr mvty = requireMonotype(v->type());
-    Variant*    vty  = is<Variant>(mvty);
-    if (!vty) { throw annotated_error(*v, "Internal compiler error, compiling variant without variant type: " + show(v) + " :: " + show(v->type())); }
+    const Variant *vty = is<Variant>(mvty);
+    if (vty == nullptr && show(v->value()) == "()") {
+      vty = isVariantPEnum(mvty);
+      if (vty != nullptr) {
+        llvm::Type *uty = toLLVM(mvty);
+        return withContext([&](auto &) {
+          return llvm::Constant::getIntegerValue(
+              uty, llvm::APInt(8 * sizeOf(mvty), vty->id(v->label())));
+        });
+      }
+    }
+    if (!vty) { throw annotated_error(*v, "Internal compiler error, compiling variant without penum/variant type: " + show(v) + " :: " + show(v->type())); }
 
     llvm::Value* p  = compileAllocStmt(sizeOf(mvty), alignment(mvty), ptrType(byteType()));
     llvm::Value* tg = cvalue(vty->id(v->label()));
diff --git a/lib/hobbes/eval/func.C b/lib/hobbes/eval/func.C
index a399bbdc0..3ac827dd4 100644
--- a/lib/hobbes/eval/func.C
+++ b/lib/hobbes/eval/func.C
@@ -3,6 +3,7 @@
 #include <hobbes/eval/func.H>
 #include <hobbes/eval/ctype.H>
 #include <hobbes/db/file.H>
+#include <hobbes/lang/preds/hasctor/variant.H>
 
 #include <iostream>
 
@@ -882,6 +883,71 @@ public:
   }
 };
 
+class penumShow : public op {
+public:
+  llvm::Value *apply(jitcc *c, const MonoTypes &tys, const MonoTypePtr &,
+                     const Exprs &es) override {
+    const Variant *vty = isVariantPEnum(tys[0]);
+    if (vty == nullptr) {
+      throw annotated_error(*es[0], "Internal error, " + show(tys[0]) +
+                                        " is not an application");
+    }
+    const auto &ms = vty->members();
+    llvm::Value *id = c->compile(es[0]);
+    return withContext([&](llvm::LLVMContext &ctx) -> llvm::Value * {
+      id = c->builder()->CreateZExt(id, c->builder()->getInt32Ty());
+      return genIfElse(c, ctx, id, ms, ms.size() - 1);
+    });
+  }
+  hobbes::PolyTypePtr type(typedb &) const override {
+    static PolyTypePtr ty(new PolyType(
+        1, qualtype(functy(list(tgen(0)), arrayty(prim<char>())))));
+    return ty;
+  }
+
+private:
+  llvm::Value *genIfElse(jitcc *c, llvm::LLVMContext &ctx, llvm::Value *id,
+                         const Variant::Members &ms, size_t ind) {
+    auto *builder = c->builder();
+    llvm::Function *thisFn = builder->GetInsertBlock()->getParent();
+    llvm::Value *cond =
+        builder->CreateICmpEQ(builder->getInt32(ms[ind].id), id);
+
+    auto *thenBlock = llvm::BasicBlock::Create(ctx, "then", thisFn);
+    auto *elseBlock = llvm::BasicBlock::Create(ctx, "else");
+    auto *mergeBlock = llvm::BasicBlock::Create(ctx, "ifmerge");
+
+    builder->CreateCondBr(cond, thenBlock, elseBlock);
+    builder->SetInsertPoint(thenBlock);
+    llvm::Value *thenExp = c->compile(ExprPtr(
+        mkarray("|" + ms[ind].selector + "|", LexicalAnnotation::null())));
+    builder->CreateBr(mergeBlock);
+
+    thenBlock = builder->GetInsertBlock();
+
+    thisFn->getBasicBlockList().push_back(elseBlock);
+    builder->SetInsertPoint(elseBlock);
+
+    llvm::Value *elseExp = nullptr;
+    if (ind == 0) {
+      elseExp = c->compile(ExprPtr(mkarray("?", LexicalAnnotation::null())));
+    } else {
+      elseExp = genIfElse(c, ctx, id, ms, ind - 1);
+    }
+
+    builder->CreateBr(mergeBlock);
+
+    elseBlock = builder->GetInsertBlock();
+
+    thisFn->getBasicBlockList().push_back(mergeBlock);
+    builder->SetInsertPoint(mergeBlock);
+    auto *pn = builder->CreatePHI(toLLVM(arrayty(prim<char>()), true), 2);
+    pn->addIncoming(thenExp, thenBlock);
+    pn->addIncoming(elseExp, elseBlock);
+    return pn;
+  }
+};
+
 /*
  * NOTE: stdstrsizeF and stdstrelemF assume a certain memory representation for std::string
  *       this makes them very efficient in e.g. large match expressions on std::string values
@@ -1079,6 +1145,8 @@ void initDefOperators(cc* c) {
   BINDF(".variantSplit",      new varSplit());
   BINDF(".variantInjectHead", new varInjH());
 
+  BINDF("penumShow",          new penumShow());
+
   // access std::string fields
   c->bind("stdstrsize", &stdstrsize);
   c->bind("stdstrelem", &stdstrelem);
diff --git a/lib/hobbes/lang/preds/hasctor/variant.C b/lib/hobbes/lang/preds/hasctor/variant.C
index 8580579b9..703540e48 100644
--- a/lib/hobbes/lang/preds/hasctor/variant.C
+++ b/lib/hobbes/lang/preds/hasctor/variant.C
@@ -1,11 +1,30 @@
 
+#include "hobbes/lang/type.H"
 #include <hobbes/lang/preds/hasctor/variant.H>
 #include <hobbes/lang/typeinf.H>
 
 namespace hobbes {
 
+const Variant *isVariantPEnum(const MonoTypePtr &e) {
+  if (const TApp *tappty = is<TApp>(e)) {
+    if (const Prim *fn = is<Prim>(tappty->fn())) {
+      if (fn->name() == "penum" && tappty->args().size() == 2) {
+        return is<Variant>(tappty->args()[1]);
+      }
+    }
+  }
+  return nullptr;
+}
+
+static const Variant *isMaybeNestedVariant(const MonoTypePtr &e) {
+  if (const auto *vty = is<Variant>(e)) {
+    return vty;
+  }
+  return isVariantPEnum(e);
+}
+
 bool HCVariantEliminator::satisfied(const TEnvPtr&, const HasCtor& hc, Definitions*) const {
-  if (const Variant* vty = is<Variant>(hc.variant)) {
+  if (const Variant* vty = isMaybeNestedVariant(hc.variant)) {
     if (const TString* fname = is<TString>(hc.ctorlbl)) {
       if (const Variant::Member* m = vty->mmember(fname->value())) {
         return *m->type == *hc.ctorty;
@@ -16,7 +35,7 @@ bool HCVariantEliminator::satisfied(const TEnvPtr&, const HasCtor& hc, Definitio
 }
 
 bool HCVariantEliminator::satisfiable(const TEnvPtr& tenv, const HasCtor& hc, Definitions*) const {
-  if (const Variant* vty = is<Variant>(hc.variant)) {
+  if (const Variant* vty = isMaybeNestedVariant(hc.variant)) {
     if (const TString* fname = is<TString>(hc.ctorlbl)) {
       const Variant::Member* vm = vty->mmember(fname->value());
       return vm != 0 && unifiable(tenv, vm->type, hc.ctorty);
@@ -28,7 +47,7 @@ bool HCVariantEliminator::satisfiable(const TEnvPtr& tenv, const HasCtor& hc, De
 }
 
 bool HCVariantEliminator::refine(const TEnvPtr&, const HasCtor& hc, MonoTypeUnifier* s, Definitions*) {
-  if (const Variant* vty = is<Variant>(hc.variant)) {
+  if (const Variant* vty = isMaybeNestedVariant(hc.variant)) {
     if (const TString* fname = is<TString>(hc.ctorlbl)) {
       if (const Variant::Member* m = vty->mmember(fname->value())) {
         size_t uc = s->size();
diff --git a/lib/hobbes/lang/type.C b/lib/hobbes/lang/type.C
index 95dd1592c..5546a3eb5 100644
--- a/lib/hobbes/lang/type.C
+++ b/lib/hobbes/lang/type.C
@@ -1,4 +1,5 @@
 
+#include <algorithm>
 #include <hobbes/lang/type.H>
 #include <hobbes/lang/expr.H>
 #include <hobbes/lang/tylift.H>
@@ -858,12 +859,25 @@ void showFull(const Variant::Members& ms, std::ostream& out) {
   out << "|";
   size_t i = nextVisibleMember(0, ms);
   if (i < ms.size()) {
-    out << ms[i].selector;
-    showFullVarPayloadSuffix(ms[i].type, out);
+    const bool discrete = [s = std::next(ms.cbegin(), i), e = ms.cend()] {
+      // not start from zero or not continous
+      return s->id != 0 ||
+             std::adjacent_find(s, e, [](const auto &a, const auto &b) {
+               return !((a.id < b.id) && (a.id + 1 == b.id));
+             }) != e;
+    }();
+    const auto showPayload = [&out, discrete](const Variant::Member &m) {
+      out << m.selector;
+      if (discrete) {
+        out << '(' << m.id << ')';
+      }
+      showFullVarPayloadSuffix(m.type, out);
+    };
+
+    showPayload(ms[i]);
     for (size_t j = i + 1; j < ms.size(); ++j) {
       out << ", ";
-      out << ms[j].selector;
-      showFullVarPayloadSuffix(ms[j].type, out);
+      showPayload(ms[j]);
     }
   }
   out << "|";
diff --git a/lib/hobbes/read/pgen/hexpr.lex.C b/lib/hobbes/read/pgen/hexpr.lex.C
index 019a10e9c..42a06871d 100644
--- a/lib/hobbes/read/pgen/hexpr.lex.C
+++ b/lib/hobbes/read/pgen/hexpr.lex.C
@@ -1,6 +1,6 @@
-#line 2 "hexpr.lex.C"
+#line 1 "hexpr.lex.C"
 
-#line 4 "hexpr.lex.C"
+#line 3 "hexpr.lex.C"
 
 #define  YY_INT_ALIGNED short int
 
@@ -789,9 +789,9 @@ std::string* identifier(const char* b, const char* e) {
     return hobbes::autorelease(new std::string(b, e));
   }
 }
-#line 793 "hexpr.lex.C"
+#line 792 "hexpr.lex.C"
 
-#line 795 "hexpr.lex.C"
+#line 794 "hexpr.lex.C"
 
 #define INITIAL 0
 #define BLOCK_COMMENT 1
@@ -1028,7 +1028,7 @@ YY_DECL
   }
 
 
-#line 1032 "hexpr.lex.C"
+#line 1031 "hexpr.lex.C"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1730,7 +1730,7 @@ YY_RULE_SETUP
 #line 214 "hexpr.l"
 ECHO;
 	YY_BREAK
-#line 1734 "hexpr.lex.C"
+#line 1733 "hexpr.lex.C"
 			case YY_STATE_EOF(INITIAL):
 			case YY_STATE_EOF(BLOCK_COMMENT):
 				yyterminate();
@@ -2027,7 +2027,7 @@ static int yy_get_next_buffer (void)
 	if ( ! yy_is_jam )
 		*(yy_state_ptr)++ = yy_current_state;
 
-	return yy_is_jam ? 0 : yy_current_state;
+  return yy_is_jam ? 0 : yy_current_state;
 }
 
 #ifndef YY_NO_UNPUT
diff --git a/lib/hobbes/read/pgen/hexpr.parse.C b/lib/hobbes/read/pgen/hexpr.parse.C
index d1c6f5a18..319b2067c 100644
--- a/lib/hobbes/read/pgen/hexpr.parse.C
+++ b/lib/hobbes/read/pgen/hexpr.parse.C
@@ -298,6 +298,39 @@ MonoTypePtr makeRecType(const Record::Members& tms) {
   return Record::make(tms);
 }
 
+static MonoTypePtr makePVarTypeImp(const Variant::Members &vms,
+                                   const LexicalAnnotation *la) {
+  const auto sanityCheck = [&] {
+    auto tvms = vms;
+    std::sort(tvms.begin(), tvms.end(),
+              [](const auto &a, const auto &b) { return a.id < b.id; });
+    const auto it = std::adjacent_find(
+        tvms.cbegin(), tvms.cend(),
+        [](const auto &a, const auto &b) { return a.id == b.id; });
+    if (it != tvms.cend()) {
+      const auto es =
+          "penum has duplicated value(" + std::to_string(it->id) + ")";
+      if (la != nullptr) {
+        throw annotated_error(*la, es);
+      } else {
+        throw std::runtime_error(es);
+      }
+    }
+  };
+
+  sanityCheck();
+  return Variant::make(vms);
+}
+
+MonoTypePtr makePVarType(const Variant::Members &vms) {
+  return makePVarTypeImp(vms, nullptr);
+}
+
+MonoTypePtr makePVarType(const Variant::Members &vms,
+                         const LexicalAnnotation &la) {
+  return makePVarTypeImp(vms, &la);
+}
+
 MonoTypePtr makeVarType(const Variant::Members& vms) {
   Variant::Members tvms = vms;
   for (unsigned int i = 0; i < tvms.size(); ++i) {
@@ -323,7 +356,7 @@ extern PatVarCtorFn patVarCtorFn;
 }
 
 
-#line 327 "hexpr.parse.C"
+#line 360 "hexpr.parse.C"
 
 # ifndef YY_CAST
 #  ifdef __cplusplus
@@ -346,7 +379,7 @@ extern PatVarCtorFn patVarCtorFn;
 #  endif
 # endif
 
-// #include "hexpr.parse.H"
+//#include "hexpr.parse.H"
 /* Symbol kind.  */
 enum yysymbol_kind_t
 {
@@ -530,7 +563,9 @@ enum yysymbol_kind_t
   YYSYMBOL_msumlist = 176,                 /* msumlist  */
   YYSYMBOL_mreclist = 177,                 /* mreclist  */
   YYSYMBOL_mvarlist = 178,                 /* mvarlist  */
-  YYSYMBOL_id = 179                        /* id  */
+  YYSYMBOL_mpvarlist = 179,                /* mpvarlist  */
+  YYSYMBOL_mpvar = 180,                    /* mpvar  */
+  YYSYMBOL_id = 181                        /* id  */
 };
 typedef enum yysymbol_kind_t yysymbol_kind_t;
 
@@ -855,16 +890,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  74
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   3078
+#define YYLAST   3032
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  98
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  82
+#define YYNNTS  84
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  366
+#define YYNRULES  374
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  809
+#define YYNSTATES  826
 
 /* YYMAXUTOK -- Last valid token kind.  */
 #define YYMAXUTOK   352
@@ -923,43 +958,44 @@ static const yytype_int8 yytranslate[] =
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
-       0,   488,   488,   489,   490,   491,   494,   495,   496,   498,
-     499,   500,   502,   503,   504,   505,   506,   507,   509,   510,
-     511,   512,   513,   514,   515,   516,   517,   518,   519,   520,
-     521,   522,   523,   524,   525,   526,   527,   528,   529,   532,
-     535,   538,   539,   540,   543,   544,   547,   549,   552,   553,
-     554,   555,   556,   557,   558,   559,   561,   562,   564,   566,
-     567,   569,   572,   573,   574,   575,   577,   578,   580,   583,
-     585,   587,   588,   590,   592,   594,   595,   596,   597,   598,
-     599,   600,   601,   602,   603,   604,   605,   606,   607,   608,
-     609,   610,   611,   612,   614,   615,   617,   618,   621,   622,
-     623,   624,   626,   627,   628,   629,   630,   631,   633,   634,
-     636,   637,   638,   639,   640,   641,   642,   643,   644,   646,
-     647,   648,   649,   650,   652,   653,   654,   655,   657,   660,
-     661,   664,   667,   670,   682,   683,   686,   688,   689,   691,
-     693,   694,   696,   697,   699,   700,   702,   703,   705,   706,
-     709,   710,   713,   714,   715,   716,   717,   718,   719,   720,
-     721,   724,   725,   726,   727,   728,   731,   732,   733,   736,
-     739,   742,   743,   746,   747,   748,   749,   750,   751,   752,
-     753,   754,   755,   756,   757,   758,   759,   762,   765,   766,
-     767,   768,   769,   770,   771,   772,   773,   774,   775,   776,
-     777,   778,   779,   780,   781,   782,   785,   787,   788,   790,
-     792,   793,   795,   797,   798,   800,   801,   803,   804,   805,
-     807,   808,   810,   811,   813,   814,   816,   817,   820,   821,
-     823,   824,   825,   826,   827,   828,   829,   830,   831,   832,
-     833,   834,   835,   836,   837,   838,   839,   840,   841,   842,
-     843,   844,   845,   846,   848,   849,   850,   851,   852,   854,
-     856,   857,   859,   860,   862,   863,   865,   867,   868,   869,
-     871,   872,   873,   874,   875,   876,   877,   878,   879,   880,
-     881,   882,   883,   884,   885,   891,   892,   893,   894,   896,
-     897,   899,   900,   901,   903,   904,   905,   907,   908,   911,
-     913,   914,   916,   917,   918,   919,   920,   921,   922,   923,
-     924,   925,   927,   928,   929,   930,   932,   933,   934,   935,
-     937,   938,   939,   941,   942,   944,   945,   947,   948,   949,
-     951,   952,   953,   954,   955,   956,   957,   958,   959,   960,
-     961,   962,   963,   964,   965,   966,   967,   968,   970,   971,
-     973,   974,   976,   977,   979,   980,   982,   983,   985,   986,
-     988,   989,   991,   992,   993,   994,   996
+       0,   524,   524,   525,   526,   527,   530,   531,   532,   534,
+     535,   536,   538,   539,   540,   541,   542,   543,   545,   546,
+     547,   548,   549,   550,   551,   552,   553,   554,   555,   556,
+     557,   558,   559,   560,   561,   562,   563,   564,   565,   568,
+     571,   574,   575,   576,   579,   580,   583,   585,   588,   589,
+     590,   591,   592,   593,   594,   595,   597,   598,   600,   602,
+     603,   605,   608,   609,   610,   611,   613,   614,   616,   619,
+     621,   623,   624,   626,   628,   630,   631,   632,   633,   634,
+     635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
+     645,   646,   647,   648,   650,   651,   653,   654,   657,   658,
+     659,   660,   662,   663,   664,   665,   666,   667,   669,   670,
+     672,   673,   674,   675,   676,   677,   678,   679,   680,   682,
+     683,   684,   685,   686,   688,   689,   690,   691,   693,   696,
+     697,   700,   703,   706,   718,   719,   722,   724,   725,   727,
+     729,   730,   732,   733,   735,   736,   738,   739,   741,   742,
+     745,   746,   749,   750,   751,   752,   753,   754,   755,   756,
+     757,   760,   761,   762,   763,   764,   767,   768,   769,   772,
+     775,   778,   779,   782,   783,   784,   785,   786,   787,   788,
+     789,   790,   791,   792,   793,   794,   795,   798,   801,   802,
+     803,   804,   805,   806,   807,   808,   809,   810,   811,   812,
+     813,   814,   815,   816,   817,   818,   821,   823,   824,   826,
+     828,   829,   831,   833,   834,   836,   837,   839,   840,   841,
+     843,   844,   846,   847,   849,   850,   852,   853,   856,   857,
+     859,   860,   861,   862,   863,   864,   865,   866,   867,   868,
+     869,   870,   871,   872,   873,   874,   875,   876,   877,   878,
+     879,   880,   881,   882,   884,   885,   886,   887,   888,   890,
+     892,   893,   895,   896,   898,   899,   901,   903,   904,   905,
+     907,   908,   909,   910,   911,   912,   913,   914,   915,   916,
+     917,   918,   919,   920,   921,   927,   928,   929,   930,   932,
+     933,   935,   936,   937,   939,   940,   941,   943,   944,   947,
+     949,   950,   952,   953,   954,   955,   956,   957,   958,   959,
+     960,   961,   963,   964,   965,   966,   968,   969,   970,   971,
+     973,   974,   975,   977,   978,   980,   981,   983,   984,   985,
+     987,   988,   989,   990,   991,   992,   993,   994,   995,   996,
+     997,   998,   999,  1000,  1001,  1002,  1003,  1004,  1005,  1007,
+    1008,  1010,  1011,  1013,  1014,  1016,  1017,  1019,  1020,  1022,
+    1023,  1025,  1026,  1028,  1029,  1030,  1031,  1033,  1034,  1036,
+    1037,  1038,  1039,  1040,  1042
 };
 #endif
 
@@ -1005,7 +1041,7 @@ static const char *const yytname[] =
   "recfieldpath", "varfields", "varbind", "cargs", "qtype", "cst",
   "tpreds", "tpred", "l1mtargl", "ltmtype", "l0mtype", "l1mtype", "tyind",
   "cppid", "l0mtargl", "l0mtarglt", "mtuplist", "msumlist", "mreclist",
-  "mvarlist", "id", YY_NULLPTR
+  "mvarlist", "mpvarlist", "mpvar", "id", YY_NULLPTR
 };
 
 static const char *
@@ -1033,12 +1069,12 @@ static const yytype_int16 yytoknum[] =
 };
 #endif
 
-#define YYPACT_NINF (-590)
+#define YYPACT_NINF (-603)
 
 #define yypact_value_is_default(Yyn) \
   ((Yyn) == YYPACT_NINF)
 
-#define YYTABLE_NINF (-366)
+#define YYTABLE_NINF (-367)
 
 #define yytable_value_is_error(Yyn) \
   0
@@ -1047,87 +1083,89 @@ static const yytype_int16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-     385,  1512,  2283,  2283,   159,    28,    28,    28,    53,    53,
-     131,   131,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,    93,
-     121,  2283,  2985,   -32,  2985,    28,   185,  1732,  2283,    93,
-     137,  2283,   376,  -590,   959,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,   260,  -590,   263,   301,    21,   273,  2751,  2595,
-    2283,  1815,  1690,  1690,  -590,   176,   272,   399,   364,   412,
-    -590,   321,  -590,  -590,  -590,  1512,   365,   373,  -590,  2981,
-     179,  -590,  -590,   218,   868,   409,    53,   445,  1177,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  1690,    28,   -14,  -590,   353,
-    -590,   430,   259,  2907,    28,   259,   480,  2361,   444,   446,
-    2673,   448,   449,   450,    93,   451,   452,   454,   455,   456,
-     457,   461,   465,  1611,   466,   468,   469,  -590,  -590,   470,
-    -590,   203,   -29,   117,   343,   490,   500,    99,   458,    28,
-      28,   460,  -590,  1276,  1276,  1690,  2283,  2049,    21,  -590,
-    -590,    93,  2283,   230,  -590,  -590,   481,   444,   446,  2673,
-     448,   449,   450,   451,   452,   454,   456,   457,   461,   465,
-     466,   468,   469,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  1690,  1690,    28,   383,
-     301,  1096,  -590,  -590,  -590,  1535,  2517,  2517,  2517,  2517,
-    2595,  2751,  2751,  2751,  2751,  2751,  2751,  2751,  2751,  2751,
-    2751,  2751,  2829,  2829,  2829,  2283,  -590,   959,    28,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  1276,  -590,  1276,  -590,
-    -590,  -590,    28,    28,   459,   155,  1399,  1399,    28,  2283,
-     345,  -590,   138,  1399,    28,    29,    53,  2981,    28,   459,
-      28,    28,    34,  -590,    41,   516,   514,   517,  -590,  -590,
-     346,   483,   358,  -590,   523,  2283,    66,  2595,   485,   486,
-     259,    19,  -590,   530,  2985,  1893,    93,   487,  1971,  -590,
-     532,   533,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  2283,  1690,  2127,  -590,  -590,   403,  2283,  2283,
-    2283,  -590,  -590,  -590,  -590,  -590,   527,  -590,   540,  -590,
-    -590,  -590,   350,   499,  2283,   124,  -590,  -590,  2283,   234,
-    2283,   359,   233,   435,   537,   196,  2283,  -590,  2283,     1,
-     495,   495,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,   959,
-    -590,  -590,  -590,   535,   354,   507,  -590,   548,  -590,     0,
-    1177,  -590,   684,   459,    46,   436,   551,   120,   400,   116,
-     544,   494,  -590,   868,   184,  1399,  1399,    93,  1399,  1399,
-    1399,   800,  1399,   503,    53,   582,    28,    28,  1177,   519,
-     563,   570,   592,  -590,  1399,  1399,  1399,  1399,  -590,   534,
-    1690,  -590,    45,  1690,  -590,  2283,  -590,  -590,   434,  1690,
-     486,  -590,  -590,  -590,  -590,   205,  -590,  -590,  -590,  -590,
-    -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  -590,  1893,
-    2439,    93,   453,   301,  -590,   523,  -590,  2283,  -590,  -590,
-    2283,  -590,  -590,    -1,   574,  -590,   536,  -590,   573,  -590,
-     538,   541,   459,   178,  1177,  -590,  -590,   539,  2205,  -590,
-    -590,  2283,   255,   547,  -590,   542,  -590,   543,  -590,    52,
-    1690,  1690,  -590,  -590,  -590,  1399,  -590,  -590,  -590,  -590,
-    1399,   545,  -590,  1399,  -590,    28,  1177,  1399,  1177,  -590,
-      28,  1177,  1399,  -590,  -590,  1399,  1399,  1399,   114,   112,
-     304,   503,   503,   503,  -590,   503,   503,    37,    53,   582,
-    -590,    26,  -590,   351,  -590,  -590,   195,  1177,  1177,  1177,
-      53,   592,  -590,   503,   503,   503,   503,  -590,  -590,  -590,
-    -590,  -590,  -590,   578,   410,  -590,   433,   828,  -590,   549,
-    -590,    47,  2985,   589,   211,   552,   550,  -590,  1690,  2283,
-    -590,  2283,  -590,  -590,  -590,  -590,  -590,   553,  -590,  2283,
-     270,  2283,  -590,  -590,  -590,   554,   556,   503,   225,   463,
-      54,   599,  -590,     7,   298,   561,   608,   564,    42,   503,
-     166,   201,   611,   126,   612,  1399,  1399,  1399,  1399,  1399,
-     582,    28,  -590,  -590,   582,    28,    28,  -590,   592,  -590,
-     391,  -590,  -590,   609,  -590,    28,   593,   434,    28,  2283,
-    2283,  2283,  -590,  -590,  -590,  2283,  -590,  -590,   616,   259,
-    2439,  2439,  -590,  -590,  -590,  -590,   571,  -590,  -590,  -590,
-    2283,   278,  -590,  -590,  -590,   615,  -590,   620,  -590,   617,
-    1177,  1399,   618,   621,  1177,   622,  1399,  1399,  1399,  1399,
-    1399,  1399,   503,   503,   503,   503,   503,   582,    30,   582,
-    -590,    28,   592,  -590,  1177,  2283,   619,  2283,  -590,   624,
-    -590,   626,  -590,  -590,   584,    55,  2517,  -590,  2283,   292,
-    1399,   587,  1399,  -590,   236,  1399,  1399,  -590,  1399,   305,
-     243,   282,   209,   307,   172,   582,  -590,  -590,  2283,  -590,
-    2283,  2283,  -590,  -590,  -590,     1,   585,  -590,  2283,   296,
-     503,  -590,   503,   627,   503,   503,   503,   629,  -590,  -590,
-    1399,  -590,  1399,   582,  -590,  -590,  -590,  2517,  -590,  2283,
-     300,  1399,  1399,   283,   329,     1,  -590,  2283,   311,   503,
-     503,  -590,  -590,  -590,  2283,   319,  -590,  2283,   320,  -590,
-    2283,   322,  -590,  2283,   325,  -590,  2283,   326,  -590,  2283,
-     327,  -590,  2283,   330,  -590,  2283,   341,  -590,  2283,   342,
-    -590,  2283,   344,  -590,  2283,   630,  -590,  2283,  -590
+     383,  1294,  2083,  2083,    45,    52,    52,    52,    77,    77,
+     110,   110,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,   121,
+     124,  2083,  2863,     1,  2863,    52,   123,  1532,  2083,   121,
+     411,  2083,   424,  -603,  1397,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,   176,  -603,   243,   225,   145,   273,  2629,  2473,
+    2083,  1615,  2952,  2952,  -603,   161,   212,   478,   454,   434,
+    -603,   268,  -603,  -603,  -603,  1294,   391,   309,  -603,   862,
+     189,  -603,  -603,   196,  1887,   369,    77,   376,  1965,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  2952,    52,   -26,  -603,   380,
+    -603,   366,   256,  2785,    52,   256,   416,  2161,   386,   397,
+    2551,   406,   415,   417,   121,   422,   432,   479,   484,   486,
+     492,   496,   498,  2317,   499,   503,   504,  -603,  -603,   506,
+    -603,   258,   333,    96,   408,   525,   545,    30,   394,    52,
+      52,   438,  -603,  2043,  2043,  2952,  2083,  1849,   145,  -603,
+    -603,   121,  2083,    44,  -603,  -603,   520,   386,   397,  2551,
+     406,   415,   417,   422,   432,   479,   486,   492,   496,   498,
+     499,   503,   504,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  2952,  2952,    52,   430,
+     225,   866,  -603,  -603,  -603,  2886,  2395,  2395,  2395,  2395,
+    2473,  2629,  2629,  2629,  2629,  2629,  2629,  2629,  2629,  2629,
+    2629,  2629,  2707,  2707,  2707,  2083,  -603,  1397,    52,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  2043,  -603,  2043,  -603,
+    -603,  -603,    52,    52,   217,  1002,  2121,  2121,    52,  2083,
+     351,  -603,   360,  2121,    52,    27,    77,   862,    52,   217,
+      52,    52,   144,  -603,    20,   555,   550,   554,  -603,  -603,
+     358,   515,   431,  -603,   560,  2083,   138,  2473,   528,   530,
+     256,    15,  -603,   574,  2863,  1693,   121,   533,  1771,  -603,
+     578,   580,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  2083,  2952,  1927,  -603,  -603,    39,  2083,  2083,
+    2083,  -603,  -603,  -603,  -603,  -603,  1184,  -603,   588,  -603,
+    -603,  -603,   359,   535,  2083,    10,  -603,  -603,  2083,   129,
+    2083,   377,   188,   459,   591,   101,  2083,  -603,  2083,   -10,
+     541,   541,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  1397,
+    -603,  -603,  -603,   590,    97,   563,  -603,   290,  -603,    60,
+    1965,  -603,   488,   217,   140,   464,   605,   167,   466,   468,
+    -603,     4,   594,   551,  -603,  1887,   350,  2121,  2121,   121,
+    2121,  2121,  2121,  1036,  2121,   556,    77,   631,    52,    52,
+    1965,   566,   614,    79,   638,  -603,  2121,  2121,  2121,  2121,
+    -603,   579,  2952,  -603,    16,  2952,  -603,  2083,  -603,  -603,
+     437,  2952,   530,  -603,  -603,  -603,  -603,   283,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  1693,  2239,   121,   448,   225,  -603,   560,  -603,  2083,
+    -603,  -603,  2083,  -603,  -603,   174,   617,  -603,   582,  -603,
+     618,  -603,   585,   586,   217,   581,  1965,  -603,  -603,   595,
+    2005,  -603,  -603,  2083,   149,   599,  -603,   583,  -603,   596,
+    -603,    17,  2952,  2952,  -603,  -603,  -603,  2121,  -603,  -603,
+    -603,  -603,  2121,   597,  -603,  2121,  -603,    52,  1965,  2121,
+    1965,  -603,    52,  -603,    52,  1965,   485,  2121,  -603,  -603,
+    2121,  2121,  2121,    38,    31,   299,   556,   556,   556,  -603,
+     556,   556,    29,    77,   631,  -603,    23,  -603,    48,  -603,
+    -603,   184,  1965,  1965,  1965,    77,   638,  -603,   556,   556,
+     556,   556,  -603,  -603,  -603,  -603,  -603,  -603,   628,   471,
+    -603,   387,  1490,  -603,   598,  -603,    46,  2863,   630,   133,
+     592,   593,  -603,  2952,  2083,  -603,  2083,  -603,  -603,  -603,
+    -603,  -603,   602,  -603,  2083,   192,  2083,  -603,  -603,  -603,
+     600,   601,   556,   173,   449,   255,   640,  -603,    84,   159,
+     603,   642,  -603,   611,   606,    57,   612,   620,   621,   622,
+     623,   556,   153,   190,   667,    56,   669,  2121,  2121,  2121,
+    2121,  2121,   631,    52,  -603,  -603,   631,    52,    52,  -603,
+     638,  -603,   378,  -603,  -603,   671,  -603,    52,   653,   437,
+      52,  2083,  2083,  2083,  -603,  -603,  -603,  2083,  -603,  -603,
+     679,   256,  2239,  2239,  -603,  -603,  -603,  -603,   633,  -603,
+    -603,  -603,  2083,   234,  -603,  -603,  -603,   677,  -603,   682,
+    -603,   680,  1965,  2121,   681,   678,  1965,   685,  2121,  -603,
+    -603,  -603,  -603,  -603,  2121,  2121,  2121,  2121,  2121,   556,
+     556,   556,   556,   556,   631,    25,   631,  -603,    52,   638,
+    -603,  1965,  2083,   683,  2083,  -603,   687,  -603,   693,  -603,
+    -603,   641,   353,  2395,  -603,  2083,   252,  2121,   651,  2121,
+    -603,   324,  2121,  2121,  -603,  2121,   219,   213,   326,   206,
+     301,    73,   631,  -603,  -603,  2083,  -603,  2083,  2083,  -603,
+    -603,  -603,   -10,   648,  -603,  2083,   275,   556,  -603,   556,
+     692,   556,   556,   556,   695,  -603,  -603,  2121,  -603,  2121,
+     631,  -603,  -603,  -603,  2395,  -603,  2083,   306,  2121,  2121,
+     332,   303,   -10,  -603,  2083,   311,   556,   556,  -603,  -603,
+    -603,  2083,   312,  -603,  2083,   315,  -603,  2083,   320,  -603,
+    2083,   335,  -603,  2083,   336,  -603,  2083,   337,  -603,  2083,
+     338,  -603,  2083,   342,  -603,  2083,   346,  -603,  2083,   347,
+    -603,  2083,   697,  -603,  2083,  -603
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1137,12 +1175,12 @@ static const yytype_int16 yydefact[] =
 {
        0,     9,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   366,   183,   170,   220,   185,   186,   288,     0,
+     181,   182,   374,   183,   170,   220,   185,   186,   288,     0,
        0,     0,     0,     0,     0,     0,     0,   294,   294,   267,
        0,     0,     0,     2,     8,    10,    12,    17,    13,    14,
       15,    16,     0,    39,   128,   184,   169,   151,     0,     0,
        0,   294,     0,     0,     4,   101,   107,   109,   118,   123,
-     127,   151,     5,   151,     1,     9,     0,    40,   350,     0,
+     127,   151,     5,   151,     1,     9,     0,    40,   351,     0,
        0,    71,    73,     0,     0,     0,     0,     0,     0,   278,
      273,   277,   272,   271,   274,   275,   283,   284,   276,   279,
      280,   281,   282,   287,   270,   261,     0,     0,   138,     0,
@@ -1159,10 +1197,10 @@ static const yytype_int16 yydefact[] =
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     6,     9,     0,    88,
       89,    90,    91,    92,    93,    78,    82,    81,    79,    83,
-      84,    85,    86,    75,    76,    87,     0,    72,     0,   341,
-     340,   346,     0,     0,     0,     0,     0,     0,     0,     0,
+      84,    85,    86,    75,    76,    87,     0,    72,     0,   342,
+     341,   347,     0,     0,     0,     0,     0,     0,     0,     0,
        0,   300,     0,   330,     0,    52,    69,    73,     0,     0,
-       0,     0,    62,    96,   356,     0,   328,   329,   330,   263,
+       0,     0,    62,    96,   357,     0,   328,   329,   330,   263,
        0,   260,     0,   265,     0,     0,     0,     0,     0,     0,
      222,     0,   208,     0,     0,   261,   267,     0,     0,   141,
        0,   151,   188,   189,   190,   191,   192,   193,   196,   195,
@@ -1173,77 +1211,79 @@ static const yytype_int16 yydefact[] =
        0,     0,     0,     0,     0,     0,     0,   228,     0,   100,
      103,   104,   105,   106,   112,   111,   110,   113,   114,   115,
      116,   117,   121,   119,   120,   124,   125,   126,     3,     7,
-     351,    44,    45,     0,     0,     0,   339,     0,   326,   356,
-       0,   332,     0,     0,     0,     0,   330,     0,     0,   330,
-       0,     0,   299,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   302,   323,     0,     0,     0,     0,     0,   326,
-       0,   365,     0,    97,     0,     0,     0,     0,   255,     0,
-       0,   257,     0,     0,   129,     0,   137,   139,     0,     0,
-     131,   225,   133,   207,   214,     0,   173,   174,   175,   176,
-     177,   178,   179,   180,   182,   183,   170,   185,   186,   261,
-     261,   267,     0,   184,   151,     0,   143,     0,   134,   140,
-       0,   296,   149,     0,     0,   153,     0,   167,     0,   268,
-       0,     0,     0,   356,     0,   150,   156,     0,     0,   157,
-      19,     0,     0,     0,   249,     0,   244,     0,   251,     0,
-       0,     0,   246,    98,    99,     0,   331,   335,   336,   325,
-       0,     0,   333,     0,   337,     0,     0,     0,     0,   338,
-       0,     0,     0,   347,   301,     0,     0,     0,     0,     0,
-       0,   303,   305,   304,   344,   343,   324,    48,     0,    54,
-      59,    53,    56,     0,    94,    70,    63,     0,     0,     0,
-       0,    64,    66,   358,   327,   357,   359,   256,   262,   258,
-     264,   266,   130,     0,     0,   289,     0,     0,   224,   209,
-     211,     0,     0,     0,     0,     0,     0,   154,     0,     0,
-     152,     0,   162,   161,   297,   160,   159,     0,    20,     0,
-       0,     0,   250,   245,   252,     0,     0,   342,     0,     0,
-       0,     0,   361,   356,     0,     0,   363,   364,   356,   345,
-       0,     0,   330,     0,   330,     0,     0,     0,     0,     0,
-       0,     0,    61,    60,     0,     0,     0,    95,     0,   354,
-       0,   364,    68,     0,    67,     0,   164,     0,     0,     0,
-       0,     0,   214,   219,   218,     0,   213,   216,   217,   172,
-       0,     0,   163,   135,   142,   148,   147,   269,   158,    21,
-       0,     0,   108,   248,   247,     0,   349,     0,   348,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   322,   315,   314,   313,   312,    50,    49,    55,
-      57,    58,    65,   353,     0,     0,     0,     0,   290,     0,
-     291,     0,   226,   210,     0,     0,     0,    22,     0,     0,
-       0,     0,     0,   360,     0,     0,     0,   362,     0,   358,
-       0,     0,     0,     0,     0,     0,   355,    47,     0,   165,
-       0,     0,   212,   215,   217,   145,   146,    23,     0,     0,
-     311,   334,   309,     0,   317,   321,   320,     0,   308,   306,
-       0,   316,     0,    51,   293,   292,   227,     0,    24,     0,
-       0,     0,     0,     0,     0,   144,    25,     0,     0,   310,
-     319,   307,   318,    26,     0,     0,    27,     0,     0,    28,
-       0,     0,    29,     0,     0,    30,     0,     0,    31,     0,
-       0,    32,     0,     0,    33,     0,     0,    34,     0,     0,
-      35,     0,     0,    36,     0,     0,    37,     0,    38
+     352,    44,    45,     0,     0,     0,   340,     0,   326,   357,
+       0,   332,     0,     0,     0,     0,   330,     0,     0,     0,
+     368,   330,     0,     0,   299,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   302,   323,     0,     0,     0,     0,
+       0,   326,     0,   366,     0,    97,     0,     0,     0,     0,
+     255,     0,     0,   257,     0,     0,   129,     0,   137,   139,
+       0,     0,   131,   225,   133,   207,   214,     0,   173,   174,
+     175,   176,   177,   178,   179,   180,   182,   183,   170,   185,
+     186,   261,   261,   267,     0,   184,   151,     0,   143,     0,
+     134,   140,     0,   296,   149,     0,     0,   153,     0,   167,
+       0,   268,     0,     0,     0,   357,     0,   150,   156,     0,
+       0,   157,    19,     0,     0,     0,   249,     0,   244,     0,
+     251,     0,     0,     0,   246,    98,    99,     0,   331,   335,
+     336,   325,     0,     0,   333,     0,   337,     0,     0,     0,
+       0,   338,     0,   339,     0,     0,     0,     0,   348,   301,
+       0,     0,     0,     0,     0,     0,   303,   305,   304,   345,
+     344,   324,    48,     0,    54,    59,    53,    56,     0,    94,
+      70,    63,     0,     0,     0,     0,    64,    66,   359,   327,
+     358,   360,   256,   262,   258,   264,   266,   130,     0,     0,
+     289,     0,     0,   224,   209,   211,     0,     0,     0,     0,
+       0,     0,   154,     0,     0,   152,     0,   162,   161,   297,
+     160,   159,     0,    20,     0,     0,     0,   250,   245,   252,
+       0,     0,   343,     0,     0,     0,     0,   362,   357,     0,
+       0,   364,   367,     0,   365,   357,     0,     0,     0,     0,
+       0,   346,     0,     0,   330,     0,   330,     0,     0,     0,
+       0,     0,     0,     0,    61,    60,     0,     0,     0,    95,
+       0,   355,     0,   365,    68,     0,    67,     0,   164,     0,
+       0,     0,     0,     0,   214,   219,   218,     0,   213,   216,
+     217,   172,     0,     0,   163,   135,   142,   148,   147,   269,
+     158,    21,     0,     0,   108,   248,   247,     0,   350,     0,
+     349,     0,     0,     0,     0,     0,     0,     0,     0,   371,
+     373,   372,   370,   369,     0,     0,     0,     0,     0,   322,
+     315,   314,   313,   312,    50,    49,    55,    57,    58,    65,
+     354,     0,     0,     0,     0,   290,     0,   291,     0,   226,
+     210,     0,     0,     0,    22,     0,     0,     0,     0,     0,
+     361,     0,     0,     0,   363,     0,   359,     0,     0,     0,
+       0,     0,     0,   356,    47,     0,   165,     0,     0,   212,
+     215,   217,   145,   146,    23,     0,     0,   311,   334,   309,
+       0,   317,   321,   320,     0,   308,   306,     0,   316,     0,
+      51,   293,   292,   227,     0,    24,     0,     0,     0,     0,
+       0,     0,   144,    25,     0,     0,   310,   319,   307,   318,
+      26,     0,     0,    27,     0,     0,    28,     0,     0,    29,
+       0,     0,    30,     0,     0,    31,     0,     0,    32,     0,
+       0,    33,     0,     0,    34,     0,     0,    35,     0,     0,
+      36,     0,     0,    37,     0,    38
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -590,  -590,   596,   462,   -26,  -590,  -590,  -590,  -590,   134,
-    -590,  -590,    59,    56,  -589,  -515,  -590,    57,  -519,  -387,
-     498,     4,   415,    58,   265,    -2,  -198,   -39,   284,   -28,
-     281,    18,  -590,   401,  -590,   388,  -590,   110,  -590,   -17,
-    -590,   405,  -590,    48,  -590,  -590,   -13,   -58,  -590,  -590,
-     251,   -47,  -590,   -91,   -56,  -174,  -590,  -173,  -376,  -590,
-      -8,   -51,  -590,    63,   -24,  -126,   502,  -590,   291,  -590,
-     447,   -86,   984,  -590,   464,  -590,  -590,  -590,  -590,  -590,
-    -590,   668
+    -603,  -603,   663,   512,   -32,  -603,  -603,  -603,  -603,   197,
+    -603,  -603,   108,   105,  -602,  -526,  -603,   104,  -534,  -390,
+     549,     0,   480,   111,   328,    -2,  -202,   -42,   389,   -31,
+     313,    13,  -603,   465,  -603,   452,  -603,   169,  -603,   -21,
+    -603,   463,  -603,   102,  -603,  -603,    33,   -39,  -603,  -603,
+     316,   -47,  -603,   -92,    74,  -176,  -603,  -183,  -402,  -603,
+     -19,   -52,  -603,   112,   -35,  -126,   559,  -603,   352,  -603,
+     505,   -69,   767,  -603,   509,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,   240,   436
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
        0,     4,    43,    44,    45,    46,    47,   151,    48,    49,
-     632,    50,   541,   542,   539,   540,    51,   551,   552,   265,
-     266,    52,   139,   543,   272,   140,    65,    66,    67,    68,
-      69,    70,   107,   108,   298,   299,   736,   472,   473,    54,
-     291,   292,   569,   570,   571,   646,   647,    55,   113,   440,
-     441,   201,   202,   109,   279,   280,   281,   282,   283,   144,
-     145,    56,   564,   565,   141,   337,   338,   260,   261,   412,
-     387,   339,   274,   667,    77,   275,   630,   276,   277,   395,
-     398,    73
+     644,    50,   546,   547,   544,   545,    51,   556,   557,   265,
+     266,    52,   139,   548,   272,   140,    65,    66,    67,    68,
+      69,    70,   107,   108,   298,   299,   753,   474,   475,    54,
+     291,   292,   574,   575,   576,   658,   659,    55,   113,   442,
+     443,   201,   202,   109,   279,   280,   281,   282,   283,   144,
+     145,    56,   569,   570,   141,   337,   338,   260,   261,   414,
+     387,   339,   274,   679,    77,   275,   642,   276,   277,   395,
+     398,   399,   400,    73
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1251,181 +1291,161 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-      64,    72,   273,   158,   200,   200,   203,   203,   359,   360,
-     361,   362,    81,    81,   143,   112,   205,   115,   152,    53,
-     165,   103,   351,   352,   623,   353,   300,   537,   340,   111,
-     164,   687,   634,  -352,   624,   689,   142,   415,   725,   148,
-    -352,   424,   422,   510,    22,   620,   114,   200,   424,   249,
-     671,   323,   160,    22,   250,   285,   560,   324,   166,    22,
-     251,   158,    53,   643,   158,   207,   208,   161,   286,   252,
-      22,   643,    22,   644,  -352,  -352,   577,    22,    22,   578,
-      22,   644,   424,   676,   247,   253,   209,   247,   411,   513,
-      81,    22,   164,    53,   165,   411,   290,   200,   442,   341,
-      89,    90,    91,    92,    93,    94,    95,   625,   269,   416,
-     255,   625,   270,    96,   271,   297,   103,   621,    22,    97,
-     381,   258,   382,   560,   559,   645,   259,    79,    98,   411,
-     411,   594,   342,   669,   411,   435,   753,   330,   200,   200,
-     105,   164,   411,   200,   106,   357,    22,   200,   616,   357,
-     521,   617,   615,   346,    99,   345,    22,   146,   488,    74,
-     347,   517,    22,   633,   518,   100,   101,   680,   388,   388,
-     249,   363,   623,   634,   623,   250,   404,   102,   405,   331,
-      22,   251,   406,   419,   407,   408,   423,   409,   410,   390,
-     252,   372,   373,   374,   325,   105,  -365,  -365,   322,   106,
-     411,   489,   411,   628,    22,    84,   253,   300,   411,   677,
-     249,  -352,   206,   752,   411,   250,   404,   246,   405,   424,
-      22,   251,   406,   378,   407,   408,   411,   409,   410,   269,
-     252,   255,   391,   270,   501,   271,    28,   463,   623,   158,
-     207,   208,   258,    22,   678,    53,   253,   259,   437,   651,
-     419,    29,   750,    79,   411,    22,   248,   401,   525,    22,
-     411,   209,   526,   117,   527,   200,   411,   474,   348,   269,
-     247,   255,   491,   270,   572,   271,   502,   445,   321,   156,
-      22,   157,   258,   434,   322,   351,   352,   259,   353,   411,
-      28,   652,    79,   589,    28,    22,   297,   411,    22,   153,
-     665,   509,   154,    22,   511,    29,   509,   388,   660,    29,
-     496,   162,   -73,   411,   497,   743,   708,    22,   748,   478,
-     471,    22,   476,   155,   411,    22,   479,   480,   481,   159,
-     738,   411,   273,   156,   759,   157,    22,   156,   767,   157,
-     618,   210,   487,   619,    22,    22,   490,    22,   493,   774,
-      22,    22,    22,   152,   503,    22,   504,   777,   780,   225,
-     783,   749,   771,   786,   789,   792,    22,    22,   795,    22,
-     411,   411,   200,   227,   558,   200,    22,   561,   672,   798,
-     801,   200,   804,   203,   626,   747,   411,   751,     1,     2,
-       3,   287,   567,   411,   158,   411,   419,    53,   584,   530,
-     228,   463,   463,   354,   219,   220,   221,   506,    22,   772,
-      89,    90,    91,    92,    93,    94,    95,   411,    81,   228,
-     402,   428,   326,    96,   327,   485,   403,   429,    22,    97,
-     602,   322,   605,   562,   494,   607,   143,   431,    98,   432,
-     495,   264,   200,   200,   595,   596,   211,   212,   213,   214,
-     215,   216,   217,   218,   563,   222,   223,   224,   142,    22,
-     423,   629,   602,   631,    99,   575,   693,   638,   576,   149,
-     150,   639,   694,   573,   249,   100,   101,   268,    22,   250,
-     519,   520,   477,   666,    22,   251,   587,   102,    22,   588,
-     636,   637,   385,   288,   252,   364,   365,   366,   367,   368,
-     369,   370,   371,   375,   376,   377,    80,    83,   735,   200,
-     253,   357,    85,    87,   498,   514,   499,   515,   294,   302,
-     200,   303,   474,   305,   306,   307,   308,   309,   328,   310,
-     311,   312,   313,   269,   386,   255,   314,   270,   329,   271,
-     315,   317,   249,   318,   319,   320,   258,   250,   350,   425,
-     332,   259,    22,   251,    81,   649,   335,   426,   427,   765,
-     385,   433,   252,   249,   430,   438,   439,   444,   250,   466,
-     470,  -254,   484,    22,   251,   500,   486,   656,   253,   657,
-     209,   505,   507,   252,   713,   516,   523,   659,   717,   662,
-     522,   411,   463,   463,   595,   596,   538,   548,   158,   253,
-     547,   482,   386,   255,   549,   256,   550,   257,   726,   557,
-     579,   581,   635,   580,   258,   591,   585,   592,   582,   259,
-     593,   583,   269,   508,   255,   599,   270,   650,   271,   642,
-     658,   653,   654,   670,   663,   258,   664,   700,   701,   702,
-     259,   673,   674,   704,   675,   679,   681,   695,   480,   481,
-     705,   697,   706,   710,   711,   712,   715,   728,   707,   731,
-     716,   718,   730,   732,   741,   761,   757,   762,   807,    57,
-      71,   226,   622,    75,    76,    78,    82,    82,    86,    88,
-     688,   690,   417,   546,   691,   692,   469,   436,   655,   379,
-     703,   568,   733,   727,   524,   729,   443,   104,   110,   249,
-     698,     0,   392,   116,   250,     0,   737,   104,   147,    22,
-     251,     0,    57,     0,     0,     0,     0,   384,     0,   252,
-       0,     0,     0,     0,     0,   163,   754,     0,   755,   756,
-     204,   204,     0,     0,     0,   253,   758,     0,     0,     0,
-       0,     0,     0,    57,     0,     0,     0,     0,    82,     0,
-       0,    82,   263,     0,   267,     0,   278,   766,   269,     0,
-     255,   512,   270,     0,   271,   773,     0,     0,     0,     0,
-       0,   258,   776,   204,   284,   779,   259,     0,   782,     0,
-       0,   785,   293,     0,   788,   301,     0,   791,     0,     0,
-     794,     0,   104,   797,     0,     0,   800,     0,     0,   803,
-       0,     0,   806,     0,     0,   808,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   249,     0,   333,   334,     0,
-     250,   278,   278,   204,     0,    22,   251,     0,     0,   104,
-       0,   349,     0,     0,     0,   252,   640,     0,     0,     0,
-       0,     0,     0,   183,   184,   185,   186,   187,   188,   189,
-     190,   253,   191,    22,   192,   193,    25,   194,   195,     0,
-       0,   641,     0,     0,   204,   204,   284,   355,     0,   204,
-       0,     0,     0,   204,   393,     0,   255,     0,   270,     0,
-     271,     0,     0,   249,     0,     0,     0,   258,   250,     0,
-     534,     0,   259,    22,   251,    57,   380,     0,     0,     0,
-       0,     0,   196,   252,   197,     0,   198,     0,   199,     0,
-       0,     0,     0,     0,   278,     0,   278,     0,     0,   253,
-     383,    78,   278,   278,   396,   399,   400,     0,     0,     0,
-       0,   278,   414,     0,    82,     0,   418,   278,   420,   421,
-     278,     0,   254,     0,   255,     0,   256,     0,   257,     0,
-       0,     0,     0,     0,   110,   258,     0,     0,     0,   293,
-     259,     0,     0,   464,   465,     0,   301,     0,     7,     8,
-       9,    10,    11,     0,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,   204,     0,     0,     0,   104,     0,     0,     0,     0,
-       0,     0,     0,     0,   263,    29,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    30,    31,   492,    32,     0,
-      33,     0,     0,     0,     0,     0,     0,     0,     0,    34,
-      35,    36,     0,    37,     0,    38,     0,    39,     0,    40,
-       0,     0,     0,     0,     0,     0,     0,    57,     0,     0,
-       0,    41,     0,     0,    42,   278,     0,     0,   278,     0,
-     278,   278,     0,     0,     0,     0,     0,     0,   262,     0,
+      64,    72,   158,   143,   359,   360,   361,   362,    81,    81,
+     103,   112,   152,   115,    53,   353,   205,   165,   635,   273,
+     351,   352,   646,   200,   200,   300,   542,   164,   340,   111,
+     704,   636,   565,   742,   706,   417,   142,   632,   525,   148,
+      22,    22,    22,   285,   490,    74,    89,    90,    91,    92,
+      93,    94,    95,  -353,   207,   208,   286,    53,   166,    96,
+     158,   426,   655,   158,    22,    97,   200,   628,   330,    22,
+     629,    22,   656,    22,    98,   209,   627,    22,   526,   114,
+     247,   638,   348,   247,  -366,  -366,    81,   491,    53,   164,
+    -353,   165,   290,  -353,   444,   564,   599,   697,   688,   565,
+      99,   426,    22,   512,   637,   103,   637,   418,   413,   633,
+     331,   100,   101,   554,   769,   297,   200,  -353,   479,   413,
+     381,   342,   382,   102,   657,   426,   413,   683,    89,    90,
+      91,    92,    93,    94,    95,    22,   203,   203,   164,   503,
+     770,    96,   346,   228,   413,   413,    22,    97,   413,    22,
+     508,    79,   424,   526,    22,   345,    98,   200,   200,   249,
+     347,   413,   200,    22,   250,   645,   200,   493,   363,    22,
+     251,   663,   413,   325,    22,   646,   160,   322,   635,   252,
+     635,   504,    99,   515,    84,   388,   388,   594,   372,   373,
+     374,   161,   640,   100,   101,   253,   694,   206,   105,   249,
+     421,   117,   106,   425,   250,   102,   300,   437,   519,    22,
+     251,   520,   105,   664,    22,   153,   106,    22,   269,   252,
+     255,    22,   270,   378,   271,   207,   208,   246,   413,   341,
+     672,   258,   249,   695,   248,   253,   259,   250,   158,   684,
+      53,   413,    22,   251,   635,   439,   209,   413,   677,   767,
+     385,   582,   252,   159,   583,   413,   465,   403,   269,    22,
+     255,   413,   270,    79,   271,   498,   247,   421,   253,   499,
+      79,   258,   725,   447,    28,   357,   259,    22,   413,   357,
+     353,   210,   154,   436,   200,   351,   352,    28,   765,    29,
+     755,   269,   386,   255,   413,   270,   297,   271,    22,   764,
+      22,   413,    29,   155,   258,   249,   225,   413,   480,   259,
+     250,   162,   -73,   776,    28,    22,   251,   156,   511,   157,
+     473,   513,   478,   511,   388,   252,   481,   482,   483,    29,
+     156,    22,   157,   321,   681,   630,    22,    22,   631,   322,
+      22,   253,   489,   413,   784,    22,   492,   152,   495,   791,
+     794,   273,   577,   797,   505,   228,   506,   156,   800,   157,
+      22,    22,    22,    22,   269,   510,   255,    22,   270,   655,
+     271,    22,    22,   803,   806,   809,   812,   258,    22,   656,
+     815,   768,   259,   789,   818,   821,     1,     2,     3,   413,
+     535,   413,    53,   200,   572,   158,   200,   476,   406,   227,
+     407,   264,   200,   760,   408,   766,   409,   410,   268,   411,
+     412,   788,   413,   323,   413,   421,    81,   589,   287,   324,
+     413,   650,   465,   465,   530,   651,   404,   143,   531,   288,
+     532,   146,   405,   430,   487,   567,    22,    57,    71,   431,
+     322,    75,    76,    78,    82,    82,    86,    88,   413,   607,
+     354,   610,   496,   710,   294,    22,   614,   568,   497,   711,
+     142,   302,    22,   200,   200,   104,   110,   580,   578,   678,
+     581,   116,   303,    22,    22,   104,   147,   222,   223,   224,
+      57,   305,   425,   641,   607,   643,   332,   326,   592,   327,
+     306,   593,   307,   163,   219,   220,   221,   308,   204,   204,
+     616,   617,   618,   249,   619,   620,   563,   309,   250,   566,
+     433,    57,   434,    22,   251,   203,    82,   149,   150,    82,
+     263,   752,   267,   252,   278,   211,   212,   213,   214,   215,
+     216,   217,   218,   200,   335,   375,   376,   377,   500,   253,
+     501,   204,   284,   516,   200,   517,   521,   522,   523,   524,
+     293,   648,   649,   301,   310,    81,   661,    80,    83,   311,
+     104,   312,   269,   328,   255,   514,   270,   313,   271,    85,
+      87,   314,   782,   315,   317,   258,   600,   601,   318,   319,
+     259,   320,   668,   329,   669,   333,   334,   350,   427,   278,
+     278,   204,   671,   428,   674,   429,   432,   104,   435,   349,
+     364,   365,   366,   367,   368,   369,   370,   371,   440,   158,
+     441,   446,   488,   730,  -353,   468,   472,   734,  -254,   406,
+     486,   407,   426,   465,   465,   408,   209,   409,   410,   502,
+     411,   412,   204,   204,   284,   355,   507,   204,   509,   518,
+     527,   204,   743,   528,   413,   543,   357,   552,   553,   717,
+     718,   719,   555,   584,   562,   721,   586,   476,   597,   585,
+     482,   483,   647,    57,   380,   587,   588,   596,   662,   413,
+     724,   665,   590,   598,   682,   666,   686,   604,   654,   670,
+     675,   676,   278,   685,   278,   526,   687,   689,   383,    78,
+     278,   278,   396,   401,   402,   690,   691,   692,   693,   278,
+     416,   696,    82,   698,   420,   278,   422,   423,   278,   712,
+     744,   714,   746,   722,   723,   727,   728,   733,   729,   732,
+     749,   745,   110,   754,   735,   747,   748,   293,   758,   774,
+     778,   466,   467,   779,   301,   824,   600,   601,   226,   379,
+     634,   705,   707,   771,   709,   772,   773,   419,   551,   708,
+     471,   438,   667,   775,   445,   750,   720,   529,   573,   204,
+     392,   715,   384,   104,   612,     0,     0,     0,     0,     0,
+       0,     0,   263,     0,   783,     0,     0,     0,     0,     0,
+       0,     0,   790,     0,     0,   494,     0,     0,     0,   793,
+       0,     0,   796,     0,     0,   799,     0,     0,   802,     0,
+       0,   805,     0,     0,   808,     0,     0,   811,     0,     0,
+     814,     0,     0,   817,     0,    57,   820,     0,     0,   823,
+       0,     0,   825,   278,     0,     0,   278,     0,   278,   278,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,   263,     0,   278,   278,   104,   278,   278,   278,   278,
-     278,     0,   267,     0,   544,   545,   278,     0,     0,     0,
+     278,   262,   267,     0,   549,   550,   278,     0,     0,     0,
        0,     0,   278,   278,   278,   278,     0,     0,   204,     0,
-     284,   204,     0,     0,     0,     0,   566,   204,     0,     0,
+     284,   204,     0,     0,     0,     0,   571,   204,     0,     0,
        0,   183,   184,   185,   186,   187,   188,   189,   190,     0,
-     191,    22,   192,   193,    25,   194,   195,   464,   464,   465,
-     574,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   356,     0,     0,     0,     0,     0,     0,     0,
-     278,     0,   278,     0,     0,     0,     0,     0,     0,     0,
-     590,     0,     0,     0,     0,     0,     0,   284,   204,   204,
-     196,     0,   197,   278,   198,     0,   199,     0,   278,     0,
-       0,   278,     0,   601,   278,   278,   278,     0,   606,   278,
-     278,     0,   249,   278,   612,   614,     0,   250,     0,     0,
-       0,     0,    22,   251,     0,     0,    82,     0,     0,     0,
-       0,   627,   252,     0,   278,   278,   278,   278,   267,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   253,     0,
-       0,     0,     0,     0,     0,   204,     0,     0,   389,   648,
-     394,   397,     0,     0,     0,     0,   204,   413,     0,     0,
-       0,   269,     0,   255,     0,   270,     0,   271,   661,     0,
-       0,     0,     0,     0,   258,     0,     0,   668,     0,   259,
+     191,    22,   192,   193,    25,   194,   195,   466,   466,   467,
+     579,     0,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   356,   239,   240,   241,   242,     0,     0,     0,
+     278,     0,   278,     0,     0,     0,   243,   244,     0,     0,
+     595,   245,     0,     0,     0,     0,     0,   284,   204,   204,
+     196,     0,   197,   278,   198,     0,   199,   137,   278,     0,
+       0,   278,     0,   606,   278,   278,   278,     0,   611,   138,
+     613,   278,     0,   278,     0,     0,   278,   624,   626,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    82,
+       0,     0,     0,     0,   639,     0,     0,   278,   278,   278,
+     278,   267,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   204,     0,
+       0,     0,   660,     0,     0,     0,     0,   249,     0,   204,
+       0,   389,   250,   394,   397,     0,     0,    22,   251,     0,
+     415,   673,     0,     0,     0,     0,   390,   252,     0,     0,
+     680,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   249,     0,   253,     0,     0,   250,     0,     0,     0,
+       0,    22,   251,   278,   278,   278,   278,   278,     0,   549,
+       0,   252,     0,   549,   549,     0,   269,     0,   255,   391,
+     270,     0,   271,   713,     0,   571,   716,   253,     0,   258,
+       0,     0,     0,     0,   259,     0,     0,     0,   466,   466,
+       0,     0,     0,   485,     0,     0,     0,     0,     0,   726,
+     393,     0,   255,     0,   270,     0,   271,     0,   278,   278,
+       0,     0,   278,   258,   278,     0,   539,     0,   259,     0,
+     278,   278,   278,   278,   278,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   639,     0,     0,   278,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   751,     0,
+       0,     0,   756,   278,     0,   278,     0,     0,   278,   278,
+       0,   278,   262,     0,   533,   534,     0,   536,   537,   538,
+     540,   541,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   777,   558,   559,   560,   561,     0,     0,   249,
+       0,     0,     0,   278,   250,   278,     0,     0,     0,    22,
+     251,     0,     0,   785,   278,   278,     0,   385,     0,   252,
+       0,   792,     0,     0,     0,     0,     0,     0,   795,     0,
+       0,   798,     0,     0,   801,   253,     0,   804,     0,     0,
+     807,     0,     0,   810,     0,     0,   813,     0,     0,   816,
+       0,   389,   819,     0,     0,   822,     0,     0,   484,   386,
+     255,     0,   256,     0,   257,     0,     0,     0,     0,     0,
+       0,   258,     0,     0,   602,     0,   259,     0,     0,   603,
+       0,     0,   605,     0,     0,   608,   609,     0,     0,     0,
+       0,     0,   615,     0,   621,     0,     0,   622,   623,   625,
+       5,     6,     0,     7,     8,     9,    10,    11,     0,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   278,   278,   278,   278,   278,     0,   544,
-       0,   249,     0,   544,   544,     0,   250,     0,     0,     0,
-       0,    22,   251,   696,     0,   566,   699,     0,     0,     0,
-       0,   252,     0,     0,     0,     0,     0,     0,   464,   464,
-     483,     0,     0,     0,     0,     0,     0,   253,     0,   709,
-       0,     0,     0,     0,     0,     0,     0,     0,   278,   278,
-       0,     0,   278,     0,   278,   278,   278,   278,   278,   278,
-     336,     0,   255,     0,   270,     0,   271,     0,     0,   627,
-       0,     0,   278,   258,     0,     0,     0,     0,   259,     0,
-       0,     0,     0,   734,     0,     0,     0,   739,   278,     0,
-     278,     0,     0,   278,   278,     0,   278,   262,     0,   528,
-     529,     0,   531,   532,   533,   535,   536,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   760,   553,   554,
-     555,   556,     0,     0,   249,     0,     0,     0,   278,   250,
-     278,     0,     0,     0,    22,   251,     0,     0,   768,   278,
-     278,     0,     0,     0,   252,     0,   775,     0,     0,     0,
-       0,     0,     0,   778,     0,     0,   781,     0,     0,   784,
-     253,     0,   787,     0,     0,   790,     0,     0,   793,     0,
-       0,   796,     0,     0,   799,     0,   389,   802,     0,     0,
-     805,     0,     0,   393,     0,   255,     0,   270,     0,   271,
-       0,     0,     0,     0,     0,     0,   258,     0,     0,   597,
-       0,   259,     0,     0,   598,     0,     0,   600,     0,     0,
-     603,   604,     0,     0,     0,   608,   609,     0,     0,   610,
-     611,   613,     0,     0,     0,     0,     0,     0,     5,     6,
-       0,     7,     8,     9,    10,    11,     0,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,     0,     0,     0,     0,     0,     0,
-     183,   184,   185,   186,   187,   188,   189,   190,    29,   191,
-      22,   192,   193,    25,   194,   195,     0,     0,    30,    31,
-       0,    32,     0,    33,     0,     0,     0,     0,     0,     0,
-       0,   358,    34,    35,    36,     0,    37,     0,    38,     0,
-      39,     0,    40,     0,     0,     0,     0,     0,     0,   682,
-     683,   684,   685,   686,    41,     0,     0,    42,     0,   196,
-       0,   197,     0,   198,     0,   199,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    58,     0,   714,     0,    29,     0,     0,
-     719,   720,   721,   722,   723,   724,     0,    30,    31,     0,
-      32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
-       0,    34,    35,    36,     0,    61,   316,    38,     0,    39,
-       0,    40,     0,     0,   740,     0,   742,     0,     0,   744,
-     745,     0,   746,    41,     0,   183,   184,   185,   186,   187,
+      29,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      30,    31,     0,    32,     0,    33,     0,     0,     0,     0,
+       0,     0,     0,     0,    34,    35,    36,     0,    37,     0,
+      38,     0,    39,     0,    40,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    41,     0,     0,    42,
+       0,     0,     0,     0,   699,   700,   701,   702,   703,     0,
+       0,     0,     0,     0,     0,     0,     7,     8,     9,    10,
+      11,     0,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
+     731,     0,     0,    30,    31,   736,    32,     0,    33,     0,
+       0,   737,   738,   739,   740,   741,     0,    34,    35,    36,
+       0,    37,     0,    38,     0,    39,     0,    40,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    41,
+       0,     0,    42,     0,   757,     0,   759,     0,   652,   761,
+     762,     0,   763,     0,     0,   183,   184,   185,   186,   187,
      188,   189,   190,     0,   191,    22,   192,   193,    25,   194,
-     195,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   763,     0,   764,     0,     0,     0,
-       0,     0,     0,     0,     0,   769,   770,    12,    13,    14,
+     195,     0,     0,   653,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   780,     0,   781,     0,     0,     0,
+       0,     0,     0,     0,     0,   786,   787,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,   196,     0,   197,     0,   198,     0,
      199,     0,   118,   119,   120,   121,   122,   123,   124,   125,
@@ -1441,82 +1461,82 @@ static const yytype_int16 yytable[] =
      133,    30,    31,     0,    32,     0,    33,     0,     0,   180,
      181,    60,     0,     0,   182,    34,    35,    36,     0,    61,
        0,    38,     0,    39,     0,    40,     0,     0,    62,    63,
-       0,     0,     0,     0,     0,     0,     0,    41,   446,   447,
-     448,   449,   450,   451,   452,   453,    20,   454,    22,   455,
-     456,    25,   457,   458,    28,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    41,   448,   449,
+     450,   451,   452,   453,   454,   455,    20,   456,    22,   457,
+     458,    25,   459,   460,    28,     0,     0,     0,     0,     0,
        0,     0,     0,   167,   168,   169,   170,   171,   172,    29,
      173,   174,   175,   128,   176,   177,   178,   179,   133,    30,
       31,     0,    32,     0,    33,     0,     0,   180,   181,    60,
-       0,     0,   182,    34,    35,    36,     0,   459,     0,   460,
-       0,   461,     0,   462,     0,     0,    62,    63,     0,     0,
+       0,     0,   182,    34,    35,    36,     0,   461,     0,   462,
+       0,   463,     0,   464,     0,     0,    62,    63,     0,     0,
        0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
       26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
        0,     0,     0,     0,     0,     0,    59,    30,    31,     0,
       32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
-       0,    34,    35,    36,   467,   295,     0,    38,     0,   296,
-     468,    40,     0,     0,    62,    63,     0,     0,     0,     0,
+       0,    34,    35,    36,   469,   295,     0,    38,     0,   296,
+     470,    40,     0,     0,    62,    63,     0,     0,     0,     0,
        0,     0,     0,    41,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,   343,    27,
       28,     0,     0,   344,     0,     0,     0,     0,     0,     0,
        0,    58,     0,     0,     0,    29,     0,     0,     0,     0,
-       0,     0,     0,     0,    59,    30,    31,     0,    32,     0,
-      33,     0,     0,     0,     0,    60,     0,     0,     0,    34,
-      35,    36,     0,    61,     0,    38,     0,    39,     0,    40,
-       0,     0,    62,    63,     0,     0,     0,     0,     0,     0,
+       0,     0,   249,     0,    59,    30,    31,   250,    32,     0,
+      33,     0,    22,   251,     0,    60,     0,     0,     0,    34,
+      35,    36,   252,    61,     0,    38,     0,    39,     0,    40,
+       0,     0,    62,    63,     0,     0,     0,     0,   253,     0,
        0,    41,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    58,
-       0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
-       0,     0,    59,    30,    31,     0,    32,     0,    33,     0,
-       0,     0,     0,    60,     0,     0,     0,    34,    35,    36,
-       0,    61,     0,    38,   475,    39,     0,    40,     0,     0,
-      62,    63,     0,     0,     0,     0,     0,     0,     0,    41,
+       0,   254,     0,   255,     0,   256,     0,   257,     0,    58,
+       0,     0,     0,    29,   258,     0,     0,     0,     0,   259,
+     249,     0,    59,    30,    31,   250,    32,     0,    33,     0,
+      22,   251,     0,    60,     0,     0,     0,    34,    35,    36,
+     252,    61,     0,    38,   477,    39,     0,    40,     0,     0,
+      62,    63,     0,     0,     0,     0,   253,     0,     0,    41,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    58,     0,     0,
-       0,    29,     0,     0,     0,     0,     0,     0,     0,     0,
-      59,    30,    31,     0,    32,     0,    33,     0,     0,     0,
-       0,    60,     0,     0,     0,    34,    35,    36,     0,    61,
-       0,    38,   586,    39,     0,    40,     0,     0,    62,    63,
-       0,     0,     0,     0,     0,     0,     0,    41,    12,    13,
+      22,    23,    24,    25,    26,    27,    28,     0,     0,   269,
+       0,   255,     0,   270,     0,   271,     0,    58,     0,     0,
+       0,    29,   258,     0,     0,     0,     0,   259,   249,     0,
+      59,    30,    31,   250,    32,     0,    33,     0,    22,   251,
+       0,    60,     0,     0,     0,    34,    35,    36,   252,    61,
+       0,    38,   591,    39,     0,    40,     0,     0,    62,    63,
+       0,     0,     0,     0,   253,     0,     0,    41,    12,    13,
       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    58,     0,     0,     0,    29,
-       0,     0,     0,     0,     0,     0,     0,     0,    59,    30,
-      31,     0,    32,     0,    33,     0,     0,     0,     0,    60,
-       0,     0,     0,    34,    35,    36,     0,    61,     0,    38,
+      24,    25,    26,    27,    28,     0,     0,   336,     0,   255,
+       0,   270,     0,   271,     0,    58,     0,     0,     0,    29,
+     258,     0,     0,     0,     0,   259,   249,     0,    59,    30,
+      31,   250,    32,     0,    33,     0,    22,   251,     0,    60,
+       0,     0,     0,    34,    35,    36,   252,    61,     0,    38,
        0,    39,     0,    40,     0,     0,    62,    63,     0,     0,
-       0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
+       0,     0,   253,     0,     0,    41,    12,    13,    14,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
-       0,     0,     0,     0,     0,     0,    59,    30,    31,     0,
+      26,    27,    28,     0,     0,   393,     0,   255,     0,   270,
+       0,   271,     0,    58,     0,     0,     0,    29,   258,     0,
+       0,     0,     0,   259,     0,     0,    59,    30,    31,     0,
       32,     0,    33,     0,     0,     0,     0,    60,     0,     0,
        0,    34,    35,    36,     0,   295,     0,    38,     0,   296,
        0,    40,     0,     0,    62,    63,     0,     0,     0,     0,
-       0,     0,     0,    41,   446,   447,   448,   449,   450,   451,
-     452,   453,    20,   454,    22,   455,   456,    25,   457,   458,
+       0,     0,     0,    41,   448,   449,   450,   451,   452,   453,
+     454,   455,    20,   456,    22,   457,   458,    25,   459,   460,
       28,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,    58,     0,     0,     0,    29,     0,     0,     0,     0,
        0,     0,     0,     0,    59,    30,    31,     0,    32,     0,
       33,     0,     0,     0,     0,    60,     0,     0,     0,    34,
-      35,    36,     0,   459,     0,   460,     0,   461,     0,   462,
+      35,    36,     0,   461,     0,   462,     0,   463,     0,   464,
        0,     0,    62,    63,     0,     0,     0,     0,     0,     0,
        0,    41,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    58,
        0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
-       0,     0,    59,    30,    31,     0,    32,     0,    33,     0,
+       0,     0,     0,    30,    31,     0,    32,     0,    33,     0,
        0,     0,     0,    60,     0,     0,     0,    34,    35,    36,
-       0,    61,     0,    38,     0,    39,     0,    40,     0,     0,
+       0,    61,   316,    38,     0,    39,     0,    40,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    41,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,    58,     0,     0,
        0,    29,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    30,    31,     0,    32,     0,    33,     0,     0,     0,
+      59,    30,    31,     0,    32,     0,    33,     0,     0,     0,
        0,    60,     0,     0,     0,    34,    35,    36,     0,    61,
        0,    38,     0,    39,     0,    40,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,    41,    12,    13,
@@ -1524,8 +1544,8 @@ static const yytype_int16 yytable[] =
       24,    25,    26,    27,    28,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,    58,     0,     0,     0,    29,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    30,
-      31,     0,    32,     0,    33,     0,     0,     0,     0,     0,
-       0,     0,     0,    34,    35,    36,     0,    61,   304,    38,
+      31,     0,    32,     0,    33,     0,     0,     0,     0,    60,
+       0,     0,     0,    34,    35,    36,     0,    61,     0,    38,
        0,    39,     0,    40,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,    41,    12,    13,    14,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
@@ -1533,12 +1553,12 @@ static const yytype_int16 yytable[] =
        0,     0,     0,    58,     0,     0,     0,    29,     0,     0,
        0,     0,     0,     0,     0,     0,     0,    30,    31,     0,
       32,     0,    33,     0,     0,     0,     0,     0,     0,     0,
-       0,    34,    35,    36,     0,    61,     0,    38,     0,    39,
+       0,    34,    35,    36,     0,    61,   304,    38,     0,    39,
        0,    40,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,    41,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    29,     0,     0,     0,     0,
+       0,    58,     0,     0,     0,    29,     0,     0,     0,     0,
        0,     0,     0,     0,     0,    30,    31,     0,    32,     0,
       33,     0,     0,     0,     0,     0,     0,     0,     0,    34,
       35,    36,     0,    61,     0,    38,     0,    39,     0,    40,
@@ -1547,197 +1567,193 @@ static const yytype_int16 yytable[] =
       20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,    29,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,     0,     0,     0,     0,   289,
-       0,     0,     0,     0,     0,     0,     0,    34,    35,     0,
+       0,     0,     0,    30,    31,     0,    32,     0,    33,     0,
+       0,     0,     0,     0,     0,     0,     0,    34,    35,    36,
        0,    61,     0,    38,     0,    39,     0,    40,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    41,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,     0,     0,     0,
-       0,   229,   230,   231,   232,   233,   234,   235,   236,   237,
-     238,    29,   239,   240,   241,   242,     0,     0,     0,     0,
-       0,     0,    31,     0,     0,   243,   244,     0,     0,     0,
-     245,     0,     0,     0,     0,    34,    35,     0,     0,    61,
-       0,    38,     0,    39,     0,    40,   137,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    41,   138
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    29,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    31,     0,     0,     0,     0,   289,     0,     0,
+       0,     0,     0,     0,     0,    34,    35,     0,     0,    61,
+       0,    38,     0,    39,     0,    40,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    41,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,     0,     0,     0,     0,     0,
+       0,   183,   184,   185,   186,   187,   188,   189,   190,    29,
+     191,    22,   192,   193,    25,   194,   195,     0,     0,     0,
+      31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   358,    34,    35,     0,     0,    61,     0,    38,
+       0,    39,     0,    40,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    41,     0,     0,     0,     0,
+     196,     0,   197,     0,   198,     0,   199,   183,   184,   185,
+     186,   187,   188,   189,   190,     0,   191,    22,   192,   193,
+      25,   194,   195,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   196,     0,   197,     0,
+     198,     0,   199
 };
 
 static const yytype_int16 yycheck[] =
 {
-       2,     3,    88,    54,    62,    63,    62,    63,   206,   207,
-     208,   209,     8,     9,    38,    32,    63,    34,    44,     1,
-      59,    29,   196,   197,   539,   198,   117,   414,   154,    31,
-      58,   620,   551,    33,     8,   624,    38,     8,     8,    41,
-      33,    41,     8,    43,    25,     8,    78,   105,    41,    15,
-      43,    80,    31,    25,    20,    69,   432,    86,    60,    25,
-      26,   112,    44,    16,   115,    64,    65,    46,    82,    35,
-      25,    16,    25,    26,    33,    33,    77,    25,    25,    80,
-      25,    26,    41,    41,    80,    51,    85,    83,    88,    43,
-      86,    25,   120,    75,   133,    88,   113,   155,    79,   155,
-       7,     8,     9,    10,    11,    12,    13,    81,    74,    80,
-      76,    81,    78,    20,    80,   117,   124,    80,    25,    26,
-     246,    87,   248,   499,    79,    78,    92,    74,    35,    88,
-      88,    79,   156,    79,    88,    69,   725,    38,   196,   197,
-      74,   169,    88,   201,    78,   201,    25,   205,    36,   205,
-      34,    39,    38,   161,    61,   157,    25,    20,    34,     0,
-     162,    41,    25,   550,    44,    72,    73,    41,   254,   255,
-      15,   210,   687,   692,   689,    20,    38,    84,    40,    80,
-      25,    26,    44,   269,    46,    47,   272,    49,    50,    34,
-      35,   219,   220,   221,    77,    74,    80,    81,    81,    78,
-      88,    77,    88,     8,    25,    74,    51,   298,    88,    43,
-      15,    33,    36,    41,    88,    20,    38,    38,    40,    41,
-      25,    26,    44,   225,    46,    47,    88,    49,    50,    74,
-      35,    76,    77,    78,    38,    80,    31,   295,   753,   290,
-      64,    65,    87,    25,    43,   227,    51,    92,   287,    38,
-     336,    46,    43,    74,    88,    25,    38,   259,    74,    25,
-      88,    85,    78,    78,    80,   323,    88,   323,    38,    74,
-     266,    76,    38,    78,    69,    80,    80,   294,    75,    74,
-      25,    76,    87,   285,    81,   459,   460,    92,   461,    88,
-      31,    80,    74,    38,    31,    25,   298,    88,    25,    39,
-      75,   387,    39,    25,   390,    46,   392,   393,    38,    46,
-      77,    38,    39,    88,    81,    79,    38,    25,    75,   327,
-     322,    25,   324,    60,    88,    25,   328,   329,   330,    28,
-      38,    88,   418,    74,    38,    76,    25,    74,    38,    76,
-      36,    69,   344,    39,    25,    25,   348,    25,   350,    38,
-      25,    25,    25,   379,   356,    25,   358,    38,    38,    38,
-      38,    79,    79,    38,    38,    38,    25,    25,    38,    25,
-      88,    88,   430,     8,   430,   433,    25,   433,    80,    38,
-      38,   439,    38,   439,    33,    80,    88,    80,     3,     4,
-       5,    38,   439,    88,   445,    88,   482,   379,   484,   407,
-      46,   459,   460,    20,    40,    41,    42,    53,    25,    80,
-       7,     8,     9,    10,    11,    12,    13,    88,   414,    46,
-      75,    75,    79,    20,    81,    75,    81,    81,    25,    26,
-     516,    81,   518,   435,    75,   521,   460,    79,    35,    81,
-      81,    32,   500,   501,   500,   501,    47,    48,    49,    50,
-      51,    52,    53,    54,    20,    43,    44,    45,   460,    25,
-     546,   547,   548,   549,    61,   467,    75,    34,   470,    93,
-      94,    38,    81,    20,    15,    72,    73,    32,    25,    20,
-      80,    81,    79,    20,    25,    26,   488,    84,    25,   491,
-      80,    81,    33,    63,    35,   211,   212,   213,   214,   215,
-     216,   217,   218,   222,   223,   224,     8,     9,   706,   567,
-      51,   567,    10,    11,    79,    79,    81,    81,    38,    75,
-     578,    75,   578,    75,    75,    75,    75,    75,    38,    75,
-      75,    75,    75,    74,    75,    76,    75,    78,    38,    80,
-      75,    75,    15,    75,    75,    75,    87,    20,    67,    33,
-      92,    92,    25,    26,   550,   572,    96,    43,    41,   757,
-      33,    38,    35,    15,    81,    80,    80,    37,    20,    82,
-      38,    38,    32,    25,    26,    38,    77,   579,    51,   581,
-      85,    46,    75,    35,   670,    34,    92,   589,   674,   591,
-      46,    88,   650,   651,   650,   651,    14,    34,   649,    51,
-      81,    74,    75,    76,    34,    78,    14,    80,   694,    75,
-      36,    38,    34,    77,    87,    68,    77,    75,    80,    92,
-      77,    80,    74,    75,    76,    80,    78,    38,    80,    80,
-      77,    79,    82,    34,    80,    87,    80,   639,   640,   641,
-      92,    80,    34,   645,    80,    34,    34,    38,   650,   651,
-      34,    58,    81,    38,    34,    38,    38,    38,   660,    33,
-      39,    39,    38,    79,    77,    38,    81,    38,    38,     1,
-       2,    75,   538,     5,     6,     7,     8,     9,    10,    11,
-     621,   625,   267,   418,   626,   628,   298,   286,   578,   227,
-     642,   440,   705,   695,   403,   697,   291,    29,    30,    15,
-     637,    -1,   255,    35,    20,    -1,   708,    39,    40,    25,
-      26,    -1,    44,    -1,    -1,    -1,    -1,   253,    -1,    35,
-      -1,    -1,    -1,    -1,    -1,    57,   728,    -1,   730,   731,
-      62,    63,    -1,    -1,    -1,    51,   738,    -1,    -1,    -1,
-      -1,    -1,    -1,    75,    -1,    -1,    -1,    -1,    80,    -1,
-      -1,    83,    84,    -1,    86,    -1,    88,   759,    74,    -1,
-      76,    77,    78,    -1,    80,   767,    -1,    -1,    -1,    -1,
-      -1,    87,   774,   105,   106,   777,    92,    -1,   780,    -1,
-      -1,   783,   114,    -1,   786,   117,    -1,   789,    -1,    -1,
-     792,    -1,   124,   795,    -1,    -1,   798,    -1,    -1,   801,
-      -1,    -1,   804,    -1,    -1,   807,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    15,    -1,   149,   150,    -1,
-      20,   153,   154,   155,    -1,    25,    26,    -1,    -1,   161,
-      -1,   163,    -1,    -1,    -1,    35,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    15,    16,    17,    18,    19,    20,    21,
-      22,    51,    24,    25,    26,    27,    28,    29,    30,    -1,
-      -1,    33,    -1,    -1,   196,   197,   198,   199,    -1,   201,
-      -1,    -1,    -1,   205,    74,    -1,    76,    -1,    78,    -1,
-      80,    -1,    -1,    15,    -1,    -1,    -1,    87,    20,    -1,
-      90,    -1,    92,    25,    26,   227,   228,    -1,    -1,    -1,
-      -1,    -1,    74,    35,    76,    -1,    78,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,   246,    -1,   248,    -1,    -1,    51,
-     252,   253,   254,   255,   256,   257,   258,    -1,    -1,    -1,
-      -1,   263,   264,    -1,   266,    -1,   268,   269,   270,   271,
-     272,    -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,
-      -1,    -1,    -1,    -1,   286,    87,    -1,    -1,    -1,   291,
-      92,    -1,    -1,   295,   296,    -1,   298,    -1,     9,    10,
-      11,    12,    13,    -1,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,   323,    -1,    -1,    -1,   327,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   336,    46,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    56,    57,   349,    59,    -1,
-      61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
-      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,    -1,    -1,
-      -1,    92,    -1,    -1,    95,   387,    -1,    -1,   390,    -1,
-     392,   393,    -1,    -1,    -1,    -1,    -1,    -1,    84,    -1,
-      -1,   403,    -1,   405,   406,   407,   408,   409,   410,   411,
-     412,    -1,   414,    -1,   416,   417,   418,    -1,    -1,    -1,
-      -1,    -1,   424,   425,   426,   427,    -1,    -1,   430,    -1,
-     432,   433,    -1,    -1,    -1,    -1,   438,   439,    -1,    -1,
+       2,     3,    54,    38,   206,   207,   208,   209,     8,     9,
+      29,    32,    44,    34,     1,   198,    63,    59,   544,    88,
+     196,   197,   556,    62,    63,   117,   416,    58,   154,    31,
+     632,     8,   434,     8,   636,     8,    38,     8,    34,    41,
+      25,    25,    25,    69,    34,     0,     7,     8,     9,    10,
+      11,    12,    13,    33,    64,    65,    82,    44,    60,    20,
+     112,    41,    16,   115,    25,    26,   105,    36,    38,    25,
+      39,    25,    26,    25,    35,    85,    38,    25,    74,    78,
+      80,    33,    38,    83,    80,    81,    86,    77,    75,   120,
+      33,   133,   113,    33,    79,    79,    79,    41,    41,   501,
+      61,    41,    25,    43,    81,   124,    81,    80,    88,    80,
+      80,    72,    73,    34,    41,   117,   155,    33,    79,    88,
+     246,   156,   248,    84,    78,    41,    88,    43,     7,     8,
+       9,    10,    11,    12,    13,    25,    62,    63,   169,    38,
+     742,    20,   161,    46,    88,    88,    25,    26,    88,    25,
+      53,    74,     8,    74,    25,   157,    35,   196,   197,    15,
+     162,    88,   201,    25,    20,   555,   205,    38,   210,    25,
+      26,    38,    88,    77,    25,   709,    31,    81,   704,    35,
+     706,    80,    61,    43,    74,   254,   255,    38,   219,   220,
+     221,    46,     8,    72,    73,    51,    43,    36,    74,    15,
+     269,    78,    78,   272,    20,    84,   298,    69,    41,    25,
+      26,    44,    74,    80,    25,    39,    78,    25,    74,    35,
+      76,    25,    78,   225,    80,    64,    65,    38,    88,   155,
+      38,    87,    15,    43,    38,    51,    92,    20,   290,    80,
+     227,    88,    25,    26,   770,   287,    85,    88,    75,    43,
+      33,    77,    35,    28,    80,    88,   295,   259,    74,    25,
+      76,    88,    78,    74,    80,    77,   266,   336,    51,    81,
+      74,    87,    38,   294,    31,   201,    92,    25,    88,   205,
+     463,    69,    39,   285,   323,   461,   462,    31,    75,    46,
+      38,    74,    75,    76,    88,    78,   298,    80,    25,    80,
+      25,    88,    46,    60,    87,    15,    38,    88,   327,    92,
+      20,    38,    39,    38,    31,    25,    26,    74,   387,    76,
+     322,   390,   324,   392,   393,    35,   328,   329,   330,    46,
+      74,    25,    76,    75,    79,    36,    25,    25,    39,    81,
+      25,    51,   344,    88,    38,    25,   348,   379,   350,    38,
+      38,   420,    69,    38,   356,    46,   358,    74,    38,    76,
+      25,    25,    25,    25,    74,    75,    76,    25,    78,    16,
+      80,    25,    25,    38,    38,    38,    38,    87,    25,    26,
+      38,    80,    92,    80,    38,    38,     3,     4,     5,    88,
+     409,    88,   379,   432,   441,   447,   435,   323,    38,     8,
+      40,    32,   441,    79,    44,    79,    46,    47,    32,    49,
+      50,    79,    88,    80,    88,   484,   416,   486,    38,    86,
+      88,    34,   461,   462,    74,    38,    75,   462,    78,    63,
+      80,    20,    81,    75,    75,   437,    25,     1,     2,    81,
+      81,     5,     6,     7,     8,     9,    10,    11,    88,   518,
+      20,   520,    75,    75,    38,    25,   525,    20,    81,    81,
+     462,    75,    25,   502,   503,    29,    30,   469,    20,    20,
+     472,    35,    75,    25,    25,    39,    40,    43,    44,    45,
+      44,    75,   551,   552,   553,   554,    92,    79,   490,    81,
+      75,   493,    75,    57,    40,    41,    42,    75,    62,    63,
+      15,    16,    17,    15,    19,    20,   432,    75,    20,   435,
+      79,    75,    81,    25,    26,   441,    80,    93,    94,    83,
+      84,   723,    86,    35,    88,    47,    48,    49,    50,    51,
+      52,    53,    54,   572,    96,   222,   223,   224,    79,    51,
+      81,   105,   106,    79,   583,    81,    80,    81,    80,    81,
+     114,    80,    81,   117,    75,   555,   577,     8,     9,    75,
+     124,    75,    74,    38,    76,    77,    78,    75,    80,    10,
+      11,    75,   774,    75,    75,    87,   502,   503,    75,    75,
+      92,    75,   584,    38,   586,   149,   150,    67,    33,   153,
+     154,   155,   594,    43,   596,    41,    81,   161,    38,   163,
+     211,   212,   213,   214,   215,   216,   217,   218,    80,   661,
+      80,    37,    77,   682,    33,    82,    38,   686,    38,    38,
+      32,    40,    41,   662,   663,    44,    85,    46,    47,    38,
+      49,    50,   196,   197,   198,   199,    46,   201,    75,    34,
+      46,   205,   711,    92,    88,    14,   572,    81,    34,   651,
+     652,   653,    14,    36,    75,   657,    38,   583,    75,    77,
+     662,   663,    34,   227,   228,    80,    80,    68,    38,    88,
+     672,    79,    77,    77,    34,    82,    34,    80,    80,    77,
+      80,    80,   246,    80,   248,    74,    80,    75,   252,   253,
+     254,   255,   256,   257,   258,    75,    75,    75,    75,   263,
+     264,    34,   266,    34,   268,   269,   270,   271,   272,    38,
+     712,    58,   714,    34,    81,    38,    34,    39,    38,    38,
+      79,    38,   286,   725,    39,    38,    33,   291,    77,    81,
+      38,   295,   296,    38,   298,    38,   662,   663,    75,   227,
+     543,   633,   637,   745,   640,   747,   748,   267,   420,   638,
+     298,   286,   583,   755,   291,   722,   654,   405,   442,   323,
+     255,   649,   253,   327,   524,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   336,    -1,   776,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   784,    -1,    -1,   349,    -1,    -1,    -1,   791,
+      -1,    -1,   794,    -1,    -1,   797,    -1,    -1,   800,    -1,
+      -1,   803,    -1,    -1,   806,    -1,    -1,   809,    -1,    -1,
+     812,    -1,    -1,   815,    -1,   379,   818,    -1,    -1,   821,
+      -1,    -1,   824,   387,    -1,    -1,   390,    -1,   392,   393,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   405,    -1,   407,   408,   409,   410,   411,   412,   413,
+     414,    84,   416,    -1,   418,   419,   420,    -1,    -1,    -1,
+      -1,    -1,   426,   427,   428,   429,    -1,    -1,   432,    -1,
+     434,   435,    -1,    -1,    -1,    -1,   440,   441,    -1,    -1,
       -1,    15,    16,    17,    18,    19,    20,    21,    22,    -1,
-      24,    25,    26,    27,    28,    29,    30,   459,   460,   461,
-     462,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     482,    -1,   484,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     492,    -1,    -1,    -1,    -1,    -1,    -1,   499,   500,   501,
-      74,    -1,    76,   505,    78,    -1,    80,    -1,   510,    -1,
-      -1,   513,    -1,   515,   516,   517,   518,    -1,   520,   521,
-     522,    -1,    15,   525,   526,   527,    -1,    20,    -1,    -1,
-      -1,    -1,    25,    26,    -1,    -1,   538,    -1,    -1,    -1,
-      -1,   543,    35,    -1,   546,   547,   548,   549,   550,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,
-      -1,    -1,    -1,    -1,    -1,   567,    -1,    -1,   254,   571,
-     256,   257,    -1,    -1,    -1,    -1,   578,   263,    -1,    -1,
-      -1,    74,    -1,    76,    -1,    78,    -1,    80,   590,    -1,
-      -1,    -1,    -1,    -1,    87,    -1,    -1,   599,    -1,    92,
+      24,    25,    26,    27,    28,    29,    30,   461,   462,   463,
+     464,    -1,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    46,    51,    52,    53,    54,    -1,    -1,    -1,
+     484,    -1,   486,    -1,    -1,    -1,    64,    65,    -1,    -1,
+     494,    69,    -1,    -1,    -1,    -1,    -1,   501,   502,   503,
+      74,    -1,    76,   507,    78,    -1,    80,    85,   512,    -1,
+      -1,   515,    -1,   517,   518,   519,   520,    -1,   522,    97,
+     524,   525,    -1,   527,    -1,    -1,   530,   531,   532,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   543,
+      -1,    -1,    -1,    -1,   548,    -1,    -1,   551,   552,   553,
+     554,   555,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   572,    -1,
+      -1,    -1,   576,    -1,    -1,    -1,    -1,    15,    -1,   583,
+      -1,   254,    20,   256,   257,    -1,    -1,    25,    26,    -1,
+     263,   595,    -1,    -1,    -1,    -1,    34,    35,    -1,    -1,
+     604,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    15,    -1,    51,    -1,    -1,    20,    -1,    -1,    -1,
+      -1,    25,    26,   627,   628,   629,   630,   631,    -1,   633,
+      -1,    35,    -1,   637,   638,    -1,    74,    -1,    76,    77,
+      78,    -1,    80,   647,    -1,   649,   650,    51,    -1,    87,
+      -1,    -1,    -1,    -1,    92,    -1,    -1,    -1,   662,   663,
+      -1,    -1,    -1,   336,    -1,    -1,    -1,    -1,    -1,   673,
+      74,    -1,    76,    -1,    78,    -1,    80,    -1,   682,   683,
+      -1,    -1,   686,    87,   688,    -1,    90,    -1,    92,    -1,
+     694,   695,   696,   697,   698,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   708,    -1,    -1,   711,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   722,    -1,
+      -1,    -1,   726,   727,    -1,   729,    -1,    -1,   732,   733,
+      -1,   735,   405,    -1,   407,   408,    -1,   410,   411,   412,
+     413,   414,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   756,   426,   427,   428,   429,    -1,    -1,    15,
+      -1,    -1,    -1,   767,    20,   769,    -1,    -1,    -1,    25,
+      26,    -1,    -1,   777,   778,   779,    -1,    33,    -1,    35,
+      -1,   785,    -1,    -1,    -1,    -1,    -1,    -1,   792,    -1,
+      -1,   795,    -1,    -1,   798,    51,    -1,   801,    -1,    -1,
+     804,    -1,    -1,   807,    -1,    -1,   810,    -1,    -1,   813,
+      -1,   484,   816,    -1,    -1,   819,    -1,    -1,    74,    75,
+      76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,
+      -1,    87,    -1,    -1,   507,    -1,    92,    -1,    -1,   512,
+      -1,    -1,   515,    -1,    -1,   518,   519,    -1,    -1,    -1,
+      -1,    -1,   525,    -1,   527,    -1,    -1,   530,   531,   532,
+       6,     7,    -1,     9,    10,    11,    12,    13,    -1,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   615,   616,   617,   618,   619,    -1,   621,
-      -1,    15,    -1,   625,   626,    -1,    20,    -1,    -1,    -1,
-      -1,    25,    26,   635,    -1,   637,   638,    -1,    -1,    -1,
-      -1,    35,    -1,    -1,    -1,    -1,    -1,    -1,   650,   651,
-     336,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,   661,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   670,   671,
-      -1,    -1,   674,    -1,   676,   677,   678,   679,   680,   681,
-      74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,   691,
-      -1,    -1,   694,    87,    -1,    -1,    -1,    -1,    92,    -1,
-      -1,    -1,    -1,   705,    -1,    -1,    -1,   709,   710,    -1,
-     712,    -1,    -1,   715,   716,    -1,   718,   403,    -1,   405,
-     406,    -1,   408,   409,   410,   411,   412,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   739,   424,   425,
-     426,   427,    -1,    -1,    15,    -1,    -1,    -1,   750,    20,
-     752,    -1,    -1,    -1,    25,    26,    -1,    -1,   760,   761,
-     762,    -1,    -1,    -1,    35,    -1,   768,    -1,    -1,    -1,
-      -1,    -1,    -1,   775,    -1,    -1,   778,    -1,    -1,   781,
-      51,    -1,   784,    -1,    -1,   787,    -1,    -1,   790,    -1,
-      -1,   793,    -1,    -1,   796,    -1,   482,   799,    -1,    -1,
-     802,    -1,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,   505,
-      -1,    92,    -1,    -1,   510,    -1,    -1,   513,    -1,    -1,
-     516,   517,    -1,    -1,    -1,   521,   522,    -1,    -1,   525,
-     526,   527,    -1,    -1,    -1,    -1,    -1,    -1,     6,     7,
-      -1,     9,    10,    11,    12,    13,    -1,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    46,    24,
-      25,    26,    27,    28,    29,    30,    -1,    -1,    56,    57,
-      -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    46,    70,    71,    72,    -1,    74,    -1,    76,    -1,
-      78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,   615,
-     616,   617,   618,   619,    92,    -1,    -1,    95,    -1,    74,
-      -1,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    42,    -1,   671,    -1,    46,    -1,    -1,
-     676,   677,   678,   679,   680,   681,    -1,    56,    57,    -1,
-      59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,
-      -1,    70,    71,    72,    -1,    74,    75,    76,    -1,    78,
-      -1,    80,    -1,    -1,   710,    -1,   712,    -1,    -1,   715,
-     716,    -1,   718,    92,    -1,    15,    16,    17,    18,    19,
+      46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,
+      76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    92,    -1,    -1,    95,
+      -1,    -1,    -1,    -1,   627,   628,   629,   630,   631,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     9,    10,    11,    12,
+      13,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
+     683,    -1,    -1,    56,    57,   688,    59,    -1,    61,    -1,
+      -1,   694,   695,   696,   697,   698,    -1,    70,    71,    72,
+      -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      -1,    -1,    95,    -1,   727,    -1,   729,    -1,     8,   732,
+     733,    -1,   735,    -1,    -1,    15,    16,    17,    18,    19,
       20,    21,    22,    -1,    24,    25,    26,    27,    28,    29,
-      30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   750,    -1,   752,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   761,   762,    15,    16,    17,
+      30,    -1,    -1,    33,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   767,    -1,   769,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   778,   779,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    74,    -1,    76,    -1,    78,    -1,
       80,    -1,    40,    41,    42,    43,    44,    45,    46,    47,
@@ -1773,38 +1789,38 @@ static const yytype_int16 yycheck[] =
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    55,    56,    57,    -1,    59,    -1,
-      61,    -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    70,
-      71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
-      -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    15,    -1,    55,    56,    57,    20,    59,    -1,
+      61,    -1,    25,    26,    -1,    66,    -1,    -1,    -1,    70,
+      71,    72,    35,    74,    -1,    76,    -1,    78,    -1,    80,
+      -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    51,    -1,
       -1,    92,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-      -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,
-      -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,
-      -1,    74,    -1,    76,    77,    78,    -1,    80,    -1,    -1,
-      83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    42,
+      -1,    -1,    -1,    46,    87,    -1,    -1,    -1,    -1,    92,
+      15,    -1,    55,    56,    57,    20,    59,    -1,    61,    -1,
+      25,    26,    -1,    66,    -1,    -1,    -1,    70,    71,    72,
+      35,    74,    -1,    76,    77,    78,    -1,    80,    -1,    -1,
+      83,    84,    -1,    -1,    -1,    -1,    51,    -1,    -1,    92,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,
-      -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,
-      -1,    66,    -1,    -1,    -1,    70,    71,    72,    -1,    74,
+      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    -1,    42,    -1,    -1,
+      -1,    46,    87,    -1,    -1,    -1,    -1,    92,    15,    -1,
+      55,    56,    57,    20,    59,    -1,    61,    -1,    25,    26,
+      -1,    66,    -1,    -1,    -1,    70,    71,    72,    35,    74,
       -1,    76,    77,    78,    -1,    80,    -1,    -1,    83,    84,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
+      -1,    -1,    -1,    -1,    51,    -1,    -1,    92,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    46,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    56,
-      57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    66,
-      -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,    76,
+      27,    28,    29,    30,    31,    -1,    -1,    74,    -1,    76,
+      -1,    78,    -1,    80,    -1,    42,    -1,    -1,    -1,    46,
+      87,    -1,    -1,    -1,    -1,    92,    15,    -1,    55,    56,
+      57,    20,    59,    -1,    61,    -1,    25,    26,    -1,    66,
+      -1,    -1,    -1,    70,    71,    72,    35,    74,    -1,    76,
       -1,    78,    -1,    80,    -1,    -1,    83,    84,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,
+      -1,    -1,    51,    -1,    -1,    92,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    55,    56,    57,    -1,
+      29,    30,    31,    -1,    -1,    74,    -1,    76,    -1,    78,
+      -1,    80,    -1,    42,    -1,    -1,    -1,    46,    87,    -1,
+      -1,    -1,    -1,    92,    -1,    -1,    55,    56,    57,    -1,
       59,    -1,    61,    -1,    -1,    -1,    -1,    66,    -1,    -1,
       -1,    70,    71,    72,    -1,    74,    -1,    76,    -1,    78,
       -1,    80,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,
@@ -1820,15 +1836,15 @@ static const yytype_int16 yycheck[] =
       23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
       -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    55,    56,    57,    -1,    59,    -1,    61,    -1,
+      -1,    -1,    -1,    56,    57,    -1,    59,    -1,    61,    -1,
       -1,    -1,    -1,    66,    -1,    -1,    -1,    70,    71,    72,
-      -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
+      -1,    74,    75,    76,    -1,    78,    -1,    80,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,
       -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,
+      55,    56,    57,    -1,    59,    -1,    61,    -1,    -1,    -1,
       -1,    66,    -1,    -1,    -1,    70,    71,    72,    -1,    74,
       -1,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
@@ -1836,8 +1852,8 @@ static const yytype_int16 yycheck[] =
       27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    46,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,
-      57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    70,    71,    72,    -1,    74,    75,    76,
+      57,    -1,    59,    -1,    61,    -1,    -1,    -1,    -1,    66,
+      -1,    -1,    -1,    70,    71,    72,    -1,    74,    -1,    76,
       -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    92,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
@@ -1845,12 +1861,12 @@ static const yytype_int16 yycheck[] =
       -1,    -1,    -1,    42,    -1,    -1,    -1,    46,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,    -1,
       59,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    70,    71,    72,    -1,    74,    -1,    76,    -1,    78,
+      -1,    70,    71,    72,    -1,    74,    75,    76,    -1,    78,
       -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    92,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
+      -1,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    56,    57,    -1,    59,    -1,
       61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
       71,    72,    -1,    74,    -1,    76,    -1,    78,    -1,    80,
@@ -1859,18 +1875,34 @@ static const yytype_int16 yycheck[] =
       23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    62,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    -1,
+      -1,    -1,    -1,    56,    57,    -1,    59,    -1,    61,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
       -1,    74,    -1,    76,    -1,    78,    -1,    80,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
-      -1,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    46,    51,    52,    53,    54,    -1,    -1,    -1,    -1,
-      -1,    -1,    57,    -1,    -1,    64,    65,    -1,    -1,    -1,
-      69,    -1,    -1,    -1,    -1,    70,    71,    -1,    -1,    74,
-      -1,    76,    -1,    78,    -1,    80,    85,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    97
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    57,    -1,    -1,    -1,    -1,    62,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    70,    71,    -1,    -1,    74,
+      -1,    76,    -1,    78,    -1,    80,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
+      -1,    15,    16,    17,    18,    19,    20,    21,    22,    46,
+      24,    25,    26,    27,    28,    29,    30,    -1,    -1,    -1,
+      57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    46,    70,    71,    -1,    -1,    74,    -1,    76,
+      -1,    78,    -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    92,    -1,    -1,    -1,    -1,
+      74,    -1,    76,    -1,    78,    -1,    80,    15,    16,    17,
+      18,    19,    20,    21,    22,    -1,    24,    25,    26,    27,
+      28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    74,    -1,    76,    -1,
+      78,    -1,    80
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1882,82 +1914,84 @@ static const yytype_uint8 yystos[] =
       23,    24,    25,    26,    27,    28,    29,    30,    31,    46,
       56,    57,    59,    61,    70,    71,    72,    74,    76,    78,
       80,    92,    95,   100,   101,   102,   103,   104,   106,   107,
-     109,   114,   119,   129,   137,   145,   159,   179,    42,    55,
+     109,   114,   119,   129,   137,   145,   159,   181,    42,    55,
       66,    74,    83,    84,   123,   124,   125,   126,   127,   128,
-     129,   179,   123,   179,     0,   179,   179,   172,   179,    74,
-     118,   119,   179,   118,    74,   164,   179,   164,   179,     7,
+     129,   181,   123,   181,     0,   181,   181,   172,   181,    74,
+     118,   119,   181,   118,    74,   164,   181,   164,   181,     7,
        8,     9,    10,    11,    12,    13,    20,    26,    35,    61,
-      72,    73,    84,   158,   179,    74,    78,   130,   131,   151,
-     179,   123,   137,   146,    78,   137,   179,    78,    40,    41,
+      72,    73,    84,   158,   181,    74,    78,   130,   131,   151,
+     181,   123,   137,   146,    78,   137,   181,    78,    40,    41,
       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
       52,    53,    54,    55,    64,    65,    69,    85,    97,   120,
-     123,   162,   123,   162,   157,   158,    20,   179,   123,    93,
+     123,   162,   123,   162,   157,   158,    20,   181,   123,    93,
       94,   105,   102,    39,    39,    60,    74,    76,   159,    28,
-      31,    46,    38,   179,   127,   125,   123,    40,    41,    42,
+      31,    46,    38,   181,   127,   125,   123,    40,    41,    42,
       43,    44,    45,    47,    48,    49,    51,    52,    53,    54,
       64,    65,    69,    15,    16,    17,    18,    19,    20,    21,
       22,    24,    26,    27,    29,    30,    74,    76,    78,    80,
-     145,   149,   150,   152,   179,   149,    36,    64,    65,    85,
+     145,   149,   150,   152,   181,   149,    36,    64,    65,    85,
       69,    47,    48,    49,    50,    51,    52,    53,    54,    40,
       41,    42,    43,    44,    45,    38,   100,     8,    46,    40,
       41,    42,    43,    44,    45,    46,    47,    48,    49,    51,
       52,    53,    54,    64,    65,    69,    38,   119,    38,    15,
       20,    26,    35,    51,    74,    76,    78,    80,    87,    92,
-     165,   166,   170,   179,    32,   117,   118,   179,    32,    74,
-      78,    80,   122,   169,   170,   173,   175,   176,   179,   152,
-     153,   154,   155,   156,   179,    69,    82,    38,    63,    62,
-     137,   138,   139,   179,    38,    74,    78,   123,   132,   133,
-     151,   179,    75,    75,    75,    75,    75,    75,    75,    75,
+     165,   166,   170,   181,    32,   117,   118,   181,    32,    74,
+      78,    80,   122,   169,   170,   173,   175,   176,   181,   152,
+     153,   154,   155,   156,   181,    69,    82,    38,    63,    62,
+     137,   138,   139,   181,    38,    74,    78,   123,   132,   133,
+     151,   181,    75,    75,    75,    75,    75,    75,    75,    75,
       75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
       75,    75,    81,    80,    86,    77,    79,    81,    38,    38,
-      38,    80,    92,   179,   179,    96,    74,   163,   164,   169,
-     163,   152,   162,    29,    34,   123,   158,   123,    38,   179,
-      67,   153,   153,   155,    20,   179,    46,   152,    46,   124,
+      38,    80,    92,   181,   181,    96,    74,   163,   164,   169,
+     163,   152,   162,    29,    34,   123,   158,   123,    38,   181,
+      67,   153,   153,   155,    20,   181,    46,   152,    46,   124,
      124,   124,   124,   125,   126,   126,   126,   126,   126,   126,
      126,   126,   127,   127,   127,   128,   128,   128,   123,   101,
-     179,   163,   163,   179,   172,    33,    75,   168,   169,   170,
-      34,    77,   168,    74,   170,   177,   179,   170,   178,   179,
-     179,   123,    75,    81,    38,    40,    44,    46,    47,    49,
-      50,    88,   167,   170,   179,     8,    80,   120,   179,   169,
-     179,   179,     8,   169,    41,    33,    43,    41,    75,    81,
-      81,    79,    81,    38,   123,    69,   131,   125,    80,    80,
-     147,   148,    79,   139,    37,   137,    15,    16,    17,    18,
-      19,    20,    21,    22,    24,    26,    27,    29,    30,    74,
-      76,    78,    80,   145,   179,   179,    82,    73,    79,   133,
-      38,   123,   135,   136,   152,    77,   123,    79,   158,   123,
-     123,   123,    74,   170,    32,    75,    77,   123,    34,    77,
-     123,    38,   179,   123,    75,    81,    77,    81,    79,    81,
-      38,    38,    80,   123,   123,    46,    53,    75,    75,   169,
-      43,   169,    77,    43,    79,    81,    34,    41,    44,    80,
-      81,    34,    46,    92,   166,    74,    78,    80,   170,   170,
-     158,   170,   170,   170,    90,   170,   170,   117,    14,   112,
-     113,   110,   111,   121,   179,   179,   122,    81,    34,    34,
-      14,   115,   116,   170,   170,   170,   170,    75,   152,    79,
-     156,   152,   123,    20,   160,   161,   179,   149,   148,   140,
-     141,   142,    69,    20,   179,   123,   123,    77,    80,    36,
-      77,    38,    80,    80,   169,    77,    77,   123,   123,    38,
-     179,    68,    75,    77,    79,   152,   152,   170,   170,    80,
-     170,   179,   169,   170,   170,   169,   179,   169,   170,   170,
-     170,   170,   179,   170,   179,    38,    36,    39,    36,    39,
-       8,    80,   107,   113,     8,    81,    33,   179,     8,   169,
-     174,   169,   108,   117,   116,    34,    80,    81,    34,    38,
-       8,    33,    80,    16,    26,    78,   143,   144,   179,   137,
-      38,    38,    80,    79,    82,   135,   123,   123,    77,   123,
-      38,   179,   123,    80,    80,    75,    20,   171,   179,    79,
-      34,    43,    80,    80,    34,    80,    41,    43,    43,    34,
-      41,    34,   170,   170,   170,   170,   170,   112,   110,   112,
-     111,   121,   115,    75,    81,    38,   179,    58,   161,   179,
-     123,   123,   123,   141,   123,    34,    81,   123,    38,   179,
-      38,    34,    38,   169,   170,    38,    39,   169,    39,   170,
-     170,   170,   170,   170,   170,     8,   169,   123,    38,   123,
-      38,    33,    79,   144,   179,   124,   134,   123,    38,   179,
-     170,    77,   170,    79,   170,   170,   170,    80,    75,    79,
-      43,    80,    41,   112,   123,   123,   123,    81,   123,    38,
-     179,    38,    38,   170,   170,   124,   123,    38,   179,   170,
-     170,    79,    80,   123,    38,   179,   123,    38,   179,   123,
-      38,   179,   123,    38,   179,   123,    38,   179,   123,    38,
-     179,   123,    38,   179,   123,    38,   179,   123,    38,   179,
-     123,    38,   179,   123,    38,   179,   123,    38,   123
+     181,   163,   163,   181,   172,    33,    75,   168,   169,   170,
+      34,    77,   168,    74,   170,   177,   181,   170,   178,   179,
+     180,   181,   181,   123,    75,    81,    38,    40,    44,    46,
+      47,    49,    50,    88,   167,   170,   181,     8,    80,   120,
+     181,   169,   181,   181,     8,   169,    41,    33,    43,    41,
+      75,    81,    81,    79,    81,    38,   123,    69,   131,   125,
+      80,    80,   147,   148,    79,   139,    37,   137,    15,    16,
+      17,    18,    19,    20,    21,    22,    24,    26,    27,    29,
+      30,    74,    76,    78,    80,   145,   181,   181,    82,    73,
+      79,   133,    38,   123,   135,   136,   152,    77,   123,    79,
+     158,   123,   123,   123,    74,   170,    32,    75,    77,   123,
+      34,    77,   123,    38,   181,   123,    75,    81,    77,    81,
+      79,    81,    38,    38,    80,   123,   123,    46,    53,    75,
+      75,   169,    43,   169,    77,    43,    79,    81,    34,    41,
+      44,    80,    81,    80,    81,    34,    74,    46,    92,   166,
+      74,    78,    80,   170,   170,   158,   170,   170,   170,    90,
+     170,   170,   117,    14,   112,   113,   110,   111,   121,   181,
+     181,   122,    81,    34,    34,    14,   115,   116,   170,   170,
+     170,   170,    75,   152,    79,   156,   152,   123,    20,   160,
+     161,   181,   149,   148,   140,   141,   142,    69,    20,   181,
+     123,   123,    77,    80,    36,    77,    38,    80,    80,   169,
+      77,    77,   123,   123,    38,   181,    68,    75,    77,    79,
+     152,   152,   170,   170,    80,   170,   181,   169,   170,   170,
+     169,   181,   180,   181,   169,   170,    15,    16,    17,    19,
+      20,   170,   170,   170,   181,   170,   181,    38,    36,    39,
+      36,    39,     8,    80,   107,   113,     8,    81,    33,   181,
+       8,   169,   174,   169,   108,   117,   116,    34,    80,    81,
+      34,    38,     8,    33,    80,    16,    26,    78,   143,   144,
+     181,   137,    38,    38,    80,    79,    82,   135,   123,   123,
+      77,   123,    38,   181,   123,    80,    80,    75,    20,   171,
+     181,    79,    34,    43,    80,    80,    34,    80,    41,    75,
+      75,    75,    75,    75,    43,    43,    34,    41,    34,   170,
+     170,   170,   170,   170,   112,   110,   112,   111,   121,   115,
+      75,    81,    38,   181,    58,   161,   181,   123,   123,   123,
+     141,   123,    34,    81,   123,    38,   181,    38,    34,    38,
+     169,   170,    38,    39,   169,    39,   170,   170,   170,   170,
+     170,   170,     8,   169,   123,    38,   123,    38,    33,    79,
+     144,   181,   124,   134,   123,    38,   181,   170,    77,   170,
+      79,   170,   170,   170,    80,    75,    79,    43,    80,    41,
+     112,   123,   123,   123,    81,   123,    38,   181,    38,    38,
+     170,   170,   124,   123,    38,   181,   170,   170,    79,    80,
+     123,    38,   181,   123,    38,   181,   123,    38,   181,   123,
+      38,   181,   123,    38,   181,   123,    38,   181,   123,    38,
+     181,   123,    38,   181,   123,    38,   181,   123,    38,   181,
+     123,    38,   181,   123,    38,   123
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
@@ -1997,9 +2031,10 @@ static const yytype_uint8 yyr1[] =
      166,   166,   166,   166,   166,   166,   166,   166,   166,   166,
      166,   166,   166,   167,   167,   168,   168,   169,   169,   169,
      170,   170,   170,   170,   170,   170,   170,   170,   170,   170,
-     170,   170,   170,   170,   170,   170,   170,   170,   171,   171,
-     172,   172,   173,   173,   174,   174,   175,   175,   176,   176,
-     177,   177,   178,   178,   178,   178,   179
+     170,   170,   170,   170,   170,   170,   170,   170,   170,   171,
+     171,   172,   172,   173,   173,   174,   174,   175,   175,   176,
+     176,   177,   177,   178,   178,   178,   178,   179,   179,   180,
+     180,   180,   180,   180,   181
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -2038,10 +2073,11 @@ static const yytype_int8 yyr2[] =
        1,     3,     2,     3,     3,     3,     7,     9,     7,     7,
        9,     7,     5,     5,     5,     5,     7,     7,     9,     9,
        7,     7,     5,     1,     2,     2,     1,     3,     1,     1,
-       1,     3,     2,     3,     7,     3,     3,     3,     3,     2,
-       1,     1,     4,     3,     3,     4,     1,     3,     1,     1,
-       1,     3,     1,     5,     1,     3,     1,     3,     3,     3,
-       5,     3,     5,     3,     3,     1,     1
+       1,     3,     2,     3,     7,     3,     3,     3,     3,     3,
+       2,     1,     1,     4,     3,     3,     4,     1,     3,     1,
+       1,     1,     3,     1,     5,     1,     3,     1,     3,     3,
+       3,     5,     3,     5,     3,     3,     1,     3,     1,     4,
+       4,     4,     4,     4,     1
 };
 
 
@@ -2875,793 +2911,793 @@ yyreduce:
   switch (yyn)
     {
   case 2: /* s: "domodule" module  */
-#line 488 "hexpr.y"
+#line 524 "hexpr.y"
                             { yyParsedModule = (yyvsp[0].module);                     }
-#line 2881 "hexpr.parse.C"
+#line 2917 "hexpr.parse.C"
     break;
 
   case 3: /* s: "dodefn" id "=" l0expr  */
-#line 489 "hexpr.y"
+#line 525 "hexpr.y"
                             { yyParsedVar    = *(yyvsp[-2].string); yyParsedExpr = (yyvsp[0].exp); }
-#line 2887 "hexpr.parse.C"
+#line 2923 "hexpr.parse.C"
     break;
 
   case 4: /* s: "dodefn" l0expr  */
-#line 490 "hexpr.y"
+#line 526 "hexpr.y"
                             { yyParsedVar    = "";  yyParsedExpr = (yyvsp[0].exp); }
-#line 2893 "hexpr.parse.C"
+#line 2929 "hexpr.parse.C"
     break;
 
   case 5: /* s: "doexpr" l0expr  */
-#line 491 "hexpr.y"
+#line 527 "hexpr.y"
                             { yyParsedExpr   = (yyvsp[0].exp);                     }
-#line 2899 "hexpr.parse.C"
+#line 2935 "hexpr.parse.C"
     break;
 
   case 6: /* module: "option" id module  */
-#line 494 "hexpr.y"
+#line 530 "hexpr.y"
                                  { (yyval.module) = (yyvsp[0].module); (yyval.module)->setOption(*(yyvsp[-1].string), m((yylsp[-2]))); }
-#line 2905 "hexpr.parse.C"
+#line 2941 "hexpr.parse.C"
     break;
 
   case 7: /* module: "module" id "where" defs  */
-#line 495 "hexpr.y"
+#line 531 "hexpr.y"
                                  { (yyval.module) = new Module(*(yyvsp[-2].string), *(yyvsp[0].mdefs)); }
-#line 2911 "hexpr.parse.C"
+#line 2947 "hexpr.parse.C"
     break;
 
   case 8: /* module: defs  */
-#line 496 "hexpr.y"
+#line 532 "hexpr.y"
                                  { (yyval.module) = new Module(freshName(), *(yyvsp[0].mdefs)); }
-#line 2917 "hexpr.parse.C"
+#line 2953 "hexpr.parse.C"
     break;
 
   case 9: /* defs: %empty  */
-#line 498 "hexpr.y"
+#line 534 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); }
-#line 2923 "hexpr.parse.C"
+#line 2959 "hexpr.parse.C"
     break;
 
   case 10: /* defs: def  */
-#line 499 "hexpr.y"
+#line 535 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2929 "hexpr.parse.C"
+#line 2965 "hexpr.parse.C"
     break;
 
   case 11: /* defs: defs def  */
-#line 500 "hexpr.y"
+#line 536 "hexpr.y"
                     { (yyval.mdefs) = (yyvsp[-1].mdefs);                            (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2935 "hexpr.parse.C"
+#line 2971 "hexpr.parse.C"
     break;
 
   case 12: /* def: importdef  */
-#line 502 "hexpr.y"
+#line 538 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2941 "hexpr.parse.C"
+#line 2977 "hexpr.parse.C"
     break;
 
   case 13: /* def: tydef  */
-#line 503 "hexpr.y"
+#line 539 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2947 "hexpr.parse.C"
+#line 2983 "hexpr.parse.C"
     break;
 
   case 14: /* def: vartybind  */
-#line 504 "hexpr.y"
+#line 540 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mvtydef); }
-#line 2953 "hexpr.parse.C"
+#line 2989 "hexpr.parse.C"
     break;
 
   case 15: /* def: classdef  */
-#line 505 "hexpr.y"
+#line 541 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2959 "hexpr.parse.C"
+#line 2995 "hexpr.parse.C"
     break;
 
   case 16: /* def: instdef  */
-#line 506 "hexpr.y"
+#line 542 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2965 "hexpr.parse.C"
+#line 3001 "hexpr.parse.C"
     break;
 
   case 17: /* def: pragmadef  */
-#line 507 "hexpr.y"
+#line 543 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2971 "hexpr.parse.C"
+#line 3007 "hexpr.parse.C"
     break;
 
   case 18: /* def: id "=" l0expr  */
-#line 509 "hexpr.y"
+#line 545 "hexpr.y"
                    { (yyval.mdef) = new MVarDef(list(*(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 2977 "hexpr.parse.C"
+#line 3013 "hexpr.parse.C"
     break;
 
   case 19: /* def: id id "=" l0expr  */
-#line 510 "hexpr.y"
+#line 546 "hexpr.y"
                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 2983 "hexpr.parse.C"
+#line 3019 "hexpr.parse.C"
     break;
 
   case 20: /* def: id id id "=" l0expr  */
-#line 511 "hexpr.y"
+#line 547 "hexpr.y"
                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 2989 "hexpr.parse.C"
+#line 3025 "hexpr.parse.C"
     break;
 
   case 21: /* def: id id id id "=" l0expr  */
-#line 512 "hexpr.y"
+#line 548 "hexpr.y"
                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 2995 "hexpr.parse.C"
+#line 3031 "hexpr.parse.C"
     break;
 
   case 22: /* def: id id id id id "=" l0expr  */
-#line 513 "hexpr.y"
+#line 549 "hexpr.y"
                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-6]), (yylsp[0]))); }
-#line 3001 "hexpr.parse.C"
+#line 3037 "hexpr.parse.C"
     break;
 
   case 23: /* def: id id id id id id "=" l0expr  */
-#line 514 "hexpr.y"
+#line 550 "hexpr.y"
                                   { (yyval.mdef) = new MVarDef(list(*(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 3007 "hexpr.parse.C"
+#line 3043 "hexpr.parse.C"
     break;
 
   case 24: /* def: id id id id id id id "=" l0expr  */
-#line 515 "hexpr.y"
+#line 551 "hexpr.y"
                                      { (yyval.mdef) = new MVarDef(list(*(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-8]), (yylsp[0]))); }
-#line 3013 "hexpr.parse.C"
+#line 3049 "hexpr.parse.C"
     break;
 
   case 25: /* def: id id id id id id id id "=" l0expr  */
-#line 516 "hexpr.y"
+#line 552 "hexpr.y"
                                         { (yyval.mdef) = new MVarDef(list(*(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-9]), (yylsp[0]))); }
-#line 3019 "hexpr.parse.C"
+#line 3055 "hexpr.parse.C"
     break;
 
   case 26: /* def: id id id id id id id id id "=" l0expr  */
-#line 517 "hexpr.y"
+#line 553 "hexpr.y"
                                            { (yyval.mdef) = new MVarDef(list(*(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-10]), (yylsp[0]))); }
-#line 3025 "hexpr.parse.C"
+#line 3061 "hexpr.parse.C"
     break;
 
   case 27: /* def: id id id id id id id id id id "=" l0expr  */
-#line 518 "hexpr.y"
+#line 554 "hexpr.y"
                                               { (yyval.mdef) = new MVarDef(list(*(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-11]), (yylsp[0]))); }
-#line 3031 "hexpr.parse.C"
+#line 3067 "hexpr.parse.C"
     break;
 
   case 28: /* def: id id id id id id id id id id id "=" l0expr  */
-#line 519 "hexpr.y"
+#line 555 "hexpr.y"
                                                  { (yyval.mdef) = new MVarDef(list(*(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-12]), (yylsp[0]))); }
-#line 3037 "hexpr.parse.C"
+#line 3073 "hexpr.parse.C"
     break;
 
   case 29: /* def: id id id id id id id id id id id id "=" l0expr  */
-#line 520 "hexpr.y"
+#line 556 "hexpr.y"
                                                     { (yyval.mdef) = new MVarDef(list(*(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-13]), (yylsp[0]))); }
-#line 3043 "hexpr.parse.C"
+#line 3079 "hexpr.parse.C"
     break;
 
   case 30: /* def: id id id id id id id id id id id id id "=" l0expr  */
-#line 521 "hexpr.y"
+#line 557 "hexpr.y"
                                                        { (yyval.mdef) = new MVarDef(list(*(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-14]), (yylsp[0]))); }
-#line 3049 "hexpr.parse.C"
+#line 3085 "hexpr.parse.C"
     break;
 
   case 31: /* def: id id id id id id id id id id id id id id "=" l0expr  */
-#line 522 "hexpr.y"
+#line 558 "hexpr.y"
                                                           { (yyval.mdef) = new MVarDef(list(*(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-15]), (yylsp[0]))); }
-#line 3055 "hexpr.parse.C"
+#line 3091 "hexpr.parse.C"
     break;
 
   case 32: /* def: id id id id id id id id id id id id id id id "=" l0expr  */
-#line 523 "hexpr.y"
+#line 559 "hexpr.y"
                                                              { (yyval.mdef) = new MVarDef(list(*(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-16]), (yylsp[0]))); }
-#line 3061 "hexpr.parse.C"
+#line 3097 "hexpr.parse.C"
     break;
 
   case 33: /* def: id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 524 "hexpr.y"
+#line 560 "hexpr.y"
                                                                 { (yyval.mdef) = new MVarDef(list(*(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-17]), (yylsp[0]))); }
-#line 3067 "hexpr.parse.C"
+#line 3103 "hexpr.parse.C"
     break;
 
   case 34: /* def: id id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 525 "hexpr.y"
+#line 561 "hexpr.y"
                                                                    { (yyval.mdef) = new MVarDef(list(*(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-18]), (yylsp[0]))); }
-#line 3073 "hexpr.parse.C"
+#line 3109 "hexpr.parse.C"
     break;
 
   case 35: /* def: id id id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 526 "hexpr.y"
+#line 562 "hexpr.y"
                                                                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-19]), (yylsp[0]))); }
-#line 3079 "hexpr.parse.C"
+#line 3115 "hexpr.parse.C"
     break;
 
   case 36: /* def: id id id id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 527 "hexpr.y"
+#line 563 "hexpr.y"
                                                                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-20]), (yylsp[0]))); }
-#line 3085 "hexpr.parse.C"
+#line 3121 "hexpr.parse.C"
     break;
 
   case 37: /* def: id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 528 "hexpr.y"
+#line 564 "hexpr.y"
                                                                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-21]), (yylsp[0]))); }
-#line 3091 "hexpr.parse.C"
+#line 3127 "hexpr.parse.C"
     break;
 
   case 38: /* def: id id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
-#line 529 "hexpr.y"
+#line 565 "hexpr.y"
                                                                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-22].string), *(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-22]), (yylsp[0]))); }
-#line 3097 "hexpr.parse.C"
+#line 3133 "hexpr.parse.C"
     break;
 
   case 39: /* def: l5expr  */
-#line 532 "hexpr.y"
+#line 568 "hexpr.y"
             { (yyval.mdef) = new MVarDef(list(freshName()), let(freshName(), ExprPtr((yyvsp[0].exp)), mktunit(m((yylsp[0]))), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3103 "hexpr.parse.C"
+#line 3139 "hexpr.parse.C"
     break;
 
   case 40: /* importdef: "import" cppid  */
-#line 535 "hexpr.y"
+#line 571 "hexpr.y"
                           { (yyval.mdef) = new MImport(yyModulePath, *(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3109 "hexpr.parse.C"
+#line 3145 "hexpr.parse.C"
     break;
 
   case 41: /* pragmadef: "{-#" pragmaty "#-}"  */
-#line 538 "hexpr.y"
+#line 574 "hexpr.y"
                                 { (yyval.mdef) = (yyvsp[-1].mdef); }
-#line 3115 "hexpr.parse.C"
+#line 3151 "hexpr.parse.C"
     break;
 
   case 42: /* pragmaty: "UNSAFE" id  */
-#line 539 "hexpr.y"
+#line 575 "hexpr.y"
                       { (yyval.mdef) = new MUnsafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3121 "hexpr.parse.C"
+#line 3157 "hexpr.parse.C"
     break;
 
   case 43: /* pragmaty: "SAFE" id  */
-#line 540 "hexpr.y"
+#line 576 "hexpr.y"
                     { (yyval.mdef) = new MSafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3127 "hexpr.parse.C"
+#line 3163 "hexpr.parse.C"
     break;
 
   case 44: /* tydef: "type" nameseq "=" qtype  */
-#line 543 "hexpr.y"
+#line 579 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Transparent, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3133 "hexpr.parse.C"
+#line 3169 "hexpr.parse.C"
     break;
 
   case 45: /* tydef: "data" nameseq "=" qtype  */
-#line 544 "hexpr.y"
+#line 580 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Opaque, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3139 "hexpr.parse.C"
+#line 3175 "hexpr.parse.C"
     break;
 
   case 46: /* vartybind: name "::" qtype  */
-#line 547 "hexpr.y"
+#line 583 "hexpr.y"
                            { (yyval.mvtydef) = new MVarTypeDef(*(yyvsp[-2].string), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3145 "hexpr.parse.C"
+#line 3181 "hexpr.parse.C"
     break;
 
   case 47: /* vardef: names "=" l0expr  */
-#line 549 "hexpr.y"
+#line 585 "hexpr.y"
                          { (yyval.mvdef) = new MVarDef(*(yyvsp[-2].strings), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3151 "hexpr.parse.C"
+#line 3187 "hexpr.parse.C"
     break;
 
   case 48: /* classdef: "class" cst "=>" id names  */
-#line 552 "hexpr.y"
+#line 588 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-3].tconstraints), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3157 "hexpr.parse.C"
+#line 3193 "hexpr.parse.C"
     break;
 
   case 49: /* classdef: "class" cst "=>" id names "|" fundeps  */
-#line 553 "hexpr.y"
+#line 589 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-6]), (yylsp[0]))); wantIndent(false); }
-#line 3163 "hexpr.parse.C"
+#line 3199 "hexpr.parse.C"
     break;
 
   case 50: /* classdef: "class" cst "=>" id names "where" cmembers  */
-#line 554 "hexpr.y"
+#line 590 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3169 "hexpr.parse.C"
+#line 3205 "hexpr.parse.C"
     break;
 
   case 51: /* classdef: "class" cst "=>" id names "|" fundeps "where" cmembers  */
-#line 555 "hexpr.y"
+#line 591 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-7].tconstraints), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-8]), (yylsp[0])));            wantIndent(false); }
-#line 3175 "hexpr.parse.C"
+#line 3211 "hexpr.parse.C"
     break;
 
   case 52: /* classdef: "class" id names  */
-#line 556 "hexpr.y"
+#line 592 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3181 "hexpr.parse.C"
+#line 3217 "hexpr.parse.C"
     break;
 
   case 53: /* classdef: "class" id names "|" fundeps  */
-#line 557 "hexpr.y"
+#line 593 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3187 "hexpr.parse.C"
+#line 3223 "hexpr.parse.C"
     break;
 
   case 54: /* classdef: "class" id names "where" cmembers  */
-#line 558 "hexpr.y"
+#line 594 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-4]), (yylsp[0])));            wantIndent(false); }
-#line 3193 "hexpr.parse.C"
+#line 3229 "hexpr.parse.C"
     break;
 
   case 55: /* classdef: "class" id names "|" fundeps "where" cmembers  */
-#line 559 "hexpr.y"
+#line 595 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3199 "hexpr.parse.C"
+#line 3235 "hexpr.parse.C"
     break;
 
   case 56: /* fundeps: fundep  */
-#line 561 "hexpr.y"
+#line 597 "hexpr.y"
                             { (yyval.fundeps) = autorelease(new CFunDepDefs()); (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3205 "hexpr.parse.C"
+#line 3241 "hexpr.parse.C"
     break;
 
   case 57: /* fundeps: fundeps "," fundep  */
-#line 562 "hexpr.y"
+#line 598 "hexpr.y"
                             { (yyval.fundeps) = (yyvsp[-2].fundeps);                             (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3211 "hexpr.parse.C"
+#line 3247 "hexpr.parse.C"
     break;
 
   case 58: /* fundep: idseq "->" idseq  */
-#line 564 "hexpr.y"
+#line 600 "hexpr.y"
                          { (yyval.fundep) = autorelease(new CFunDepDef(*(yyvsp[-2].strings), *(yyvsp[0].strings))); }
-#line 3217 "hexpr.parse.C"
+#line 3253 "hexpr.parse.C"
     break;
 
   case 59: /* cmembers: cmember  */
-#line 566 "hexpr.y"
+#line 602 "hexpr.y"
                            { (yyval.mvtydefs) = autorelease(new MVarTypeDefs()); (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3223 "hexpr.parse.C"
+#line 3259 "hexpr.parse.C"
     break;
 
   case 60: /* cmembers: cmembers cmember  */
-#line 567 "hexpr.y"
+#line 603 "hexpr.y"
                            { (yyval.mvtydefs) = (yyvsp[-1].mvtydefs);                              (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3229 "hexpr.parse.C"
+#line 3265 "hexpr.parse.C"
     break;
 
   case 61: /* cmember: "indent" vartybind  */
-#line 569 "hexpr.y"
+#line 605 "hexpr.y"
                             { (yyval.mvtydef) = (yyvsp[0].mvtydef); }
-#line 3235 "hexpr.parse.C"
+#line 3271 "hexpr.parse.C"
     break;
 
   case 62: /* instdef: "instance" id types  */
-#line 572 "hexpr.y"
+#line 608 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3241 "hexpr.parse.C"
+#line 3277 "hexpr.parse.C"
     break;
 
   case 63: /* instdef: "instance" cst "=>" id types  */
-#line 573 "hexpr.y"
+#line 609 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-3].tconstraints),           *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3247 "hexpr.parse.C"
+#line 3283 "hexpr.parse.C"
     break;
 
   case 64: /* instdef: "instance" id types "where" imembers  */
-#line 574 "hexpr.y"
+#line 610 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-4]), (yylsp[0])));        wantIndent(false); }
-#line 3253 "hexpr.parse.C"
+#line 3289 "hexpr.parse.C"
     break;
 
   case 65: /* instdef: "instance" cst "=>" id types "where" imembers  */
-#line 575 "hexpr.y"
+#line 611 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-5].tconstraints),           *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-6]), (yylsp[0])));        wantIndent(false); }
-#line 3259 "hexpr.parse.C"
+#line 3295 "hexpr.parse.C"
     break;
 
   case 66: /* imembers: imember  */
-#line 577 "hexpr.y"
+#line 613 "hexpr.y"
                            { (yyval.mvdefs) = autorelease(new MVarDefs()); (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3265 "hexpr.parse.C"
+#line 3301 "hexpr.parse.C"
     break;
 
   case 67: /* imembers: imembers imember  */
-#line 578 "hexpr.y"
+#line 614 "hexpr.y"
                            { (yyval.mvdefs) = (yyvsp[-1].mvdefs);                          (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3271 "hexpr.parse.C"
+#line 3307 "hexpr.parse.C"
     break;
 
   case 68: /* imember: "indent" vardef  */
-#line 580 "hexpr.y"
+#line 616 "hexpr.y"
                          { (yyval.mvdef) = (yyvsp[0].mvdef); }
-#line 3277 "hexpr.parse.C"
+#line 3313 "hexpr.parse.C"
     break;
 
   case 69: /* names: nameseq  */
-#line 583 "hexpr.y"
+#line 619 "hexpr.y"
                { (yyval.strings) = (yyvsp[0].strings); }
-#line 3283 "hexpr.parse.C"
+#line 3319 "hexpr.parse.C"
     break;
 
   case 70: /* names: id opname id  */
-#line 585 "hexpr.y"
+#line 621 "hexpr.y"
                     { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[-1].string)); (yyval.strings)->push_back(*(yyvsp[-2].string)); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3289 "hexpr.parse.C"
+#line 3325 "hexpr.parse.C"
     break;
 
   case 71: /* nameseq: name  */
-#line 587 "hexpr.y"
+#line 623 "hexpr.y"
                       { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3295 "hexpr.parse.C"
+#line 3331 "hexpr.parse.C"
     break;
 
   case 72: /* nameseq: nameseq name  */
-#line 588 "hexpr.y"
+#line 624 "hexpr.y"
                       { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3301 "hexpr.parse.C"
+#line 3337 "hexpr.parse.C"
     break;
 
   case 73: /* name: id  */
-#line 590 "hexpr.y"
+#line 626 "hexpr.y"
          { (yyval.string) = (yyvsp[0].string); }
-#line 3307 "hexpr.parse.C"
+#line 3343 "hexpr.parse.C"
     break;
 
   case 74: /* name: "(" opname ")"  */
-#line 592 "hexpr.y"
+#line 628 "hexpr.y"
                      { (yyval.string) = (yyvsp[-1].string); }
-#line 3313 "hexpr.parse.C"
+#line 3349 "hexpr.parse.C"
     break;
 
   case 75: /* opname: "and"  */
-#line 594 "hexpr.y"
+#line 630 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("and")); }
-#line 3319 "hexpr.parse.C"
+#line 3355 "hexpr.parse.C"
     break;
 
   case 76: /* opname: "or"  */
-#line 595 "hexpr.y"
+#line 631 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("or")); }
-#line 3325 "hexpr.parse.C"
+#line 3361 "hexpr.parse.C"
     break;
 
   case 77: /* opname: "o"  */
-#line 596 "hexpr.y"
+#line 632 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3331 "hexpr.parse.C"
+#line 3367 "hexpr.parse.C"
     break;
 
   case 78: /* opname: "."  */
-#line 597 "hexpr.y"
+#line 633 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3337 "hexpr.parse.C"
+#line 3373 "hexpr.parse.C"
     break;
 
   case 79: /* opname: "~"  */
-#line 598 "hexpr.y"
+#line 634 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("~")); }
-#line 3343 "hexpr.parse.C"
+#line 3379 "hexpr.parse.C"
     break;
 
   case 80: /* opname: "=~"  */
-#line 599 "hexpr.y"
+#line 635 "hexpr.y"
                { (yyval.string) = autorelease(new std::string("=~")); }
-#line 3349 "hexpr.parse.C"
+#line 3385 "hexpr.parse.C"
     break;
 
   case 81: /* opname: "==="  */
-#line 600 "hexpr.y"
+#line 636 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("===")); }
-#line 3355 "hexpr.parse.C"
+#line 3391 "hexpr.parse.C"
     break;
 
   case 82: /* opname: "=="  */
-#line 601 "hexpr.y"
+#line 637 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("==")); }
-#line 3361 "hexpr.parse.C"
+#line 3397 "hexpr.parse.C"
     break;
 
   case 83: /* opname: "<"  */
-#line 602 "hexpr.y"
+#line 638 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<")); }
-#line 3367 "hexpr.parse.C"
+#line 3403 "hexpr.parse.C"
     break;
 
   case 84: /* opname: "<="  */
-#line 603 "hexpr.y"
+#line 639 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<=")); }
-#line 3373 "hexpr.parse.C"
+#line 3409 "hexpr.parse.C"
     break;
 
   case 85: /* opname: ">"  */
-#line 604 "hexpr.y"
+#line 640 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">")); }
-#line 3379 "hexpr.parse.C"
+#line 3415 "hexpr.parse.C"
     break;
 
   case 86: /* opname: ">="  */
-#line 605 "hexpr.y"
+#line 641 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">=")); }
-#line 3385 "hexpr.parse.C"
+#line 3421 "hexpr.parse.C"
     break;
 
   case 87: /* opname: "in"  */
-#line 606 "hexpr.y"
+#line 642 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("in")); }
-#line 3391 "hexpr.parse.C"
+#line 3427 "hexpr.parse.C"
     break;
 
   case 88: /* opname: "++"  */
-#line 607 "hexpr.y"
+#line 643 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("append")); }
-#line 3397 "hexpr.parse.C"
+#line 3433 "hexpr.parse.C"
     break;
 
   case 89: /* opname: "+"  */
-#line 608 "hexpr.y"
+#line 644 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("+")); }
-#line 3403 "hexpr.parse.C"
+#line 3439 "hexpr.parse.C"
     break;
 
   case 90: /* opname: "-"  */
-#line 609 "hexpr.y"
+#line 645 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("-")); }
-#line 3409 "hexpr.parse.C"
+#line 3445 "hexpr.parse.C"
     break;
 
   case 91: /* opname: "*"  */
-#line 610 "hexpr.y"
+#line 646 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("*")); }
-#line 3415 "hexpr.parse.C"
+#line 3451 "hexpr.parse.C"
     break;
 
   case 92: /* opname: "/"  */
-#line 611 "hexpr.y"
+#line 647 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("/")); }
-#line 3421 "hexpr.parse.C"
+#line 3457 "hexpr.parse.C"
     break;
 
   case 93: /* opname: "%"  */
-#line 612 "hexpr.y"
+#line 648 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("%")); }
-#line 3427 "hexpr.parse.C"
+#line 3463 "hexpr.parse.C"
     break;
 
   case 94: /* idseq: id  */
-#line 614 "hexpr.y"
+#line 650 "hexpr.y"
                 { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3433 "hexpr.parse.C"
+#line 3469 "hexpr.parse.C"
     break;
 
   case 95: /* idseq: idseq id  */
-#line 615 "hexpr.y"
+#line 651 "hexpr.y"
                 { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3439 "hexpr.parse.C"
+#line 3475 "hexpr.parse.C"
     break;
 
   case 96: /* types: l0mtype  */
-#line 617 "hexpr.y"
+#line 653 "hexpr.y"
                      { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3445 "hexpr.parse.C"
+#line 3481 "hexpr.parse.C"
     break;
 
   case 97: /* types: types l0mtype  */
-#line 618 "hexpr.y"
+#line 654 "hexpr.y"
                      { (yyval.mtypes) = (yyvsp[-1].mtypes);                           (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3451 "hexpr.parse.C"
+#line 3487 "hexpr.parse.C"
     break;
 
   case 98: /* l0expr: "\\" patterns "." l0expr  */
-#line 621 "hexpr.y"
+#line 657 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3457 "hexpr.parse.C"
+#line 3493 "hexpr.parse.C"
     break;
 
   case 99: /* l0expr: "fn" patterns "." l0expr  */
-#line 622 "hexpr.y"
+#line 658 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3463 "hexpr.parse.C"
+#line 3499 "hexpr.parse.C"
     break;
 
   case 100: /* l0expr: lhexpr "<-" lhexpr  */
-#line 623 "hexpr.y"
+#line 659 "hexpr.y"
                                  { (yyval.exp) = new Assign(ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3469 "hexpr.parse.C"
+#line 3505 "hexpr.parse.C"
     break;
 
   case 101: /* l0expr: lhexpr  */
-#line 624 "hexpr.y"
+#line 660 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3475 "hexpr.parse.C"
+#line 3511 "hexpr.parse.C"
     break;
 
   case 102: /* lhexpr: "!" l1expr  */
-#line 626 "hexpr.y"
+#line 662 "hexpr.y"
                                  { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), (yyvsp[0].exp), m((yylsp[-1]),(yylsp[0]))); }
-#line 3481 "hexpr.parse.C"
+#line 3517 "hexpr.parse.C"
     break;
 
   case 103: /* lhexpr: lhexpr "and" lhexpr  */
-#line 627 "hexpr.y"
+#line 663 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("and",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3487 "hexpr.parse.C"
+#line 3523 "hexpr.parse.C"
     break;
 
   case 104: /* lhexpr: lhexpr "or" lhexpr  */
-#line 628 "hexpr.y"
+#line 664 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("or",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3493 "hexpr.parse.C"
+#line 3529 "hexpr.parse.C"
     break;
 
   case 105: /* lhexpr: lhexpr "o" lhexpr  */
-#line 629 "hexpr.y"
+#line 665 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("compose",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3499 "hexpr.parse.C"
+#line 3535 "hexpr.parse.C"
     break;
 
   case 106: /* lhexpr: l1expr "in" l1expr  */
-#line 630 "hexpr.y"
+#line 666 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("in",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3505 "hexpr.parse.C"
+#line 3541 "hexpr.parse.C"
     break;
 
   case 107: /* lhexpr: l1expr  */
-#line 631 "hexpr.y"
+#line 667 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3511 "hexpr.parse.C"
+#line 3547 "hexpr.parse.C"
     break;
 
   case 108: /* l1expr: "if" l0expr "then" l0expr "else" l0expr  */
-#line 633 "hexpr.y"
+#line 669 "hexpr.y"
                                                 { (yyval.exp) = TAPP3(var("if",m((yylsp[-5]))), (yyvsp[-4].exp), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-5]), (yylsp[0]))); }
-#line 3517 "hexpr.parse.C"
+#line 3553 "hexpr.parse.C"
     break;
 
   case 109: /* l1expr: l2expr  */
-#line 634 "hexpr.y"
+#line 670 "hexpr.y"
                                                 { (yyval.exp) = (yyvsp[0].exp); }
-#line 3523 "hexpr.parse.C"
+#line 3559 "hexpr.parse.C"
     break;
 
   case 110: /* l2expr: l2expr "~" l2expr  */
-#line 636 "hexpr.y"
+#line 672 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("~",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3529 "hexpr.parse.C"
+#line 3565 "hexpr.parse.C"
     break;
 
   case 111: /* l2expr: l2expr "===" l2expr  */
-#line 637 "hexpr.y"
+#line 673 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("===",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3535 "hexpr.parse.C"
+#line 3571 "hexpr.parse.C"
     break;
 
   case 112: /* l2expr: l2expr "==" l2expr  */
-#line 638 "hexpr.y"
+#line 674 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3541 "hexpr.parse.C"
+#line 3577 "hexpr.parse.C"
     break;
 
   case 113: /* l2expr: l2expr "!=" l2expr  */
-#line 639 "hexpr.y"
+#line 675 "hexpr.y"
                             { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))), m((yylsp[-2]),(yylsp[0]))); }
-#line 3547 "hexpr.parse.C"
+#line 3583 "hexpr.parse.C"
     break;
 
   case 114: /* l2expr: l2expr "<" l2expr  */
-#line 640 "hexpr.y"
+#line 676 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3553 "hexpr.parse.C"
+#line 3589 "hexpr.parse.C"
     break;
 
   case 115: /* l2expr: l2expr "<=" l2expr  */
-#line 641 "hexpr.y"
+#line 677 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3559 "hexpr.parse.C"
+#line 3595 "hexpr.parse.C"
     break;
 
   case 116: /* l2expr: l2expr ">" l2expr  */
-#line 642 "hexpr.y"
+#line 678 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3565 "hexpr.parse.C"
+#line 3601 "hexpr.parse.C"
     break;
 
   case 117: /* l2expr: l2expr ">=" l2expr  */
-#line 643 "hexpr.y"
+#line 679 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3571 "hexpr.parse.C"
+#line 3607 "hexpr.parse.C"
     break;
 
   case 118: /* l2expr: l3expr  */
-#line 644 "hexpr.y"
+#line 680 "hexpr.y"
                             { (yyval.exp) = (yyvsp[0].exp); }
-#line 3577 "hexpr.parse.C"
+#line 3613 "hexpr.parse.C"
     break;
 
   case 119: /* l3expr: l3expr "+" l3expr  */
-#line 646 "hexpr.y"
+#line 682 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("+",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3583 "hexpr.parse.C"
+#line 3619 "hexpr.parse.C"
     break;
 
   case 120: /* l3expr: l3expr "-" l3expr  */
-#line 647 "hexpr.y"
+#line 683 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("-",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3589 "hexpr.parse.C"
+#line 3625 "hexpr.parse.C"
     break;
 
   case 121: /* l3expr: l3expr "++" l3expr  */
-#line 648 "hexpr.y"
+#line 684 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("append",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3595 "hexpr.parse.C"
+#line 3631 "hexpr.parse.C"
     break;
 
   case 122: /* l3expr: "-" l3expr  */
-#line 649 "hexpr.y"
+#line 685 "hexpr.y"
                            { (yyval.exp) = TAPP1(var("neg",m((yylsp[-1]))), ExprPtr((yyvsp[0].exp)), m((yylsp[-1]),(yylsp[0]))); }
-#line 3601 "hexpr.parse.C"
+#line 3637 "hexpr.parse.C"
     break;
 
   case 123: /* l3expr: l4expr  */
-#line 650 "hexpr.y"
+#line 686 "hexpr.y"
                            { (yyval.exp) = (yyvsp[0].exp); }
-#line 3607 "hexpr.parse.C"
+#line 3643 "hexpr.parse.C"
     break;
 
   case 124: /* l4expr: l4expr "*" l4expr  */
-#line 652 "hexpr.y"
+#line 688 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("*", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3613 "hexpr.parse.C"
+#line 3649 "hexpr.parse.C"
     break;
 
   case 125: /* l4expr: l4expr "/" l4expr  */
-#line 653 "hexpr.y"
+#line 689 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("/", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3619 "hexpr.parse.C"
+#line 3655 "hexpr.parse.C"
     break;
 
   case 126: /* l4expr: l4expr "%" l4expr  */
-#line 654 "hexpr.y"
+#line 690 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("%", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3625 "hexpr.parse.C"
+#line 3661 "hexpr.parse.C"
     break;
 
   case 127: /* l4expr: l5expr  */
-#line 655 "hexpr.y"
+#line 691 "hexpr.y"
                           { (yyval.exp) = (yyvsp[0].exp); }
-#line 3631 "hexpr.parse.C"
+#line 3667 "hexpr.parse.C"
     break;
 
   case 128: /* l5expr: l6expr  */
-#line 657 "hexpr.y"
+#line 693 "hexpr.y"
                { (yyval.exp) = (yyvsp[0].exp); }
-#line 3637 "hexpr.parse.C"
+#line 3673 "hexpr.parse.C"
     break;
 
   case 129: /* l5expr: "let" letbindings "in" l0expr  */
-#line 660 "hexpr.y"
+#line 696 "hexpr.y"
                                       { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-2].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3643 "hexpr.parse.C"
+#line 3679 "hexpr.parse.C"
     break;
 
   case 130: /* l5expr: "let" letbindings ";" "in" l0expr  */
-#line 661 "hexpr.y"
+#line 697 "hexpr.y"
                                           { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]),(yylsp[0])))->clone(); }
-#line 3649 "hexpr.parse.C"
+#line 3685 "hexpr.parse.C"
     break;
 
   case 131: /* l5expr: "match" l6exprs "with" patternexps  */
-#line 664 "hexpr.y"
+#line 700 "hexpr.y"
                                            { (yyval.exp) = compileMatch(yyParseCC, *(yyvsp[-2].exps), normPatternRules(*(yyvsp[0].patternexps), m((yylsp[-3]),(yylsp[0]))), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3655 "hexpr.parse.C"
+#line 3691 "hexpr.parse.C"
     break;
 
   case 132: /* l5expr: l6expr "matches" pattern  */
-#line 667 "hexpr.y"
+#line 703 "hexpr.y"
                                  { (yyval.exp) = compileMatchTest(yyParseCC, ExprPtr((yyvsp[-2].exp)), PatternPtr((yyvsp[0].pattern)), m((yylsp[-2]),(yylsp[0])))->clone(); }
-#line 3661 "hexpr.parse.C"
+#line 3697 "hexpr.parse.C"
     break;
 
   case 133: /* l5expr: "parse" "{" prules "}"  */
-#line 670 "hexpr.y"
+#line 706 "hexpr.y"
                                {
         try {
           (yyval.exp) = makeParser(yyParseCC, *(yyvsp[-1].prules), m((yylsp[-3]),(yylsp[0])))->clone();
@@ -3672,1407 +3708,1455 @@ yyreduce:
           throw annotated_error(m((yylsp[-3]),(yylsp[0])), ss.str());
         }
       }
-#line 3676 "hexpr.parse.C"
+#line 3712 "hexpr.parse.C"
     break;
 
   case 134: /* l5expr: "do" "{" dobindings "}"  */
-#line 682 "hexpr.y"
+#line 718 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-1].letbindings), ExprPtr(new Unit(m((yylsp[-3]),(yylsp[0])))), m((yylsp[-3]),(yylsp[0]))); }
-#line 3682 "hexpr.parse.C"
+#line 3718 "hexpr.parse.C"
     break;
 
   case 135: /* l5expr: "do" "{" dobindings "return" l0expr "}"  */
-#line 683 "hexpr.y"
+#line 719 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[-1].exp)), m((yylsp[-5]),(yylsp[0]))); }
-#line 3688 "hexpr.parse.C"
+#line 3724 "hexpr.parse.C"
     break;
 
   case 136: /* l5expr: l6expr "::" qtype  */
-#line 686 "hexpr.y"
+#line 722 "hexpr.y"
                                 { (yyval.exp) = new Assump(ExprPtr((yyvsp[-2].exp)), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]),(yylsp[0]))); }
-#line 3694 "hexpr.parse.C"
+#line 3730 "hexpr.parse.C"
     break;
 
   case 137: /* letbindings: letbindings ";" letbinding  */
-#line 688 "hexpr.y"
+#line 724 "hexpr.y"
                                         { (yyvsp[-2].letbindings)->push_back(*(yyvsp[0].letbinding)); (yyval.letbindings) = (yyvsp[-2].letbindings); }
-#line 3700 "hexpr.parse.C"
+#line 3736 "hexpr.parse.C"
     break;
 
   case 138: /* letbindings: letbinding  */
-#line 689 "hexpr.y"
+#line 725 "hexpr.y"
                                         { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3706 "hexpr.parse.C"
+#line 3742 "hexpr.parse.C"
     break;
 
   case 139: /* letbinding: irrefutablep "=" l1expr  */
-#line 691 "hexpr.y"
+#line 727 "hexpr.y"
                                     { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-2].pattern)), ExprPtr((yyvsp[0].exp)))); }
-#line 3712 "hexpr.parse.C"
+#line 3748 "hexpr.parse.C"
     break;
 
   case 140: /* dobindings: dobindings dobinding  */
-#line 693 "hexpr.y"
+#line 729 "hexpr.y"
                                  { (yyval.letbindings) = (yyvsp[-1].letbindings); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3718 "hexpr.parse.C"
+#line 3754 "hexpr.parse.C"
     break;
 
   case 141: /* dobindings: dobinding  */
-#line 694 "hexpr.y"
+#line 730 "hexpr.y"
                                  { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3724 "hexpr.parse.C"
+#line 3760 "hexpr.parse.C"
     break;
 
   case 142: /* dobinding: irrefutablep "=" l0expr ";"  */
-#line 696 "hexpr.y"
+#line 732 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-3].pattern)), ExprPtr((yyvsp[-1].exp)))); }
-#line 3730 "hexpr.parse.C"
+#line 3766 "hexpr.parse.C"
     break;
 
   case 143: /* dobinding: l0expr ";"  */
-#line 697 "hexpr.y"
+#line 733 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr(new MatchAny("_",m((yylsp[-1])))), ExprPtr((yyvsp[-1].exp)))); }
-#line 3736 "hexpr.parse.C"
+#line 3772 "hexpr.parse.C"
     break;
 
   case 144: /* cselconds: cselconds "," lhexpr  */
-#line 699 "hexpr.y"
+#line 735 "hexpr.y"
                                 { (yyval.exps) = (yyvsp[-2].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3742 "hexpr.parse.C"
+#line 3778 "hexpr.parse.C"
     break;
 
   case 145: /* cselconds: lhexpr  */
-#line 700 "hexpr.y"
+#line 736 "hexpr.y"
                                 { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3748 "hexpr.parse.C"
+#line 3784 "hexpr.parse.C"
     break;
 
   case 146: /* cselection: pattern "<-" l0expr "," cselconds  */
-#line 702 "hexpr.y"
+#line 738 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-4].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[-2].exp)); (yyval.cselection)->conds = *(yyvsp[0].exps); }
-#line 3754 "hexpr.parse.C"
+#line 3790 "hexpr.parse.C"
     break;
 
   case 147: /* cselection: pattern "<-" l0expr  */
-#line 703 "hexpr.y"
+#line 739 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-2].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[0].exp)); }
-#line 3760 "hexpr.parse.C"
+#line 3796 "hexpr.parse.C"
     break;
 
   case 148: /* cselections: cselections "|" cselection  */
-#line 705 "hexpr.y"
+#line 741 "hexpr.y"
                                         { (yyval.cselections) = (yyvsp[-2].cselections); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3766 "hexpr.parse.C"
+#line 3802 "hexpr.parse.C"
     break;
 
   case 149: /* cselections: cselection  */
-#line 706 "hexpr.y"
+#line 742 "hexpr.y"
                                         { (yyval.cselections) = autorelease(new CSelections()); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3772 "hexpr.parse.C"
+#line 3808 "hexpr.parse.C"
     break;
 
   case 150: /* l6expr: l6expr "(" cargs ")"  */
-#line 709 "hexpr.y"
+#line 745 "hexpr.y"
                                 { (yyval.exp) = new App(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].exps), m((yylsp[-3]), (yylsp[0]))); }
-#line 3778 "hexpr.parse.C"
+#line 3814 "hexpr.parse.C"
     break;
 
   case 151: /* l6expr: id  */
-#line 710 "hexpr.y"
+#line 746 "hexpr.y"
                                 { (yyval.exp) = varCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 3784 "hexpr.parse.C"
+#line 3820 "hexpr.parse.C"
     break;
 
   case 152: /* l6expr: "[" l0expr ".." l0expr "]"  */
-#line 713 "hexpr.y"
+#line 749 "hexpr.y"
                                                           { (yyval.exp) = new App(var("range", m((yylsp[-2]))), list(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3790 "hexpr.parse.C"
+#line 3826 "hexpr.parse.C"
     break;
 
   case 153: /* l6expr: "[" l0expr ".." "]"  */
-#line 714 "hexpr.y"
+#line 750 "hexpr.y"
                                                           { (yyval.exp) = new App(var("iterateS", m((yylsp[-1]))), list(ExprPtr((yyvsp[-2].exp)), fn(str::strings(".x"), fncall(var("+", m((yylsp[-1]))), list(var(".x", m((yylsp[-1]))), ExprPtr(new Int(1, m((yylsp[-1]))))), m((yylsp[-1]))), m((yylsp[-1])))), m((yylsp[-3]), (yylsp[0]))); }
-#line 3796 "hexpr.parse.C"
+#line 3832 "hexpr.parse.C"
     break;
 
   case 154: /* l6expr: "[" l0expr "|" cselections "]"  */
-#line 715 "hexpr.y"
+#line 751 "hexpr.y"
                                                           { (yyval.exp) = desugarComprehension(yyParseCC, ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].cselections), m((yylsp[-4]), (yylsp[0]))); }
-#line 3802 "hexpr.parse.C"
+#line 3838 "hexpr.parse.C"
     break;
 
   case 155: /* l6expr: "[" cargs "]"  */
-#line 716 "hexpr.y"
+#line 752 "hexpr.y"
                                                           { (yyval.exp) = new MkArray(*(yyvsp[-1].exps), m((yylsp[-2]), (yylsp[0]))); }
-#line 3808 "hexpr.parse.C"
+#line 3844 "hexpr.parse.C"
     break;
 
   case 156: /* l6expr: l6expr "[" "timeV" "]"  */
-#line 717 "hexpr.y"
+#line 753 "hexpr.y"
                                                           { (yyval.exp) = maybeArraySliceWithTime(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].string), m((yylsp[-3]), (yylsp[0]))); }
-#line 3814 "hexpr.parse.C"
+#line 3850 "hexpr.parse.C"
     break;
 
   case 157: /* l6expr: l6expr "[" l0expr "]"  */
-#line 718 "hexpr.y"
+#line 754 "hexpr.y"
                                                           { (yyval.exp) = mkAIndex(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3820 "hexpr.parse.C"
+#line 3856 "hexpr.parse.C"
     break;
 
   case 158: /* l6expr: l6expr "[" l0expr ":" l0expr "]"  */
-#line 719 "hexpr.y"
+#line 755 "hexpr.y"
                                                           { (yyval.exp) = new App(var("slice", m((yylsp[-2]))), list(ExprPtr((yyvsp[-5].exp)), ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-5]), (yylsp[0]))); }
-#line 3826 "hexpr.parse.C"
+#line 3862 "hexpr.parse.C"
     break;
 
   case 159: /* l6expr: l6expr "[" l0expr ":" "]"  */
-#line 720 "hexpr.y"
+#line 756 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-1]))), list(var(vn,m((yylsp[-4]))), ExprPtr((yyvsp[-2].exp)), fncall(var("size",m((yylsp[-1]))), list(var(vn,m((yylsp[-4])))),m((yylsp[-4])))),m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3832 "hexpr.parse.C"
+#line 3868 "hexpr.parse.C"
     break;
 
   case 160: /* l6expr: l6expr "[" ":" l0expr "]"  */
-#line 721 "hexpr.y"
+#line 757 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-2]))), list(var(vn,m((yylsp[-4]))), fncall(var("size",m((yylsp[-2]))), list(var(vn,m((yylsp[-2])))),m((yylsp[-4]))), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3838 "hexpr.parse.C"
+#line 3874 "hexpr.parse.C"
     break;
 
   case 161: /* l6expr: "|" id "=" l0expr "|"  */
-#line 724 "hexpr.y"
+#line 760 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-3].string), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3844 "hexpr.parse.C"
+#line 3880 "hexpr.parse.C"
     break;
 
   case 162: /* l6expr: "|" "intV" "=" l0expr "|"  */
-#line 725 "hexpr.y"
+#line 761 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(".f" + str::from((yyvsp[-3].intv)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3850 "hexpr.parse.C"
+#line 3886 "hexpr.parse.C"
     break;
 
   case 163: /* l6expr: "|" id "|"  */
-#line 726 "hexpr.y"
+#line 762 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-1].string), ExprPtr(new Unit(m((yylsp[-1])))), m((yylsp[-2]), (yylsp[0]))); }
-#line 3856 "hexpr.parse.C"
+#line 3892 "hexpr.parse.C"
     break;
 
   case 164: /* l6expr: "case" l0expr "of" "|" varfields "|"  */
-#line 727 "hexpr.y"
+#line 763 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-4].exp)), *(yyvsp[-1].vfields), m((yylsp[-5]), (yylsp[0]))); }
-#line 3862 "hexpr.parse.C"
+#line 3898 "hexpr.parse.C"
     break;
 
   case 165: /* l6expr: "case" l0expr "of" "|" varfields "|" "default" l0expr  */
-#line 728 "hexpr.y"
+#line 764 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-6].exp)), *(yyvsp[-3].vfields), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 3868 "hexpr.parse.C"
+#line 3904 "hexpr.parse.C"
     break;
 
   case 166: /* l6expr: "{" recfields "}"  */
-#line 731 "hexpr.y"
+#line 767 "hexpr.y"
                               { if ((yyvsp[-1].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-1].rfields), m((yylsp[-2]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-2]), (yylsp[0]))); } }
-#line 3874 "hexpr.parse.C"
+#line 3910 "hexpr.parse.C"
     break;
 
   case 167: /* l6expr: "{" recfields "," "}"  */
-#line 732 "hexpr.y"
+#line 768 "hexpr.y"
                               { if ((yyvsp[-2].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-2].rfields), m((yylsp[-3]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-3]), (yylsp[0]))); } }
-#line 3880 "hexpr.parse.C"
+#line 3916 "hexpr.parse.C"
     break;
 
   case 168: /* l6expr: l6expr recfieldpath  */
-#line 733 "hexpr.y"
+#line 769 "hexpr.y"
                               { (yyval.exp) = makeProjSeq((yyvsp[-1].exp), *(yyvsp[0].strings), m((yylsp[-1]), (yylsp[0]))); }
-#line 3886 "hexpr.parse.C"
+#line 3922 "hexpr.parse.C"
     break;
 
   case 169: /* l6expr: recfieldpath  */
-#line 736 "hexpr.y"
+#line 772 "hexpr.y"
                      { (yyval.exp) = new Fn(str::strings("x"), proj(var("x", m((yylsp[0]))), *(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3892 "hexpr.parse.C"
+#line 3928 "hexpr.parse.C"
     break;
 
   case 170: /* l6expr: "regexV"  */
-#line 739 "hexpr.y"
+#line 775 "hexpr.y"
                  { (yyval.exp) = compileRegexFn(yyParseCC, std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0])))->clone(); }
-#line 3898 "hexpr.parse.C"
+#line 3934 "hexpr.parse.C"
     break;
 
   case 171: /* l6expr: "pack" l6expr  */
-#line 742 "hexpr.y"
+#line 778 "hexpr.y"
                                            { (yyval.exp) = new Pack(ExprPtr((yyvsp[0].exp)), m((yylsp[-1]), (yylsp[0]))); }
-#line 3904 "hexpr.parse.C"
+#line 3940 "hexpr.parse.C"
     break;
 
   case 172: /* l6expr: "unpack" id "=" l6expr "in" l6expr  */
-#line 743 "hexpr.y"
+#line 779 "hexpr.y"
                                            { (yyval.exp) = new Unpack(*(yyvsp[-4].string), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 3910 "hexpr.parse.C"
+#line 3946 "hexpr.parse.C"
     break;
 
   case 173: /* l6expr: "boolV"  */
-#line 746 "hexpr.y"
+#line 782 "hexpr.y"
                     { (yyval.exp) = new Bool((yyvsp[0].boolv), m((yylsp[0]))); }
-#line 3916 "hexpr.parse.C"
+#line 3952 "hexpr.parse.C"
     break;
 
   case 174: /* l6expr: "charV"  */
-#line 747 "hexpr.y"
+#line 783 "hexpr.y"
                     { (yyval.exp) = new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3922 "hexpr.parse.C"
+#line 3958 "hexpr.parse.C"
     break;
 
   case 175: /* l6expr: "byteV"  */
-#line 748 "hexpr.y"
+#line 784 "hexpr.y"
                     { (yyval.exp) = new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3928 "hexpr.parse.C"
+#line 3964 "hexpr.parse.C"
     break;
 
   case 176: /* l6expr: "bytesV"  */
-#line 749 "hexpr.y"
+#line 785 "hexpr.y"
                     { (yyval.exp) = mkarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3934 "hexpr.parse.C"
+#line 3970 "hexpr.parse.C"
     break;
 
   case 177: /* l6expr: "shortV"  */
-#line 750 "hexpr.y"
+#line 786 "hexpr.y"
                     { (yyval.exp) = new Short((yyvsp[0].shortv), m((yylsp[0]))); }
-#line 3940 "hexpr.parse.C"
+#line 3976 "hexpr.parse.C"
     break;
 
   case 178: /* l6expr: "intV"  */
-#line 751 "hexpr.y"
+#line 787 "hexpr.y"
                     { (yyval.exp) = new Int((yyvsp[0].intv), m((yylsp[0]))); }
-#line 3946 "hexpr.parse.C"
+#line 3982 "hexpr.parse.C"
     break;
 
   case 179: /* l6expr: "longV"  */
-#line 752 "hexpr.y"
+#line 788 "hexpr.y"
                     { (yyval.exp) = new Long((yyvsp[0].longv), m((yylsp[0]))); }
-#line 3952 "hexpr.parse.C"
+#line 3988 "hexpr.parse.C"
     break;
 
   case 180: /* l6expr: "int128V"  */
-#line 753 "hexpr.y"
+#line 789 "hexpr.y"
                     { (yyval.exp) = new Int128((yyvsp[0].int128v), m((yylsp[0]))); }
-#line 3958 "hexpr.parse.C"
+#line 3994 "hexpr.parse.C"
     break;
 
   case 181: /* l6expr: "floatV"  */
-#line 754 "hexpr.y"
+#line 790 "hexpr.y"
                     { (yyval.exp) = new Float((yyvsp[0].floatv), m((yylsp[0]))); }
-#line 3964 "hexpr.parse.C"
+#line 4000 "hexpr.parse.C"
     break;
 
   case 182: /* l6expr: "doubleV"  */
-#line 755 "hexpr.y"
+#line 791 "hexpr.y"
                     { (yyval.exp) = new Double((yyvsp[0].doublev), m((yylsp[0]))); }
-#line 3970 "hexpr.parse.C"
+#line 4006 "hexpr.parse.C"
     break;
 
   case 183: /* l6expr: "stringV"  */
-#line 756 "hexpr.y"
+#line 792 "hexpr.y"
                     { (yyval.exp) = mkarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 3976 "hexpr.parse.C"
+#line 4012 "hexpr.parse.C"
     break;
 
   case 184: /* l6expr: tsseq  */
-#line 757 "hexpr.y"
+#line 793 "hexpr.y"
                     { (yyval.exp) = mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0])))->clone(); }
-#line 3982 "hexpr.parse.C"
+#line 4018 "hexpr.parse.C"
     break;
 
   case 185: /* l6expr: "timeV"  */
-#line 758 "hexpr.y"
+#line 794 "hexpr.y"
                     { (yyval.exp) = mkTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 3988 "hexpr.parse.C"
+#line 4024 "hexpr.parse.C"
     break;
 
   case 186: /* l6expr: "dateTimeV"  */
-#line 759 "hexpr.y"
+#line 795 "hexpr.y"
                     { (yyval.exp) = mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 3994 "hexpr.parse.C"
+#line 4030 "hexpr.parse.C"
     break;
 
   case 187: /* l6expr: "(" cargs ")"  */
-#line 762 "hexpr.y"
+#line 798 "hexpr.y"
                       { (yyval.exp) = pickNestedExp((yyvsp[-1].exps), m((yylsp[-2]),(yylsp[0]))); }
-#line 4000 "hexpr.parse.C"
+#line 4036 "hexpr.parse.C"
     break;
 
   case 188: /* l6expr: "(" "++" ")"  */
-#line 765 "hexpr.y"
+#line 801 "hexpr.y"
                       { (yyval.exp) = new Var("append", m((yylsp[-1]))); }
-#line 4006 "hexpr.parse.C"
+#line 4042 "hexpr.parse.C"
     break;
 
   case 189: /* l6expr: "(" "+" ")"  */
-#line 766 "hexpr.y"
+#line 802 "hexpr.y"
                       { (yyval.exp) = new Var("+",      m((yylsp[-1]))); }
-#line 4012 "hexpr.parse.C"
+#line 4048 "hexpr.parse.C"
     break;
 
   case 190: /* l6expr: "(" "-" ")"  */
-#line 767 "hexpr.y"
+#line 803 "hexpr.y"
                       { (yyval.exp) = new Var("-",      m((yylsp[-1]))); }
-#line 4018 "hexpr.parse.C"
+#line 4054 "hexpr.parse.C"
     break;
 
   case 191: /* l6expr: "(" "*" ")"  */
-#line 768 "hexpr.y"
+#line 804 "hexpr.y"
                       { (yyval.exp) = new Var("*",      m((yylsp[-1]))); }
-#line 4024 "hexpr.parse.C"
+#line 4060 "hexpr.parse.C"
     break;
 
   case 192: /* l6expr: "(" "/" ")"  */
-#line 769 "hexpr.y"
+#line 805 "hexpr.y"
                       { (yyval.exp) = new Var("/",      m((yylsp[-1]))); }
-#line 4030 "hexpr.parse.C"
+#line 4066 "hexpr.parse.C"
     break;
 
   case 193: /* l6expr: "(" "%" ")"  */
-#line 770 "hexpr.y"
+#line 806 "hexpr.y"
                       { (yyval.exp) = new Var("%",      m((yylsp[-1]))); }
-#line 4036 "hexpr.parse.C"
+#line 4072 "hexpr.parse.C"
     break;
 
   case 194: /* l6expr: "(" "~" ")"  */
-#line 771 "hexpr.y"
+#line 807 "hexpr.y"
                       { (yyval.exp) = new Var("~",      m((yylsp[-1]))); }
-#line 4042 "hexpr.parse.C"
+#line 4078 "hexpr.parse.C"
     break;
 
   case 195: /* l6expr: "(" "===" ")"  */
-#line 772 "hexpr.y"
+#line 808 "hexpr.y"
                       { (yyval.exp) = new Var("===",    m((yylsp[-1]))); }
-#line 4048 "hexpr.parse.C"
+#line 4084 "hexpr.parse.C"
     break;
 
   case 196: /* l6expr: "(" "==" ")"  */
-#line 773 "hexpr.y"
+#line 809 "hexpr.y"
                       { (yyval.exp) = new Var("==",     m((yylsp[-1]))); }
-#line 4054 "hexpr.parse.C"
+#line 4090 "hexpr.parse.C"
     break;
 
   case 197: /* l6expr: "(" "!=" ")"  */
-#line 774 "hexpr.y"
+#line 810 "hexpr.y"
                       { (yyval.exp) = new Var("!=",     m((yylsp[-1]))); }
-#line 4060 "hexpr.parse.C"
+#line 4096 "hexpr.parse.C"
     break;
 
   case 198: /* l6expr: "(" "<" ")"  */
-#line 775 "hexpr.y"
+#line 811 "hexpr.y"
                       { (yyval.exp) = new Var("<",      m((yylsp[-1]))); }
-#line 4066 "hexpr.parse.C"
+#line 4102 "hexpr.parse.C"
     break;
 
   case 199: /* l6expr: "(" ">" ")"  */
-#line 776 "hexpr.y"
+#line 812 "hexpr.y"
                       { (yyval.exp) = new Var(">",      m((yylsp[-1]))); }
-#line 4072 "hexpr.parse.C"
+#line 4108 "hexpr.parse.C"
     break;
 
   case 200: /* l6expr: "(" ">=" ")"  */
-#line 777 "hexpr.y"
+#line 813 "hexpr.y"
                       { (yyval.exp) = new Var(">=",     m((yylsp[-1]))); }
-#line 4078 "hexpr.parse.C"
+#line 4114 "hexpr.parse.C"
     break;
 
   case 201: /* l6expr: "(" "<=" ")"  */
-#line 778 "hexpr.y"
+#line 814 "hexpr.y"
                       { (yyval.exp) = new Var("<=",     m((yylsp[-1]))); }
-#line 4084 "hexpr.parse.C"
+#line 4120 "hexpr.parse.C"
     break;
 
   case 202: /* l6expr: "(" "and" ")"  */
-#line 779 "hexpr.y"
+#line 815 "hexpr.y"
                       { (yyval.exp) = new Var("and",    m((yylsp[-1]))); }
-#line 4090 "hexpr.parse.C"
+#line 4126 "hexpr.parse.C"
     break;
 
   case 203: /* l6expr: "(" "or" ")"  */
-#line 780 "hexpr.y"
+#line 816 "hexpr.y"
                       { (yyval.exp) = new Var("or",     m((yylsp[-1]))); }
-#line 4096 "hexpr.parse.C"
+#line 4132 "hexpr.parse.C"
     break;
 
   case 204: /* l6expr: "(" "in" ")"  */
-#line 781 "hexpr.y"
+#line 817 "hexpr.y"
                       { (yyval.exp) = new Var("in",     m((yylsp[-1]))); }
-#line 4102 "hexpr.parse.C"
+#line 4138 "hexpr.parse.C"
     break;
 
   case 205: /* l6expr: "(" "!" ")"  */
-#line 782 "hexpr.y"
+#line 818 "hexpr.y"
                       { (yyval.exp) = new Var("not",    m((yylsp[-1]))); }
-#line 4108 "hexpr.parse.C"
+#line 4144 "hexpr.parse.C"
     break;
 
   case 206: /* l6expr: "`" l0expr "`"  */
-#line 785 "hexpr.y"
+#line 821 "hexpr.y"
                        { (yyval.exp) = new Assump(fncall(var("unsafeCast", m((yylsp[-1]))), list(mktunit(m((yylsp[-1])))), m((yylsp[-1]))), qualtype(tapp(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp)))))), m((yylsp[-1]))); }
-#line 4114 "hexpr.parse.C"
+#line 4150 "hexpr.parse.C"
     break;
 
   case 207: /* prules: prules prule  */
-#line 787 "hexpr.y"
+#line 823 "hexpr.y"
                      { (yyval.prules) = (yyvsp[-1].prules); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4120 "hexpr.parse.C"
+#line 4156 "hexpr.parse.C"
     break;
 
   case 208: /* prules: prule  */
-#line 788 "hexpr.y"
+#line 824 "hexpr.y"
                      { (yyval.prules) = autorelease(new Grammar()); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4126 "hexpr.parse.C"
+#line 4162 "hexpr.parse.C"
     break;
 
   case 209: /* prule: id ":=" prdefs  */
-#line 790 "hexpr.y"
+#line 826 "hexpr.y"
                       { (yyval.prule) = autorelease(new Grammar::value_type(*(yyvsp[-2].string), *(yyvsp[0].prdefs))); }
-#line 4132 "hexpr.parse.C"
+#line 4168 "hexpr.parse.C"
     break;
 
   case 210: /* prdefs: prdefs "|" prdef  */
-#line 792 "hexpr.y"
+#line 828 "hexpr.y"
                          { (yyval.prdefs) = (yyvsp[-2].prdefs); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4138 "hexpr.parse.C"
+#line 4174 "hexpr.parse.C"
     break;
 
   case 211: /* prdefs: prdef  */
-#line 793 "hexpr.y"
+#line 829 "hexpr.y"
                          { (yyval.prdefs) = autorelease(new GrammarRules()); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4144 "hexpr.parse.C"
+#line 4180 "hexpr.parse.C"
     break;
 
   case 212: /* prdef: pbelems "{" l0expr "}"  */
-#line 795 "hexpr.y"
+#line 831 "hexpr.y"
                               { (yyval.prdef) = autorelease(new GrammarRule(*(yyvsp[-3].pbelems), ExprPtr((yyvsp[-1].exp)))); }
-#line 4150 "hexpr.parse.C"
+#line 4186 "hexpr.parse.C"
     break;
 
   case 213: /* pbelems: pbelems pbelem  */
-#line 797 "hexpr.y"
+#line 833 "hexpr.y"
                         { (yyval.pbelems) = (yyvsp[-1].pbelems); (yyval.pbelems)->push_back(*(yyvsp[0].pbelem)); }
-#line 4156 "hexpr.parse.C"
+#line 4192 "hexpr.parse.C"
     break;
 
   case 214: /* pbelems: %empty  */
-#line 798 "hexpr.y"
+#line 834 "hexpr.y"
                         { (yyval.pbelems) = autorelease(new BoundGrammarValues()); }
-#line 4162 "hexpr.parse.C"
+#line 4198 "hexpr.parse.C"
     break;
 
   case 215: /* pbelem: id ":" pvalue  */
-#line 800 "hexpr.y"
+#line 836 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue(*(yyvsp[-2].string), GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4168 "hexpr.parse.C"
+#line 4204 "hexpr.parse.C"
     break;
 
   case 216: /* pbelem: pvalue  */
-#line 801 "hexpr.y"
+#line 837 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue("_", GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4174 "hexpr.parse.C"
+#line 4210 "hexpr.parse.C"
     break;
 
   case 217: /* pvalue: id  */
-#line 803 "hexpr.y"
+#line 839 "hexpr.y"
                       { (yyval.pvalue) = new GSymRef(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4180 "hexpr.parse.C"
+#line 4216 "hexpr.parse.C"
     break;
 
   case 218: /* pvalue: "stringV"  */
-#line 804 "hexpr.y"
+#line 840 "hexpr.y"
                       { (yyval.pvalue) = new GStr(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4186 "hexpr.parse.C"
+#line 4222 "hexpr.parse.C"
     break;
 
   case 219: /* pvalue: "charV"  */
-#line 805 "hexpr.y"
+#line 841 "hexpr.y"
                       { (yyval.pvalue) = new GStr(std::string(1, str::readCharDef(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4192 "hexpr.parse.C"
+#line 4228 "hexpr.parse.C"
     break;
 
   case 220: /* tsseq: "timespanV"  */
-#line 807 "hexpr.y"
+#line 843 "hexpr.y"
                          { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4198 "hexpr.parse.C"
+#line 4234 "hexpr.parse.C"
     break;
 
   case 221: /* tsseq: tsseq "timespanV"  */
-#line 808 "hexpr.y"
+#line 844 "hexpr.y"
                          { (yyval.strings) = (yyvsp[-1].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4204 "hexpr.parse.C"
+#line 4240 "hexpr.parse.C"
     break;
 
   case 222: /* l6exprs: l6exprs l6expr  */
-#line 810 "hexpr.y"
+#line 846 "hexpr.y"
                         { (yyval.exps) = (yyvsp[-1].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4210 "hexpr.parse.C"
+#line 4246 "hexpr.parse.C"
     break;
 
   case 223: /* l6exprs: l6expr  */
-#line 811 "hexpr.y"
+#line 847 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4216 "hexpr.parse.C"
+#line 4252 "hexpr.parse.C"
     break;
 
   case 224: /* patternexps: patternexps patternexp  */
-#line 813 "hexpr.y"
+#line 849 "hexpr.y"
                                     { (yyval.patternexps) = (yyvsp[-1].patternexps); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4222 "hexpr.parse.C"
+#line 4258 "hexpr.parse.C"
     break;
 
   case 225: /* patternexps: patternexp  */
-#line 814 "hexpr.y"
+#line 850 "hexpr.y"
                                     { (yyval.patternexps) = autorelease(new PatternRows()); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4228 "hexpr.parse.C"
+#line 4264 "hexpr.parse.C"
     break;
 
   case 226: /* patternexp: "|" patterns "->" l0expr  */
-#line 816 "hexpr.y"
+#line 852 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)))); }
-#line 4234 "hexpr.parse.C"
+#line 4270 "hexpr.parse.C"
     break;
 
   case 227: /* patternexp: "|" patterns "where" l0expr "->" l0expr  */
-#line 817 "hexpr.y"
+#line 853 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-4].patterns), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)))); }
-#line 4240 "hexpr.parse.C"
+#line 4276 "hexpr.parse.C"
     break;
 
   case 228: /* patterns: patterns pattern  */
-#line 820 "hexpr.y"
+#line 856 "hexpr.y"
                            { (yyval.patterns) = (yyvsp[-1].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4246 "hexpr.parse.C"
+#line 4282 "hexpr.parse.C"
     break;
 
   case 229: /* patterns: pattern  */
-#line 821 "hexpr.y"
+#line 857 "hexpr.y"
                            { (yyval.patterns) = autorelease(new Patterns()); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4252 "hexpr.parse.C"
+#line 4288 "hexpr.parse.C"
     break;
 
   case 230: /* refutablep: "boolV"  */
-#line 823 "hexpr.y"
+#line 859 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Bool((yyvsp[0].boolv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4258 "hexpr.parse.C"
+#line 4294 "hexpr.parse.C"
     break;
 
   case 231: /* refutablep: "charV"  */
-#line 824 "hexpr.y"
+#line 860 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4264 "hexpr.parse.C"
+#line 4300 "hexpr.parse.C"
     break;
 
   case 232: /* refutablep: "byteV"  */
-#line 825 "hexpr.y"
+#line 861 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4270 "hexpr.parse.C"
+#line 4306 "hexpr.parse.C"
     break;
 
   case 233: /* refutablep: "shortV"  */
-#line 826 "hexpr.y"
+#line 862 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Short((yyvsp[0].shortv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4276 "hexpr.parse.C"
+#line 4312 "hexpr.parse.C"
     break;
 
   case 234: /* refutablep: "intV"  */
-#line 827 "hexpr.y"
+#line 863 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int((yyvsp[0].intv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4282 "hexpr.parse.C"
+#line 4318 "hexpr.parse.C"
     break;
 
   case 235: /* refutablep: "longV"  */
-#line 828 "hexpr.y"
+#line 864 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Long((yyvsp[0].longv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4288 "hexpr.parse.C"
+#line 4324 "hexpr.parse.C"
     break;
 
   case 236: /* refutablep: "int128V"  */
-#line 829 "hexpr.y"
+#line 865 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int128((yyvsp[0].int128v), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4294 "hexpr.parse.C"
+#line 4330 "hexpr.parse.C"
     break;
 
   case 237: /* refutablep: "doubleV"  */
-#line 830 "hexpr.y"
+#line 866 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Double((yyvsp[0].doublev), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4300 "hexpr.parse.C"
+#line 4336 "hexpr.parse.C"
     break;
 
   case 238: /* refutablep: "bytesV"  */
-#line 831 "hexpr.y"
+#line 867 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 4306 "hexpr.parse.C"
+#line 4342 "hexpr.parse.C"
     break;
 
   case 239: /* refutablep: "stringV"  */
-#line 832 "hexpr.y"
+#line 868 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4312 "hexpr.parse.C"
+#line 4348 "hexpr.parse.C"
     break;
 
   case 240: /* refutablep: tsseq  */
-#line 833 "hexpr.y"
+#line 869 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimespanPrim(*(yyvsp[0].strings), m((yylsp[0]))), mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4318 "hexpr.parse.C"
+#line 4354 "hexpr.parse.C"
     break;
 
   case 241: /* refutablep: "timeV"  */
-#line 834 "hexpr.y"
+#line 870 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4324 "hexpr.parse.C"
+#line 4360 "hexpr.parse.C"
     break;
 
   case 242: /* refutablep: "dateTimeV"  */
-#line 835 "hexpr.y"
+#line 871 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkDateTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4330 "hexpr.parse.C"
+#line 4366 "hexpr.parse.C"
     break;
 
   case 243: /* refutablep: "regexV"  */
-#line 836 "hexpr.y"
+#line 872 "hexpr.y"
                                        { (yyval.pattern) = new MatchRegex(std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0]))); }
-#line 4336 "hexpr.parse.C"
+#line 4372 "hexpr.parse.C"
     break;
 
   case 244: /* refutablep: "[" patternseq "]"  */
-#line 837 "hexpr.y"
+#line 873 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4342 "hexpr.parse.C"
+#line 4378 "hexpr.parse.C"
     break;
 
   case 245: /* refutablep: "[" patternseq "," "]"  */
-#line 838 "hexpr.y"
+#line 874 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4348 "hexpr.parse.C"
+#line 4384 "hexpr.parse.C"
     break;
 
   case 246: /* refutablep: "|" id "|"  */
-#line 839 "hexpr.y"
+#line 875 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-1].string), PatternPtr(new MatchLiteral(PrimitivePtr(new Unit(m((yylsp[-1])))), m((yylsp[-1])))), m((yylsp[-2]),(yylsp[0]))); }
-#line 4354 "hexpr.parse.C"
+#line 4390 "hexpr.parse.C"
     break;
 
   case 247: /* refutablep: "|" id "=" pattern "|"  */
-#line 840 "hexpr.y"
+#line 876 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-3].string), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4360 "hexpr.parse.C"
+#line 4396 "hexpr.parse.C"
     break;
 
   case 248: /* refutablep: "|" "intV" "=" pattern "|"  */
-#line 841 "hexpr.y"
+#line 877 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(".f" + str::from((yyvsp[-3].intv)), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4366 "hexpr.parse.C"
+#line 4402 "hexpr.parse.C"
     break;
 
   case 249: /* refutablep: "(" patternseq ")"  */
-#line 842 "hexpr.y"
+#line 878 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4372 "hexpr.parse.C"
+#line 4408 "hexpr.parse.C"
     break;
 
   case 250: /* refutablep: "(" patternseq "," ")"  */
-#line 843 "hexpr.y"
+#line 879 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4378 "hexpr.parse.C"
+#line 4414 "hexpr.parse.C"
     break;
 
   case 251: /* refutablep: "{" recpatfields "}"  */
-#line 844 "hexpr.y"
+#line 880 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4384 "hexpr.parse.C"
+#line 4420 "hexpr.parse.C"
     break;
 
   case 252: /* refutablep: "{" recpatfields "," "}"  */
-#line 845 "hexpr.y"
+#line 881 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4390 "hexpr.parse.C"
+#line 4426 "hexpr.parse.C"
     break;
 
   case 253: /* refutablep: id  */
-#line 846 "hexpr.y"
+#line 882 "hexpr.y"
                                        { (yyval.pattern) = patVarCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4396 "hexpr.parse.C"
+#line 4432 "hexpr.parse.C"
     break;
 
   case 254: /* irrefutablep: id  */
-#line 848 "hexpr.y"
+#line 884 "hexpr.y"
                                        { (yyval.pattern) = new MatchAny(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4402 "hexpr.parse.C"
+#line 4438 "hexpr.parse.C"
     break;
 
   case 255: /* irrefutablep: "(" patternseq ")"  */
-#line 849 "hexpr.y"
+#line 885 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4408 "hexpr.parse.C"
+#line 4444 "hexpr.parse.C"
     break;
 
   case 256: /* irrefutablep: "(" patternseq "," ")"  */
-#line 850 "hexpr.y"
+#line 886 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4414 "hexpr.parse.C"
+#line 4450 "hexpr.parse.C"
     break;
 
   case 257: /* irrefutablep: "{" recpatfields "}"  */
-#line 851 "hexpr.y"
+#line 887 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4420 "hexpr.parse.C"
+#line 4456 "hexpr.parse.C"
     break;
 
   case 258: /* irrefutablep: "{" recpatfields "," "}"  */
-#line 852 "hexpr.y"
+#line 888 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4426 "hexpr.parse.C"
+#line 4462 "hexpr.parse.C"
     break;
 
   case 259: /* pattern: refutablep  */
-#line 854 "hexpr.y"
+#line 890 "hexpr.y"
                     { (yyval.pattern) = (yyvsp[0].pattern); }
-#line 4432 "hexpr.parse.C"
+#line 4468 "hexpr.parse.C"
     break;
 
   case 260: /* patternseq: patternseqn  */
-#line 856 "hexpr.y"
+#line 892 "hexpr.y"
                           { (yyval.patterns) = (yyvsp[0].patterns); }
-#line 4438 "hexpr.parse.C"
+#line 4474 "hexpr.parse.C"
     break;
 
   case 261: /* patternseq: %empty  */
-#line 857 "hexpr.y"
+#line 893 "hexpr.y"
                           { (yyval.patterns) = new Patterns(); }
-#line 4444 "hexpr.parse.C"
+#line 4480 "hexpr.parse.C"
     break;
 
   case 262: /* patternseqn: patternseqn "," pattern  */
-#line 859 "hexpr.y"
+#line 895 "hexpr.y"
                                      { (yyval.patterns) = (yyvsp[-2].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4450 "hexpr.parse.C"
+#line 4486 "hexpr.parse.C"
     break;
 
   case 263: /* patternseqn: pattern  */
-#line 860 "hexpr.y"
+#line 896 "hexpr.y"
                                      { (yyval.patterns) = new Patterns(); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4456 "hexpr.parse.C"
+#line 4492 "hexpr.parse.C"
     break;
 
   case 264: /* recpatfields: recpatfields "," recpatfield  */
-#line 862 "hexpr.y"
+#line 898 "hexpr.y"
                                            { (yyval.recpatfields) = (yyvsp[-2].recpatfields); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4462 "hexpr.parse.C"
+#line 4498 "hexpr.parse.C"
     break;
 
   case 265: /* recpatfields: recpatfield  */
-#line 863 "hexpr.y"
+#line 899 "hexpr.y"
                                            { (yyval.recpatfields) = new MatchRecord::Fields(); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4468 "hexpr.parse.C"
+#line 4504 "hexpr.parse.C"
     break;
 
   case 266: /* recpatfield: id "=" pattern  */
-#line 865 "hexpr.y"
+#line 901 "hexpr.y"
                             { (yyval.recpatfield) = new MatchRecord::Field(*(yyvsp[-2].string), PatternPtr((yyvsp[0].pattern))); }
-#line 4474 "hexpr.parse.C"
+#line 4510 "hexpr.parse.C"
     break;
 
   case 267: /* recfields: %empty  */
-#line 867 "hexpr.y"
+#line 903 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); }
-#line 4480 "hexpr.parse.C"
+#line 4516 "hexpr.parse.C"
     break;
 
   case 268: /* recfields: recfieldname "=" l0expr  */
-#line 868 "hexpr.y"
+#line 904 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4486 "hexpr.parse.C"
+#line 4522 "hexpr.parse.C"
     break;
 
   case 269: /* recfields: recfields "," recfieldname "=" l0expr  */
-#line 869 "hexpr.y"
+#line 905 "hexpr.y"
                                                  { (yyval.rfields) = (yyvsp[-4].rfields);                                     (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4492 "hexpr.parse.C"
+#line 4528 "hexpr.parse.C"
     break;
 
   case 270: /* recfieldname: id  */
-#line 871 "hexpr.y"
+#line 907 "hexpr.y"
                          { (yyval.string) = (yyvsp[0].string); }
-#line 4498 "hexpr.parse.C"
+#line 4534 "hexpr.parse.C"
     break;
 
   case 271: /* recfieldname: "data"  */
-#line 872 "hexpr.y"
+#line 908 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("data")); }
-#line 4504 "hexpr.parse.C"
+#line 4540 "hexpr.parse.C"
     break;
 
   case 272: /* recfieldname: "type"  */
-#line 873 "hexpr.y"
+#line 909 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("type")); }
-#line 4510 "hexpr.parse.C"
+#line 4546 "hexpr.parse.C"
     break;
 
   case 273: /* recfieldname: "where"  */
-#line 874 "hexpr.y"
+#line 910 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("where")); }
-#line 4516 "hexpr.parse.C"
+#line 4552 "hexpr.parse.C"
     break;
 
   case 274: /* recfieldname: "class"  */
-#line 875 "hexpr.y"
+#line 911 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("class")); wantIndent(false); }
-#line 4522 "hexpr.parse.C"
+#line 4558 "hexpr.parse.C"
     break;
 
   case 275: /* recfieldname: "instance"  */
-#line 876 "hexpr.y"
+#line 912 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("instance")); wantIndent(false); }
-#line 4528 "hexpr.parse.C"
+#line 4564 "hexpr.parse.C"
     break;
 
   case 276: /* recfieldname: "exists"  */
-#line 877 "hexpr.y"
+#line 913 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("exists")); }
-#line 4534 "hexpr.parse.C"
+#line 4570 "hexpr.parse.C"
     break;
 
   case 277: /* recfieldname: "import"  */
-#line 878 "hexpr.y"
+#line 914 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("import")); }
-#line 4540 "hexpr.parse.C"
+#line 4576 "hexpr.parse.C"
     break;
 
   case 278: /* recfieldname: "module"  */
-#line 879 "hexpr.y"
+#line 915 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("module")); }
-#line 4546 "hexpr.parse.C"
+#line 4582 "hexpr.parse.C"
     break;
 
   case 279: /* recfieldname: "parse"  */
-#line 880 "hexpr.y"
+#line 916 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("parse")); }
-#line 4552 "hexpr.parse.C"
+#line 4588 "hexpr.parse.C"
     break;
 
   case 280: /* recfieldname: "do"  */
-#line 881 "hexpr.y"
+#line 917 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("do")); }
-#line 4558 "hexpr.parse.C"
+#line 4594 "hexpr.parse.C"
     break;
 
   case 281: /* recfieldname: "return"  */
-#line 882 "hexpr.y"
+#line 918 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("return")); }
-#line 4564 "hexpr.parse.C"
+#line 4600 "hexpr.parse.C"
     break;
 
   case 282: /* recfieldname: "fn"  */
-#line 883 "hexpr.y"
+#line 919 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("fn")); }
-#line 4570 "hexpr.parse.C"
+#line 4606 "hexpr.parse.C"
     break;
 
   case 283: /* recfieldname: "intV"  */
-#line 884 "hexpr.y"
+#line 920 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string(".f" + str::from((yyvsp[0].intv)))); }
-#line 4576 "hexpr.parse.C"
+#line 4612 "hexpr.parse.C"
     break;
 
   case 284: /* recfieldname: "stringV"  */
-#line 885 "hexpr.y"
+#line 921 "hexpr.y"
                          { std::string stringField = str::unescape(str::trimq(*(yyvsp[0].string)));
                            if (stringField.size() > 0 && stringField[0] == '.' ) {
                              throw annotated_error(m((yylsp[0])), "Cannot define record string label with leading '.'");
                            }
                            (yyval.string) = autorelease(new std::string(str::unescape(str::trimq(*(yyvsp[0].string))))); }
-#line 4586 "hexpr.parse.C"
+#line 4622 "hexpr.parse.C"
     break;
 
   case 285: /* recfieldpath: recfieldpath "." recfieldname  */
-#line 891 "hexpr.y"
+#line 927 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-2].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4592 "hexpr.parse.C"
+#line 4628 "hexpr.parse.C"
     break;
 
   case 286: /* recfieldpath: recfieldpath "tupSection"  */
-#line 892 "hexpr.y"
+#line 928 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-1].strings); str::seq x = tupSectionFields(*(yyvsp[0].string)); (yyval.strings)->insert((yyval.strings)->end(), x.begin(), x.end()); }
-#line 4598 "hexpr.parse.C"
+#line 4634 "hexpr.parse.C"
     break;
 
   case 287: /* recfieldpath: "." recfieldname  */
-#line 893 "hexpr.y"
+#line 929 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4604 "hexpr.parse.C"
+#line 4640 "hexpr.parse.C"
     break;
 
   case 288: /* recfieldpath: "tupSection"  */
-#line 894 "hexpr.y"
+#line 930 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); *(yyval.strings) = tupSectionFields(*(yyvsp[0].string)); }
-#line 4610 "hexpr.parse.C"
+#line 4646 "hexpr.parse.C"
     break;
 
   case 289: /* varfields: varbind  */
-#line 896 "hexpr.y"
+#line 932 "hexpr.y"
                                  { (yyval.vfields) = autorelease(new Case::Bindings()); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4616 "hexpr.parse.C"
+#line 4652 "hexpr.parse.C"
     break;
 
   case 290: /* varfields: varfields "," varbind  */
-#line 897 "hexpr.y"
+#line 933 "hexpr.y"
                                  { (yyval.vfields) = (yyvsp[-2].vfields); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4622 "hexpr.parse.C"
+#line 4658 "hexpr.parse.C"
     break;
 
   case 291: /* varbind: id "=" l0expr  */
-#line 899 "hexpr.y"
+#line 935 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-2].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4628 "hexpr.parse.C"
+#line 4664 "hexpr.parse.C"
     break;
 
   case 292: /* varbind: id ":" id "=" l0expr  */
-#line 900 "hexpr.y"
+#line 936 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-4].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4634 "hexpr.parse.C"
+#line 4670 "hexpr.parse.C"
     break;
 
   case 293: /* varbind: "intV" ":" id "=" l0expr  */
-#line 901 "hexpr.y"
+#line 937 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(".f" + str::from((yyvsp[-4].intv)), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4640 "hexpr.parse.C"
+#line 4676 "hexpr.parse.C"
     break;
 
   case 294: /* cargs: %empty  */
-#line 903 "hexpr.y"
+#line 939 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); }
-#line 4646 "hexpr.parse.C"
+#line 4682 "hexpr.parse.C"
     break;
 
   case 295: /* cargs: l0expr  */
-#line 904 "hexpr.y"
+#line 940 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4652 "hexpr.parse.C"
+#line 4688 "hexpr.parse.C"
     break;
 
   case 296: /* cargs: cargs "," l0expr  */
-#line 905 "hexpr.y"
+#line 941 "hexpr.y"
                         { (yyvsp[-2].exps)->push_back(ExprPtr((yyvsp[0].exp))); (yyval.exps) = (yyvsp[-2].exps); }
-#line 4658 "hexpr.parse.C"
+#line 4694 "hexpr.parse.C"
     break;
 
   case 297: /* qtype: cst "=>" l0mtype  */
-#line 907 "hexpr.y"
+#line 943 "hexpr.y"
                          { (yyval.qualtype) = new QualType(*(yyvsp[-2].tconstraints), *(yyvsp[0].mtype)); }
-#line 4664 "hexpr.parse.C"
+#line 4700 "hexpr.parse.C"
     break;
 
   case 298: /* qtype: l0mtype  */
-#line 908 "hexpr.y"
+#line 944 "hexpr.y"
                          { (yyval.qualtype) = new QualType(Constraints(), *(yyvsp[0].mtype)); }
-#line 4670 "hexpr.parse.C"
+#line 4706 "hexpr.parse.C"
     break;
 
   case 299: /* cst: "(" tpreds ")"  */
-#line 911 "hexpr.y"
+#line 947 "hexpr.y"
                     { (yyval.tconstraints) = (yyvsp[-1].tconstraints); }
-#line 4676 "hexpr.parse.C"
+#line 4712 "hexpr.parse.C"
     break;
 
   case 300: /* tpreds: tpred  */
-#line 913 "hexpr.y"
+#line 949 "hexpr.y"
                          { (yyval.tconstraints) = autorelease(new Constraints()); (yyval.tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); }
-#line 4682 "hexpr.parse.C"
+#line 4718 "hexpr.parse.C"
     break;
 
   case 301: /* tpreds: tpreds "," tpred  */
-#line 914 "hexpr.y"
+#line 950 "hexpr.y"
                          { (yyvsp[-2].tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); (yyval.tconstraints) = (yyvsp[-2].tconstraints); }
-#line 4688 "hexpr.parse.C"
+#line 4724 "hexpr.parse.C"
     break;
 
   case 302: /* tpred: id l1mtargl  */
-#line 916 "hexpr.y"
+#line 952 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(*(yyvsp[-1].string), *(yyvsp[0].mtypes)); }
-#line 4694 "hexpr.parse.C"
+#line 4730 "hexpr.parse.C"
     break;
 
   case 303: /* tpred: l1mtype "==" l1mtype  */
-#line 917 "hexpr.y"
+#line 953 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(EqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4700 "hexpr.parse.C"
+#line 4736 "hexpr.parse.C"
     break;
 
   case 304: /* tpred: l1mtype "!=" l1mtype  */
-#line 918 "hexpr.y"
+#line 954 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(NotEqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4706 "hexpr.parse.C"
+#line 4742 "hexpr.parse.C"
     break;
 
   case 305: /* tpred: l1mtype "~" l1mtype  */
-#line 919 "hexpr.y"
+#line 955 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(FixIsoRecur::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4712 "hexpr.parse.C"
+#line 4748 "hexpr.parse.C"
     break;
 
   case 306: /* tpred: l1mtype "=" "{" l1mtype "*" l1mtype "}"  */
-#line 920 "hexpr.y"
+#line 956 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4718 "hexpr.parse.C"
+#line 4754 "hexpr.parse.C"
     break;
 
   case 307: /* tpred: l1mtype "=" "{" id ":" l1mtype "*" l1mtype "}"  */
-#line 921 "hexpr.y"
+#line 957 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4724 "hexpr.parse.C"
+#line 4760 "hexpr.parse.C"
     break;
 
   case 308: /* tpred: l1mtype "=" "(" l1mtype "*" l1mtype ")"  */
-#line 922 "hexpr.y"
+#line 958 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4730 "hexpr.parse.C"
+#line 4766 "hexpr.parse.C"
     break;
 
   case 309: /* tpred: "{" l1mtype "*" l1mtype "}" "=" l1mtype  */
-#line 923 "hexpr.y"
+#line 959 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4736 "hexpr.parse.C"
+#line 4772 "hexpr.parse.C"
     break;
 
   case 310: /* tpred: "{" id ":" l1mtype "*" l1mtype "}" "=" l1mtype  */
-#line 924 "hexpr.y"
+#line 960 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4742 "hexpr.parse.C"
+#line 4778 "hexpr.parse.C"
     break;
 
   case 311: /* tpred: "(" l1mtype "*" l1mtype ")" "=" l1mtype  */
-#line 925 "hexpr.y"
+#line 961 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(1), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4748 "hexpr.parse.C"
+#line 4784 "hexpr.parse.C"
     break;
 
   case 312: /* tpred: l1mtype "." recfieldname "::" l1mtype  */
-#line 927 "hexpr.y"
+#line 963 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4754 "hexpr.parse.C"
+#line 4790 "hexpr.parse.C"
     break;
 
   case 313: /* tpred: l1mtype "." recfieldname "<-" l1mtype  */
-#line 928 "hexpr.y"
+#line 964 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4760 "hexpr.parse.C"
+#line 4796 "hexpr.parse.C"
     break;
 
   case 314: /* tpred: l1mtype "/" l1mtype "::" l1mtype  */
-#line 929 "hexpr.y"
+#line 965 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4766 "hexpr.parse.C"
+#line 4802 "hexpr.parse.C"
     break;
 
   case 315: /* tpred: l1mtype "/" l1mtype "<-" l1mtype  */
-#line 930 "hexpr.y"
+#line 966 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4772 "hexpr.parse.C"
+#line 4808 "hexpr.parse.C"
     break;
 
   case 316: /* tpred: l1mtype "=" "|" l1mtype "+" l1mtype "|"  */
-#line 932 "hexpr.y"
+#line 968 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4778 "hexpr.parse.C"
+#line 4814 "hexpr.parse.C"
     break;
 
   case 317: /* tpred: "|" l1mtype "+" l1mtype "|" "=" l1mtype  */
-#line 933 "hexpr.y"
+#line 969 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4784 "hexpr.parse.C"
+#line 4820 "hexpr.parse.C"
     break;
 
   case 318: /* tpred: l1mtype "=" "|" id ":" l1mtype "+" l1mtype "|"  */
-#line 934 "hexpr.y"
+#line 970 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4790 "hexpr.parse.C"
+#line 4826 "hexpr.parse.C"
     break;
 
   case 319: /* tpred: "|" id ":" l1mtype "+" l1mtype "|" "=" l1mtype  */
-#line 935 "hexpr.y"
+#line 971 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4796 "hexpr.parse.C"
+#line 4832 "hexpr.parse.C"
     break;
 
   case 320: /* tpred: "|" id ":" l0mtype "|" "::" l1mtype  */
-#line 937 "hexpr.y"
+#line 973 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), TString::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype))); }
-#line 4802 "hexpr.parse.C"
+#line 4838 "hexpr.parse.C"
     break;
 
   case 321: /* tpred: "|" l1mtype "/" l0mtype "|" "::" l1mtype  */
-#line 938 "hexpr.y"
+#line 974 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), *(yyvsp[-5].mtype),                *(yyvsp[-3].mtype))); }
-#line 4808 "hexpr.parse.C"
+#line 4844 "hexpr.parse.C"
     break;
 
   case 322: /* tpred: l1mtype "++" l1mtype "=" l1mtype  */
-#line 939 "hexpr.y"
+#line 975 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(AppendsToUnqualifier::constraintName(), list(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4814 "hexpr.parse.C"
+#line 4850 "hexpr.parse.C"
     break;
 
   case 323: /* l1mtargl: l1mtype  */
-#line 941 "hexpr.y"
+#line 977 "hexpr.y"
                            { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4820 "hexpr.parse.C"
+#line 4856 "hexpr.parse.C"
     break;
 
   case 324: /* l1mtargl: l1mtargl l1mtype  */
-#line 942 "hexpr.y"
+#line 978 "hexpr.y"
                            { (yyvsp[-1].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 4826 "hexpr.parse.C"
+#line 4862 "hexpr.parse.C"
     break;
 
   case 325: /* ltmtype: ltmtype l0mtype  */
-#line 944 "hexpr.y"
+#line 980 "hexpr.y"
                           { (yyval.mtypes) = (yyvsp[-1].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4832 "hexpr.parse.C"
+#line 4868 "hexpr.parse.C"
     break;
 
   case 326: /* ltmtype: l0mtype  */
-#line 945 "hexpr.y"
+#line 981 "hexpr.y"
                           { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4838 "hexpr.parse.C"
+#line 4874 "hexpr.parse.C"
     break;
 
   case 327: /* l0mtype: l0mtargl "->" l1mtype  */
-#line 947 "hexpr.y"
+#line 983 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(Func::make(tuplety(*(yyvsp[-2].mtypes)), *(yyvsp[0].mtype)))); }
-#line 4844 "hexpr.parse.C"
+#line 4880 "hexpr.parse.C"
     break;
 
   case 328: /* l0mtype: mtuplist  */
-#line 948 "hexpr.y"
+#line 984 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeTupleType(*(yyvsp[0].mtypes)))); }
-#line 4850 "hexpr.parse.C"
+#line 4886 "hexpr.parse.C"
     break;
 
   case 329: /* l0mtype: msumlist  */
-#line 949 "hexpr.y"
+#line 985 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeSumType(*(yyvsp[0].mtypes)))); }
-#line 4856 "hexpr.parse.C"
+#line 4892 "hexpr.parse.C"
     break;
 
   case 330: /* l1mtype: id  */
-#line 951 "hexpr.y"
+#line 987 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(monoTypeByName(*(yyvsp[0].string)))); }
-#line 4862 "hexpr.parse.C"
+#line 4898 "hexpr.parse.C"
     break;
 
   case 331: /* l1mtype: "<" cppid ">"  */
-#line 952 "hexpr.y"
+#line 988 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(OpaquePtr::make(str::replace<char>(*(yyvsp[-1].string), ".", "::"), 0, false))); }
-#line 4868 "hexpr.parse.C"
+#line 4904 "hexpr.parse.C"
     break;
 
   case 332: /* l1mtype: "[" "]"  */
-#line 953 "hexpr.y"
+#line 989 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("[]"))); }
-#line 4874 "hexpr.parse.C"
+#line 4910 "hexpr.parse.C"
     break;
 
   case 333: /* l1mtype: "[" ltmtype "]"  */
-#line 954 "hexpr.y"
+#line 990 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(Array::make(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4880 "hexpr.parse.C"
+#line 4916 "hexpr.parse.C"
     break;
 
   case 334: /* l1mtype: "[" ":" l0mtype "|" tyind ":" "]"  */
-#line 955 "hexpr.y"
+#line 991 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(FixedArray::make(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype)))); }
-#line 4886 "hexpr.parse.C"
+#line 4922 "hexpr.parse.C"
     break;
 
   case 335: /* l1mtype: "(" "->" ")"  */
-#line 956 "hexpr.y"
+#line 992 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("->"))); }
-#line 4892 "hexpr.parse.C"
+#line 4928 "hexpr.parse.C"
     break;
 
   case 336: /* l1mtype: "(" ltmtype ")"  */
-#line 957 "hexpr.y"
+#line 993 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(clone(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4898 "hexpr.parse.C"
+#line 4934 "hexpr.parse.C"
     break;
 
   case 337: /* l1mtype: "{" mreclist "}"  */
-#line 958 "hexpr.y"
+#line 994 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeRecType(*(yyvsp[-1].mreclist)))); }
-#line 4904 "hexpr.parse.C"
+#line 4940 "hexpr.parse.C"
     break;
 
   case 338: /* l1mtype: "|" mvarlist "|"  */
-#line 959 "hexpr.y"
+#line 995 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeVarType(*(yyvsp[-1].mvarlist)))); }
-#line 4910 "hexpr.parse.C"
+#line 4946 "hexpr.parse.C"
     break;
 
-  case 339: /* l1mtype: "(" ")"  */
-#line 960 "hexpr.y"
+  case 339: /* l1mtype: "|" mpvarlist "|"  */
+#line 996 "hexpr.y"
+                                           { (yyval.mtype) = autorelease(new MonoTypePtr(makePVarType(*(yyvsp[-1].mvarlist), m((yylsp[-1]))))); }
+#line 4952 "hexpr.parse.C"
+    break;
+
+  case 340: /* l1mtype: "(" ")"  */
+#line 997 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("unit"))); }
-#line 4916 "hexpr.parse.C"
+#line 4958 "hexpr.parse.C"
     break;
 
-  case 340: /* l1mtype: "intV"  */
-#line 961 "hexpr.y"
+  case 341: /* l1mtype: "intV"  */
+#line 998 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(((yyvsp[0].intv) == 0) ? Prim::make("void") : TLong::make((yyvsp[0].intv)))); }
-#line 4922 "hexpr.parse.C"
+#line 4964 "hexpr.parse.C"
     break;
 
-  case 341: /* l1mtype: "boolV"  */
-#line 962 "hexpr.y"
+  case 342: /* l1mtype: "boolV"  */
+#line 999 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr((yyvsp[0].boolv) ? TLong::make(1) : TLong::make(0))); }
-#line 4928 "hexpr.parse.C"
+#line 4970 "hexpr.parse.C"
     break;
 
-  case 342: /* l1mtype: "exists" id "." l1mtype  */
-#line 963 "hexpr.y"
+  case 343: /* l1mtype: "exists" id "." l1mtype  */
+#line 1000 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Exists::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4934 "hexpr.parse.C"
+#line 4976 "hexpr.parse.C"
     break;
 
-  case 343: /* l1mtype: l1mtype "@" l1mtype  */
-#line 964 "hexpr.y"
+  case 344: /* l1mtype: l1mtype "@" l1mtype  */
+#line 1001 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype), *(yyvsp[0].mtype)))); }
-#line 4940 "hexpr.parse.C"
+#line 4982 "hexpr.parse.C"
     break;
 
-  case 344: /* l1mtype: l1mtype "@" "?"  */
-#line 965 "hexpr.y"
+  case 345: /* l1mtype: l1mtype "@" "?"  */
+#line 1002 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype)))); }
-#line 4946 "hexpr.parse.C"
+#line 4988 "hexpr.parse.C"
     break;
 
-  case 345: /* l1mtype: "^" id "." l1mtype  */
-#line 966 "hexpr.y"
+  case 346: /* l1mtype: "^" id "." l1mtype  */
+#line 1003 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Recursive::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4952 "hexpr.parse.C"
+#line 4994 "hexpr.parse.C"
     break;
 
-  case 346: /* l1mtype: "stringV"  */
-#line 967 "hexpr.y"
+  case 347: /* l1mtype: "stringV"  */
+#line 1004 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TString::make(str::unescape(str::trimq(*(yyvsp[0].string)))))); }
-#line 4958 "hexpr.parse.C"
+#line 5000 "hexpr.parse.C"
     break;
 
-  case 347: /* l1mtype: "`" l0expr "`"  */
-#line 968 "hexpr.y"
+  case 348: /* l1mtype: "`" l0expr "`"  */
+#line 1005 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TApp::make(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp))))))); }
-#line 4964 "hexpr.parse.C"
+#line 5006 "hexpr.parse.C"
     break;
 
-  case 348: /* tyind: id  */
-#line 970 "hexpr.y"
+  case 349: /* tyind: id  */
+#line 1007 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TVar::make(*(yyvsp[0].string)))); }
-#line 4970 "hexpr.parse.C"
+#line 5012 "hexpr.parse.C"
     break;
 
-  case 349: /* tyind: "intV"  */
-#line 971 "hexpr.y"
+  case 350: /* tyind: "intV"  */
+#line 1008 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TLong::make((yyvsp[0].intv)))); }
-#line 4976 "hexpr.parse.C"
+#line 5018 "hexpr.parse.C"
     break;
 
-  case 350: /* cppid: id  */
-#line 973 "hexpr.y"
+  case 351: /* cppid: id  */
+#line 1010 "hexpr.y"
                     { (yyval.string) = (yyvsp[0].string); }
-#line 4982 "hexpr.parse.C"
+#line 5024 "hexpr.parse.C"
     break;
 
-  case 351: /* cppid: cppid "." id  */
-#line 974 "hexpr.y"
+  case 352: /* cppid: cppid "." id  */
+#line 1011 "hexpr.y"
                     { (yyval.string) = (yyvsp[-2].string); *(yyval.string) += "."; *(yyval.string) += *(yyvsp[0].string); }
-#line 4988 "hexpr.parse.C"
+#line 5030 "hexpr.parse.C"
     break;
 
-  case 352: /* l0mtargl: l1mtype  */
-#line 976 "hexpr.y"
+  case 353: /* l0mtargl: l1mtype  */
+#line 1013 "hexpr.y"
                                         { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4994 "hexpr.parse.C"
+#line 5036 "hexpr.parse.C"
     break;
 
-  case 353: /* l0mtargl: "(" l0mtype "," l0mtarglt ")"  */
-#line 977 "hexpr.y"
+  case 354: /* l0mtargl: "(" l0mtype "," l0mtarglt ")"  */
+#line 1014 "hexpr.y"
                                         { (yyvsp[-1].mtypes)->insert((yyvsp[-1].mtypes)->begin(), *(yyvsp[-3].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 5000 "hexpr.parse.C"
+#line 5042 "hexpr.parse.C"
     break;
 
-  case 354: /* l0mtarglt: l0mtype  */
-#line 979 "hexpr.y"
+  case 355: /* l0mtarglt: l0mtype  */
+#line 1016 "hexpr.y"
                                  { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5006 "hexpr.parse.C"
+#line 5048 "hexpr.parse.C"
     break;
 
-  case 355: /* l0mtarglt: l0mtarglt "," l0mtype  */
-#line 980 "hexpr.y"
+  case 356: /* l0mtarglt: l0mtarglt "," l0mtype  */
+#line 1017 "hexpr.y"
                                  { (yyvsp[-2].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-2].mtypes); }
-#line 5012 "hexpr.parse.C"
+#line 5054 "hexpr.parse.C"
     break;
 
-  case 356: /* mtuplist: l1mtype  */
-#line 982 "hexpr.y"
+  case 357: /* mtuplist: l1mtype  */
+#line 1019 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5018 "hexpr.parse.C"
+#line 5060 "hexpr.parse.C"
     break;
 
-  case 357: /* mtuplist: mtuplist "*" l1mtype  */
-#line 983 "hexpr.y"
+  case 358: /* mtuplist: mtuplist "*" l1mtype  */
+#line 1020 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5024 "hexpr.parse.C"
+#line 5066 "hexpr.parse.C"
     break;
 
-  case 358: /* msumlist: l1mtype "+" l1mtype  */
-#line 985 "hexpr.y"
+  case 359: /* msumlist: l1mtype "+" l1mtype  */
+#line 1022 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[-2].mtype)); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5030 "hexpr.parse.C"
+#line 5072 "hexpr.parse.C"
     break;
 
-  case 359: /* msumlist: msumlist "+" l1mtype  */
-#line 986 "hexpr.y"
+  case 360: /* msumlist: msumlist "+" l1mtype  */
+#line 1023 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5036 "hexpr.parse.C"
+#line 5078 "hexpr.parse.C"
     break;
 
-  case 360: /* mreclist: mreclist "," id ":" l0mtype  */
-#line 988 "hexpr.y"
+  case 361: /* mreclist: mreclist "," id ":" l0mtype  */
+#line 1025 "hexpr.y"
                                       { (yyval.mreclist) = (yyvsp[-4].mreclist);                                 (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 5042 "hexpr.parse.C"
+#line 5084 "hexpr.parse.C"
     break;
 
-  case 361: /* mreclist: id ":" l0mtype  */
-#line 989 "hexpr.y"
+  case 362: /* mreclist: id ":" l0mtype  */
+#line 1026 "hexpr.y"
                                       { (yyval.mreclist) = autorelease(new Record::Members()); (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 5048 "hexpr.parse.C"
+#line 5090 "hexpr.parse.C"
     break;
 
-  case 362: /* mvarlist: mvarlist "," id ":" l0mtype  */
-#line 991 "hexpr.y"
+  case 363: /* mvarlist: mvarlist "," id ":" l0mtype  */
+#line 1028 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-4].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 5054 "hexpr.parse.C"
+#line 5096 "hexpr.parse.C"
     break;
 
-  case 363: /* mvarlist: mvarlist "," id  */
-#line 992 "hexpr.y"
+  case 364: /* mvarlist: mvarlist "," id  */
+#line 1029 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-2].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 5060 "hexpr.parse.C"
+#line 5102 "hexpr.parse.C"
     break;
 
-  case 364: /* mvarlist: id ":" l0mtype  */
-#line 993 "hexpr.y"
+  case 365: /* mvarlist: id ":" l0mtype  */
+#line 1030 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 5066 "hexpr.parse.C"
+#line 5108 "hexpr.parse.C"
     break;
 
-  case 365: /* mvarlist: id  */
-#line 994 "hexpr.y"
+  case 366: /* mvarlist: id  */
+#line 1031 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 5072 "hexpr.parse.C"
+#line 5114 "hexpr.parse.C"
+    break;
+
+  case 367: /* mpvarlist: mpvarlist "," mpvar  */
+#line 1033 "hexpr.y"
+                               { (yyval.mvarlist) = (yyvsp[-2].mvarlist);                                  (yyval.mvarlist)->push_back(*(yyvsp[0].mpvar)); }
+#line 5120 "hexpr.parse.C"
+    break;
+
+  case 368: /* mpvarlist: mpvar  */
+#line 1034 "hexpr.y"
+                               { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(*(yyvsp[0].mpvar)); }
+#line 5126 "hexpr.parse.C"
+    break;
+
+  case 369: /* mpvar: id "(" "intV" ")"  */
+#line 1036 "hexpr.y"
+                           { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].intv))); }
+#line 5132 "hexpr.parse.C"
+    break;
+
+  case 370: /* mpvar: id "(" "shortV" ")"  */
+#line 1037 "hexpr.y"
+                           { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].shortv))); }
+#line 5138 "hexpr.parse.C"
+    break;
+
+  case 371: /* mpvar: id "(" "boolV" ")"  */
+#line 1038 "hexpr.y"
+                           { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].boolv))); }
+#line 5144 "hexpr.parse.C"
+    break;
+
+  case 372: /* mpvar: id "(" "byteV" ")"  */
+#line 1039 "hexpr.y"
+                           { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), str::dehex(*(yyvsp[-1].string)))); }
+#line 5150 "hexpr.parse.C"
+    break;
+
+  case 373: /* mpvar: id "(" "charV" ")"  */
+#line 1040 "hexpr.y"
+                           { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), str::readCharDef(*(yyvsp[-1].string)))); }
+#line 5156 "hexpr.parse.C"
     break;
 
 
-#line 5076 "hexpr.parse.C"
+#line 5160 "hexpr.parse.C"
 
       default: break;
     }
@@ -5302,7 +5386,7 @@ yyreturn:
   return yyresult;
 }
 
-#line 998 "hexpr.y"
+#line 1044 "hexpr.y"
 
 #pragma GCC diagnostic pop
 
diff --git a/lib/hobbes/read/pgen/hexpr.y b/lib/hobbes/read/pgen/hexpr.y
index 6284c0a4d..9406ff357 100644
--- a/lib/hobbes/read/pgen/hexpr.y
+++ b/lib/hobbes/read/pgen/hexpr.y
@@ -229,6 +229,39 @@ MonoTypePtr makeRecType(const Record::Members& tms) {
   return Record::make(tms);
 }
 
+static MonoTypePtr makePVarTypeImp(const Variant::Members &vms,
+                                   const LexicalAnnotation *la) {
+  const auto sanityCheck = [&] {
+    auto tvms = vms;
+    std::sort(tvms.begin(), tvms.end(),
+              [](const auto &a, const auto &b) { return a.id < b.id; });
+    const auto it = std::adjacent_find(
+        tvms.cbegin(), tvms.cend(),
+        [](const auto &a, const auto &b) { return a.id == b.id; });
+    if (it != tvms.cend()) {
+      const auto es =
+          "penum has duplicated value(" + std::to_string(it->id) + ")";
+      if (la != nullptr) {
+        throw annotated_error(*la, es);
+      } else {
+        throw std::runtime_error(es);
+      }
+    }
+  };
+
+  sanityCheck();
+  return Variant::make(vms);
+}
+
+MonoTypePtr makePVarType(const Variant::Members &vms) {
+  return makePVarTypeImp(vms, nullptr);
+}
+
+MonoTypePtr makePVarType(const Variant::Members &vms,
+                         const LexicalAnnotation &la) {
+  return makePVarTypeImp(vms, &la);
+}
+
 MonoTypePtr makeVarType(const Variant::Members& vms) {
   Variant::Members tvms = vms;
   for (unsigned int i = 0; i < tvms.size(); ++i) {
@@ -299,6 +332,7 @@ extern PatVarCtorFn patVarCtorFn;
   hobbes::MonoTypes*           mtypes;
   hobbes::Record::Members*     mreclist;
   hobbes::Variant::Members*    mvarlist;
+  hobbes::Variant::Member*     mpvar;
 
   std::string*                            string;
   bool                                    boolv;
@@ -433,6 +467,8 @@ extern PatVarCtorFn patVarCtorFn;
 %type <mtypes>       types mtuplist msumlist
 %type <mreclist>     mreclist
 %type <mvarlist>     mvarlist
+%type <mvarlist>     mpvarlist
+%type <mpvar>        mpvar
 
 %type <exp>          l0expr lhexpr l1expr l2expr l3expr l4expr l5expr l6expr
 %type <exps>         l6exprs cargs cselconds
@@ -957,6 +993,7 @@ l1mtype: id                                { $$ = autorelease(new MonoTypePtr(mo
        | "(" ltmtype ")"                   { try { $$ = autorelease(new MonoTypePtr(clone(yyParseCC->replaceTypeAliases(accumTApp(*$2))))); } catch (std::exception& ex) { throw annotated_error(m(@2), ex.what()); } }
        | "{" mreclist "}"                  { $$ = autorelease(new MonoTypePtr(makeRecType(*$2))); }
        | "|" mvarlist "|"                  { $$ = autorelease(new MonoTypePtr(makeVarType(*$2))); }
+       | "|" mpvarlist "|"                 { $$ = autorelease(new MonoTypePtr(makePVarType(*$2, m(@2)))); }
        | "(" ")"                           { $$ = autorelease(new MonoTypePtr(Prim::make("unit"))); }
        | "intV"                            { $$ = autorelease(new MonoTypePtr(($1 == 0) ? Prim::make("void") : TLong::make($1))); }
        | "boolV"                           { $$ = autorelease(new MonoTypePtr($1 ? TLong::make(1) : TLong::make(0))); }
@@ -993,6 +1030,15 @@ mvarlist: mvarlist "," id ":" l0mtype { $$ = $1;
         | id ":" l0mtype              { $$ = autorelease(new Variant::Members()); $$->push_back(Variant::Member(*$1, *$3,                0)); }
         | id                          { $$ = autorelease(new Variant::Members()); $$->push_back(Variant::Member(*$1, Prim::make("unit"), 0)); }
 
+mpvarlist: mpvarlist "," mpvar { $$ = $1;                                  $$->push_back(*$3); }
+         | mpvar               { $$ = autorelease(new Variant::Members()); $$->push_back(*$1); }
+
+mpvar: id "(" "intV" ")"   { $$ = autorelease(new Variant::Member(*$1, Prim::make("unit"), $3)); }
+     | id "(" "shortV" ")" { $$ = autorelease(new Variant::Member(*$1, Prim::make("unit"), $3)); }
+     | id "(" "boolV" ")"  { $$ = autorelease(new Variant::Member(*$1, Prim::make("unit"), $3)); }
+     | id "(" "byteV" ")"  { $$ = autorelease(new Variant::Member(*$1, Prim::make("unit"), str::dehex(*$3))); }
+     | id "(" "charV" ")"  { $$ = autorelease(new Variant::Member(*$1, Prim::make("unit"), str::readCharDef(*$3))); }
+
 id: TIDENT;
 
 %%
diff --git a/lib/hobbes/read/pgen/pgen.sh b/lib/hobbes/read/pgen/pgen.sh
index 86c61f710..6e3f742ad 100755
--- a/lib/hobbes/read/pgen/pgen.sh
+++ b/lib/hobbes/read/pgen/pgen.sh
@@ -4,6 +4,7 @@ cd `dirname ${BASH_SOURCE[0]}`
 
 # generate the LALR(1) parser and token definitions
 ${BISON:-bison} -d -ohexpr.parse.C hexpr.y
+sed -i 's,#include "hexpr.parse.H",//&,' hexpr.parse.C
 
 # obey internal convention for division of source and header files
 mv hexpr.parse.H ../../../../include/hobbes/read/pgen/
diff --git a/test/Variants.C b/test/Variants.C
index 649375941..8e6c3d2d6 100644
--- a/test/Variants.C
+++ b/test/Variants.C
@@ -132,3 +132,144 @@ TEST(Variants, Trunc) {
   EXPECT_TRUE(c().compileFn<bool()>("trunc(|Red=42|::|Blue:[char],Red:int,Green:(double*double)|)===|Red|")());
 }
 
+template <typename T, T v0, T v1, T v2> struct PEnumBase {
+  static constexpr bool is_hmeta_enum = true;
+  using rep_t = T;
+  enum class Enum : T { e0 = v0, e1 = v1, e2 = v2 };
+  Enum value;
+  PEnumBase() : value(Enum::e0) {}
+  explicit PEnumBase(Enum e) : value(e) {}
+  static std::vector<std::pair<std::string, T>> meta() {
+    return {std::make_pair("e0", v0), std::make_pair("e1", v1),
+            std::make_pair("e2", v2)};
+  }
+};
+
+struct PECharNContinous : PEnumBase<char, '0', '1', '2'> {};
+static_assert(sizeof(PECharNContinous::rep_t) == sizeof(PECharNContinous), "");
+DEFINE_PACKED_ENUM(PECharContinous, char, (e0), (e1), (e2));
+DEFINE_STRUCT(SP_C_Char, (PECharContinous, pe), (PECharNContinous, pen),
+              (int, x));
+
+namespace hobbes {
+template<> struct lift<PECharContinous *, false>
+    : liftEnum<PECharContinous, PECharContinous::rep_t> {};
+template<> struct lift<PECharNContinous *, false>
+    : liftEnum<PECharNContinous, PECharNContinous::rep_t> {};
+} // namespace hobbes
+
+TEST(Variants, PEnumsChar) {
+  struct PECharNFail : PEnumBase<char, '2', '4', '2'> {};
+  PECharNFail penf;
+  // raise from liftEnum
+  EXPECT_EXCEPTION_MSG((c().compileFn<const array<char>*(PECharNFail)>("x", "show(x)")(PECharNFail{})), std::exception, "(50)"); // 50 == '2';
+
+  SP_C_Char spcc;
+  spcc.pe.value = PECharContinous::Enum::e2;
+  spcc.pen.value = PECharNContinous::Enum::e1;
+  spcc.x = 42;
+
+  cc x;
+  x.bind("spcc", &spcc);
+  compile(&x, x.readModule(R"(
+type e012 = ((penum char |e0('0'), e1('1'), e2('2')|))
+
+newpen :: e012
+newpen = unsafeCast('0')::e012
+)"));
+
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pe) == \"|e2|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e1|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc) == \"{pe=|e2|, pen=|e1|, x=42}\"")());
+
+  // show with pre-defined type
+  EXPECT_TRUE(x.compileFn<bool()>("show(|e1|::e012) == \"|e1|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast('2')::e012) == \"|e2|\"")());
+
+  // show with type defined on the fly
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast('A')::((penum char |AP('A'), BP('B')|))) == \"|AP|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(|CP|::((penum char |CP(3), DP(4), EP(5)|))) == \"|CP|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast(unsafeCast(0X01)::char)::((penum char |AN, BN|))) == \"|BN|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(|CN|::((penum char |CN, DN, EN|))) == \"|CN|\"")());
+
+  // either all or none have custom defined values
+  EXPECT_EXCEPTION_MSG(x.compileFn<void()>("let _ = |FP|::((penum char |FP('F'), GP, HP('H')|)) in ()")(), std::exception, R"(syntax error, unexpected ",", expecting ()");
+
+  // value must be unique
+  EXPECT_EXCEPTION_MSG(x.compileFn<void()>("let _ = |GN|::((penum char |FN('O'), GN('P'), HN('O')|)) in ()")(), std::exception, "(79)"); // 79 == 'O'
+
+  // write to a penum defined in C++ land
+  x.compileFn<void()>("spcc.pen <- unsafeCast('2')::e012")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e2|\"")());
+  x.compileFn<void()>("spcc.pen <- |e1|::e012")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e1|\"")());
+
+  // write to a penum defined in hobbes
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e0|\"")());
+  x.compileFn<void()>("newpen <- unsafeCast('1')::e012")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e1|\"")());
+  x.compileFn<void()>("newpen <- |e2|::e012")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e2|\"")());
+}
+
+struct PEShortNContinous : PEnumBase<short, 3, 4, 7> {};
+static_assert(sizeof(PEShortNContinous::rep_t) == sizeof(PEShortNContinous), "");
+DEFINE_PACKED_ENUM(PEShortContinous, short, (e0), (e1), (e2));
+DEFINE_STRUCT(SP_C_Short, (PEShortContinous, pe), (PEShortNContinous, pen),
+              (int, x));
+
+namespace hobbes {
+template<> struct lift<PEShortContinous *, false>
+    : liftEnum<PEShortContinous, PEShortContinous::rep_t> {};
+template<> struct lift<PEShortNContinous *, false>
+    : liftEnum<PEShortNContinous, PEShortNContinous::rep_t> {};
+} // namespace hobbes
+
+TEST(Variants, PEnumsShort) {
+  SP_C_Short spcc;
+  spcc.pe.value = PEShortContinous::Enum::e2;
+  spcc.pen.value = PEShortNContinous::Enum::e1;
+  spcc.x = 42;
+
+  cc x;
+  x.bind("spcc", &spcc);
+  compile(&x, x.readModule(R"(
+type e347 = ((penum short |e0(3), e1(4), e2(7)|))
+
+newpen :: e347
+newpen = unsafeCast(3S)::e347
+)"));
+
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pe) == \"|e2|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e1|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc) == \"{pe=|e2|, pen=|e1|, x=42}\"")());
+
+  // show with pre-defined type
+  EXPECT_TRUE(x.compileFn<bool()>("show(|e1|::e347) == \"|e1|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast(7S)::e347) == \"|e2|\"")());
+
+  // show with type defined on the fly
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast(1S)::((penum short |AP(1), BP(2)|))) == \"|AP|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(|CP|::((penum short |CP(3), DP(4), EP(5)|))) == \"|CP|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(unsafeCast(1S)::((penum short |AN, BN|))) == \"|BN|\"")());
+  EXPECT_TRUE(x.compileFn<bool()>("show(|CN|::((penum short |CN, DN, EN|))) == \"|CN|\"")());
+
+  // either all or none have custom defined values
+  EXPECT_EXCEPTION_MSG(x.compileFn<void()>("let _ = |FP|::((penum char |FP(3), GP, HP(5)|)) in ()")(), std::exception, R"(syntax error, unexpected ",", expecting ()");
+
+  // value must be unique
+  EXPECT_EXCEPTION_MSG(x.compileFn<void()>("let _ = |GN|::((penum short |FN(79), GN(80), HN(79)|)) in ()")(), std::exception, "(79)");
+
+  // write to a penum defined in C++ land
+  x.compileFn<void()>("spcc.pen <- unsafeCast(7S)::e347")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e2|\"")());
+  x.compileFn<void()>("spcc.pen <- |e1|::e347")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(spcc.pen) == \"|e1|\"")());
+
+  // write to a penum defined in hobbes
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e0|\"")());
+  x.compileFn<void()>("newpen <- unsafeCast(4S)::e347")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e1|\"")());
+  x.compileFn<void()>("newpen <- |e2|::e347")();
+  EXPECT_TRUE(x.compileFn<bool()>("show(newpen) == \"|e2|\"")());
+}
diff --git a/test/test.H b/test/test.H
index 6d9426a64..d2e00de93 100644
--- a/test/test.H
+++ b/test/test.H
@@ -160,5 +160,28 @@ private:
     } \
   }
 
+#define EXPECT_EXCEPTION_MSG(p, E, S) \
+  { \
+    bool exp = false; \
+    const std::string s = S; \
+    try { \
+      (p); \
+    } catch (const E& e) { \
+      const std::string es = e.what(); \
+      if (es.find(s) != std::string::npos) { \
+        exp = true; \
+      } \
+    } \
+    if (!exp) { \
+      std::ostringstream errmsg; \
+      errmsg << "Expression '" #p "' expects a '" #E; \
+      if (!s.empty()) { \
+        errmsg << "' which contains string '" #S; \
+      } \
+      errmsg << "' at " << " " << FILEINFO(__FILE__, __LINE__); \
+      throw std::runtime_error(errmsg.str()); \
+    } \
+  }
+
 #endif
 

From 2029c661a463e5cba353bf7af7c7edcf24feacc8 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Tue, 5 Oct 2021 02:41:17 +0000
Subject: [PATCH 20/40] auto fixes from clang tidy for readability and
 possble(?) performance gain (#426)

* cppcoreguidelines-explicit-virtual-functions

* modernize-use-auto

* unused typedef causes build fail in gcc10

* readability-implicit-bool-conversion

* modernize-use-using

* modernize-use-nullptr

* readability-container-size-empty

* hicpp-use-equals-default

* readability-simplify-boolean-expr

* hicpp-noexcept-move

* performance-for-range-copy

* bugprone-reserved-identifier

* modernize-avoid-bind

* modernize-deprecated-headers

* modernize-loop-convert

* modernize-make-shared

* modernize-make-unique

* modernize-redundant-void-arg

* modernize-return-braced-init-list

* modernize-use-emplace

* modernize-use-equals-delete

* modernize-use-noexcept

* modernize-use-transparent-functors

* performance-faster-string-find

* performance-unnecessary-value-param

* readability-const-return-type

* readability-make-member-function-const

* readability-qualified-auto

* readability-redundant-string-cstr

* readability-redundant-member-init,readability-redundant-string-init

* modernize c++ part of hexpr.y

* fix build failure
---
 bin/hi/cio.H                                  |  18 +-
 bin/hi/evaluator.C                            |  43 +-
 bin/hi/evaluator.H                            |   6 +-
 bin/hi/funcdefs.C                             |  20 +-
 bin/hi/main.C                                 |  56 +-
 bin/hi/www.C                                  |  33 +-
 bin/hi/www.H                                  |  10 +-
 bin/hog/batchrecv.C                           |   6 +-
 bin/hog/batchsend.C                           |  41 +-
 bin/hog/boot/gen/boot.C                       |   2 +-
 bin/hog/boot/gen/bootdata.H                   |   4 +-
 bin/hog/config.C                              |   4 +-
 bin/hog/config.H                              |   2 +-
 bin/hog/local.C                               |   2 +-
 bin/hog/main.C                                |   8 +-
 bin/hog/netconnection.C                       |   2 +-
 bin/hog/path.C                                |   2 +-
 bin/hog/recovery.C                            |   8 +-
 bin/hog/session.C                             |  38 +-
 bin/hog/session.H                             |   2 +-
 include/hobbes/boot/gen/bootdata.H            | 212 ++++----
 include/hobbes/cfregion.H                     | 176 ++++---
 include/hobbes/convert.H                      |  36 +-
 include/hobbes/db/file.H                      |  56 +-
 include/hobbes/db/series.H                    |  14 +-
 include/hobbes/eval/cc.H                      |  47 +-
 include/hobbes/eval/cmodule.H                 |   2 +-
 include/hobbes/eval/func.H                    |   6 +-
 include/hobbes/eval/jitcc.H                   |  12 +-
 include/hobbes/eval/search.H                  |   2 +-
 include/hobbes/events/events.H                |   4 +-
 include/hobbes/events/httpd.H                 |   8 +-
 include/hobbes/fregion.H                      | 161 +++---
 include/hobbes/ipc/net.H                      |  16 +-
 include/hobbes/ipc/prepl.H                    |   2 +-
 include/hobbes/ipc/process.H                  |  16 +-
 include/hobbes/ipc/procman.H                  |  12 +-
 include/hobbes/lang/constraints.H             |   2 +-
 include/hobbes/lang/expr.H                    | 490 +++++++++---------
 include/hobbes/lang/module.H                  |  64 +--
 include/hobbes/lang/pat/dfa.H                 |  60 +--
 include/hobbes/lang/pat/pattern.H             |  58 +--
 include/hobbes/lang/pat/regex.H               |  18 +-
 include/hobbes/lang/preds/appendsto.H         |  16 +-
 include/hobbes/lang/preds/appendsto/record.H  |  12 +-
 include/hobbes/lang/preds/class.H             |  46 +-
 include/hobbes/lang/preds/consrecord.H        |  16 +-
 include/hobbes/lang/preds/consvariant.H       |  16 +-
 include/hobbes/lang/preds/cpptdesc.H          |  16 +-
 include/hobbes/lang/preds/data.H              |  16 +-
 include/hobbes/lang/preds/deconstruct.H       |  16 +-
 include/hobbes/lang/preds/equal.H             |  16 +-
 include/hobbes/lang/preds/hasctor.H           |  16 +-
 include/hobbes/lang/preds/hasctor/variant.H   |  10 +-
 include/hobbes/lang/preds/hasfield.H          |  16 +-
 include/hobbes/lang/preds/hasfield/lookup.H   |  10 +-
 include/hobbes/lang/preds/hasfield/record.H   |  10 +-
 include/hobbes/lang/preds/hasfield/slookup.H  |  10 +-
 .../hobbes/lang/preds/hasfield/tenvlookup.H   |  10 +-
 include/hobbes/lang/preds/loadref.H           |  16 +-
 include/hobbes/lang/preds/not.H               |  16 +-
 include/hobbes/lang/preds/packsto.H           |  16 +-
 include/hobbes/lang/preds/recty.H             |  16 +-
 include/hobbes/lang/preds/sizeof.H            |  16 +-
 include/hobbes/lang/preds/subtype.H           |  16 +-
 include/hobbes/lang/preds/subtype/obj.H       |  22 +-
 include/hobbes/lang/preds/typeof.H            |  16 +-
 include/hobbes/lang/preds/vapp.H              |  16 +-
 include/hobbes/lang/preds/vtrunc.H            |  16 +-
 include/hobbes/lang/tylift.H                  |  32 +-
 include/hobbes/lang/type.H                    | 236 ++++-----
 include/hobbes/lang/typeinf.H                 |   8 +-
 include/hobbes/lang/typemap.H                 |  20 +-
 include/hobbes/lang/tyunqualify.H             |  32 +-
 include/hobbes/mc/encode.H                    | 116 ++---
 include/hobbes/mc/liveness.H                  |  39 +-
 include/hobbes/mc/regalloc.H                  |  60 +--
 include/hobbes/net.H                          | 118 ++---
 include/hobbes/parse/data.H                   |  17 +-
 include/hobbes/parse/grammar.H                |  20 +-
 include/hobbes/parse/lalr.H                   |  48 +-
 include/hobbes/parse/parser.H                 |   6 +-
 include/hobbes/parse/terminal.H               |  24 +-
 include/hobbes/read/parser.H                  |   6 +-
 include/hobbes/reflect.H                      | 170 +++---
 include/hobbes/slmap.H                        |  40 +-
 include/hobbes/storage.H                      | 185 ++++---
 include/hobbes/util/array.H                   |  34 +-
 include/hobbes/util/autorelease.H             |  12 +-
 include/hobbes/util/codec.H                   |  12 +-
 include/hobbes/util/func.H                    |  20 +-
 include/hobbes/util/lannotation.H             |  16 +-
 include/hobbes/util/llvm.H                    |  52 +-
 include/hobbes/util/perf.H                    |  10 +-
 include/hobbes/util/ptr.H                     |  12 +-
 include/hobbes/util/rmap.H                    |  12 +-
 include/hobbes/util/str.H                     |  30 +-
 include/hobbes/util/stream.H                  |  32 +-
 include/hobbes/util/time.H                    |  12 +-
 include/hobbes/util/trie.H                    |  28 +-
 include/hobbes/util/unionfind.H               |   8 +-
 lib/hobbes/boot/bootgen.sh                    |  14 +-
 lib/hobbes/boot/gen/boot.C                    |   2 +-
 lib/hobbes/db/bindings.C                      | 179 +++----
 lib/hobbes/db/cbindings.C                     |  39 +-
 lib/hobbes/db/file.C                          |  22 +-
 lib/hobbes/db/series.C                        |  52 +-
 lib/hobbes/db/signals.C                       |  80 +--
 lib/hobbes/eval/cc.C                          |  59 +--
 lib/hobbes/eval/cexpr.C                       | 276 +++++-----
 lib/hobbes/eval/cmodule.C                     | 185 ++++---
 lib/hobbes/eval/ctype.C                       |  52 +-
 lib/hobbes/eval/func.C                        | 136 ++---
 lib/hobbes/eval/funcdefs.C                    |  26 +-
 lib/hobbes/eval/jitcc.C                       |  56 +-
 lib/hobbes/eval/search.C                      |  80 +--
 lib/hobbes/events/events.C                    |  14 +-
 lib/hobbes/events/httpd.C                     |  22 +-
 lib/hobbes/ipc/nbindings.C                    | 134 ++---
 lib/hobbes/ipc/net.C                          |  38 +-
 lib/hobbes/ipc/prepl.C                        |  52 +-
 lib/hobbes/ipc/process.C                      |  14 +-
 lib/hobbes/ipc/procman.C                      |  33 +-
 lib/hobbes/lang/closcvt.C                     |  16 +-
 lib/hobbes/lang/constraints.C                 |  11 +-
 lib/hobbes/lang/expr.C                        | 422 +++++++--------
 lib/hobbes/lang/macroexpand.C                 |  42 +-
 lib/hobbes/lang/module.C                      |  39 +-
 lib/hobbes/lang/pat/dfa.C                     | 216 ++++----
 lib/hobbes/lang/pat/pattern.C                 | 140 ++---
 lib/hobbes/lang/pat/print.C                   |   6 +-
 lib/hobbes/lang/pat/regex.C                   | 103 ++--
 lib/hobbes/lang/preds/appendsto.C             |  18 +-
 lib/hobbes/lang/preds/appendsto/record.C      |  47 +-
 lib/hobbes/lang/preds/class.C                 | 127 ++---
 lib/hobbes/lang/preds/consrecord.C            |  35 +-
 lib/hobbes/lang/preds/consvariant.C           |  25 +-
 lib/hobbes/lang/preds/cpptdesc.C              |  51 +-
 lib/hobbes/lang/preds/data.C                  |   4 +-
 lib/hobbes/lang/preds/deconstruct.C           |  46 +-
 lib/hobbes/lang/preds/equal.C                 |   2 +-
 lib/hobbes/lang/preds/hasctor.C               |  12 +-
 lib/hobbes/lang/preds/hasctor/variant.C       |   8 +-
 lib/hobbes/lang/preds/hasfield.C              |   6 +-
 lib/hobbes/lang/preds/hasfield/lookup.C       |  13 +-
 lib/hobbes/lang/preds/hasfield/record.C       |  12 +-
 lib/hobbes/lang/preds/hasfield/slookup.C      |  17 +-
 lib/hobbes/lang/preds/hasfield/tenvlookup.C   |  32 +-
 lib/hobbes/lang/preds/loadref.C               |  21 +-
 lib/hobbes/lang/preds/not.C                   |   2 +-
 lib/hobbes/lang/preds/packsto.C               |  16 +-
 lib/hobbes/lang/preds/recty.C                 |  21 +-
 lib/hobbes/lang/preds/sizeof.C                |   9 +-
 lib/hobbes/lang/preds/str.C                   |  46 +-
 lib/hobbes/lang/preds/subtype.C               |  21 +-
 lib/hobbes/lang/preds/subtype/obj.C           |  71 +--
 lib/hobbes/lang/preds/typeof.C                |   2 +-
 lib/hobbes/lang/preds/vapp.C                  |  23 +-
 lib/hobbes/lang/preds/vtrunc.C                |  17 +-
 lib/hobbes/lang/type.C                        | 476 ++++++++---------
 lib/hobbes/lang/typeinf.C                     | 209 ++++----
 lib/hobbes/lang/typemap.C                     |  50 +-
 lib/hobbes/lang/typepreds.C                   |  26 +-
 lib/hobbes/lang/tyunqualify.C                 |   4 +-
 lib/hobbes/parse/data.C                       |   2 +-
 lib/hobbes/parse/grammar.C                    |   6 +-
 lib/hobbes/parse/lalr.C                       | 211 ++++----
 lib/hobbes/parse/parser.C                     |  13 +-
 lib/hobbes/parse/terminal.C                   |   2 +-
 lib/hobbes/read/parser.C                      |  36 +-
 lib/hobbes/read/pgen/hexpr.lex.C              |  10 +-
 lib/hobbes/read/pgen/hexpr.parse.C            |  40 +-
 lib/hobbes/read/pgen/hexpr.y                  |  40 +-
 lib/hobbes/util/lannotation.C                 |  28 +-
 lib/hobbes/util/region.C                      |  40 +-
 lib/hobbes/util/str.C                         |  68 +--
 test/Arrays.C                                 |   4 +-
 test/Compiler.C                               |  31 +-
 test/Convert.C                                |   6 +-
 test/Definitions.C                            |   2 +-
 test/MC.C                                     |   2 +-
 test/Main.C                                   |   4 +-
 test/Net.C                                    |  14 +-
 test/Objects.C                                |  16 +-
 test/Prelude.C                                |   2 +-
 test/Python.C                                 |   4 +-
 test/Storage.C                                |  36 +-
 test/Structs.C                                |  10 +-
 test/TypeInf.C                                |   5 +-
 test/Variants.C                               |  14 +-
 test/test.H                                   |  10 +-
 191 files changed, 4156 insertions(+), 4195 deletions(-)

diff --git a/bin/hi/cio.H b/bin/hi/cio.H
index 073e356c2..7a6b243ab 100644
--- a/bin/hi/cio.H
+++ b/bin/hi/cio.H
@@ -7,7 +7,7 @@
 namespace hi {
 
 // controls display options
-typedef unsigned char color;
+using color = unsigned char;
 
 DEFINE_STRUCT(ConsoleColors,
   (color, promptfg),
@@ -62,13 +62,13 @@ inline void sendCmd(std::ostream& out, int n0, int n1, int n2, char c) {
   }
 }
 
-struct setbold { setbold() { } };
+struct setbold {};
 inline std::ostream& operator<<(std::ostream& lhs, const setbold&) {
   sendCmd(lhs, 1, 'm');
   return lhs;
 }
 
-struct setunderline { setunderline() { } };
+struct setunderline {};
 inline std::ostream& operator<<(std::ostream& lhs, const setunderline&) {
   sendCmd(lhs, 4, 'm');
   return lhs;
@@ -103,18 +103,14 @@ inline std::ostream& operator<<(std::ostream& lhs, const setbgc& c) {
   return lhs;
 }
 
-struct resetfmt {
-  resetfmt() { }
-};
+struct resetfmt {};
 
 inline std::ostream& operator<<(std::ostream& lhs, const resetfmt&) {
   sendCmd(lhs, 0, 'm');
   return lhs;
 }
 
-struct clearscr {
-  clearscr() { }
-};
+struct clearscr {};
 
 inline std::ostream& operator<<(std::ostream& lhs, const clearscr&) {
   sendCmd(lhs, 2, 'J');
@@ -151,13 +147,13 @@ inline std::ostream& operator<<(std::ostream& lhs, const movecursor& mc) {
   return lhs;
 }
 
-struct eraseToEOL { eraseToEOL() { } };
+struct eraseToEOL {};
 inline std::ostream& operator<<(std::ostream& lhs, const eraseToEOL&) {
   sendCmd(lhs, 0, 'K');
   return lhs;
 }
 
-struct clearline { clearline() { } };
+struct clearline {};
 inline std::ostream& operator<<(std::ostream& lhs, const clearline&) {
   sendCmd(lhs, 2, 'K');
   return lhs;
diff --git a/bin/hi/evaluator.C b/bin/hi/evaluator.C
index 6d944187d..693c35b7d 100644
--- a/bin/hi/evaluator.C
+++ b/bin/hi/evaluator.C
@@ -3,14 +3,15 @@
 #include "funcdefs.H"
 #include "cio.H"
 
-#include <hobbes/eval/cmodule.H>
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/db/file.H>
+#include <hobbes/eval/cmodule.H>
 #include <hobbes/ipc/net.H>
+#include <hobbes/lang/preds/class.H>
 #include <hobbes/util/perf.H>
 #include <hobbes/util/str.H>
 #include <hobbes/util/time.H>
 #include <iostream>
+#include <memory>
 
 namespace {
 void defPrintUnreachableMatches(const hobbes::cc::UnreachableMatches& m) {
@@ -22,7 +23,7 @@ namespace hi {
 
 // allocate a string in global memory
 hobbes::array<char>* allocGlobalStr(const char* x, size_t len) {
-  hobbes::array<char>* r = reinterpret_cast<hobbes::array<char>*>(malloc(sizeof(long) + len * sizeof(char)));
+  auto* r = reinterpret_cast<hobbes::array<char>*>(malloc(sizeof(long) + len * sizeof(char)));
   memcpy(r->data, x, len * sizeof(char));
   r->size = len;
   return r;
@@ -36,12 +37,12 @@ void bindArguments(hobbes::cc& ctx, const Args::NameVals& args) {
   // type-level binding, for [("foo", "bar"), ...]:
   //   class Argument a b | a -> b
   //   instance Argument "foo" "bar"
-  TClass* tc = new TClass("Argument", 2, TClass::Members(), list(FunDep(list(0), 1)), LexicalAnnotation::null());
+  auto* tc = new TClass("Argument", 2, TClass::Members(), list(FunDep(list(0), 1)), LexicalAnnotation::null());
   Definitions drainDefs;
   for (const auto& arg : args) {
     tc->insert(
       ctx.typeEnv(),
-      TCInstancePtr(new TCInstance("Argument", list(MonoTypePtr(TString::make(arg.first)), MonoTypePtr(TString::make(arg.second))), MemberMapping(), LexicalAnnotation::null())),
+      std::make_shared<TCInstance>("Argument", list(MonoTypePtr(TString::make(arg.first)), MonoTypePtr(TString::make(arg.second))), MemberMapping(), LexicalAnnotation::null()),
       &drainDefs
     );
   }
@@ -51,12 +52,12 @@ void bindArguments(hobbes::cc& ctx, const Args::NameVals& args) {
   // value-level binding
   //   arguments :: [[char]*[char]]
   //   arguments = [("foo", "bar"), ...]
-  typedef std::pair<array<char>*, array<char>*> StrPair;
-  typedef array<StrPair> StrPairs;
+  using StrPair = std::pair<array<char> *, array<char> *>;
+  using StrPairs = array<StrPair>;
 
-  StrPairs* arguments = reinterpret_cast<StrPairs*>(malloc(sizeof(long) + args.size() * sizeof(StrPair)));
+  auto* arguments = reinterpret_cast<StrPairs*>(malloc(sizeof(long) + args.size() * sizeof(StrPair)));
   arguments->size = 0;
-  for (auto arg : args) {
+  for (const auto& arg : args) {
     arguments->data[arguments->size].first  = allocGlobalStr(arg.first);
     arguments->data[arguments->size].second = allocGlobalStr(arg.second);
     ++arguments->size;
@@ -65,7 +66,7 @@ void bindArguments(hobbes::cc& ctx, const Args::NameVals& args) {
 }
 
 // set up the evaluation environment for our cc
-evaluator::evaluator(const Args& args) : silent(args.silent), wwwd(0), opts(args.opts) {
+evaluator::evaluator(const Args& args) : silent(args.silent), wwwd(nullptr), opts(args.opts) {
   using namespace hobbes;
 
   bindArguments(this->ctx, args.scriptNameVals);
@@ -93,7 +94,7 @@ evaluator::~evaluator() {
 }
 
 bool hiddenFileName(const std::string& fname) {
-  return fname.size() == 0 || fname[0] == '.';
+  return fname.empty() || fname[0] == '.';
 }
 
 bool loadSilently(const std::string& mfile) {
@@ -106,7 +107,7 @@ void evaluator::runMachineREPL() {
 
 void evaluator::showClass(const std::string& cname) {
   hobbes::UnqualifierPtr uq = this->ctx.typeEnv()->lookupUnqualifier(cname);
-  if (const hobbes::TClass* c = dynamic_cast<const hobbes::TClass*>(uq.get())) {
+  if (const auto* c = dynamic_cast<const hobbes::TClass*>(uq.get())) {
     c->show(std::cout);
   } else {
     throw std::runtime_error("Undefined type class: " + cname);
@@ -115,11 +116,11 @@ void evaluator::showClass(const std::string& cname) {
 
 void evaluator::showInstances(const std::string& cname) {
   hobbes::UnqualifierPtr uq = this->ctx.typeEnv()->lookupUnqualifier(cname);
-  if (const hobbes::TClass* c = dynamic_cast<const hobbes::TClass*>(uq.get())) {
-    for (auto i : c->instances()) {
+  if (const auto* c = dynamic_cast<const hobbes::TClass*>(uq.get())) {
+    for (const auto& i : c->instances()) {
       i->show(std::cout);
     }
-    for (auto i : c->instanceFns()) {
+    for (const auto& i : c->instanceFns()) {
       i->show(std::cout);
     }
   } else {
@@ -170,7 +171,7 @@ void printConstraint(const hobbes::ConstraintPtr& c) {
 }
 
 void printQualType(const hobbes::Constraints& cs, const hobbes::MonoTypePtr& ty) {
-  if (cs.size() > 0) {
+  if (!cs.empty()) {
     printConstraint(cs[0]);
     for (size_t i = 1; i < cs.size(); ++i) {
       std::cout << setfgc(colors.stdtextfg) << ", ";
@@ -204,7 +205,7 @@ void evaluator::printTypeEnv() {
 }
 
 hobbes::str::seq evaluator::completionsFor(const std::string& prefix) const {
-  if (prefix.size() == 0) {
+  if (prefix.empty()) {
     return hobbes::str::seq();
   } else {
     hobbes::str::seq vars;
@@ -232,13 +233,13 @@ void evaluator::printAssembly(const std::string& expr, void (*f)(void*,size_t))
 }
 
 void evaluator::perfTestExpr(const std::string& expr) {
-  typedef void (*pvthunk)();
+  using pvthunk = void (*)();
   pvthunk f = this->ctx.compileFn<void()>(readExpr("let x = (" + expr + ") in ()"));
   f();
 
   const size_t numRuns = 1000;
   unsigned long nsCSum = 0;
-  unsigned long nsCMin = static_cast<unsigned long>(-1);
+  auto nsCMin = static_cast<unsigned long>(-1);
   unsigned long nsCMax = 0;
 
   for (size_t i = 0; i < numRuns; ++i) {
@@ -265,7 +266,7 @@ void evaluator::breakdownEvalExpr(const std::string& expr) {
   long ust = hobbes::tick() - t0;
 
   t0 = hobbes::tick();
-  typedef void (*pvthunk)();
+  using pvthunk = void (*)();
   pvthunk f = this->ctx.compileFn<void()>(e);
   long ct = hobbes::tick() - t0;
 
@@ -295,7 +296,7 @@ bool evaluator::satisfied(const hobbes::ConstraintPtr& c) {
 }
 
 void showSearchResults(const std::string&, const hobbes::SearchEntries& ses) {
-  if (ses.size() > 0) {
+  if (!ses.empty()) {
     std::map<std::string, std::string> stbl;
     for (const auto& se : ses) {
       stbl[se.sym] = hobbes::show(se.ty);
diff --git a/bin/hi/evaluator.H b/bin/hi/evaluator.H
index 1fe491d56..ad23ebcb8 100644
--- a/bin/hi/evaluator.H
+++ b/bin/hi/evaluator.H
@@ -7,11 +7,11 @@
 
 namespace hi {
 
-typedef std::vector<std::string> ModuleFiles;
+using ModuleFiles = std::vector<std::string>;
 
 struct Args {
-  typedef std::map<std::string, std::string> NameVals;
-  typedef std::vector<std::string> strs;
+  using NameVals = std::map<std::string, std::string>;
+  using strs = std::vector<std::string>;
 
   ModuleFiles              mfiles;
   std::vector<std::string> evalExprs;
diff --git a/bin/hi/funcdefs.C b/bin/hi/funcdefs.C
index 02e5bd3d3..7b08d0189 100644
--- a/bin/hi/funcdefs.C
+++ b/bin/hi/funcdefs.C
@@ -7,13 +7,13 @@
 #include <hobbes/util/str.H>
 #include <hobbes/util/time.H>
 
-#include <time.h>
-#include <unistd.h>
-#include <fstream>
 #include <cstdlib>
-#include <sys/types.h>
-#include <sys/stat.h>
+#include <ctime>
 #include <fcntl.h>
+#include <fstream>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 namespace hi {
 
@@ -48,7 +48,7 @@ const hobbes::array<char>* showTick(long x) {
 void enableConsoleCmds(bool f);
 
 // spawn sub-processes and support basic I/O
-typedef std::pair<int, int> PIO;
+using PIO = std::pair<int, int>;
 
 const PIO* pexec(const hobbes::array<char>* cmd) {
   PIO* p = hobbes::make<PIO>(0, 0);
@@ -75,13 +75,13 @@ const PIO* pexec(const hobbes::array<char>* cmd) {
     close(c2p[1]);
 
     hobbes::str::seq args = hobbes::str::csplit(hobbes::makeStdString(cmd), " ");
-    if (args.size() == 0) return p;
+    if (args.empty()) return p;
   
     std::vector<const char*> argv;
-    for (size_t i = 0; i < args.size(); ++i) {
-      argv.push_back(args[i].c_str());
+    for (const auto &arg : args) {
+      argv.push_back(arg.c_str());
     }
-    argv.push_back(0);
+    argv.push_back(nullptr);
   
     execv(args[0].c_str(), const_cast<char* const*>(&argv[0]));
     exit(0);
diff --git a/bin/hi/main.C b/bin/hi/main.C
index 96fed7728..93b1cf40f 100644
--- a/bin/hi/main.C
+++ b/bin/hi/main.C
@@ -6,27 +6,27 @@
 #include <hobbes/util/os.H>
 #include <hobbes/eval/cmodule.H>
 
-#include <iostream>
+#include <csetjmp>
+#include <csignal>
+#include <cstdlib>
+#include <ctime>
 #include <fstream>
-#include <time.h>
+#include <iostream>
 #include <unistd.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <setjmp.h>
 
 #include "cio.H"
 #include "evaluator.H"
 
-#include <stdio.h>
-#include <readline/readline.h>
+#include <cstdio>
 #include <readline/history.h>
+#include <readline/readline.h>
 
 namespace str = hobbes::str;
 
 namespace hi {
 
 // the one evaluator for this process
-evaluator* eval = 0;
+evaluator* eval = nullptr;
 
 // control color options (these can be tweaked by ~/.hirc)
 ConsoleColors colors;
@@ -106,7 +106,7 @@ void printAnnotatedError(const hobbes::annotated_error& ae, const hobbes::Constr
   for (const auto& m : ae.messages()) {
     std::cout << setbold() << setfgc(colors.errorfg) << m.second.lineDesc() << ": " << m.first << "\n";
     for (const auto& c : cs) {
-      if (eval && !eval->satisfied(c)) {
+      if ((eval != nullptr) && !eval->satisfied(c)) {
         std::cout << "  " << hobbes::show(c) << std::endl;
       }
     }
@@ -118,8 +118,8 @@ void printAnnotatedError(const hobbes::annotated_error& ae, const hobbes::Constr
 void printASM(void*,size_t);
 
 // show help on supported prompt commands
-typedef std::pair<std::string, std::string> CmdDesc;
-typedef std::vector<CmdDesc>                CmdDescs;
+using CmdDesc = std::pair<std::string, std::string>;
+using CmdDescs = std::vector<CmdDesc>;
 
 void showShellHelp(const CmdDescs& cds) {
   std::string header = "Supported hi commands";
@@ -136,8 +136,8 @@ void showShellHelp(const CmdDescs& cds) {
             << std::endl;
 
   double hw  = static_cast<double>(llen - header.size()) / 2.0;
-  size_t lhw = static_cast<size_t>(floor(hw));
-  size_t rhw = static_cast<size_t>(ceil(hw));
+  auto lhw = static_cast<size_t>(floor(hw));
+  auto rhw = static_cast<size_t>(ceil(hw));
 
   std::cout << "| "
               << std::string(lhw, ' ')
@@ -194,7 +194,7 @@ void showUnsafeSymbols() {
 void echoCommandHistory() {
   const int history_max = 10;
   HIST_ENTRY** history = history_list();
-  if (history) {
+  if (history != nullptr) {
     // take the last history_max elements of history
     int startIndex = history_length > history_max ? history_length - history_max : 0;
     for (int i = startIndex; i < history_length; ++i) {
@@ -217,7 +217,7 @@ char* completionStep(const char*, int state) {
   if (state >= 0 && size_t(state) < completionMatches.size()) {
     return strdup(completionMatches[state].c_str());
   } else {
-    return 0;
+    return nullptr;
   }
 }
 
@@ -229,7 +229,7 @@ char** completions(const char* pfx, int start, int) {
 #ifdef BUILD_LINUX
     rl_bind_key('\t', rl_abort);
 #endif
-    return 0;
+    return nullptr;
   }
 }
 
@@ -281,7 +281,7 @@ void repl(evaluator*) {
     [](int,void*) {
       rl_callback_read_char();
     },
-    0
+    nullptr
   );
 
   // poll for events and dispatch them
@@ -291,11 +291,11 @@ void repl(evaluator*) {
 void evalLine(char* x) {
   // preprocess this line from readline
   std::string line;
-  if (x) {
+  if (x != nullptr) {
     line = str::trim<char>(x);
     free(x);
 
-    if (line.size() > 0) {
+    if (!line.empty()) {
       add_history(line.c_str());
     }
   } else {
@@ -309,7 +309,7 @@ void evalLine(char* x) {
     if (line == ":q") {
       std::cout << resetfmt() << std::flush;
       exit(0);
-    } else if (line == "") {
+    } else if (line.empty()) {
       return;
     } else if (line == ":^") {
       echoCommandHistory();
@@ -430,14 +430,14 @@ unsigned int digitLen(unsigned int x) {
 template <typename C>
   unsigned int sumSize(const C& cs) {
     unsigned int s = 0;
-    for (typename C::const_iterator c = cs.begin(); c != cs.end(); ++c) {
+    for (auto c = cs.begin(); c != cs.end(); ++c) {
       s += c->size();
     }
     return s;
   }
 
 bool isNum(const std::string& x) {
-  return x.size() > 0 && x[0] == '0';
+  return !x.empty() && x[0] == '0';
 }
 
 bool isRegister(const std::string& x) {
@@ -455,7 +455,7 @@ void printASMArg(const std::string& x) {
 }
 
 unsigned int fmtLen(const str::seq& args) {
-  if (args.size() == 0) {
+  if (args.empty()) {
     return 0;
   } else if (args.size() == 1) {
     return args[0].size();
@@ -487,7 +487,7 @@ void printASMTable(const str::seq& insts, const str::seqs& args, unsigned int ma
 
     // show the arguments
     const str::seq& argl = args[i];
-    if (argl.size() > 0) {
+    if (!argl.empty()) {
       printASMArg(argl[0]);
       for (unsigned int k = 1; k < argl.size(); ++k) {
         std::cout << setfgc(colors.argdelimfg) << ", ";
@@ -572,7 +572,7 @@ void runProcess(const std::string& cmd, std::ostream& out) {
 
   char buf[4096];
   int n;
-  while ((n = read(pio[0], buf, sizeof(buf)))) {
+  while ((n = read(pio[0], buf, sizeof(buf))) != 0) {
     out.write(buf, n);
   }
   close(pio[0]);
@@ -709,9 +709,9 @@ int main(int argc, char** argv) {
     }
 
     // load any modules passed in
-    if (args.mfiles.size() > 0) {
-      for (ModuleFiles::const_iterator m = args.mfiles.begin(); m != args.mfiles.end(); ++m) {
-        eval->loadModule(str::expandPath(*m));
+    if (!args.mfiles.empty()) {
+      for (const auto &mfile : args.mfiles) {
+        eval->loadModule(str::expandPath(mfile));
       }
     }
 
diff --git a/bin/hi/www.C b/bin/hi/www.C
index 0f4553a3d..5ae567a35 100644
--- a/bin/hi/www.C
+++ b/bin/hi/www.C
@@ -70,11 +70,7 @@ bool catPathToFSPath(const std::string& cat, const std::string& cpath, std::stri
   }
   
   *fsPath = exeDir() + "/../../common/www/" + cat + "/" + cpath;
-  if (fileExists(*fsPath)) {
-    return true;
-  }
-
-  return false;
+  return fileExists(*fsPath);
 }
 
 // find a www 'system' file
@@ -219,7 +215,7 @@ void WWWServer::evalHxpFile(const hobbes::HTTPRequest&, int fd, const std::strin
 }
 
 // utility functions for web processes
-typedef hobbes::array<char> cstr;
+using cstr = hobbes::array<char>;
 
 const cstr* linkTarget(const cstr* p) {
   using namespace hobbes;
@@ -232,7 +228,7 @@ const cstr* slurpFile(const cstr* fpath) {
   return makeString(str::slurp(f));
 }
 
-typedef std::pair<const cstr*, const cstr*> cstrpair;
+using cstrpair = std::pair<const cstr *, const cstr *>;
 
 const hobbes::array< const cstr* >* csplit(const cstr* s, const cstr* ss) {
   using namespace hobbes;
@@ -245,7 +241,7 @@ const hobbes::array< const cstr* >* csplit(const cstr* s, const cstr* ss) {
 }
 
 long unixTime() {
-  return time(0) * (1000 * 1000);
+  return time(nullptr) * (1000 * 1000);
 }
 
 const cstr* formatJSTime(long x) {
@@ -284,8 +280,7 @@ WWWServer::WWWServer(int port, hobbes::cc* c) : c(c) {
   hobbes::installHTTPD(port, &WWWServer::evalHTTPRequest, this);
 }
 
-WWWServer::~WWWServer() {
-}
+WWWServer::~WWWServer() = default;
 
 std::string urlDecode(const std::string& x) {
   using namespace hobbes::str;
@@ -317,9 +312,7 @@ std::string htmlEncode(const std::string& x) {
   using namespace hobbes::str;
 
   std::ostringstream ss;
-  for (size_t i = 0; i < x.size(); ++i) {
-    char c = x[i];
-
+  for (const char c : x) {
     switch (c) {
     case '&':
       ss << "&amp;";
@@ -344,7 +337,7 @@ std::string showType(hobbes::cc& c, const hobbes::QualTypePtr& t) {
   hobbes::QualTypePtr st = hobbes::simplifyVarNames(hobbes::qualtype(cs, t->monoType()));
 
   std::ostringstream ss;
-  if (st->constraints().size() > 0) {
+  if (!st->constraints().empty()) {
     ss << htmlEncode(hobbes::show(st->constraints()[0]));
     for (size_t i = 1; i < st->constraints().size(); ++i) {
       ss << ", " << htmlEncode(hobbes::show(st->constraints()[i]));
@@ -360,8 +353,8 @@ void WWWServer::printDefaultPage(int fd) {
   b << "<html><head><title>hi process</title></head><body><pre>";
 
   b << "<h2>Environment</h2>\n<table>";
-  for (auto vty : this->c->typeEnv()->typeEnvTable()) {
-    if (vty.first.size() > 0 && vty.first[0] != '.') {
+  for (const auto& vty : this->c->typeEnv()->typeEnvTable()) {
+    if (!vty.first.empty() && vty.first[0] != '.') {
       b << "<tr><td><b>" << vty.first << "</b></td><td>" << showType(*this->c, vty.second->instantiate()) << "</td></tr>";
     }
   }
@@ -377,7 +370,7 @@ void WWWServer::printDefaultPage(int fd) {
 
 void WWWServer::printQueryResult(int fd, const std::string& expr) {
   try {
-    typedef void (*pprintF)();
+    using pprintF = void (*)();
     pprintF f = this->c->compileFn<void()>("print(" + expr + ")");
 
     // redirect stdout for this evaluation
@@ -492,7 +485,7 @@ std::string WWWServer::mimeTypeForExt(const std::string& ext) {
       std::string line;
       std::getline(mtypes, line);
 
-      if (line.size() > 0 && line[0] != '#') {
+      if (!line.empty() && line[0] != '#') {
         using namespace hobbes;
 
         str::pair lp = str::lsplit(line, "\t");
@@ -516,8 +509,8 @@ WWWServer::VarBindingDescs* WWWServer::getVarBindingDescs() {
   auto*       result    = hobbes::makeArray<VarBindingDesc>(tenvTable.size());
 
   size_t i = 0;
-  for (auto vty : tenvTable) {
-    if (vty.first.size() > 0 && vty.first[0] != '.') {
+  for (const auto& vty : tenvTable) {
+    if (!vty.first.empty() && vty.first[0] != '.') {
       result->data[i].first  = hobbes::makeString(vty.first);
       result->data[i].second = hobbes::makeString(showType(*this->c, vty.second->instantiate()));
       ++i;
diff --git a/bin/hi/www.H b/bin/hi/www.H
index 0a52c40fd..fd11d40b8 100644
--- a/bin/hi/www.H
+++ b/bin/hi/www.H
@@ -19,17 +19,17 @@ private:
   void printQueryResult(int, const std::string&);
   void printFileContents(int, const std::string&);
 
-  typedef void (*PrintPageFn)(int fd, const hobbes::array<char>* queryString);
+  using PrintPageFn = void (*)(int, const hobbes::array<char> *);
   struct HxpFile {
     time_t      ftime;
     PrintPageFn f;
   };
-  typedef std::unordered_map<std::string, HxpFile> HxpFiles;
+  using HxpFiles = std::unordered_map<std::string, HxpFile>;
   HxpFiles hxpFiles;
   const HxpFile& hxpFile(const std::string& fpath);
   void evalHxpFile(const hobbes::HTTPRequest&, int fd, const std::string& fpath, const std::string& queryString);
 
-  typedef std::map<std::string, std::string> MIMETypes;
+  using MIMETypes = std::map<std::string, std::string>;
   MIMETypes mimeTypes;
   std::string mimeType(const std::string& fpath);
   std::string mimeTypeForExt(const std::string& ext);
@@ -38,8 +38,8 @@ private:
   static void evalHTTPRequest(const hobbes::HTTPRequest& req, int fd, void* ud);
 
   // useful bindings
-  typedef std::pair<const hobbes::array<char>*, const hobbes::array<char>*> VarBindingDesc;
-  typedef hobbes::array<VarBindingDesc> VarBindingDescs;
+  using VarBindingDesc = std::pair<const hobbes::array<char> *, const hobbes::array<char> *>;
+  using VarBindingDescs = hobbes::array<VarBindingDesc>;
   VarBindingDescs* getVarBindingDescs();
 };
 
diff --git a/bin/hog/batchrecv.C b/bin/hog/batchrecv.C
index d98e33775..3c9d3005a 100644
--- a/bin/hog/batchrecv.C
+++ b/bin/hog/batchrecv.C
@@ -68,7 +68,7 @@ struct gzbuffer {
   void decompressChunk() {
     this->zin.next_out  = outb->data();
     this->zin.avail_out = outb->size();
-    checkZLibRC(inflate(&this->zin, Z_NO_FLUSH) < 0);
+    checkZLibRC(static_cast<int>(inflate(&this->zin, Z_NO_FLUSH) < 0));
     this->off   = 0;
     this->avail = this->outb->size() - this->zin.avail_out;
   }
@@ -141,7 +141,7 @@ DEFINE_STRUCT(
   (int,               remotePort)
 );
 
-void runRecvConnection(SessionGroup* sg, NetConnection* pc, std::string dir) {
+void runRecvConnection(SessionGroup* sg, NetConnection* pc, const std::string& dir) {
   std::unique_ptr<NetConnection> connection(pc);
   std::vector<uint8_t> inb, outb, txn;
   outb.resize(1 * 1024 * 1024); // reserve 1MB for buffering
@@ -193,7 +193,7 @@ void runRecvConnection(SessionGroup* sg, NetConnection* pc, std::string dir) {
   }
 }
 
-[[noreturn]] void runRecvServer(std::unique_ptr<NetServer> server, std::string dir, bool consolidate, hobbes::StoredSeries::StorageMode sm) {
+[[noreturn]] void runRecvServer(std::unique_ptr<NetServer> server, const std::string& dir, bool consolidate, hobbes::StoredSeries::StorageMode sm) {
   SessionGroup* sg = makeSessionGroup(consolidate, sm);
   std::vector<std::thread> cthreads;
 
diff --git a/bin/hog/batchsend.C b/bin/hog/batchsend.C
index 239e5ef36..6f39b0803 100644
--- a/bin/hog/batchsend.C
+++ b/bin/hog/batchsend.C
@@ -7,14 +7,15 @@
 #include <hobbes/util/os.H>
 #include <hobbes/util/perf.H>
 
+#include <atomic>
+#include <functional>
 #include <iostream>
 #include <map>
-#include <thread>
+#include <memory>
 #include <mutex>
-#include <atomic>
-#include <functional>
+#include <thread>
+#include <utility>
 #include <vector>
-#include <memory>
 
 #include <glob.h>
 #include <zlib.h>
@@ -64,7 +65,7 @@ struct Destination {
 
 std::ostream& operator<<(std::ostream& o, const std::vector<Destination>& xs) {
   o << "[";
-  if (xs.size() > 0) {
+  if (!xs.empty()) {
     auto x = xs.begin();
     o << "\"" << x->hostport << "\"";
     ++x;
@@ -92,11 +93,11 @@ void sendFileContents(NetConnection& connection, const openfd& sfd) {
 
 void sendSegmentFiles(NetConnection& connection, const std::string& localdir) {
   // poll for segment files
-  typedef std::map<time_t, std::set<std::string>> OrderedSegFiles;
+  using OrderedSegFiles = std::map<time_t, std::set<std::string>>;
   OrderedSegFiles segfiles;
 
   glob_t g;
-  if (glob((localdir + "/segment-*.gz").c_str(), GLOB_NOSORT, 0, &g) == 0) {
+  if (glob((localdir + "/segment-*.gz").c_str(), GLOB_NOSORT, nullptr, &g) == 0) {
     for (size_t i = 0; i < g.gl_pathc; ++i) {
       struct stat st;
       if (stat(g.gl_pathv[i], &st) == 0) {
@@ -155,7 +156,7 @@ void sendInitMessageToAll(const std::string& groupName, std::vector<Destination>
 using IdleFn = std::function<void()>;
 using ReadyFn = std::function<bool()>;
 
-void sendSegmentFilesToAll(std::vector<Destination>& destinations, IdleFn idleFn) {
+void sendSegmentFilesToAll(std::vector<Destination>& destinations, const IdleFn& idleFn) {
   bool yield = false;
   while (!yield) {
     for (auto & d : destinations) {
@@ -175,7 +176,7 @@ void sendSegmentFilesToAll(std::vector<Destination>& destinations, IdleFn idleFn
   }
 }
 
-void runConnectedSegmentSendingProcess(const std::string& groupName, std::vector<Destination>& destinations, IdleFn idleFn) {
+void runConnectedSegmentSendingProcess(const std::string& groupName, std::vector<Destination>& destinations, const IdleFn& idleFn) {
   try {
     sendInitMessageToAll(groupName, destinations);
     sendSegmentFilesToAll(destinations, idleFn);
@@ -199,7 +200,7 @@ void connect(std::vector<Destination>& destinations) {
   }
 }
 
-void runSegmentSendingProcess(const size_t sessionHash, const std::string groupName, std::vector<Destination>& destinations, ReadyFn readyFn, IdleFn idleFn) {
+void runSegmentSendingProcess(const size_t sessionHash, const std::string& groupName, std::vector<Destination>& destinations, const ReadyFn& readyFn, const IdleFn& idleFn) {
   if (destinations.empty()) {
     out() << "no batchsend host specified, compressed segment files will accumulate locally" << std::endl;
   } else {
@@ -251,16 +252,16 @@ struct BatchSendSession {
   std::vector<const BatchSendSession*> detached;
   std::function<void()>    finalizer;
 
-  BatchSendSession(const size_t sessionHash, const std::string& groupName, const std::string& dir, size_t clevel, const std::vector<std::string>& sendto, const std::vector<const BatchSendSession*> detached, const std::function<void()> finalizer)
-    : buffer(0), c(0), sz(0), dir(dir), readerAlive(true), detached(detached), finalizer(finalizer) {
+  BatchSendSession(const size_t sessionHash, const std::string& groupName, const std::string& dir, size_t clevel, const std::vector<std::string>& sendto, const std::vector<const BatchSendSession*>& detached, const std::function<void()>& finalizer)
+    : buffer(nullptr), c(0), sz(0), dir(dir), readerAlive(true), detached(detached), finalizer(finalizer) {
     for (const auto & hostport : sendto) {
       auto localdir = ensureDirExists(dir + "/" + hostport + "/");
-      destinations.push_back(Destination{localdir, hostport});
+      destinations.emplace_back(localdir, hostport);
     }
 
     // start from last segment in directory 
     const auto paths = hobbes::str::paths(dir + "*/segment-*.gz");
-    if (paths.size() > 0) {
+    if (!paths.empty()) {
       this->c = std::stoi(hobbes::str::rsplit(hobbes::str::rsplit(paths.back(), ".gz").first, "segment-").second);
     }
 
@@ -277,7 +278,7 @@ struct BatchSendSession {
 
     auto idleFn = [this, groupName]() {
       static thread_local uint64_t count = 0;
-      if (++count % 16) return; // not checking on each idle cycle
+      if ((++count % 16) != 0u) return; // not checking on each idle cycle
 
       if (!readerAlive && completed()) {
         this->finalizer();
@@ -289,7 +290,7 @@ struct BatchSendSession {
     this->sendingThread = std::thread([this, sessionHash, groupName, dir, readerId, readyFn, idleFn]() {
       const auto senderId = hobbes::storage::thisProcThread();
       std::vector<std::string> senderqueue;
-      for (auto s : this->detached) {
+      for (const auto *s : this->detached) {
         senderqueue.push_back(s->dir);
       }
       StatFile::instance().log(SenderRegistration{hobbes::now(), sessionHash, readerId, senderId, this->dir, senderqueue});
@@ -337,7 +338,7 @@ struct BatchSendSession {
   bool completed() const {
     return std::all_of(destinations.begin(), destinations.end(), [](const Destination& d) {
       glob_t g;
-      auto ret = glob((d.localdir + "/segment-*.gz").c_str(), GLOB_NOSORT, 0, &g);
+      auto ret = glob((d.localdir + "/segment-*.gz").c_str(), GLOB_NOSORT, nullptr, &g);
       if (ret == 0) {
         auto remaining = g.gl_pathc;
         globfree(&g);
@@ -406,7 +407,7 @@ struct SenderGroup {
     auto it = std::find_if_not(detached.begin(), detached.end(), [](const BatchSendSession* s) { return s->completed(); });
     detached.erase(detached.begin(), it);
 
-    senders.push_back(std::unique_ptr<BatchSendSession>(new BatchSendSession{sessionHash, name, dir, clevel, sendto, detached, finalizeSenderF}));
+    senders.push_back(std::make_unique<BatchSendSession>(sessionHash, name, dir, clevel, sendto, detached, finalizeSenderF));
 
     return senders.back().get();
   }
@@ -423,7 +424,7 @@ std::vector<const BatchSendSession*> SenderGroup::detached;
 std::mutex SenderGroup::mutex;
 
 void pushLocalData(const hobbes::storage::QueueConnection& qc, const size_t sessionHash, const std::string& groupName, const std::string& partialDir, const std::string& fullDir, const hobbes::storage::ProcThread& readerId, const hobbes::storage::WaitPolicy wp, const RunMode& runMode, std::atomic<bool>& conn, const std::function<void()>& finalizeSenderF) {
-  auto sn = SenderGroup::create(sessionHash, groupName, fullDir, runMode.clevel, runMode.sendto, finalizeSenderF);
+  auto *sn = SenderGroup::create(sessionHash, groupName, fullDir, runMode.clevel, runMode.sendto, finalizeSenderF);
   const long batchsendtime = runMode.batchsendtime * 1000;
   const size_t batchsendsize = std::max<size_t>(10*1024*1024, runMode.batchsendsize);
   long t0 = hobbes::time();
@@ -442,7 +443,7 @@ void pushLocalData(const hobbes::storage::QueueConnection& qc, const size_t sess
   }
 
   auto timeoutF = [&](const hobbes::storage::reader& reader) {
-    if (conn == false && *reader.config().wstate == PRIV_HSTORE_STATE_READER_WAITING) {
+    if (!conn && *reader.config().wstate == PRIV_HSTORE_STATE_READER_WAITING) {
       // if we are here, the client is disconnected and the queue is drained
       // detach tcp send session synchronously and shut down the reader
       SenderGroup::detach(sn);
diff --git a/bin/hog/boot/gen/boot.C b/bin/hog/boot/gen/boot.C
index 3284e2a74..1e44ef219 100644
--- a/bin/hog/boot/gen/boot.C
+++ b/bin/hog/boot/gen/boot.C
@@ -7,7 +7,7 @@ namespace hog {
 #include "bootdata.H"
 
 void compileBootCode(hobbes::cc& ctx) {
-  hobbes::compile(&ctx, ctx.readModule(std::string(reinterpret_cast<const char*>(___bootdata), ___bootdata_len)));
+  hobbes::compile(&ctx, ctx.readModule(std::string(reinterpret_cast<const char*>(_bootdata), _bootdata_len)));
 }
 
 }
diff --git a/bin/hog/boot/gen/bootdata.H b/bin/hog/boot/gen/bootdata.H
index ee1989a0b..55eb3943e 100644
--- a/bin/hog/boot/gen/bootdata.H
+++ b/bin/hog/boot/gen/bootdata.H
@@ -1,4 +1,4 @@
-unsigned char ___bootdata[] = {
+unsigned char _bootdata[] = {
   0x2f, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x72,
   0x65, 0x61, 0x64, 0x20, 0x3a, 0x20, 0x49, 0x2f, 0x4f, 0x20, 0x66, 0x6f,
   0x72, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x70, 0x69,
@@ -586,4 +586,4 @@ unsigned char ___bootdata[] = {
   0x64, 0x28, 0x74, 0x78, 0x6e, 0x29, 0x3a, 0x3a, 0x28, 0x28, 0x29, 0x2b,
   0x74, 0x29, 0x29, 0x0a, 0x0a
 };
-unsigned int ___bootdata_len = 7025;
+unsigned int _bootdata_len = 7025;
diff --git a/bin/hog/config.C b/bin/hog/config.C
index 55c131add..4decb512a 100644
--- a/bin/hog/config.C
+++ b/bin/hog/config.C
@@ -112,7 +112,7 @@ RunMode config(int argc, const char** argv) {
 
       ++i;
       while (i < argc && argv[i][0] != '-') {
-        r.sendto.push_back(argv[i]);
+        r.sendto.emplace_back(argv[i]);
         ++i;
       }
       --i;
@@ -148,7 +148,7 @@ RunMode config(int argc, const char** argv) {
   }
 
   if (r.t == RunMode::local || r.t == RunMode::batchsend) {
-    if (r.groups.size() == 0) {
+    if (r.groups.empty()) {
       throw std::runtime_error("can't record data because no groups have been specified");
     }
     if (::access(r.groupServerDir.c_str(), W_OK) != 0) {
diff --git a/bin/hog/config.H b/bin/hog/config.H
index c5ed0a085..d01750f27 100644
--- a/bin/hog/config.H
+++ b/bin/hog/config.H
@@ -41,7 +41,7 @@ struct RunMode {
 template <typename T>
 inline std::ostream& operator<<(std::ostream& o, const std::vector<T>& xs) {
   o << "[";
-  if (xs.size() > 0) {
+  if (!xs.empty()) {
     auto x = xs.cbegin();
     o << "\"" << *x << "\"";
     ++x;
diff --git a/bin/hog/local.C b/bin/hog/local.C
index 04f69a383..573e5a31f 100644
--- a/bin/hog/local.C
+++ b/bin/hog/local.C
@@ -17,7 +17,7 @@ void recordLocalData(SessionGroup* sg, const hobbes::storage::QueueConnection& q
   using namespace hobbes;
 
   auto timeoutF = [&qc,&conn](const storage::reader& reader) {
-    if (conn == false && *reader.config().wstate == PRIV_HSTORE_STATE_READER_WAITING) {
+    if (!conn && *reader.config().wstate == PRIV_HSTORE_STATE_READER_WAITING) {
       throw ShutdownException("SHM reader shutting down, name: " + qc.shmname);
     }
   };
diff --git a/bin/hog/main.C b/bin/hog/main.C
index 52cff895d..76d992300 100644
--- a/bin/hog/main.C
+++ b/bin/hog/main.C
@@ -17,7 +17,7 @@
 #include "path.H"
 #include "out.H"
 
-#include <signal.h>
+#include <csignal>
 
 namespace hog {
 
@@ -86,7 +86,7 @@ void runGroupHost(const size_t sessionHash, const std::string& groupName, const
     [sg,groupName,&sessionHash,&m,&reg](int s) {
       out() << "new connection for '" << groupName << "'" << std::endl;
 
-      int c = accept(s, 0, 0);
+      int c = accept(s, nullptr, nullptr);
       if (c != -1) {
         try {
           uint32_t version = 0;
@@ -118,12 +118,12 @@ void run(const RunMode& m, const std::vector<std::string>& args) {
     out() << "hog stat file : " << StatFile::instance().filename() << std::endl;
     hog::StatFile::instance().log(hog::ProcessEnvironment{hobbes::now(), sessionHash, hobbes::string::from(m), args, hog::SessionType::Enum::Normal});
     pullRemoteDataT(m.dir, m.localport, m.consolidate, m.storageMode).join();
-  } else if (m.groups.size() > 0) {
+  } else if (!m.groups.empty()) {
     out() << "hog stat file : " << StatFile::instance().filename() << std::endl;
     hog::StatFile::instance().log(hog::ProcessEnvironment{hobbes::now(), sessionHash, hobbes::string::from(m), args, hog::SessionType::Enum::Normal});
     std::map<std::string, std::map<int, RegInfo>> registry;
 
-    for (auto g : m.groups) {
+    for (const auto& g : m.groups) {
       try {
         out() << "install a monitor for the '" << g << "' group" << std::endl;
         runGroupHost(sessionHash, g, m, registry[g]);
diff --git a/bin/hog/netconnection.C b/bin/hog/netconnection.C
index f0d63709d..ccb58a230 100644
--- a/bin/hog/netconnection.C
+++ b/bin/hog/netconnection.C
@@ -102,7 +102,7 @@ bool DefaultNetConnection::sendFile(int fd) {
   off_t size = sb.st_size;
   off_t offset = 0;
 
-  while (size) {
+  while (size != 0) {
     const ssize_t sent = sendfile(this->fd, fd, &offset, size);
     if (sent >= 0) {
       size -= sent;
diff --git a/bin/hog/path.C b/bin/hog/path.C
index 8b5a5a76d..97fa18d20 100644
--- a/bin/hog/path.C
+++ b/bin/hog/path.C
@@ -9,7 +9,7 @@ std::string instantiateDir(const std::string& groupName, const std::string& dir)
   std::string x = hobbes::str::replace<char>(dir, "$GROUP", groupName);
 
   // instantiate date
-  time_t now = ::time(0);
+  time_t now = ::time(nullptr);
   if (const tm* t = localtime(&now)) {
     std::ostringstream ss;
     ss << t->tm_year + 1900 << "." << (t->tm_mon < 9 ? "0" : "") << t->tm_mon + 1 << "." << (t->tm_mday < 10 ? "0" : "") << t->tm_mday;
diff --git a/bin/hog/recovery.C b/bin/hog/recovery.C
index fd78d8afd..57bc2979c 100644
--- a/bin/hog/recovery.C
+++ b/bin/hog/recovery.C
@@ -43,7 +43,7 @@ template<typename T>
 static std::vector<T> retrieveFromStats(hobbes::fregion::reader& r) {
   std::vector<T> ts;
 
-  auto& data = r.series<T>(T::_hmeta_struct_type_name().c_str());
+  auto& data = r.series<T>(T::_hmeta_struct_type_name());
   T t;
   while (data.next(&t)) {
     ts.emplace_back(std::move(t));
@@ -111,7 +111,7 @@ static std::vector<RecoveredDetails> recoverSessionInformation() {
       for (const std::vector<ReaderRegistration>::const_iterator& rr : readerRegistrations) {
         if (sr->readerId == rr->readerId) {
           // pair together reader and sender regs with matching reader ids
-          details.readerSenderRegs.push_back(std::make_pair(*rr, *sr));
+          details.readerSenderRegs.emplace_back(*rr, *sr);
         }
       }
     }
@@ -146,7 +146,7 @@ static bool hasBeenRecovered(const std::vector<SessionRecovered>& sessionRecover
 
 static bool hasBeenCorrectlyClosed(const std::vector<SenderState>& senderStates) {
   // Sender states should be temporally ordered earliest->latest
-  return senderStates.size() == 0 ? false : senderStates.back().status.value == SenderStatus::Enum::Closed;
+  return senderStates.empty() ? false : senderStates.back().status.value == SenderStatus::Enum::Closed;
 }
 
 struct RecoveryTask {
@@ -301,7 +301,7 @@ void detectFaultAndRecover() {
 
     const std::vector<RecoveryTask> tasks = getTasksRequiringRecovery(recoveredDetails);
     // ignore groups with no associable tasks
-    if (tasks.size() > 0) {
+    if (!tasks.empty()) {
       recoveryTaskGroups.emplace_back(RecoveryTaskGroup{runMode,
         recoveredDetails.processEnvironment.sessionHash,
         recoveredDetails.processEnvironment.argv,
diff --git a/bin/hog/session.C b/bin/hog/session.C
index 2dc00f164..93b86bc2b 100644
--- a/bin/hog/session.C
+++ b/bin/hog/session.C
@@ -22,7 +22,7 @@ bool hstoreCanRead(storage::Transaction& txn, size_t n) {
 }
 
 const uint8_t* hstoreUnsafeRead(storage::Transaction& txn, size_t n) {
-  auto p = txn.ptr();
+  const auto *p = txn.ptr();
   txn.skip(n);
   return p;
 }
@@ -37,8 +37,8 @@ const uint8_t* hstoreUnsafeReadFixedArray(storage::Transaction& txn, size_t byte
 }
 
 cc* loggerCompiler() {
-  static cc* c = 0;
-  if (!c) {
+  static cc* c = nullptr;
+  if (c == nullptr) {
     c = new cc();
     c->bind("hstoreCanRead",              &hstoreCanRead);
     c->bind("hstoreUnsafeRead",           &hstoreUnsafeRead);
@@ -62,7 +62,7 @@ DEFINE_STRUCT(
 std::string ensureDirExists(const std::string& dirPfx) {
   hobbes::str::seq ps = hobbes::str::csplit(dirPfx, "/");
   std::ostringstream pfx;
-  if (ps.size() > 0) {
+  if (!ps.empty()) {
     for (size_t i = 0; i < (ps.size()-1); ++i) {
       pfx << ps[i] << "/";
       if (mkdir(pfx.str().c_str(), S_IRWXU | S_IRWXG | S_IRWXO) == -1 && errno != EEXIST) {
@@ -89,12 +89,12 @@ struct Session {
   hobbes::writer* db;
 
   // sections of the file for structured data
-  typedef std::vector<hobbes::StoredSeries*> StoredSeriess;
+  using StoredSeriess = std::vector<hobbes::StoredSeries *>;
   StoredSeriess streams;
 
   // functions for actually writing stream data
-  typedef void (*WriteFn)(hobbes::storage::Transaction*);
-  typedef std::vector<WriteFn> WriteFns;
+  using WriteFn = void (*)(hobbes::storage::Transaction *);
+  using WriteFns = std::vector<WriteFn>;
 
   WriteFns writeFns;
 
@@ -120,7 +120,7 @@ public:
   std::string ready() {
     std::string fpath = moveToUniqueFilename(this->tmpPath, this->dirPfx, ".log");
     this->tmpPath = "";
-    this->f = 0;
+    this->f = nullptr;
     return fpath;
   }
 
@@ -137,7 +137,7 @@ public:
   AppendFirstMatchingFile(const std::string& dirPfx, storage::CommitMethod cm, const storage::statements& stmts) : dirPfx(dirPfx) {
     this->f = findMatchingFile(dirPfx, cm, stmts);
 
-    if (this->f == 0) {
+    if (this->f == nullptr) {
       this->tmpPath = freshTempFile(dirPfx);
       this->f       = new writer(this->tmpPath);
     }
@@ -159,7 +159,7 @@ public:
       fpath = moveToUniqueFilename(this->tmpPath, this->dirPfx, ".log");
       this->tmpPath = "";
     }
-    this->f = 0;
+    this->f = nullptr;
     return fpath;
   }
 
@@ -171,9 +171,9 @@ private:
 
   static writer* findMatchingFile(const std::string& dirPfx, storage::CommitMethod cm, const storage::statements& stmts) {
     glob_t g;
-    if (glob((dirPfx + "*.log").c_str(), GLOB_NOSORT, 0, &g) == 0) {
+    if (glob((dirPfx + "*.log").c_str(), GLOB_NOSORT, nullptr, &g) == 0) {
       for (size_t i = 0; i < g.gl_pathc; ++i) {
-        writer* f = 0;
+        writer* f = nullptr;
         try {
           f = new writer(g.gl_pathv[i]);
           if (fileMatchesStatements(f, cm, stmts)) {
@@ -188,7 +188,7 @@ private:
       globfree(&g);
     }
 
-    return 0; // couldn't find any matching file
+    return nullptr; // couldn't find any matching file
   }
 
   static bool fileMatchesStatements(writer* f, storage::CommitMethod cm, const storage::statements& stmts) {
@@ -261,7 +261,7 @@ ProcessTxnF initStorageSession(Session* s, const std::string& dirPfx, storage::P
   // allocate space for every log statement
   Variant::Members txnEntries;
 
-  for (auto stmt : stmts) {
+  for (const auto& stmt : stmts) {
     MonoTypePtr pty = decode(stmt.type);
     out << " ==> " << stmt.name << " :: " << show(pty) << " (#" << stmt.id << ")" << std::endl;
     if (s->streams.size() <= stmt.id) {
@@ -269,7 +269,7 @@ ProcessTxnF initStorageSession(Session* s, const std::string& dirPfx, storage::P
       s->writeFns.resize(stmt.id + 1);
     }
 
-    auto ss = new StoredSeries(c, s->db, stmt.name, pty, 10000, sm);
+    auto *ss = new StoredSeries(c, s->db, stmt.name, pty, 10000, sm);
     std::string writefn = "write_" + str::from(hobbes::time()) + "_" + stmt.name;
     ss->bindAs(c, writefn);
 
@@ -379,7 +379,7 @@ ProcessTxnF initStorageSession(Session* s, const std::string& dirPfx, storage::P
 // support merging log session data where type structures are identical
 class SessionGroup {
 public:
-  virtual ~SessionGroup() { }
+  virtual ~SessionGroup() = default;
   virtual ProcessTxnF appendStorageSession(const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts) = 0;
 };
 
@@ -388,7 +388,7 @@ public:
   ConsolidateGroup(hobbes::StoredSeries::StorageMode sm) : sm(sm) {
   }
 
-  ProcessTxnF appendStorageSession(const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts) {
+  ProcessTxnF appendStorageSession(const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts) override {
     std::lock_guard<std::mutex> slock(this->m);
     for (auto* cs : this->sessions) {
       if (dirPfx == cs->dirPfx && qos == cs->qos && cm == cs->cm && stmts == cs->stmts) {
@@ -433,8 +433,8 @@ public:
   SimpleGroup(hobbes::StoredSeries::StorageMode sm) : sm(sm) {
   }
 
-  ProcessTxnF appendStorageSession(const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts) {
-    Session* s = new Session;
+  ProcessTxnF appendStorageSession(const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts) override {
+    auto* s = new Session;
     return initStorageSession<AllocFreshFile>(s, dirPfx, qos, cm, stmts, this->sm);
   }
 private:
diff --git a/bin/hog/session.H b/bin/hog/session.H
index 39fc8edaa..544c83bbf 100644
--- a/bin/hog/session.H
+++ b/bin/hog/session.H
@@ -19,7 +19,7 @@ namespace hog {
 class SessionGroup;
 SessionGroup* makeSessionGroup(bool consolidate = false, hobbes::StoredSeries::StorageMode sm = hobbes::StoredSeries::Raw);
 
-typedef std::function<void(hobbes::storage::Transaction&)> ProcessTxnF;
+using ProcessTxnF = std::function<void (hobbes::storage::Transaction &)>;
 ProcessTxnF appendStorageSession(SessionGroup*, const std::string& dirPfx, hobbes::storage::PipeQOS qos, hobbes::storage::CommitMethod cm, const hobbes::storage::statements& stmts);
 
 // common way to prepare output directories from dir prefix patterns
diff --git a/include/hobbes/boot/gen/bootdata.H b/include/hobbes/boot/gen/bootdata.H
index 7a4feeb0e..57c0b9068 100644
--- a/include/hobbes/boot/gen/bootdata.H
+++ b/include/hobbes/boot/gen/bootdata.H
@@ -1,4 +1,4 @@
-unsigned char __amapping_hob[] = {
+unsigned char _amapping_hob[] = {
   0x0a, 0x2f, 0x2a, 0x0a, 0x20, 0x20, 0x42, 0x61, 0x73, 0x69, 0x63, 0x20,
   0x6f, 0x76, 0x65, 0x72, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20,
   0x66, 0x6f, 0x72, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x6e,
@@ -455,8 +455,8 @@ unsigned char __amapping_hob[] = {
   0x72, 0x61, 0x79, 0x56, 0x69, 0x65, 0x77, 0x20, 0x3d, 0x20, 0x6c, 0x6f,
   0x61, 0x64, 0x0a
 };
-unsigned int __amapping_hob_len = 5451;
-unsigned char __arith_hob[] = {
+unsigned int _amapping_hob_len = 5451;
+unsigned char _arith_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x61, 0x72, 0x69, 0x74, 0x68, 0x6d,
   0x65, 0x74, 0x69, 0x63, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x6f, 0x61,
   0x64, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x2a, 0x2f, 0x0a, 0x0a, 0x2f, 0x2f,
@@ -1007,8 +1007,8 @@ unsigned char __arith_hob[] = {
   0x20, 0x78, 0x20, 0x25, 0x20, 0x28, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72,
   0x74, 0x28, 0x79, 0x29, 0x20, 0x3a, 0x3a, 0x20, 0x62, 0x29, 0x0a, 0x0a
 };
-unsigned int __arith_hob_len = 6588;
-unsigned char __convert_hob[] = {
+unsigned int _arith_hob_len = 6588;
+unsigned char _convert_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72,
   0x74, 0x20, 0x3a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x22,
   0x6d, 0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x2d, 0x70, 0x72, 0x65, 0x73,
@@ -1407,8 +1407,8 @@ unsigned char __convert_hob[] = {
   0x54, 0x61, 0x69, 0x6c, 0x28, 0x73, 0x72, 0x63, 0x29, 0x2c, 0x20, 0x64,
   0x73, 0x74, 0x29, 0x3b, 0x7d, 0x0a, 0x0a
 };
-unsigned int __convert_hob_len = 4759;
-unsigned char __eq_hob[] = {
+unsigned int _convert_hob_len = 4759;
+unsigned char _eq_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x69,
   0x74, 0x79, 0x2f, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e,
   0x63, 0x65, 0x2f, 0x6e, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x73, 0x73, 0x20,
@@ -1753,8 +1753,8 @@ unsigned char __eq_hob[] = {
   0x28, 0x61, 0x73, 0x2c, 0x20, 0x62, 0x73, 0x2c, 0x20, 0x30, 0x4c, 0x29,
   0x0a, 0x0a
 };
-unsigned int __eq_hob_len = 4106;
-unsigned char __eqord_hob[] = {
+unsigned int _eq_hob_len = 4106;
+unsigned char _eqord_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x69,
   0x6e, 0x67, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x6f, 0x61, 0x64, 0x69,
   0x6e, 0x67, 0x0a, 0x20, 0x2a, 0x2f, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73,
@@ -2395,8 +2395,8 @@ unsigned char __eqord_hob[] = {
   0x20, 0x20, 0x78, 0x20, 0x3e, 0x3d, 0x20, 0x28, 0x63, 0x6f, 0x6e, 0x76,
   0x65, 0x72, 0x74, 0x28, 0x79, 0x29, 0x3a, 0x3a, 0x61, 0x29, 0x0a, 0x0a
 };
-unsigned int __eqord_hob_len = 7668;
-unsigned char __farray_hob[] = {
+unsigned int _eqord_hob_len = 7668;
+unsigned char _farray_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x63, 0x6f, 0x6d,
   0x6d, 0x6f, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x66, 0x75,
   0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x61, 0x6c, 0x6c, 0x69,
@@ -3430,8 +3430,8 @@ unsigned char __farray_hob[] = {
   0x29, 0x0a, 0x7d, 0x0a, 0x7b, 0x2d, 0x23, 0x20, 0x53, 0x41, 0x46, 0x45,
   0x20, 0x75, 0x6e, 0x7a, 0x69, 0x70, 0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a
 };
-unsigned int __farray_hob_len = 12384;
-unsigned char __farrfilt_hob[] = {
+unsigned int _farray_hob_len = 12384;
+unsigned char _farrfilt_hob[] = {
   0x2f, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x66, 0x61,
   0x72, 0x72, 0x66, 0x69, 0x6c, 0x74, 0x20, 0x3a, 0x20, 0x65, 0x66, 0x66,
   0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65,
@@ -4169,8 +4169,8 @@ unsigned char __farrfilt_hob[] = {
   0x20, 0x74, 0x61, 0x6b, 0x65, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x52, 0x20,
   0x23, 0x2d, 0x7d, 0x0a, 0x0a
 };
-unsigned int __farrfilt_hob_len = 8825;
-unsigned char __flip_hob[] = {
+unsigned int _farrfilt_hob_len = 8825;
+unsigned char _flip_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x66, 0x6c, 0x69, 0x70, 0x20, 0x61, 0x6e, 0x20,
   0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x63,
   0x6f, 0x72, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x20,
@@ -4238,8 +4238,8 @@ unsigned char __flip_hob[] = {
   0x20, 0x5b, 0x61, 0x74, 0x5d, 0x2c, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72,
   0x64, 0x54, 0x61, 0x69, 0x6c, 0x28, 0x79, 0x29, 0x29, 0x0a, 0x0a
 };
-unsigned int __flip_hob_len = 791;
-unsigned char __fstrfns_hob[] = {
+unsigned int _flip_hob_len = 791;
+unsigned char _fstrfns_hob[] = {
   0x0a, 0x66, 0x69, 0x6e, 0x64, 0x53, 0x75, 0x62, 0x73, 0x65, 0x71, 0x53,
   0x74, 0x65, 0x70, 0x20, 0x3a, 0x3a, 0x20, 0x28, 0x45, 0x71, 0x75, 0x69,
   0x76, 0x20, 0x61, 0x20, 0x62, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x28, 0x5b,
@@ -4290,8 +4290,8 @@ unsigned char __fstrfns_hob[] = {
   0x68, 0x28, 0x73, 0x73, 0x29, 0x2c, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74,
   0x68, 0x28, 0x73, 0x29, 0x29, 0x29, 0x0a, 0x0a
 };
-unsigned int __fstrfns_hob_len = 584;
-unsigned char __hasdef_hob[] = {
+unsigned int _fstrfns_hob_len = 584;
+unsigned char _hasdef_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
   0x74, 0x0a, 0x20, 0x2a, 0x2f, 0x0a, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73,
   0x20, 0x48, 0x61, 0x73, 0x44, 0x65, 0x66, 0x20, 0x61, 0x20, 0x77, 0x68,
@@ -4313,8 +4313,8 @@ unsigned char __hasdef_hob[] = {
   0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x64, 0x65, 0x66, 0x20,
   0x3d, 0x20, 0x7c, 0x31, 0x3d, 0x64, 0x65, 0x66, 0x7c, 0x0a, 0x0a
 };
-unsigned int __hasdef_hob_len = 239;
-unsigned char __list_hob[] = {
+unsigned int _hasdef_hob_len = 239;
+unsigned char _list_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x66, 0x75, 0x6e,
   0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x6e, 0x69, 0x6c, 0x20, 0x3a,
   0x3a, 0x20, 0x28, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x28, 0x5e, 0x78, 0x2e,
@@ -4740,8 +4740,8 @@ unsigned char __list_hob[] = {
   0x20, 0x30, 0x4c, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65, 0x29, 0x29, 0x29,
   0x0a
 };
-unsigned int __list_hob_len = 5077;
-unsigned char __lookup_hob[] = {
+unsigned int _list_hob_len = 5077;
+unsigned char _lookup_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20,
   0x3a, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x70, 0x72,
   0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x2a, 0x2f, 0x0a,
@@ -4850,8 +4850,8 @@ unsigned char __lookup_hob[] = {
   0x6f, 0x6b, 0x75, 0x70, 0x28, 0x6b, 0x2c, 0x20, 0x76, 0x73, 0x29, 0x7c,
   0x0a, 0x0a
 };
-unsigned int __lookup_hob_len = 1274;
-unsigned char __maybe_hob[] = {
+unsigned int _lookup_hob_len = 1274;
+unsigned char _maybe_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x6d, 0x61, 0x79, 0x62, 0x65, 0x0a,
   0x20, 0x2a, 0x2f, 0x0a, 0x0a, 0x2f, 0x2f, 0x20, 0x5b, 0x64, 0x6f, 0x63,
   0x5d, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73,
@@ -5287,8 +5287,8 @@ unsigned char __maybe_hob[] = {
   0x65, 0x6e, 0x75, 0x6d, 0x20, 0x3d, 0x20, 0x75, 0x6e, 0x73, 0x61, 0x66,
   0x65, 0x43, 0x61, 0x73, 0x74, 0x0a, 0x0a
 };
-unsigned int __maybe_hob_len = 5203;
-unsigned char __patterns_hob[] = {
+unsigned int _maybe_hob_len = 5203;
+unsigned char _patterns_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x20, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72,
   0x74, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20,
   0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x66,
@@ -5716,8 +5716,8 @@ unsigned char __patterns_hob[] = {
   0x20, 0x78, 0x73, 0x20, 0x3d, 0x20, 0x6d, 0x66, 0x6c, 0x61, 0x74, 0x74,
   0x65, 0x6e, 0x28, 0x78, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a, 0x0a
 };
-unsigned int __patterns_hob_len = 5112;
-unsigned char __proccodec_hob[] = {
+unsigned int _patterns_hob_len = 5112;
+unsigned char _proccodec_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20,
   0x72, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20,
   0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x61, 0x6c, 0x75,
@@ -6156,8 +6156,8 @@ unsigned char __proccodec_hob[] = {
   0x73, 0x61, 0x66, 0x65, 0x43, 0x61, 0x73, 0x74, 0x28, 0x78, 0x29, 0x3a,
   0x3a, 0x72, 0x29, 0x0a, 0x0a
 };
-unsigned int __proccodec_hob_len = 5237;
-unsigned char __read_hob[] = {
+unsigned int _proccodec_hob_len = 5237;
+unsigned char _read_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69,
   0x63, 0x20, 0x64, 0x65, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a,
   0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x73,
@@ -6254,8 +6254,8 @@ unsigned char __read_hob[] = {
   0x22, 0x22, 0x29, 0x20, 0x7c, 0x20, 0x5f, 0x20, 0x2d, 0x3e, 0x20, 0x6e,
   0x6f, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x0a, 0x0a
 };
-unsigned int __read_hob_len = 1136;
-unsigned char __set_hob[] = {
+unsigned int _read_hob_len = 1136;
+unsigned char _set_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x73, 0x65, 0x74, 0x73, 0x0a, 0x20,
   0x2a, 0x2f, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x53, 0x65, 0x74,
   0x20, 0x61, 0x20, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20,
@@ -6393,8 +6393,8 @@ unsigned char __set_hob[] = {
   0x20, 0x69, 0x6e, 0x20, 0x78, 0x73, 0x20, 0x7c, 0x20, 0x5f, 0x20, 0x2d,
   0x3e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x0a, 0x0a
 };
-unsigned int __set_hob_len = 1629;
-unsigned char __show_hob[] = {
+unsigned int _set_hob_len = 1629;
+unsigned char _show_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69,
   0x63, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74,
   0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x69, 0x73, 0x70,
@@ -7121,8 +7121,8 @@ unsigned char __show_hob[] = {
   0x65, 0x0a, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d,
   0x20, 0x73, 0x68, 0x6f, 0x77, 0x0a, 0x0a
 };
-unsigned int __show_hob_len = 8695;
-unsigned char __sort_hob[] = {
+unsigned int _show_hob_len = 8695;
+unsigned char _sort_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x61, 0x20, 0x62, 0x61, 0x73, 0x69,
   0x63, 0x20, 0x69, 0x6e, 0x2d, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x71,
   0x75, 0x69, 0x63, 0x6b, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x6e, 0x20,
@@ -7497,8 +7497,8 @@ unsigned char __sort_hob[] = {
   0x64, 0x53, 0x75, 0x62, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x23, 0x2d,
   0x7d, 0x0a, 0x0a
 };
-unsigned int __sort_hob_len = 4467;
-unsigned char __sscan_hob[] = {
+unsigned int _sort_hob_len = 4467;
+unsigned char _sscan_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d,
   0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e,
   0x63, 0x65, 0x20, 0x73, 0x63, 0x61, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63,
@@ -8248,8 +8248,8 @@ unsigned char __sscan_hob[] = {
   0x63, 0x74, 0x41, 0x73, 0x73, 0x6f, 0x63, 0x6c, 0x52, 0x61, 0x6e, 0x67,
   0x65, 0x20, 0x23, 0x2d, 0x7d, 0x0a, 0x0a
 };
-unsigned int __sscan_hob_len = 8971;
-unsigned char __storage_hob[] = {
+unsigned int _sscan_hob_len = 8971;
+unsigned char _storage_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e,
   0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x65, 0x20,
   0x63, 0x61, 0x6e, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20,
@@ -9357,8 +9357,8 @@ unsigned char __storage_hob[] = {
   0x74, 0x29, 0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x65,
   0x29, 0x29, 0x29, 0x0a, 0x0a
 };
-unsigned int __storage_hob_len = 13265;
-unsigned char __storeslmap_hob[] = {
+unsigned int _storage_hob_len = 13265;
+unsigned char _storeslmap_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x73,
   0x6c, 0x6d, 0x61, 0x70, 0x20, 0x3a, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f,
   0x72, 0x74, 0x20, 0x62, 0x61, 0x73, 0x69, 0x63, 0x20, 0x71, 0x75, 0x65,
@@ -9460,8 +9460,8 @@ unsigned char __storeslmap_hob[] = {
   0x6e, 0x74, 0x73, 0x28, 0x78, 0x73, 0x2c, 0x20, 0x30, 0x4c, 0x2c, 0x20,
   0x73, 0x69, 0x7a, 0x65, 0x28, 0x78, 0x73, 0x29, 0x29, 0x29, 0x0a, 0x0a
 };
-unsigned int __storeslmap_hob_len = 1200;
-unsigned char __streams_hob[] = {
+unsigned int _storeslmap_hob_len = 1200;
+unsigned char _streams_hob[] = {
   0x0a, 0x2f, 0x2f, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
   0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x69, 0x6e,
   0x69, 0x74, 0x65, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65,
@@ -9624,8 +9624,8 @@ unsigned char __streams_hob[] = {
   0x3b, 0x20, 0x70, 0x75, 0x74, 0x53, 0x74, 0x72, 0x28, 0x22, 0x2e, 0x2e,
   0x2e, 0x22, 0x29, 0x3b, 0x20, 0x7d, 0x0a, 0x0a
 };
-unsigned int __streams_hob_len = 1928;
-unsigned char __strings_hob[] = {
+unsigned int _streams_hob_len = 1928;
+unsigned char _strings_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
   0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x6f, 0x63,
   0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
@@ -9674,8 +9674,8 @@ unsigned char __strings_hob[] = {
   0x3d, 0x3d, 0x3d, 0x20, 0x6c, 0x63, 0x61, 0x73, 0x65, 0x28, 0x62, 0x73,
   0x29, 0x0a, 0x0a
 };
-unsigned int __strings_hob_len = 555;
-unsigned char __table_hob[] = {
+unsigned int _strings_hob_len = 555;
+unsigned char _table_hob[] = {
   0x2f, 0x2a, 0x0a, 0x20, 0x2a, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
   0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20,
   0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x0a, 0x20, 0x2a, 0x2f, 0x0a,
@@ -10319,8 +10319,8 @@ unsigned char __table_hob[] = {
   0x69, 0x70, 0x70, 0x65, 0x64, 0x28, 0x66, 0x6c, 0x69, 0x70, 0x28, 0x78,
   0x29, 0x29, 0x0a
 };
-unsigned int __table_hob_len = 7695;
-unsigned char __zstorage_hob[] = {
+unsigned int _table_hob_len = 7695;
+unsigned char _zstorage_hob[] = {
   0x2f, 0x2f, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x0a, 0x69,
   0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x28, 0x74, 0x2f, 0x70,
   0x3a, 0x3a, 0x78, 0x29, 0x20, 0x3d, 0x3e, 0x20, 0x53, 0x4c, 0x6f, 0x6f,
@@ -12060,60 +12060,60 @@ unsigned char __zstorage_hob[] = {
   0x28, 0x66, 0x2c, 0x20, 0x78, 0x73, 0x5b, 0x30, 0x3a, 0x5d, 0x29, 0x0a,
   0x0a
 };
-unsigned int __zstorage_hob_len = 20845;
+unsigned int _zstorage_hob_len = 20845;
 unsigned char* module_defs[] = {
-__amapping_hob,
-__arith_hob,
-__convert_hob,
-__eq_hob,
-__eqord_hob,
-__farray_hob,
-__farrfilt_hob,
-__flip_hob,
-__fstrfns_hob,
-__hasdef_hob,
-__list_hob,
-__lookup_hob,
-__maybe_hob,
-__patterns_hob,
-__proccodec_hob,
-__read_hob,
-__set_hob,
-__show_hob,
-__sort_hob,
-__sscan_hob,
-__storage_hob,
-__storeslmap_hob,
-__streams_hob,
-__strings_hob,
-__table_hob,
-__zstorage_hob,
-0 };
+_amapping_hob,
+_arith_hob,
+_convert_hob,
+_eq_hob,
+_eqord_hob,
+_farray_hob,
+_farrfilt_hob,
+_flip_hob,
+_fstrfns_hob,
+_hasdef_hob,
+_list_hob,
+_lookup_hob,
+_maybe_hob,
+_patterns_hob,
+_proccodec_hob,
+_read_hob,
+_set_hob,
+_show_hob,
+_sort_hob,
+_sscan_hob,
+_storage_hob,
+_storeslmap_hob,
+_streams_hob,
+_strings_hob,
+_table_hob,
+_zstorage_hob,
+nullptr };
 unsigned int module_lens[] = {
-__amapping_hob_len,
-__arith_hob_len,
-__convert_hob_len,
-__eq_hob_len,
-__eqord_hob_len,
-__farray_hob_len,
-__farrfilt_hob_len,
-__flip_hob_len,
-__fstrfns_hob_len,
-__hasdef_hob_len,
-__list_hob_len,
-__lookup_hob_len,
-__maybe_hob_len,
-__patterns_hob_len,
-__proccodec_hob_len,
-__read_hob_len,
-__set_hob_len,
-__show_hob_len,
-__sort_hob_len,
-__sscan_hob_len,
-__storage_hob_len,
-__storeslmap_hob_len,
-__streams_hob_len,
-__strings_hob_len,
-__table_hob_len,
-__zstorage_hob_len,
-0 };
+_amapping_hob_len,
+_arith_hob_len,
+_convert_hob_len,
+_eq_hob_len,
+_eqord_hob_len,
+_farray_hob_len,
+_farrfilt_hob_len,
+_flip_hob_len,
+_fstrfns_hob_len,
+_hasdef_hob_len,
+_list_hob_len,
+_lookup_hob_len,
+_maybe_hob_len,
+_patterns_hob_len,
+_proccodec_hob_len,
+_read_hob_len,
+_set_hob_len,
+_show_hob_len,
+_sort_hob_len,
+_sscan_hob_len,
+_storage_hob_len,
+_storeslmap_hob_len,
+_streams_hob_len,
+_strings_hob_len,
+_table_hob_len,
+_zstorage_hob_len,
+0u };
diff --git a/include/hobbes/cfregion.H b/include/hobbes/cfregion.H
index 36892274d..8d87f9d50 100644
--- a/include/hobbes/cfregion.H
+++ b/include/hobbes/cfregion.H
@@ -38,8 +38,8 @@ namespace hobbes { namespace fregion {
 
 // parameters for arithmetic coding and modeling
 struct arithn {
-  typedef uint32_t code;
-  typedef uint32_t freq;
+  using code = uint32_t;
+  using freq = uint32_t;
 
   static constexpr uint32_t cbits    = 16;
   static constexpr code     cmax     = (code(1) << cbits) - code(1);
@@ -109,7 +109,7 @@ struct cwbitstream {
   size_t* batchNode;
 
   // allocate an initial batch and prepare to write bits
-  cwbitstream(imagefile* file) : file(file), buffer(0), seg(0), batchNode(0) {
+  cwbitstream(imagefile* file) : file(file), buffer(nullptr), seg(nullptr), batchNode(nullptr) {
   }
 
   // initialize a root node from a pair of model states (init and final)
@@ -126,7 +126,7 @@ struct cwbitstream {
 
     // seek to the last buffer (where the next pointer goes to the null batch node)
     if (this->batchNode[0] == 1) {
-      size_t* nextNode = reinterpret_cast<size_t*>(mapFileData(this->file, this->batchNode[2], 3*sizeof(size_t)));
+      auto* nextNode = reinterpret_cast<size_t*>(mapFileData(this->file, this->batchNode[2], 3*sizeof(size_t)));
       while (nextNode[0] == 1) {
         unmapFileData(this->file, this->batchNode, 3*sizeof(size_t));
         this->batchNode = nextNode;
@@ -167,7 +167,7 @@ struct cwbitstream {
   // start a new segment within the current batch
   void stepSegment() {
     this->seg->nextRef = findSpace(this->file, pagetype::data, sizeof(cbatchseg), sizeof(size_t));
-    cbatchseg* newseg = reinterpret_cast<cbatchseg*>(mapFileData(this->file, this->seg->nextRef, sizeof(cbatchseg)));
+    auto* newseg = reinterpret_cast<cbatchseg*>(mapFileData(this->file, this->seg->nextRef, sizeof(cbatchseg)));
     unmapFileData(this->file, this->seg, sizeof(cbatchseg));
     this->seg = newseg;
     this->buffer->bitIndex = 0;
@@ -176,7 +176,7 @@ struct cwbitstream {
   // start a new buffer with a given initial model
   uint64_t stepBuffer(uint64_t initModel, uint64_t scratchModel) {
     // release the old batch
-    if (this->buffer) {
+    if (this->buffer != nullptr) {
       unmapFileData(this->file, this->buffer, sizeof(cbatch));
     }
 
@@ -197,7 +197,7 @@ struct cwbitstream {
     // allocate a new node to hold this new batch
     size_t  nodeSize = 3 * sizeof(size_t);
     size_t  nodeLoc  = findSpace(this->file, pagetype::data, nodeSize, sizeof(size_t));
-    size_t* newNode  = reinterpret_cast<size_t*>(mapFileData(this->file, nodeLoc, nodeSize));
+    auto* newNode  = reinterpret_cast<size_t*>(mapFileData(this->file, nodeLoc, nodeSize));
 
     newNode[0] = 1;
     newNode[1] = batchRef;
@@ -382,7 +382,7 @@ struct crbitstream {
       this->seg      = reinterpret_cast<cbatchseg*>(mapFileData(this->file, this->seg->nextRef, sizeof(cbatchseg)));
       this->bitIndex = 0;
     }
-    bool bit = this->seg->bits[this->bitIndex>>3]&(1<<((this->bitIndex)%8));
+    bool bit = (this->seg->bits[this->bitIndex>>3]&(1<<((this->bitIndex)%8))) != 0;
     ++this->bitIndex;
     return bit;
   }
@@ -451,8 +451,8 @@ struct crbitstream {
 
 template <uint8_t maxSymbol>
   struct cumFreqState {
-    typedef uint16_t index_t;
-    typedef uint16_t symbol;
+    using index_t = uint16_t;
+    using symbol = uint16_t;
 
     static constexpr index_t symbolCount = static_cast<index_t>(maxSymbol)+1;
     static constexpr symbol  esc         = static_cast<symbol>(symbolCount);
@@ -503,10 +503,10 @@ template <uint8_t maxSymbol>
 template <uint8_t maxSymbol = 0xff>
   struct dmodel0 : public cumFreqState<maxSymbol> {
   public:
-    typedef cumFreqState<maxSymbol> CFS;
-    typedef typename CFS::index_t   index_t;
-    typedef typename CFS::symbol    symbol;
-    typedef typename CFS::CModel    CModel;
+    using CFS = cumFreqState<maxSymbol>;
+    using index_t = typename CFS::index_t;
+    using symbol = typename CFS::symbol;
+    using CModel = typename CFS::CModel;
 
     static constexpr index_t symbolCount = CFS::symbolCount;
     static constexpr symbol  esc         = CFS::esc;
@@ -598,8 +598,8 @@ template <typename T, typename P = void>
 // nothing compresses to nothing (that's a positive statement)
 template <>
   struct compress<unit> {
-    typedef int PModel;
-    typedef int CModel;
+    using PModel = int;
+    using CModel = int;
 
     static void init(const PModel&, CModel*) { }
     static void write(cwbitstream*, PModel*, CModel*, unit) { }
@@ -609,10 +609,10 @@ template <>
 // compressed a fixed set of values, cast to a (possibly larger) type
 template <uint8_t maxSym, typename AsSym>
   struct compressFixedSet {
-    typedef dmodel0<maxSym>    M;
-    typedef typename M::PModel PModel;
-    typedef typename M::CModel CModel;
-    typedef typename M::symbol symbol;
+    using M = dmodel0<maxSym>;
+    using PModel = typename M::PModel;
+    using CModel = typename M::CModel;
+    using symbol = typename M::symbol;
 
     static const arithn::code escRange = static_cast<arithn::code>(maxSym)+1;
 
@@ -621,7 +621,7 @@ template <uint8_t maxSym, typename AsSym>
     }
 
     static void write(cwbitstream* bits, PModel* pm, CModel* cm, AsSym s) {
-      uint8_t c = static_cast<uint8_t>(s);
+      auto c = static_cast<uint8_t>(s);
       arithn::code clow, chigh;
       if (M::find(cm, c, &clow, &chigh)) {
         bits->write(clow, chigh, M::interval(cm));
@@ -641,7 +641,7 @@ template <uint8_t maxSym, typename AsSym>
       rbits->shift(clow, chigh, M::interval(cm));
 
       if (s == M::esc) {
-        symbol nc = static_cast<symbol>(rbits->svalue(escRange));
+        auto nc = static_cast<symbol>(rbits->svalue(escRange));
         rbits->shift(nc, nc+1, escRange);
         M::add(pm, cm, nc);
         *c = static_cast<AsSym>(static_cast<uint8_t>(nc));
@@ -704,11 +704,11 @@ template <> struct compress<size_t> : public compressByteSeq<size_t> { };
 // to compress floating point numbers, treat them like a structure {sign:bool, exp:b, val:nat}
 template <typename T, typename Exp, typename Val, Val ExpWidth, Val ValWidth>
   struct compressFloat {
-    typedef compress<bool> CSign;
-    typedef compress<Exp>  CExp;
-    typedef compress<Val>  CVal;
-    typedef tuple<typename CSign::PModel, typename CExp::PModel, typename CVal::PModel> PModel;
-    typedef tuple<typename CSign::CModel, typename CExp::CModel, typename CVal::CModel> CModel;
+    using CSign = compress<bool>;
+    using CExp = compress<Exp>;
+    using CVal = compress<Val>;
+    using PModel = tuple<typename CSign::PModel, typename CExp::PModel, typename CVal::PModel>;
+    using CModel = tuple<typename CSign::CModel, typename CExp::CModel, typename CVal::CModel>;
 
     static void init(const PModel& pm, CModel* cm) {
       CSign::init(pm.template at<0>(), &cm->template at<0>());
@@ -749,13 +749,13 @@ template <> struct compress<double> : public compressByteSeq<double> { };
 #endif
 
 // compress tuples, pairs and structures
-template <typename T> struct PModelOf { typedef typename compress<T>::PModel type; };
-template <typename T> struct CModelOf { typedef typename compress<T>::CModel type; };
+template <typename T> struct PModelOf { using type = typename compress<T>::PModel; };
+template <typename T> struct CModelOf { using type = typename compress<T>::CModel; };
 
 template <size_t i, size_t n, typename PModel, typename CModel, typename ... Ts>
   struct compressTuple {
-    typedef typename nth<i, Ts...>::type H;
-    typedef compressTuple<i+1, n, PModel, CModel, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using Recurse = compressTuple<i + 1, n, PModel, CModel, Ts...>;
 
     static void init(const PModel& pm, CModel* cm) {
       compress<H>::init(pm.template at<i>(), &cm->template at<i>());
@@ -779,9 +779,9 @@ template <size_t n, typename PModel, typename CModel, typename ... Ts>
 
 template <typename ... Fields>
   struct compress<tuple<Fields...>> {
-    typedef typename fmap<PModelOf, tuple<Fields...>>::type PModel;
-    typedef typename fmap<CModelOf, tuple<Fields...>>::type CModel;
-    typedef compressTuple<0, sizeof...(Fields), PModel, CModel, Fields...> Reflect;
+    using PModel = typename fmap<PModelOf, tuple<Fields...>>::type;
+    using CModel = typename fmap<CModelOf, tuple<Fields...>>::type;
+    using Reflect = compressTuple<0, sizeof...(Fields), PModel, CModel, Fields...>;
 
     static void init(const PModel& pm, CModel* cm)                                           { Reflect::init(pm, cm); }
     static void write(cwbitstream* bits,  PModel* pm, CModel* cm, const tuple<Fields...>& t) { Reflect::write(bits, pm, cm, t); }
@@ -790,10 +790,10 @@ template <typename ... Fields>
 
 template <typename U, typename V>
   struct compress<std::pair<U,V>> {
-    typedef std::pair<U,V> T;
-    typedef tuple<U,V>     TT;
-    typedef typename compress<TT>::PModel PModel;
-    typedef typename compress<TT>::CModel CModel;
+    using T = std::pair<U, V>;
+    using TT = tuple<U, V>;
+    using PModel = typename compress<TT>::PModel;
+    using CModel = typename compress<TT>::CModel;
 
     static void init(const PModel& pm, CModel* cm)                            { compress<TT>::init(pm, cm); }
     static void write(cwbitstream* bits,  PModel* pm, CModel* cm, const T& t) { compress<TT>::write(bits, pm, cm, *reinterpret_cast<const TT*>(&t)); }
@@ -802,9 +802,9 @@ template <typename U, typename V>
 
 template <typename T>
   struct compress<T, typename tbool<T::is_hmeta_struct>::type> {
-    typedef typename T::as_tuple_type TT;
-    typedef typename compress<TT>::PModel PModel;
-    typedef typename compress<TT>::CModel CModel;
+    using TT = typename T::as_tuple_type;
+    using PModel = typename compress<TT>::PModel;
+    using CModel = typename compress<TT>::CModel;
 
     static void init(const PModel& pm, CModel* cm)                            { compress<TT>::init(pm, cm); }
     static void write(cwbitstream* bits,  PModel* pm, CModel* cm, const T& t) { compress<TT>::write(bits, pm, cm, *reinterpret_cast<const TT*>(&t)); }
@@ -815,8 +815,8 @@ template <typename T>
 // these behave like dependent pairs of a size N followed by N values
 template <typename T, typename CT>
   struct compressSequence {
-    typedef std::pair<compress<size_t>::PModel, typename compress<T>::PModel> PModel;
-    typedef std::pair<compress<size_t>::CModel, typename compress<T>::CModel> CModel;
+    using PModel = std::pair<compress<size_t>::PModel, typename compress<T>::PModel>;
+    using CModel = std::pair<compress<size_t>::CModel, typename compress<T>::CModel>;
 
     static void init(const PModel& pm, CModel* cm) {
       compress<size_t>::init(pm.first,  &cm->first);
@@ -853,15 +853,15 @@ template <size_t C, typename P = void>
   };
 template <size_t C>
   struct compressEnum<C, typename tbool<(C < 256)>::type> : public compressFixedSet<static_cast<uint8_t>(C)-1, uint8_t> {
-    typedef uint8_t element;
+    using element = uint8_t;
   };
 
 template <typename T>
   struct compress<T, typename tbool<T::is_hmeta_enum>::type> {
-    typedef compressEnum<T::ctorCount> R;
-    typedef typename R::PModel  PModel;
-    typedef typename R::CModel  CModel;
-    typedef typename R::element element;
+    using R = compressEnum<T::ctorCount>;
+    using PModel = typename R::PModel;
+    using CModel = typename R::CModel;
+    using element = typename R::element;
 
     static void init(const PModel& pm, CModel* cm) {
       R::init(pm, cm);
@@ -878,8 +878,8 @@ template <typename T>
 
 template <size_t tag, typename T, typename M>
   struct variantCompressor {
-    typedef typename M::first_type  PModel;
-    typedef typename M::second_type CModel;
+    using PModel = typename M::first_type;
+    using CModel = typename M::second_type;
 
     static void fn(T* p, cwbitstream* bits, PModel* pm, CModel* cm) {
       compress<T>::write(bits, &pm->template at<tag>(), &cm->template at<tag>(), *p);
@@ -887,8 +887,8 @@ template <size_t tag, typename T, typename M>
   };
 template <size_t tag, typename T, typename M>
   struct variantDecompressor {
-    typedef typename M::first_type  PModel;
-    typedef typename M::second_type CModel;
+    using PModel = typename M::first_type;
+    using CModel = typename M::second_type;
 
     static void fn(T* p, crbitstream* rbits, PModel* pm, CModel* cm) {
       new (p) T();
@@ -898,19 +898,19 @@ template <size_t tag, typename T, typename M>
 
 template <typename ... Ctors>
   struct compress<variant<Ctors...>> {
-    typedef compressEnum<sizeof...(Ctors)> TagC;
-    typedef typename TagC::PModel TagPModel;
-    typedef typename TagC::CModel TagCModel;
-    typedef typename TagC::element TagElement;
+    using TagC = compressEnum<sizeof...(Ctors)>;
+    using TagPModel = typename TagC::PModel;
+    using TagCModel = typename TagC::CModel;
+    using TagElement = typename TagC::element;
 
-    typedef typename fmap<PModelOf, tuple<Ctors...>>::type PayloadPModel;
-    typedef typename fmap<CModelOf, tuple<Ctors...>>::type PayloadCModel;
-    typedef compressTuple<0, sizeof...(Ctors), PayloadPModel, PayloadCModel, Ctors...> PayloadReflect;
+    using PayloadPModel = typename fmap<PModelOf, tuple<Ctors...>>::type;
+    using PayloadCModel = typename fmap<CModelOf, tuple<Ctors...>>::type;
+    using PayloadReflect = compressTuple<0, sizeof...(Ctors), PayloadPModel, PayloadCModel, Ctors...>;
 
-    typedef std::pair<TagPModel, PayloadPModel> PModel;
-    typedef std::pair<TagCModel, PayloadCModel> CModel;
+    using PModel = std::pair<TagPModel, PayloadPModel>;
+    using CModel = std::pair<TagCModel, PayloadCModel>;
 
-    typedef std::pair<PayloadPModel, PayloadCModel> PayloadModels;
+    using PayloadModels = std::pair<PayloadPModel, PayloadCModel>;
 
     static void init(const PModel& pm, CModel* cm) {
       TagC::init(pm.first, &cm->first);
@@ -930,9 +930,9 @@ template <typename ... Ctors>
 
 template <typename T>
   struct compress<T, typename tbool<T::is_hmeta_variant>::type> {
-    typedef typename T::as_variant_type VT;
-    typedef typename compress<VT>::PModel PModel;
-    typedef typename compress<VT>::CModel CModel;
+    using VT = typename T::as_variant_type;
+    using PModel = typename compress<VT>::PModel;
+    using CModel = typename compress<VT>::CModel;
 
     static void init(const PModel& pm, CModel* cm)                            { compress<VT>::init(pm, cm); }
     static void write(cwbitstream* bits,  PModel* pm, CModel* cm, const T& t) { compress<VT>::write(bits, pm, cm, *reinterpret_cast<const VT*>(&t)); }
@@ -941,9 +941,9 @@ template <typename T>
 
 template <typename T>
   struct compress<T, typename tbool<T::is_hmeta_alias>::type> {
-    typedef typename T::type RT;
-    typedef typename compress<RT>::PModel PModel;
-    typedef typename compress<RT>::CModel CModel;
+    using RT = typename T::type;
+    using PModel = typename compress<RT>::PModel;
+    using CModel = typename compress<RT>::CModel;
 
     static void init(const PModel& pm, CModel* cm)                            { compress<RT>::init(pm, cm); }
     static void write(cwbitstream* bits,  PModel* pm, CModel* cm, const T& t) { compress<RT>::write(bits, pm, cm, *reinterpret_cast<const RT*>(&t)); }
@@ -963,7 +963,7 @@ inline ty::desc storedBitSeqType() {
   ty::desc bt = store<cbatchseg>::storeType();
 
   if (bt->tid == PRIV_HPPF_TYCTOR_STRUCT) {
-    ty::Struct* s = reinterpret_cast<ty::Struct*>(bt.get());
+    auto* s = reinterpret_cast<ty::Struct*>(bt.get());
     size_t pc = 0;
 
     for (auto& f : s->fields) {
@@ -986,7 +986,7 @@ inline ty::desc storedCompressedSeqTypeDef(const ty::desc& t, const ty::desc& mo
   ty::desc bt = store<cbatch>::storeType();
 
   if (bt->tid == PRIV_HPPF_TYCTOR_STRUCT) {
-    ty::Struct* s = reinterpret_cast<ty::Struct*>(bt.get());
+    auto* s = reinterpret_cast<ty::Struct*>(bt.get());
     size_t pc = 0;
 
     for (auto& f : s->fields) {
@@ -1025,7 +1025,7 @@ inline size_t inferCompressedBatchSize(const bytes& bs) {
   ty::desc t = ty::decode(bs);
 
   if (t->tid == PRIV_HPPF_TYCTOR_TAPP) {
-    auto ap = reinterpret_cast<const ty::App*>(t.get());
+    const auto *ap = reinterpret_cast<const ty::App*>(t.get());
 
     if (ap->f->tid == PRIV_HPPF_TYCTOR_PRIM && ap->args.size() == 3) {
       if (reinterpret_cast<const ty::Prim*>(ap->f.get())->n == "cseq") {
@@ -1049,8 +1049,8 @@ inline size_t inferCompressedBatchSize(const bytes& bs) {
 template <typename T>
   class cwseries : public seriesi {
   public:
-    typedef typename compress<T>::PModel PModel;
-    typedef typename compress<T>::CModel CModel;
+    using PModel = typename compress<T>::PModel;
+    using CModel = typename compress<T>::CModel;
 
     cwseries(imagefile* f, const std::string& seqname, size_t maxBatchSize) : tdef(ty::elimFileRefs(store<T>::storeType())), f(f), seqname(seqname), batchSize(maxBatchSize), out(f) {
       // determine sequence types
@@ -1068,7 +1068,7 @@ template <typename T>
 
         // define the sequence and prepare to write to it
         size_t  headNodeRef = findSpace(this->f, pagetype::data, sizeof(size_t), sizeof(size_t));
-        size_t* headNode    = reinterpret_cast<size_t*>(mapFileData(this->f, headNodeRef, sizeof(size_t)));
+        auto* headNode    = reinterpret_cast<size_t*>(mapFileData(this->f, headNodeRef, sizeof(size_t)));
         *headNode = this->out.initFresh(initModelRef, this->scratchModelRef);
         addBinding(this->f, this->seqname, ty::encoding(this->stdef), headNodeRef);
         unmapFileData(this->f, headNode, sizeof(size_t));
@@ -1076,7 +1076,7 @@ template <typename T>
         throw std::runtime_error("Can't write to sequence " + seqname + " as type '" + ty::show(this->stdef) + "', already defined as type '" + ty::show(ty::decode(b->second.type)) + "'");
       } else {
         // load the head batch and initialize from it
-        size_t* headNode      = reinterpret_cast<size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
+        auto* headNode      = reinterpret_cast<size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
         this->scratchModelRef = this->out.initFromRoot(*headNode, sizeof(PModel));
         this->scratchModel    = reinterpret_cast<PModel*>(mapFileData(this->f, this->scratchModelRef, sizeof(PModel)));
 
@@ -1084,12 +1084,11 @@ template <typename T>
         unmapFileData(this->f, headNode, sizeof(size_t));
       }
     }
-    ~cwseries() {
-    }
+    ~cwseries() = default;
     cwseries(const cwseries<T>&) = delete;
     cwseries<T>& operator=(const cwseries<T>&) = delete;
 
-    const ty::desc&    typeDef()  const { return this->tdef; }
+    const ty::desc&    typeDef()  const override { return this->tdef; }
     const std::string& name()     const { return this->seqname; }
     imagefile*         file()     const { return this->f; }
 
@@ -1102,7 +1101,7 @@ template <typename T>
 
         // allocate/initialize the model for this bitstream segment (from the terminal state of the scratch model for the previous segment)
         uint64_t newScratchModelRef = findSpace(this->f, pagetype::data, sizeof(PModel), sizeof(size_t));
-        PModel*  newScratchModel    = reinterpret_cast<PModel*>(mapFileData(this->f, newScratchModelRef, sizeof(PModel)));
+        auto*  newScratchModel    = reinterpret_cast<PModel*>(mapFileData(this->f, newScratchModelRef, sizeof(PModel)));
         memcpy(reinterpret_cast<void*>(newScratchModel), this->scratchModel, sizeof(PModel));
         unmapFileData(this->f, this->scratchModel, sizeof(PModel));
 
@@ -1162,7 +1161,7 @@ public:
     write(this->f, static_cast<uint8_t>(0x0d));
   }
 private:
-  typedef std::map<std::string, seriesi*> wseriess;
+  using wseriess = std::map<std::string, seriesi *>;
   imagefile* f;
   wseriess   ss;
 };
@@ -1171,8 +1170,8 @@ private:
 template <typename T>
   class crseries : public seriesi {
   public:
-    typedef typename compress<T>::PModel PModel;
-    typedef typename compress<T>::CModel CModel;
+    using PModel = typename compress<T>::PModel;
+    using CModel = typename compress<T>::CModel;
 
     crseries(imagefile* f, const std::string& seqname, const binding& b) : tdef(ty::elimFileRefs(store<T>::storeType())), f(f), batchSize(inferCompressedBatchSize(b.type)), readState(f) {
       // determine value and sequence types
@@ -1189,10 +1188,9 @@ template <typename T>
     }
     crseries(imagefile* f, const std::string& seqname) : crseries(f, seqname, loadBinding(f, seqname)) {
     }
-    ~crseries() {
-    }
+    ~crseries() = default;
 
-    const ty::desc& typeDef()  const { return this->tdef; }
+    const ty::desc& typeDef()  const override { return this->tdef; }
     imagefile*      file()     const { return this->f; }
 
     bool next(T* x) {
@@ -1232,7 +1230,7 @@ template <typename T>
 
     void loadReadState(uint64_t root) {
       while (root != 0) {
-        uint64_t* d = reinterpret_cast<uint64_t*>(mapFileData(this->f, root, 3*sizeof(uint64_t)));
+        auto* d = reinterpret_cast<uint64_t*>(mapFileData(this->f, root, 3*sizeof(uint64_t)));
         if (d[0] == 0) {
           root = 0;
         } else {
@@ -1251,14 +1249,14 @@ template <typename T>
       }
 
       if (this->batches.size() == 0) {
-        this->readState.buffer = 0;
+        this->readState.buffer = nullptr;
         return false;
       } else {
         // load this compressed data segment
         this->readState.reset(reinterpret_cast<const cbatch*>(mapFileData(this->f, this->batches.front(), sizeof(cbatch))));
 
         // initialize the model for this batch
-        const uint8_t* modelState = reinterpret_cast<const uint8_t*>(mapFileData(this->f, this->readState.buffer->initModel, sizeof(PModel)));
+        const auto* modelState = reinterpret_cast<const uint8_t*>(mapFileData(this->f, this->readState.buffer->initModel, sizeof(PModel)));
         memcpy(reinterpret_cast<void*>(&this->scratchModel), modelState, sizeof(PModel));
         unmapFileData(this->f, reinterpret_cast<const void*>(modelState), sizeof(PModel));
         compress<T>::init(this->scratchModel, &this->scratchModelState);
@@ -1301,7 +1299,7 @@ public:
       return rordering(this->f, name);
     }
 private:
-  typedef std::map<std::string, seriesi*> rseriess;
+  using rseriess = std::map<std::string, seriesi *>;
   imagefile* f;
   rseriess   ss;
 };
diff --git a/include/hobbes/convert.H b/include/hobbes/convert.H
index 9ca97840f..f1c77fbd6 100644
--- a/include/hobbes/convert.H
+++ b/include/hobbes/convert.H
@@ -30,7 +30,7 @@ template <typename T, typename P = void>
 //   and maps into a statically-known type
 template <typename T>
   struct convFn {
-    typedef std::function<void(const void*, T*)> type;
+    using type = std::function<void (const void *, T *)>;
   };
 
 /////////////////////////
@@ -101,7 +101,7 @@ SCAST_CONVERT("double", double, ("char", char), ("byte", uint8_t), ("short", int
 template <typename T, size_t N>
   struct into<std::array<T, N>> {
     static typename convFn<std::array<T,N>>::type from(const ty::desc& t) {
-      const ty::FArr* pfa  = reinterpret_cast<const ty::FArr*>(t.get());
+      const auto* pfa  = reinterpret_cast<const ty::FArr*>(t.get());
 
       if (t->tid != PRIV_HPPF_TYCTOR_FIXEDARR) {
         throw std::runtime_error("Can't convert from " + ty::show(t) + " to " + hobbes::string::demangle<std::array<T,N>>());
@@ -137,8 +137,8 @@ template <typename T, size_t N>
 template <typename T>
   struct StructConvField {
     struct type {
-      typedef T                        value_type;
-      typedef typename convFn<T>::type convert_fn;
+      using value_type = T;
+      using convert_fn = typename convFn<T>::type;
 
       size_t     srcOffset;
       size_t     dstOffset;
@@ -204,8 +204,8 @@ template <typename ConvFns, size_t n, typename ... Ts>
 // the inductive case (apply at the pointed-to field, then continue walking the struct)
 template <typename ConvFns, size_t i, size_t n, typename ... Ts>
   struct ApplyStructConvF<ConvFns, tuple<Ts...>, i, n> {
-    typedef typename nth<i, Ts...>::type H;
-    typedef ApplyStructConvF<ConvFns, tuple<Ts...>, i+1, n> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using Recurse = ApplyStructConvF<ConvFns, tuple<Ts...>, i + 1, n>;
 
     static void apply(const ConvFns& cfns, const void* src, tuple<Ts...>* dst) {
       const auto& cfn = cfns.template at<i>();
@@ -217,15 +217,15 @@ template <typename ConvFns, size_t i, size_t n, typename ... Ts>
 template <typename T>
   struct into<T, typename tbool<T::is_hmeta_struct>::type> {
     static typename convFn<T>::type from(const ty::desc& t) {
-      const ty::Struct* pr = reinterpret_cast<const ty::Struct*>(t.get());
+      const auto* pr = reinterpret_cast<const ty::Struct*>(t.get());
 
       if (t->tid != PRIV_HPPF_TYCTOR_STRUCT) {
         throw std::runtime_error("Can't convert from " + ty::show(t) + " due to kind mismatch (not a struct)");
       } else {
-        typedef typename T::as_tuple_type TT;
+        using TT = typename T::as_tuple_type;
 
         // prepare the conversion map out of the source into the dest
-        typedef typename fmap<StructConvField, TT>::type StructConvF;
+        using StructConvF = typename fmap<StructConvField, TT>::type;
         StructConvF scf;
         MakeStructConvF<T, TT, StructConvF, 0, TT::count>::init(pr, &scf);
 
@@ -246,8 +246,8 @@ template <typename T>
 // a variant conversion function over a variant type holds conversion functions at every possible ctor/payload
 template <typename T>
   struct VariantConvF {
-    typedef std::function<void(const void*, T*)> CtorConvF;
-    typedef std::unordered_map<uint32_t, CtorConvF> Ctors;
+    using CtorConvF = std::function<void (const void *, T *)>;
+    using Ctors = std::unordered_map<uint32_t, CtorConvF>;
 
     Ctors  ctors;
     size_t srcPayloadOffset;
@@ -281,7 +281,7 @@ template <typename DstVariantT, typename VariantConvF, size_t n, typename ... Ts
 template <typename DstVariantT, typename VariantConvF, size_t i, size_t n, typename ... Ts>
   struct MakeVariantConvF<DstVariantT, variant<Ts...>, VariantConvF, i, n> {
     static void init(const ty::Variant* srcTy, VariantConvF* convFs) {
-      typedef typename nth<i, Ts...>::type H;
+      using H = typename nth<i, Ts...>::type;
 
       // figure out how to convert just this constructor (if possible)
       if (const ty::Variant::Ctor* srcCtor = namedCtor(srcTy, DstVariantT::template _hmeta_ctor_name<i>())) {
@@ -301,12 +301,12 @@ template <typename DstVariantT, typename VariantConvF, size_t i, size_t n, typen
 
     // find the definition of the named ctor in the source variant (or return null if there is no such ctor)
     static const ty::Variant::Ctor* namedCtor(const ty::Variant* ty, const std::string& cname) {
-      for (size_t k = 0; k < ty->ctors.size(); ++k) {
-        if (ty->ctors[k].at<0>() == cname) {
-          return &ty->ctors[k];
+      for (const auto &ctor : ty->ctors) {
+        if (ctor.at<0>() == cname) {
+          return &ctor;
         }
       }
-      return 0;
+      return nullptr;
     }
   };
 
@@ -314,12 +314,12 @@ template <typename DstVariantT, typename VariantConvF, size_t i, size_t n, typen
 template <typename T>
   struct into<T, typename tbool<T::is_hmeta_variant>::type> {
     static typename convFn<T>::type from(const ty::desc& t) {
-      const ty::Variant* pv = reinterpret_cast<const ty::Variant*>(t.get());
+      const auto* pv = reinterpret_cast<const ty::Variant*>(t.get());
 
       if (t->tid != PRIV_HPPF_TYCTOR_VARIANT) {
         throw std::runtime_error("Can't convert from " + ty::show(t) + " due to kind mismatch (not a variant)");
       } else {
-        typedef typename T::as_variant_type VT;
+        using VT = typename T::as_variant_type;
 
         // prepare the conversion map out of the source into the dest
         VariantConvF<VT> vcf;
diff --git a/include/hobbes/db/file.H b/include/hobbes/db/file.H
index 479b4b379..be79f7925 100644
--- a/include/hobbes/db/file.H
+++ b/include/hobbes/db/file.H
@@ -50,9 +50,9 @@ template <typename T, bool InStruct>
 // a dbseq is a linked list sequence just like 'seq' except that its links are file offsets rather than memory offsets
 template <typename T>
   struct dbseq {
-    typedef fileref<dbseq<T>*>    link_t;
-    typedef std::pair<T, link_t>  cons_t;
-    typedef variant<unit, cons_t> rep_t;
+    using link_t = fileref<dbseq<T> *>;
+    using cons_t = std::pair<T, link_t>;
+    using rep_t = variant<unit, cons_t>;
 
     rep_t data;
 
@@ -77,48 +77,48 @@ template <typename T, bool InStruct>
 // determine representation type (this is necessary to differentiate types represented by value or reference)
 template <typename T>
   struct frefty {
-    typedef T  type;
-    typedef T* ptr;
+    using type = T;
+    using ptr = T *;
   };
 
 template <typename T>
   struct frefty< array<T> > {
-    typedef array<T>* type;
-    typedef array<T>* ptr;
+    using type = array<T> *;
+    using ptr = array<T> *;
   };
 
 template <typename T>
   struct frefty< array<T>* > {
-    typedef array<T>* type;
-    typedef array<T>* ptr;
+    using type = array<T> *;
+    using ptr = array<T> *;
   };
 
 template <typename T>
   struct frefty< dbseq<T> > {
-    typedef dbseq<T>* type;
-    typedef dbseq<T>* ptr;
+    using type = dbseq<T> *;
+    using ptr = dbseq<T> *;
   };
 
 template <typename T>
   struct frefty< dbseq<T>* > {
-    typedef dbseq<T>* type;
-    typedef dbseq<T>* ptr;
+    using type = dbseq<T> *;
+    using ptr = dbseq<T> *;
   };
 
 template <typename T>
   struct frefty< recursive<T> > {
-    typedef recursive<T>* type;
-    typedef recursive<T>* ptr;
+    using type = recursive<T> *;
+    using ptr = recursive<T> *;
   };
 
 template <typename T>
   struct frefty< recursive<T>* > {
-    typedef recursive<T>* type;
-    typedef recursive<T>* ptr;
+    using type = recursive<T> *;
+    using ptr = recursive<T> *;
   };
 
 // common typedefs
-typedef fileref<array<char>*> strref;
+using strref = fileref<array<char> *>;
 
 // what is the size of a type as represented in storage?
 size_t storageSizeOf(const MonoTypePtr&);
@@ -128,7 +128,7 @@ class cc;
 
 // data file details are internally defined
 namespace fregion { struct imagefile; }
-typedef fregion::imagefile imagefile;
+using imagefile = fregion::imagefile;
 
 // a db reader can only read data from a file
 class reader {
@@ -173,9 +173,9 @@ public:
       unsafeUnloadArray(xs, sizeof(T));
     }
 private:
-  typedef std::vector<uint64_t> StoredOffsets;
-  typedef std::vector<size_t>   StoredOffsetElemSizes;
-  typedef std::vector<size_t>   StoredOffsetSizes;
+  using StoredOffsets = std::vector<uint64_t>;
+  using StoredOffsetElemSizes = std::vector<size_t>;
+  using StoredOffsetSizes = std::vector<size_t>;
 
   StoredOffsets     storedOffsets;
   StoredOffsetSizes storedOffElemSizes;
@@ -184,14 +184,14 @@ public:
   // to speed up dynamic lookups of top-level variables at runtime
   //  (this allows an external user to skip string matching and type structure analysis)
   inline unsigned int pushOffset(uint64_t offset, const MonoTypePtr& ty) {
-    unsigned int r = static_cast<unsigned int>(this->storedOffsets.size());
+    auto r = static_cast<unsigned int>(this->storedOffsets.size());
     this->storedOffsets.push_back(offset);
     if (const Array* a = is<Array>(ty)) {
       this->storedOffElemSizes.push_back(1 + storageSizeOf(a->type()));
     } else {
       this->storedOffElemSizes.push_back(0);
     }
-    this->storedOffSizes.push_back((is<Array>(ty)||storedAsDArray(ty)) ? 0 : storageSizeOf(ty));
+    this->storedOffSizes.push_back(((is<Array>(ty) != nullptr)||storedAsDArray(ty)) ? 0 : storageSizeOf(ty));
     return r;
   }
 
@@ -236,8 +236,8 @@ public:
   int unsafeGetFD() const;
 public:
   // helpful diagnostic functions
-  typedef std::pair<uint8_t, short> PageEntry;
-  typedef array<PageEntry>          PageEntries;
+  using PageEntry = std::pair<uint8_t, short>;
+  using PageEntries = array<PageEntry>;
 
   PageEntries* pageEntries() const;
 protected:
@@ -247,7 +247,7 @@ protected:
     MonoTypePtr type;
     uint64_t    offset;
   };
-  typedef std::unordered_map<std::string, SBinding> SBindings;
+  using SBindings = std::unordered_map<std::string, SBinding>;
   SBindings sbindings;
   void addSBinding(const std::string&, const MonoTypePtr&, uint64_t);
 };
@@ -287,7 +287,7 @@ public:
 
   template <typename TIter>
     fileref<array<typename std::iterator_traits<TIter>::value_type>*> store(TIter b, TIter e) {
-      typedef typename std::iterator_traits<TIter>::value_type T;
+      using T = typename std::iterator_traits<TIter>::value_type;
       size_t len = e - b;
       array<T>* r = store<T>(len);
       for (size_t i = 0; i < len; ++i) {
diff --git a/include/hobbes/db/series.H b/include/hobbes/db/series.H
index 4c7c274f4..dd0f1351d 100644
--- a/include/hobbes/db/series.H
+++ b/include/hobbes/db/series.H
@@ -15,7 +15,7 @@
 
 namespace hobbes {
 
-typedef uint64_t ufileref;
+using ufileref = uint64_t;
 
 // A -> (A)
 MonoTypePtr entuple(const MonoTypePtr&);
@@ -75,7 +75,7 @@ private:
   uint64_t  batchNode;
   uint64_t* headNodeRef;
 
-  typedef void (*StoreFn)(writer*, const void*, void*);
+  using StoreFn = void (*)(writer *, const void *, void *);
   StoreFn storeFn;
 
   void consBatchNode(uint64_t nextPtr);
@@ -91,10 +91,10 @@ public:
   CompressedStoredSeries(cc*, writer*, const std::string&, const MonoTypePtr&, size_t);
   ~CompressedStoredSeries();
 
-  typedef void (*CWriteFn)(UCWriter*, void*, const void*);
-  typedef uint8_t* (*CAllocM)(writer*);
-  typedef void (*CPrepM)(UCWriter*,uint8_t*);
-  typedef void (*CDeallocM)(uint8_t*);
+  using CWriteFn = void (*)(UCWriter *, void *, const void *);
+  using CAllocM = uint8_t *(*)(writer *);
+  using CPrepM = void (*)(UCWriter *, uint8_t *);
+  using CDeallocM = void (*)(uint8_t *);
 
   // where has this series been placed?
   ufileref rootRef() const;
@@ -113,7 +113,7 @@ public:
   // (assumes that this series will live at least as long as the bound function is usable)
   void bindAs(cc*, const std::string&);
 private:
-  typedef std::pair<MonoTypePtr, MonoTypePtr> ModelTypes;
+  using ModelTypes = std::pair<MonoTypePtr, MonoTypePtr>;
 
   writer*     outputFile;
   MonoTypePtr recordType;
diff --git a/include/hobbes/eval/cc.H b/include/hobbes/eval/cc.H
index 18356b21b..1e7b09986 100644
--- a/include/hobbes/eval/cc.H
+++ b/include/hobbes/eval/cc.H
@@ -43,7 +43,7 @@ private:
 };
 
 // parameter parsing for the 'compileFn' family of functions
-typedef std::function<ExprPtr(const std::string &)> ExprParser;
+using ExprParser = std::function<ExprPtr (const std::string &)>;
 
 template <typename... NamesAndExpr> struct PArgl {};
 template <> struct PArgl<ExprPtr> {
@@ -99,20 +99,19 @@ public:
   virtual ~cc();
 
   // parse expressions
-  typedef ModulePtr (*readModuleFileFn)(cc *, const std::string &);
+  using readModuleFileFn = ModulePtr (*)(cc *, const std::string &);
   ModulePtr readModuleFile(const std::string &);
   void setReadModuleFileFn(readModuleFileFn);
 
-  typedef ModulePtr (*readModuleFn)(cc *, const std::string &);
+  using readModuleFn = ModulePtr (*)(cc *, const std::string &);
   ModulePtr readModule(const std::string &);
   void setReadModuleFn(readModuleFn);
 
-  typedef std::pair<std::string, ExprPtr> (*readExprDefnFn)(
-      cc *, const std::string &);
+  using readExprDefnFn = std::pair<std::string, ExprPtr> (*)(cc *, const std::string &);
   std::pair<std::string, ExprPtr> readExprDefn(const std::string &);
   void setReadExprDefnFn(readExprDefnFn);
 
-  typedef ExprPtr (*readExprFn)(cc *, const std::string &);
+  using readExprFn = ExprPtr (*)(cc *, const std::string &);
   ExprPtr readExpr(const std::string &);
   MonoTypePtr readMonoType(const std::string &);
   void setReadExprFn(readExprFn);
@@ -121,7 +120,7 @@ public:
     LexicalAnnotation la;
     std::string lines;
   };
-  typedef void (*gatherUnreachableMatchesFn)(const UnreachableMatches &);
+  using gatherUnreachableMatchesFn = void (*)(const UnreachableMatches &);
   void gatherUnreachableMatches(const UnreachableMatches &m);
   void setGatherUnreachableMatchesFn(gatherUnreachableMatchesFn f);
 
@@ -221,7 +220,7 @@ public:
   void dumpModule();
 
   // get the x86 machine code for an expression (useful for debugging)
-  typedef std::vector<unsigned char> bytes;
+  using bytes = std::vector<unsigned char>;
   bytes machineCodeForExpr(const std::string &expr);
 
   // keep track of C++ classes so that we can perform upcasts where necessary
@@ -262,8 +261,8 @@ public:
   }
 
 private:
-  typedef std::pair<str::seq, MonoTypePtr> TTyDef;
-  typedef std::unordered_map<std::string, TTyDef> TTyDefs;
+  using TTyDef = std::pair<str::seq, MonoTypePtr>;
+  using TTyDefs = std::unordered_map<std::string, TTyDef>;
   TTyDefs ttyDefs;
 
 public:
@@ -271,22 +270,22 @@ public:
   // ("transparent" in the sense that all other aspects of compilation see the
   // fully expanded type)
   void defineTypeAlias(const std::string &name, const str::seq &argNames,
-                       const MonoTypePtr &ty);
-  bool isTypeAliasName(const std::string &name) const;
-  MonoTypePtr replaceTypeAliases(const MonoTypePtr &ty) const;
+                       const MonoTypePtr &ty) override;
+  bool isTypeAliasName(const std::string &name) const override;
+  MonoTypePtr replaceTypeAliases(const MonoTypePtr &ty) const override;
 
   // typedb interface
   PolyTypePtr opaquePtrPolyType(const std::type_info &ti, unsigned int sz,
-                                bool inStruct);
+                                bool inStruct) override;
   MonoTypePtr opaquePtrMonoType(const std::type_info &ti, unsigned int sz,
-                                bool inStruct);
+                                bool inStruct) override;
 
-  PolyTypePtr generalize(const MonoTypePtr &mt) const;
+  PolyTypePtr generalize(const MonoTypePtr &mt) const override;
 
   MonoTypePtr defineNamedType(const std::string &name, const str::seq &argNames,
-                              const MonoTypePtr &ty);
-  bool isTypeName(const std::string &) const;
-  MonoTypePtr namedTypeRepresentation(const std::string &) const;
+                              const MonoTypePtr &ty) override;
+  bool isTypeName(const std::string &) const override;
+  MonoTypePtr namedTypeRepresentation(const std::string &) const override;
 
   // an 'unsafe' compilation method
   //   (the compiled function will conform to the input type description, but
@@ -358,7 +357,7 @@ private:
   int dfaOverNfaMaxRatio = 4;
 
   // the bound root type-def environment
-  typedef std::map<std::string, PolyTypePtr> TypeAliasMap;
+  using TypeAliasMap = std::map<std::string, PolyTypePtr>;
 
   TEnvPtr tenv;
   TypeAliasMap typeAliases;
@@ -378,10 +377,8 @@ public:
   // compiler-local type structure caches for internal use
   std::unordered_map<MonoType *, MonoTypePtr> unappTyDefns;
 
-private:
-  // disable copying
-  cc(const cc &);
-  void operator=(const cc &);
+  cc(const cc &) = delete;
+  void operator=(const cc &) = delete;
 };
 
 #define LIFTCTY(cc, e) (cc).liftMonoType<decltype(e)>()
@@ -394,7 +391,7 @@ template <typename T> struct rccF {
 };
 
 template <typename R, typename... Args> struct rccF<R (*)(Args...)> {
-  typedef R (*cbF)(Args...);
+  using cbF = R (*)(Args...);
   static cbF compile(cc *c, const str::seq &vns, const std::string &expr) {
     return rcast<cbF>(c->unsafeCompileFn(lift<cbF>::type(*c), vns, expr));
   }
diff --git a/include/hobbes/eval/cmodule.H b/include/hobbes/eval/cmodule.H
index 3f183d532..037d4e2c0 100644
--- a/include/hobbes/eval/cmodule.H
+++ b/include/hobbes/eval/cmodule.H
@@ -20,7 +20,7 @@ void popModuleDir();
 void compile(cc*, const ModulePtr& m);
 
 // set language options, display language options
-typedef std::map<std::string, std::string> OptDescs;
+using OptDescs = std::map<std::string, std::string>;
 OptDescs getAllOptions();
 
 ExprPtr translateExprWithOpts(const ModulePtr&, const ExprPtr&);
diff --git a/include/hobbes/eval/func.H b/include/hobbes/eval/func.H
index 2d2243001..f0900f54f 100644
--- a/include/hobbes/eval/func.H
+++ b/include/hobbes/eval/func.H
@@ -16,11 +16,11 @@ inline bool hasPointerRep(const MonoTypePtr& t) {
   if (const OpaquePtr* op = is<OpaquePtr>(rt)) {
     return !op->storedContiguously();
   }
-  return is<Record>(rt) || is<FixedArray>(rt) || is<Array>(rt) || is<Variant>(rt) || is<Recursive>(rt);
+  return (is<Record>(rt) != nullptr) || (is<FixedArray>(rt) != nullptr) || (is<Array>(rt) != nullptr) || (is<Variant>(rt) != nullptr) || (is<Recursive>(rt) != nullptr);
 }
 
 inline bool hasPointerRep(const PolyTypePtr& t) {
-  if (t->typeVariables() > 0 || t->instantiate()->constraints().size() > 0) {
+  if (t->typeVariables() > 0 || !t->instantiate()->constraints().empty()) {
     return false;
   } else {
     return hasPointerRep(requireMonotype(t));
@@ -33,7 +33,7 @@ inline bool isLargeType(const MonoTypePtr& t) {
   if (const OpaquePtr* p = is<OpaquePtr>(rt)) {
     return p->storedContiguously();
   } else {
-    return is<Record>(rt) || is<FixedArray>(rt) || is<Variant>(rt);
+    return (is<Record>(rt) != nullptr) || (is<FixedArray>(rt) != nullptr) || (is<Variant>(rt) != nullptr);
   }
 }
 
diff --git a/include/hobbes/eval/jitcc.H b/include/hobbes/eval/jitcc.H
index d75a28e4c..db1cedd1f 100644
--- a/include/hobbes/eval/jitcc.H
+++ b/include/hobbes/eval/jitcc.H
@@ -119,7 +119,7 @@ public:
   llvm::Value* internConstString(const std::string&);
 
   // get the machine code produced for a given expression
-  typedef std::vector<uint8_t> bytes;
+  using bytes = std::vector<uint8_t>;
   bytes machineCodeForExpr(const ExprPtr&);
 
   // inline all global definitions within an expression
@@ -174,7 +174,7 @@ private:
   std::unique_ptr<llvm::IRBuilder<>> irbuilder;
 
   // the bound root function environment
-  typedef std::map<std::string, op*> FuncEnv;
+  using FuncEnv = std::map<std::string, op *>;
   FuncEnv fenv;
 
   // keep track of variables and local scopes during compilation
@@ -199,7 +199,7 @@ private:
     inline UCF(const std::string& name, const str::seq& argns, const MonoTypes& argtys, const ExprPtr& exp)
       : name(name), argns(argns), argtys(argtys), exp(exp) { }
   };
-  typedef std::vector<UCF> UCFS;
+  using UCFS = std::vector<UCF>;
   void unsafeCompileFunctions(UCFS*);
 
   // keep track of global variables
@@ -239,7 +239,7 @@ private:
   llvm::Value* loadConstant(const std::string&);
 
   // keep some interned strings, helpful for global constants and debug info
-  typedef std::unordered_map<std::string, std::string> InternConstVars;
+  using InternConstVars = std::unordered_map<std::string, std::string>;
   InternConstVars internConstVars;
 
 #if LLVM_VERSION_MAJOR >= 11
@@ -258,7 +258,7 @@ private:
 
   // keep track of monotyped definitions as expressions
   // (in case we want to inline them later)
-  typedef std::map<std::string, ExprPtr> GlobalExprs;
+  using GlobalExprs = std::map<std::string, ExprPtr>;
   GlobalExprs globalExprs;
 
 #if LLVM_VERSION_MAJOR >= 11
@@ -267,7 +267,7 @@ private:
 };
 
 // shorthand for compilation over a sequence of expressions
-typedef std::vector<llvm::Value*> Values;
+using Values = std::vector<llvm::Value *>;
 
 Values compile(jitcc*, const Exprs&);
 Values compileArgs(jitcc*, const Exprs&);
diff --git a/include/hobbes/eval/search.H b/include/hobbes/eval/search.H
index c73b1f6f5..58d1f7e53 100644
--- a/include/hobbes/eval/search.H
+++ b/include/hobbes/eval/search.H
@@ -15,7 +15,7 @@ struct SearchEntry {
   std::string       sym; // a symbol matching a user query
   MonoTypePtr       ty;  // the exact result type given by this symbol
 };
-typedef std::vector<SearchEntry> SearchEntries;
+using SearchEntries = std::vector<SearchEntry>;
 
 struct SearchCache {
   std::map<MonoTypePtr, SearchEntries> univByType;
diff --git a/include/hobbes/events/events.H b/include/hobbes/events/events.H
index 36a1f0b52..4272248ac 100644
--- a/include/hobbes/events/events.H
+++ b/include/hobbes/events/events.H
@@ -10,10 +10,10 @@
 namespace hobbes {
 
 // add a read event handler for a file descriptor
-typedef void (*eventhandler)(int fd, void* ud);
+using eventhandler = void (*)(int, void *);
 
 // return true to automatically repeat after an interval
-typedef bool (*timerfunc)();
+using timerfunc = bool (*)();
 
 void addTimer(timerfunc f, int millisecInterval);
 
diff --git a/include/hobbes/events/httpd.H b/include/hobbes/events/httpd.H
index ef4655ea6..f6a4e7d24 100644
--- a/include/hobbes/events/httpd.H
+++ b/include/hobbes/events/httpd.H
@@ -12,8 +12,8 @@
 namespace hobbes {
 
 struct HTTPRequest {
-  typedef std::map<std::string, std::string> Headers;
-  typedef std::vector<char> Data;
+  using Headers = std::map<std::string, std::string>;
+  using Data = std::vector<char>;
 
   std::string method;
   std::string document;
@@ -21,9 +21,9 @@ struct HTTPRequest {
   Data        data;
 };
 
-typedef void (*HTTPRequestHandler)(const HTTPRequest&, int fd, void* ud);
+using HTTPRequestHandler = void (*)(const HTTPRequest &, int, void *);
 
-int installHTTPD(int port, HTTPRequestHandler, void* ud = 0);
+int installHTTPD(int port, HTTPRequestHandler, void* ud = nullptr);
 
 }
 
diff --git a/include/hobbes/fregion.H b/include/hobbes/fregion.H
index b507fd0c8..411d10444 100644
--- a/include/hobbes/fregion.H
+++ b/include/hobbes/fregion.H
@@ -48,13 +48,13 @@
 #include <array>
 #include <type_traits>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
+#include <cassert>
+#include <cstring>
 #include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <string.h>
-#include <assert.h>
 
 // filesystem waits depend on platform details
 #include <sys/time.h>
@@ -106,10 +106,10 @@ struct pagedata {
   void type(pagetype::code x) { this->ptfd = encode(x, availBytes()); }
   void availBytes(uint16_t x) { this->ptfd = encode(type(), x); }
 };
-typedef std::vector<pagedata> pagetable;
+using pagetable = std::vector<pagedata>;
 
 // the index of a page of data in the underlying file
-typedef uint64_t file_pageindex_t;
+using file_pageindex_t = uint64_t;
 
 // convenience for raising errors out of errno
 inline void raiseSysError [[noreturn]] (const std::string& msg, const std::string& fname) {
@@ -118,7 +118,7 @@ inline void raiseSysError [[noreturn]] (const std::string& msg, const std::strin
   throw std::runtime_error(ss.str());
 }
 
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 // a stored name/value binding
 struct binding {
@@ -129,7 +129,7 @@ struct binding {
   size_t boffset; // where is this binding data stored in the file?
 };
 
-typedef std::map<std::string, binding> bindingset;
+using bindingset = std::map<std::string, binding>;
 
 // a mem-mapped file region
 struct fregion {
@@ -140,7 +140,7 @@ struct fregion {
 };
 
 // account for mappings by absolute page
-typedef std::map<file_pageindex_t, fregion> fmappings;
+using fmappings = std::map<file_pageindex_t, fregion>;
 
 // remember which mapped sections correspond to which pages
 struct falloc {
@@ -148,11 +148,11 @@ struct falloc {
   size_t           size; // the number of bytes allocated to this thing
 };
 
-typedef std::map<char*, falloc> fallocs;
+using fallocs = std::map<char *, falloc>;
 
 // fast page searches (to avoid linear searches of the entire page table)
-typedef std::vector<file_pageindex_t>     pageseq;
-typedef std::map<pagetype::code, pageseq> ptyorder;
+using pageseq = std::vector<file_pageindex_t>;
+using ptyorder = std::map<pagetype::code, pageseq>;
 
 // an image file, opened either for reading or writing
 struct imagefile {
@@ -423,7 +423,7 @@ template <typename T>
 // try to find a page with as much free space as requested
 inline bool findPageWithSpace(imagefile* f, pagetype::code pt, size_t datalen, size_t alignment, file_pageindex_t* idx) {
   const pageseq& pord = f->freespace[pt];
-  if (pord.size() == 0) {
+  if (pord.empty()) {
     return false;
   }
 
@@ -514,7 +514,7 @@ inline void appendTOCData(imagefile* f, const pagetable& newpages) {
   }
 
   // if we added TOC pages while writing the input TOC entries, then TOC entries for those TOC pages need to be added too
-  if (newtocpages.size() > 0) {
+  if (!newtocpages.empty()) {
     appendTOCData(f, newtocpages);
   }
 }
@@ -529,7 +529,7 @@ inline size_t findSpace(imagefile* f, pagetype::code pt, size_t datalen, size_t
   if (findPageWithSpace(f, pt, datalen, alignment, &fpage)) {
     pagedata& pd = f->pages[fpage];
 
-    uint64_t offset = align<size_t>(f->page_size - pd.availBytes(), alignment);
+    auto offset = align<size_t>(f->page_size - pd.availBytes(), alignment);
 
     updateTOCData(f, fpage, pagedata(pt, f->page_size - (offset+datalen)));
     return position(f, fpage, offset);
@@ -587,7 +587,7 @@ inline void addBinding(imagefile* f, const std::string& vname, const bytes& type
 // mmap a region out of this file
 inline fregion& createFileRegionMap(imagefile* f, file_pageindex_t page, size_t pages) {
   // leave no gaps in page mappings
-  if (f->mappings.size() > 0) {
+  if (!f->mappings.empty()) {
     fregion& mr = f->mappings.rbegin()->second;
 
     size_t pend = mr.base_page + mr.pages;
@@ -601,7 +601,7 @@ inline fregion& createFileRegionMap(imagefile* f, file_pageindex_t page, size_t
   pages = align<size_t>(pages, f->mmapPageMultiple);
 
   // map the specified file region into memory
-  char* d = reinterpret_cast<char*>(mmap(0, pages * f->page_size, PROT_READ | (f->readonly ? 0 : PROT_WRITE), MAP_SHARED, f->fd, page * f->page_size));
+  char* d = reinterpret_cast<char*>(mmap(nullptr, pages * f->page_size, PROT_READ | (f->readonly ? 0 : PROT_WRITE), MAP_SHARED, f->fd, page * f->page_size));
   if (d == MAP_FAILED) {
     raiseSysError
     (
@@ -647,7 +647,7 @@ template <typename K, typename V>
 // find the mapping data for a region, or create it if necessary
 inline fregion& mappedFileRegion(imagefile* f, file_pageindex_t page, size_t pages) {
   // try to find the nearest possible mapping for this page
-  fmappings::iterator fm = gleb(f->mappings, page);
+  auto fm = gleb(f->mappings, page);
 
   // if we couldn't find a mapping, then we have to make one
   if (fm == f->mappings.end()) {
@@ -691,7 +691,7 @@ inline char* mapFileData(imagefile* f, size_t fpos, size_t sz) {
 // deallocate memory mapped out of this file
 // (if this means that there are no outstanding references to the mapping, then the mapping itself is released)
 inline void unmapFileData(imagefile* f, const void* p, size_t sz) {
-  fallocs::iterator fa = f->allocs.find(const_cast<char*>(reinterpret_cast<const char*>(p)));
+  auto fa = f->allocs.find(const_cast<char*>(reinterpret_cast<const char*>(p)));
   if (fa == f->allocs.end()) {
     return;
   }
@@ -702,7 +702,7 @@ inline void unmapFileData(imagefile* f, const void* p, size_t sz) {
 
   // dereference these bytes from the page mapping
   // if the page mapping has no references, we can remove the page mapping too
-  fmappings::iterator fm = f->mappings.find(dpage);
+  auto fm = f->mappings.find(dpage);
   if (fm == f->mappings.end()) {
     throw std::runtime_error("Internal error, inconsistent file mapping state");
   }
@@ -815,7 +815,7 @@ inline size_t readEnvironmentPage(imagefile* f, file_pageindex_t p) {
     //        page is filled up to and including the last byte (otherwise we'd mistakenly
     //        assume that we have to continue reading from the next page)
     size_t           pos   = filePosition(f) - 1;
-    file_pageindex_t tpage = file_pageindex_t(pos / f->page_size);
+    auto tpage = file_pageindex_t(pos / f->page_size);
     uint16_t         rpos  = (pos % f->page_size) + 1;
 
     if (rpos == (f->page_size - f->pages[tpage].availBytes())) {
@@ -871,7 +871,7 @@ inline void readFile(imagefile* f, uint16_t minVersion, uint16_t maxVersion) {
 
 // open a file, or create it if necessary
 inline imagefile* openFile(const std::string& fname, bool readonly, uint16_t minVersion = HFREGION_CURRENT_FILE_FORMAT_VERSION, uint16_t maxVersion = HFREGION_CURRENT_FILE_FORMAT_VERSION, size_t mmapPageMultiple = 262144 /* 1GB */) {
-  imagefile* f        = new imagefile();
+  auto* f        = new imagefile();
   f->path             = fname;
   f->readonly         = readonly;
   f->mmapPageMultiple = mmapPageMultiple;
@@ -918,7 +918,7 @@ inline imagefile* openFile(const std::string& fname, bool readonly, uint16_t min
 // does this file even represent a structured data file?
 // we'll say yes if it can be opened, it has the magic number, and its size is a multiple of its page size
 inline bool isFRegion(const std::string& fname) {
-  imagefile* f = new imagefile();
+  auto* f = new imagefile();
   f->path      = fname;
   f->readonly  = true;
 
@@ -1224,11 +1224,11 @@ template <>
     static size_t alignment() { return sizeof(size_t); }
 
     static void write(imagefile* f, void* p, const std::string& x) {
-      if (x.size() > 0) {
+      if (!x.empty()) {
         auto bc = sizeof(size_t) + x.size();
 
         size_t dloc = findSpace(f, pagetype::data, bc, sizeof(size_t));
-        uint8_t* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
+        auto* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
         *reinterpret_cast<size_t*>(d) = x.size();
         memcpy(d+sizeof(size_t), x.data(), x.size());
         unmapFileData(f, d, bc);
@@ -1240,7 +1240,7 @@ template <>
     }
     static void read (imagefile* f, const void* p, std::string* x) {
       auto     dloc = *reinterpret_cast<const size_t*>(p);
-      size_t*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
+      auto*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
       char*    s    = reinterpret_cast<char*>(mapFileData(f, dloc+sizeof(size_t), *c));
 
       x->assign(s, s + *c);
@@ -1261,11 +1261,11 @@ template <typename T>
   struct store<std::vector<T>, typename tbool<store<T>::can_memcpy>::type> : public storeVectorDef<T> {
     static const bool can_memcpy = false;
     static void write(imagefile* f, void* p, const std::vector<T>& x) {
-      if (x.size() > 0) {
+      if (!x.empty()) {
         auto bc = sizeof(size_t) + sizeof(T)*x.size();
 
         size_t dloc = findSpace(f, pagetype::data, bc, sizeof(size_t));
-        uint8_t* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
+        auto* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
         *reinterpret_cast<size_t*>(d) = x.size();
         memcpy(d+sizeof(size_t), &x[0], sizeof(T)*x.size());
         unmapFileData(f, d, bc);
@@ -1277,8 +1277,8 @@ template <typename T>
     }
     static void read(imagefile* f, const void* p, std::vector<T>* x) {
       auto     dloc = *reinterpret_cast<const size_t*>(p);
-      size_t*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
-      uint8_t* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c * sizeof(T)));
+      auto*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
+      auto* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c * sizeof(T)));
 
       x->resize(*c);
       memcpy(reinterpret_cast<void*>(&(*x)[0]), d, *c * sizeof(T));
@@ -1291,15 +1291,15 @@ template <typename T>
   struct store<std::vector<T>, typename tbool<!store<T>::can_memcpy>::type> : public storeVectorDef<T> {
     static const bool can_memcpy = false;
     static void write(imagefile* f, void* p, const std::vector<T>& x) {
-      if (x.size() > 0) {
+      if (!x.empty()) {
         size_t tsz = store<T>::size();
         auto   bc  = sizeof(size_t) + tsz*x.size();
 
         size_t dloc = findSpace(f, pagetype::data, bc, sizeof(size_t));
-        uint8_t* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
+        auto* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
         *reinterpret_cast<size_t*>(d) = x.size();
 
-        auto dc = d + sizeof(size_t);
+        auto *dc = d + sizeof(size_t);
         for (const auto& xv : x) {
           store<T>::write(f, dc, xv);
           dc += tsz;
@@ -1314,8 +1314,8 @@ template <typename T>
     static void read(imagefile* f, const void* p, std::vector<T>* x) {
       size_t   tsz  = store<T>::size();
       auto     dloc = *reinterpret_cast<const size_t*>(p);
-      size_t*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
-      uint8_t* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c * tsz));
+      auto*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
+      auto* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c * tsz));
       uint8_t* dc   = d;
 
       x->resize(*c);
@@ -1334,14 +1334,14 @@ template <>
   struct store<std::vector<bool>> : public storeVectorDef<bool> {
     static const bool can_memcpy = false;
     static void write(imagefile* f, void* p, const std::vector<bool>& x) {
-      if (x.size() > 0) {
+      if (!x.empty()) {
         auto   bc  = sizeof(size_t) + x.size();
 
         size_t dloc = findSpace(f, pagetype::data, bc, sizeof(size_t));
-        uint8_t* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
+        auto* d = reinterpret_cast<uint8_t*>(mapFileData(f, dloc, bc));
         *reinterpret_cast<size_t*>(d) = x.size();
 
-        auto dc = d + sizeof(size_t);
+        auto *dc = d + sizeof(size_t);
         for (const auto& xv : x) {
           store<bool>::write(f, dc, xv);
           dc += 1;
@@ -1355,8 +1355,8 @@ template <>
     }
     static void read(imagefile* f, const void* p, std::vector<bool>* x) {
       auto     dloc = *reinterpret_cast<const size_t*>(p);
-      size_t*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
-      uint8_t* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c));
+      auto*  c    = reinterpret_cast<size_t*>(mapFileData(f, dloc, sizeof(size_t)));
+      auto* d    = reinterpret_cast<uint8_t*>(mapFileData(f, dloc+sizeof(size_t), *c));
       uint8_t* dc   = d;
 
       x->resize(*c);
@@ -1404,10 +1404,10 @@ template <typename U, typename V>
 // store tuples
 template <size_t i, size_t n, typename ... Ts>
   struct storeTupleDef {
-    typedef typename nth<i, Ts...>::type H;
-    typedef tuple<Ts...>                 TT;
-    typedef typename TT::offs            offs;
-    typedef storeTupleDef<i+1, n, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using TT = tuple<Ts...>;
+    using offs = typename TT::offs;
+    using Recurse = storeTupleDef<i + 1, n, Ts...>;
 
     static void fieldDefs(size_t offset, ty::Struct::Fields* fs) {
       offset = align(offset, store<H>::alignment());
@@ -1452,7 +1452,7 @@ template <typename ... Ts>
 template <typename ... Ts>
   struct store<tuple<Ts...>, typename tbool<!all_memcpyable<Ts...>::value>::type> : public storeTupleDef<0, sizeof...(Ts), Ts...> {
     static const bool can_memcpy = false;
-    typedef storeTupleDef<0, sizeof...(Ts), Ts...> Reflect;
+    using Reflect = storeTupleDef<0, sizeof...(Ts), Ts...>;
 
     static void write(imagefile* f, void* p, const tuple<Ts...>& x) {
       Reflect::incrWrite(f, p, x);
@@ -1529,8 +1529,8 @@ struct writeFieldF {
 
   template <typename T>
     void visit(const char*) {
-      size_t ooff = align<size_t>(this->ooffset, store<T>::alignment());
-      size_t ioff = align<size_t>(this->ioffset, alignof(T));
+      auto ooff = align<size_t>(this->ooffset, store<T>::alignment());
+      auto ioff = align<size_t>(this->ioffset, alignof(T));
 
       store<T>::write(this->f, this->o + ooff, *reinterpret_cast<const T*>(this->i + ioff));
 
@@ -1548,8 +1548,8 @@ struct readFieldF {
 
   template <typename T>
     void visit(const char*) {
-      size_t ioff = align<size_t>(this->ioffset, store<T>::alignment());
-      size_t ooff = align<size_t>(this->ooffset, alignof(T));
+      auto ioff = align<size_t>(this->ioffset, store<T>::alignment());
+      auto ooff = align<size_t>(this->ooffset, alignof(T));
 
       store<T>::read(this->f, this->i + ioff, reinterpret_cast<T*>(this->o + ooff));
 
@@ -1590,9 +1590,9 @@ template <typename T>
 // store variants
 template <size_t i, size_t n, typename ... Ts>
   struct storeVariantDef {
-    typedef typename nth<i, Ts...>::type   H;
-    typedef variant<Ts...>                 VT;
-    typedef storeVariantDef<i+1, n, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using VT = variant<Ts...>;
+    using Recurse = storeVariantDef<i + 1, n, Ts...>;
 
     static void ctorDefs(ty::Variant::Ctors* cs) {
       cs->push_back(ty::Variant::Ctor(".f" + hobbes::string::from(i), static_cast<int>(i), store<H>::storeType()));
@@ -1639,7 +1639,7 @@ template <size_t tag, typename T, typename M>
 template <typename ... Ts>
   struct store<variant<Ts...>, typename tbool<!all_memcpyable<Ts...>::value>::type> : public storeVariantDef<0, sizeof...(Ts), Ts...> {
     static const bool can_memcpy = false;
-    typedef storeVariantDef<0, sizeof...(Ts), Ts...> Reflect;
+    using Reflect = storeVariantDef<0, sizeof...(Ts), Ts...>;
 
     static void write(imagefile* f, void* p, const variant<Ts...>& x) {
       x.template apply<void, variantGenWrite, void, imagefile*, void*, size_t>(f, p, Reflect::tagOffset());
@@ -1693,7 +1693,7 @@ struct calcVSizeF {
 
 template <typename T>
   struct store<T, typename tbool<T::is_hmeta_variant>::type> {
-    typedef typename T::as_variant_type VT;
+    using VT = typename T::as_variant_type;
     static const bool can_memcpy = store<VT>::can_memcpy;
 
     static ty::desc storeType() {
@@ -1713,7 +1713,7 @@ template <typename T>
 // store opaque type aliases
 template <typename T>
   struct store<T, typename tbool<T::is_hmeta_alias>::type> {
-    typedef typename T::type RT;
+    using RT = typename T::type;
 
     static ty::desc storeType() { return ty::prim(T::name(), store<RT>::storeType()); ; }
 
@@ -1731,7 +1731,7 @@ template <typename T>
  ***********************/
 
 struct seriesi {
-  virtual ~seriesi() { }
+  virtual ~seriesi() = default;
   virtual const ty::desc& typeDef() const = 0;
 };
 
@@ -1777,10 +1777,9 @@ template <typename T>
         }
       }
     }
-    ~wseries() {
-    }
+    ~wseries() = default;
 
-    const ty::desc&    typeDef()  const { return this->tdef; }
+    const ty::desc&    typeDef()  const override { return this->tdef; }
     const std::string& name()     const { return this->seqname; }
     imagefile*         file()     const { return this->f; }
 
@@ -1933,9 +1932,8 @@ template <typename ... Wss>
     wsseq(imagefile* f, const std::string& n, Wss& ... wss) : log(f, n, 10000, seqVar<Wss...>::storeType(f, wss...)) {
       seqVar<Wss...>::setWriteCBs(0, [this](uint32_t id, uint64_t p){this->log(std::pair<uint32_t,uint64_t>(id,p));}, wss...);
     }
-    ~wsseq() {
-    }
-    const ty::desc& typeDef()  const { return this->log.typeDef(); }
+    ~wsseq() = default;
+    const ty::desc& typeDef()  const override { return this->log.typeDef(); }
   private:
     wseries<std::pair<uint32_t,size_t>> log;
   };
@@ -2041,7 +2039,7 @@ public:
         size_t dloc = findSpace(this->f, pagetype::data, sizeof(size_t)+len*sizeof(T), std::max<size_t>(sizeof(size_t), alignof(T)));
         addBinding(this->f, n, ty::encoding(ty::array(store<T>::storeType())), dloc);
         
-        array<T>* result = reinterpret_cast<array<T>*>(mapFileData(this->f, dloc, sizeof(size_t)+len*sizeof(T)));
+        auto* result = reinterpret_cast<array<T>*>(mapFileData(this->f, dloc, sizeof(size_t)+len*sizeof(T)));
         result->size = len;
         return result;
       } else {
@@ -2056,7 +2054,7 @@ public:
 
         // optimistically map as much as needed for the requested array length
         // but make sure that the array is stored with the expected length
-        array<T>* result = reinterpret_cast<array<T>*>(mapFileData(this->f, b->second.offset, sizeof(size_t)+len*sizeof(T)));
+        auto* result = reinterpret_cast<array<T>*>(mapFileData(this->f, b->second.offset, sizeof(size_t)+len*sizeof(T)));
 
         if (result->size != len) {
           unmapFileData(this->f, result, sizeof(size_t)+len*sizeof(T));
@@ -2080,7 +2078,7 @@ public:
   imagefile* fileData() { return this->f; }
   const imagefile* fileData() const { return this->f; }
 private:
-  typedef std::map<std::string, seriesi*> wseriess;
+  using wseriess = std::map<std::string, seriesi *>;
   imagefile* f;
   wseriess   ss;
 };
@@ -2088,7 +2086,7 @@ private:
 // utility to wait for updates to a file (per platform)
 inline long fsWaitTickMS() {
   struct timeval t;
-  if (gettimeofday(&t, 0) == 0) {
+  if (gettimeofday(&t, nullptr) == 0) {
     return (t.tv_sec*1000)+(t.tv_usec/1000);
   } else {
     return 0;
@@ -2166,7 +2164,7 @@ public:
     memset(&evt, 0, sizeof(evt));
     evt.events   = EPOLLIN | EPOLLPRI | EPOLLERR;
     evt.data.fd  = this->ifd;
-    evt.data.ptr = 0;
+    evt.data.ptr = nullptr;
 
     if (epoll_ctl(this->ep, EPOLL_CTL_ADD, this->ifd, &evt) != 0) {
       throw std::runtime_error("Failed to add inotify FD to epoll set: " + std::string(strerror(errno)));
@@ -2177,7 +2175,7 @@ public:
     close(this->ifd);
   }
 
-  int wait(int maxWaitMS) {
+  int wait(int maxWaitMS) const {
     if (maxWaitMS == 0) {
       return 0;
     } else if (maxWaitMS < 0) {
@@ -2226,10 +2224,9 @@ template <typename T>
     }
     rseries(imagefile* f, const std::string& seqname) : rseries(f, seqname, store<T>::storeType(), loadBinding(f, seqname)) {
     }
-    ~rseries() {
-    }
+    ~rseries() = default;
 
-    const ty::desc& typeDef() const { return this->tdef; }
+    const ty::desc& typeDef() const override { return this->tdef; }
     imagefile*      file()    const { return this->f; }
 
     bool next(T* x, int maxWaitMS = 0 /* <0 : infinite wait, 0 : no wait, >0 : wait up to milliseconds */) {
@@ -2282,7 +2279,7 @@ template <typename T>
 
       // if we're in the left '()' case, our state is "null"
       // else our state can be set to load the 'carray T n' batch in this node
-      if (d[0]) {
+      if (d[0] != 0u) {
         this->headLen     = reinterpret_cast<const uint64_t*>(mapFileData(this->f, d[1], bsz));
         this->head        = reinterpret_cast<const uint8_t*>(this->headLen) + sizeof(uint64_t);
         this->nextNodeRef = d[2];
@@ -2338,7 +2335,7 @@ template <typename T>
           }
         }
       }
-      while ((maxWaitMS = fwatch.wait(maxWaitMS)));
+      while ((maxWaitMS = fwatch.wait(maxWaitMS)) != 0);
 
       // we just couldn't get there
       return false;
@@ -2385,8 +2382,8 @@ public:
     return false;
   }
 private:
-  typedef std::map<std::string, std::pair<uint32_t, ty::desc>> VarDef;
-  typedef std::unordered_map<uint32_t, std::function<void(imagefile*,uint64_t)>> VarCtorBindings;
+  using VarDef = std::map<std::string, std::pair<uint32_t, ty::desc>>;
+  using VarCtorBindings = std::unordered_map<uint32_t, std::function<void (imagefile *, uint64_t)>>;
   struct LogDef {
     // the encoded ordering variant type and seq binding
     ty::desc       tdesc;
@@ -2518,24 +2515,24 @@ public:
         );
       } else if (b->second.type == ty::encoding(ty::array(store<T>::storeType()))) {
         // map the array length to determine how much to map for the array
-        const size_t* lenp = reinterpret_cast<const size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
+        const auto* lenp = reinterpret_cast<const size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
         size_t        len  = *lenp;
 
         // now that we know the stored length, we can map the array contents
-        const array<T>* result = reinterpret_cast<const array<T>*>(mapFileData(this->f, b->second.offset, sizeof(size_t)+len*sizeof(T)));
+        const auto* result = reinterpret_cast<const array<T>*>(mapFileData(this->f, b->second.offset, sizeof(size_t)+len*sizeof(T)));
 
         // and we can get rid of the map segment for the len
         unmapFileData(this->f, lenp, sizeof(size_t));
 
         return result;
       } else if (b->second.type == ty::encoding(ty::fileRef(ty::array(store<T>::storeType())))) {
-        const size_t* offp = reinterpret_cast<const size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
+        const auto* offp = reinterpret_cast<const size_t*>(mapFileData(this->f, b->second.offset, sizeof(size_t)));
         size_t off = *offp;
         unmapFileData(this->f, offp, sizeof(size_t));
 
-        const size_t*   lenp   = reinterpret_cast<const size_t*>(mapFileData(this->f, off, sizeof(size_t)));
+        const auto*   lenp   = reinterpret_cast<const size_t*>(mapFileData(this->f, off, sizeof(size_t)));
         size_t          len    = *lenp;
-        const array<T>* result = reinterpret_cast<const array<T>*>(mapFileData(this->f, off, sizeof(size_t)+len*sizeof(T)));
+        const auto* result = reinterpret_cast<const array<T>*>(mapFileData(this->f, off, sizeof(size_t)+len*sizeof(T)));
         unmapFileData(this->f, lenp, sizeof(size_t));
         return result;
       } else {
@@ -2551,7 +2548,7 @@ public:
   imagefile* fileData() { return this->f; }
   const imagefile* fileData() const { return this->f; }
 private:
-  typedef std::map<std::string, seriesi*> rseriess;
+  using rseriess = std::map<std::string, seriesi *>;
   imagefile* f;
   rseriess   ss;
 };
diff --git a/include/hobbes/ipc/net.H b/include/hobbes/ipc/net.H
index e2ddcf279..2402ef9d1 100644
--- a/include/hobbes/ipc/net.H
+++ b/include/hobbes/ipc/net.H
@@ -33,9 +33,9 @@ std::string remoteHostname(int socket);
 int remotePort(int socket);
 
 // run a REPL server at some port, either indirectly or directly with a compiler
-typedef std::vector<uint8_t> RawData;
-typedef uint32_t             exprid;
-typedef std::function<ExprPtr(ExprPtr const&)> ReWriteExprFn;
+using RawData = std::vector<uint8_t>;
+using exprid = uint32_t;
+using ReWriteExprFn = std::function<ExprPtr (const ExprPtr &)>;
 
 struct Server {
   virtual void        connect   (int conn) = 0;
@@ -81,11 +81,11 @@ private:
     MonoTypePtr inty;
     MonoTypePtr outty;
   };
-  typedef std::map<exprid, ExprDef> ExprDefs;
+  using ExprDefs = std::map<exprid, ExprDef>;
   ExprDefs exprDefs;
 
-  typedef std::pair<const void*,const void*> ExprTy;
-  typedef std::map<ExprTy, exprid> ExprTyToID;
+  using ExprTy = std::pair<const void *, const void *>;
+  using ExprTyToID = std::map<ExprTy, exprid>;
   ExprTyToID exprTyToID;
 public:
   /* run-time methods */
@@ -93,7 +93,7 @@ public:
 
   // append a receive function to the end of the sequence of receive handlers
   // these functions will be applied in order to read values from the remote process
-  typedef char* (*ReadFn)(int);
+  using ReadFn = char *(*)(int);
   size_t appendReadFn(ReadFn);
 
   // read a result (reading and discarding any intermediate results)
@@ -103,7 +103,7 @@ public:
   static size_t unsafeAppendReadFn(size_t, ReadFn);
   static char* unsafeRead(size_t, size_t);
 private:
-  typedef std::queue<ReadFn> ReadFns;
+  using ReadFns = std::queue<ReadFn>;
   ReadFns readFns;
   size_t rbno;
   size_t reno;
diff --git a/include/hobbes/ipc/prepl.H b/include/hobbes/ipc/prepl.H
index b80fb52b2..d9085059c 100644
--- a/include/hobbes/ipc/prepl.H
+++ b/include/hobbes/ipc/prepl.H
@@ -29,7 +29,7 @@ void procRead(proc*, std::ostream*, uint64_t waitUS = 0);
 MonoTypePtr refinedType(const proc& p, const std::string& fname, const MonoTypePtr& hasty);
 int invocationID(const proc& p, const std::string& fname, const MonoTypePtr& hasty);
 
-typedef std::pair<size_t, MonoTypePtr> PrepProcExpr;
+using PrepProcExpr = std::pair<size_t, MonoTypePtr>;
 PrepProcExpr procPrepareExpr(const proc&, const ExprPtr&);
 
 void runMachineREPL(cc*);
diff --git a/include/hobbes/ipc/process.H b/include/hobbes/ipc/process.H
index e7cb621ac..5201d9b10 100644
--- a/include/hobbes/ipc/process.H
+++ b/include/hobbes/ipc/process.H
@@ -17,14 +17,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 private:
   std::shared_ptr<ProcManager> procman{std::make_shared<ProcManager>()};
 };
diff --git a/include/hobbes/ipc/procman.H b/include/hobbes/ipc/procman.H
index e5dc57d20..82a58273d 100644
--- a/include/hobbes/ipc/procman.H
+++ b/include/hobbes/ipc/procman.H
@@ -13,15 +13,15 @@ public:
   bool isSpawnedPid(const std::string&, long) const;
 
   // hf eliminator interface
-  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const;
-  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const override;
+  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 private:
   friend struct ProcManUnqualify;
 
-  typedef std::map<std::string, proc> SpawnedProcs;
+  using SpawnedProcs = std::map<std::string, proc>;
   SpawnedProcs procs;
 
   const proc& lp(long) const;
diff --git a/include/hobbes/lang/constraints.H b/include/hobbes/lang/constraints.H
index 5753d52ba..0b97634f8 100644
--- a/include/hobbes/lang/constraints.H
+++ b/include/hobbes/lang/constraints.H
@@ -24,7 +24,7 @@ public:
   void insert(const TEnvPtr&, const ConstraintPtr&, MonoTypeUnifier*);
   Constraints constraints() const;
 private:
-  typedef type_map<ConstraintPtr> CSet;
+  using CSet = type_map<ConstraintPtr>;
   CSet csts;
 };
 
diff --git a/include/hobbes/lang/expr.H b/include/hobbes/lang/expr.H
index a9d876e70..8303f19c4 100644
--- a/include/hobbes/lang/expr.H
+++ b/include/hobbes/lang/expr.H
@@ -12,7 +12,7 @@
 
 namespace hobbes {
 
-typedef __int128 int128_t;
+using int128_t = __int128;
 
 class Expr : public LexicallyAnnotated {
 public:
@@ -42,11 +42,11 @@ private:
 template <typename Case>
   class ExprCase : public Expr {
   public:
-    typedef ExprCase<Case> Base;
+    using Base = ExprCase<Case>;
     ExprCase(const LexicalAnnotation&);
     virtual bool operator==(const Case&) const = 0;
 
-    bool operator==(const Expr& rhs) const {
+    bool operator==(const Expr& rhs) const override {
       if (this == &rhs) {
         return true;
       } else if (const Case* trhs = is<Case>(&rhs)) {
@@ -57,11 +57,11 @@ template <typename Case>
     }
   };
 
-typedef std::shared_ptr<Expr> ExprPtr;
-typedef std::vector<ExprPtr>  Exprs;
+using ExprPtr = std::shared_ptr<Expr>;
+using Exprs = std::vector<ExprPtr>;
 
-typedef std::pair<std::string, ExprPtr> Definition;
-typedef std::vector<Definition>         Definitions;
+using Definition = std::pair<std::string, ExprPtr>;
+using Definitions = std::vector<Definition>;
 
 std::string show(const Expr& e);
 std::string show(const Expr* e);
@@ -78,29 +78,29 @@ std::string showAnnotated(const Definition& d);
 
 class Primitive : public Expr {
 public:
-  virtual bool operator==(const Expr&) const = 0;
+  bool operator==(const Expr&) const override = 0;
   virtual bool operator< (const Primitive&) const = 0;
   virtual MonoTypePtr primType() const = 0;
 
   // for efficient case dispatch
   Primitive(int cid, const LexicalAnnotation&);
 };
-typedef std::shared_ptr<Primitive> PrimitivePtr;
+using PrimitivePtr = std::shared_ptr<Primitive>;
 
 struct PrimPtrLT {
   bool operator()(const PrimitivePtr&, const PrimitivePtr&) const;
 };
-typedef std::set<PrimitivePtr, PrimPtrLT> PrimitiveSet;
+using PrimitiveSet = std::set<PrimitivePtr, PrimPtrLT>;
 
 template <typename Case>
   class PrimitiveCase : public Primitive {
   public:
-    typedef PrimitiveCase<Case> Base;
+    using Base = PrimitiveCase<Case>;
     PrimitiveCase(const LexicalAnnotation&);
     virtual bool equiv(const Case&) const = 0;
     virtual bool lt(const Case&) const = 0;
 
-    bool operator<(const Primitive& rhs) const {
+    bool operator<(const Primitive& rhs) const override {
       if (const Case* trhs = is<Case>(&rhs)) {
         return lt(*trhs);
       } else {
@@ -108,7 +108,7 @@ template <typename Case>
       }
     }
 
-    bool operator==(const Expr& rhs) const {
+    bool operator==(const Expr& rhs) const override {
       if (const Case* trhs = is<Case>(&rhs)) {
         return this->equiv(*trhs);
       } else {
@@ -120,12 +120,12 @@ template <typename Case>
 class Unit : public PrimitiveCase<Unit> {
 public:
   Unit(const LexicalAnnotation&);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Unit&) const;
-  bool lt(const Unit&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Unit&) const override;
+  bool lt(const Unit&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 0;
 };
@@ -135,12 +135,12 @@ public:
   Bool(bool x, const LexicalAnnotation&);
   bool value() const;
   void value(bool);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Bool&) const;
-  bool lt(const Bool&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Bool&) const override;
+  bool lt(const Bool&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 1;
 private:
@@ -152,12 +152,12 @@ public:
   Char(char x, const LexicalAnnotation&);
   char value() const;
   void value(char);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Char&) const;
-  bool lt(const Char&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Char&) const override;
+  bool lt(const Char&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 2;
 private:
@@ -170,12 +170,12 @@ public:
   Byte(unsigned char x, const LexicalAnnotation&);
   unsigned char value() const;
   void value(unsigned char);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Byte&) const;
-  bool lt(const Byte&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Byte&) const override;
+  bool lt(const Byte&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 3;
 private:
@@ -188,12 +188,12 @@ public:
   Short(short x, const LexicalAnnotation&);
   short value() const;
   void value(short);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Short&) const;
-  bool lt(const Short&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Short&) const override;
+  bool lt(const Short&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 4;
 private:
@@ -206,12 +206,12 @@ public:
   Int(int x, const LexicalAnnotation&);
   int value() const;
   void value(int);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Int&) const;
-  bool lt(const Int&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Int&) const override;
+  bool lt(const Int&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 5;
 private:
@@ -224,12 +224,12 @@ public:
   Long(long x, const LexicalAnnotation&);
   long value() const;
   void value(long);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Long&) const;
-  bool lt(const Long&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Long&) const override;
+  bool lt(const Long&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 6;
 private:
@@ -242,12 +242,12 @@ public:
   Float(float x, const LexicalAnnotation&);
   float value() const;
   void value(float);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Float&) const;
-  bool lt(const Float&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Float&) const override;
+  bool lt(const Float&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 7;
 private:
@@ -260,12 +260,12 @@ public:
   Double(double x, const LexicalAnnotation&);
   double value() const;
   void value(double);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Double&) const;
-  bool lt(const Double&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Double&) const override;
+  bool lt(const Double&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 8;
 private:
@@ -284,13 +284,13 @@ template <typename Case>
 class Var : public ExprCase<Var> {
 public:
   Var(const std::string& id, const LexicalAnnotation&);
-  bool operator==(const Var&) const;
+  bool operator==(const Var&) const override;
 
   const std::string& value() const;
   void value(const std::string&);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 9;
 private:
@@ -301,7 +301,7 @@ private:
 class Let : public ExprCase<Let> {
 public:
   Let(const std::string& id, const ExprPtr& e, const ExprPtr& b, const LexicalAnnotation&);
-  bool operator==(const Let&) const;
+  bool operator==(const Let&) const override;
 
   const std::string& var() const;
   const ExprPtr&     varExpr() const;
@@ -311,9 +311,9 @@ public:
   void varExpr(const ExprPtr&);
   void bodyExpr(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 10;
 private:
@@ -325,11 +325,11 @@ private:
 // local mutually-recursive function definition
 class LetRec : public ExprCase<LetRec> {
 public:
-  typedef std::pair<std::string, ExprPtr> Binding;
-  typedef std::vector<Binding> Bindings;
+  using Binding = std::pair<std::string, ExprPtr>;
+  using Bindings = std::vector<Binding>;
 
   LetRec(const Bindings&, const ExprPtr&, const LexicalAnnotation&);
-  bool operator==(const LetRec&) const;
+  bool operator==(const LetRec&) const override;
 
   const Bindings& bindings() const;
   const ExprPtr& bodyExpr() const;
@@ -338,9 +338,9 @@ public:
   Bindings& bindings();
   void bodyExpr(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream&) const;
-  void showAnnotated(std::ostream&) const;
+  Expr* clone() const override;
+  void show(std::ostream&) const override;
+  void showAnnotated(std::ostream&) const override;
 
   static const int type_case_id = 11;
 private:
@@ -351,10 +351,10 @@ private:
 // \x0...xn -> E (function introduction)
 class Fn : public ExprCase<Fn> {
 public:
-  typedef std::vector<std::string> VarNames;
+  using VarNames = std::vector<std::string>;
 
   Fn(const VarNames& vs, const ExprPtr& e, const LexicalAnnotation&);
-  bool operator==(const Fn&) const;
+  bool operator==(const Fn&) const override;
 
   const VarNames& varNames() const;
   const ExprPtr&  body() const;
@@ -362,9 +362,9 @@ public:
   VarNames& varNames();
   void body(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 12;
 private:
@@ -376,7 +376,7 @@ private:
 class App : public ExprCase<App> {
 public:
   App(const ExprPtr& fn, const Exprs& args, const LexicalAnnotation&);
-  bool operator==(const App&) const;
+  bool operator==(const App&) const override;
 
   const ExprPtr& fn() const;
   const Exprs& args() const;
@@ -384,9 +384,9 @@ public:
   void fn(const ExprPtr&);
   Exprs& args();
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 13;
 private:
@@ -398,7 +398,7 @@ private:
 class Assign : public ExprCase<Assign> {
 public:
   Assign(const ExprPtr& lhs, const ExprPtr& rhs, const LexicalAnnotation&);
-  bool operator==(const Assign&) const;
+  bool operator==(const Assign&) const override;
 
   const ExprPtr& left() const;
   const ExprPtr& right() const;
@@ -406,9 +406,9 @@ public:
   void left(const ExprPtr&);
   void right(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 14;
 private:
@@ -420,14 +420,14 @@ private:
 class MkArray : public ExprCase<MkArray> {
 public:
   MkArray(const Exprs& es, const LexicalAnnotation&);
-  bool operator==(const MkArray&) const;
+  bool operator==(const MkArray&) const override;
 
   const Exprs& values() const;
   Exprs& values();
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 15;
 private:
@@ -438,7 +438,7 @@ private:
 class MkVariant : public ExprCase<MkVariant> {
 public:
   MkVariant(const std::string& lbl, const ExprPtr& e, const LexicalAnnotation&);
-  bool operator==(const MkVariant&) const;
+  bool operator==(const MkVariant&) const override;
 
   const std::string& label() const;
   const ExprPtr& value() const;
@@ -446,9 +446,9 @@ public:
   void label(const std::string&);
   void value(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 16;
 private:
@@ -459,18 +459,18 @@ private:
 // {f0=E0,...,fN=EN} (record introduction)
 class MkRecord : public ExprCase<MkRecord> {
 public:
-  typedef std::pair<std::string, ExprPtr> FieldDef;
-  typedef std::vector<FieldDef>           FieldDefs;
+  using FieldDef = std::pair<std::string, ExprPtr>;
+  using FieldDefs = std::vector<FieldDef>;
 
   MkRecord(const FieldDefs& fs, const LexicalAnnotation&);
-  bool operator==(const MkRecord&) const;
+  bool operator==(const MkRecord&) const override;
 
   const FieldDefs& fields() const;
   FieldDefs& fields();
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 17;
 private:
@@ -487,7 +487,7 @@ private:
 class AIndex : public ExprCase<AIndex> {
 public:
   AIndex(const ExprPtr&, const ExprPtr&, const LexicalAnnotation&);
-  bool operator==(const AIndex&) const;
+  bool operator==(const AIndex&) const override;
 
   const ExprPtr& array() const;
   const ExprPtr& index() const;
@@ -495,9 +495,9 @@ public:
   void array(const ExprPtr&);
   void index(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 18;
 private:
@@ -509,18 +509,18 @@ private:
 class Case : public ExprCase<Case> {
 public:
   struct Binding {
-    Binding() { }
+    Binding() = default;
     Binding(const std::string& selector, const std::string& vname, const ExprPtr& exp) : selector(selector), vname(vname), exp(exp) { }
 
     std::string selector;
     std::string vname;
     ExprPtr     exp;
   };
-  typedef std::vector<Binding> Bindings;
+  using Bindings = std::vector<Binding>;
 
   Case(const ExprPtr& v, const Bindings& bs, const LexicalAnnotation&);
   Case(const ExprPtr& v, const Bindings& bs, const ExprPtr& def, const LexicalAnnotation&);
-  bool operator==(const Case&) const;
+  bool operator==(const Case&) const override;
 
   const ExprPtr&  variant() const;
   const Bindings& bindings() const;
@@ -533,9 +533,9 @@ public:
   bool hasBinding(const std::string&) const;
   void addBinding(const std::string& selector, const std::string& vname, const ExprPtr& exp);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 19;
 private:
@@ -548,17 +548,17 @@ private:
 class Switch : public ExprCase<Switch> {
 public:
   struct Binding {
-    Binding() { }
+    Binding() = default;
     Binding(const PrimitivePtr& value, const ExprPtr& exp) : value(value), exp(exp) { }
 
     PrimitivePtr value;
     ExprPtr      exp;
   };
-  typedef std::vector<Binding> Bindings;
+  using Bindings = std::vector<Binding>;
 
   Switch(const ExprPtr& v, const Bindings& bs, const LexicalAnnotation&);
   Switch(const ExprPtr& v, const Bindings& bs, const ExprPtr& def, const LexicalAnnotation&);
-  bool operator==(const Switch&) const;
+  bool operator==(const Switch&) const override;
 
   const ExprPtr&  expr()        const;
   const Bindings& bindings()    const;
@@ -568,9 +568,9 @@ public:
   Bindings& bindings();
   void defaultExpr(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream&) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream&) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 20;
 private:
@@ -583,7 +583,7 @@ private:
 class Proj : public ExprCase<Proj> {
 public:
   Proj(const ExprPtr& r, const std::string& fn, const LexicalAnnotation&);
-  bool operator==(const Proj&) const;
+  bool operator==(const Proj&) const override;
 
   const ExprPtr& record() const;
   const std::string& field() const;
@@ -591,9 +591,9 @@ public:
   void record(const ExprPtr&);
   void field(const std::string&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 21;
 private:
@@ -605,7 +605,7 @@ private:
 class Assump : public ExprCase<Assump> {
 public:
   Assump(const ExprPtr& e, const QualTypePtr& t, const LexicalAnnotation&);
-  bool operator==(const Assump&) const;
+  bool operator==(const Assump&) const override;
 
   const ExprPtr& expr() const;
   const QualTypePtr& ty() const;
@@ -613,9 +613,9 @@ public:
   void expr(const ExprPtr&);
   void ty(const QualTypePtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 22;
 private:
@@ -627,14 +627,14 @@ private:
 class Pack : public ExprCase<Pack> {
 public:
   Pack(const ExprPtr& e, const LexicalAnnotation&);
-  bool operator==(const Pack&) const;
+  bool operator==(const Pack&) const override;
 
   const ExprPtr& expr() const;
   void expr(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 23;
 private:
@@ -645,7 +645,7 @@ private:
 class Unpack : public ExprCase<Unpack> {
 public:
   Unpack(const std::string&, const ExprPtr&, const ExprPtr&, const LexicalAnnotation&);
-  bool operator==(const Unpack&) const;
+  bool operator==(const Unpack&) const override;
 
   const std::string& varName() const;
   const ExprPtr&     package() const;
@@ -655,9 +655,9 @@ public:
   void package(const ExprPtr&);
   void expr(const ExprPtr&);
 
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
 
   static const int type_case_id = 24;
 private:
@@ -672,12 +672,12 @@ public:
   Int128(int128_t x, const LexicalAnnotation&);
   int128_t value() const;
   void value(int128_t);
-  Expr* clone() const;
-  void show(std::ostream& out) const;
-  void showAnnotated(std::ostream& out) const;
-  bool equiv(const Int128&) const;
-  bool lt(const Int128&) const;
-  MonoTypePtr primType() const;
+  Expr* clone() const override;
+  void show(std::ostream& out) const override;
+  void showAnnotated(std::ostream& out) const override;
+  bool equiv(const Int128&) const override;
+  bool lt(const Int128&) const override;
+  MonoTypePtr primType() const override;
 
   static const int type_case_id = 25;
 private:
@@ -778,19 +778,19 @@ inline ExprPtr mktunit(const LexicalAnnotation& la) {
 }
 
 inline ExprPtr mkrecord(const MkRecord::FieldDefs& fds, const LexicalAnnotation& la) {
-  if (fds.size() == 0) {
+  if (fds.empty()) {
     return mktunit(la);
   } else {
     ExprPtr result(new MkRecord(fds, la));
   
     Constraints     csts;
     Record::Members ms;
-    for (MkRecord::FieldDefs::const_iterator fd = fds.begin(); fd != fds.end(); ++fd) {
-      if (fd->second->type() == QualTypePtr()) {
+    for (const auto &fd : fds) {
+      if (fd.second->type() == QualTypePtr()) {
         return result;
       } else {
-        mergeConstraints(fd->second->type()->constraints(), &csts);
-        ms.push_back(Record::Member(fd->first, fd->second->type()->monoType()));
+        mergeConstraints(fd.second->type()->constraints(), &csts);
+        ms.push_back(Record::Member(fd.first, fd.second->type()->monoType()));
       }
     }
 
@@ -851,8 +851,8 @@ template <typename ... Cases>
 
 inline Constraints liftConstraints(const Exprs& es) {
   Constraints r;
-  for (Exprs::const_iterator e = es.begin(); e != es.end(); ++e) {
-    QualTypePtr qt = (*e)->type();
+  for (const auto &e : es) {
+    QualTypePtr qt = e->type();
     if (qt != QualTypePtr()) {
       append(&r, qt->constraints());
     }
@@ -889,7 +889,7 @@ inline ExprPtr closcall(const ExprPtr& c, const Exprs& args, const LexicalAnnota
   }
 
   const Exists* ety = is<Exists>(qt->monoType());
-  if (!ety) {
+  if (ety == nullptr) {
     throw annotated_error(*c, "Expected existential type in closure application");
   }
 
@@ -904,7 +904,7 @@ inline ExprPtr closcall(const ExprPtr& c, const Exprs& args, const LexicalAnnota
 // op :: (a0..aN) -> r => \(a0..aN).op(a0..aN)
 inline ExprPtr etaLift(const std::string& opname, const MonoTypePtr& oty, const LexicalAnnotation& la) {
   Func* fty = is<Func>(oty);
-  if (!fty) { throw annotated_error(la, "Internal compiler error while eta-expanding primitive op: " + opname); }
+  if (fty == nullptr) { throw annotated_error(la, "Internal compiler error while eta-expanding primitive op: " + opname); }
 
   ExprPtr op = var(opname, oty, la);
 
@@ -931,8 +931,8 @@ inline Expr* mkarray(const std::vector<unsigned char>& v, const LexicalAnnotatio
   QualTypePtr aty = qualtype(arrayty(bty));
 
   Exprs cs;
-  for (size_t b = 0; b < v.size(); ++b) {
-    ExprPtr be(new Byte(v[b], la));
+  for (const unsigned char b : v) {
+    ExprPtr be(new Byte(b, la));
     be->type(ety);
     cs.push_back(be);
   }
@@ -952,8 +952,8 @@ inline Expr* mkarray(const std::string& v, const LexicalAnnotation& la) {
   QualTypePtr aty = qualtype(arrayty(cty));
 
   Exprs cs;
-  for (size_t c = 0; c < v.size(); ++c) {
-    ExprPtr ce(new Char(v[c], la));
+  for (const char c : v) {
+    ExprPtr ce(new Char(c, la));
     ce->type(ety);
     cs.push_back(ce);
   }
@@ -968,7 +968,7 @@ inline Expr* mkarray(const std::string& v, const LexicalAnnotation& la) {
 }
 
 inline ExprPtr switchE(const ExprPtr& e, const Switch::Bindings& bs, const ExprPtr& def, const LexicalAnnotation& la) {
-  if (bs.size() == 0) {
+  if (bs.empty()) {
     return def;
   } else {
     return ExprPtr(new Switch(e, bs, def, la));
@@ -1029,16 +1029,16 @@ inline ExprPtr assign(const ExprPtr& lhs, const ExprPtr& rhs, const LexicalAnnot
 
 inline Exprs exprs(const MkRecord::FieldDefs& ms) {
   Exprs r;
-  for (MkRecord::FieldDefs::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    r.push_back(m->second);
+  for (const auto &m : ms) {
+    r.push_back(m.second);
   }
   return r;
 }
 
 inline Exprs exprs(const Case::Bindings& bs) {
   Exprs r;
-  for (Case::Bindings::const_iterator b = bs.begin(); b != bs.end(); ++b) {
-    r.push_back(b->exp);
+  for (const auto &b : bs) {
+    r.push_back(b.exp);
   }
   return r;
 }
@@ -1046,8 +1046,8 @@ inline Exprs exprs(const Case::Bindings& bs) {
 // replaces instances of a given variable name with the specified expression
 //  (NOTE: this does nothing to prevent variable capture, other than respecting shadowing)
 //  (ie: the free variables of the substituted expression should be disjoint with program variables)
-typedef std::map<std::string, ExprPtr> VarMapping;
-ExprPtr substitute(const VarMapping& vm, const ExprPtr& e, bool* mapped = 0);
+using VarMapping = std::map<std::string, ExprPtr>;
+ExprPtr substitute(const VarMapping& vm, const ExprPtr& e, bool* mapped = nullptr);
 
 // apply a type substitution across an expression
 ExprPtr substitute(const MonoTypeSubst& s, const ExprPtr& e);
@@ -1133,34 +1133,34 @@ template <typename T>
   struct switchExprC : public switchExpr<T> {
     virtual ~switchExprC() = default;
     virtual T withConst(const Expr* v)      const = 0;
-    virtual T with     (const Var* v)       const = 0;
-    virtual T with     (const Let* v)       const = 0;
-    virtual T with     (const LetRec* v)    const = 0;
-    virtual T with     (const Fn* v)        const = 0;
-    virtual T with     (const App* v)       const = 0;
-    virtual T with     (const Assign* v)    const = 0;
-    virtual T with     (const MkArray* v)   const = 0;
-    virtual T with     (const MkVariant* v) const = 0;
-    virtual T with     (const MkRecord* v)  const = 0;
-    virtual T with     (const AIndex* v)    const = 0;
-    virtual T with     (const Case* v)      const = 0;
-    virtual T with     (const Switch* v)    const = 0;
-    virtual T with     (const Proj* v)      const = 0;
-    virtual T with     (const Assump* v)    const = 0;
-    virtual T with     (const Pack* v)      const = 0;
-    virtual T with     (const Unpack* v)    const = 0;
+    T with     (const Var* v)       const override = 0;
+    T with     (const Let* v)       const override = 0;
+    T with     (const LetRec* v)    const override = 0;
+    T with     (const Fn* v)        const override = 0;
+    T with     (const App* v)       const override = 0;
+    T with     (const Assign* v)    const override = 0;
+    T with     (const MkArray* v)   const override = 0;
+    T with     (const MkVariant* v) const override = 0;
+    T with     (const MkRecord* v)  const override = 0;
+    T with     (const AIndex* v)    const override = 0;
+    T with     (const Case* v)      const override = 0;
+    T with     (const Switch* v)    const override = 0;
+    T with     (const Proj* v)      const override = 0;
+    T with     (const Assump* v)    const override = 0;
+    T with     (const Pack* v)      const override = 0;
+    T with     (const Unpack* v)    const override = 0;
 
     // implement just the constant 'with' terms to collapse them
-    T with(const Unit*   v) const { return withConst(v); }
-    T with(const Bool*   v) const { return withConst(v); }
-    T with(const Char*   v) const { return withConst(v); }
-    T with(const Byte*   v) const { return withConst(v); }
-    T with(const Short*  v) const { return withConst(v); }
-    T with(const Int*    v) const { return withConst(v); }
-    T with(const Long*   v) const { return withConst(v); }
-    T with(const Int128* v) const { return withConst(v); }
-    T with(const Float*  v) const { return withConst(v); }
-    T with(const Double* v) const { return withConst(v); }
+    T with(const Unit*   v) const override { return withConst(v); }
+    T with(const Bool*   v) const override { return withConst(v); }
+    T with(const Char*   v) const override { return withConst(v); }
+    T with(const Byte*   v) const override { return withConst(v); }
+    T with(const Short*  v) const override { return withConst(v); }
+    T with(const Int*    v) const override { return withConst(v); }
+    T with(const Long*   v) const override { return withConst(v); }
+    T with(const Int128* v) const override { return withConst(v); }
+    T with(const Float*  v) const override { return withConst(v); }
+    T with(const Double* v) const override { return withConst(v); }
   };
 
 bool isConst(const ExprPtr&);
@@ -1274,7 +1274,7 @@ template <typename T>
 template <typename T>
   std::vector<T> switchOf(const Exprs& es, const switchExpr<T>& f) {
     std::vector<T> result;
-    for (auto e : es) {
+    for (const auto& e : es) {
       result.push_back(switchOf(e, f));
     }
     return result;
@@ -1283,7 +1283,7 @@ template <typename T>
 template <typename T>
   std::vector<T> switchOf(const Exprs& es, const switchExprM<T>& f) {
     std::vector<T> result;
-    for (auto e : es) {
+    for (const auto& e : es) {
       result.push_back(switchOf(e, const_cast<switchExprM<T>&>(f)));
     }
     return result;
@@ -1291,10 +1291,10 @@ template <typename T>
 
 template <typename K, typename T>
   std::vector< std::pair<K, T> > switchOf(const std::vector< std::pair<K, ExprPtr> >& kes, const switchExpr<T>& f) {
-    typedef std::pair<K, T> KT;
-    typedef std::vector<KT> KTS;
+    using KT = std::pair<K, T>;
+    using KTS = std::vector<KT>;
     KTS kts;
-    for (auto ke : kes) {
+    for (const auto& ke : kes) {
       kts.push_back(KT(ke.first, switchOf(ke.second, f)));
     }
     return kts;
@@ -1302,10 +1302,10 @@ template <typename K, typename T>
 
 template <typename K, typename T>
   std::vector< std::pair<K, T> > switchOf(const std::vector< std::pair<K, ExprPtr> >& kes, const switchExprM<T>& f) {
-    typedef std::pair<K, T> KT;
-    typedef std::vector<KT> KTS;
+    using KT = std::pair<K, T>;
+    using KTS = std::vector<KT>;
     KTS kts;
-    for (auto ke : kes) {
+    for (const auto& ke : kes) {
       kts.push_back(KT(ke.first, switchOf(ke.second, const_cast<switchExprM<T>&>(f))));
     }
     return kts;
@@ -1323,57 +1323,57 @@ struct switchExprTyFn : public switchExprC<ExprPtr> {
   virtual ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const;
 
   // allocate a fresh expression, updating types as we go
-  ExprPtr withConst(const Expr* v)      const;
-  ExprPtr with     (const Var* v)       const;
-  ExprPtr with     (const Let* v)       const;
-  ExprPtr with     (const LetRec* v)    const;
-  ExprPtr with     (const Fn* v)        const;
-  ExprPtr with     (const App* v)       const;
-  ExprPtr with     (const Assign* v)    const;
-  ExprPtr with     (const MkArray* v)   const;
-  ExprPtr with     (const MkVariant* v) const;
-  ExprPtr with     (const MkRecord* v)  const;
-  ExprPtr with     (const AIndex* v)    const;
-  ExprPtr with     (const Case* v)      const;
-  ExprPtr with     (const Switch* v)    const;
-  ExprPtr with     (const Proj* v)      const;
-  ExprPtr with     (const Assump* v)    const;
-  ExprPtr with     (const Pack* v)      const;
-  ExprPtr with     (const Unpack* v)    const;
+  ExprPtr withConst(const Expr* v)      const override;
+  ExprPtr with     (const Var* v)       const override;
+  ExprPtr with     (const Let* v)       const override;
+  ExprPtr with     (const LetRec* v)    const override;
+  ExprPtr with     (const Fn* v)        const override;
+  ExprPtr with     (const App* v)       const override;
+  ExprPtr with     (const Assign* v)    const override;
+  ExprPtr with     (const MkArray* v)   const override;
+  ExprPtr with     (const MkVariant* v) const override;
+  ExprPtr with     (const MkRecord* v)  const override;
+  ExprPtr with     (const AIndex* v)    const override;
+  ExprPtr with     (const Case* v)      const override;
+  ExprPtr with     (const Switch* v)    const override;
+  ExprPtr with     (const Proj* v)      const override;
+  ExprPtr with     (const Assump* v)    const override;
+  ExprPtr with     (const Pack* v)      const override;
+  ExprPtr with     (const Unpack* v)    const override;
 };
 
 struct switchExprTyFnM : public switchExprM<UnitV> {
   // whatever type transform is being done (default is the identity transform)
   virtual QualTypePtr withTy(const QualTypePtr& qt) const;
 
-  UnitV with(Unit* v);
-  UnitV with(Bool* v);
-  UnitV with(Char* v);
-  UnitV with(Byte* v);
-  UnitV with(Short* v);
-  UnitV with(Int* v);
-  UnitV with(Long* v);
-  UnitV with(Int128* v);
-  UnitV with(Float* v);
-  UnitV with(Double* v);
-  UnitV with(Var* v);
-  UnitV with(Let* v);
-  UnitV with(LetRec* v);
-  UnitV with(Fn* v);
-  UnitV with(App* v);
-  UnitV with(Assign* v);
-  UnitV with(MkArray* v);
-  UnitV with(MkVariant* v);
-  UnitV with(MkRecord* v);
-  UnitV with(AIndex* v);
-  UnitV with(Case* v);
-  UnitV with(Switch* v);
-  UnitV with(Proj* v);
-  UnitV with(Assump* v);
-  UnitV with(Pack* v);
-  UnitV with(Unpack* v);
+  UnitV with(Unit* v) override;
+  UnitV with(Bool* v) override;
+  UnitV with(Char* v) override;
+  UnitV with(Byte* v) override;
+  UnitV with(Short* v) override;
+  UnitV with(Int* v) override;
+  UnitV with(Long* v) override;
+  UnitV with(Int128* v) override;
+  UnitV with(Float* v) override;
+  UnitV with(Double* v) override;
+  UnitV with(Var* v) override;
+  UnitV with(Let* v) override;
+  UnitV with(LetRec* v) override;
+  UnitV with(Fn* v) override;
+  UnitV with(App* v) override;
+  UnitV with(Assign* v) override;
+  UnitV with(MkArray* v) override;
+  UnitV with(MkVariant* v) override;
+  UnitV with(MkRecord* v) override;
+  UnitV with(AIndex* v) override;
+  UnitV with(Case* v) override;
+  UnitV with(Switch* v) override;
+  UnitV with(Proj* v) override;
+  UnitV with(Assump* v) override;
+  UnitV with(Pack* v) override;
+  UnitV with(Unpack* v) override;
 private:
-  UnitV updateTy(Expr* e);
+  UnitV updateTy(Expr* e) const;
 };
 
 Case::Bindings switchOf(const Case::Bindings& bs, const switchExpr<ExprPtr>& f);
@@ -1402,7 +1402,7 @@ ExprPtr stripExplicitAssumptions(const ExprPtr&);
 const ExprPtr& stripAssumpHead(const ExprPtr&);
 
 // find the free variables in a term
-typedef std::set<std::string> VarSet;
+using VarSet = std::set<std::string>;
 
 VarSet freeVars(const ExprPtr&);
 VarSet freeVars(const Expr&);
diff --git a/include/hobbes/lang/module.H b/include/hobbes/lang/module.H
index 95eff2269..637f98be5 100644
--- a/include/hobbes/lang/module.H
+++ b/include/hobbes/lang/module.H
@@ -26,12 +26,12 @@ protected:
 private:
   int cid;
 };
-typedef std::shared_ptr<ModuleDef> ModuleDefPtr;
-typedef std::vector<ModuleDefPtr>  ModuleDefs;
+using ModuleDefPtr = std::shared_ptr<ModuleDef>;
+using ModuleDefs = std::vector<ModuleDefPtr>;
 
 template <typename Case>
   struct ModuleDefCase : public ModuleDef {
-    typedef ModuleDefCase<Case> Base;
+    using Base = ModuleDefCase<Case>;
     ModuleDefCase(const LexicalAnnotation&);
   };
 
@@ -42,7 +42,7 @@ public:
   const std::string& path() const;
   const std::string& name() const;
 
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   static const int type_case_id = 0;
 private:
@@ -60,7 +60,7 @@ public:
   const str::seq&    arguments() const;
   const QualTypePtr& type() const;
 
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   static const int type_case_id = 1;
 private:
@@ -76,15 +76,15 @@ public:
   const std::string& varName() const;
   const QualTypePtr& varType() const;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   static const int type_case_id = 2;
 private:
   std::string vname;
   QualTypePtr qty;
 };
-typedef std::shared_ptr<MVarTypeDef> MVarTypeDefPtr;
-typedef std::vector<MVarTypeDefPtr>  MVarTypeDefs;
+using MVarTypeDefPtr = std::shared_ptr<MVarTypeDef>;
+using MVarTypeDefs = std::vector<MVarTypeDefPtr>;
 
 class MVarDef : public ModuleDefCase<MVarDef> {
 public:
@@ -92,20 +92,20 @@ public:
   const str::seq& varWithArgs() const;
   const ExprPtr&  varExpr() const;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   static const int type_case_id = 3;
 private:
   str::seq vargl;
   ExprPtr  expr;
 };
-typedef std::shared_ptr<MVarDef> MVarDefPtr;
-typedef std::vector<MVarDefPtr>  MVarDefs;
+using MVarDefPtr = std::shared_ptr<MVarDef>;
+using MVarDefs = std::vector<MVarDefPtr>;
 
 MVarDefs substitute(const MonoTypeSubst&, const MVarDefs&);
 
-typedef std::pair<str::seq, str::seq> CFunDepDef;
-typedef std::vector<CFunDepDef>       CFunDepDefs;
+using CFunDepDef = std::pair<str::seq, str::seq>;
+using CFunDepDefs = std::vector<CFunDepDef>;
 
 class ClassDef : public ModuleDefCase<ClassDef> {
 public:
@@ -114,10 +114,10 @@ public:
   const Constraints&  constraints() const;
   const std::string&  name() const;
   const str::seq&     vars() const;
-  const CFunDepDefs   fundeps() const;
+  CFunDepDefs         fundeps() const;
   const MVarTypeDefs& members() const;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   static const int type_case_id = 4;
 private:
@@ -127,8 +127,8 @@ private:
   CFunDepDefs  fdeps;
   MVarTypeDefs mvtydefs;
 };
-typedef std::shared_ptr<ClassDef> ClassDefPtr;
-typedef std::vector<ClassDefPtr>  ClassDefs;
+using ClassDefPtr = std::shared_ptr<ClassDef>;
+using ClassDefs = std::vector<ClassDefPtr>;
 
 class InstanceDef : public ModuleDefCase<InstanceDef> {
 public:
@@ -139,7 +139,7 @@ public:
   const MonoTypes&   args() const;
   const MVarDefs&    members() const;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   static const int type_case_id = 5;
 private:
@@ -148,13 +148,13 @@ private:
   MonoTypes   targs;
   MVarDefs    mdefs;
 };
-typedef std::shared_ptr<InstanceDef> InstanceDefPtr;
-typedef std::vector<InstanceDefPtr>  InstanceDefs;
+using InstanceDefPtr = std::shared_ptr<InstanceDef>;
+using InstanceDefs = std::vector<InstanceDefPtr>;
 
 class MUnsafePragmaDef : public ModuleDefCase<MUnsafePragmaDef> {
 public:
   MUnsafePragmaDef(const std::string& symbol, const LexicalAnnotation& la) : Base(la), symbol(symbol) {}
-  void show(std::ostream& out) const { out << "{-# UNSAFE " << symbol << " #-}"; } ; 
+  void show(std::ostream& out) const override { out << "{-# UNSAFE " << symbol << " #-}"; } ; 
 
   const std::string& symbolValue() const { return symbol; }
   static const int type_case_id = 6;
@@ -166,7 +166,7 @@ private:
 class MSafePragmaDef : public ModuleDefCase<MSafePragmaDef> {
 public:
   MSafePragmaDef(const std::string& symbol, const LexicalAnnotation& la) : Base(la), symbol(symbol) {}
-  void show(std::ostream& out) const { out << "{-# SAFE " << symbol << " #-}"; } ; 
+  void show(std::ostream& out) const override { out << "{-# SAFE " << symbol << " #-}"; } ; 
 
   const std::string& symbolValue() const { return symbol; }
   static const int type_case_id = 7;
@@ -224,14 +224,14 @@ template <typename T>
 struct switchMDefTyFn : switchMDef<ModuleDefPtr> {
   virtual QualTypePtr withTy(const QualTypePtr&) const = 0;
 
-  ModuleDefPtr with(const MImport*)     const;
-  ModuleDefPtr with(const MTypeDef*)    const;
-  ModuleDefPtr with(const MVarTypeDef*) const;
-  ModuleDefPtr with(const MVarDef*)     const;
-  ModuleDefPtr with(const ClassDef*)    const;
-  ModuleDefPtr with(const InstanceDef*) const;
-  ModuleDefPtr with(const MUnsafePragmaDef*)  const;
-  ModuleDefPtr with(const MSafePragmaDef*)  const;
+  ModuleDefPtr with(const MImport*)     const override;
+  ModuleDefPtr with(const MTypeDef*)    const override;
+  ModuleDefPtr with(const MVarTypeDef*) const override;
+  ModuleDefPtr with(const MVarDef*)     const override;
+  ModuleDefPtr with(const ClassDef*)    const override;
+  ModuleDefPtr with(const InstanceDef*) const override;
+  ModuleDefPtr with(const MUnsafePragmaDef*)  const override;
+  ModuleDefPtr with(const MSafePragmaDef*)  const override;
 
 };
 
@@ -253,8 +253,8 @@ private:
   std::vector<std::string> opts;
 };
 
-typedef std::shared_ptr<Module> ModulePtr;
-typedef std::vector<ModulePtr>  Modules;
+using ModulePtr = std::shared_ptr<Module>;
+using Modules = std::vector<ModulePtr>;
 
 // basic utilities
 std::string show(const Module& m);
diff --git a/include/hobbes/lang/pat/dfa.H b/include/hobbes/lang/pat/dfa.H
index 460ed47bf..f8e1f529e 100644
--- a/include/hobbes/lang/pat/dfa.H
+++ b/include/hobbes/lang/pat/dfa.H
@@ -13,16 +13,16 @@
 
 namespace hobbes {
 
-typedef size_t               stateidx_t;
-typedef std::set<stateidx_t> stateidxset;
+using stateidx_t = size_t;
+using stateidxset = std::set<stateidx_t>;
 
-typedef std::pair<std::string, MonoTypePtr> PrimFArg;
-typedef std::vector<PrimFArg> PrimFArgs;
+using PrimFArg = std::pair<std::string, MonoTypePtr>;
+using PrimFArgs = std::vector<PrimFArg>;
 
 // the various states of pattern matching
 class MState {
 public:
-  virtual ~MState(void) = default;  
+  virtual ~MState() = default;
   virtual std::string stamp() = 0;
 
   // how many times is this state referenced?
@@ -51,14 +51,14 @@ template <typename Case>
 
 class LoadVars : public MStateCase<LoadVars> {
 public:
-  typedef std::pair<std::string, ExprPtr> Def;
-  typedef std::vector<Def> Defs;
+  using Def = std::pair<std::string, ExprPtr>;
+  using Defs = std::vector<Def>;
 
   LoadVars(const Defs&, stateidx_t);
   const Defs& defs() const;
   stateidx_t nextState() const;
 
-  std::string stamp();
+  std::string stamp() override;
 
   static const int type_case_id = 0;
 private:
@@ -68,15 +68,15 @@ private:
 
 class SwitchVal : public MStateCase<SwitchVal> {
 public:
-  typedef std::pair<PrimitivePtr, stateidx_t> Jump;
-  typedef std::vector<Jump> Jumps;
+  using Jump = std::pair<PrimitivePtr, stateidx_t>;
+  using Jumps = std::vector<Jump>;
 
   SwitchVal(const std::string&, const Jumps&, stateidx_t);
   const std::string& switchVar() const;
   const Jumps& jumps() const;
   stateidx_t defaultState() const;
 
-  std::string stamp();
+  std::string stamp() override;
 
   static const int type_case_id = 1;
 private:
@@ -87,15 +87,15 @@ private:
 
 class SwitchVariant : public MStateCase<SwitchVariant> {
 public:
-  typedef std::pair<std::string, stateidx_t> CtorJump;
-  typedef std::vector<CtorJump> CtorJumps;
+  using CtorJump = std::pair<std::string, stateidx_t>;
+  using CtorJumps = std::vector<CtorJump>;
 
   SwitchVariant(const std::string&, const CtorJumps&, stateidx_t);
   const std::string& switchVar() const;
   const CtorJumps& jumps() const;
   stateidx_t defaultState() const;
 
-  std::string stamp();
+  std::string stamp() override;
 
   static const int type_case_id = 2;
 private:
@@ -110,7 +110,7 @@ public:
 
   const ExprPtr& expr() const;
 
-  std::string stamp();
+  std::string stamp() override;
 
   static const int type_case_id = 3;
 private:
@@ -123,13 +123,13 @@ template <typename Case>
   MStateCase<Case>::MStateCase() : MState(Case::type_case_id) {
   }
 
-typedef std::shared_ptr<MState> MStatePtr;
-typedef std::vector<MStatePtr>  MStates;
+using MStatePtr = std::shared_ptr<MState>;
+using MStates = std::vector<MStatePtr>;
 
 // destruction-side for high-level pattern representations
 template <typename T>
 struct switchMState {
-    virtual ~switchMState(void) = default;
+    virtual ~switchMState() = default;
     virtual T with(const LoadVars*)      const = 0;
     virtual T with(const SwitchVal*)     const = 0;
     virtual T with(const SwitchVariant*) const = 0;
@@ -158,22 +158,22 @@ template <typename T>
   }
 
 // DFA construction from annotated/normalized pattern match tables
-typedef std::unordered_map<std::string, stateidx_t> StatesIdx;
+using StatesIdx = std::unordered_map<std::string, stateidx_t>;
 
-typedef std::unordered_map<std::string, ExprPtr>     VarNames;       // memoize usage of variable names
-typedef std::map<size_t, ExprPtr>                    ArrayElem;
-typedef std::unordered_map<std::string, ArrayElem>   VarArrayElem;   // memoize array 'element' access in match variables
-typedef std::unordered_map<std::string, ExprPtr>     VarArrayLen;    // memoize array 'size' access in match variables
-typedef std::unordered_map<std::string, ExprPtr>     StructField;
-typedef std::unordered_map<std::string, StructField> VarStructField; // memoize struct field access in match variables
+using VarNames = std::unordered_map<std::string, ExprPtr>;       // memoize usage of variable names
+using ArrayElem = std::map<size_t, ExprPtr>;
+using VarArrayElem = std::unordered_map<std::string, ArrayElem>;   // memoize array 'element' access in match variables
+using VarArrayLen = std::unordered_map<std::string, ExprPtr>;    // memoize array 'size' access in match variables
+using StructField = std::unordered_map<std::string, ExprPtr>;
+using VarStructField = std::unordered_map<std::string, StructField>; // memoize struct field access in match variables
 
-typedef std::pair<std::string, ExprPtr>         FoldedState;
-typedef std::vector<FoldedState>                FoldedStates;     // local functions for states that should be lifted out
-typedef std::unordered_map<stateidx_t, ExprPtr> FoldedStateCalls; // call expressions into states that have been folded into local functions
+using FoldedState = std::pair<std::string, ExprPtr>;
+using FoldedStates = std::vector<FoldedState>;     // local functions for states that should be lifted out
+using FoldedStateCalls = std::unordered_map<stateidx_t, ExprPtr>; // call expressions into states that have been folded into local functions
 
-typedef std::unordered_map<PatternRows, stateidx_t, hobbes::genHash<PatternRows>> TableCfgStates; // map distinct pattern table configs to their corresponding states (avoid reconstructing the whole state description)
+using TableCfgStates = std::unordered_map<PatternRows, stateidx_t, hobbes::genHash<PatternRows>>; // map distinct pattern table configs to their corresponding states (avoid reconstructing the whole state description)
 
-typedef std::unordered_map<Expr*, size_t> ExprIdxs; // map back from result expressions to row IDs
+using ExprIdxs = std::unordered_map<Expr *, size_t>; // map back from result expressions to row IDs
 
 struct MDFA {
   // the lexical extent of the whole match in the original source program
diff --git a/include/hobbes/lang/pat/pattern.H b/include/hobbes/lang/pat/pattern.H
index e6bd9c24e..0a6f87244 100644
--- a/include/hobbes/lang/pat/pattern.H
+++ b/include/hobbes/lang/pat/pattern.H
@@ -14,15 +14,15 @@
 
 namespace hobbes {
 
-typedef std::vector<size_t> Idxs;
+using Idxs = std::vector<size_t>;
 
 // the main signature for this module -- convert a pattern match expression to a primitive compilable expression
 class Pattern;
-typedef std::shared_ptr<Pattern> PatternPtr;
-typedef std::vector<PatternPtr>  Patterns;
+using PatternPtr = std::shared_ptr<Pattern>;
+using Patterns = std::vector<PatternPtr>;
 
 struct PatternRow {
-  inline PatternRow() { }
+  inline PatternRow() = default;
   inline PatternRow(const Patterns& ps, const ExprPtr& r) : patterns(ps), result(r) { }
   inline PatternRow(const Patterns& ps, const ExprPtr& g, const ExprPtr& r) : patterns(ps), guard(g), result(r) { }
 
@@ -30,8 +30,8 @@ struct PatternRow {
   ExprPtr  guard;    // a required condition for a match (may be null if there is no guard)
   ExprPtr  result;   // the expression to be evaluated when the given pattern conditions are met
 };
-typedef std::vector<PatternRow> PatternRows;
-typedef std::shared_ptr<std::vector<std::pair<size_t, PatternRow>>> UnreachableMatchRowsPtr;
+using PatternRows = std::vector<PatternRow>;
+using UnreachableMatchRowsPtr = std::shared_ptr<std::vector<std::pair<size_t, PatternRow>>>;
 
 // support quick hashing of pattern tables
 bool operator==(const PatternRow&, const PatternRow&);
@@ -76,7 +76,7 @@ private:
 template <typename Case>
   class PatternCase : public Pattern {
   public:
-    typedef PatternCase<Case> Base;
+    using Base = PatternCase<Case>;
     PatternCase(const LexicalAnnotation&);
   };
 
@@ -96,15 +96,15 @@ public:
   const ExprPtr&      expression()    const;
   const PrimitivePtr& equivConstant() const;
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
 
   static const int type_case_id = 0;
 private:
   PrimitivePtr p;
   ExprPtr      e;
 
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 };
 
 // match any value, maybe bind it to a variable name
@@ -114,14 +114,14 @@ public:
 
   const std::string& value() const;
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
 
   static const int type_case_id = 1;
 private:
   std::string vn;
 
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 };
 
 // match an array of patterns
@@ -136,15 +136,15 @@ public:
   // allow external permutation of array match sequence
   void indexes(const Idxs&);
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
 
   static const int type_case_id = 2;
 private:
   Patterns ps;
   Idxs     idxs;
 
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 };
 
 // match a regular expression
@@ -158,20 +158,20 @@ public:
 
   static PatternPtr toRegex(const MatchArray&);
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
   static const int type_case_id = 3;
 private:
   RegexPtr regex;
 
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 };
 
 // match a record of patterns
 class MatchRecord : public PatternCase<MatchRecord> {
 public:
-  typedef std::pair<std::string, PatternPtr> Field;
-  typedef std::vector<Field>                 Fields;
+  using Field = std::pair<std::string, PatternPtr>;
+  using Fields = std::vector<Field>;
 
   MatchRecord(const Fields& fs, const LexicalAnnotation&); // default indexes = [0,fs.size())
 
@@ -182,15 +182,15 @@ public:
   const Fields& fields() const;
   void fields(const Fields&);
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
 
   static const int type_case_id = 4;
 private:
   Fields fs;
   Idxs   is;
   
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 
   static void show(std::ostream&, const Field& f);
 };
@@ -203,15 +203,15 @@ public:
   const std::string& label() const;
   const PatternPtr&  value() const;
 
-  void show(std::ostream&) const;
-  bool operator==(const Pattern&) const;
+  void show(std::ostream&) const override;
+  bool operator==(const Pattern&) const override;
 
   static const int type_case_id = 5;
 private:
   std::string lbl;
   PatternPtr  p;
   
-  void assignSubNames(const std::string&);
+  void assignSubNames(const std::string&) override;
 };
 
 template <typename Case>
@@ -290,8 +290,8 @@ struct CSelection {
   ExprPtr    seq;
   Exprs      conds;
 };
-typedef std::shared_ptr<CSelection> CSelectionPtr;
-typedef std::vector<CSelectionPtr> CSelections;
+using CSelectionPtr = std::shared_ptr<CSelection>;
+using CSelections = std::vector<CSelectionPtr>;
 
 Expr* desugarComprehension(cc* c, const ExprPtr& ex, const CSelections& cs, const LexicalAnnotation& la);
 
diff --git a/include/hobbes/lang/pat/regex.H b/include/hobbes/lang/pat/regex.H
index dc69e756a..4b5d8f8c7 100644
--- a/include/hobbes/lang/pat/regex.H
+++ b/include/hobbes/lang/pat/regex.H
@@ -35,19 +35,19 @@ class cc;
  *     rstates : a mapping of F return codes to input regex indexes
  */
 struct Regex {
-  virtual ~Regex(void) = default;
+  virtual ~Regex() = default;
   virtual void show(std::ostream&) const = 0;
 };
-typedef std::shared_ptr<Regex> RegexPtr;
-typedef std::vector<RegexPtr> Regexes;
+using RegexPtr = std::shared_ptr<Regex>;
+using Regexes = std::vector<RegexPtr>;
 RegexPtr parseRegex(const std::string&);
 str::seq bindingNames(const RegexPtr&);
 
-typedef size_t RegexIdx;
-typedef std::set<RegexIdx> RegexIdxs;
-typedef std::map<size_t, RegexIdxs> RStates;
+using RegexIdx = size_t;
+using RegexIdxs = std::set<RegexIdx>;
+using RStates = std::map<size_t, RegexIdxs>;
 
-typedef std::map<size_t, str::seq> CaptureVarsAt;
+using CaptureVarsAt = std::map<size_t, str::seq>;
 
 struct CRegexes {
   std::string   fname;         // the low-level function that evaluates a set of regular expressions against an input
@@ -58,8 +58,8 @@ struct CRegexes {
 
 CRegexes makeRegexFn(cc*, const Regexes&, const LexicalAnnotation&);
 
-typedef std::pair<std::string, ExprPtr> CVarDef;
-typedef std::vector<CVarDef> CVarDefs;
+using CVarDef = std::pair<std::string, ExprPtr>;
+using CVarDefs = std::vector<CVarDef>;
 
 CVarDefs unpackCaptureVars(const std::string& strVar, const std::string& bufferVar, const CRegexes&, size_t state, const LexicalAnnotation&);
 
diff --git a/include/hobbes/lang/preds/appendsto.H b/include/hobbes/lang/preds/appendsto.H
index 3fe8780c9..923aef381 100644
--- a/include/hobbes/lang/preds/appendsto.H
+++ b/include/hobbes/lang/preds/appendsto.H
@@ -50,14 +50,14 @@ public:
   void addEliminator(const std::shared_ptr<ATEliminator>&);
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 private:
   using ATEliminators = std::vector<std::shared_ptr<ATEliminator>>;
   ATEliminators eliminators;
diff --git a/include/hobbes/lang/preds/appendsto/record.H b/include/hobbes/lang/preds/appendsto/record.H
index 8a3604816..262f675ec 100644
--- a/include/hobbes/lang/preds/appendsto/record.H
+++ b/include/hobbes/lang/preds/appendsto/record.H
@@ -7,12 +7,12 @@
 namespace hobbes {
 
 struct ATRecordEliminator : public ATEliminator {
-  bool satisfied(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fname, const MonoTypePtr& fty) const;
-  bool satisfiable(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fname, const MonoTypePtr& fty) const;
-  bool refine(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fieldName, const MonoTypePtr& fty, MonoTypeUnifier* s);
-  PolyTypePtr lookup(const std::string& vn) const;
-  SymSet bindings() const;
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
+  bool satisfied(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fname, const MonoTypePtr& fty) const override;
+  bool satisfiable(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fname, const MonoTypePtr& fty) const override;
+  bool refine(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fieldName, const MonoTypePtr& fty, MonoTypeUnifier* s) override;
+  PolyTypePtr lookup(const std::string& vn) const override;
+  SymSet bindings() const override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/class.H b/include/hobbes/lang/preds/class.H
index f12e71023..04ac66f04 100644
--- a/include/hobbes/lang/preds/class.H
+++ b/include/hobbes/lang/preds/class.H
@@ -18,20 +18,20 @@ FunDeps inferFundeps(const TEnvPtr& tenv, const Constraints& cs);
 FunDeps mergeFundeps(const FunDeps& lhs, const FunDeps& rhs);
 
 // a 'member mapping' is a set of named overloaded definitions
-typedef std::map<std::string, ExprPtr> MemberMapping;
+using MemberMapping = std::map<std::string, ExprPtr>;
 
 // a 'type class' is a scheme for overloading terms
 class TCInstance;
-typedef std::shared_ptr<TCInstance> TCInstancePtr;
-typedef std::vector<TCInstancePtr>  TCInstances;
+using TCInstancePtr = std::shared_ptr<TCInstance>;
+using TCInstances = std::vector<TCInstancePtr>;
 
 class TCInstanceFn;
-typedef std::shared_ptr<TCInstanceFn> TCInstanceFnPtr;
-typedef std::vector<TCInstanceFnPtr>  TCInstanceFns;
+using TCInstanceFnPtr = std::shared_ptr<TCInstanceFn>;
+using TCInstanceFns = std::vector<TCInstanceFnPtr>;
 
 class TClass : public Unqualifier, public LexicallyAnnotated {
 public:
-  typedef std::map<std::string, MonoTypePtr> Members;
+  using Members = std::map<std::string, MonoTypePtr>;
 
   TClass(const Constraints& reqs, const std::string& tcname, size_t tvs, const Members& tcmembers, const LexicalAnnotation&);
   TClass(const Constraints& reqs, const std::string& tcname, size_t tvs, const Members& tcmembers, const FunDeps& fundeps, const LexicalAnnotation&);
@@ -53,14 +53,14 @@ public:
   TCInstances matches(const TEnvPtr& tenv, const MonoTypes& mts, MonoTypeUnifier*, Definitions* ds) const;
 
   // unqualifier interface
-  bool        refine     (const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions* ds);
-  bool        satisfied  (const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds)                   const;
-  bool        satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds)                   const;
-  void        explain    (const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify  (const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const;
-  PolyTypePtr lookup     (const std::string& vn)                                                            const;
-  SymSet      bindings   ()                                                                                 const;
-  FunDeps     dependencies(const ConstraintPtr&)                                                            const;
+  bool        refine     (const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions* ds) override;
+  bool        satisfied  (const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds)                   const override;
+  bool        satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds)                   const override;
+  void        explain    (const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify  (const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const override;
+  PolyTypePtr lookup     (const std::string& vn)                                                            const override;
+  SymSet      bindings   ()                                                                                 const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                                            const override;
 
   // the member type in the implied context of this class's qua[nt|l]ification
   //   (normally you should use 'lookup' to get fully qualified types)
@@ -75,8 +75,8 @@ public:
 private:
   friend class TCInstanceFn;
 
-  typedef type_map<TCInstancePtr> TCMonoInstDB;
-  typedef type_map<TCInstanceFns> TCInstFnDB;
+  using TCMonoInstDB = type_map<TCInstancePtr>;
+  using TCInstFnDB = type_map<TCInstanceFns>;
 
   std::string   tcname;
   size_t        tvs;
@@ -93,18 +93,18 @@ private:
   bool refine(const TEnvPtr& tenv, const ConstraintPtr& c, const FunDep& fd, MonoTypeUnifier* s, Definitions* ds) const;
 
   // to support recursive types, track recursive invocations and assume they're satisfiable
-  typedef type_map<bool> TestedInstances;
+  using TestedInstances = type_map<bool>;
   mutable TestedInstances testedInstances;
 
   // cache satisfiability tests
   mutable TestedInstances satfInstances;
 };
-typedef std::shared_ptr<TClass>          TClassPtr;
-typedef std::map<std::string, TClassPtr> TClassEnv;
+using TClassPtr = std::shared_ptr<TClass>;
+using TClassEnv = std::map<std::string, TClassPtr>;
 
 class TCInstance : public LexicallyAnnotated {
 public:
-  typedef std::shared_ptr<Expr> ExprPtr;
+  using ExprPtr = std::shared_ptr<Expr>;
 
   TCInstance(const std::string& tcname, const MonoTypes& itys, const MemberMapping& mmap, const LexicalAnnotation&);
 
@@ -135,10 +135,10 @@ public:
   size_t arity() const;
 
   // can we immediately exclude this instance generator for this type list?
-  bool satisfiable(const TEnvPtr&, const MonoTypes&, Definitions*);
+  bool satisfiable(const TEnvPtr&, const MonoTypes&, Definitions*) const;
 
   // assuming we're not satisfiable, what are the constraints that aren't satisfiable?
-  void explainSatisfiability(const TEnvPtr&, const MonoTypes&, Definitions*, Constraints*, Constraints*);
+  void explainSatisfiability(const TEnvPtr&, const MonoTypes&, Definitions*, Constraints*, Constraints*) const;
 
   // (possibly) produce a type class instance from this generator
   bool apply(const TEnvPtr& tenv, const MonoTypes& tys, const TClass* c, MonoTypeUnifier*, Definitions* rdefs, TCInstancePtr* out) const;
@@ -154,7 +154,7 @@ public:
   void show(std::ostream&) const;
 
   // produce a sequence of type variables and constraints unique to this invocation
-  typedef std::pair<Constraints, MonoTypes> IFnDef;
+  using IFnDef = std::pair<Constraints, MonoTypes>;
   IFnDef freshDef(MonoTypeSubst* s) const;
 private:
   std::string   tcname;
diff --git a/include/hobbes/lang/preds/consrecord.H b/include/hobbes/lang/preds/consrecord.H
index d09c41bac..8e20e03f0 100644
--- a/include/hobbes/lang/preds/consrecord.H
+++ b/include/hobbes/lang/preds/consrecord.H
@@ -22,14 +22,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/consvariant.H b/include/hobbes/lang/preds/consvariant.H
index ea80df74e..3faa0ec2e 100644
--- a/include/hobbes/lang/preds/consvariant.H
+++ b/include/hobbes/lang/preds/consvariant.H
@@ -19,14 +19,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/cpptdesc.H b/include/hobbes/lang/preds/cpptdesc.H
index a364f2586..4d102e40c 100644
--- a/include/hobbes/lang/preds/cpptdesc.H
+++ b/include/hobbes/lang/preds/cpptdesc.H
@@ -12,14 +12,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/data.H b/include/hobbes/lang/preds/data.H
index d48354b79..31e03bda4 100644
--- a/include/hobbes/lang/preds/data.H
+++ b/include/hobbes/lang/preds/data.H
@@ -15,14 +15,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/deconstruct.H b/include/hobbes/lang/preds/deconstruct.H
index 6f14b5f32..8c8f60526 100644
--- a/include/hobbes/lang/preds/deconstruct.H
+++ b/include/hobbes/lang/preds/deconstruct.H
@@ -15,14 +15,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/equal.H b/include/hobbes/lang/preds/equal.H
index abbf1c946..fed9ee8d5 100644
--- a/include/hobbes/lang/preds/equal.H
+++ b/include/hobbes/lang/preds/equal.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/hasctor.H b/include/hobbes/lang/preds/hasctor.H
index 8660c4b4f..d45f21ab8 100644
--- a/include/hobbes/lang/preds/hasctor.H
+++ b/include/hobbes/lang/preds/hasctor.H
@@ -42,14 +42,14 @@ public:
   void addEliminator(const std::shared_ptr<HCEliminator>&);
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 private:
   using HCEliminators = std::vector<std::shared_ptr<HCEliminator>>;
   HCEliminators eliminators;
diff --git a/include/hobbes/lang/preds/hasctor/variant.H b/include/hobbes/lang/preds/hasctor/variant.H
index fc59b53c5..6f4267d64 100644
--- a/include/hobbes/lang/preds/hasctor/variant.H
+++ b/include/hobbes/lang/preds/hasctor/variant.H
@@ -7,11 +7,11 @@
 namespace hobbes {
 
 struct HCVariantEliminator : public HCEliminator {
-  bool satisfied(const TEnvPtr& tenv, const HasCtor&, Definitions*) const;
-  bool satisfiable(const TEnvPtr& tenv, const HasCtor&, Definitions*) const;
-  bool refine(const TEnvPtr& tenv, const HasCtor&, MonoTypeUnifier* s, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const HasCtor&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr& tenv, const HasCtor&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr& tenv, const HasCtor&, Definitions*) const override;
+  bool refine(const TEnvPtr& tenv, const HasCtor&, MonoTypeUnifier* s, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const HasCtor&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 const Variant* isVariantPEnum(const MonoTypePtr& e);
diff --git a/include/hobbes/lang/preds/hasfield.H b/include/hobbes/lang/preds/hasfield.H
index a474b4c2b..4fac67635 100644
--- a/include/hobbes/lang/preds/hasfield.H
+++ b/include/hobbes/lang/preds/hasfield.H
@@ -60,14 +60,14 @@ public:
   void addEliminator(const std::shared_ptr<HFEliminator>&);
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 private:
   using HFEliminators = std::vector<std::shared_ptr<HFEliminator>>;
   HFEliminators eliminators;
diff --git a/include/hobbes/lang/preds/hasfield/lookup.H b/include/hobbes/lang/preds/hasfield/lookup.H
index 73cdbdb1b..a8a4a7c77 100644
--- a/include/hobbes/lang/preds/hasfield/lookup.H
+++ b/include/hobbes/lang/preds/hasfield/lookup.H
@@ -8,11 +8,11 @@
 namespace hobbes {
 
 struct HFLookupEliminator : public HFEliminator {
-  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/hasfield/record.H b/include/hobbes/lang/preds/hasfield/record.H
index 6f886e4f5..93d2d7c06 100644
--- a/include/hobbes/lang/preds/hasfield/record.H
+++ b/include/hobbes/lang/preds/hasfield/record.H
@@ -7,11 +7,11 @@
 namespace hobbes {
 
 struct HFRecordEliminator : public HFEliminator {
-  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/hasfield/slookup.H b/include/hobbes/lang/preds/hasfield/slookup.H
index 47829a77d..43df2f972 100644
--- a/include/hobbes/lang/preds/hasfield/slookup.H
+++ b/include/hobbes/lang/preds/hasfield/slookup.H
@@ -8,11 +8,11 @@
 namespace hobbes {
 
 struct HFSLookupEliminator : public HFEliminator {
-  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/hasfield/tenvlookup.H b/include/hobbes/lang/preds/hasfield/tenvlookup.H
index a32af5b84..5ecc545f0 100644
--- a/include/hobbes/lang/preds/hasfield/tenvlookup.H
+++ b/include/hobbes/lang/preds/hasfield/tenvlookup.H
@@ -7,11 +7,11 @@
 namespace hobbes {
 
 struct HFTEnvLookupEliminator : public HFEliminator {
-  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const;
-  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*);
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool satisfied(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr& tenv, const HasField&, Definitions*) const override;
+  bool refine(const TEnvPtr& tenv, const HasField&, MonoTypeUnifier* s, Definitions*) override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/loadref.H b/include/hobbes/lang/preds/loadref.H
index a0cc4daa5..301a8b922 100644
--- a/include/hobbes/lang/preds/loadref.H
+++ b/include/hobbes/lang/preds/loadref.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/not.H b/include/hobbes/lang/preds/not.H
index ed5917ed0..55fc5c33f 100644
--- a/include/hobbes/lang/preds/not.H
+++ b/include/hobbes/lang/preds/not.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/packsto.H b/include/hobbes/lang/preds/packsto.H
index a36e0bcdf..c0191d41c 100644
--- a/include/hobbes/lang/preds/packsto.H
+++ b/include/hobbes/lang/preds/packsto.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                 const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)               const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                            const;
-  SymSet      bindings ()                                                                 const;
-  FunDeps     dependencies(const ConstraintPtr&)                                          const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                 const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)               const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                            const override;
+  SymSet      bindings ()                                                                 const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                          const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/recty.H b/include/hobbes/lang/preds/recty.H
index c040c17c8..3ec51b1c7 100644
--- a/include/hobbes/lang/preds/recty.H
+++ b/include/hobbes/lang/preds/recty.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/sizeof.H b/include/hobbes/lang/preds/sizeof.H
index 7adfb531e..9fa90a4bf 100644
--- a/include/hobbes/lang/preds/sizeof.H
+++ b/include/hobbes/lang/preds/sizeof.H
@@ -12,14 +12,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/subtype.H b/include/hobbes/lang/preds/subtype.H
index 8b5d431d0..f8b3597e5 100644
--- a/include/hobbes/lang/preds/subtype.H
+++ b/include/hobbes/lang/preds/subtype.H
@@ -43,14 +43,14 @@ public:
   void addEliminator(const std::shared_ptr<SubtypeEliminator>&);
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 private:
   using SubtypeEliminators = std::vector<std::shared_ptr<SubtypeEliminator>>;
   SubtypeEliminators eliminators;
diff --git a/include/hobbes/lang/preds/subtype/obj.H b/include/hobbes/lang/preds/subtype/obj.H
index 85cc73d75..8ce48b1dc 100644
--- a/include/hobbes/lang/preds/subtype/obj.H
+++ b/include/hobbes/lang/preds/subtype/obj.H
@@ -38,7 +38,7 @@ struct PtrAdjustment {
     }
   }
 };
-typedef std::vector<PtrAdjustment> PtrAdjustmentPath; // for A <: ... <: Z, all adjustments
+using PtrAdjustmentPath = std::vector<PtrAdjustment>; // for A <: ... <: Z, all adjustments
 
 std::string show(const PtrAdjustmentPath& p);
 
@@ -46,7 +46,7 @@ std::string show(const PtrAdjustmentPath& p);
 //  (this implementation only works with GCC)
 class Objs : public SubtypeEliminator {
 public:
-  virtual ~Objs(void) = default;
+  virtual ~Objs() = default;
 #ifndef __clang__
   typedef __cxxabiv1::__class_type_info     class_type;
   typedef __cxxabiv1::__si_class_type_info  si_class_type;
@@ -55,7 +55,7 @@ public:
   // record class definitions
   void add(const class_type* ct);
 #else
-  typedef int class_type;
+  using class_type = int;
 #endif
   bool add(const std::type_info& ti);
   bool add(const std::type_info* ti);
@@ -77,21 +77,21 @@ public:
   PolyTypePtr generalize(const MonoTypePtr& mt) const;
 
   // subtype eliminator interface
-  bool refine     (const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs, MonoTypeUnifier* s);
-  bool satisfied  (const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs) const;
-  bool satisfiable(const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs) const;
+  bool refine     (const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs, MonoTypeUnifier* s) override;
+  bool satisfied  (const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs) const override;
+  bool satisfiable(const TEnvPtr& tenv, const MonoTypePtr& lhs, const MonoTypePtr& rhs) const override;
 
-  ExprPtr unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr     lookup   (const std::string& vn)                              const;
-  SymSet          bindings ()                                                   const;
+  ExprPtr unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr     lookup   (const std::string& vn)                              const override;
+  SymSet          bindings ()                                                   const override;
 private:
-  typedef std::map<std::string, const class_type*> ClassDefs;
+  using ClassDefs = std::map<std::string, const class_type *>;
   ClassDefs classDefs;
 
   bool mayBeKnown(const MonoTypePtr& mt) const;
   bool pathExists(const std::string& from, const std::string& to) const;
 };
-typedef std::shared_ptr<Objs> ObjsPtr;
+using ObjsPtr = std::shared_ptr<Objs>;
 
 }
 
diff --git a/include/hobbes/lang/preds/typeof.H b/include/hobbes/lang/preds/typeof.H
index b49c0752f..27d7f4804 100644
--- a/include/hobbes/lang/preds/typeof.H
+++ b/include/hobbes/lang/preds/typeof.H
@@ -13,14 +13,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                           const;
-  SymSet      bindings ()                                                                const;
-  FunDeps     dependencies(const ConstraintPtr&)                                         const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)              const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&,const ExprPtr&,Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                           const override;
+  SymSet      bindings ()                                                                const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                         const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/vapp.H b/include/hobbes/lang/preds/vapp.H
index 5c512bd1b..91110cc64 100644
--- a/include/hobbes/lang/preds/vapp.H
+++ b/include/hobbes/lang/preds/vapp.H
@@ -17,14 +17,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 };
 
 }
diff --git a/include/hobbes/lang/preds/vtrunc.H b/include/hobbes/lang/preds/vtrunc.H
index e4358385f..73c1975ed 100644
--- a/include/hobbes/lang/preds/vtrunc.H
+++ b/include/hobbes/lang/preds/vtrunc.H
@@ -17,14 +17,14 @@ public:
   static std::string constraintName();
 
   // unqualifier interface
-  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs);
-  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  PolyTypePtr lookup   (const std::string& vn)                                             const;
-  SymSet      bindings ()                                                                  const;
-  FunDeps     dependencies(const ConstraintPtr&)                                           const;
+  bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+  bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+  bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+  void        explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds, annmsgs* msgs) override;
+  ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  PolyTypePtr lookup   (const std::string& vn)                                             const override;
+  SymSet      bindings ()                                                                  const override;
+  FunDeps     dependencies(const ConstraintPtr&)                                           const override;
 };
 
 }
diff --git a/include/hobbes/lang/tylift.H b/include/hobbes/lang/tylift.H
index 3dcdc2a22..9376fce8e 100644
--- a/include/hobbes/lang/tylift.H
+++ b/include/hobbes/lang/tylift.H
@@ -43,18 +43,18 @@ struct typedb {
 };
 
 struct nulltypedb : public typedb {
-  MonoTypePtr defineNamedType(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty);
-  bool isTypeName(const std::string&) const;
-  [[noreturn]] MonoTypePtr namedTypeRepresentation(const std::string&) const;
+  MonoTypePtr defineNamedType(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty) override;
+  bool isTypeName(const std::string&) const override;
+  [[noreturn]] MonoTypePtr namedTypeRepresentation(const std::string&) const override;
 
-  [[noreturn]] void defineTypeAlias(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty);
-  bool isTypeAliasName(const std::string& name) const;
-  MonoTypePtr replaceTypeAliases(const MonoTypePtr& ty) const;
+  [[noreturn]] void defineTypeAlias(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty) override;
+  bool isTypeAliasName(const std::string& name) const override;
+  MonoTypePtr replaceTypeAliases(const MonoTypePtr& ty) const override;
   
-  [[noreturn]] PolyTypePtr opaquePtrPolyType(const std::type_info&, unsigned int sz, bool inStruct);
-  [[noreturn]] MonoTypePtr opaquePtrMonoType(const std::type_info&, unsigned int sz, bool inStruct);
+  [[noreturn]] PolyTypePtr opaquePtrPolyType(const std::type_info&, unsigned int sz, bool inStruct) override;
+  [[noreturn]] MonoTypePtr opaquePtrMonoType(const std::type_info&, unsigned int sz, bool inStruct) override;
  
-  PolyTypePtr generalize(const MonoTypePtr& mt) const;
+  PolyTypePtr generalize(const MonoTypePtr& mt) const override;
 };
 extern nulltypedb nulltdb;
 
@@ -75,8 +75,8 @@ struct recursion {
 // a linked list is a recursive sum of nested tuples starting at unit
 template <typename T>
   struct seq {
-    typedef std::pair<T, seq<T>*> pair_t;
-    typedef variant<unit, pair_t> rep_t;
+    using pair_t = std::pair<T, seq<T> *>;
+    using rep_t = variant<unit, pair_t>;
     rep_t data;
 
     seq() : data(unit()) { }
@@ -169,7 +169,7 @@ template <bool InStruct>
 template <typename F, typename S>
   struct liftPair {
     static MonoTypePtr type(typedb& tenv) {
-      typedef std::pair<F,S> FS;
+      using FS = std::pair<F, S>;
       Record::Members fs;
       fs.push_back(Record::Member(".f0", lift<F, true>::type(tenv), offsetof(FS, first)));
       fs.push_back(Record::Member(".f1", lift<S, true>::type(tenv), offsetof(FS, second)));
@@ -312,7 +312,7 @@ template <typename F>
   struct closure { };
 template <typename R, typename ... Args>
   struct closure<R(Args...)> {
-    typedef R (*F)(const void*,Args...);
+    using F = R (*)(const void *, Args...);
     F    f;
     char data[1];
 
@@ -342,7 +342,7 @@ template <bool InStruct, typename R, typename ... Args>
 // -- then as with the hobbes::variant layout
 template <const char* TN, typename T>
   struct label {
-    typedef T type;
+    using type = T;
     T value;
     label() : value() { }
     label(const T& x) : value(x) { }
@@ -350,12 +350,12 @@ template <const char* TN, typename T>
   };
 template <typename T, typename P = void>
   struct liftVarCtor {
-    typedef T type;
+    using type = T;
     static std::string labelText(int idx) { return ".f" + str::from(idx); }
   };
 template <const char* TN, typename T>
   struct liftVarCtor< label<TN, T> > {
-    typedef typename label<TN, T>::type type;
+    using type = typename label<TN, T>::type;
     static std::string labelText(int) { return label<TN, T>::name(); }
   };
 template <typename ... CTys>
diff --git a/include/hobbes/lang/type.H b/include/hobbes/lang/type.H
index 8e1dccf36..0db745644 100644
--- a/include/hobbes/lang/type.H
+++ b/include/hobbes/lang/type.H
@@ -2,17 +2,17 @@
 #ifndef HOBBES_LANG_TYPE_HPP_INCLUDED
 #define HOBBES_LANG_TYPE_HPP_INCLUDED
 
+#include <hobbes/util/array.H>
 #include <hobbes/util/hash.H>
+#include <hobbes/util/lannotation.H>
 #include <hobbes/util/ptr.H>
-#include <hobbes/util/array.H>
 #include <hobbes/util/str.H>
-#include <hobbes/util/lannotation.H>
-#include <string>
-#include <vector>
-#include <set>
 #include <map>
 #include <memory>
+#include <set>
 #include <stdexcept>
+#include <string>
+#include <vector>
 
 namespace hobbes {
 
@@ -21,24 +21,24 @@ class MonoTypeUnifier;
 
 // forall a0..aN : T
 class PolyType;
-typedef std::shared_ptr<PolyType> PolyTypePtr;
-typedef std::vector<PolyTypePtr>    PolyTypes;
+using PolyTypePtr = std::shared_ptr<PolyType>;
+using PolyTypes = std::vector<PolyTypePtr>;
 
 // (C0, ..., Cn) => T
 class QualType;
-typedef std::shared_ptr<QualType> QualTypePtr;
-typedef std::vector<QualTypePtr>    QualTypes;
+using QualTypePtr = std::shared_ptr<QualType>;
+using QualTypes = std::vector<QualTypePtr>;
 
 // P(T)
 class Constraint;
-typedef std::shared_ptr<Constraint> ConstraintPtr;
-typedef std::vector<ConstraintPtr>    Constraints;
+using ConstraintPtr = std::shared_ptr<Constraint>;
+using Constraints = std::vector<ConstraintPtr>;
 
 // T
 class MonoType {
 public:
   virtual ~MonoType();
-  typedef std::shared_ptr<MonoType> ptr;
+  using ptr = std::shared_ptr<MonoType>;
 
   virtual void show(std::ostream&) const = 0;
   bool operator==(const MonoType& rhs) const;
@@ -57,7 +57,7 @@ private:
 
 public:
   // improves performance of identifying type variables and tgens
-  typedef std::set<std::string> TypeVarNames;
+  using TypeVarNames = std::set<std::string>;
   TypeVarNames freeTVars;
   int tgenCount;
 
@@ -68,8 +68,8 @@ public:
   mutable ptr unaliasedType;
 };
 
-typedef MonoType::ptr MonoTypePtr;
-typedef std::vector<MonoTypePtr>  MonoTypes;
+using MonoTypePtr = MonoType::ptr;
+using MonoTypes = std::vector<MonoTypePtr>;
 
 inline std::ostream& operator<<(std::ostream& out, const MonoTypePtr& t) {
   t->show(out);
@@ -78,13 +78,13 @@ inline std::ostream& operator<<(std::ostream& out, const MonoTypePtr& t) {
 
 // nested environments for types and type predicate resolvers
 class TEnv;
-typedef std::shared_ptr<TEnv> TEnvPtr;
+using TEnvPtr = std::shared_ptr<TEnv>;
 
 class Unqualifier;
-typedef std::shared_ptr<Unqualifier> UnqualifierPtr;
+using UnqualifierPtr = std::shared_ptr<Unqualifier>;
 
 class UnqualifierSet;
-typedef std::shared_ptr<UnqualifierSet> UnqualifierSetPtr;
+using UnqualifierSetPtr = std::shared_ptr<UnqualifierSet>;
 
 class TEnv {
 public:
@@ -111,12 +111,12 @@ public:
   TEnv* root();
 public:
   // get access to the internal type environment map (should only be used for debugging)
-  typedef std::map<std::string, PolyTypePtr> PolyTypeEnv;
+  using PolyTypeEnv = std::map<std::string, PolyTypePtr>;
 
   PolyTypeEnv typeEnvTable(std::function<std::string const&(std::string const&)> const& = [](std::string const& binding) -> std::string const& { return binding; }) const;
   str::set boundVariables() const;
 
-  typedef std::map<std::string, UnqualifierPtr> Unqualifiers;
+  using Unqualifiers = std::map<std::string, UnqualifierPtr>;
   const Unqualifiers& unqualifiers() const;
 private:
   TEnvPtr           parent;
@@ -129,7 +129,7 @@ public:
   MonoTypePtr unalias(const std::string&) const;
   bool isOpaqueTypeAlias(const std::string&) const;
 private:
-  typedef std::map<std::string, MonoTypePtr> TypeAliases;
+  using TypeAliases = std::map<std::string, MonoTypePtr>;
   TypeAliases typeAliases;
 
 public:
@@ -145,10 +145,10 @@ TEnvPtr fnFrame(const TEnvPtr&, const str::seq&, const MonoTypes&);
 TEnvPtr bindFrame(const TEnvPtr&, const std::string&, const MonoTypePtr&);
 TEnvPtr bindFrame(const TEnvPtr&, const std::string&, const QualTypePtr&);
 
-typedef std::string                   TVName;
-typedef std::vector<TVName>           Names;
-typedef std::set<TVName>              NameSet;
-typedef std::map<TVName, MonoTypePtr> MonoTypeSubst;
+using TVName = std::string;
+using Names = std::vector<TVName>;
+using NameSet = std::set<TVName>;
+using MonoTypeSubst = std::map<TVName, MonoTypePtr>;
 
 inline MonoTypeSubst substitution(const str::seq& ns, const MonoTypes& ts) {
   MonoTypeSubst s;
@@ -267,7 +267,7 @@ template <typename Case>
 // or may be an alias for a composite type
 class Prim : public MonoTypeCase<Prim> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const std::string& name() const;
   const MonoTypePtr& representation() const;
@@ -286,7 +286,7 @@ private:
 // an opaque pointer to some C++ type
 class OpaquePtr : public MonoTypeCase<OpaquePtr> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const std::string& name()               const;
   unsigned int       size()               const;
@@ -311,7 +311,7 @@ MonoTypePtr normIfOpaquePtr(const MonoTypePtr& ty);
 class TVar : public MonoTypeCase<TVar> {
 public:
   const std::string& name() const;
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   static const int type_case_id = 2;
 
@@ -327,7 +327,7 @@ private:
 class TGen : public MonoTypeCase<TGen> {
 public:
   int id() const;
-  void show(std::ostream& out) const; // should never be shown
+  void show(std::ostream& out) const override; // should never be shown
 
   static const int type_case_id = 3;
 
@@ -342,7 +342,7 @@ private:
 // an array whose length is determined
 class FixedArray : public MonoTypeCase<FixedArray> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const MonoTypePtr& type() const;
   const MonoTypePtr& length() const;
@@ -363,7 +363,7 @@ private:
 // an array whose length is not known at compile-time
 class Array : public MonoTypeCase<Array> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const MonoTypePtr& type() const;
 
@@ -390,9 +390,9 @@ public:
     MonoTypePtr  type;
     unsigned int id;
   };
-  typedef std::vector<Member> Members;
+  using Members = std::vector<Member>;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   // get the first visible member and the type of the 'remainder' of the variant after ignoring the first field
   // (these are used for structural decomposition in generic functions)
@@ -440,9 +440,9 @@ public:
     MonoTypePtr type;
     int         offset;
   };
-  typedef std::vector<Member> Members;
+  using Members = std::vector<Member>;
 
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const Members& members() const;
   const MonoTypePtr& member(const std::string& mn) const;
@@ -498,7 +498,7 @@ unsigned int alignment(const MonoTypePtr&);
 // a flat (contextless) function type
 class Func : public MonoTypeCase<Func> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const MonoTypePtr& argument() const;
   const MonoTypePtr& result() const;
@@ -520,7 +520,7 @@ private:
 // an abstraction of type structure suitable for unifying otherwise distinct types
 class Exists : public MonoTypeCase<Exists> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const std::string& absTypeName() const;
   const MonoTypePtr& absType() const;
@@ -544,7 +544,7 @@ QualTypePtr unpackedType(const QualTypePtr& qty);
 // type-level values (the writing is on the wall here -- this is a hack and we are going to need full dependent types)
 class TString : public MonoTypeCase<TString> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   const std::string& value() const;
 
@@ -560,7 +560,7 @@ private:
 
 class TLong : public MonoTypeCase<TLong> {
 public:
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
   long value() const;
 
@@ -577,7 +577,7 @@ private:
 // a type-level abstraction
 class TAbs : public MonoTypeCase<TAbs> {
 public:
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const str::seq&    args() const;
   const MonoTypePtr& body() const;
@@ -596,7 +596,7 @@ private:
 // a type-level application
 class TApp : public MonoTypeCase<TApp> {
 public:
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const MonoTypePtr& fn() const;
   const MonoTypes&   args() const;
@@ -615,7 +615,7 @@ private:
 // a recursive type
 class Recursive : public MonoTypeCase<Recursive> {
 public:
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const std::string& recTypeName() const;
   const MonoTypePtr& recType() const;
@@ -634,11 +634,11 @@ private:
 // expressions in types
 //  (eventually we will need to eliminate the distinction between types and expressions)
 class Expr;
-typedef std::shared_ptr<Expr> ExprPtr;
+using ExprPtr = std::shared_ptr<Expr>;
 
 class TExpr : public MonoTypeCase<TExpr> {
 public:
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const ExprPtr& expr() const;
 
@@ -712,35 +712,35 @@ template <typename T>
 struct CPtr {
   template <typename T>
     struct as {
-      typedef const T* ty;
+      using ty = const T *;
     };
 };
 
 struct MPtr {
   template <typename T>
     struct as {
-      typedef T* ty;
+      using ty = T *;
     };
 };
 
 template <typename T, typename Ptr, typename PtrC, typename F>
   T switchOfF(Ptr ty, F f) {
-    typedef typename PtrC::template as<Prim>::ty       PrimT;
-    typedef typename PtrC::template as<OpaquePtr>::ty  OpaquePtrT;
-    typedef typename PtrC::template as<TVar>::ty       TVarT;
-    typedef typename PtrC::template as<TGen>::ty       TGenT;
-    typedef typename PtrC::template as<TAbs>::ty       TAbsT;
-    typedef typename PtrC::template as<TApp>::ty       TAppT;
-    typedef typename PtrC::template as<FixedArray>::ty FixedArrayT;
-    typedef typename PtrC::template as<Array>::ty      ArrayT;
-    typedef typename PtrC::template as<Variant>::ty    VariantT;
-    typedef typename PtrC::template as<Record>::ty     RecordT;
-    typedef typename PtrC::template as<Func>::ty       FuncT;
-    typedef typename PtrC::template as<Exists>::ty     ExistsT;
-    typedef typename PtrC::template as<Recursive>::ty  RecursiveT;
-    typedef typename PtrC::template as<TString>::ty    TStringT;
-    typedef typename PtrC::template as<TLong>::ty      TLongT;
-    typedef typename PtrC::template as<TExpr>::ty      TExprT;
+    using PrimT = typename PtrC::template as<Prim>::ty;
+    using OpaquePtrT = typename PtrC::template as<OpaquePtr>::ty;
+    using TVarT = typename PtrC::template as<TVar>::ty;
+    using TGenT = typename PtrC::template as<TGen>::ty;
+    using TAbsT = typename PtrC::template as<TAbs>::ty;
+    using TAppT = typename PtrC::template as<TApp>::ty;
+    using FixedArrayT = typename PtrC::template as<FixedArray>::ty;
+    using ArrayT = typename PtrC::template as<Array>::ty;
+    using VariantT = typename PtrC::template as<Variant>::ty;
+    using RecordT = typename PtrC::template as<Record>::ty;
+    using FuncT = typename PtrC::template as<Func>::ty;
+    using ExistsT = typename PtrC::template as<Exists>::ty;
+    using RecursiveT = typename PtrC::template as<Recursive>::ty;
+    using TStringT = typename PtrC::template as<TString>::ty;
+    using TLongT = typename PtrC::template as<TLong>::ty;
+    using TExprT = typename PtrC::template as<TExpr>::ty;
 
     switch (ty->case_id()) {
     case Prim::type_case_id:
@@ -793,24 +793,24 @@ template <typename T>
 template <typename T>
   std::vector<T> switchOf(const MonoTypes& ts, const switchType<T>& f) {
     std::vector<T> result;
-    for (MonoTypes::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-      result.push_back(switchOf(*t, f));
+    for (const auto &t : ts) {
+      result.push_back(switchOf(t, f));
     }
     return result;
   }
 
 template <typename T>
   T switchOf(const MonoTypes& ts, T s, T (*appendF)(T,T), const switchType<T>& f) {
-    for (MonoTypes::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-      s = appendF(s, switchOf(*t, f));
+    for (const auto &t : ts) {
+      s = appendF(s, switchOf(t, f));
     }
     return s;
   }
 
 template <typename K, typename T>
   std::vector< std::pair<K, T> > switchOf(const std::vector< std::pair<K, MonoTypePtr> >& kts, const switchType<T>& f) {
-    typedef std::pair<K, T> KT;
-    typedef std::vector<KT> KTS;
+    using KT = std::pair<K, T>;
+    using KTS = std::vector<KT>;
     KTS r;
     for (typename std::vector< std::pair<K, MonoTypePtr> >::const_iterator kt = kts.begin(); kt != kts.end(); ++kt) {
       r.push_back(KT(kt->first, switchOf(kt->second, f)));
@@ -821,8 +821,8 @@ template <typename K, typename T>
 template <typename T>
   Variant::Members switchOf(const Variant::Members& ms, const switchType<T>& f) {
     Variant::Members r;
-    for (Variant::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-      r.push_back(Variant::Member(m->selector, switchOf(m->type, f), m->id));
+    for (const auto &m : ms) {
+      r.push_back(Variant::Member(m.selector, switchOf(m.type, f), m.id));
     }
     return r;
   }
@@ -830,16 +830,16 @@ template <typename T>
 template <typename T>
   Record::Members switchOf(const Record::Members& ms, const switchType<T>& f) {
     Record::Members r;
-    for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-      r.push_back(Record::Member(m->field, switchOf(m->type, f), m->offset));
+    for (const auto &m : ms) {
+      r.push_back(Record::Member(m.field, switchOf(m.type, f), m.offset));
     }
     return r;
   }
 
 inline MonoTypes selectTypes(const Variant::Members& ms) {
   MonoTypes r;
-  for (Variant::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    r.push_back(m->type);
+  for (const auto &m : ms) {
+    r.push_back(m.type);
   }
   return r;
 }
@@ -854,8 +854,8 @@ inline str::seq selectNames(const Variant::Members& ms) {
 
 inline MonoTypes selectTypes(const Record::Members& ms) {
   MonoTypes r;
-  for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    r.push_back(m->type);
+  for (const auto &m : ms) {
+    r.push_back(m.type);
   }
   return r;
 }
@@ -870,46 +870,46 @@ inline str::seq selectNames(const Record::Members& ms) {
 
 // walk a type structure for a side-effect (override any part to do per-constructor walks)
 struct walkTy : public switchType<UnitV> {
-  UnitV with(const Prim*       v) const;
-  UnitV with(const OpaquePtr*  v) const;
-  UnitV with(const TVar*       v) const;
-  UnitV with(const TGen*       v) const;
-  UnitV with(const TAbs*       v) const;
-  UnitV with(const TApp*       v) const;
-  UnitV with(const FixedArray* v) const;
-  UnitV with(const Array*      v) const;
-  UnitV with(const Variant*    v) const;
-  UnitV with(const Record*     v) const;
-  UnitV with(const Func*       v) const;
-  UnitV with(const Exists*     v) const;
-  UnitV with(const Recursive*  v) const;
-  UnitV with(const TString*    v) const;
-  UnitV with(const TLong*      v) const;
-  UnitV with(const TExpr*      v) const;
+  UnitV with(const Prim*       v) const override;
+  UnitV with(const OpaquePtr*  v) const override;
+  UnitV with(const TVar*       v) const override;
+  UnitV with(const TGen*       v) const override;
+  UnitV with(const TAbs*       v) const override;
+  UnitV with(const TApp*       v) const override;
+  UnitV with(const FixedArray* v) const override;
+  UnitV with(const Array*      v) const override;
+  UnitV with(const Variant*    v) const override;
+  UnitV with(const Record*     v) const override;
+  UnitV with(const Func*       v) const override;
+  UnitV with(const Exists*     v) const override;
+  UnitV with(const Recursive*  v) const override;
+  UnitV with(const TString*    v) const override;
+  UnitV with(const TLong*      v) const override;
+  UnitV with(const TExpr*      v) const override;
 };
 
 // copy a type structure entirely (override any part to do a partial 'Type -> Type' transform)
 struct switchTyFn : public switchType<MonoTypePtr> {
-  MonoTypePtr with(const Prim*       v) const;
-  MonoTypePtr with(const OpaquePtr*  v) const;
-  MonoTypePtr with(const TVar*       v) const;
-  MonoTypePtr with(const TGen*       v) const;
-  MonoTypePtr with(const TAbs*       v) const;
-  MonoTypePtr with(const TApp*       v) const;
-  MonoTypePtr with(const FixedArray* v) const;
-  MonoTypePtr with(const Array*      v) const;
-  MonoTypePtr with(const Variant*    v) const;
-  MonoTypePtr with(const Record*     v) const;
-  MonoTypePtr with(const Func*       v) const;
-  MonoTypePtr with(const Exists*     v) const;
-  MonoTypePtr with(const Recursive*  v) const;
+  MonoTypePtr with(const Prim*       v) const override;
+  MonoTypePtr with(const OpaquePtr*  v) const override;
+  MonoTypePtr with(const TVar*       v) const override;
+  MonoTypePtr with(const TGen*       v) const override;
+  MonoTypePtr with(const TAbs*       v) const override;
+  MonoTypePtr with(const TApp*       v) const override;
+  MonoTypePtr with(const FixedArray* v) const override;
+  MonoTypePtr with(const Array*      v) const override;
+  MonoTypePtr with(const Variant*    v) const override;
+  MonoTypePtr with(const Record*     v) const override;
+  MonoTypePtr with(const Func*       v) const override;
+  MonoTypePtr with(const Exists*     v) const override;
+  MonoTypePtr with(const Recursive*  v) const override;
 
   // bleh
-  MonoTypePtr with(const TString* v) const;
-  MonoTypePtr with(const TLong*   v) const;
+  MonoTypePtr with(const TString* v) const override;
+  MonoTypePtr with(const TLong*   v) const override;
 
   // not quite as bleh
-  MonoTypePtr with(const TExpr*) const;
+  MonoTypePtr with(const TExpr*) const override;
 };
 
 MonoTypePtr clone(const MonoTypePtr&);
@@ -935,7 +935,7 @@ int tgenSize(const MonoTypes& mts);
 int tgenSize(const ConstraintPtr& c);
 [[noreturn]] int tgenSize(const QualTypePtr& qt);
 
-typedef std::set<int> TGenVarSet;
+using TGenVarSet = std::set<int>;
 TGenVarSet tgenVars(const MonoTypePtr&);
 
 TVName        canonicalName(int v);
@@ -1028,7 +1028,7 @@ inline MonoTypePtr primty(const char* x, const MonoTypePtr& aty) {
 }
 
 inline QualTypePtr qualtype(const Constraints& cs, const MonoTypePtr& p) {
-  return QualTypePtr(new QualType(cs, p));
+  return std::make_shared<QualType>(cs, p);
 }
 
 inline QualTypePtr qualtype(const Constraints& cs, MonoType* mt) {
@@ -1036,11 +1036,11 @@ inline QualTypePtr qualtype(const Constraints& cs, MonoType* mt) {
 }
 
 inline QualTypePtr qualtype(const MonoTypePtr& p) {
-  return QualTypePtr(new QualType(p));
+  return std::make_shared<QualType>(p);
 }
 
 inline QualTypePtr qualtype(MonoType* mt) {
-  return QualTypePtr(new QualType(MonoTypePtr(mt)));
+  return std::make_shared<QualType>(MonoTypePtr(mt));
 }
 
 inline QualTypePtr qualtype(const char* x) {
@@ -1048,11 +1048,11 @@ inline QualTypePtr qualtype(const char* x) {
 }
 
 inline PolyTypePtr polytype(int tvs, const QualTypePtr& qt) {
-  return PolyTypePtr(new PolyType(tvs, qt));
+  return std::make_shared<PolyType>(tvs, qt);
 }
 
 inline PolyTypePtr polytype(const QualTypePtr& qt) {
-  return PolyTypePtr(new PolyType(qt));
+  return std::make_shared<PolyType>(qt);
 }
 
 inline PolyTypePtr polytype(const MonoTypePtr& p) {
@@ -1080,7 +1080,7 @@ inline MonoTypePtr tstring(const std::string& x) {
 }
 
 inline MonoTypePtr tuplety(const MonoTypes& mtys = MonoTypes()) {
-  if (mtys.size() == 0) {
+  if (mtys.empty()) {
     return primty("unit");
   } else {
     Record::Members ms;
@@ -1125,7 +1125,7 @@ inline MonoTypePtr functy(const MonoTypePtr& aty, const MonoTypePtr& rty) {
 }
 
 inline MonoTypePtr functy(const MonoTypes& atys, const MonoTypePtr& rty) {
-  if (atys.size() == 0) {
+  if (atys.empty()) {
     return Func::make(tuplety(list(tuplety())), rty);
   } else {
     return Func::make(tuplety(atys), rty);
@@ -1268,7 +1268,7 @@ MonoTypePtr fileRefTy(const MonoTypePtr&);
 template <>
   struct genHash<Record::Member> {
     inline size_t operator()(const Record::Member& x) const {
-      typedef std::tuple<std::string, MonoTypePtr, unsigned int> RMTup;
+      using RMTup = std::tuple<std::string, MonoTypePtr, unsigned int>;
       static genHash<RMTup> h;
       return h(RMTup(x.field, x.type, x.offset));
     }
@@ -1276,7 +1276,7 @@ template <>
 template <>
   struct genHash<Variant::Member> {
     inline size_t operator()(const Variant::Member& x) const {
-      typedef std::tuple<std::string, MonoTypePtr, unsigned int> VMTup;
+      using VMTup = std::tuple<std::string, MonoTypePtr, unsigned int>;
       static genHash<VMTup> h;
       return h(VMTup(x.selector, x.type, x.id));
     }
diff --git a/include/hobbes/lang/typeinf.H b/include/hobbes/lang/typeinf.H
index e141bb45f..5755e7cb0 100644
--- a/include/hobbes/lang/typeinf.H
+++ b/include/hobbes/lang/typeinf.H
@@ -65,14 +65,14 @@ private:
   size_t bcount;
 
   // avoid binding to certain type variables
-  typedef std::map<std::string, size_t> SuppressVarCounts;
+  using SuppressVarCounts = std::map<std::string, size_t>;
   SuppressVarCounts suppressVarCounts;
 
   bool suppressed(const std::string&) const;
   bool suppressed(const MonoTypePtr&) const;
 
   // equivalences between types
-  typedef equivalence_mapping<MonoTypePtr, UTypeRec, LiftUType, MoreDefinedType> M;
+  using M = equivalence_mapping<MonoTypePtr, UTypeRec, LiftUType, MoreDefinedType>;
   M m;
 };
 
@@ -121,10 +121,10 @@ void mgu(const MonoTypes& ts0, const MonoTypes& ts1, MonoTypeUnifier* u);
 void mgu(const ConstraintPtr&, const ConstraintPtr&, MonoTypeUnifier*);
 
 // some utilities for dealing with qualified types
-typedef std::pair<Constraints, MonoTypes> QualLiftedMonoTypes;
+using QualLiftedMonoTypes = std::pair<Constraints, MonoTypes>;
 QualLiftedMonoTypes liftQualifiers(const QualTypes& qts);
 
-typedef std::pair<Constraints, MonoTypePtr> QualLiftedMonoType;
+using QualLiftedMonoType = std::pair<Constraints, MonoTypePtr>;
 
 }
 
diff --git a/include/hobbes/lang/typemap.H b/include/hobbes/lang/typemap.H
index 4e0d0a434..493bea321 100644
--- a/include/hobbes/lang/typemap.H
+++ b/include/hobbes/lang/typemap.H
@@ -16,13 +16,13 @@ struct MonoTypeLT {
 struct MTyMap {
   template <typename V>
     struct map {
-      typedef std::map<MonoTypePtr, V, MonoTypeLT> type;
+      using type = std::map<MonoTypePtr, V, MonoTypeLT>;
     };
 };
 
 // used to do exact matches on types with a wildcard
-typedef variant<unit, MonoTypePtr> MaybePathPoint;
-typedef std::vector<MaybePathPoint> MaybePathPoints;
+using MaybePathPoint = variant<unit, MonoTypePtr>;
+using MaybePathPoints = std::vector<MaybePathPoint>;
 
 // a map from type sequences to some value
 template <typename V>
@@ -63,11 +63,11 @@ template <typename V>
       findMatches(this->d.rootPoint(), path, 0, out);
     }
   private:
-    typedef prefix_tree<MonoTypePtr, V, MTyMap> tmdata;
+    using tmdata = prefix_tree<MonoTypePtr, V, MTyMap>;
     tmdata d;
 
     bool hasMatch(MonoTypeUnifier& u, typename tmdata::point_t p, const MonoTypes& mts, size_t i) const {
-      if (p == 0) {
+      if (p == nullptr) {
         return false;
       }
 
@@ -96,7 +96,7 @@ template <typename V>
     }
 
     void findMatches(MonoTypeUnifier& u, typename tmdata::point_t p, const MonoTypes& mts, size_t i, std::vector<V>* out) const {
-      if (p == 0) return;
+      if (p == nullptr) return;
 
       if (i == mts.size()) {
         if (const V* v = this->d.valueAt(p)) {
@@ -124,7 +124,7 @@ template <typename V>
     }
 
     void findBidiMatches(MonoTypeUnifier& u, typename tmdata::point_t p, const MonoTypes& mts, size_t i, std::vector<V>* out) const {
-      if (p == 0) return;
+      if (p == nullptr) return;
 
       if (i == mts.size()) {
         if (const V* v = this->d.valueAt(p)) {
@@ -148,7 +148,7 @@ template <typename V>
     }
 
     void findMatches(typename tmdata::point_t p, const MaybePathPoints& path, size_t i, std::vector<V>* out) const {
-      if (p == 0) return;
+      if (p == nullptr) return;
 
       if (i == path.size()) {
         if (const V* v = this->d.valueAt(p)) {
@@ -156,13 +156,13 @@ template <typename V>
         }
       } else {
         // do we need an exact match or any point here?
-        if (const MonoTypePtr* mt = get<MonoTypePtr>(path[i])) {
+        if (const auto* mt = get<MonoTypePtr>(path[i])) {
           findMatches(this->d.moveTo(*mt, p), path, i + 1, out);
         } else {
           typename tmdata::KeyPointSeq kps;
           this->d.keyPointsAt(&kps, p);
 
-          for (auto kp : kps) {
+          for (const auto& kp : kps) {
             findMatches(kp.second, path, i + 1, out);
           }
         }
diff --git a/include/hobbes/lang/tyunqualify.H b/include/hobbes/lang/tyunqualify.H
index 8dec8294b..ec18d9d9f 100644
--- a/include/hobbes/lang/tyunqualify.H
+++ b/include/hobbes/lang/tyunqualify.H
@@ -9,17 +9,17 @@
 
 namespace hobbes {
 
-typedef std::set<std::string> SymSet;
+using SymSet = std::set<std::string>;
 
 // how do some parameters of a constraint determine others?
-typedef std::vector<int>       VarIDs;
-typedef std::pair<VarIDs, int> FunDep;
-typedef std::vector<FunDep>    FunDeps;
+using VarIDs = std::vector<int>;
+using FunDep = std::pair<VarIDs, int>;
+using FunDeps = std::vector<FunDep>;
 
 // if E :: T and R.satisfied(T), then R.unqualify(E)
 class Unqualifier {
   public:
-    virtual ~Unqualifier(void) {};
+    virtual ~Unqualifier() = default;;
     // bind any implied type variables in a constraint
     virtual bool refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions* ds) = 0;
 
@@ -44,29 +44,29 @@ class Unqualifier {
     // list functional dependencies between constraint parameters (if any)
     virtual FunDeps dependencies(const ConstraintPtr&) const = 0;
 };
-typedef std::shared_ptr<Unqualifier> UnqualifierPtr;
+using UnqualifierPtr = std::shared_ptr<Unqualifier>;
 
 // type predicates are resolved by an assumed disjoint set of unqualifiers
 class UnqualifierSet : public Unqualifier {
   public:
-    typedef std::map<std::string, UnqualifierPtr> Unqualifiers;
+    using Unqualifiers = std::map<std::string, UnqualifierPtr>;
 
     void                add(const std::string& name, const UnqualifierPtr& uq);
     UnqualifierPtr      findUnqualifier(const std::string& name);
     const Unqualifiers& unqualifiers() const;
 
-    bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*);
-    bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const;
-    bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const;
-    void        explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*);
-    ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-    PolyTypePtr lookup(const std::string& vn)                                                const;
-    SymSet      bindings()                                                                   const;
-    FunDeps     dependencies(const ConstraintPtr&)                                           const;
+    bool        refine(const TEnvPtr&,const ConstraintPtr&,MonoTypeUnifier*,Definitions*) override;
+    bool        satisfied(const TEnvPtr&,const ConstraintPtr&,Definitions*)                  const override;
+    bool        satisfiable(const TEnvPtr&,const ConstraintPtr&,Definitions*)                const override;
+    void        explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override;
+    ExprPtr     unqualify(const TEnvPtr&,const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+    PolyTypePtr lookup(const std::string& vn)                                                const override;
+    SymSet      bindings()                                                                   const override;
+    FunDeps     dependencies(const ConstraintPtr&)                                           const override;
   private:
     Unqualifiers uqs;
 };
-typedef std::shared_ptr<UnqualifierSet> UnqualifierSetPtr;
+using UnqualifierSetPtr = std::shared_ptr<UnqualifierSet>;
 
 // utilities to remove discharged type predicates
 bool hasConstraint(const ConstraintPtr& c, const Constraints& cs);
diff --git a/include/hobbes/mc/encode.H b/include/hobbes/mc/encode.H
index c3ae43c21..1d00fe5e0 100644
--- a/include/hobbes/mc/encode.H
+++ b/include/hobbes/mc/encode.H
@@ -53,10 +53,10 @@
 #include <stdexcept>
 #include <sstream>
 
+#include <cmath>
+#include <cstring>
 #include <sys/mman.h>
 #include <unistd.h>
-#include <cstring>
-#include <math.h>
 
 namespace hobbes { namespace mc {
 
@@ -124,7 +124,7 @@ public:
   }
 
   uint8_t* base() { return this->mem; }
-  size_t   size() { return this->sz; }
+  size_t   size() const { return this->sz; }
 
   // allocate some number of additional bytes at the tail of the buffer
   // return the address where those bytes can be written (this is how machine code is accumulated)
@@ -135,7 +135,7 @@ public:
       growBuffer(std::max<size_t>(newsz, this->allocsz * 2));
     }
 
-    auto r = this->mem + this->sz;
+    auto *r = this->mem + this->sz;
     this->sz += segsz;
     return r;
   }
@@ -159,8 +159,8 @@ public:
   // this is useful for deciding an efficient form of call instruction just if we are within 32-bits of the target
   // but need to degrade to a less efficient (larger code size) call if not
 # define HMC_MAX_PATCH_LEN 16
-  typedef std::array<uint8_t, HMC_MAX_PATCH_LEN>                     PatchBuffer;
-  typedef std::function<void(const uint8_t*,PatchBuffer*,uint32_t*)> PatchFn;
+  using PatchBuffer = std::array<uint8_t, 16>;
+  using PatchFn = std::function<void (const uint8_t *, PatchBuffer *, uint32_t *)>;
 
   void patchWithRIP(const PatchFn& pfn) {
     // make the initial patch and remember how many bytes it used initially
@@ -169,7 +169,7 @@ public:
     // this is additionally complicated by the fact that this initial allocation
     // can cause a buffer move itself
     while (true) {
-      auto        rip = this->mem + this->sz;
+      auto *      rip = this->mem + this->sz;
       PatchBuffer b;
       uint32_t    n = 0;
 
@@ -190,7 +190,7 @@ public:
   }
 
   // finalize the buffer so that we can execute its code
-  typedef void (*ThunkF)();
+  using ThunkF = void (*)();
 
   ThunkF finalize() {
     resolveLabelReferences();
@@ -210,8 +210,8 @@ private:
   uint8_t* mem;
 
   // label defs/refs
-  typedef std::map<std::string, size_t>              LabelDefs;
-  typedef std::map<std::string, std::vector<size_t>> LabelRefs;
+  using LabelDefs = std::map<std::string, size_t>;
+  using LabelRefs = std::map<std::string, std::vector<size_t>>;
 
   LabelDefs labelDefs;
   LabelRefs labelRefs;
@@ -237,8 +237,8 @@ private:
   }
 
   // keep track of RIP-dependent patches and re-derive them when we grow our buffer (which should be an infrequent event)
-  typedef std::pair<PatchFn, uint32_t> Patch;
-  typedef std::map<const uint8_t*, Patch> Patches;
+  using Patch = std::pair<PatchFn, uint32_t>;
+  using Patches = std::map<const uint8_t *, Patch>;
 
   Patches ripPatches;
 
@@ -305,7 +305,7 @@ private:
   // apply cumulative adjustments at fixed offsets to source offsets
   // this allows us to make insertions in exec buffers and "fix up" references to offsets in the original buffer
   // (e.g. if we had an offset to 5 before, but inserted 2 bytes at 3, then our offset should be adjusted to 7)
-  typedef std::map<size_t, int> CumAdjustments;
+  using CumAdjustments = std::map<size_t, int>;
 
   static size_t applyCumAdjustments(const CumAdjustments& cadj, size_t offset) {
     auto leb = cadj.lower_bound(offset);
@@ -337,7 +337,7 @@ private:
     return align(x, this->pagesz);
   }
   static uint8_t* allocateBuffer(size_t sz) {
-    uint8_t* r = reinterpret_cast<uint8_t*>(mmap(0, sz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0));
+    auto* r = reinterpret_cast<uint8_t*>(mmap(nullptr, sz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0));
     if (r == MAP_FAILED) {
       throw std::runtime_error("Failed to allocate exec buffer memory with error: " + std::string(strerror(errno)));
     }
@@ -358,7 +358,7 @@ private:
  *
  *       Where 'sz' means value size in bytes and 'ty' means register class (int or float).
  */
-typedef uint8_t RegSize; // 1,2,4,8
+using RegSize = uint8_t; // 1,2,4,8
 enum RegClass { Int, Float };
 
 template <typename RegisterID>
@@ -435,7 +435,7 @@ template <typename RegisterID>
 class Arg {
 public:
   // invalid argument
-  Arg() : vtag(TReg) { this->variant.vreg = 0; }
+  Arg() : vtag(TReg) { this->variant.vreg = nullptr; }
   
   Arg(const Arg& rhs) {
     copyFrom(rhs);
@@ -465,7 +465,7 @@ public:
   static Arg<RegisterID> ireg(RegisterID name, RegSize rsize) { return reg(name, rsize, Int); }
   static Arg<RegisterID> freg(RegisterID name, RegSize rsize) { return reg(name, rsize, Float); }
 
-  const Reg<RegisterID>* reg() const { return this->vtag == TReg ? this->variant.vreg : 0; }
+  const Reg<RegisterID>* reg() const { return this->vtag == TReg ? this->variant.vreg : nullptr; }
 
   // or it can be an indirect memory reference through a register calculation
   // these register calculations can look like [B+I*S+D] where B and I are registers, S is a scale factor in {0,1,2,4,8}, and D is up to a 32-bit const displacement
@@ -497,7 +497,7 @@ public:
   static Arg<RegisterID> regDeref(RegisterID index, uint8_t scale, int32_t offset, RegSize rsize, RegClass rclass) { return regDeref(RegisterID(), false, index, scale, offset, rsize, rclass); }
   static Arg<RegisterID> regDeref(const Reg<RegisterID>& index, uint8_t scale, int32_t offset, RegSize rsize, RegClass rclass) { return regDeref(RegisterID(), false, index.name, scale, offset, rsize, rclass); }
 
-  const RegDeref<RegisterID>* regDeref() const { return this->vtag == TRegDeref ? this->variant.vregderef : 0; }
+  const RegDeref<RegisterID>* regDeref() const { return this->vtag == TRegDeref ? this->variant.vregderef : nullptr; }
 
   // refer to the label 'label'
   static Arg<RegisterID> labelRef(const LabelRef& lbl) {
@@ -509,7 +509,7 @@ public:
     lref.rsize = rsize;
     return labelRef(lref);
   }
-  const LabelRef* labelRef() const { return this->vtag == TLabelRef ? this->variant.vlabelref : 0; }
+  const LabelRef* labelRef() const { return this->vtag == TLabelRef ? this->variant.vlabelref : nullptr; }
 
   // an immediate value
   static Arg<RegisterID> immediate(const Immediate& i) {
@@ -531,7 +531,7 @@ public:
   static Arg<RegisterID> i64 (int64_t  x) { return immediate(static_cast<int64_t>(x), true,  sizeof(x)); }
   static Arg<RegisterID> ui64(uint64_t x) { return immediate(static_cast<int64_t>(x), false, sizeof(x)); }
 
-  const Immediate* immediate() const { return this->vtag == TImmediate ? this->variant.vimmediate : 0; }
+  const Immediate* immediate() const { return this->vtag == TImmediate ? this->variant.vimmediate : nullptr; }
 
   // the variant view of this data
   enum Tag : uint8_t {
@@ -607,7 +607,7 @@ private:
     this->vtag = rhs.vtag;
     if (!rhs.variant.vreg) {
       // 0-initialize just for a 0-initialized copy
-      this->variant.vreg = 0;
+      this->variant.vreg = nullptr;
       return;
     }
 
@@ -635,7 +635,7 @@ enum X86Reg : uint8_t {
 };
 
 // an instruction argument using x86 machine register IDs is a 'machine arg'
-typedef Arg<X86Reg> MArg;
+using MArg = Arg<X86Reg>;
 
 // by tradition, there are some special names for some of the registers
 // we should be consistent with those naming standards when interfacing with humans
@@ -694,7 +694,7 @@ inline const Reg<X86Reg>* maybeMReg(const std::string& name) {
     }
   }
   auto r = mregs.find(name);
-  return (r != mregs.end()) ? &r->second : 0;
+  return (r != mregs.end()) ? &r->second : nullptr;
 }
 inline const Reg<X86Reg>& mreg(const std::string& name) {
   if (const auto* p = maybeMReg(name)) {
@@ -816,14 +816,14 @@ struct Instruction {
     return r;
   }
   const LabelRef* labelDef() const {
-    return this->op=="deflbl" && this->argc==1 ? this->args[0].labelRef() : 0;
+    return this->op=="deflbl" && this->argc==1 ? this->args[0].labelRef() : nullptr;
   }
   const LabelRef* jumpTarget() const {
     // jump instructions start with "j" by convention, should be good enough
     if (this->op.size() > 0 && this->op[0] == 'j' && this->argc == 1) {
       return this->args[0].labelRef();
     } else {
-      return 0;
+      return nullptr;
     }
   }
   bool controlFollows() const {
@@ -850,8 +850,8 @@ template <typename RegisterID>
 using Instructions = std::vector<Instruction<RegisterID>>;
 
 // an instruction using x86 machine registers is a 'machine instruction'
-typedef Instruction<X86Reg> MInst;
-typedef std::vector<MInst>  MInsts;
+using MInst = Instruction<X86Reg>;
+using MInsts = std::vector<MInst>;
 
 // print instructions and instruction sequences for human display
 template <typename RegisterID>
@@ -947,10 +947,10 @@ public:
     }
   }
   const Reg<X86Reg>* reg() const {
-    return this->isRegister ? this->variant.vreg : 0;
+    return this->isRegister ? this->variant.vreg : nullptr;
   }
   const RegDeref<X86Reg>* regDeref() const {
-    return !this->isRegister ? this->variant.vregderef : 0;
+    return !this->isRegister ? this->variant.vregderef : nullptr;
   }
 private:
   bool isRegister;
@@ -964,7 +964,7 @@ private:
 class Output;
 class MatchFunction {
 public:
-  MatchFunction() : pf(0) { }
+  MatchFunction() : pf(nullptr) { }
   template <typename ... Args>
   MatchFunction(void(*pf)(Output&,const Args&...)) {
     this->pf = reinterpret_cast<void*>(pf);
@@ -998,39 +998,39 @@ public:
   // we use these patterns for instructions that have specializations to work with a specific register (usually r0 aka "rax")
   static P reg(const std::string& name) {
     const auto& nreg = mreg(name);
-    return P(MLitReg, nreg.name, nreg.rsize, nreg.rclass);
+    return {MLitReg, nreg.name, nreg.rsize, nreg.rclass};
   }
 
   // partial register mapping
   // (match size and class, but leave 'name' free)
-  static P r8 () { return P(MReg, 1, RegClass::Int); }
-  static P r16() { return P(MReg, 2, RegClass::Int); }
-  static P r32() { return P(MReg, 4, RegClass::Int); }
-  static P r64() { return P(MReg, 8, RegClass::Int); }
+  static P r8 () { return {MReg, 1, RegClass::Int}; }
+  static P r16() { return {MReg, 2, RegClass::Int}; }
+  static P r32() { return {MReg, 4, RegClass::Int}; }
+  static P r64() { return {MReg, 8, RegClass::Int}; }
 
-  static P rf32() { return P(MReg, 4, RegClass::Float); }
-  static P rf64() { return P(MReg, 8, RegClass::Float); }
+  static P rf32() { return {MReg, 4, RegClass::Float}; }
+  static P rf64() { return {MReg, 8, RegClass::Float}; }
 
   // RM matching (accepting either register or memory arguments)
-  static P rm8()  { return P(MRM, 1, RegClass::Int); }
-  static P rm16() { return P(MRM, 2, RegClass::Int); }
-  static P rm32() { return P(MRM, 4, RegClass::Int); }
-  static P rm64() { return P(MRM, 8, RegClass::Int); }
+  static P rm8()  { return {MRM, 1, RegClass::Int}; }
+  static P rm16() { return {MRM, 2, RegClass::Int}; }
+  static P rm32() { return {MRM, 4, RegClass::Int}; }
+  static P rm64() { return {MRM, 8, RegClass::Int}; }
 
-  static P rmf32() { return P(MRM, 4, RegClass::Float); }
-  static P rmf64() { return P(MRM, 8, RegClass::Float); }
+  static P rmf32() { return {MRM, 4, RegClass::Float}; }
+  static P rmf64() { return {MRM, 8, RegClass::Float}; }
 
   // label references
-  static P lbl(RegSize sz = 4) { return P(MLabelRef, sz, RegClass::Int); }
+  static P lbl(RegSize sz = 4) { return {MLabelRef, sz, RegClass::Int}; }
 
   // exact immediate values (some instructions like SHL are specialized for exact value arguments)
-  static P imm8(int8_t x) { return P(MLitImm, x, 1, RegClass::Int); }
+  static P imm8(int8_t x) { return {MLitImm, x, 1, RegClass::Int}; }
 
   // immediate values matching by size
-  static P imm8 () { return P(MImm, 1, RegClass::Int); }
-  static P imm16() { return P(MImm, 2, RegClass::Int); }
-  static P imm32() { return P(MImm, 4, RegClass::Int); }
-  static P imm64() { return P(MImm, 8, RegClass::Int); }
+  static P imm8 () { return {MImm, 1, RegClass::Int}; }
+  static P imm16() { return {MImm, 2, RegClass::Int}; }
+  static P imm32() { return {MImm, 4, RegClass::Int}; }
+  static P imm64() { return {MImm, 8, RegClass::Int}; }
 
   // does an argument match this pattern?
   bool matches(const MArg& arg) const {
@@ -1271,8 +1271,8 @@ private:
 // we should also be able to infer which arguments are in/out/inout here
 class Match {
 public:
-  typedef std::vector<Rule> RuleSeq;
-  typedef std::vector<int>  VarRefs;
+  using RuleSeq = std::vector<Rule>;
+  using VarRefs = std::vector<int>;
 
   Match() { /* invalid */ }
   Match(const RuleSeq& rules) {
@@ -1613,7 +1613,7 @@ public:
         int64_t diff = reinterpret_cast<uint64_t>(faddr) - reinterpret_cast<uint64_t>(rip + 5);
 
         if (canLowerTo<int32_t>(diff)) {
-          int32_t diff32 = static_cast<int32_t>(diff);
+          auto diff32 = static_cast<int32_t>(diff);
 
           // call rel32 = e8 id (5 bytes)
           (*b)[0] = 0xe8;
@@ -1651,14 +1651,14 @@ private:
 
 #ifndef HMC_ENCODE_NO_INLINE_CODETABLES
 
-typedef std::map<std::string, Match> EncodingTable;
+using EncodingTable = std::map<std::string, Match>;
 
 inline void bootEncodingTable(EncodingTable& t) {
-  typedef Output&            O;
-  typedef const Reg<X86Reg>& R;
-  typedef const RM&          RM;
-  typedef const Immediate&   I;
-  typedef const LabelRef&    LR;
+  using O = Output &;
+  using R = const Reg<X86Reg> &;
+  using RM = const RM &;
+  using I = const Immediate &;
+  using LR = const LabelRef &;
 
   t["add"] = Match({
     Rule(io(P::reg("al")),  P::imm8(),  [](O o, I ib){o(        ui8(0x04), ui8(ib));}),
diff --git a/include/hobbes/mc/liveness.H b/include/hobbes/mc/liveness.H
index e348466f2..c7ea5000c 100644
--- a/include/hobbes/mc/liveness.H
+++ b/include/hobbes/mc/liveness.H
@@ -32,21 +32,21 @@
 #ifndef HMC_LIVENESS_H_INCLUDED
 #define HMC_LIVENESS_H_INCLUDED
 
-#include <set>
-#include <vector>
+#include <cassert>
 #include <map>
-#include <unordered_map>
+#include <set>
 #include <stdexcept>
-#include <assert.h>
+#include <unordered_map>
+#include <vector>
 
 namespace hobbes { namespace mc {
 
 // a dynamic bitset, used to represent a set of variables (assuming a mapping of variable name to 0-N index)
 class VarSet {
 public:
-  VarSet() : varc(0), bcount(0), bits(0) {
+  VarSet() : varc(0), bcount(0), bits(nullptr) {
   }
-  VarSet(uint64_t vc) : varc(0), bcount(0), bits(0) {
+  VarSet(uint64_t vc) : varc(0), bcount(0), bits(nullptr) {
     resize(vc);
   }
   VarSet(const VarSet& s) { copyBuffer(s); }
@@ -60,15 +60,15 @@ public:
   }
 
   void clear() {
-    if (this->bits) {
+    if (this->bits != nullptr) {
       memset(this->bits, 0, this->bcount * sizeof(uint64_t));
     }
   }
 
   void resize(uint64_t sz) {
-    uint64_t  asz   = align<uint64_t>(sz, 64);
+    auto  asz   = align<uint64_t>(sz, 64);
     uint64_t  bc    = asz / 64;
-    uint64_t* nbits = new uint64_t[bc];
+    auto* nbits = new uint64_t[bc];
 
     if (bc <= this->bcount) {
       memcpy(nbits, this->bits, bc * sizeof(uint64_t));
@@ -150,7 +150,7 @@ public:
       uint64_t k = b;
 
       // gather members in 4-bit steps
-      while (v) {
+      while (v != 0u) {
         switch (v & 0x0f) {
         default: 
         case 0:                                                            break; // 0000
@@ -242,16 +242,15 @@ inline std::set<L> truncTo(const std::set<U>& us) {
 //                 key  :: Var -> K      (such that K is unique for Var and has < defined)
 //                 desc :: K -> string   (describe a variable key for an error message)
 //
-typedef uint32_t VarID;
+using VarID = uint32_t;
 
 template <typename VarM>
 class VarUniverse {
 public:
-  typedef typename VarM::Var Var;
-  typedef decltype(VarM::key(*reinterpret_cast<Var*>(42))) K;
+  using Var = typename VarM::Var;
+  using K = decltype(VarM::key(*reinterpret_cast<Var *>(42)));
 
-  VarUniverse() {
-  }
+  VarUniverse() = default;
 
   void define(const Var& v) {
     auto k = VarM::key(v);
@@ -310,8 +309,8 @@ private:
 template <typename InstM, typename VarM = InstM>
 class BlockLiveness {
 public:
-  typedef typename InstM::Instruction Inst;
-  typedef typename InstM::Var         Var;
+  using Inst = typename InstM::Instruction;
+  using Var = typename InstM::Var;
 
   BlockLiveness(const std::set<Var>& initVars, const std::vector<Inst>& insts, const InstM& instM) : insts(insts), instM(instM) {
     // initialize the variable universe out of the instruction sequence
@@ -356,7 +355,7 @@ public:
               pc < insts.size()             && // pc is valid
               instM.follows(insts, pc)      && // control follows straight from pc to pc+1
               !instM.jumpsTo(insts, pc, &n) && // pc doesn't jump anywhere else
-              !jumpTargets.count(pc+1)         // and the next instruction is only reachable from this one
+              (jumpTargets.count(pc+1) == 0u)         // and the next instruction is only reachable from this one
             )
       {
         // the next instruction is in the block
@@ -550,8 +549,8 @@ public:
 template <typename InstM, typename VarM = InstM>
 class BasicLiveness {
 public:
-  typedef typename InstM::Instruction Inst;
-  typedef typename InstM::Var         Var;
+  using Inst = typename InstM::Instruction;
+  using Var = typename InstM::Var;
 
   BasicLiveness(const std::set<Var>& initVars, const std::vector<Inst>& insts, const InstM& instM) : insts(insts), instM(instM) {
     // initialize the variable universe out of the instruction sequence
diff --git a/include/hobbes/mc/regalloc.H b/include/hobbes/mc/regalloc.H
index e168e91e5..f7b5fe7bf 100644
--- a/include/hobbes/mc/regalloc.H
+++ b/include/hobbes/mc/regalloc.H
@@ -42,11 +42,11 @@
 
 #include "encode.H"
 #include "liveness.H"
+#include <cassert>
+#include <map>
 #include <set>
 #include <stack>
-#include <map>
 #include <stdexcept>
-#include <assert.h>
 
 namespace hobbes { namespace mc {
 
@@ -56,11 +56,11 @@ namespace hobbes { namespace mc {
 static const uint32_t MaxRegisters = 16;
 
 // instructions subject to register allocation have free register names (as strings)
-typedef Instructions<std::string> RInsts;
-typedef Instruction <std::string> RInst;
-typedef Arg         <std::string> RArg;
-typedef Reg         <std::string> RReg;
-typedef RegDeref    <std::string> RRegDeref;
+using RInsts = Instructions<std::string>;
+using RInst = Instruction<std::string>;
+using RArg = Arg<std::string>;
+using RReg = Reg<std::string>;
+using RRegDeref = RegDeref<std::string>;
 
 inline std::string stdRegName(X86Reg r, RegClass rc) {
   return regName(r, 8, rc);
@@ -102,7 +102,7 @@ inline const std::set<Reg<X86Reg>>& callerSaveRegs() {
       i.name   = static_cast<X86Reg>(r);
       i.rsize  = 8;
       i.rclass = RegClass::Int;
-      if (r != 4 && !saved.count(i)) {
+      if (r != 4 && (saved.count(i) == 0u)) {
         regs.insert(i);
       }
 
@@ -110,7 +110,7 @@ inline const std::set<Reg<X86Reg>>& callerSaveRegs() {
       f.name   = static_cast<X86Reg>(r);
       f.rsize  = 8;
       f.rclass = RegClass::Float;
-      if (!saved.count(f)) {
+      if (saved.count(f) == 0u) {
         regs.insert(f);
       }
     }
@@ -160,7 +160,7 @@ inline std::string rmap(const std::map<X86Reg, std::string>& m, X86Reg r, RegCla
     return k->second;
   }
 }
-inline void rmapInto(const std::map<X86Reg, std::string>& m, std::set<std::string>* s, MArg ma) {
+inline void rmapInto(const std::map<X86Reg, std::string>& m, std::set<std::string>* s, const MArg& ma) {
   if (const auto* reg = ma.reg()) {
     s->insert(rmap(m, reg->name, reg->rclass));
   } else if (const auto* rd = ma.regDeref()) {
@@ -205,7 +205,7 @@ inline std::set<std::string> regUses(const RInst& ri) {
     rmapInto(lm, &r, ma);
   }
   for (const auto& ma : defs(mi)) {
-    if (!ma.reg()) {
+    if (ma.reg() == nullptr) {
       rmapInto(lm, &r, ma);
     }
   }
@@ -215,8 +215,8 @@ inline std::set<std::string> regUses(const RInst& ri) {
 // a liveness module for instruction sequences with infinite named registers
 class RInstM {
 public:
-  typedef RInst       Instruction;
-  typedef std::string Var;
+  using Instruction = RInst;
+  using Var = std::string;
 
   RInstM(const RInsts& insts) {
     for (size_t pc = 0; pc < insts.size(); ++pc) {
@@ -427,7 +427,7 @@ public:
     }
   }
 private:
-  typedef std::map<VarID, std::set<VarID>> VarIDSets;
+  using VarIDSets = std::map<VarID, std::set<VarID>>;
 
   size_t    varc;
   VarSet    vtest;
@@ -466,7 +466,7 @@ public:
         // in the case of a reg move, remember that we can coalesce the two vars involved
         // add interference edges for all _other_ vars live out here
         VarID sv = live.id(src->name);
-        for (auto rd : regDefs(inst)) {
+        for (const auto& rd : regDefs(inst)) {
           VarID d = live.id(rd);
 
           addMoveEdge(d, sv);
@@ -479,7 +479,7 @@ public:
       } else {
         // generic instruction,
         // add interference edges for all vars live out here
-        for (auto rd : regDefs(inst)) {
+        for (const auto& rd : regDefs(inst)) {
           VarID d = live.id(rd);
 
           for (auto o : i.liveOut()) {
@@ -556,7 +556,7 @@ private:
         }
       }
     }
-    return 0;
+    return nullptr;
   }
 
   void addInterfereEdge(VarID v0, VarID v1) {
@@ -588,7 +588,7 @@ public:
     return this->assignSeq;
   }
 
-  typedef std::map<VarID, VarID> VarAliasing;
+  using VarAliasing = std::map<VarID, VarID>;
 
   const VarAliasing& aliasedVars() const {
     return this->coalescedVars;
@@ -607,12 +607,12 @@ private:
   uint32_t degree     (VarID v) const { return this->ig->interferences(v).size(); }
 
   // divisions of the interference graph to evaluate
-  typedef std::set<VarID> VarList;
+  using VarList = std::set<VarID>;
   VarList removeVar, freezeVar, spillVar;
   VarSet  assignedVars;
 
-  typedef std::pair<VarID, VarID> Move;
-  typedef std::set<Move> MoveList;
+  using Move = std::pair<VarID, VarID>;
+  using MoveList = std::set<Move>;
   MoveList moves;
   MoveList delayedMoves;
 
@@ -670,7 +670,7 @@ private:
         for (VarID mv : this->ig->moves(v)) {
           Move mvid = moveID(v, mv);
 
-          if (this->delayedMoves.erase(mvid)) {
+          if (this->delayedMoves.erase(mvid) != 0u) {
             this->moves.insert(mvid);
           }
         }
@@ -918,7 +918,7 @@ private:
 // apply : replace var names in instructions, either mapping into the space of fewer var names or into the space
 //         of machine registers
 //
-typedef std::map<std::string, X86Reg> RMSubst;
+using RMSubst = std::map<std::string, X86Reg>;
 
 inline MInst subst(const RMSubst& s, const RInst& i) {
   return
@@ -940,13 +940,13 @@ inline MInst subst(const RMSubst& s, const RInst& i) {
     );
 }
 
-typedef std::map<std::string, std::string> RRSubst;
+using RRSubst = std::map<std::string, std::string>;
 
 inline RInst subst(const RRSubst& s, const RInst& i) {
   return
     i.mapRegs<std::string>(
       [&](const std::string& rname, RegSize, RegClass) -> std::string {
-        if (maybeMReg(rname)) {
+        if (maybeMReg(rname) != nullptr) {
           return rname;
         } else {
           auto k = s.find(rname);
@@ -1045,9 +1045,9 @@ inline RInsts saveCalleeSaveRegs(const RInsts& insts) {
 
   if (csaveInsts.empty()) {
     const auto& csaveRegs = calleeSaveRegs();
-    for (auto r = csaveRegs.begin(); r != csaveRegs.end(); ++r) {
-      std::string n = ".save." + regName(*r);
-      csaveInsts.push_back(RInst::make("mov", RArg::reg(n, r->rsize, r->rclass), RArg::reg(stdRegName(r->name, r->rclass), r->rsize, r->rclass)));
+    for (const auto &csaveReg : csaveRegs) {
+      std::string n = ".save." + regName(csaveReg);
+      csaveInsts.push_back(RInst::make("mov", RArg::reg(n, csaveReg.rsize, csaveReg.rclass), RArg::reg(stdRegName(csaveReg.name, csaveReg.rclass), csaveReg.rsize, csaveReg.rclass)));
     }
     for (auto r = csaveRegs.rbegin(); r != csaveRegs.rend(); ++r) {
       std::string n = ".save." + regName(*r);
@@ -1097,7 +1097,7 @@ size_t firstFit(const ProgramLiveness& live, const Interference& ig, const std::
 
 // spillFrame : calculate the spill frame for a set of variables to spill, packed into as few frame slots as possible
 //              computed offsets will be relative to a given frame size (and the frame size will be updated on exit)
-typedef std::map<VarID, uint32_t> SpillFrame;
+using SpillFrame = std::map<VarID, uint32_t>;
 
 inline SpillFrame spillFrame(const ProgramLiveness& live, const Interference& ig, uint32_t* sframe, const std::set<VarID>& spillVars) {
   // find a slot for each spilled var (creating as few as necessary)
@@ -1166,7 +1166,7 @@ inline RRSubst spillSubst(size_t pc, const std::set<VarID>& spillVars, const Pro
   RRSubst r;
   for (const std::string& v : vs) {
     VarID vid = live.id(v);
-    if (spillVars.count(vid)) {
+    if (spillVars.count(vid) != 0u) {
       std::ostringstream vns;
       vns << ".spill." << vid << "." << pc;
       r[v] = vns.str();
diff --git a/include/hobbes/net.H b/include/hobbes/net.H
index bd7f38ad2..6b7a72a9e 100644
--- a/include/hobbes/net.H
+++ b/include/hobbes/net.H
@@ -21,15 +21,15 @@
 #include <map>
 #include <stdexcept>
 
+#include <cstring>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <netdb.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
 
 // types with static reflection info (for reflective structs, variants, etc)
 #include "reflect.H"
@@ -41,7 +41,7 @@ namespace hobbes { namespace net {
 #define HNET_CMD_INVOKE  static_cast<uint8_t>(2)
 #define HNET_RESULT_FAIL 0
 
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 // basic socket I/O
 inline void sendData(int socket, const uint8_t* d, size_t sz) {
@@ -127,15 +127,15 @@ struct RPCDef {
   bytes       willPut; // what type will be sent?
   bytes       willGet; // what type will be received?
 };
-typedef std::vector<RPCDef> RPCDefs;
+using RPCDefs = std::vector<RPCDef>;
 
 // initiate a session on a connected socket by sending all of the RPC defs
 inline int initSession(int s, const RPCDefs& rpcds) {
-  uint32_t version = HNET_VERSION;
+  auto version = HNET_VERSION;
   sendData(s, reinterpret_cast<const uint8_t*>(&version), sizeof(version));
 
   for (const auto& rpcd : rpcds) {
-    uint8_t defCmd = HNET_CMD_DEFEXPR;
+    auto defCmd = HNET_CMD_DEFEXPR;
     sendData(s, &defCmd, sizeof(defCmd));
     sendData(s, reinterpret_cast<const uint8_t*>(&rpcd.id), sizeof(rpcd.id));
     sendString(s, rpcd.expr);
@@ -161,8 +161,8 @@ inline addrinfo* lookupAddrInfo(const std::string& host, const std::string& port
   h.ai_family   = AF_UNSPEC;
   h.ai_socktype = SOCK_STREAM;
 
-  struct addrinfo* addrs = 0;
-  switch (getaddrinfo(host.empty()? 0 : host.c_str(), port.empty() ? 0 : port.c_str(), &h, &addrs)) {
+  struct addrinfo* addrs = nullptr;
+  switch (getaddrinfo(host.empty()? nullptr : host.c_str(), port.empty() ? nullptr : port.c_str(), &h, &addrs)) {
   case 0:              return addrs;
   case EAI_ADDRFAMILY: throw std::runtime_error("Cannot make socket connection to " + host + ":" + port);
   case EAI_AGAIN:      throw std::runtime_error(host + ":" + port + " is temporarily unavailable");
@@ -172,26 +172,26 @@ inline addrinfo* lookupAddrInfo(const std::string& host, const std::string& port
   case EAI_SERVICE:    throw std::runtime_error("Failed to resolve service: " + port);
   default:             throw std::runtime_error("Unknown error while trying to resolve " + host + ":" + port);
   }
-  return 0;
+  return nullptr;
 }
 
 inline int makeConnection(const std::string& localAddr, const std::string& host, const std::string& port) {
-  struct addrinfo* localAddrs = localAddr.empty() ? 0 : lookupAddrInfo(localAddr, "");
+  struct addrinfo* localAddrs = localAddr.empty() ? nullptr : lookupAddrInfo(localAddr, "");
   struct addrinfo* addrs      = lookupAddrInfo(host, port);
 
-  for (auto p = addrs; p != 0; p = p->ai_next) {
+  for (auto *p = addrs; p != nullptr; p = p->ai_next) {
     int s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
     if (s == -1) continue;
 
-    auto la = localAddrs;
-    for (; la != 0; la = la->ai_next) {
+    auto *la = localAddrs;
+    for (; la != nullptr; la = la->ai_next) {
       if (la->ai_family == p->ai_family && la->ai_socktype == p->ai_socktype && la->ai_protocol == p->ai_protocol) {
         if (bind(s, la->ai_addr, la->ai_addrlen) != -1) {
           break;
         }
       }
     }
-    if (la == 0 && localAddrs != 0) continue;
+    if (la == nullptr && localAddrs != nullptr) continue;
 
     if (connect(s, p->ai_addr, p->ai_addrlen) == -1) {
       close(s);
@@ -222,7 +222,7 @@ inline int makeConnection(const std::string& host, size_t port) {
 }
 
 inline int makeConnection(const std::string& hostport) {
-  auto p = hostport.find(":");
+  auto p = hostport.find(':');
   if (p == std::string::npos) {
     throw std::runtime_error("Failed to determine port: " + hostport);
   } else {
@@ -276,7 +276,7 @@ template <>
     static void     write(int, const unit&) { }
     static void     read (int, unit*)       { }
 
-    typedef uint8_t async_read_state;
+    using async_read_state = uint8_t;
     static void prepare(uint8_t*) {}
     static bool accum(int, uint8_t*, unit*) { return true; }
   };
@@ -290,7 +290,7 @@ template <typename T>
     static void     write(int s, const T& x) { io<typename T::rep_t>::write(s, static_cast<typename T::rep_t>(x.value)); }
     static void     read(int s, T* x)        { io<typename T::rep_t>::read(s, reinterpret_cast<typename T::rep_t*>(&x->value)); }
 
-    typedef uint8_t async_read_state;
+    using async_read_state = uint8_t;
     static void prepare(uint8_t* o) { *o = 0; }
     static bool accum(int s, uint8_t* o, T* x) { *o += recvDataPartial(s, reinterpret_cast<uint8_t*>(x) + *o, sizeof(typename T::rep_t) - *o); return *o == sizeof(typename T::rep_t); }
   };
@@ -298,8 +298,8 @@ template <typename T>
 // support variants
 template <size_t i, size_t n, typename ... Ts>
   struct descVariantTy {
-    typedef typename nth<i, Ts...>::type H;
-    typedef descVariantTy<i+1, n, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using Recurse = descVariantTy<i + 1, n, Ts...>;
 
     static void ctorDefs(ty::Variant::Ctors* cs) {
       std::ostringstream fn;
@@ -333,14 +333,14 @@ template <size_t tag, typename T, typename M>
   };
 template <typename T>
   struct AsyncStateOf {
-    typedef typename io<T>::async_read_state type;
+    using type = typename io<T>::async_read_state;
   };
 template <size_t tag, typename T, typename M>
   struct variantAsyncInit {
     static void fn(T* p, void* rs) {
       new (p) T();
 
-      typedef typename io<T>::async_read_state RSType;
+      using RSType = typename io<T>::async_read_state;
       new (rs) RSType();
       io<T>::prepare(reinterpret_cast<RSType*>(rs));
     }
@@ -348,7 +348,7 @@ template <size_t tag, typename T, typename M>
 template <size_t tag, typename T, typename M>
   struct variantAsyncAccum {
     static bool fn(T* p, int s, void* rs) {
-      typedef typename io<T>::async_read_state RSType;
+      using RSType = typename io<T>::async_read_state;
       return io<T>::accum(s, reinterpret_cast<RSType*>(rs), p);
     }
   };
@@ -367,9 +367,9 @@ template <typename ... Ctors>
       variantApp<void, variantGenRead, void, tuple<Ctors...>, int>::apply(x->unsafeTag(), x->unsafePayload(), s);
     }
 
-    typedef typename io<uint32_t>::async_read_state            TagState;
-    typedef typename fmap<AsyncStateOf, tuple<Ctors...>>::type PayloadSAsTuple;
-    typedef typename toVariant<PayloadSAsTuple>::type          PayloadState;
+    using TagState = typename io<uint32_t>::async_read_state;
+    using PayloadSAsTuple = typename fmap<AsyncStateOf, tuple<Ctors...>>::type;
+    using PayloadState = typename toVariant<PayloadSAsTuple>::type;
 
     struct async_read_state {
       bool         readTag;
@@ -406,7 +406,7 @@ struct descVariantF {
 };
 template <typename T>
   struct io<T, typename tbool<T::is_hmeta_variant>::type> {
-    typedef typename T::as_variant_type VT;
+    using VT = typename T::as_variant_type;
     static const bool can_memcpy = io<VT>::can_memcpy;
 
     static ty::desc type() {
@@ -419,7 +419,7 @@ template <typename T>
     static void write(int s, const T& x) { io<VT>::write(s, *reinterpret_cast<const VT*>(&x)); }
     static void read (int s, T* x)       { io<VT>::read(s, reinterpret_cast<VT*>(x)); }
 
-    typedef typename io<VT>::async_read_state async_read_state;
+    using async_read_state = typename io<VT>::async_read_state;
     static void prepare(async_read_state* o)            { io<VT>::prepare(o); }
     static bool accum(int s, async_read_state* o, T* x) { return io<VT>::accum(s, o, reinterpret_cast<VT*>(x)); }
   };
@@ -442,8 +442,8 @@ template <typename U, typename V>
 
     // async reading of pairs
     struct async_read_state {
-      typedef typename io<U>::async_read_state Ustate;
-      typedef typename io<V>::async_read_state Vstate;
+      using Ustate = typename io<U>::async_read_state;
+      using Vstate = typename io<V>::async_read_state;
 
       bool   readFirst;
       Ustate fstState;
@@ -493,7 +493,7 @@ template <typename T, size_t N>
 
     static bool accum(int s, async_read_state* o, T (*x)[N]) {
       const auto len = sizeof(T) * N;
-      uint8_t* buf = reinterpret_cast<uint8_t*>(&((*x)[0]));
+      auto* buf = reinterpret_cast<uint8_t*>(&((*x)[0]));
       o->bytesRead += recvDataPartial(s, buf + o->bytesRead, len - o->bytesRead);
       return o->bytesRead == len;
     }
@@ -516,7 +516,7 @@ template <typename T, size_t N>
     }
 
     struct async_read_state {
-      typedef typename io<T>::async_read_state ElemS;
+      using ElemS = typename io<T>::async_read_state;
 
       size_t idx;
       ElemS  elemS;
@@ -552,7 +552,7 @@ template <typename T>
 
     // async reading of mem-copyable vectors
     struct async_read_state {
-      typedef io<size_t>::async_read_state LenS;
+      using LenS = io<size_t>::async_read_state;
 
       bool   readLen;
       LenS   lenS;
@@ -574,7 +574,7 @@ template <typename T>
           o->readLen   = false;
         }
       } else {
-        uint8_t* buf = reinterpret_cast<uint8_t*>(&(*x)[0]);
+        auto* buf = reinterpret_cast<uint8_t*>(&(*x)[0]);
         o->bytesRead += recvDataPartial(s, buf + o->bytesRead, o->byteLen - o->bytesRead);
       }
       return !o->readLen && o->bytesRead == o->byteLen;
@@ -603,8 +603,8 @@ template <typename T>
 
     // async reading of vectors
     struct async_read_state {
-      typedef io<size_t>::async_read_state LenS;
-      typedef typename io<T>::async_read_state ElemS;
+      using LenS = io<size_t>::async_read_state;
+      using ElemS = typename io<T>::async_read_state;
 
       bool   readLen;
       LenS   lenS;
@@ -660,9 +660,9 @@ template <typename K, typename T>
       }
     }
 
-    typedef io<size_t>::async_read_state LenS;
-    typedef typename io<K>::async_read_state      KS;
-    typedef typename io<T>::async_read_state      TS;
+    using LenS = io<size_t>::async_read_state;
+    using KS = typename io<K>::async_read_state;
+    using TS = typename io<T>::async_read_state;
     enum class ReadS : uint8_t { LenS, KS, TS };
 
     struct async_read_state {
@@ -721,7 +721,7 @@ template <>
 
     // async reading of strings
     struct async_read_state {
-      typedef io<size_t>::async_read_state LenS;
+      using LenS = io<size_t>::async_read_state;
 
       bool   readLen;
       LenS   lenS;
@@ -742,7 +742,7 @@ template <>
           o->readLen = false;
         }
       } else {
-        uint8_t* buf = reinterpret_cast<uint8_t*>(&(*x)[0]);
+        auto* buf = reinterpret_cast<uint8_t*>(&(*x)[0]);
         o->bytesRead += recvDataPartial(s, buf + o->bytesRead, o->byteLen - o->bytesRead);
       }
       return !o->readLen && o->bytesRead == o->byteLen;
@@ -752,10 +752,10 @@ template <>
 // support tuples
 template <size_t i, size_t n, typename ... Fs>
   struct tupInd {
-    typedef typename nth<i, Fs...>::type H;
-    typedef tuple<Fs...>                 TT;
-    typedef typename TT::offs            offs;
-    typedef tupInd<i+1, n, Fs...>        Recurse;
+    using H = typename nth<i, Fs...>::type;
+    using TT = tuple<Fs...>;
+    using offs = typename TT::offs;
+    using Recurse = tupInd<i + 1, n, Fs...>;
 
     static void accFields(ty::Struct::Fields* fs) {
       std::ostringstream ss;
@@ -779,7 +779,7 @@ template <size_t n, typename ... Fs>
 template <size_t tag, typename T, typename M>
   struct tupAsyncInit {
     static void fn(T*, void* rs) {
-      typedef typename io<T>::async_read_state RSType;
+      using RSType = typename io<T>::async_read_state;
       new (rs) RSType();
       io<T>::prepare(reinterpret_cast<RSType*>(rs));
     }
@@ -798,8 +798,8 @@ template <typename ... Fs>
     static void write(int s, const tuple<Fs...>& x) { tupInd<0, sizeof...(Fs), Fs...>::write(s, x); }
     static void read (int s, tuple<Fs...>* x)       { tupInd<0, sizeof...(Fs), Fs...>::read (s, x); }
 
-    typedef typename fmap<AsyncStateOf, tuple<Fs...>>::type SAsTuple;
-    typedef typename toVariant<SAsTuple>::type              async_read_state;
+    using SAsTuple = typename fmap<AsyncStateOf, tuple<Fs...>>::type;
+    using async_read_state = typename toVariant<SAsTuple>::type;
 
     static void prepare(async_read_state* o) {
       o->unsafeTag() = 0;
@@ -835,11 +835,11 @@ template <typename T>
     static const bool can_memcpy = false;
     static ty::desc type() { ty::Struct::Fields fs; defStructF df(&fs); T::meta(df); return ty::record(fs); }
 
-    typedef typename T::as_tuple_type TT;
+    using TT = typename T::as_tuple_type;
     static void write(int s, const T& x) { io<TT>::write(s, *reinterpret_cast<const TT*>(&x)); }
     static void read (int s, T* x)       { io<TT>::read (s, reinterpret_cast<TT*>(x)); }
 
-    typedef typename io<TT>::async_read_state async_read_state;
+    using async_read_state = typename io<TT>::async_read_state;
     static void prepare(async_read_state* o) { io<TT>::prepare(o); }
     static bool accum(int s, async_read_state* o, T* x) { return io<TT>::accum(s, o, reinterpret_cast<TT*>(x)); }
   };
@@ -863,14 +863,14 @@ template <typename T, typename ... Ts>
 // support opaque type aliases
 template <typename T>
   struct io<T, typename tbool<T::is_hmeta_alias>::type> {
-    typedef typename T::type RT;
+    using RT = typename T::type;
     static const bool can_memcpy = io<RT>::can_memcpy;
 
     static ty::desc type()                   { return ty::prim(T::name(), io<RT>::type()); }
     static void     write(int s, const T& x) { io<RT>::write(s, x.value); }
     static void     read (int s, T* x)       { io<RT>::read (s, &x->value); }
 
-    typedef typename io<RT>::async_read_state async_read_state;
+    using async_read_state = typename io<RT>::async_read_state;
     static void prepare(async_read_state* o)            { io<RT>::prepare(o); }
     static bool accum(int s, async_read_state* o, T* x) { return io<typename T::type>::accum(s, o, &x->value); }
   };
@@ -985,7 +985,7 @@ template <typename F>
   };
 template <typename R, typename ... Args>
   struct AsyncRPCFunc<R(Args...)> : public AsyncReader {
-    typedef std::function<void(const R&)> K;
+    using K = std::function<void (const R &)>;
 
     AsyncRPCFunc(AsyncScheduler* sched, int* socket, uint32_t exprid) :
       sched(sched), socket(socket), exprid(exprid)
@@ -1008,7 +1008,7 @@ template <typename R, typename ... Args>
       this->sched->enqueue(this);
     }
 
-    bool readAndFinish() {
+    bool readAndFinish() override {
       if (io<R>::accum(*this->socket, &this->pr, &this->r)) {
         this->ks.front()(this->r);
         this->ks.pop();
@@ -1024,8 +1024,8 @@ template <typename R, typename ... Args>
     int*            socket;
     uint32_t        exprid;
 
-    typedef typename io<R>::async_read_state async_read_state;
-    typedef std::queue<K> KS;
+    using async_read_state = typename io<R>::async_read_state;
+    using KS = std::queue<K>;
 
     KS               ks;
     R                r;
diff --git a/include/hobbes/parse/data.H b/include/hobbes/parse/data.H
index 8c13066a0..989426c8f 100644
--- a/include/hobbes/parse/data.H
+++ b/include/hobbes/parse/data.H
@@ -17,8 +17,8 @@
 
 namespace hobbes {
 
-typedef unsigned int nat;
-typedef std::vector<nat> nats;
+using nat = unsigned int;
+using nats = std::vector<nat>;
 
 template <typename T>
   std::string show(const T* t) {
@@ -31,7 +31,7 @@ template <typename T>
   std::string show(const std::vector<T*>& ts) {
     std::ostringstream ss;
     ss << "[";
-    if (ts.size() > 0) {
+    if (!ts.empty()) {
       ts[0]->show(ss);
       for (unsigned int i = 1; i < ts.size(); ++i) {
         ss << ", ";
@@ -46,8 +46,8 @@ template <typename T>
 // we just watch characters and record newlines
 class linedb {
 public:
-  typedef std::shared_ptr<linedb>  ptr;
-  typedef std::pair<nat, nat> LineCol;
+  using ptr = std::shared_ptr<linedb>;
+  using LineCol = std::pair<nat, nat>;
 
   linedb(nat stype, const std::string& sdesc);
 
@@ -66,15 +66,14 @@ private:
 };
 
 // load a set of lines around an implicated set from the specified line database
-typedef std::vector<std::string> strings;
-typedef std::pair<nats, strings> ldblines;
+using strings = std::vector<std::string>;
+using ldblines = std::pair<nats, strings>;
 
 ldblines load(const linedb::ptr& ldb, const linedb::LineCol& i, const linedb::LineCol& f);
 
 template <typename K, typename V>
   V mapLookup(const std::map<K, V>& m, const K& k) {
-    typedef typename std::map<K, V>::const_iterator CI;
-    CI i = m.find(k);
+    auto i = m.find(k);
     if (i == m.end()) {
       throw std::runtime_error("Unexpected map index undefined");
     } else {
diff --git a/include/hobbes/parse/grammar.H b/include/hobbes/parse/grammar.H
index 45dad484b..e74e117b1 100644
--- a/include/hobbes/parse/grammar.H
+++ b/include/hobbes/parse/grammar.H
@@ -17,18 +17,18 @@ namespace hobbes {
 
 class GrammarValue : public LexicallyAnnotated {
 public:
+  GrammarValue() = delete;
+
   GrammarValue(const LexicallyAnnotated&);
   virtual ~GrammarValue() = default;
   virtual void show(std::ostream&) const = 0;
-private:
-  GrammarValue();
 };
-typedef std::shared_ptr<GrammarValue> GrammarValuePtr;
+using GrammarValuePtr = std::shared_ptr<GrammarValue>;
 
 class GSymRef : public GrammarValue {
 public:
   GSymRef(const std::string&, const LexicalAnnotation&);
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const std::string& value() const;
 private:
@@ -38,7 +38,7 @@ private:
 class GStr : public GrammarValue {
 public:
   GStr(const std::string&, const LexicalAnnotation&);
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
   const std::string& value() const;
 private:
@@ -53,7 +53,7 @@ template <typename T>
 
 template <typename T>
   T switchOf(const GrammarValuePtr& p, const switchGrammarValue<T>& f) {
-    if (const GSymRef* x = dynamic_cast<const GSymRef*>(p.get())) {
+    if (const auto* x = dynamic_cast<const GSymRef*>(p.get())) {
       return f.with(x);
     } else if (const GStr* x = dynamic_cast<const GStr*>(p.get())) {
       return f.with(x);
@@ -70,7 +70,7 @@ struct BoundGrammarValue {
   std::string     varname;
   GrammarValuePtr element;
 };
-typedef std::vector<BoundGrammarValue> BoundGrammarValues;
+using BoundGrammarValues = std::vector<BoundGrammarValue>;
 
 struct GrammarRule {
   inline GrammarRule(const BoundGrammarValues& vs, const ExprPtr& e) : values(vs), reduction(e) { }
@@ -78,10 +78,10 @@ struct GrammarRule {
   BoundGrammarValues values;
   ExprPtr            reduction;
 };
-typedef std::vector<GrammarRule> GrammarRules;
+using GrammarRules = std::vector<GrammarRule>;
 
-typedef std::pair<std::string, GrammarRules> GrammarSymDef;
-typedef std::vector<GrammarSymDef> Grammar;
+using GrammarSymDef = std::pair<std::string, GrammarRules>;
+using Grammar = std::vector<GrammarSymDef>;
 
 // allow the construction of parsers from grammars
 class cc;
diff --git a/include/hobbes/parse/lalr.H b/include/hobbes/parse/lalr.H
index 55cdfa185..f51225546 100644
--- a/include/hobbes/parse/lalr.H
+++ b/include/hobbes/parse/lalr.H
@@ -14,9 +14,9 @@
 namespace hobbes {
 
 // a grammar is a mapping from abstract terminals to the set of rules matching those terminals
-typedef terminals                  rule;
-typedef std::vector<rule>          rules;
-typedef std::map<terminal*, rules> grammar;
+using rule = terminals;
+using rules = std::vector<rule>;
+using grammar = std::map<terminal *, rules>;
 
 // an item represents the state of recognizing a rule
 struct item {
@@ -34,23 +34,23 @@ struct item {
 
 // an itemset is a partial description of the state of a parser
 //  (with no duplicate items)
-typedef std::set<item>       itemset;
-typedef std::vector<itemset> itemsets;
+using itemset = std::set<item>;
+using itemsets = std::vector<itemset>;
 
 // transitions : a set of states to transition to indexed on terminals
-typedef std::map<terminal*, nat> state_transitions;
+using state_transitions = std::map<terminal *, nat>;
 
 // each closed itemset represents a numbered parser state
-typedef std::map<itemset, nat> parser_states;
+using parser_states = std::map<itemset, nat>;
 
 // the reverse parser state map
-typedef std::map<nat, itemset> state_definitions;
+using state_definitions = std::map<nat, itemset>;
 
 // a set of state transitions map values to target parser states (by index)
-typedef std::map<terminal*, nat> state_transitions;
+using state_transitions = std::map<terminal *, nat>;
 
 // each state has its own set of state transitions
-typedef std::map<nat, state_transitions> parser_state_transitions;
+using parser_state_transitions = std::map<nat, state_transitions>;
 
 // a parserdef is an ordered sequence of states, along with the transitions defined for each state
 struct parserdef {
@@ -138,8 +138,8 @@ parserdef lr0parser(const grammar& g, terminal* s);
 nat follow(const parserdef& p, nat q, terminal* t);
 
 // a transition of the LR(0) parser can be described by a state and terminal
-typedef std::pair<nat, terminal*> transition;
-typedef std::set<transition>      transitionset;
+using transition = std::pair<nat, terminal *>;
+using transitionset = std::set<transition>;
 
 transitionset transitions(const parserdef& p);
 
@@ -160,8 +160,8 @@ terminalset directReads(const parserdef& p, const transition& x);
 template <typename X, typename Y, typename Fp, typename A, typename R>
   class digraphF {
   public:
-    typedef std::set<X>    Xs;
-    typedef std::map<X, Y> F;
+    using Xs = std::set<X>;
+    using F = std::map<X, Y>;
 
     static F map(const Xs& xs, const Fp& fp, const A& append, const R& r) {
       return digraphF(xs, fp, append, r).map();
@@ -175,15 +175,15 @@ template <typename X, typename Y, typename Fp, typename A, typename R>
     digraphF(const Xs& xs, const Fp& fp, const A& append, const R& r) : xs(xs), fp(fp), append(append), r(r) {
     }
 
-    typedef std::stack<X>    Xstack;
-    typedef std::map<X, nat> Xidxs;
+    using Xstack = std::stack<X>;
+    using Xidxs = std::map<X, nat>;
 
     F map() const {
       F      f;
       Xstack s;
       Xidxs  n = freshIdxs(this->xs);
 
-      for (typename Xs::const_iterator x = this->xs.begin(); x != this->xs.end(); ++x) {
+      for (auto x = this->xs.begin(); x != this->xs.end(); ++x) {
         if (n[*x] == 0) {
           traverse(*x, &s, &n, &f);
         }
@@ -201,7 +201,7 @@ template <typename X, typename Y, typename Fp, typename A, typename R>
       (*f)[x] = this->fp(x);
 
       // and the values of any nodes in the input relation
-      for (typename Xs::const_iterator y = this->xs.begin(); y != this->xs.end(); ++y) {
+      for (auto y = this->xs.begin(); y != this->xs.end(); ++y) {
         if (this->r(x, *y)) {
           // the node y is in the relation
           // if it hasn't been visited yet, then recurse into it to determine its value
@@ -231,7 +231,7 @@ template <typename X, typename Y, typename Fp, typename A, typename R>
 
     static Xidxs freshIdxs(const Xs& xs) {
       Xidxs r;
-      for (typename Xs::const_iterator x = xs.begin(); x != xs.end(); ++x) {
+      for (auto x = xs.begin(); x != xs.end(); ++x) {
         r[*x] = 0;
       }
       return r;
@@ -241,7 +241,7 @@ template <typename X, typename Y, typename Fp, typename A, typename R>
   };
 
 // the across/up sets of LALR(1) determination
-typedef std::map<transition, terminalset> transition_lookahead;
+using transition_lookahead = std::map<transition, terminalset>;
 
 transition_lookahead Reads(const parserdef& p, const transitionset& ts);
 transition_lookahead Follow(const parserdef& p, const transitionset& ts);
@@ -252,7 +252,7 @@ parserdef lalr1parser(const grammar& g, terminal* s);
 // an ambiguity conflict on a particular terminal
 class ambiguity_conflict : public std::runtime_error {
 public:
-  ambiguity_conflict(const std::string& ex, terminal* t) throw();
+  ambiguity_conflict(const std::string& ex, terminal* t) noexcept;
 
   terminal* failedTerminal() const;
 private:
@@ -262,7 +262,7 @@ private:
 // a failure to compile a grammar to an LALR table, with cause
 class compile_table_failure : public std::runtime_error {
 public:
-  compile_table_failure(const std::string& msg, const grammar& g, const itemset& faileditems, terminal* t) throw();
+  compile_table_failure(const std::string& msg, const grammar& g, const itemset& faileditems, terminal* t) noexcept;
 
   const grammar& failedGrammar() const;
   const itemset& failedItems() const;
@@ -331,10 +331,10 @@ private:
 std::ostream& operator<<(std::ostream& out, const action& act);
 
 // a parser state maps a set of terminals to actions
-typedef std::map<terminal*, action> lrstate;
+using lrstate = std::map<terminal *, action>;
 
 // an ordered sequence of states describes the whole behavior of an LR parser
-typedef std::vector<lrstate> lrtable;
+using lrtable = std::vector<lrstate>;
 
 // determine the LR table, derived from the LALR(1) parser
 lrtable lalrTable(const parserdef& pd, const precedence& p = precedence());
diff --git a/include/hobbes/parse/parser.H b/include/hobbes/parse/parser.H
index 6c8c10f57..f46ba3f24 100644
--- a/include/hobbes/parse/parser.H
+++ b/include/hobbes/parse/parser.H
@@ -23,8 +23,8 @@ namespace hobbes {
 // such that:
 //   the type of R matches the type of R for all other definitions of S
 struct ParseRule {
-  typedef std::pair<std::string, terminal*> Binding;
-  typedef std::vector<Binding> Bindings;
+  using Binding = std::pair<std::string, terminal *>;
+  using Bindings = std::vector<Binding>;
 
   inline ParseRule(terminal* s, const Bindings& bs, const ExprPtr& r) : symbol(s), bindings(bs), reducer(r) { }
 
@@ -34,7 +34,7 @@ struct ParseRule {
 };
 
 // and a parser is a set of such rules
-typedef std::vector<ParseRule> Parser;
+using Parser = std::vector<ParseRule>;
 
 // consume a grammar to produce a parser for that grammar
 class cc;
diff --git a/include/hobbes/parse/terminal.H b/include/hobbes/parse/terminal.H
index 0775dbd32..b8bd7e8db 100644
--- a/include/hobbes/parse/terminal.H
+++ b/include/hobbes/parse/terminal.H
@@ -25,8 +25,8 @@ struct terminal {
   virtual PatternPtr matchPattern() const = 0;
   virtual ExprPtr matchRefExpr() const = 0;
 };
-typedef std::vector<terminal*> terminals;
-typedef std::set<terminal*> terminalset;
+using terminals = std::vector<terminal *>;
+using terminalset = std::set<terminal *>;
 
 // characters can be terminals
 class character : public terminal {
@@ -34,10 +34,10 @@ public:
   character(char x = 0);
   char value() const;
   void value(char);
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
 
-  PatternPtr matchPattern() const;
-  ExprPtr matchRefExpr() const;
+  PatternPtr matchPattern() const override;
+  ExprPtr matchRefExpr() const override;
 private:
   char x;
 };
@@ -47,10 +47,10 @@ class symbol : public terminal {
 public:
   symbol(const std::string& sname);
   const std::string& name() const;
-  void show(std::ostream& out) const;
+  void show(std::ostream& out) const override;
 
-  [[noreturn]] PatternPtr matchPattern() const;
-  [[noreturn]] ExprPtr matchRefExpr() const;
+  [[noreturn]] PatternPtr matchPattern() const override;
+  [[noreturn]] ExprPtr matchRefExpr() const override;
 private:
   std::string sname;
 };
@@ -59,11 +59,11 @@ private:
 class endOfFile : public terminal {
 public:
   endOfFile();
-  void show(std::ostream&) const;
+  void show(std::ostream&) const override;
   static terminal* value();
 
-  [[noreturn]] PatternPtr matchPattern() const;
-  [[noreturn]] ExprPtr matchRefExpr() const;
+  [[noreturn]] PatternPtr matchPattern() const override;
+  [[noreturn]] ExprPtr matchRefExpr() const override;
 };
 
 // allow terminals to be ordered by basic precedence / associativity definitions
@@ -79,7 +79,7 @@ struct prec {
   assoc::pref asc;
 };
 
-typedef std::map<terminal*, prec> precedence;
+using precedence = std::map<terminal *, prec>;
 
 }
 
diff --git a/include/hobbes/read/parser.H b/include/hobbes/read/parser.H
index 1cbcdf40f..3d6602edb 100644
--- a/include/hobbes/read/parser.H
+++ b/include/hobbes/read/parser.H
@@ -18,7 +18,7 @@ ModulePtr defReadModuleFile(cc*, const std::string&);
 ModulePtr defReadModule(cc*, const char*);
 ModulePtr defReadModule(cc*, const std::string&);
 
-typedef std::pair<std::string, ExprPtr> ExprDefn;
+using ExprDefn = std::pair<std::string, ExprPtr>;
 ExprDefn defReadExprDefn(cc*, const std::string&);
 
 ExprPtr defReadExpr(cc*, const std::string&);
@@ -28,10 +28,10 @@ ExprPtr defReadExpr(cc*, const std::string&);
 Expr* defVarCtor(const std::string&, const LexicalAnnotation&);
 Pattern* defPatVarCtor(const std::string&, const LexicalAnnotation&);
 
-typedef Expr* (*VarCtorFn)(const std::string&, const LexicalAnnotation&);
+using VarCtorFn = Expr *(*)(const std::string &, const LexicalAnnotation &);
 void overrideVarCtor(VarCtorFn);
 
-typedef Pattern* (*PatVarCtorFn)(const std::string&, const LexicalAnnotation&);
+using PatVarCtorFn = Pattern *(*)(const std::string &, const LexicalAnnotation &);
 void overridePatVarCtor(PatVarCtorFn);
 
 }
diff --git a/include/hobbes/reflect.H b/include/hobbes/reflect.H
index d94b5078b..3de3a275a 100644
--- a/include/hobbes/reflect.H
+++ b/include/hobbes/reflect.H
@@ -12,17 +12,17 @@
 #ifndef HOBBES_REFLECT_H_INCLUDED
 #define HOBBES_REFLECT_H_INCLUDED
 
-#include <memory>
-#include <string>
-#include <vector>
-#include <map>
+#include <cassert>
+#include <cstring>
+#include <cxxabi.h>
 #include <iostream>
+#include <map>
+#include <memory>
 #include <sstream>
-#include <cstring>
-#include <assert.h>
 #include <stdexcept>
+#include <string>
 #include <type_traits>
-#include <cxxabi.h>
+#include <vector>
 
 #if defined(__APPLE__) && defined(__MACH__)
 #include <fcntl.h>
@@ -50,7 +50,7 @@ namespace string {
     inline std::string demangle() {
       if (const char* tn = typeid(T).name()) {
         int s = 0;
-        if (char* dmn = abi::__cxa_demangle(tn, 0, 0, &s)) {
+        if (char* dmn = abi::__cxa_demangle(tn, nullptr, nullptr, &s)) {
           std::string r(dmn);
           free(dmn);
           return r;
@@ -63,9 +63,9 @@ namespace string {
     }
 
   // tokenize strings
-  typedef std::vector<std::string> seq;
+  using seq = std::vector<std::string>;
   inline seq csplit(const std::string& str, const std::string& pivot) {
-    typedef std::string::size_type size_type;
+    using size_type = std::string::size_type;
   
     seq       ret;
     size_type mp = 0;
@@ -85,7 +85,7 @@ namespace string {
     return ret;
   }
 
-  typedef std::pair<std::string, std::string> pair;
+  using pair = std::pair<std::string, std::string>;
   inline pair rsplit(const std::string& s, const std::string& ss) {
     size_t p = s.rfind(ss);
     if (p == std::string::npos) {
@@ -96,7 +96,7 @@ namespace string {
   }
 
   inline std::string cdelim(const seq& ss, const std::string& d) {
-    if (ss.size() > 0) {
+    if (!ss.empty()) {
       std::ostringstream x;
       x << ss[0];
       for (size_t i = 1; i < ss.size(); ++i) {
@@ -109,7 +109,7 @@ namespace string {
   }
 }
 
-typedef __int128 int128_t;
+using int128_t = __int128;
 
 // very basic macro metaprogramming
 #define PRIV_HPPF_FIRST(a, ...) a
@@ -188,7 +188,7 @@ template <size_t... pcs>
 
 // value-level bool -> type-level bool
 template <bool f> struct tbool { };
-template <>       struct tbool<true> { typedef void type; };
+template <>       struct tbool<true> { using type = void; };
 
 // test to see if a type(s) can be printed
 template <typename T, class = decltype(std::declval<std::ostream&>() << std::declval<T>())>
@@ -230,7 +230,7 @@ template <size_t index, size_t base, typename Field, typename ... Fields>
   struct offsetInfo<index, base, Field, Fields...> {
     static const size_t offset = alignTo(base, alignof(Field));
 
-    typedef offsetInfo<index+1, offset+sizeof(Field), Fields...> tail;
+    using tail = offsetInfo<index + 1, offset + sizeof(Field), Fields...>;
 
     static const size_t maxAlignment = szmax(alignof(Field), tail::maxAlignment);
     static const size_t size         = (offset-base) + sizeof(Field) + tail::size;
@@ -265,13 +265,13 @@ template <typename Offs>
 template <size_t, typename ... Fields>
   struct nth { };
 template <typename Field, typename ... Fields>
-  struct nth<0, Field, Fields...> { typedef Field type; };
+  struct nth<0, Field, Fields...> { using type = Field; };
 template <size_t n, typename Field, typename ... Fields>
   struct nth<n, Field, Fields...> : nth<n-1, Fields...> { };
 
 template <typename ... Fields>
   struct tuple {
-    typedef offsetInfo<0, 0, Fields...> offs;
+    using offs = offsetInfo<0, 0, Fields...>;
     static const size_t alignment = offs::maxAlignment;
     static const size_t size      = alignTo(offs::size, offs::maxAlignment);
     static const bool   packed    = (size == offs::size) && offs::packed;
@@ -316,11 +316,11 @@ template <>
     static const size_t alignment = 1;
     static const size_t size      = 0;
 
-    tuple() { }
-    tuple(const tuple<>&) { }
-    ~tuple() { }
+    tuple() = default;
+    tuple(const tuple<>&) = default;
+    ~tuple() = default;
 
-    tuple<>& operator=(const tuple<>&) { return *this; }
+    tuple<>& operator=(const tuple<>&) = default;
   };
 
 template <typename ... Fields>
@@ -331,33 +331,33 @@ template <typename ... Fields>
 template <size_t i, typename T>
   struct tupType { };
 template <size_t i, typename ... Ts>
-  struct tupType<i, tuple<Ts...>> { typedef typename nth<i, Ts...>::type type; };
+  struct tupType<i, tuple<Ts...>> { using type = typename nth<i, Ts...>::type; };
 
 // map a function over a tuple's types (useful for structurally-derived types)
 template <typename ... Ts>
   struct concatT { };
 template <typename ... Ts1, typename ... Ts2, typename ... Rest>
   struct concatT<tuple<Ts1...>, tuple<Ts2...>, Rest...> {
-    typedef typename concatT<tuple<Ts1..., Ts2...>, Rest...>::type type;
+    using type = typename concatT<tuple<Ts1..., Ts2...>, Rest...>::type;
   }; 
 template <typename ... Ts>
   struct concatT<tuple<Ts...>> {
-    typedef tuple<Ts...> type;
+    using type = tuple<Ts...>;
   };
 
 template <template <typename T> class F, typename X>
   struct fmap { };
 template <template <typename T> class F, typename H, typename ... Rest>
   struct fmap<F, tuple<H, Rest...>> {
-    typedef typename concatT<tuple<typename F<H>::type>, typename fmap<F, tuple<Rest...>>::type>::type type;
+    using type = typename concatT<tuple<typename F<H>::type>, typename fmap<F, tuple<Rest...>>::type>::type;
   }; 
 template <template <typename T> class F, typename H>
   struct fmap<F, tuple<H>> {
-    typedef tuple<typename F<H>::type> type;
+    using type = tuple<typename F<H>::type>;
   };
 template <template <typename T> class F>
   struct fmap<F, tuple<>> {
-    typedef tuple<> type;
+    using type = tuple<>;
   };
 
 // show a tuple iff its fields can be shown
@@ -384,7 +384,7 @@ template <typename ... Ts>
 
 // the trivially true proposition -- ie: C's "void" with its one value constructible
 struct unit {
-  unit() { }
+  unit() = default;
   bool operator==(const unit&) const { return true; }
   bool operator< (const unit&) const { return false; }
 };
@@ -393,7 +393,7 @@ inline std::ostream& operator<<(std::ostream& o, const unit&) { o << "()"; retur
 // drop the first type from a sequence to determine a tuple type
 // (useful with these macro expansions where we can't distinguish first and rest values)
 template <typename ... Ts>             struct tupleTail           {                            };
-template <typename T, typename ... Ts> struct tupleTail<T, Ts...> { typedef tuple<Ts...> type; };
+template <typename T, typename ... Ts> struct tupleTail<T, Ts...> { using type = tuple<Ts...>; };
 
 // reflective structs
 #define PRIV_HPPF_STRUCT_FIELD(t, n) t n;
@@ -473,15 +473,15 @@ template <typename T, typename ... Ts> struct tupleTail<T, Ts...> { typedef tupl
 template <bool f, typename T, typename F>
   struct TIfF { };
 template <typename T, typename F>
-  struct TIfF<true, T, F> { typedef T type; };
+  struct TIfF<true, T, F> { using type = T; };
 template <typename T, typename F>
-  struct TIfF<false, T, F> { typedef F type; };
+  struct TIfF<false, T, F> { using type = F; };
 template <typename T>
   struct TSizeOfF { static const size_t value = sizeof(T); };
 template <typename T>
   struct TAlignOfF { static const size_t value = alignof(T); };
 template <template <class> class SzP, typename T0, typename ... Ts>
-  struct maximum { static const size_t value = SzP<T0>::value; typedef T0 type; };
+  struct maximum { static const size_t value = SzP<T0>::value; using type = T0; };
 template <template <class> class SzP, typename T0, typename T1, typename ... Ts>
   struct maximum<SzP, T0, T1, Ts...> : public maximum<SzP, typename TIfF<SzP<T1>::value < SzP<T0>::value, T0, T1>::type, Ts...> { };
 
@@ -492,21 +492,21 @@ template <typename T, typename ... Ctors>
 template <typename T, typename Ctor, typename ... Ctors>
   struct CtorIndexOf<T, Ctor, Ctors...> { static const uint32_t value = 1 + CtorIndexOf<T, Ctors...>::value; };
 template <typename T, typename ... Ts>
-  struct First { typedef T type; };
+  struct First { using type = T; };
 
 template <size_t i, typename R, template <size_t,class,class> class F, typename U, typename A, typename ... Ctors>
   struct variantAppInit {
   };
 template <size_t i, typename R, template <size_t,class,class> class F, typename U, typename ... Args, typename ... Ctors>
   struct variantAppInit<i, R, F, U, tuple<Args...>, Ctors...> {
-    typedef R (*PF)(void*, Args...);
+    using PF = R (*)(void *, Args...);
     static bool init(PF*) { return true; }
   };
 template <size_t i, typename R, template <size_t,class,class> class F, typename U, typename ... Args, typename Ctor, typename ... Ctors>
   struct variantAppInit<i, R, F, U, tuple<Args...>, Ctor, Ctors...> {
-    typedef R (*PF)(void*, Args...);
+    using PF = R (*)(void *, Args...);
     static bool init(PF* pfs) {
-      typedef R (*TPF)(Ctor*, Args...);
+      using TPF = R (*)(Ctor *, Args...);
       TPF tpf = &F<i, Ctor, U>::fn;
       pfs[i] = reinterpret_cast<PF>(tpf);
       return variantAppInit<i+1, R, F, U, tuple<Args...>, Ctors...>::init(pfs);
@@ -518,7 +518,7 @@ template <typename R, template <size_t,class,class> class F, typename U, typenam
   };
 template <template <size_t,class,class> class F, typename U, typename ... Ctors, typename ... Args>
   struct variantApp<void, F, U, tuple<Ctors...>, Args...> {
-    typedef void (*PF)(void*, Args...);
+    using PF = void (*)(void *, Args...);
     static PF* fns() {
       static PF fvec[sizeof...(Ctors)];
       static bool init = variantAppInit<0, void, F, U, tuple<Args...>, Ctors...>::init(fvec);
@@ -533,7 +533,7 @@ template <template <size_t,class,class> class F, typename U, typename ... Ctors,
 
 template <typename R, template <size_t,class,class> class F, typename U, typename ... Ctors, typename ... Args>
   struct variantApp<R, F, U, tuple<Ctors...>, Args...> {
-    typedef R (*PF)(void*, Args...);
+    using PF = R (*)(void *, Args...);
     static PF* fns() {
       static PF fvec[sizeof...(Ctors)];
       static bool init = variantAppInit<0, R, F, U, tuple<Args...>, Ctors...>::init(fvec);
@@ -601,8 +601,8 @@ template <typename ... Ctors>
     static const size_t count = sizeof...(Ctors);
     static_assert(count > 0, "Empty variants are impossible to construct");
 
-    typedef variantApp<void, variantPayloadCtor, void, tuple<Ctors...>, const void*> VCCtor;
-    typedef variantApp<void, variantPayloadDtor, void, tuple<Ctors...>>              VDtor;
+    using VCCtor = variantApp<void, variantPayloadCtor, void, tuple<Ctors...>, const void *>;
+    using VDtor = variantApp<void, variantPayloadDtor, void, tuple<Ctors...>>;
 
     variant() : tag(0) {
       new (this->storage) typename First<Ctors...>::type();
@@ -669,7 +669,7 @@ template <typename ... Ctors>
         if (this->tag == CtorIndexOf<T, Ctors...>::value) {
           return const_cast<T*>(reinterpret_cast<const T*>(this->storage));
         } else {
-          return 0;
+          return nullptr;
         }
       }
   };
@@ -688,12 +688,12 @@ template <typename T, typename ... Ctors, typename = std::enable_if_t<detail::Co
   }
 
 template <typename ... Ts>             struct variantTail           {                              };
-template <typename T, typename ... Ts> struct variantTail<T, Ts...> { typedef variant<Ts...> type; };
+template <typename T, typename ... Ts> struct variantTail<T, Ts...> { using type = variant<Ts...>; };
 
 template <typename T>
   struct toVariant { };
 template <typename ... Ts>
-  struct toVariant<tuple<Ts...>> { typedef variant<Ts...> type; };
+  struct toVariant<tuple<Ts...>> { using type = variant<Ts...>; };
 
 // show a variant iff its constructors can be shown
 template <size_t, typename T, typename U>
@@ -959,7 +959,7 @@ template <typename ... Ts>
 // arrays with dynamically-determined length
 template <typename T>
   struct array {
-    typedef array<T>* ptr;
+    using ptr = array<T> *;
 
     size_t size;
     T      data[1]; // unknown length, bytes inline with this structure
@@ -1016,7 +1016,7 @@ template <typename T, size_t N>       T* end  (      carray<T,N>& d) { return d.
 template <typename RepTy>
   struct alias {
     static const bool is_hmeta_alias = true;
-    typedef RepTy type;
+    using type = RepTy;
     RepTy value;
 
     alias() : value() { }
@@ -1041,7 +1041,7 @@ template <typename RepTy>
 
 namespace ty {
 
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 // type encoding logic
 #define PRIV_HPPF_TYCTOR_PRIM      (static_cast<uint32_t>(0))
@@ -1056,7 +1056,7 @@ typedef std::vector<uint8_t> bytes;
 #define PRIV_HPPF_TYCTOR_TABS      (static_cast<uint32_t>(15))
 
 struct D { uint32_t tid; D(uint32_t tid) : tid(tid) { } };
-typedef std::shared_ptr<D> desc;
+using desc = std::shared_ptr<D>;
 
 struct Nat : public D {
   Nat(size_t x) : D(PRIV_HPPF_TYCTOR_SIZE), x(x) { }
@@ -1093,8 +1093,8 @@ struct Arr : public D {
 inline desc array(const desc& t) { return desc(new Arr(t)); }
 
 struct Variant : public D {
-  typedef tuple<std::string, uint32_t, desc> Ctor;
-  typedef std::vector<Ctor> Ctors;
+  using Ctor = tuple<std::string, uint32_t, desc>;
+  using Ctors = std::vector<Ctor>;
 
   Variant(const Ctors& ctors) : D(PRIV_HPPF_TYCTOR_VARIANT), ctors(ctors) { }
 
@@ -1122,14 +1122,14 @@ template <typename ... Tys>
   }
 
 struct Struct : public D {
-  typedef tuple<std::string, int, desc> Field;
-  typedef std::vector<Field> Fields;
+  using Field = tuple<std::string, int, desc>;
+  using Fields = std::vector<Field>;
 
   Struct(const Fields& fields) : D(PRIV_HPPF_TYCTOR_STRUCT), fields(fields) { }
 
   Fields fields;
 };
-inline desc record(const Struct::Fields& fields) { return fields.size() == 0 ? prim("unit") : desc(new Struct(fields)); }
+inline desc record(const Struct::Fields& fields) { return fields.empty() ? prim("unit") : desc(new Struct(fields)); }
 
 template <typename ... Tys>
   struct tupAcc { static void acc(Struct::Fields*) { } };
@@ -1171,7 +1171,7 @@ struct Recursive : public D {
 inline desc recursive(const std::string& x, const desc& t) { return desc(new Recursive(x, t)); }
 
 struct Fn : public D {
-  typedef std::vector<std::string> Args;
+  using Args = std::vector<std::string>;
   Fn(const Args& args, const desc& t) : D(PRIV_HPPF_TYCTOR_TABS), args(args), t(t) { }
 
   Args args;
@@ -1190,7 +1190,7 @@ template <typename ... Tys>
   inline desc fn(const Tys& ... tt) { Fn::Args args; return fnAcc<Tys...>::acc(&args, tt...); }
 
 struct App : public D {
-  typedef std::vector<desc> Args;
+  using Args = std::vector<desc>;
 
   App(const desc& f, const Args& args) : D(PRIV_HPPF_TYCTOR_TAPP), f(f), args(args) { }
 
@@ -1234,9 +1234,9 @@ inline desc elimFileRefs(const desc& t) {
   const D*         pd   = t.get();
   const FArr*      pfa  = reinterpret_cast<const FArr*>(pd);
   const Arr*       pa   = reinterpret_cast<const Arr*>(pd);
-  const Variant*   pv   = reinterpret_cast<const Variant*>(pd);
-  const Struct*    ps   = reinterpret_cast<const Struct*>(pd);
-  const Recursive* pr   = reinterpret_cast<const Recursive*>(pd);
+  const auto*   pv   = reinterpret_cast<const Variant*>(pd);
+  const auto*    ps   = reinterpret_cast<const Struct*>(pd);
+  const auto* pr   = reinterpret_cast<const Recursive*>(pd);
   const Fn*        pfn  = reinterpret_cast<const Fn*>(pd);
   const App*       papp = reinterpret_cast<const App*>(pd);
 
@@ -1267,7 +1267,7 @@ inline desc elimFileRefs(const desc& t) {
     {
       if (papp->f->tid == PRIV_HPPF_TYCTOR_PRIM) {
         if (reinterpret_cast<const Prim*>(papp->f.get())->n == "fileref") {
-          if (papp->args.size() > 0) {
+          if (!papp->args.empty()) {
             return elimFileRefs(papp->args[0]);
           }
         }
@@ -1312,9 +1312,9 @@ inline void encode(const desc& t, bytes* o) {
   const Var*       pvn  = reinterpret_cast<const Var*>(pd);
   const FArr*      pfa  = reinterpret_cast<const FArr*>(pd);
   const Arr*       pa   = reinterpret_cast<const Arr*>(pd);
-  const Variant*   pv   = reinterpret_cast<const Variant*>(pd);
-  const Struct*    ps   = reinterpret_cast<const Struct*>(pd);
-  const Recursive* pr   = reinterpret_cast<const Recursive*>(pd);
+  const auto*   pv   = reinterpret_cast<const Variant*>(pd);
+  const auto*    ps   = reinterpret_cast<const Struct*>(pd);
+  const auto* pr   = reinterpret_cast<const Recursive*>(pd);
   const Fn*        pfn  = reinterpret_cast<const Fn*>(pd);
   const App*       papp = reinterpret_cast<const App*>(pd);
   const Nat*       pn   = reinterpret_cast<const Nat*>(pd);
@@ -1441,7 +1441,7 @@ inline desc decodeFrom(const bytes& bs, size_t* i) {
     }
 
   case PRIV_HPPF_TYCTOR_VARIANT: {
-      size_t n = readValue<size_t>(bs, i);
+      auto n = readValue<size_t>(bs, i);
       Variant::Ctors cs;
       for (size_t k = 0; k < n; ++k) {
         std::string n  = readString(bs, i);
@@ -1454,7 +1454,7 @@ inline desc decodeFrom(const bytes& bs, size_t* i) {
     }
 
   case PRIV_HPPF_TYCTOR_STRUCT: {
-      size_t count = readValue<size_t>(bs, i);
+      auto count = readValue<size_t>(bs, i);
       Struct::Fields fs;
       for (size_t k = 0; k < count; ++k) {
         std::string n = readString(bs, i);
@@ -1472,7 +1472,7 @@ inline desc decodeFrom(const bytes& bs, size_t* i) {
 
   case PRIV_HPPF_TYCTOR_TAPP: {
       desc   f = decodeFrom(bs, i);
-      size_t n = readValue<size_t>(bs, i);
+      auto n = readValue<size_t>(bs, i);
 
       App::Args args;
       for (size_t k = 0; k < n; ++k) {
@@ -1490,7 +1490,7 @@ inline desc decodeFrom(const bytes& bs, size_t* i) {
     }
 
   case PRIV_HPPF_TYCTOR_TABS: {
-      size_t   n = readValue<size_t>(bs, i);
+      auto   n = readValue<size_t>(bs, i);
       Fn::Args args;
       for (size_t k = 0; k < n; ++k) {
         args.push_back(readString(bs, i));
@@ -1527,9 +1527,9 @@ inline void describe(const desc& t, std::ostream& o) {
   const Var*       pvn  = reinterpret_cast<const Var*>(pd);
   const FArr*      pfa  = reinterpret_cast<const FArr*>(pd);
   const Arr*       pa   = reinterpret_cast<const Arr*>(pd);
-  const Variant*   pv   = reinterpret_cast<const Variant*>(pd);
-  const Struct*    ps   = reinterpret_cast<const Struct*>(pd);
-  const Recursive* pr   = reinterpret_cast<const Recursive*>(pd);
+  const auto*   pv   = reinterpret_cast<const Variant*>(pd);
+  const auto*    ps   = reinterpret_cast<const Struct*>(pd);
+  const auto* pr   = reinterpret_cast<const Recursive*>(pd);
   const Fn*        pfn  = reinterpret_cast<const Fn*>(pd);
   const App*       papp = reinterpret_cast<const App*>(pd);
   const Nat*       pn   = reinterpret_cast<const Nat*>(pd);
@@ -1558,7 +1558,7 @@ inline void describe(const desc& t, std::ostream& o) {
     o << "]";
     break;
   case PRIV_HPPF_TYCTOR_VARIANT:
-    if (pv->ctors.size() == 0) {
+    if (pv->ctors.empty()) {
       o << "void";
     } else {
       // show as sum or variant
@@ -1582,7 +1582,7 @@ inline void describe(const desc& t, std::ostream& o) {
     }
     break;
   case PRIV_HPPF_TYCTOR_STRUCT:
-    if (ps->fields.size() == 0) {
+    if (ps->fields.empty()) {
       o << "()";
     } else {
       // show as product or record
@@ -1609,13 +1609,13 @@ inline void describe(const desc& t, std::ostream& o) {
     o << pn->x;
     break;
   case PRIV_HPPF_TYCTOR_TAPP:
-    if (papp->args.size() > 0 && papp->f->tid == PRIV_HPPF_TYCTOR_PRIM && reinterpret_cast<const ty::Prim*>(papp->f.get())->n == "fileref") {
+    if (!papp->args.empty() && papp->f->tid == PRIV_HPPF_TYCTOR_PRIM && reinterpret_cast<const ty::Prim*>(papp->f.get())->n == "fileref") {
       describe(papp->args[0], o);
       o << "@?";
     } else {
       describe(papp->f, o);
       o << "(";
-      if (papp->args.size() > 0) {
+      if (!papp->args.empty()) {
         describe(papp->args[0], o);
         for (size_t i = 1; i < papp->args.size(); ++i) {
           o << ", ";
@@ -1631,7 +1631,7 @@ inline void describe(const desc& t, std::ostream& o) {
     break;
   case PRIV_HPPF_TYCTOR_TABS:
     o << "\\";
-    if (pfn->args.size() > 0) {
+    if (!pfn->args.empty()) {
       o << pfn->args[0];
       for (size_t i = 1; i < pfn->args.size(); ++i) {
         o << " " << pfn->args[i];
@@ -1672,8 +1672,8 @@ inline bool equivModOffset(const desc& t0, const desc& t1) {
   case PRIV_HPPF_TYCTOR_ARR:
     return equivModOffset(reinterpret_cast<const Arr*>(pd0)->t, reinterpret_cast<const Arr*>(pd1)->t);
   case PRIV_HPPF_TYCTOR_VARIANT: {
-      const Variant* pv0 = reinterpret_cast<const Variant*>(pd0);
-      const Variant* pv1 = reinterpret_cast<const Variant*>(pd1);
+      const auto* pv0 = reinterpret_cast<const Variant*>(pd0);
+      const auto* pv1 = reinterpret_cast<const Variant*>(pd1);
 
       if (pv0->ctors.size() != pv1->ctors.size()) {
         return false;
@@ -1689,8 +1689,8 @@ inline bool equivModOffset(const desc& t0, const desc& t1) {
       }
     }
   case PRIV_HPPF_TYCTOR_STRUCT: {
-      const Struct* pr0 = reinterpret_cast<const Struct*>(pd0);
-      const Struct* pr1 = reinterpret_cast<const Struct*>(pd1);
+      const auto* pr0 = reinterpret_cast<const Struct*>(pd0);
+      const auto* pr1 = reinterpret_cast<const Struct*>(pd1);
 
       if (pr0->fields.size() != pr1->fields.size()) {
         return false;
@@ -1742,8 +1742,8 @@ inline size_t alignOf(const desc& t) {
   const Prim*      pt   = reinterpret_cast<const Prim*>(pd);
   const Var*       pvn  = reinterpret_cast<const Var*>(pd);
   const FArr*      pfa  = reinterpret_cast<const FArr*>(pd);
-  const Variant*   pv   = reinterpret_cast<const Variant*>(pd);
-  const Struct*    ps   = reinterpret_cast<const Struct*>(pd);
+  const auto*   pv   = reinterpret_cast<const Variant*>(pd);
+  const auto*    ps   = reinterpret_cast<const Struct*>(pd);
 
   switch (t->tid) {
   case PRIV_HPPF_TYCTOR_PRIM:
@@ -1773,7 +1773,7 @@ inline size_t alignOf(const desc& t) {
     throw std::runtime_error("Can't determine alignment of variable-length array type: " + show(t));
 
   case PRIV_HPPF_TYCTOR_VARIANT:
-    if (pv->ctors.size() == 0) {
+    if (pv->ctors.empty()) {
       return 1;
     } else {
       size_t maxAlign = 4; // the variant tag is an int
@@ -1784,7 +1784,7 @@ inline size_t alignOf(const desc& t) {
     }
 
   case PRIV_HPPF_TYCTOR_STRUCT:
-    if (ps->fields.size() == 0) {
+    if (ps->fields.empty()) {
       return 1;
     } else {
       size_t maxAlign = 1;
@@ -1816,8 +1816,8 @@ inline size_t sizeOf(const desc& t) {
   const Prim*      pt   = reinterpret_cast<const Prim*>(pd);
   const Var*       pvn  = reinterpret_cast<const Var*>(pd);
   const FArr*      pfa  = reinterpret_cast<const FArr*>(pd);
-  const Variant*   pv   = reinterpret_cast<const Variant*>(pd);
-  const Struct*    ps   = reinterpret_cast<const Struct*>(pd);
+  const auto*   pv   = reinterpret_cast<const Variant*>(pd);
+  const auto*    ps   = reinterpret_cast<const Struct*>(pd);
 
   switch (t->tid) {
   case PRIV_HPPF_TYCTOR_PRIM:
@@ -1843,7 +1843,7 @@ inline size_t sizeOf(const desc& t) {
     throw std::runtime_error("Can't determine size of variable-length array type: " + show(t));
 
   case PRIV_HPPF_TYCTOR_VARIANT:
-    if (pv->ctors.size() == 0) {
+    if (pv->ctors.empty()) {
       return 4;
     } else {
       size_t maxSize  = 4; // the variant tag is an int
@@ -1856,7 +1856,7 @@ inline size_t sizeOf(const desc& t) {
     }
 
   case PRIV_HPPF_TYCTOR_STRUCT:
-    if (ps->fields.size() == 0) {
+    if (ps->fields.empty()) {
       return 1;
     } else {
       size_t maxAlign = 1;
diff --git a/include/hobbes/slmap.H b/include/hobbes/slmap.H
index 4d2b5493f..9a32f535a 100644
--- a/include/hobbes/slmap.H
+++ b/include/hobbes/slmap.H
@@ -35,11 +35,11 @@ namespace hobbes {
 
 template <typename K, typename V>
   struct slnode {
-    typedef uint16_t level;
+    using level = uint16_t;
     static const size_t maxLevels = 8*sizeof(level);
 
     // a fileref pointer to a skip-list node
-    typedef fregion::fileref<slnode<K,V>> noderef;
+    using noderef = fregion::fileref<slnode<K, V>>;
 
     // the tower of 'next' pointers from this node
     // (0 is the "slow lane" with nothing skipped, then "faster" skips going further up)
@@ -77,7 +77,7 @@ template <typename K, typename V>
     // (this assumes that we have a valid link at this level)
     slnode<K,V>* loadNext(fregion::imagefile* f, size_t level) const {
       if (this->next[level].index == 0) {
-        return 0;
+        return nullptr;
       } else {
         return this->next[level].load(f);
       }
@@ -125,9 +125,9 @@ template <typename K, typename V>
     //   in a uniformly distributed random number
     //    (1/2 end in 1b, 1/4 end in 11b, 1/8 end in 111b, etc)
     static level chooseLevel() {
-      level bv = static_cast<level>(rand());
+      auto bv = static_cast<level>(rand());
       level r = 1;
-      while (bv&1) {
+      while ((bv&1) != 0) {
         ++r;
         bv>>=1;
       }
@@ -207,16 +207,16 @@ template <typename K, typename V>
     fregion::imagefile* f;
     slnode<K,V>*        n;
 
-    sliterator(fregion::imagefile* f=0, slnode<K,V>* n=0) : f(f), n(n) { }
+    sliterator(fregion::imagefile* f=nullptr, slnode<K,V>* n=nullptr) : f(f), n(n) { }
     bool operator==(const sliterator<K,V>& rhs) const { return this->n==rhs.n; }
     std::pair<K,V>& operator*() { return *reinterpret_cast<std::pair<K,V>*>(&this->n->key); }
     std::pair<K,V>* operator->() { return reinterpret_cast<std::pair<K,V>*>(&this->n->key); }
-    operator bool() const { return this->n != 0; }
+    operator bool() const { return this->n != nullptr; }
     
     sliterator<K,V>& operator++() {
       if (this->n->next[0].index==0) {
-        this->f=0;
-        this->n=0;
+        this->f=nullptr;
+        this->n=nullptr;
       } else {
         this->n=this->n->next[0].load(this->f);
       }
@@ -304,7 +304,7 @@ template <typename K, typename V>
       return this->d->count;
     }
 
-    typedef sliterator<K,V> iterator;
+    using iterator = sliterator<K, V>;
     iterator end()   { return iterator(); }
     iterator begin() { return (this->d->root.next.size==0 || this->d->root.next[0].index==0) ? end() : iterator(this->f, this->d->root.next[0].load(f)); }
 
@@ -315,19 +315,19 @@ template <typename K, typename V>
     iterator find(const K& k) {
       return iterator(this->f, this->d->lookup(this->f, k));
     }
+
+    slmap() = delete;
+    slmap(const slmap<K,V>&) = delete;
+    slmap<K,V>& operator=(const slmap<K,V>&) = delete;
   private:
     fregion::imagefile* f;
     slmapdata<K,V>* d;
-  private:
-    slmap();
-    slmap(const slmap<K,V>&);
-    slmap<K,V>& operator=(const slmap<K,V>&);
   };
 
 template <typename K>
   class slrefmap {
   public:
-    typedef uint64_t ufileref;
+    using ufileref = uint64_t;
 
     slrefmap(const std::string& name, fregion::imagefile* f, const ty::desc& refType) {
       this->f = f;
@@ -355,7 +355,7 @@ template <typename K>
       return this->d->count;
     }
 
-    typedef sliterator<K,ufileref> iterator;
+    using iterator = sliterator<K, ufileref>;
     iterator end()   { return iterator(); }
     iterator begin() { return (this->d->root.next.size==0 || this->d->root.next[0].index==0) ? end() : iterator(this->f, this->d->root.next[0].load(f)); }
 
@@ -366,13 +366,13 @@ template <typename K>
     iterator find(const K& k) {
       return iterator(this->f, this->d->lookup(this->f, k));
     }
+
+    slrefmap() = delete;
+    slrefmap(const slrefmap<K>&) = delete;
+    slrefmap<K>& operator=(const slrefmap<K>&) = delete;
   private:
     fregion::imagefile* f;
     slmapdata<K,ufileref>* d;
-  private:
-    slrefmap();
-    slrefmap(const slrefmap<K>&);
-    slrefmap<K>& operator=(const slrefmap<K>&);
   };
 
 }
diff --git a/include/hobbes/storage.H b/include/hobbes/storage.H
index 4d573b3b0..4b619a98f 100644
--- a/include/hobbes/storage.H
+++ b/include/hobbes/storage.H
@@ -11,21 +11,21 @@
 #ifndef HSTORE_H_INCLUDED
 #define HSTORE_H_INCLUDED
 
-#include <map>
-#include <vector>
 #include <array>
-#include <string>
-#include <string.h>
-#include <tuple>
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
 #include <functional>
 #include <iostream>
-#include <sstream>
-#include <atomic>
+#include <map>
 #include <mutex>
+#include <sstream>
 #include <stdexcept>
-#include <stdlib.h>
-#include <stdint.h>
-#include <assert.h>
+#include <string>
+#include <tuple>
+#include <vector>
 
 #include <unistd.h>
 #include <sys/types.h>
@@ -182,7 +182,7 @@ static inline long sys_futex(volatile uint32_t* p, int op, int v, struct timespe
   return syscall(SYS_futex, p, op, v, timeout, p2, v2);
 }
 static inline void waitForUpdate(volatile uint32_t* p, int eqV) {
-  sys_futex(p, FUTEX_WAIT, eqV, 0, 0, 0);
+  sys_futex(p, FUTEX_WAIT, eqV, nullptr, nullptr, 0);
 }
 static inline void waitForUpdate(volatile uint32_t* p, int eqV, size_t timeoutNS, const std::function<void()>& timeoutF) {
   if (timeoutNS == 0) {
@@ -196,7 +196,7 @@ static inline void waitForUpdate(volatile uint32_t* p, int eqV, size_t timeoutNS
 
   bool c = true;
   while (c) {
-    int r = sys_futex(p, FUTEX_WAIT, eqV, &ts, 0, 0);
+    int r = sys_futex(p, FUTEX_WAIT, eqV, &ts, nullptr, 0);
         c = r < 0 && errno == ETIMEDOUT;
 
     if (c) {
@@ -205,7 +205,7 @@ static inline void waitForUpdate(volatile uint32_t* p, int eqV, size_t timeoutNS
   }
 }
 static inline void wakeN(volatile uint32_t* p, int c) {
-  sys_futex(p, FUTEX_WAKE, c, 0, 0, 0);
+  sys_futex(p, FUTEX_WAKE, c, nullptr, nullptr, 0);
 }
 
 } // namespace futex
@@ -221,8 +221,8 @@ namespace platform = futex;
 
 namespace hobbes { namespace storage {
 
-typedef void (*WaitFn)(volatile uint32_t*, int, size_t, const std::function<void()>&);
-typedef void (*WakeFn)(volatile uint32_t*, int);
+using WaitFn = void (*)(volatile uint32_t *, int, size_t, const std::function<void ()> &);
+using WakeFn = void (*)(volatile uint32_t *, int);
 
 enum WaitPolicy {
   Platform = 0,
@@ -251,7 +251,7 @@ namespace hobbes { namespace storage {
 
 #define HSTORE_VERSION static_cast<uint32_t>(0x00020000)
 
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 // write transactions into shared memory
 #define PRIV_HSTORE_LIKELY(x)   __builtin_expect((x),1)
@@ -322,7 +322,7 @@ inline int mqconnect(const std::string& fileName) {
   addr.sun_family = AF_UNIX;
   snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", fileName.c_str());
  
-  sockaddr* saddr = reinterpret_cast<sockaddr*>(&addr);
+  auto* saddr = reinterpret_cast<sockaddr*>(&addr);
   size_t    len   = sizeof(addr);
   if (connect(r, saddr, len) == -1) {
     std::string emsg = "Unable to connect socket: " + std::string(strerror(errno));
@@ -333,13 +333,13 @@ inline int mqconnect(const std::string& fileName) {
   fd_set wd;
   FD_ZERO(&wd);
   FD_SET(r, &wd);
-  if (select(r + 1, 0, &wd, 0, 0) == -1) {
+  if (select(r + 1, nullptr, &wd, nullptr, nullptr) == -1) {
     std::string emsg = "Failed to connect socket while waiting for writeability: " + std::string(strerror(errno));
     close(r);
     throw std::runtime_error(emsg);
   }
 
-  uint32_t version = HSTORE_VERSION;
+  auto version = HSTORE_VERSION;
   mqwrite(r, reinterpret_cast<const uint8_t*>(&version), sizeof(version));
   return r;
 }
@@ -377,18 +377,18 @@ inline int mqlisten(const std::string& fileName) {
 }
 
 inline std::string defaultStoreDir() {
-  const char* td = 0;
-  if ((td = ::getenv("HOBBES_STORE_DIR"))) {
+  const char* td = nullptr;
+  if ((td = ::getenv("HOBBES_STORE_DIR")) != nullptr) {
     if (::strlen(td) > 0 && ::access(td, W_OK) == 0) {
       return std::string(td);
     }
   }
-  if ((td = ::getenv("TMPDIR"))) {
+  if ((td = ::getenv("TMPDIR")) != nullptr) {
     if (::strlen(td) > 0 && ::access(td, W_OK) == 0) {
       return std::string(td);
     }
   }
-  if ((td = ::getenv("TMP"))) {
+  if ((td = ::getenv("TMP")) != nullptr) {
     if (::strlen(td) > 0 && ::access(td, W_OK) == 0) {
       return std::string(td);
     }
@@ -418,7 +418,7 @@ inline int makeGroupHost(const std::string& groupName, const std::string& sdir =
 }
 
 // identify this process/thread
-typedef std::pair<uint64_t, uint64_t> ProcThread;
+using ProcThread = std::pair<uint64_t, uint64_t>;
 
 inline ProcThread thisProcThread() {
   ProcThread r;
@@ -466,7 +466,7 @@ inline void reconnectSHM(int* mqserver, const char* groupName, const WaitPolicy
     tmout.tv_sec = 0;
     tmout.tv_usec = 1;
 
-    auto sr = select(*mqserver+1, &rd, 0, 0, &tmout);
+    auto sr = select(*mqserver+1, &rd, nullptr, nullptr, &tmout);
     if (sr == 1) {
       char b=0;
       if (recv(*mqserver, &b, 1, MSG_PEEK) == 0) {
@@ -497,7 +497,7 @@ inline void reconnectSHM(int* mqserver, const char* groupName, const WaitPolicy
 
 struct pqueue_config {
   pqueue_config() :
-    valuesz(0), count(0), wstate(0), readerIndex(0), writerIndex(0), data(0) {
+    valuesz(0), count(0), wstate(nullptr), readerIndex(nullptr), writerIndex(nullptr), data(nullptr) {
   }
   
   pqueue_config(size_t valuesz, size_t count, uint32_t* wstate, uint32_t* ri, uint32_t* wi, uint8_t* data) :
@@ -560,8 +560,8 @@ public:
   
     // our meta-data section comes first up to the first page boundary
     // then our data section comes next
-    size_t metaLen = align<size_t>(sizeof(ShQueueHeader) + meta.size(),  pagesz);
-    size_t dataLen = align<size_t>(sizeof(ShQueueData)   + qvalsz*count, pagesz);
+    auto metaLen = align<size_t>(sizeof(ShQueueHeader) + meta.size(),  pagesz);
+    auto dataLen = align<size_t>(sizeof(ShQueueData)   + qvalsz*count, pagesz);
     size_t memLen  = metaLen + dataLen;
   
     // allocate this much data
@@ -569,13 +569,13 @@ public:
       throw std::runtime_error("Failed to truncate shared memory for '" + shmname + "': " + strerror(errno));
     }
   
-    uint8_t* mem = reinterpret_cast<uint8_t*>(mmap(0, memLen, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, shfd, 0));
+    auto* mem = reinterpret_cast<uint8_t*>(mmap(nullptr, memLen, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, shfd, 0));
     if (mem == MAP_FAILED) {
       throw std::runtime_error("Failed to map bytes out of shared memory for '" + shmname + "': " + strerror(errno));
     }
   
     // write meta data
-    ShQueueHeader* hdr = reinterpret_cast<ShQueueHeader*>(mem);
+    auto* hdr = reinterpret_cast<ShQueueHeader*>(mem);
     hdr->valsz  = qvalsz;
     hdr->count  = count;
     hdr->metasz = meta.size();
@@ -585,7 +585,7 @@ public:
     uxchg(&hdr->ready, 1);
   
     // now make this pqueue config
-    ShQueueData* sqd = reinterpret_cast<ShQueueData*>(mem + metaLen);
+    auto* sqd = reinterpret_cast<ShQueueData*>(mem + metaLen);
   
     this->shmname = shmname;
     this->shmfd   = shfd;
@@ -637,7 +637,7 @@ public:
   
   uint8_t* pollNext() {
     if (PRIV_HSTORE_UNLIKELY(*readIndex() == nextIndex(writeIndex()))) {
-      return 0;
+      return nullptr;
     } else {
       return value(*writeIndex());
     }
@@ -701,11 +701,11 @@ private:
       markPage(PRIV_HSTORE_PAGE_STATE_TENTATIVE);
       this->wq->push();
       uint8_t* npage = this->wq->pollNext();
-      markPage(npage ? PRIV_HSTORE_PAGE_STATE_CONT : PRIV_HSTORE_PAGE_STATE_ROLLBACK);
+      markPage(npage != nullptr ? PRIV_HSTORE_PAGE_STATE_CONT : PRIV_HSTORE_PAGE_STATE_ROLLBACK);
 
       this->page   = npage;
       this->offset = 0;
-      return npage;
+      return npage != nullptr;
     }
   }
 public:
@@ -722,14 +722,14 @@ public:
       this->wq->push();
       this->page = this->wq->next(this->timeoutNS, this->timeoutF);
     } else {
-      if (PRIV_HSTORE_LIKELY(this->page != 0)) {
+      if (PRIV_HSTORE_LIKELY(this->page != nullptr)) {
         markPage(PRIV_HSTORE_PAGE_STATE_COMMIT);
         this->wq->push();
       }
       this->page = this->wq->pollNext();
 
       // allow unreliable producers to process timeout events
-      if (PRIV_HSTORE_UNLIKELY(this->page == 0)) {
+      if (PRIV_HSTORE_UNLIKELY(this->page == nullptr)) {
         if (this->unrtimeNS == 0) {
           this->unrtimeNS = internal::spin::poll_tickNS();
         } else if (internal::spin::poll_tickNS() - this->unrtimeNS >= this->timeoutNS) {
@@ -742,7 +742,7 @@ public:
   }
 
   void rollback() {
-    if (PRIV_HSTORE_LIKELY(this->page != 0)) {
+    if (PRIV_HSTORE_LIKELY(this->page != nullptr)) {
       markPage(PRIV_HSTORE_PAGE_STATE_ROLLBACK);
       this->wq->push();
     }
@@ -751,7 +751,7 @@ public:
   }
 
   bool hasSpaceFor(size_t sz) const {
-    return this->page && sz < (this->pagesz - this->offset);
+    return (this->page != nullptr) && sz < (this->pagesz - this->offset);
   }
 
   // write a block of bytes within a frame
@@ -783,7 +783,7 @@ public:
       this->offset = this->pagesz;
       so += this->pagesz;
     }
-    if (!this->page) {
+    if (this->page == nullptr) {
       return false;
     } else {
       if (so < sz) {
@@ -828,13 +828,13 @@ inline QueueConnection consumeQueue(const std::string& shmname) {
   }
 
   // map memory for this data, ensure it is in a good state
-  uint8_t* mem = reinterpret_cast<uint8_t*>(mmap(0, msb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, shfd, 0));
+  auto* mem = reinterpret_cast<uint8_t*>(mmap(nullptr, msb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, shfd, 0));
   if (mem == MAP_FAILED) {
     close(shfd);
     throw std::runtime_error("Failed to map bytes out of shared memory for '" + shmname + "': " + strerror(errno));
   }
 
-  if (!reinterpret_cast<ShQueueHeader*>(mem)->ready) {
+  if (reinterpret_cast<ShQueueHeader*>(mem)->ready == 0u) {
     munmap(mem, msb.st_size);
     close(shfd);
     throw std::runtime_error("Not ready to consume shared memory for '" + shmname + "'");
@@ -871,9 +871,9 @@ private:
 public:
   reader(const QueueConnection& qc, const WaitPolicy wp) : shfd(qc.shfd), waitFn(hobbes::storage::waitFn(wp)), wakeFn(hobbes::storage::wakeFn(wp)) {
     // prepare to read the queue description
-    ShQueueHeader* hdr     = reinterpret_cast<ShQueueHeader*>(qc.data);
-    size_t         metaLen = align<size_t>(sizeof(ShQueueHeader) + hdr->metasz, qc.pagesz);
-    ShQueueData*   sqd     = reinterpret_cast<ShQueueData*>(qc.data + metaLen);
+    auto* hdr     = reinterpret_cast<ShQueueHeader*>(qc.data);
+    auto         metaLen = align<size_t>(sizeof(ShQueueHeader) + hdr->metasz, qc.pagesz);
+    auto*   sqd     = reinterpret_cast<ShQueueData*>(qc.data + metaLen);
 
     // now we should have enough to read out of this queue
     this->metad           = qc.data + sizeof(ShQueueHeader);
@@ -893,7 +893,7 @@ public:
   inline const pqueue_config& config() const { return this->cfg; }
 
   // access queue init data; (null,0) if no data was specified
-  typedef std::pair<const uint8_t*, size_t> MetaData;
+  using MetaData = std::pair<const uint8_t *, size_t>;
   MetaData meta() const {
     return MetaData(this->metad, this->metasz);
   }
@@ -939,7 +939,7 @@ public:
   // get the next value in the queue if one is present, else null
   uint8_t* pollNext() {
     if (PRIV_HSTORE_UNLIKELY(*writeIndex() == *readIndex())) {
-      return 0;
+      return nullptr;
     } else {
       return value(*readIndex());
     }
@@ -964,7 +964,7 @@ private:
   size_t         pagesz;
   uint32_t       offset;
 public:
-  rpipe(reader* rq) : rq(rq), page(0), pagesz(rq->config().valuesz - sizeof(uint32_t)), offset(0) {
+  rpipe(reader* rq) : rq(rq), page(nullptr), pagesz(rq->config().valuesz - sizeof(uint32_t)), offset(0) {
     if (rq->config().valuesz <= sizeof(uint32_t)) {
       throw std::runtime_error("queue page size too small for use as shared memory pipe");
     }
@@ -972,13 +972,13 @@ public:
 
   // read a range of bytes out of the 'pipe' into a user-supplied buffer
   size_t read(uint8_t* dst, size_t sz, uint8_t* state, size_t timeoutNS, const std::function<void()>& timeoutF) {
-    if (!this->page) {
+    if (this->page == nullptr) {
       this->page = this->rq->next(timeoutNS, timeoutF);
     }
   
     size_t doff = 0;
   
-    while (sz != 0 && this->page) {
+    while (sz != 0 && (this->page != nullptr)) {
       // how much can we copy out of the current page into the dest buffer?
       const volatile uint32_t* pend      = reinterpret_cast<const uint32_t*>(this->page + this->pagesz);
       size_t                   rpagesz   = *pend & ~(0xFF << 24);
@@ -998,12 +998,12 @@ public:
         // wait for the producer to decide what state the page is in
         while ((*pend >> 24) == PRIV_HSTORE_PAGE_STATE_TENTATIVE);
         uint8_t ps = *pend >> 24;
-        if (state) *state = ps;
+        if (state != nullptr) *state = ps;
 
         // if this page is just a continuation, continue reading
         // else we've terminated a transaction
         this->rq->pop();
-        this->page   = (ps == PRIV_HSTORE_PAGE_STATE_CONT) ? this->rq->pollNext() : 0;
+        this->page   = (ps == PRIV_HSTORE_PAGE_STATE_CONT) ? this->rq->pollNext() : nullptr;
         this->offset = 0;
       }
     }
@@ -1199,9 +1199,9 @@ template <typename T>
 // a generic method to write tuples as a last resort
 template <size_t i, size_t n, typename ... Ts>
   struct storeTupleDef {
-    typedef typename nth<i, Ts...>::type H;
-    typedef typename tuple<Ts...>::offs  offs;
-    typedef storeTupleDef<i+1, n, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using offs = typename tuple<Ts...>::offs;
+    using Recurse = storeTupleDef<i + 1, n, Ts...>;
 
     static void fieldDefs(ty::Struct::Fields* fs) {
       fs->push_back(ty::Struct::Field(".f" + hobbes::string::from(i), static_cast<int>(offsetAt<i, offs>::value), store<H>::type()));
@@ -1261,7 +1261,7 @@ template <typename ... Ts>
 template <typename ... Ts>
   struct storeStdLayoutTuple<tuple<Ts...>, typename tbool<(!tuple<Ts...>::packed && !tuple<Ts...>::offs::packed) || !all_memcpyableFs<Ts...>::value>::type> {
     static const bool can_memcpy = false;
-    typedef storeTupleDef<0, sizeof...(Ts), Ts...> Reflect;
+    using Reflect = storeTupleDef<0, sizeof...(Ts), Ts...>;
     static ty::desc type()                                 { return Reflect::type(); }
     static size_t   size(const tuple<Ts...>& t)            { return Reflect::size(t); }
     static bool     write(wpipe& p, const tuple<Ts...>& t) { return Reflect::incrWrite(p, t); }
@@ -1324,14 +1324,14 @@ template <typename T> struct member;
 
 template <typename T, typename F>
   struct member<F T::*> {
-    typedef F type;
-    typedef F T::* Acc;
+    using type = F;
+    using Acc = F T::*;
     static const F& read(const T& x, Acc a) { return x.*a; }
   };
 template <typename T, typename F>
   struct member<F (T::*)() const> {
-    typedef F type;
-    typedef F (T::*Acc)() const;
+    using type = F;
+    using Acc = F (T::*)() const;
     static F read(const T& x, Acc a) { return (x.*a)(); }
   };
 
@@ -1413,8 +1413,8 @@ template <typename T>
 // store variants
 template <size_t i, size_t n, typename ... Ts>
   struct storeVariantDef {
-    typedef typename nth<i, Ts...>::type   H;
-    typedef storeVariantDef<i+1, n, Ts...> Recurse;
+    using H = typename nth<i, Ts...>::type;
+    using Recurse = storeVariantDef<i + 1, n, Ts...>;
 
     static void ctorDefs(ty::Variant::Ctors* cs) {
       cs->push_back(ty::Variant::Ctor(".f" + hobbes::string::from(i), static_cast<int>(i), store<H>::type()));
@@ -1466,7 +1466,7 @@ struct descVariantF {
 
 template <typename T>
   struct store<T, typename tbool<T::is_hmeta_variant>::type> {
-    typedef typename T::as_variant_type VT;
+    using VT = typename T::as_variant_type;
     static const bool can_memcpy = store<VT>::can_memcpy;
 
     static ty::desc type() {
@@ -1488,7 +1488,7 @@ struct recursion {
 
 template <typename T>
   struct recursive {
-    typedef T value_type;
+    using value_type = T;
     value_type value;
     recursive(const value_type& x) : value(x) { }
   };
@@ -1499,18 +1499,18 @@ template <>
       return ty::var("x");
     }
 
-    typedef size_t (*RecSizeF)(const recursion&);
+    using RecSizeF = size_t (*)(const recursion &);
     static RecSizeF& sizeF() {
-      thread_local RecSizeF fn = 0;
+      thread_local RecSizeF fn = nullptr;
       return fn;
     }
     static size_t size(const recursion& x) {
       return sizeF()(x);
     }
 
-    typedef bool (*RecWriteF)(wpipe&, const recursion&);
+    using RecWriteF = bool (*)(wpipe &, const recursion &);
     static RecWriteF& writeF() {
-      thread_local RecWriteF fn = 0;
+      thread_local RecWriteF fn = nullptr;
       return fn;
     }
     static bool write(wpipe& p, const recursion& x) {
@@ -1527,7 +1527,7 @@ template <typename T>
       return size(*reinterpret_cast<const recursive<T>*>(x.value));
     }
     static size_t size(const recursive<T>& x) {
-      typedef typename store<recursion>::RecSizeF RSF;
+      using RSF = typename store<recursion>::RecSizeF;
       RSF sf = store<recursion>::sizeF();
       store<recursion>::sizeF() = &store<recursive<T>>::recSize;
       size_t r = store<T>::size(x.value);
@@ -1539,7 +1539,7 @@ template <typename T>
       return write(p, *reinterpret_cast<const recursive<T>*>(x.value));
     }
     static bool write(wpipe& p, const recursive<T>& x) {
-      typedef typename store<recursion>::RecWriteF RWF;
+      using RWF = typename store<recursion>::RecWriteF;
       RWF sf = store<recursion>::writeF();
       store<recursion>::writeF() = &store<recursive<T>>::recWrite;
       bool r = store<T>::write(p, x.value);
@@ -1551,7 +1551,7 @@ template <typename T>
 // store opaque type aliases
 template <typename T>
   struct store<T, typename tbool<T::is_hmeta_alias>::type> {
-    typedef typename T::type RT;
+    using RT = typename T::type;
     static const bool can_memcpy = store<RT>::can_memcpy;
 
     static ty::desc type ()                     { return ty::prim(T::name(), store<RT>::type()); ; }
@@ -1576,7 +1576,7 @@ template <typename F, typename T>
 #define HNAME(N,E) ::hobbes::storage::namedValue<PRIV_HPPF_TSTR(#N),decltype(E)>(E)
 
 // allow inference of log statement names from payload types
-typedef void (*tynamehints)(std::vector<std::string>*);
+using tynamehints = void (*)(std::vector<std::string> *);
 template <typename T>
   struct nameAt {
     template <typename U, std::string (*P)()> struct HasStorageName { };
@@ -1588,7 +1588,7 @@ template <typename T>
   struct storeNames {
     static void accum(std::vector<std::string>* ns) {
       std::string n = nameAt<T>::template is<store<T>>(0);
-      if (n.size() > 0) {
+      if (!n.empty()) {
         ns->push_back(n);
       }
     }
@@ -1612,7 +1612,7 @@ template <typename F, typename T>
 
 template <typename ... Ts>
   struct hstore_payload_types {
-    typedef unit head_type;
+    using head_type = unit;
     static const size_t count = 0;
     static const bool isTuple = true;
     static void fields(const char*,size_t,ty::Struct::Fields*) {}
@@ -1620,7 +1620,7 @@ template <typename ... Ts>
   };
 template <typename T, typename ... Ts>
   struct hstore_payload_types<T,Ts...> {
-    typedef T head_type;
+    using head_type = T;
     static const size_t count = 1 + hstore_payload_types<Ts...>::count;
     static const bool isTuple = hstore_argl_name<T>::isTuple && hstore_payload_types<Ts...>::isTuple;
     static void fields(const char* fmt, size_t f, ty::Struct::Fields* fs) {
@@ -1640,7 +1640,7 @@ template <typename ... Ts>
     return hstore_payload_types<Ts...>();
   }
 
-typedef void (*tydescfn)(bytes*,std::string*);
+using tydescfn = void (*)(bytes *, std::string *);
 template <typename TyList>
   void makeTyDescF(bytes* e, std::string* d) {
     ty::desc td;
@@ -1689,7 +1689,7 @@ struct StorageGroup {
     uint32_t    line;
     uint32_t    id;
   };
-  typedef std::map<std::string, StmtData> StorageStatements;
+  using StorageStatements = std::map<std::string, StmtData>;
 
   StorageStatements* statements;
   PipeQOS            qos;
@@ -1811,7 +1811,7 @@ struct StorageGroup {
       std::string n;
       std::vector<std::string> ns;
       tnhints(&ns);
-      if (ns.size() == 0) {
+      if (ns.empty()) {
         n = x.substr(5);
       } else {
         std::ostringstream nss;
@@ -1839,7 +1839,7 @@ struct StorageGroup {
     return fnss.str();
   }
 
-  uint32_t addStatement(const std::string file, uint32_t line, const std::string& name, size_t flags, const std::string& fmtstr, tydescfn tdesc) {
+  uint32_t addStatement(const std::string& file, uint32_t line, const std::string& name, size_t flags, const std::string& fmtstr, tydescfn tdesc) {
     if (this->statements->find(name) != this->statements->end()) {
       std::cerr
         << "fatal error: duplicate log name in use (" << name << ")"
@@ -1872,14 +1872,14 @@ struct StorageGroup {
       // make sure that all identifying parameters are consistent
       bytes ety, xty;
       s->second.tdesc(&ety,0);
-      tdesc(&xty,0);
+      tdesc(&xty,nullptr);
       if (ety != xty) {
         if (isAutoName(namet)) {
           return addStatement(file, line, incrAutoName(name), flags, fmtstr, tdesc);
         } else {
           std::string etd, xtd;
           s->second.tdesc(0,&etd);
-          tdesc(0,&xtd);
+          tdesc(nullptr,&xtd);
 
           std::cerr
             << "fatal error: incompatible types for store statement '" << name << "' between:\n"
@@ -1930,7 +1930,7 @@ struct StorageGroup {
   }
 };
 template <typename Name, CommitMethod cm>
-  thread_local wpipe* StorageGroup<Name, cm>::pipe = 0;
+  thread_local wpipe* StorageGroup<Name, cm>::pipe = nullptr;
 template <typename Name, CommitMethod cm>
   std::vector<ProcThread> StorageGroup<Name, cm>::pts;
 
@@ -2029,7 +2029,7 @@ struct statement {
            this->type   == rhs.type;
   }
 };
-typedef std::vector<statement> statements;
+using statements = std::vector<statement>;
 
 inline size_t rs(const reader::MetaData& md, size_t o, size_t n, uint8_t* b) {
   if (o + n <= md.second) {
@@ -2062,14 +2062,11 @@ inline size_t rs(const reader::MetaData& md, size_t o, bytes* s) {
 class Transaction {
 public:
   // a persistent transaction to retain log data between consumer sessions (if necessary)
-  Transaction(std::string fname) : fd(-1), file_size(0), map_size(0), data(0), data_size(0), wi(0), ri(0) {
-    for (size_t i = 0; i < fname.size(); ++i) {
-      switch (fname[i]) {
-      case '/': fname[i]='_'; break;
-      case ':': fname[i]='_'; break;
-      case '[': fname[i]='_'; break;
-      case ']': fname[i]='_'; break;
-      default:                break;
+  Transaction(std::string fname) : fd(-1), file_size(0), map_size(0), data(nullptr), data_size(nullptr), wi(0), ri(0) {
+    for (char &i : fname) {
+      switch (i) {
+      case '/': case ':': case '[': case ']': i='_'; break;
+      default: break;
       }
     }
     fname = "." + fname + ".txn";
@@ -2088,7 +2085,7 @@ public:
   }
 
   // a non-persistent transaction over constant data (just used by remote consumers)
-  Transaction(const uint8_t* d, size_t len) : fd(-1), file_size(len), map_size(len), data(const_cast<uint8_t*>(d)), data_size(0), wi(0), ri(0) {
+  Transaction(const uint8_t* d, size_t len) : fd(-1), file_size(len), map_size(len), data(const_cast<uint8_t*>(d)), data_size(nullptr), wi(0), ri(0) {
     this->data_size = &this->map_size;
   }
 
@@ -2106,7 +2103,7 @@ public:
 
   template <typename T>
     const T* read() {
-      auto p = reinterpret_cast<const T*>(ptr());
+      const auto *p = reinterpret_cast<const T*>(ptr());
       skip(sizeof(T));
       return p;
     }
@@ -2166,10 +2163,10 @@ private:
     this->file_size = sz;
 
     if (sz > this->map_size) {
-      if (this->data) { ::munmap(this->data-sizeof(size_t), this->map_size); }
+      if (this->data != nullptr) { ::munmap(this->data-sizeof(size_t), this->map_size); }
 
       this->map_size = align<size_t>(sz, /*10MB*/10485760);
-      this->data = reinterpret_cast<uint8_t*>(mmap(0, this->map_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, this->fd, 0));
+      this->data = reinterpret_cast<uint8_t*>(mmap(nullptr, this->map_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, this->fd, 0));
       if (this->data == MAP_FAILED) {
         throw std::runtime_error("Failed to map transaction persistence file");
       }
diff --git a/include/hobbes/util/array.H b/include/hobbes/util/array.H
index 329b96459..916da009f 100644
--- a/include/hobbes/util/array.H
+++ b/include/hobbes/util/array.H
@@ -2,23 +2,23 @@
 #ifndef HOBBES_UTIL_ARRAY_HPP_INCLUDED
 #define HOBBES_UTIL_ARRAY_HPP_INCLUDED
 
-#include <map>
-#include <set>
-#include <vector>
-#include <stdexcept>
 #include <algorithm>
+#include <cstring>
 #include <functional>
+#include <map>
+#include <set>
 #include <sstream>
-#include <string.h>
+#include <stdexcept>
+#include <vector>
 
 namespace hobbes {
 
 // a unit value, since C++ doesn't handle 'void' correctly
-typedef unsigned char UnitV;
+using UnitV = unsigned char;
 static const UnitV unitv = 0x00;
 
 // byte sequences, a common type of array
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 // shorthand for list construction (maybe not necessary with C++ initializer lists)
 template <typename T>
@@ -51,7 +51,7 @@ template <typename T>
 // x in (xs :: vector T)
 template <typename T>
   bool in(T x, const std::vector<T>& xs) {
-    for (typename std::vector<T>::const_iterator xi = xs.begin(); xi != xs.end(); ++xi) {
+    for (auto xi = xs.begin(); xi != xs.end(); ++xi) {
       if (*xi == x) {
         return true;
       }
@@ -69,7 +69,7 @@ template <typename T>
 
     std::ostringstream ss;
     ss << x << " not in [";
-    if (xs.size() > 0) {
+    if (!xs.empty()) {
       ss << xs[0];
       for (size_t i = 1; i < xs.size(); ++i) {
         ss << ", " << xs[i];
@@ -105,7 +105,7 @@ template <typename T, typename I>
 template <typename T, typename I>
   std::vector<T> select(const std::vector<T>& xs, const std::vector<I>& is) {
     std::vector<T> r;
-    for (typename std::vector<I>::const_iterator i = is.begin(); i != is.end(); ++i) {
+    for (auto i = is.begin(); i != is.end(); ++i) {
       r.push_back(select(xs, *i));
     }
     return r;
@@ -134,7 +134,7 @@ template <typename K, typename V>
 template <typename K, typename V>
   std::map<K, V> drop(const std::map<K, V>& m, const std::set<K>& ks) {
     std::map<K, V> result;
-    for (typename std::map<K,V>::const_iterator p = m.begin(); p != m.end(); ++p) {
+    for (auto p = m.begin(); p != m.end(); ++p) {
       if (ks.find(p->first) == ks.end()) {
         result[p->first] = p->second;
       }
@@ -150,7 +150,7 @@ template <typename T>
 template <typename CT>
   std::set<typename CT::value_type> toSet(const CT& xs) {
     std::set<typename CT::value_type> r;
-    for (auto x : xs) {
+    for (const auto& x : xs) {
       r.insert(x);
     }
     return r;
@@ -175,7 +175,7 @@ template <typename T>
 template <typename T>
   std::set<T> setUnion(const std::vector< std::set<T> >& ss) {
     std::set<T> r;
-    for (typename std::vector< std::set<T> >::const_iterator s = ss.begin(); s != ss.end(); ++s) {
+    for (auto s = ss.begin(); s != ss.end(); ++s) {
       r.insert(s->begin(), s->end());
     }
     return r;
@@ -198,7 +198,7 @@ template <typename T>
 template <typename K, typename V>
   std::set<K> keys(const std::map<K, V>& m) {
     std::set<K> r;
-    for (typename std::map<K, V>::const_iterator kv = m.begin(); kv != m.end(); ++kv) {
+    for (auto kv = m.begin(); kv != m.end(); ++kv) {
       r.insert(kv->first);
     }
     return r;
@@ -208,7 +208,7 @@ template <typename L, typename R>
   std::vector<L> first(const std::vector< std::pair<L, R> >& xs) {
     std::vector<L> result;
     result.reserve(xs.size());
-    for (typename std::vector< std::pair<L, R> >::const_iterator x = xs.begin(); x != xs.end(); ++x) {
+    for (auto x = xs.begin(); x != xs.end(); ++x) {
       result.push_back(x->first);
     }
     return result;
@@ -228,7 +228,7 @@ template <typename L, typename R>
   std::vector<R> second(const std::vector< std::pair<L, R> >& xs) {
     std::vector<R> result;
     result.reserve(xs.size());
-    for (typename std::vector< std::pair<L, R> >::const_iterator x = xs.begin(); x != xs.end(); ++x) {
+    for (auto x = xs.begin(); x != xs.end(); ++x) {
       result.push_back(x->second);
     }
     return result;
@@ -313,7 +313,7 @@ template <typename T>
 // basic bit-packed 2D bool array (maybe there's already something that does this job?)
 class bit_table {
 public:
-  inline bit_table() : data(0), rowc(0), colc(0) {
+  inline bit_table() : data(nullptr), rowc(0), colc(0) {
   }
   inline bit_table(size_t rowc, size_t colc, bool s) : rowc(rowc), colc(colc) {
     size_t msz = 1+((rowc*colc)/8);
diff --git a/include/hobbes/util/autorelease.H b/include/hobbes/util/autorelease.H
index 531607b89..32c3284a2 100644
--- a/include/hobbes/util/autorelease.H
+++ b/include/hobbes/util/autorelease.H
@@ -8,8 +8,8 @@ namespace hobbes {
 
 // simplify automatic destruction within bison parsers
 struct AutoreleaseSet {
-  typedef void (*presetfn)();
-  typedef std::vector<presetfn> ResetFns;
+  using presetfn = void (*)();
+  using ResetFns = std::vector<presetfn>;
 
   static ResetFns& resetFns() {
     thread_local ResetFns rs;
@@ -24,15 +24,15 @@ struct AutoreleaseSet {
 
   static void reset() {
     ResetFns& rfs = resetFns();
-    for (ResetFns::const_iterator f = rfs.begin(); f != rfs.end(); ++f) {
-      (*f)();
+    for (auto rf : rfs) {
+      rf();
     }
   }
 };
 
 template <typename T>
   struct Autorelease {
-    typedef std::vector<T*> Vals;
+    using Vals = std::vector<T *>;
     static Vals& vals() {
       thread_local Vals vs;
       return vs;
@@ -40,7 +40,7 @@ template <typename T>
 
     static void reset() {
       Vals& vs = vals();
-      for (typename Vals::iterator i = vs.begin(); i != vs.end(); ++i) {
+      for (auto i = vs.begin(); i != vs.end(); ++i) {
         delete *i;
       }
       vs.clear();
diff --git a/include/hobbes/util/codec.H b/include/hobbes/util/codec.H
index 8b931e033..3b1cfd17a 100644
--- a/include/hobbes/util/codec.H
+++ b/include/hobbes/util/codec.H
@@ -2,15 +2,15 @@
 #ifndef HOBBES_UTIL_CODEC_HPP_INCLUDED
 #define HOBBES_UTIL_CODEC_HPP_INCLUDED
 
+#include <cstring>
 #include <iostream>
-#include <vector>
 #include <map>
 #include <unistd.h>
-#include <string.h>
+#include <vector>
 
 namespace hobbes {
 
-typedef __int128 int128_t;
+using int128_t = __int128;
 
 #define PRIM_CODEC(T) \
   inline void encode(T x, std::ostream& out) { out.write(reinterpret_cast<const char*>(&x), sizeof(x)); } \
@@ -43,7 +43,7 @@ inline void decode(std::string* x, std::istream& in) {
 template <typename T>
   inline void encode(const std::vector<T>& xs, std::ostream& out) {
     encode(static_cast<size_t>(xs.size()), out);
-    for (auto x : xs) {
+    for (const auto& x : xs) {
       encode(x, out);
     }
   }
@@ -75,7 +75,7 @@ template <typename U, typename V>
 template <typename K, typename V>
   inline void encode(const std::map<K, V>& m, std::ostream& out) {
     encode(m.size(), out);
-    for (auto p : m) {
+    for (const auto& p : m) {
       encode(p, out);
     }
   }
@@ -195,7 +195,7 @@ inline void fdwrite(int fd, const std::string& x) {
 template <typename T>
 inline void fdwrite(int fd, const std::vector<T>& xs) {
   fdwrite(fd, xs.size());
-  if (xs.size() > 0) fdwrite(fd, &xs[0], xs.size());
+  if (!xs.empty()) fdwrite(fd, &xs[0], xs.size());
 }
 
 // remove a 'bad' mark for an FD and return true iff it was previously marked bad
diff --git a/include/hobbes/util/func.H b/include/hobbes/util/func.H
index 869665225..db1290cb3 100644
--- a/include/hobbes/util/func.H
+++ b/include/hobbes/util/func.H
@@ -10,21 +10,21 @@ template <typename T> struct func {};
 
 template <typename R, typename... Args> struct func<R(Args...)> {
   static const std::size_t arity = sizeof...(Args);
-  typedef R (*type)(Args...);
-  typedef R result_type;
+  using type = R (*)(Args...);
+  using result_type = R;
 };
 
 template <typename R, typename... Args> struct func<R (*)(Args...)> {
   static const std::size_t arity = sizeof...(Args);
-  typedef R (*type)(Args...);
-  typedef R result_type;
+  using type = R (*)(Args...);
+  using result_type = R;
 };
 
 template <typename R, typename C, typename... Args>
 struct func<R (C::*)(Args...)> {
   static const std::size_t arity = sizeof...(Args);
-  typedef R (*type)(C *, Args...);
-  typedef R result_type;
+  using type = R (*)(C *, Args...);
+  using result_type = R;
 };
 
 template <typename T> struct mfnTraits {};
@@ -32,15 +32,15 @@ template <typename T> struct mfnTraits {};
 template <typename R, typename C, typename... Args>
 struct mfnTraits<R (C::*)(Args...) const> {
   static const int arity = sizeof...(Args);
-  typedef R result_type;
-  typedef C class_type;
+  using result_type = R;
+  using class_type = C;
 };
 
 template <typename R, typename C, typename... Args>
 struct mfnTraits<R (C::*)(Args...)> {
   static const int arity = sizeof...(Args);
-  typedef R result_type;
-  typedef C class_type;
+  using result_type = R;
+  using class_type = C;
 };
 
 template <typename T> struct boolSafeFn : public func<T> {
diff --git a/include/hobbes/util/lannotation.H b/include/hobbes/util/lannotation.H
index e3efec16d..cd92b3167 100644
--- a/include/hobbes/util/lannotation.H
+++ b/include/hobbes/util/lannotation.H
@@ -14,10 +14,10 @@
 
 namespace hobbes {
 
-typedef std::pair<bool, std::string>    BuffOrFilename;
-typedef std::shared_ptr<BuffOrFilename> BuffOrFilenamePtr;
-typedef std::pair<size_t, size_t>       Pos; // line#, offset
-typedef std::pair<Pos, Pos>             LexRange;
+using BuffOrFilename = std::pair<bool, std::string>;
+using BuffOrFilenamePtr = std::shared_ptr<BuffOrFilename>;
+using Pos = std::pair<size_t, size_t>; // line#, offset
+using LexRange = std::pair<Pos, Pos>;
 
 struct LexicalAnnotation {
   LexicalAnnotation();
@@ -35,6 +35,8 @@ struct LexicalAnnotation {
 
 class LexicallyAnnotated {
 public:
+  LexicallyAnnotated() = delete;
+
   LexicallyAnnotated(const LexicallyAnnotated&);
   LexicallyAnnotated(const LexicalAnnotation&);
   LexicallyAnnotated(const LexRange&);
@@ -50,12 +52,10 @@ public:
   static LexicalAnnotation make(const Pos&, const Pos&);
 private:
   LexicalAnnotation lannotation;
-
-  LexicallyAnnotated();
 };
 
-typedef std::pair<std::string, LexicalAnnotation> annmsg;
-typedef std::vector<annmsg>                       annmsgs;
+using annmsg = std::pair<std::string, LexicalAnnotation>;
+using annmsgs = std::vector<annmsg>;
 
 class annotated_error : public std::runtime_error {
 public:
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index 70f58688f..7828c1ca8 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -65,7 +65,7 @@
 
 namespace hobbes {
 
-typedef __int128 int128_t;
+using int128_t = __int128;
 
 
 #if LLVM_VERSION_MAJOR >= 11
@@ -79,9 +79,9 @@ template <typename Fn> auto withContext(Fn fn) -> decltype(auto) {
   return fn(*threadSafeContext().getContext());
 }
 
-typedef std::vector<llvm::Type*>     Types;
-typedef std::vector<llvm::Constant*> Constants;
-typedef std::vector<llvm::Value*>    Values;
+using Types = std::vector<llvm::Type *>;
+using Constants = std::vector<llvm::Constant *>;
+using Values = std::vector<llvm::Value *>;
 
 // type utilities
 inline llvm::Type* voidType() {
@@ -476,11 +476,11 @@ inline llvm::ConstantInt* civalue(int128_t x) {
 
 #endif
 // an intermediate representation for records
-typedef std::pair<std::string, llvm::Value*> FieldValue;
-typedef std::vector<FieldValue>              RecordValue;
+using FieldValue = std::pair<std::string, llvm::Value *>;
+using RecordValue = std::vector<FieldValue>;
 
-typedef std::pair<std::string, llvm::Constant*> ConstFieldValue;
-typedef std::vector<ConstFieldValue>            ConstRecordValue;
+using ConstFieldValue = std::pair<std::string, llvm::Constant *>;
+using ConstRecordValue = std::vector<ConstFieldValue>;
 
 // add any standard settings to global variables that we need
 inline llvm::GlobalVariable* prepgv(llvm::GlobalVariable* gv, unsigned int align = sizeof(void*)) {
@@ -495,20 +495,20 @@ inline llvm::GlobalVariable* prepgv(llvm::GlobalVariable* gv, unsigned int align
 // constant :: Value -> Bool -> Const
 //   try to extract a constant from a value (either by value or reference)
 inline llvm::Constant* constant(llvm::Value* v, bool globalPtrRefs) {
-  if (llvm::GlobalVariable* gv = llvm::dyn_cast<llvm::GlobalVariable>(v)) {
+  if (auto* gv = llvm::dyn_cast<llvm::GlobalVariable>(v)) {
     if (gv->isConstant()) {
       if (globalPtrRefs) {
         return gv;
       } else {
-        return gv->hasInitializer() ? gv->getInitializer() : 0;
+        return gv->hasInitializer() ? gv->getInitializer() : nullptr;
       }
     } else {
-      return 0;
+      return nullptr;
     }
-  } else if (llvm::Constant* c = llvm::dyn_cast<llvm::Constant>(v)) {
+  } else if (auto* c = llvm::dyn_cast<llvm::Constant>(v)) {
     return c;
   } else {
-    return 0;
+    return nullptr;
   }
 }
 
@@ -529,8 +529,8 @@ inline llvm::Constant* liftAsGlobalRef(llvm::Module* m, llvm::Constant* c) {
 //   try to extract constants from a set of compiled values -- if even one value is not constant, fail by returning an empty list
 inline Constants varArrayConstants(const Values& vs, bool globalPtrRefs) {
   Constants r;
-  for (Values::const_iterator v = vs.begin(); v != vs.end(); ++v) {
-    if (llvm::Constant* c = constant(*v, globalPtrRefs)) {
+  for (auto *v : vs) {
+    if (llvm::Constant* c = constant(v, globalPtrRefs)) {
       r.push_back(c);
     } else {
       return Constants();
@@ -541,7 +541,7 @@ inline Constants varArrayConstants(const Values& vs, bool globalPtrRefs) {
 
 inline Constants liftAsGlobalRefs(llvm::Module* m, const Constants& cs) {
   Constants r;
-  for (auto c : cs) {
+  for (auto *c : cs) {
     r.push_back(liftAsGlobalRef(m, c));
   }
   return r;
@@ -564,7 +564,7 @@ inline llvm::Constant* constArray(llvm::Module* m, const Constants& cs, llvm::Ty
 inline llvm::Value* tryMkConstVarArray(llvm::IRBuilder<>* b, llvm::Module* m, llvm::Type* elemTy, const Values& vs, bool globalPtrRefs) {
   Constants cs = varArrayConstants(vs, globalPtrRefs);
   if (cs.size() != vs.size()) {
-    return 0;
+    return nullptr;
   } else {
     llvm::StructType* saty = varArrayType(elemTy, cs.size());
     llvm::StructType* caty = varArrayType(elemTy);
@@ -608,11 +608,11 @@ inline llvm::Value* memCopy(llvm::IRBuilder<>* b, llvm::Value* dst, uint32_t dst
 inline Constants mergePadding(const Constants& cs, const Record::Members& ms) {
   Constants r;
   size_t i = 0;
-  Record::Members::const_iterator m = ms.begin();
+  auto m = ms.begin();
   while (m != ms.end()) {
     if (m->field[0] == '.' && m->field[1] == 'p') {
       size_t plen = 0;
-      if (FixedArray* fa = is<FixedArray>(m->type)) {
+      if (auto* fa = is<FixedArray>(m->type)) {
         long asz = fa->requireLength();
         plen = asz < 0 ? 0 : static_cast<size_t>(asz);
       } else {
@@ -630,18 +630,18 @@ inline Constants mergePadding(const Constants& cs, const Record::Members& ms) {
 
 inline Types types(const Constants& cs) {
   Types r;
-  for (unsigned int c = 0; c < cs.size(); ++c) {
-    r.push_back(cs[c]->getType());
+  for (auto *c : cs) {
+    r.push_back(c->getType());
   }
   return r;
 }
 
-typedef std::pair<std::vector<std::string>, Values> UnzRecValues;
+using UnzRecValues = std::pair<std::vector<std::string>, Values>;
 
 inline Constants recordUZConstants(const UnzRecValues& rps, const Record* rty) {
   Constants r;
   for (size_t i = 0; i < rps.second.size(); ++i) {
-    if (llvm::Constant* c = constant(rps.second[i], is<Array>(rty->member(rps.first[i])))) { // not pretty ...
+    if (llvm::Constant* c = constant(rps.second[i], is<Array>(rty->member(rps.first[i])) != nullptr)) { // not pretty ...
       r.push_back(c);
     } else {
       return Constants();
@@ -655,7 +655,7 @@ llvm::Type* toLLVM(const MonoTypePtr&, bool);
 inline Constants liftArraysAsGlobals(llvm::Module* m, const Constants& cs, const MonoTypes& tys) {
   Constants r;
   for (size_t i = 0; i < std::min<size_t>(cs.size(), tys.size()); ++i) {
-    if (is<Array>(tys[i])) {
+    if (is<Array>(tys[i]) != nullptr) {
       r.push_back(llvm::ConstantExpr::getBitCast(liftAsGlobalRef(m, cs[i]), toLLVM(tys[i], true)));
     } else {
       r.push_back(cs[i]);
@@ -671,7 +671,7 @@ inline llvm::Constant* constantRecord(llvm::Module*, const Constants& cs, const
 inline llvm::Value* tryMkConstRecord(llvm::IRBuilder<>*, llvm::Module* m, const RecordValue& rv, const Record* rty) {
   Constants crv = recordUZConstants(unzip(rv), rty);
   if (crv.size() != rv.size()) {
-    return 0;
+    return nullptr;
   } else {
     Constants         pcs = mergePadding(crv, rty->alignedMembers());
     llvm::StructType* sty = packedRecordType(types(pcs));
@@ -734,7 +734,7 @@ inline llvm::ExecutionEngine* makeExecutionEngine(llvm::Module* m, llvm::Section
       .setMCJITMemoryManager(std::unique_ptr<llvm::SectionMemoryManager>(smm))
       .create();
 
-  if (!ee) {
+  if (ee == nullptr) {
     throw std::runtime_error("Internal error, failed to allocate execution engine with error: " + err);
   }
   return ee;
diff --git a/include/hobbes/util/perf.H b/include/hobbes/util/perf.H
index 8b1d084e4..8e18eea51 100644
--- a/include/hobbes/util/perf.H
+++ b/include/hobbes/util/perf.H
@@ -2,11 +2,11 @@
 #ifndef HOBBES_UTIL_PERF_HPP_INCLUDED
 #define HOBBES_UTIL_PERF_HPP_INCLUDED
 
+#include <ctime>
 #include <hobbes/util/os.H>
-#include <string>
-#include <sstream>
 #include <iostream>
-#include <time.h>
+#include <sstream>
+#include <string>
 #include <sys/time.h>
 
 namespace hobbes {
@@ -53,7 +53,7 @@ inline std::string describeNanoTime(long x) {
   static const double seconds = 1000*millis;
   static const double minutes = 60*seconds;
 
-  double t = static_cast<double>(x);
+  auto t = static_cast<double>(x);
   std::ostringstream ss;
 
   if ((t / minutes) >= 1) {
@@ -131,7 +131,7 @@ inline unsigned long long rdtsc(void) {
   return x;
 }
 #elif defined(__x86_64__)
-inline unsigned long long rdtsc(void) {
+inline unsigned long long rdtsc() {
   unsigned hi, lo;
   __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
   return static_cast<unsigned long long>(lo)|(static_cast<unsigned long long>(hi)<<32);
diff --git a/include/hobbes/util/ptr.H b/include/hobbes/util/ptr.H
index 4385c2378..e15c7dd86 100644
--- a/include/hobbes/util/ptr.H
+++ b/include/hobbes/util/ptr.H
@@ -16,7 +16,7 @@ namespace hobbes {
 template <typename T, typename ... Args>
   class unique_refc_map {
   public:
-    typedef T object_type;
+    using object_type = T;
 
     const std::shared_ptr<T>& get(const std::function<T*(Args...)>& mk, const Args&... args) {
       std::lock_guard<std::recursive_mutex> lock(mutex);
@@ -31,7 +31,7 @@ template <typename T, typename ... Args>
     size_t compact() {
       size_t c = 0;
       std::lock_guard<std::recursive_mutex> lock(mutex);
-      for (typename Values::iterator v = this->values.begin(); v != this->values.end();) {
+      for (auto v = this->values.begin(); v != this->values.end();) {
         if (v->second.use_count() == 1) {
           v = this->values.erase(v);
           ++c;
@@ -43,7 +43,7 @@ template <typename T, typename ... Args>
     }
   private:
     std::recursive_mutex mutex;
-    typedef std::unordered_map<std::tuple<Args...>, std::shared_ptr<T>, genHash<std::tuple<Args...>>> Values;
+    using Values = std::unordered_map<std::tuple<Args...>, std::shared_ptr<T>, genHash<std::tuple<Args...>>>;
     Values values;
   };
 
@@ -75,7 +75,7 @@ template <size_t i, typename T, typename U, typename ... Ts>
 template <typename ... UniqueRefcMaps>
   class unique_refc_maps {
   private:
-    typedef std::tuple<UniqueRefcMaps...> RefcMaps;
+    using RefcMaps = std::tuple<UniqueRefcMaps...>;
     RefcMaps refcMaps;
   public:
     template <typename T>
@@ -112,7 +112,7 @@ template <typename T, typename S>
     if (s && s->case_id() == T::type_case_id) {
       return rcast<const T*>(s);
     } else {
-      return 0;
+      return nullptr;
     }
   }
 
@@ -121,7 +121,7 @@ template <typename T, typename S>
     if (s && s->case_id() == T::type_case_id) {
       return rcast<T*>(s);
     } else {
-      return 0;
+      return nullptr;
     }
   }
 
diff --git a/include/hobbes/util/rmap.H b/include/hobbes/util/rmap.H
index f14523949..46909d374 100644
--- a/include/hobbes/util/rmap.H
+++ b/include/hobbes/util/rmap.H
@@ -16,8 +16,8 @@ namespace hobbes {
 template <typename K, typename V, typename Ord>
   class range_map {
   public:
-    typedef std::pair<K, K> range;
-    typedef std::vector<range> ranges;
+    using range = std::pair<K, K>;
+    using ranges = std::vector<range>;
 
     // show the state of this range map
     void show(std::ostream& out) const {
@@ -39,7 +39,7 @@ template <typename K, typename V, typename Ord>
       if (i < this->vs.size()) {
         return &this->vs[i];
       } else {
-        return 0;
+        return nullptr;
       }
     }
 
@@ -51,7 +51,7 @@ template <typename K, typename V, typename Ord>
       if (i == j && i < this->vs.size()) {
         return &this->vs[i];
       } else {
-        return 0;
+        return nullptr;
       }
     }
 
@@ -239,7 +239,7 @@ template <typename K, typename V, typename Ord>
       }
     }
 
-    typedef std::vector<std::pair<range, V>> Mapping;
+    using Mapping = std::vector<std::pair<range, V>>;
     Mapping mapping() const {
       Mapping r;
       for (size_t i = 0; i < this->rs.size(); ++i) {
@@ -353,7 +353,7 @@ template <typename K, typename V, typename Ord>
       assert(rangesValid());
     }
   private:
-    typedef std::vector<V> values;
+    using values = std::vector<V>;
     ranges rs;
     values vs;
 
diff --git a/include/hobbes/util/str.H b/include/hobbes/util/str.H
index bd3859ca5..b3bb91ecc 100644
--- a/include/hobbes/util/str.H
+++ b/include/hobbes/util/str.H
@@ -2,30 +2,30 @@
 #ifndef HOBBES_UTIL_STR_HPP_INCLUDED
 #define HOBBES_UTIL_STR_HPP_INCLUDED
 
+#include <cstdlib>
+#include <cxxabi.h>
 #include <hobbes/util/array.H>
-#include <string>
+#include <map>
+#include <set>
 #include <sstream>
+#include <string>
 #include <vector>
-#include <cxxabi.h>
-#include <stdlib.h>
-#include <set>
-#include <map>
 
 namespace hobbes { namespace str {
 
 std::string env(const std::string& varname);
 void env(const std::string& varname, const std::string& value);
 
-typedef std::vector<std::string>  seq;
-typedef std::vector<seq>          seqs;
-typedef std::vector<unsigned int> lengths;
+using seq = std::vector<std::string>;
+using seqs = std::vector<seq>;
+using lengths = std::vector<unsigned int>;
 
 void repeat(unsigned int n, const std::string& s, seq* out);
 seq repeat(unsigned int n, const std::string& s);
 
 template <typename C>
   unsigned int maxSize(unsigned int d, const std::vector<C>& vs) {
-    if (vs.size() == 0) {
+    if (vs.empty()) {
       return d;
     } else {
       unsigned int r = vs[0].size();
@@ -38,7 +38,7 @@ template <typename C>
 
 template <typename C>
   unsigned int minSize(unsigned int d, const std::vector<C>& vs) {
-    if (vs.size() == 0) {
+    if (vs.empty()) {
       return d;
     } else {
       unsigned int r = vs[0].size();
@@ -151,7 +151,7 @@ template <typename Char>
 template <typename Char>
   std::vector< std::basic_string<Char> > trim(const std::vector< std::basic_string<Char> >& ss) {
     std::vector< std::basic_string<Char> > result;
-    for (typename std::vector< std::basic_string<Char> >::const_iterator s = ss.begin(); s != ss.end(); ++s) {
+    for (auto s = ss.begin(); s != ss.end(); ++s) {
       result.push_back(trim<Char>(*s));
     }
     return result;
@@ -183,7 +183,7 @@ template <typename Char>
       return src;
     }
 
-    typedef typename std::basic_string<Char>::size_type SZT;
+    using SZT = typename std::basic_string<Char>::size_type;
     std::basic_string<Char> result;
     SZT                     sz     = src.find(old_substr);
     SZT                     lsz    = 0;
@@ -217,7 +217,7 @@ std::string unescape(const std::string&);
 
 bool endsWith(const std::string& s, const std::string& sfx);
 
-typedef std::pair<std::string, std::string> pair;
+using pair = std::pair<std::string, std::string>;
 
 inline pair trim(const pair& p) {
   return pair(trim(p.first), trim(p.second));
@@ -238,10 +238,10 @@ unsigned int firstFailIndex(bool (*P)(char), const std::string& s);
 std::string cdelim(const seq& ss, const std::string& d);
 
 // common containers for strings
-typedef std::set<std::string> set;
+using set = std::set<std::string>;
 std::string show(const set&);
 
-typedef std::map<std::string, std::string> named_strings;
+using named_strings = std::map<std::string, std::string>;
 std::string show(const named_strings&);
 
 // process a string by 'expanding' embedded variables/expressions and unescaping sequences
diff --git a/include/hobbes/util/stream.H b/include/hobbes/util/stream.H
index 5255475c1..c1679be50 100644
--- a/include/hobbes/util/stream.H
+++ b/include/hobbes/util/stream.H
@@ -7,21 +7,21 @@
 
 namespace hobbes { namespace stream {
 
-typedef std::vector<uint8_t> RawData;
+using RawData = std::vector<uint8_t>;
 
 template < typename Char = char, typename Traits = std::char_traits<Char> >
   class raw_ostream_buffer : public std::basic_streambuf<Char, Traits> {
   public:
-    typedef std::basic_streambuf<Char, Traits> BaseT;
-    typedef typename BaseT::int_type  int_type;
-    typedef typename BaseT::char_type char_type;
+    using BaseT = std::basic_streambuf<Char, Traits>;
+    using int_type = typename BaseT::int_type;
+    using char_type = typename BaseT::char_type;
 
     raw_ostream_buffer(RawData* d) : d(d) {
     }
   private:
     RawData* d;
 
-    int_type overflow(int_type c) {
+    int_type overflow(int_type c) override {
       if (c != Traits::eof()) {
         d->push_back(static_cast<uint8_t>(Traits::to_char_type(c)));
       }
@@ -32,24 +32,24 @@ template < typename Char = char, typename Traits = std::char_traits<Char> >
 template < typename Char = char, typename Traits = std::char_traits<Char> >
   class raw_ostream : public std::basic_ostream<Char, Traits> {
   public:
+    raw_ostream() = delete;
+    raw_ostream(const raw_ostream<Char, Traits>&) = delete;
+    raw_ostream<Char, Traits>& operator=(const raw_ostream<Char,Traits>&) = delete;
+
     raw_ostream(RawData* d) : std::basic_ostream<Char, Traits>(&buffer), buffer(d) {
     }
   private:
     raw_ostream_buffer<Char, Traits> buffer;
-
-    raw_ostream();
-    raw_ostream(const raw_ostream<Char, Traits>&);
-    raw_ostream<Char, Traits>& operator=(const raw_ostream<Char,Traits>&);
   };
 
 template < typename Char = char, typename Traits = std::char_traits<Char> >
   class raw_istream_buffer : public std::basic_streambuf<Char, Traits> {
   public:
-    typedef std::basic_streambuf<Char, Traits> BaseT;
+    using BaseT = std::basic_streambuf<Char, Traits>;
 
     raw_istream_buffer(const RawData& d) {
-      if (d.size() == 0) {
-        BaseT::setg(0,0,0);
+      if (d.empty()) {
+        BaseT::setg(nullptr,nullptr,nullptr);
       } else {
         Char* b = const_cast<Char*>(reinterpret_cast<const Char*>(&d[0]));
         BaseT::setg(b, b, const_cast<Char*>(reinterpret_cast<const Char*>(&d[0] + d.size())));
@@ -60,14 +60,14 @@ template < typename Char = char, typename Traits = std::char_traits<Char> >
 template < typename Char = char, typename Traits = std::char_traits<Char> >
   class raw_istream : public std::basic_istream<Char, Traits> {
   public:
+    raw_istream() = delete;
+    raw_istream(const raw_istream<Char, Traits>&) = delete;
+    raw_istream<Char, Traits>& operator=(const raw_istream<Char,Traits>&) = delete;
+
     raw_istream(const RawData& d) : std::basic_istream<Char, Traits>(&buffer), buffer(d) {
     }
   private:
     raw_istream_buffer<Char, Traits> buffer;
-
-    raw_istream();
-    raw_istream(const raw_istream<Char, Traits>&);
-    raw_istream<Char, Traits>& operator=(const raw_istream<Char,Traits>&);
   };
 
 }}
diff --git a/include/hobbes/util/time.H b/include/hobbes/util/time.H
index 25204ffb8..6272b96f3 100644
--- a/include/hobbes/util/time.H
+++ b/include/hobbes/util/time.H
@@ -2,11 +2,11 @@
 #ifndef HOBBES_UTIL_TIME_HPP_INCLUDED
 #define HOBBES_UTIL_TIME_HPP_INCLUDED
 
+#include <cstring>
+#include <ctime>
 #include <hobbes/util/str.H>
-#include <string>
-#include <string.h>
 #include <sstream>
-#include <ctime>
+#include <string>
 
 namespace hobbes {
 
@@ -19,7 +19,7 @@ namespace hobbes {
 inline long readTimespan(std::string s) {
   long r = 0;
 
-  while (s.size() > 0) {
+  while (!s.empty()) {
     str::pair p = str::readWhile(&str::isDigit,    s);
     str::pair u = str::readWhile(&str::isNotDigit, p.second);
 
@@ -47,7 +47,7 @@ inline long readTimespan(std::string s) {
 
 inline long readTimespan(const str::seq& ss) {
   long r = 0;
-  for (auto s : ss) {
+  for (const auto& s : ss) {
     r += readTimespan(s);
   }
   return r;
@@ -164,7 +164,7 @@ inline long timeFromDateTime(long x) {
   int64_t us = x % (1000L * 1000L);
   tm*     t  = localtime(reinterpret_cast<time_t*>(&s));
 
-  if (t) {
+  if (t != nullptr) {
     return mkTime(t->tm_hour, t->tm_min, t->tm_sec, us);
   } else {
     return mkTime(0, 0, 0, 0);
diff --git a/include/hobbes/util/trie.H b/include/hobbes/util/trie.H
index 6c186ffc4..ce4383b91 100644
--- a/include/hobbes/util/trie.H
+++ b/include/hobbes/util/trie.H
@@ -12,8 +12,8 @@ namespace hobbes {
 
 template <typename K, typename V, typename KMap>
   struct prefix_tree_node {
-    typedef typename KMap::template map<prefix_tree_node<K, V, KMap>*>::type SubkeyMap;
-    typedef variant<unit, V> MaybeV;
+    using SubkeyMap = typename KMap::template map<prefix_tree_node<K, V, KMap> *>::type;
+    using MaybeV = variant<unit, V>;
 
     ~prefix_tree_node() {
       for (typename SubkeyMap::const_iterator c = this->children.begin(); c != this->children.end(); ++c) {
@@ -29,7 +29,7 @@ template <typename K, typename V, typename KMap>
         vs->push_back(*v);
       }
 
-      for (typename SubkeyMap::const_iterator c = this->children.begin(); c != this->children.end(); ++c) {
+      for (auto c = this->children.begin(); c != this->children.end(); ++c) {
         c->second->values(vs);
       }
     }
@@ -38,7 +38,7 @@ template <typename K, typename V, typename KMap>
 template <typename K, typename V, typename KMap>
   class prefix_tree {
   private:
-    typedef prefix_tree_node<K, V, KMap> node_t;
+    using node_t = prefix_tree_node<K, V, KMap>;
     node_t* root;
 
     template <typename KIter>
@@ -58,9 +58,9 @@ template <typename K, typename V, typename KMap>
       const node_t* findNode(KIter begin, KIter end) const {
         const node_t* r = this->root;
         for (KIter i = begin; i != end; ++i) {
-          typename node_t::SubkeyMap::const_iterator c = r->children.find(*i);
+          auto c = r->children.find(*i);
           if (c == r->children.end()) {
-            return 0;
+            return nullptr;
           } else {
             r = c->second;
           }
@@ -83,7 +83,7 @@ template <typename K, typename V, typename KMap>
     template <typename KIter>
       V* lookup(KIter begin, KIter end) const {
         const node_t* n = findNode(begin, end);
-        return n ? const_cast<V*>(get<V>(n->value)) : 0;
+        return n ? const_cast<V*>(get<V>(n->value)) : nullptr;
       }
 
     void insert(const std::vector<K>& k, const V& v) {
@@ -94,7 +94,7 @@ template <typename K, typename V, typename KMap>
       return lookup(k.begin(), k.end());
     }
 
-    typedef std::vector<V> ValueSeq;
+    using ValueSeq = std::vector<V>;
     void values(ValueSeq* vs) const {
       this->root->values(vs);
     }
@@ -106,16 +106,16 @@ template <typename K, typename V, typename KMap>
     }
 
     // support incremental search
-    typedef void* point_t;
+    using point_t = void *;
     point_t rootPoint() const { return this->root; }
 
     point_t moveTo(const K& k, point_t base) const {
       const node_t* n = reinterpret_cast<node_t*>(base);
-      typename node_t::SubkeyMap::const_iterator c = n->children.find(k);
+      auto c = n->children.find(k);
       return (c == n->children.end()) ? 0 : c->second;
     }
 
-    typedef std::vector<K> KeySeq;
+    using KeySeq = std::vector<K>;
     void keysAt(KeySeq* ks, point_t base) const {
       const node_t* n = reinterpret_cast<node_t*>(base);
 
@@ -130,12 +130,12 @@ template <typename K, typename V, typename KMap>
       return r;
     }
 
-    typedef std::pair<K, point_t> KeyPoint;
-    typedef std::vector<KeyPoint> KeyPointSeq;
+    using KeyPoint = std::pair<K, point_t>;
+    using KeyPointSeq = std::vector<KeyPoint>;
     void keyPointsAt(KeyPointSeq* kps, point_t base) const {
       const node_t* n = reinterpret_cast<node_t*>(base);
 
-      for (typename node_t::SubkeyMap::const_iterator c = n->children.begin(); c != n->children.end(); ++c) {
+      for (auto c = n->children.begin(); c != n->children.end(); ++c) {
         kps->push_back(KeyPoint(c->first, c->second));
       }
     }
diff --git a/include/hobbes/util/unionfind.H b/include/hobbes/util/unionfind.H
index 496e0d172..16c7b1c44 100644
--- a/include/hobbes/util/unionfind.H
+++ b/include/hobbes/util/unionfind.H
@@ -98,9 +98,9 @@ template <typename K, typename V, typename KVLift, typename VPlus>
   private:
     size_t eqsz;
 
-    typedef eqsetmem<K, V>               node_t;
-    typedef std::unique_ptr<node_t>      nodep; // allows multiple incremental extensions of unification sets
-    typedef std::unordered_map<K, nodep> nodes_t;
+    using node_t = eqsetmem<K, V>;
+    using nodep = std::unique_ptr<node_t>; // allows multiple incremental extensions of unification sets
+    using nodes_t = std::unordered_map<K, nodep>;
     nodes_t nodes;
 
     static node_t* findRepresentative(node_t* n) {
@@ -125,7 +125,7 @@ template <typename K, typename V, typename KVLift, typename VPlus>
       if (n != this->nodes.end()) {
         return findRepresentative(n->second.get());
       } else {
-        node_t* n = new node_t(k, KVLift::apply(k));
+        auto* n = new node_t(k, KVLift::apply(k));
         this->nodes[k] = nodep(n);
         return n;
       }
diff --git a/lib/hobbes/boot/bootgen.sh b/lib/hobbes/boot/bootgen.sh
index f475f3060..8ec0616ad 100755
--- a/lib/hobbes/boot/bootgen.sh
+++ b/lib/hobbes/boot/bootgen.sh
@@ -8,20 +8,20 @@ rm -f $GENFILE
 
 for script in `ls ./*.hob`
 do
-  xxd -i $script >> $GENFILE
+  xxd -i $script | sed 's/ __/ _/' >> $GENFILE
 done
 
 echo "unsigned char* module_defs[] = {" >> $GENFILE
-for script in `ls ./*.hob`
+for script in `ls *.hob`
 do
-  echo "$script," | sed 's/\./_/g' | sed 's/\//_/g' >> $GENFILE
+  echo _"$script," | sed 's/\./_/g' >> $GENFILE
 done
-echo "0 };" >> $GENFILE
+echo "nullptr };" >> $GENFILE
 
 echo "unsigned int module_lens[] = {" >> $GENFILE
-for script in `ls ./*.hob`
+for script in `ls *.hob`
 do
-  echo "$script""_len," | sed 's/\./_/g' | sed 's/\//_/g' >> $GENFILE
+  echo _"$script""_len," | sed 's/\./_/g' >> $GENFILE
 done
-echo "0 };" >> $GENFILE
+echo "0u };" >> $GENFILE
 
diff --git a/lib/hobbes/boot/gen/boot.C b/lib/hobbes/boot/gen/boot.C
index e11054f2f..1a18242ef 100644
--- a/lib/hobbes/boot/gen/boot.C
+++ b/lib/hobbes/boot/gen/boot.C
@@ -7,7 +7,7 @@ namespace hobbes {
 #include <hobbes/boot/gen/bootdata.H>
 
 void compileBootCode(cc& ctx) {
-  for (size_t i = 0; module_defs[i] != 0; ++i) {
+  for (size_t i = 0; module_defs[i] != nullptr; ++i) {
     compile(&ctx, ctx.readModule(std::string(reinterpret_cast<const char*>(module_defs[i]), module_lens[i])));
   }
 }
diff --git a/lib/hobbes/db/bindings.C b/lib/hobbes/db/bindings.C
index 448f223c3..b4320be46 100644
--- a/lib/hobbes/db/bindings.C
+++ b/lib/hobbes/db/bindings.C
@@ -5,6 +5,7 @@
 #include <hobbes/db/signals.H>
 #include <hobbes/eval/cc.H>
 #include <hobbes/eval/funcdefs.H>
+#include <memory>
 #include <unordered_map>
 
 namespace hobbes {
@@ -14,7 +15,7 @@ MonoTypePtr fileType(bool writeable, const MonoTypePtr& stype) {
 }
 
 static uint32_t fileModeFlags(const MonoTypePtr& t) {
-  if (auto n = is<TLong>(t)) {
+  if (auto *n = is<TLong>(t)) {
     return n->value()+1;
   }
   return 0;
@@ -28,7 +29,7 @@ static bool isWriteable(uint32_t f) {
   return f == 2;
 }
 
-typedef std::pair<bool, MonoTypePtr> UTFileConfig;
+using UTFileConfig = std::pair<bool, MonoTypePtr>;
 bool unpackFileType(const MonoTypePtr& fty, UTFileConfig* fcfg) {
   if (const TApp* ap = is<TApp>(fty)) {
     if (ap->args().size() == 2) {
@@ -45,7 +46,7 @@ bool unpackFileType(const MonoTypePtr& fty, UTFileConfig* fcfg) {
   return false;
 }
 
-typedef std::pair<bool, const Record*> FileConfig;
+using FileConfig = std::pair<bool, const Record *>;
 bool unpackFileType(const MonoTypePtr& fty, FileConfig* fcfg) {
   UTFileConfig ufcfg;
   if (unpackFileType(fty, &ufcfg)) {
@@ -66,11 +67,11 @@ struct injFileReferencesF : public switchTyFn {
   ExprPtr f;
   injFileReferencesF(const ExprPtr& f) : f(f) { }
 
-  MonoTypePtr with(const Prim* t) const {
+  MonoTypePtr with(const Prim* t) const override {
     return Prim::make(t->name(), t->representation() ? switchOf(t->representation(), *this) : t->representation());
   }
 
-  MonoTypePtr with(const TApp* v) const {
+  MonoTypePtr with(const TApp* v) const override {
     MonoTypePtr tf    = switchOf(v->fn(), *this);
     MonoTypes   targs = switchOf(v->args(), *this);
 
@@ -86,7 +87,7 @@ struct injFileReferencesF : public switchTyFn {
   }
 };
 
-typedef std::pair<MonoTypePtr, ExprPtr> FRefT;
+using FRefT = std::pair<MonoTypePtr, ExprPtr>;
 
 FRefT assumeFRefT(const MonoTypePtr& ty, const LexicalAnnotation& la) {
   if (const TApp* ap = is<TApp>(ty)) {
@@ -177,7 +178,7 @@ char* dbloadarr(long db, long offset, long esz) {
 
 // load/store root values in storage files
 class dbloadVF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     llvm::Value* off = c->compile(es[1]);
 
@@ -187,7 +188,7 @@ class dbloadVF : public op {
     }
 
     llvm::Function* f = c->lookupFunction(".dbloado");
-    if (!f) { throw std::runtime_error("Expected 'dbloado' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dbloado' function as call"); }
 
     return withContext([&](auto&) -> llvm::Value* {
       llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
@@ -200,7 +201,7 @@ class dbloadVF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tg2(TGen::make(2));
@@ -210,7 +211,7 @@ class dbloadVF : public op {
 };
 
 class dbstoreVF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     llvm::Value* db   = c->compile(es[0]);
     llvm::Value* off  = c->compile(es[1]);
     llvm::Value* outv = c->compile(es[2]);
@@ -223,7 +224,7 @@ class dbstoreVF : public op {
     }
 
     llvm::Function* f = c->lookupFunction(".dbloado");
-    if (!f) { throw std::runtime_error("Expected 'dbloado' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dbloado' function as call"); }
 
     return withContext([&](auto&) -> llvm::Value* {
       llvm::Value* allocv = fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db, off));
@@ -242,7 +243,7 @@ class dbstoreVF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tg2(TGen::make(2));
@@ -253,7 +254,7 @@ class dbstoreVF : public op {
 
 // load unnamed values inside of storage files
 struct dbloadF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) override {
     FRefT frt = assumeFRefT(tys[0], es[0]->la());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
@@ -291,7 +292,7 @@ struct dbloadF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(2, qualtype(Func::make(tuplety(list(fileRefTy(tg0, tg1))), tg0))));
@@ -300,7 +301,7 @@ struct dbloadF : public op {
 };
 
 struct dbloadPF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     llvm::Value* off = c->compile(es[1]);
 
@@ -336,7 +337,7 @@ struct dbloadPF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tg2(TGen::make(2));
@@ -353,12 +354,12 @@ struct dbloadPF : public op {
 //
 //  but this currently can't be expressed
 struct dbRefFileF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     FRefT frt = assumeFRefT(tys[0], es[0]->la());
     return c->compileAtGlobalScope(frt.second);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     MonoTypePtr tg0(TGen::make(0));
     MonoTypePtr tg1(TGen::make(1));
     MonoTypePtr tg2(TGen::make(2));
@@ -382,7 +383,7 @@ void dbunloadarr(long db, long ptr, long sz) {
 }
 
 struct dbunloadF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     return withContext([&](auto&) -> llvm::Value* {
       llvm::Value* val = c->builder()->CreatePtrToInt(c->compile(es[1]), toLLVM(primty("long"), true));
@@ -414,7 +415,7 @@ struct dbunloadF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tg2(TGen::make(2));
@@ -429,13 +430,13 @@ long dballoc(long db, long datasz, size_t align) {
 }
 
 struct dballocF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs&) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs&) override {
     FRefT frt = assumeFRefT(rty, LexicalAnnotation::null());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
 
     llvm::Function* f = c->lookupFunction(".dballoc");
-    if (!f) { throw std::runtime_error("Expected 'dballoc' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dballoc' function as call"); }
 
     size_t sz = storageSizeOf(frefType(rty));
     return withContext([&](auto&) {
@@ -443,27 +444,27 @@ struct dballocF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
-    return PolyTypePtr(new PolyType(2, qualtype(Func::make(tuplety(list(primty("unit"))), fileRefTy(tgen(0), tgen(1))))));
+  PolyTypePtr type(typedb&) const override {
+    return std::make_shared<PolyType>(2, qualtype(Func::make(tuplety(list(primty("unit"))), fileRefTy(tgen(0), tgen(1)))));
   }
 };
 
 // write a value into a storage file
 struct dbstoreF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) override {
     FRefT frt = assumeFRefT(rty, es[0]->la());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
     llvm::Value* v   = c->compile(es[0]);
 
-    if (is<Array>(tys[0])) {
+    if (is<Array>(tys[0]) != nullptr) {
       throw annotated_error(*es[0], "store array nyi");
     } else {
       llvm::Function* f = c->lookupFunction(".dballoc");
-      if (!f) { throw std::runtime_error("Expected 'dballoc' function as call"); }
+      if (f == nullptr) { throw std::runtime_error("Expected 'dballoc' function as call"); }
 
       llvm::Function* dblf = c->lookupFunction(".dbloadv");
-      if (!dblf) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
+      if (dblf == nullptr) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
       size_t sz = storageSizeOf(frefType(rty));
       return withContext([&](auto&) {
@@ -479,7 +480,7 @@ struct dbstoreF : public op {
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(2, qualtype(Func::make(tuplety(list(tg0)), fileRefTy(tg0, tg1)))));
@@ -488,18 +489,18 @@ struct dbstoreF : public op {
 };
 
 struct dbstorePF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     llvm::Value* v   = c->compile(es[1]);
 
-    if (is<Array>(tys[1])) {
+    if (is<Array>(tys[1]) != nullptr) {
       throw annotated_error(*es[1], "store array nyi");
     } else {
       llvm::Function* f = c->lookupFunction(".dballoc");
-      if (!f) { throw std::runtime_error("Expected 'dballoc' function as call"); }
+      if (f == nullptr) { throw std::runtime_error("Expected 'dballoc' function as call"); }
 
       llvm::Function* dblf = c->lookupFunction(".dbloadv");
-      if (!dblf) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
+      if (dblf == nullptr) { throw std::runtime_error("Expected 'dbloadv' function as call"); }
 
       size_t sz = storageSizeOf(frefType(rty));
       return withContext([&](auto&) {
@@ -515,7 +516,7 @@ struct dbstorePF : public op {
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(2, qualtype(Func::make(tuplety(list(tapp(primty("file"), list(tlong(1), tg0)), tg1)), fileRefTy(tg1)))));
@@ -529,14 +530,14 @@ long dballocarr(long db, long elemsz, long len) {
 }
 
 struct dballocArrF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     FRefT frt = assumeFRefT(rty, es[0]->la());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
     llvm::Value* len = c->compile(es[0]);
 
     llvm::Function* f = c->lookupFunction(".dballocarr");
-    if (!f) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
 
     size_t elemsz = storageSizeOf(arrType(frt.first));
     return withContext([&](auto&) {
@@ -544,7 +545,7 @@ struct dballocArrF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(2, qualtype(Func::make(tuplety(list(primty("long"))), fileRefTy(arrayty(tg0), tg1)))));
@@ -553,12 +554,12 @@ struct dballocArrF : public op {
 };
 
 struct dballocArrPF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     llvm::Value* len = c->compile(es[1]);
 
     llvm::Function* f = c->lookupFunction(".dballocarr");
-    if (!f) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dballocarr' function as call"); }
 
     size_t elemsz = storageSizeOf(arrType(frefType(rty)));
     return withContext([&](auto&) {
@@ -566,7 +567,7 @@ struct dballocArrPF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(2, qualtype(Func::make(tuplety(list(tapp(primty("file"), list(tlong(1), tg0)), primty("long"))), fileRefTy(arrayty(tg1))))));
@@ -580,14 +581,14 @@ long dbdarrcapacity(long db, long elemsz, long arrref) {
 }
 
 struct dbarrCapacityF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     FRefT frt = assumeFRefT(tys[0], es[0]->la());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
     llvm::Value* off = c->compile(es[0]);
 
     llvm::Function* f = c->lookupFunction(".dbdarrcapacity");
-    if (!f) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
 
     size_t elemsz = storageSizeOf(darrType(frt.first));
     return withContext([&](auto&) {
@@ -595,7 +596,7 @@ struct dbarrCapacityF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr npty(new PolyType(3, qualtype(Func::make(tuplety(list(fileRefTy(darrayty(tg0), tg1))), primty("long")))));
@@ -604,12 +605,12 @@ struct dbarrCapacityF : public op {
 };
 
 struct dbarrCapacityPF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
     llvm::Value* off = c->compile(es[1]);
 
     llvm::Function* f = c->lookupFunction(".dbdarrcapacity");
-    if (!f) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dbdarrcapacity' function as call"); }
 
     size_t elemsz = storageSizeOf(darrType(frefType(tys[1])));
     return withContext([&](auto&) {
@@ -617,7 +618,7 @@ struct dbarrCapacityPF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tg2(TGen::make(2));
@@ -628,9 +629,9 @@ struct dbarrCapacityPF : public op {
 
 // create a new structured storage file with the given name and the given type structure
 long writeFileRT(const array<char>* fname, long tydef) {
-  writer*       result = new writer(makeStdString(fname));
+  auto*       result = new writer(makeStdString(fname));
   MonoTypeSubst fdefs  = result->signature();
-  const Record* rty    = reinterpret_cast<const Record*>(tydef);
+  const auto* rty    = reinterpret_cast<const Record*>(tydef);
 
   for (const auto& m : rty->members()) {
     auto fdef = fdefs.find(m.field);
@@ -653,27 +654,27 @@ void dbsignalupdate(long db) {
 }
 
 struct signalUpdateF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     llvm::Value* db  = c->compile(es[0]);
 
     llvm::Function* f = c->lookupFunction(".dbsignalupdate");
-    if (!f) { throw std::runtime_error("Expected 'dbsignalupdate' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'dbsignalupdate' function as call"); }
 
     return withContext([&](auto&) {
       return fncall(c->builder(), f, f->getFunctionType(), list<llvm::Value*>(db));
     });
   }
 
-  PolyTypePtr type(typedb&) const {
-    return PolyTypePtr(new PolyType(3, qualtype(Func::make(tuplety(list(tapp(primty("file"), list(tlong(1), tgen(0))))), primty("unit")))));
+  PolyTypePtr type(typedb&) const override {
+    return std::make_shared<PolyType>(3, qualtype(Func::make(tuplety(list(tapp(primty("file"), list(tlong(1), tgen(0))))), primty("unit"))));
   }
 };
 
 // read an existing structured storage file with the given name and the given type structure
 long readFileRT(const array<char>* fname, long tydef) {
-  reader*       result = new reader(makeStdString(fname));
+  auto*       result = new reader(makeStdString(fname));
   MonoTypeSubst fdefs  = result->signature();
-  const Record* rty    = reinterpret_cast<const Record*>(tydef);
+  const auto* rty    = reinterpret_cast<const Record*>(tydef);
 
   for (const auto& m : rty->members()) {
     auto fdef = fdefs.find(m.field);
@@ -712,7 +713,7 @@ struct openFileF : public op {
   openFileF(bool writeable, const std::string& loadf) : writeable(writeable), loadf(loadf) {
   }
 
-  typedef std::unordered_map<std::string, MonoTypePtr> InternTypes;
+  using InternTypes = std::unordered_map<std::string, MonoTypePtr>;
   InternTypes internTypes;
 
   long encodeTypePtr(const Record* rty) {
@@ -727,7 +728,7 @@ struct openFileF : public op {
     }
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     FileConfig fcfg;
 
     if (!isMonoSingular(rty)) {
@@ -740,7 +741,7 @@ struct openFileF : public op {
     return c->compile(fncall(wfrtfn, list(es[0], constant(encodeTypePtr(fcfg.second), es[0]->la())), es[0]->la()));
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     // writeFile :: [char] -> file(1L, a)
     return polytype(1, qualtype(functy(list(arrayty(primty("char"))), fileType(this->writeable, tgen(0)))));
   }
@@ -757,12 +758,12 @@ struct printFileF : public op {
   printFileF(const std::string& showf) : showf(showf) {
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     ExprPtr wfrtfn = var(this->showf, functy(list(primty("long")), primty("unit")), es[0]->la());
     return c->compile(fncall(wfrtfn, list(es[0]), es[0]->la()));
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     // showFile :: file(a, b) -> ()
     return polytype(2, qualtype(functy(list(tapp(primty("file"), list(tgen(0), tgen(1)))), primty("unit"))));
   }
@@ -771,11 +772,11 @@ struct printFileF : public op {
 // resolve variable lookups within storage files
 class DBFieldLookup : public HFEliminator {
 public:
-  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*);
-  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const;
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*) override;
+  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 bool DBFieldLookup::refine(const TEnvPtr&, const HasField& hf, MonoTypeUnifier* u, Definitions*) {
@@ -843,15 +844,15 @@ bool DBFieldLookup::satisfiable(const TEnvPtr& tenv, const HasField& hf, Definit
 
       return unifiable(tenv, fty, frtype);
     } else {
-      return is<TVar>(fname);
+      return is<TVar>(fname) != nullptr;
     }
   } else {
     if (const TApp* ap = is<TApp>(rty)) {
       if (ap->args().size() == 2) {
         if (const Prim* f = is<Prim>(ap->fn())) {
           if (f->name() == "file") {
-            if (is<TVar>(ap->args()[0]) || isFileMode(ap->args()[0])) {
-              return is<TVar>(ap->args()[1]) || is<Record>(ap->args()[1]);
+            if ((is<TVar>(ap->args()[0]) != nullptr) || isFileMode(ap->args()[0])) {
+              return (is<TVar>(ap->args()[1]) != nullptr) || (is<Record>(ap->args()[1]) != nullptr);
             }
           }
         }
@@ -894,15 +895,15 @@ struct HFDBFLUnqualify : public switchExprTyFn {
     return *ty == *this->ftype;
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     const Func* fty = is<Func>(v->type()->monoType());
-    if (!fty) {
+    if (fty == nullptr) {
       throw annotated_error(*v, "Internal error, expected annotated function type");
     }
     return wrapWithTy(v->type(),
@@ -914,7 +915,7 @@ struct HFDBFLUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return wrapWithTy(v->type(),
       new Let(
         v->var(),
@@ -925,7 +926,7 @@ struct HFDBFLUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     // read a file value
     if (this->udir == HasField::Read && hasConstraint(this->constraint, v->type()) && v->field() == this->fname && expectedObjType(v->record()->type()->monoType())) {
       ExprPtr dbfile = switchOf(v->record(), *this);
@@ -937,7 +938,7 @@ struct HFDBFLUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     ExprPtr lhs = switchOf(v->left(), *this);
     ExprPtr rhs = switchOf(v->right(), *this);
 
@@ -980,7 +981,7 @@ public:
     reader*     file;
     MonoTypePtr type;
   };
-  typedef std::map<std::string, LoadedFile> LoadedFiles;
+  using LoadedFiles = std::map<std::string, LoadedFile>;
   mutable LoadedFiles loadedFiles;
 
   const LoadedFile& loadedFile(bool writeable, const std::string& path) const {
@@ -1014,7 +1015,7 @@ public:
     throw std::runtime_error("Internal error, not loadable file load constraint: " + show(cst));
   }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) override {
     MonoTypePtr fpath, ftype;
     if (decLF(cst, &fpath, &ftype)) {
       if (const TString* fp = is<TString>(fpath)) {
@@ -1029,7 +1030,7 @@ public:
     return false;
   }
 
-  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const override {
     MonoTypePtr fpath, ftype;
     if (decLF(cst, &fpath, &ftype)) {
       if (const TString* fp = is<TString>(fpath)) {
@@ -1042,7 +1043,7 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions*) const override {
     MonoTypePtr fpath, ftype;
     if (decLF(cst, &fpath, &ftype)) {
       if (const TString* fp = is<TString>(fpath)) {
@@ -1051,13 +1052,13 @@ public:
           return unifiable(tenv, ftype, loadedFile(ufcfg.first, fp->value()).type);
         }
       } else {
-        return is<TVar>(fpath);
+        return is<TVar>(fpath) != nullptr;
       }
     }
     return false;
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct insertLoadedFileF : public switchExprTyFn {
@@ -1067,11 +1068,11 @@ public:
     insertLoadedFileF(const ConstraintPtr& constraint, long f) : constraint(constraint), f(f) {
     }
 
-    QualTypePtr withTy(const QualTypePtr& qt) const {
+    QualTypePtr withTy(const QualTypePtr& qt) const override {
       return removeConstraint(this->constraint, qt);
     }
 
-    ExprPtr with(const Var* v) const {
+    ExprPtr with(const Var* v) const override {
       if (hasConstraint(this->constraint, v->type())) {
         if (v->value() == READ_FILE_SYM || v->value() == WRITE_FILE_SYM) {
           return constant(this->f, v->la());
@@ -1081,28 +1082,28 @@ public:
     }
   };
 
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const {
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const override {
     return switchOf(e, insertLoadedFileF(cst, reinterpret_cast<long>(loadedFile(cst).file)));
   }
 
-  PolyTypePtr lookup(const std::string& vn) const {
+  PolyTypePtr lookup(const std::string& vn) const override {
     if (vn == READ_FILE_SYM) {
-      return polytype(2, qualtype(list(ConstraintPtr(new Constraint("LoadFile", list(tgen(0), fileType(false, tgen(1)))))), fileType(false, tgen(1))));
+      return polytype(2, qualtype(list(std::make_shared<Constraint>("LoadFile", list(tgen(0), fileType(false, tgen(1))))), fileType(false, tgen(1))));
     } else if (vn == WRITE_FILE_SYM) {
-      return polytype(2, qualtype(list(ConstraintPtr(new Constraint("LoadFile", list(tgen(0), fileType(true, tgen(1)))))), fileType(true, tgen(1))));
+      return polytype(2, qualtype(list(std::make_shared<Constraint>("LoadFile", list(tgen(0), fileType(true, tgen(1))))), fileType(true, tgen(1))));
     } else {
       return PolyTypePtr();
     }
   }
 
-  SymSet bindings() const {
+  SymSet bindings() const override {
     SymSet r;
     r.insert(READ_FILE_SYM);
     r.insert(WRITE_FILE_SYM);
     return r;
   }
 
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     FunDeps result;
     result.push_back(FunDep(list(0), 1));
     return result;
@@ -1117,11 +1118,11 @@ struct pageEntriesF : public op {
 
   pageEntriesF(const std::string& f) : f(f) {
   }
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     ExprPtr wfrtfn = var(this->f, functy(list(primty("long")), lift<reader::PageEntries*>::type(nulltdb)), es[0]->la());
     return c->compile(fncall(wfrtfn, list(es[0]), es[0]->la()));
   }
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     return polytype(2, qualtype(functy(list(tapp(primty("file"), list(tgen(0), tgen(1)))), lift<reader::PageEntries*>::type(nulltdb))));
   }
 };
diff --git a/lib/hobbes/db/cbindings.C b/lib/hobbes/db/cbindings.C
index 5d58212af..39d7127bb 100644
--- a/lib/hobbes/db/cbindings.C
+++ b/lib/hobbes/db/cbindings.C
@@ -16,14 +16,14 @@ struct DynCumFreqState {
   }
   uint8_t maxSymbol;
 
-  typedef uint16_t index_t;
-  typedef uint16_t symbol;
+  using index_t = uint16_t;
+  using symbol = uint16_t;
 
   index_t symbolCount() const { return static_cast<index_t>(this->maxSymbol)+1; }
   symbol  esc()         const { return static_cast<symbol>(symbolCount()); }
 
   struct CModel {
-    CModel(uint8_t maxSym) : symbols(0), indexes(0), cfreqs(0) {
+    CModel(uint8_t maxSym) : symbols(nullptr), indexes(nullptr), cfreqs(nullptr) {
       size_t n = static_cast<size_t>(maxSym) + 2; // one extra for the escape symbol
       this->symbols = new symbol[n];
       this->indexes = new index_t[n];
@@ -77,16 +77,15 @@ struct DynDModel0 : DynCumFreqState {
 public:
   DynDModel0(imagefile* f, bool input, uint8_t maxSymbol) : DynCumFreqState(maxSymbol), f(f), pm(input, maxSymbol), cm(maxSymbol) {
   }
-  ~DynDModel0() {
-  }
+  ~DynDModel0() = default;
 
-  typedef DynCumFreqState CFS;
-  typedef typename CFS::index_t index_t;
-  typedef typename CFS::symbol  symbol;
-  typedef typename CFS::CModel  CModel;
+  using CFS = DynCumFreqState;
+  using index_t = typename CFS::index_t;
+  using symbol = typename CFS::symbol;
+  using CModel = typename CFS::CModel;
 
   struct PModel {
-    PModel(bool input, uint8_t maxSymbol) : freqs(0), activeFreqs(0), pc(0), input(input), lc(0) {
+    PModel(bool input, uint8_t maxSymbol) : freqs(nullptr), activeFreqs(nullptr), pc(nullptr), input(input), lc(0) {
       if (this->input) {
         size_t n = static_cast<size_t>(maxSymbol) + 1;
         this->freqs       = new arithn::freq[n];
@@ -107,7 +106,7 @@ public:
     bool          input;
     arithn::freq  lc;
 
-    arithn::freq& c() { return *this->pc; }
+    arithn::freq& c() const { return *this->pc; }
   };
 
   imagefile* f;
@@ -211,7 +210,7 @@ public:
   }
 
   uint8_t read(DynDModel0* dm) {
-    typedef uint16_t symbol;
+    using symbol = uint16_t;
 
     symbol s=0;
     arithn::code clow=0, chigh=0;
@@ -222,7 +221,7 @@ public:
 
     if (s == dm->esc()) {
       auto escRange = dm->symbolCount();
-      symbol nc = static_cast<symbol>(this->readState.svalue(escRange));
+      auto nc = static_cast<symbol>(this->readState.svalue(escRange));
       this->readState.shift(nc, nc+1, escRange);
       dm->add(nc);
       return static_cast<uint8_t>(nc);
@@ -233,7 +232,7 @@ public:
   }
 
   bool step() {
-    if (this->readState.buffer) {
+    if (this->readState.buffer != nullptr) {
       ++this->readState.count;
 
       bool f = false;
@@ -258,7 +257,7 @@ public:
   }
 
   bool eof() const {
-    return this->readState.buffer == 0;
+    return this->readState.buffer == nullptr;
   }
 
   size_t currentInitModel() const {
@@ -272,7 +271,7 @@ private:
 
   void loadReadState(uint64_t root) {
     while (root != 0) {
-      uint64_t* d = reinterpret_cast<uint64_t*>(mapFileData(this->readState.file, root, 3*sizeof(uint64_t)));
+      auto* d = reinterpret_cast<uint64_t*>(mapFileData(this->readState.file, root, 3*sizeof(uint64_t)));
       if (d[0] == 0) {
         root = 0;
       } else {
@@ -286,12 +285,12 @@ private:
   }
 
   bool loadNextNode() {
-    if (this->readState.buffer) {
+    if (this->readState.buffer != nullptr) {
       unmapFileData(this->readState.file, reinterpret_cast<const void*>(this->readState.buffer), sizeof(cbatch));
     }
 
-    if (this->batches.size() == 0) {
-      this->readState.buffer = 0;
+    if (this->batches.empty()) {
+      this->readState.buffer = nullptr;
       return false;
     } else {
       // load this compressed data segment (the caller will then need to init from `this->readState.buffer->initModel`)
@@ -340,7 +339,7 @@ bool UCWriter::step() {
 
     // allocate/initialize the model for this bitstream segment (from the terminal state of the scratch model for the previous segment)
     uint64_t newScratchModelRef = findSpace(this->out.file, pagetype::data, this->modelSize, sizeof(size_t));
-    uint8_t* newScratchModel    = reinterpret_cast<uint8_t*>(mapFileData(this->out.file, newScratchModelRef, this->modelSize));
+    auto* newScratchModel    = reinterpret_cast<uint8_t*>(mapFileData(this->out.file, newScratchModelRef, this->modelSize));
     memcpy(newScratchModel, this->scratchModel, this->modelSize);
     unmapFileData(this->out.file, this->scratchModel, this->modelSize);
 
diff --git a/lib/hobbes/db/file.C b/lib/hobbes/db/file.C
index bfeccabe7..546e59046 100644
--- a/lib/hobbes/db/file.C
+++ b/lib/hobbes/db/file.C
@@ -43,7 +43,7 @@ MonoTypePtr darrayty(const MonoTypePtr& t) {
 
 // the representation of file reference types changed after v0
 struct mapFileRefs : public switchTyFn {
-  MonoTypePtr with(const TApp* ap) const {
+  MonoTypePtr with(const TApp* ap) const override {
     if (ap->args().size() == 2) {
       if (const Prim* f = is<Prim>(ap->fn())) {
         if (f->name() == "fileref") {
@@ -57,7 +57,7 @@ struct mapFileRefs : public switchTyFn {
 
 // the representation of stored array types changed after v1
 struct mapStoredArrays : public switchTyFn {
-  MonoTypePtr with(const Array* a) const {
+  MonoTypePtr with(const Array* a) const override {
     return darrayty(switchOf(a->type(), *this));
   }
 };
@@ -81,7 +81,7 @@ static MonoTypePtr decodeBindingByVersion(uint16_t version, const binding& b) {
 
 // for storage, we need to make sure that size is computed slightly differently than for memory
 size_t storageSizeOf(const MonoTypePtr& mty) {
-  if (is<Recursive>(mty)) {
+  if (is<Recursive>(mty) != nullptr) {
     return sizeOf(unroll(mty));
   } else {
     return sizeOf(mty);
@@ -95,7 +95,7 @@ reader::reader(imagefile* f) : fdata(f) {
 
   // and translate bindings
   for (const auto& b : this->fdata->bindings) {
-    if (b.first.size() > 0 && b.first[0] != '.') {
+    if (!b.first.empty() && b.first[0] != '.') {
       SBinding sb;
       sb.type   = decodeBindingByVersion(this->fdata->version, b.second.type);
       sb.offset = this->fdata->version==0 ? b.second.boffset : b.second.offset;
@@ -203,22 +203,22 @@ void* reader::unsafeLoad(uint64_t pos, size_t datasz) const {
 }
 
 uint64_t reader::unsafeDArrayCapacity(uint64_t pos) const {
-  uint64_t* cap    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
+  auto* cap    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
   uint64_t  result = *cap;
   unmapFileData(this->fdata, cap, sizeof(uint64_t));
   return result;
 }
 void* reader::unsafeLoadDArray(uint64_t pos) const {
   // if we're loading a darray, we actually have to read the data size first to know how much to map
-  uint64_t* cap    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
-  uint8_t*  result = reinterpret_cast<uint8_t*>(mapFileData(this->fdata, pos+sizeof(uint64_t), *cap));
+  auto* cap    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
+  auto*  result = reinterpret_cast<uint8_t*>(mapFileData(this->fdata, pos+sizeof(uint64_t), *cap));
   unmapFileData(this->fdata, cap, sizeof(uint64_t));
   return result;
 }
 
 void* reader::unsafeLoadArray(uint64_t pos, size_t sz) const {
-  uint64_t* len    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
-  uint8_t*  result = reinterpret_cast<uint8_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t) + sz * *len));
+  auto* len    = reinterpret_cast<uint64_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t)));
+  auto*  result = reinterpret_cast<uint8_t*>(mapFileData(this->fdata, pos, sizeof(uint64_t) + sz * *len));
   unmapFileData(this->fdata, len, sizeof(uint64_t));
   return result;
 }
@@ -399,7 +399,7 @@ uint64_t writer::unsafeStoreToOffset(size_t sz, size_t align) {
 
 void* writer::unsafeStoreDArray(size_t esize, size_t len) {
   size_t datasz = sizeof(long) + sizeof(long) + (len * esize);
-  unsigned char* result = reinterpret_cast<unsigned char*>(allocAnon(datasz, sizeof(size_t)));
+  auto* result = reinterpret_cast<unsigned char*>(allocAnon(datasz, sizeof(size_t)));
   *reinterpret_cast<long*>(result) = datasz;
   return reinterpret_cast<void*>(result + sizeof(long));
 }
@@ -414,7 +414,7 @@ uint64_t writer::unsafeStoreDArrayToOffset(size_t esize, size_t len) {
 
 void* writer::unsafeStoreArray(size_t esize, size_t len) {
   if (len > 0) {
-    unsigned char* result = reinterpret_cast<unsigned char*>(allocAnon(sizeof(long) + (len * esize), sizeof(size_t)));
+    auto* result = reinterpret_cast<unsigned char*>(allocAnon(sizeof(long) + (len * esize), sizeof(size_t)));
     *reinterpret_cast<long*>(result) = len;
     return result;
   } else {
diff --git a/lib/hobbes/db/series.C b/lib/hobbes/db/series.C
index 382b856f7..6bad7d4e2 100644
--- a/lib/hobbes/db/series.C
+++ b/lib/hobbes/db/series.C
@@ -1,6 +1,7 @@
 
-#include <hobbes/db/series.H>
 #include <atomic>
+#include <hobbes/db/series.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -230,7 +231,7 @@ MonoTypePtr storeAs(cc* c, const MonoTypePtr& ty) {
 //  (currently we have to account for the fact that we might be storing primitive values
 //   in that case, we'll just entuple them and write them as records)
 static void* storageFunction(cc*c, const MonoTypePtr& ty, const MonoTypePtr& storageType, const LexicalAnnotation& la) {
-  if (is<Record>(storageType)) {
+  if (is<Record>(storageType) != nullptr) {
     return c->unsafeCompileFn(
       primty("unit"),
       str::strings("f", "v", "d"),
@@ -298,8 +299,7 @@ RawStoredSeries::RawStoredSeries(cc* c, writer* outputFile, ufileref root, const
   }
 }
 
-RawStoredSeries::~RawStoredSeries() {
-}
+RawStoredSeries::~RawStoredSeries() = default;
 
 ufileref RawStoredSeries::rootRef() const {
   return this->rootLoc;
@@ -352,7 +352,7 @@ static void unsafeWriteToSeries(long ss, char* rec) {
 }
 
 static void unsafeWriteUnitToSeries(long ss) {
-  reinterpret_cast<RawStoredSeries*>(ss)->record(0, false);
+  reinterpret_cast<RawStoredSeries*>(ss)->record(nullptr, false);
 }
 
 void RawStoredSeries::bindAs(cc* c, const std::string& vname) {
@@ -375,7 +375,7 @@ void RawStoredSeries::bindAs(cc* c, const std::string& vname) {
         nla
       )
     );
-  } else if(is<Record>(this->recordType)) {
+  } else if(is<Record>(this->recordType) != nullptr) {
     // vname = \x.unsafeWriteToSeries(this, unsafeCast(x :: ty))
     c->define(
       vname,
@@ -419,17 +419,17 @@ void RawStoredSeries::consBatchNode(uint64_t nextPtr) {
   *this->headNodeRef = this->batchNode;
 }
 
-typedef array<int>           PBatch;
-typedef fileref<PBatch*>     PBatchRef;
-typedef dbseq<PBatchRef>     PBatchList;
-typedef fileref<PBatchList*> PBatchListRef;
+using PBatch = array<int>;
+using PBatchRef = fileref<PBatch *>;
+using PBatchList = dbseq<PBatchRef>;
+using PBatchListRef = fileref<PBatchList *>;
 
 void RawStoredSeries::restartFromBatchNode() {
-  PBatchList* n = reinterpret_cast<PBatchList*>(this->outputFile->unsafeLoad(*this->headNodeRef, sizeof(PBatchList)));
+  auto* n = reinterpret_cast<PBatchList*>(this->outputFile->unsafeLoad(*this->headNodeRef, sizeof(PBatchList)));
   
   // if we somehow get a root node representing the empty list, we're free to start a fresh list
   const PBatchList::cons_t* p = n->head();
-  if (!p) {
+  if (p == nullptr) {
     consBatchNode(allocBatchNode(this->outputFile));
     return;
   }
@@ -441,14 +441,14 @@ void RawStoredSeries::restartFromBatchNode() {
 }
 
 uint64_t RawStoredSeries::allocBatchNode(writer* file) {
-  PBatchList* b = new (file->store<PBatchList*>()) PBatchList();
+  auto* b = new (file->store<PBatchList*>()) PBatchList();
   uint64_t    r = file->offsetOf(b).index;
   file->unmap(b);
   return r;
 }
 
 uint64_t RawStoredSeries::allocBatchNode(writer* file, uint64_t batchOffset, uint64_t nextNodeOffset) {
-  PBatchList* b = new (file->store<PBatchList*>()) PBatchList(PBatchRef(batchOffset), PBatchListRef(nextNodeOffset));
+  auto* b = new (file->store<PBatchList*>()) PBatchList(PBatchRef(batchOffset), PBatchListRef(nextNodeOffset));
   uint64_t    r = file->offsetOf(b).index;
 
   file->unmap(b);
@@ -517,7 +517,7 @@ size_t makeCRootRef(writer* file, const MonoTypePtr&) {
 size_t makeCRootRef(writer* file, const std::string& fn, const MonoTypePtr& cseqType) {
   using namespace hobbes::fregion;
 
-  auto fd = file->fileData();
+  auto *fd = file->fileData();
   auto b  = fd->bindings.find(fn);
 
   if (b == fd->bindings.end()) {
@@ -525,7 +525,7 @@ size_t makeCRootRef(writer* file, const std::string& fn, const MonoTypePtr& cseq
     encode(cseqType, &cseqTypeEnc);
 
     size_t  headNodeRef = findSpace(fd, pagetype::data, sizeof(size_t), sizeof(size_t));
-    size_t* headNode    = reinterpret_cast<size_t*>(mapFileData(fd, headNodeRef, sizeof(size_t)));
+    auto* headNode    = reinterpret_cast<size_t*>(mapFileData(fd, headNodeRef, sizeof(size_t)));
     *headNode = findSpace(fd, pagetype::data, 3*sizeof(size_t), sizeof(size_t));
     size_t hn = *headNode;
 
@@ -534,7 +534,7 @@ size_t makeCRootRef(writer* file, const std::string& fn, const MonoTypePtr& cseq
 
     return hn;
   } else {
-    size_t* hnr = reinterpret_cast<size_t*>(mapFileData(fd, b->second.offset, sizeof(size_t)));
+    auto* hnr = reinterpret_cast<size_t*>(mapFileData(fd, b->second.offset, sizeof(size_t)));
     size_t  hn  = *hnr;
 
     unmapFileData(fd, hnr, sizeof(size_t));
@@ -552,7 +552,7 @@ static CompressedStoredSeries::CWriteFn compressedWriteFunction(cc* c, const Mon
   auto la = LexicalAnnotation::null();
   auto mt = decideModelType(c, t);
 
-  if (is<Record>(t)) {
+  if (is<Record>(t) != nullptr) {
     return reinterpret_cast<CompressedStoredSeries::CWriteFn>(
       c->unsafeCompileFn(
         primty("unit"),
@@ -571,13 +571,13 @@ static CompressedStoredSeries::CAllocM compressedMAllocFn(cc* c, const MonoTypeP
   auto la = LexicalAnnotation::null();
   auto mt = decideModelType(c, t);
 
-  if (is<Record>(t)) {
+  if (is<Record>(t) != nullptr) {
     return reinterpret_cast<CompressedStoredSeries::CAllocM>(
       c->unsafeCompileFn(
         mt.second,
         str::strings("f"),
         list(tapp(primty("file"), list(primty("unit"), primty("unit")))),
-        fncall(assume(var("ucAllocModel", la), qualtype(list(ConstraintPtr(new Constraint("UCModel", list(t, freshTypeVar(), freshTypeVar())))), freshTypeVar()), la), list(var("f", la), constant(false, la)), la)
+        fncall(assume(var("ucAllocModel", la), qualtype(list(std::make_shared<Constraint>("UCModel", list(t, freshTypeVar(), freshTypeVar()))), freshTypeVar()), la), list(var("f", la), constant(false, la)), la)
       )
     );
   } else {
@@ -590,14 +590,14 @@ static CompressedStoredSeries::CPrepM compressedMPrepFn(cc* c, const MonoTypePtr
   auto la = LexicalAnnotation::null();
   auto mt = decideModelType(c, t);
 
-  if (is<Record>(t)) {
+  if (is<Record>(t) != nullptr) {
     // (ucPrepModel::(UCModel t sm dm)=>_)(unsafeCast(ucWriterModelData(w))::sm, dm);
     return reinterpret_cast<CompressedStoredSeries::CPrepM>(
       c->unsafeCompileFn(
         primty("unit"),
         str::strings("w", "dm"),
         list(lift<UCWriter*>::type(*c), mt.second),
-        fncall(assume(var("ucPrepModel", la), qualtype(list(ConstraintPtr(new Constraint("UCModel", list(t, mt.first, mt.second)))), freshTypeVar()), la), list(
+        fncall(assume(var("ucPrepModel", la), qualtype(list(std::make_shared<Constraint>("UCModel", list(t, mt.first, mt.second))), freshTypeVar()), la), list(
           fncall(var("unsafeCast", la), list(fncall(var("ucWriterModelData", la), var("w", la), la)), la),
           var("dm", la)
         ), la)
@@ -613,13 +613,13 @@ static CompressedStoredSeries::CDeallocM compressedMDeallocFn(cc* c, const MonoT
   auto la = LexicalAnnotation::null();
   auto mt = decideModelType(c, t);
 
-  if (is<Record>(t)) {
+  if (is<Record>(t) != nullptr) {
     return reinterpret_cast<CompressedStoredSeries::CDeallocM>(
       c->unsafeCompileFn(
         primty("unit"),
         str::strings("m"),
         list(mt.second),
-        fncall(assume(var("ucDeallocModel", la), qualtype(list(ConstraintPtr(new Constraint("UCModel", list(t, freshTypeVar(), freshTypeVar())))), freshTypeVar()), la), list(var("m", la)), la)
+        fncall(assume(var("ucDeallocModel", la), qualtype(list(std::make_shared<Constraint>("UCModel", list(t, freshTypeVar(), freshTypeVar()))), freshTypeVar()), la), list(var("m", la)), la)
       )
     );
   } else {
@@ -709,7 +709,7 @@ static void unsafeWriteToCSeries(long css, char* rec) {
 }
 
 static void unsafeWriteUnitToCSeries(long css) {
-  reinterpret_cast<CompressedStoredSeries*>(css)->record(0, false);
+  reinterpret_cast<CompressedStoredSeries*>(css)->record(nullptr, false);
 }
 
 void CompressedStoredSeries::bindAs(cc* c, const std::string& vname) {
@@ -732,7 +732,7 @@ void CompressedStoredSeries::bindAs(cc* c, const std::string& vname) {
         nla
       )
     );
-  } else if(is<Record>(this->recordType)) {
+  } else if(is<Record>(this->recordType) != nullptr) {
     // vname = \x.unsafeWriteToSeries(this, unsafeCast(x :: ty))
     c->define(
       vname,
diff --git a/lib/hobbes/db/signals.C b/lib/hobbes/db/signals.C
index 1509f63cf..87ed32bf4 100644
--- a/lib/hobbes/db/signals.C
+++ b/lib/hobbes/db/signals.C
@@ -1,14 +1,14 @@
 
-#include <hobbes/db/signals.H>
+#include <atomic>
+#include <cerrno>
+#include <cstring>
 #include <hobbes/db/file.H>
+#include <hobbes/db/signals.H>
 #include <hobbes/events/events.H>
-#include <hobbes/util/os.H>
 #include <hobbes/hobbes.H>
-#include <vector>
+#include <hobbes/util/os.H>
 #include <set>
-#include <atomic>
-#include <string.h>
-#include <errno.h>
+#include <vector>
 
 #ifdef BUILD_LINUX
 #include <sys/inotify.h>
@@ -17,11 +17,11 @@
 namespace hobbes {
 
 // imported from 'bindings' (some refactoring might be good here)
-typedef std::pair<MonoTypePtr, ExprPtr> FRefT;
+using FRefT = std::pair<MonoTypePtr, ExprPtr>;
 FRefT assumeFRefT(const MonoTypePtr&, const LexicalAnnotation&);
 
-typedef std::pair<bool, MonoTypePtr> UTFileConfig;
-typedef std::pair<bool, const Record*> FileConfig;
+using UTFileConfig = std::pair<bool, MonoTypePtr>;
+using FileConfig = std::pair<bool, const Record *>;
 bool unpackFileType(const MonoTypePtr& fty, UTFileConfig* fcfg);
 bool unpackFileType(const MonoTypePtr& fty, FileConfig* fcfg);
 
@@ -29,10 +29,10 @@ MonoTypePtr injFileReferences(const MonoTypePtr&, const ExprPtr&);
 
 // raise a signal when a particular range of bytes in a file have been changed
 // (and include the reference to the file offset that changed)
-typedef bool (*ChangeSignal)(long);
-typedef std::set<ChangeSignal> ChangeSignals;
+using ChangeSignal = bool (*)(long);
+using ChangeSignals = std::set<ChangeSignal>;
 
-typedef std::vector<uint8_t> bytes;
+using bytes = std::vector<uint8_t>;
 
 enum BROffsetType : uint8_t { Binding=0, DArray=1, Value=2 };
 
@@ -43,7 +43,7 @@ struct ByteRangeWatch {
   ChangeSignals          fs;
 };
 
-typedef std::map<uint64_t, ByteRangeWatch> ByteRangeWatches;
+using ByteRangeWatches = std::map<uint64_t, ByteRangeWatch>;
 
 struct FileWatch {
   std::string      filePath;
@@ -65,7 +65,7 @@ void sweepFileWatch(FileWatch& fw) {
       size_t ref = brw.offType==BROffsetType::DArray ? (brwp.first - sizeof(size_t)) : brw.offType==BROffsetType::Binding ? newValue : brwp.first;
       brw.oldValue = newValue;
 
-      for (ChangeSignals::iterator f = brw.fs.begin(); f != brw.fs.end();) {
+      for (auto f = brw.fs.begin(); f != brw.fs.end();) {
         if ((*f)(ref)) {
           ++f;
         } else {
@@ -74,7 +74,7 @@ void sweepFileWatch(FileWatch& fw) {
       }
     }
 
-    if (brw.fs.size() > 0) {
+    if (!brw.fs.empty()) {
       ++brwi;
     } else {
       fw.byteRangeWatches.erase(brwi++);
@@ -82,7 +82,7 @@ void sweepFileWatch(FileWatch& fw) {
   }
 }
 
-typedef std::vector<FileWatch> FileWatches;
+using FileWatches = std::vector<FileWatch>;
 
 #ifdef BUILD_LINUX
 // on Linux, we can use inotify to watch for file updates
@@ -101,7 +101,7 @@ struct SystemWatch {
       fd,
       [](int fd, void* self) {
         char buf[sizeof(inotify_event) + NAME_MAX + 1];
-        inotify_event* event = reinterpret_cast<inotify_event*>(buf);
+        auto* event = reinterpret_cast<inotify_event*>(buf);
         auto rc = read(fd, event, sizeof(inotify_event));
         if (rc > 0 && event->len > 0 ) {
           rc = read(fd, event->name, event->len);
@@ -196,9 +196,9 @@ SystemWatch* watcher() {
 }
 #endif
 
-typedef std::pair<uint8_t, uint64_t>                            IsArrOldVal;
-typedef std::pair<uint64_t, IsArrOldVal>                        OffsetData;
-typedef std::pair<const array<char>*, const array<OffsetData>*> FileWatchData;
+using IsArrOldVal = std::pair<uint8_t, uint64_t>;
+using OffsetData = std::pair<uint64_t, IsArrOldVal>;
+using FileWatchData = std::pair<const array<char> *, const array<OffsetData> *>;
 
 const array<FileWatchData>* fileWatchData() {
   const SystemWatch&    w = *watcher();
@@ -250,7 +250,7 @@ void addFileSOSignal(long file, unsigned int so, ChangeSignal f) {
 const MonoTypePtr& frefType(const MonoTypePtr& fref);
 
 struct addFileSignalF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     FRefT frt = assumeFRefT(tys[0], es[0]->la());
 
     llvm::Value* db  = c->compileAtGlobalScope(frt.second);
@@ -258,7 +258,7 @@ struct addFileSignalF : public op {
     llvm::Value* sfn = c->compile(es[1]);
 
     llvm::Function* f = c->lookupFunction(".addFileSignal");
-    if (!f) { throw std::runtime_error("Expected 'addFileSignal' function as call"); }
+    if (f == nullptr) { throw std::runtime_error("Expected 'addFileSignal' function as call"); }
 
     size_t      sz     = 0;
     MonoTypePtr refty  = frefType(tys[0]);
@@ -276,7 +276,7 @@ struct addFileSignalF : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     MonoTypePtr tg0(TGen::make(0));
     MonoTypePtr tg1(TGen::make(1));
     MonoTypePtr fr = fileRefTy(tg0, tg1);
@@ -302,11 +302,11 @@ bool pullTypeArg(const std::string& fname, size_t idx, MonoTypePtr* p, const Mon
 
 // alias the file and 'signals' type as a way of getting at top-level file addresses
 class signalsF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return c->compile(es[0]);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     MonoTypePtr fty = tapp(primty("file"), list(tgen(0), tgen(1)));
     MonoTypePtr sty = tapp(primty("signals", primty("unit")), list(tgen(1)));
     return polytype(2, qualtype(functy(list(fty), sty)));
@@ -316,11 +316,11 @@ class signalsF : public op {
 // add signals for top-level file variables
 class AddDBFieldSignal : public HFEliminator {
 public:
-  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*);
-  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const;
-  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const;
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const;
-  std::string name() const;
+  bool refine(const TEnvPtr&, const HasField&, MonoTypeUnifier*, Definitions*) override;
+  bool satisfied(const TEnvPtr&, const HasField&, Definitions*) const override;
+  bool satisfiable(const TEnvPtr&, const HasField&, Definitions*) const override;
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*) const override;
+  std::string name() const override;
 };
 
 const Record* signalRecord(const MonoTypePtr& r) {
@@ -331,7 +331,7 @@ const Record* signalRecord(const MonoTypePtr& r) {
       }
     }
   }
-  return 0;
+  return nullptr;
 }
 
 ExprPtr sigFileExpr(const ExprPtr& e) {
@@ -404,14 +404,14 @@ bool AddDBFieldSignal::satisfiable(const TEnvPtr& tenv, const HasField& hf, Defi
 
   if (dir != HasField::Write) return false;
 
-  if (is<TString>(fname)) {
+  if (is<TString>(fname) != nullptr) {
     if (hf.recordExpr) {
       return !isMonoSingular(fty) || satisfied(tenv, hf, ds);
     } else {
-      return is<TVar>(rty);
+      return is<TVar>(rty) != nullptr;
     }
   } else {
-    return is<TVar>(fname);
+    return is<TVar>(fname) != nullptr;
   }
 }
 
@@ -438,7 +438,7 @@ struct ADBFSigUnqualify : public switchExprTyFn {
         this->frec   = signalRecord(this->stype);
         this->findex = this->frec->index(this->fname);
 
-        return this->frec != 0;
+        return this->frec != nullptr;
       }
     }
     return false;
@@ -454,7 +454,7 @@ struct ADBFSigUnqualify : public switchExprTyFn {
     return *ty == *this->stype;
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     ExprPtr aresult(new Assump(result, result->type(), result->la()));
@@ -462,9 +462,9 @@ struct ADBFSigUnqualify : public switchExprTyFn {
     return aresult;
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     const Func* fty = is<Func>(v->type()->monoType());
-    if (!fty) {
+    if (fty == nullptr) {
       throw annotated_error(*v, "Internal error, expected annotated function type");
     }
     return wrapWithTy(v->type(),
@@ -476,7 +476,7 @@ struct ADBFSigUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return wrapWithTy(v->type(),
       new Let(
         v->var(),
@@ -487,7 +487,7 @@ struct ADBFSigUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     const auto& la = v->la();
 
     // set a signal callback
diff --git a/lib/hobbes/eval/cc.C b/lib/hobbes/eval/cc.C
index 3c8ece766..6c3eb930e 100644
--- a/lib/hobbes/eval/cc.C
+++ b/lib/hobbes/eval/cc.C
@@ -24,10 +24,11 @@
 #include <csignal>
 #include <cstdlib>
 
-#include <stdexcept>
-#include <unordered_map>
 #include <fstream>
+#include <memory>
 #include <mutex>
+#include <stdexcept>
+#include <unordered_map>
 
 namespace hobbes {
 
@@ -62,7 +63,7 @@ cc::cc() :
   // this seems to want to be a very primitive type class ...
   TClass::Members cvtcms;
   cvtcms["convert"] = functy(list(tgen(0)), tgen(1));
-  TClass* cvtc = new TClass("Convert", 2, cvtcms, FunDeps(), LexicalAnnotation::null());
+  auto* cvtc = new TClass("Convert", 2, cvtcms, FunDeps(), LexicalAnnotation::null());
   this->tenv->bind("Convert", UnqualifierPtr(cvtc));
 
   // support equality constraints
@@ -91,12 +92,12 @@ cc::cc() :
   this->tenv->bind(FixIsoRecur::constraintName(), UnqualifierPtr(new FixIsoRecur()));
 
   // support subtype constraints (including safe upcasting between C++ objects)
-  SubtypeUnqualifier* subuq = new SubtypeUnqualifier();
+  auto* subuq = new SubtypeUnqualifier();
   subuq->addEliminator(this->objs);
   this->tenv->bind(SubtypeUnqualifier::constraintName(), UnqualifierPtr(subuq));
 
   // support constraints on "field projection" (for records, "objects", ...)
-  FieldVerifier* fv = new FieldVerifier();
+  auto* fv = new FieldVerifier();
   this->tenv->bind(FieldVerifier::constraintName(), UnqualifierPtr(fv));
 
   // support constraints on "selective construction" (for variants, ...)
@@ -184,16 +185,16 @@ ExprPtr cc::normalize(const ExprPtr& e) {
 }
 
 llvm::GlobalVariable* extractGlobal(llvm::Value* e) {
-  if (llvm::GlobalVariable* g = llvm::dyn_cast<llvm::GlobalVariable>(e)) {
+  if (auto* g = llvm::dyn_cast<llvm::GlobalVariable>(e)) {
     return g;
-  } else if (llvm::ConstantExpr* c = llvm::dyn_cast<llvm::ConstantExpr>(e)) {
+  } else if (auto* c = llvm::dyn_cast<llvm::ConstantExpr>(e)) {
     if (c->isCast() && c->getNumOperands() == 1) {
       return extractGlobal(c->getOperand(0));
     } else {
-      return 0;
+      return nullptr;
     }
   } else {
-    return 0;
+    return nullptr;
   }
 }
 
@@ -250,9 +251,9 @@ void cc::drainUnqualifyDefs(const Definitions& ds) {
   this->drainingDefs = true;
 
   // forward declare the polymorphic functions, batch letrec compile the monomorphic functions
-  for (Definitions::const_iterator d = ds.begin(); d != ds.end(); ++d) {
-    const std::string& vname = d->first;
-    const ExprPtr&     e     = d->second;
+  for (const auto &d : ds) {
+    const std::string& vname = d.first;
+    const ExprPtr&     e     = d.second;
 
     bool forwardDeclared = this->tenv->hasBinding(vname) && !hasValueBinding(vname);
 
@@ -277,7 +278,7 @@ void cc::drainUnqualifyDefs(const Definitions& ds) {
   if (finaldef) {
     this->drainingDefs = false;
 
-    if (this->drainDefs.size() > 0) {
+    if (!this->drainDefs.empty()) {
       this->jit->compileFunctions(this->drainDefs);
       this->drainDefs.clear();
     }
@@ -347,18 +348,18 @@ bool cc::isTypeAliasName(const std::string& name) const {
 }
 
 struct repTypeAliasesF : public switchTyFn {
-  typedef std::pair<str::seq, MonoTypePtr>        TTyDef;
-  typedef std::unordered_map<std::string, TTyDef> TTyDefs;
+  using TTyDef = std::pair<str::seq, MonoTypePtr>;
+  using TTyDefs = std::unordered_map<std::string, TTyDef>;
   const TTyDefs& ttyDefs;
  
   repTypeAliasesF(const TTyDefs& ttyDefs) : ttyDefs(ttyDefs) {
   }
 
-  MonoTypePtr with(const Prim* v) const {
+  MonoTypePtr with(const Prim* v) const override {
     if (!v->representation()) {
       auto td = this->ttyDefs.find(v->name());
       if (td != this->ttyDefs.end()) {
-        if (td->second.first.size() == 0) {
+        if (td->second.first.empty()) {
           return td->second.second;
         }
       }
@@ -366,7 +367,7 @@ struct repTypeAliasesF : public switchTyFn {
     return Prim::make(v->name(), v->representation());
   }
 
-  MonoTypePtr with(const TApp* v) const {
+  MonoTypePtr with(const TApp* v) const override {
     if (const Prim* f = is<Prim>(v->fn())) {
       auto td = this->ttyDefs.find(f->name());
       if (td != this->ttyDefs.end()) {
@@ -416,7 +417,7 @@ MonoTypePtr cc::opaquePtrMonoType(const std::type_info& ti, unsigned int sz, boo
     // OK, we don't know what this type looks like so we'll give it an opaque pointer type
     // but strip the pointer char from the name, we assume opaqueptr types are always pointers
     std::string tn = str::demangle(ti.name());
-    while (tn.size()>0 && tn.back()=='*') {
+    while (!tn.empty() && tn.back()=='*') {
       tn=tn.substr(0,tn.size()-1);
     }
     return MonoTypePtr(OpaquePtr::make(tn, sz, inStruct));
@@ -433,9 +434,9 @@ void cc::overload(const std::string& tyclass, const MonoTypes& tys) {
   UnqualifierPtr tyc = this->tenv->lookupUnqualifier(tyclass);
   TClassPtr      c   = std::dynamic_pointer_cast<TClass>(tyc);
   
-  if (c.get() == 0) {
+  if (c.get() == nullptr) {
     throw std::runtime_error("Cannot define overload in '" + tyclass + "', class does not exist.");
-  } else if (c->members().size() != 0) {
+  } else if (!c->members().empty()) {
     throw std::runtime_error("Cannot define partial overload for type class '" + tyclass + "', which has " + str::from(c->members().size()) + " members.");
   }
 
@@ -443,7 +444,7 @@ void cc::overload(const std::string& tyclass, const MonoTypes& tys) {
 
   if (tgenSize(tys) == 0) {
     Definitions ds;
-    c->insert(typeEnv(), TCInstancePtr(new TCInstance(tyclass, tys, insts, LexicalAnnotation::null())), &ds);
+    c->insert(typeEnv(), std::make_shared<TCInstance>(tyclass, tys, insts, LexicalAnnotation::null()), &ds);
     drainUnqualifyDefs(ds);
   } else {
     throw std::runtime_error("cc::overload forgot how to produce instance functions");
@@ -455,7 +456,7 @@ void cc::overload(const std::string& tyclass, const MonoTypes& tys, const ExprPt
   UnqualifierPtr tyc = this->tenv->lookupUnqualifier(tyclass);
   TClassPtr      c   = std::dynamic_pointer_cast<TClass>(tyc);
   
-  if (c.get() == 0) {
+  if (c.get() == nullptr) {
     throw std::runtime_error("Cannot define overload in '" + tyclass + "', class does not exist.");
   } else if (c->members().size() != 1) {
     throw std::runtime_error("Cannot define partial overload for type class '" + tyclass + "', which has " + str::from(c->members().size()) + " members.");
@@ -466,7 +467,7 @@ void cc::overload(const std::string& tyclass, const MonoTypes& tys, const ExprPt
 
   if (tgenSize(tys) == 0) {
     Definitions ds;
-    c->insert(typeEnv(), TCInstancePtr(new TCInstance(tyclass, tys, insts, e->la())), &ds);
+    c->insert(typeEnv(), std::make_shared<TCInstance>(tyclass, tys, insts, e->la()), &ds);
     drainUnqualifyDefs(ds);
   } else {
     throw std::runtime_error("cc::overload forgot how to produce instance functions");
@@ -486,7 +487,7 @@ void cc::addInstance(const TClassPtr& c, const TCInstancePtr& i) {
 
 MonoTypePtr cc::defineNamedType(const std::string& name, const str::seq& argNames, const MonoTypePtr& ty) {
   hlock _;
-  if (argNames.size() > 0) {
+  if (!argNames.empty()) {
     MonoTypePtr tfn    = tabs(argNames, ty);
     MonoTypePtr talias = MonoTypePtr(Prim::make(name, tfn));
     MonoTypePtr tappd  = tapp(talias, typeVars(argNames));
@@ -526,9 +527,9 @@ void cc::dumpTypeEnv(std::function<std::string const&(std::string const&)> const
 }
 
 void cc::dumpTypeEnv(str::seq* syms, str::seq* types, std::function<std::string const&(std::string const&)> const& rewriteFn) const {
-  for (auto te : this->tenv->typeEnvTable(rewriteFn)) {
+  for (const auto& te : this->tenv->typeEnvTable(rewriteFn)) {
     // don't show hidden symbols since they're not meant for users
-    if (te.first.size() > 0 && te.first[0] != '.') {
+    if (!te.first.empty() && te.first[0] != '.') {
       syms->push_back(te.first);
 
       auto t = te.second->instantiate();
@@ -600,7 +601,7 @@ void* cc::memalloc(size_t sz, size_t asz) {
 }
 
 inline TEnvPtr allocTEnvFrame(const str::seq& names, const MonoTypes& tys, const TEnvPtr& ptenv) {
-  if (names.size() == 0) {
+  if (names.empty()) {
     return ptenv;
   } else {
     TEnvPtr r(new TEnv(ptenv));
@@ -616,7 +617,7 @@ void* cc::unsafeCompileFn(const MonoTypePtr& retTy, const str::seq& tnames, cons
   hlock _;
   str::seq names = tnames;
 
-  if (names.size() == 0 && argTys.size() == 1 && isUnit(argTys[0])) {
+  if (names.empty() && argTys.size() == 1 && isUnit(argTys[0])) {
     names.push_back("_");
   } else if (names.size() != argTys.size()) {
     std::ostringstream ss;
diff --git a/lib/hobbes/eval/cexpr.C b/lib/hobbes/eval/cexpr.C
index 1a1124b01..488cda026 100644
--- a/lib/hobbes/eval/cexpr.C
+++ b/lib/hobbes/eval/cexpr.C
@@ -28,9 +28,9 @@ Values removeUnit(const Values& vs, const MonoTypes& mts) {
 
 MonoTypes removeUnit(const MonoTypes& mts) {
   MonoTypes r;
-  for (MonoTypes::const_iterator mt = mts.begin(); mt != mts.end(); ++mt) {
-    if (!isUnit(*mt)) {
-      r.push_back(*mt);
+  for (const auto &mt : mts) {
+    if (!isUnit(mt)) {
+      r.push_back(mt);
     }
   }
   return r;
@@ -38,9 +38,9 @@ MonoTypes removeUnit(const MonoTypes& mts) {
 
 Record::Members removeUnit(const Record::Members& ms) {
   Record::Members r;
-  for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    if (!isUnit(m->type)) {
-      r.push_back(*m);
+  for (const auto &m : ms) {
+    if (!isUnit(m.type)) {
+      r.push_back(m);
     }
   }
   return r;
@@ -49,16 +49,16 @@ Record::Members removeUnit(const Record::Members& ms) {
 // compile int constants for int switches
 class compileIntConstF : public switchConst<llvm::ConstantInt*> {
 public:
-  llvm::ConstantInt* with(const Unit*   v) const { return fail(*v); }
-  llvm::ConstantInt* with(const Bool*   v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Char*   v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Byte*   v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Short*  v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Int*    v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Long*   v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Int128* v) const { return civalue(v->value()); }
-  llvm::ConstantInt* with(const Float*  v) const { return fail(*v); }
-  llvm::ConstantInt* with(const Double* v) const { return fail(*v); }
+  llvm::ConstantInt* with(const Unit*   v) const override { return fail(*v); }
+  llvm::ConstantInt* with(const Bool*   v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Char*   v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Byte*   v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Short*  v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Int*    v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Long*   v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Int128* v) const override { return civalue(v->value()); }
+  llvm::ConstantInt* with(const Float*  v) const override { return fail(*v); }
+  llvm::ConstantInt* with(const Double* v) const override { return fail(*v); }
 private:
   llvm::ConstantInt* fail(const LexicallyAnnotated& la) const {
     throw annotated_error(la, "Internal error, can't switch on non-integral type");
@@ -75,25 +75,25 @@ public:
   compileExpF(const std::string& vname, jitcc* c) : c(c), vname(vname) {
   }
 
-  llvm::Value* with(const Unit*    ) const { return cvalue(true); } // should get optimized away -- unit should have no runtime representation
-  llvm::Value* with(const Bool*   v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Char*   v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Byte*   v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Short*  v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Int*    v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Long*   v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Int128* v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Float*  v) const { return cvalue(v->value()); }
-  llvm::Value* with(const Double* v) const { return cvalue(v->value()); }
+  llvm::Value* with(const Unit*    ) const override { return cvalue(true); } // should get optimized away -- unit should have no runtime representation
+  llvm::Value* with(const Bool*   v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Char*   v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Byte*   v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Short*  v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Int*    v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Long*   v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Int128* v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Float*  v) const override { return cvalue(v->value()); }
+  llvm::Value* with(const Double* v) const override { return cvalue(v->value()); }
 
-  llvm::Value* with(const Var* v) const {
+  llvm::Value* with(const Var* v) const override {
     return c->lookupVar(v->value(), requireMonotype(v->type()));
   }
 
-  llvm::Value* with(const Let* v) const {
+  llvm::Value* with(const Let* v) const override {
     // compile the bound variable's value
     llvm::Value* var  = compile(v->varExpr());
-    llvm::Value* body = 0;
+    llvm::Value* body = nullptr;
 
     try {
       beginScope(v->var(), var);
@@ -107,7 +107,7 @@ public:
     return body;
   }
 
-  llvm::Value* with(const LetRec* v) const {
+  llvm::Value* with(const LetRec* v) const override {
     try {
       this->c->pushScope();
       this->c->compileFunctions(v->bindings());
@@ -120,9 +120,9 @@ public:
     }
   }
 
-  llvm::Value* with(const Fn* v) const {
+  llvm::Value* with(const Fn* v) const override {
     Func* fty = is<Func>(requireMonotype(v->type()));
-    if (!fty) {
+    if (fty == nullptr) {
       throw annotated_error(*v, "Internal compiler error, not a function type: " + show(v->type()));
     }
 
@@ -137,7 +137,7 @@ public:
     }
   }
 
-  llvm::Value* with(const App* v) const {
+  llvm::Value* with(const App* v) const override {
     // for the special case of "operators", we should allow them to decide how to compile
     //   this allows us to use primitive instructions / control-flow
     if (Var* fv = is<Var>(stripAssumpHead(v->fn()))) {
@@ -155,7 +155,7 @@ public:
     });
   }
 
-  llvm::Value* with(const Assign* v) const {
+  llvm::Value* with(const Assign* v) const override {
     MonoTypePtr lty = requireMonotype(v->left()->type());
     MonoTypePtr rty = requireMonotype(v->right()->type());
 
@@ -177,10 +177,10 @@ public:
     }
   }
 
-  llvm::Value* with(const MkArray* v) const {
+  llvm::Value* with(const MkArray* v) const override {
     MonoTypePtr ty  = requireMonotype(v->type());
-    Array*      aty = is<Array>(ty);
-    if (aty == 0) {
+    auto*      aty = is<Array>(ty);
+    if (aty == nullptr) {
       throw annotated_error(*v, "Internal compiler error -- can't make array out of non-array type: " + show(ty));
     }
 
@@ -189,7 +189,7 @@ public:
     if (llvm::Value* cr = compileConstArray(aty->type(), vs)) {
       return cr;
     } else {
-      bool         isStoredPtr = is<OpaquePtr>(aty->type()) || is<Func>(aty->type()); // consistent with ctype.C, store opaque ptrs and functions in arrays as pointers
+      bool         isStoredPtr = (is<OpaquePtr>(aty->type()) != nullptr) || (is<Func>(aty->type()) != nullptr); // consistent with ctype.C, store opaque ptrs and functions in arrays as pointers
       llvm::Type*  elemTy      = toLLVM(aty->type(), isStoredPtr);
       llvm::Value* p           = compileAllocStmt(sizeof(long) + sizeOf(aty->type()) * vs.size(), std::max<size_t>(sizeof(long), alignment(aty->type())), ptrType(llvmVarArrType(elemTy)));
 
@@ -220,7 +220,7 @@ public:
     }
   }
 
-  llvm::Value* with(const MkVariant* v) const {
+  llvm::Value* with(const MkVariant* v) const override {
     MonoTypePtr mvty = requireMonotype(v->type());
     const Variant *vty = is<Variant>(mvty);
     if (vty == nullptr && show(v->value()) == "()") {
@@ -233,7 +233,7 @@ public:
         });
       }
     }
-    if (!vty) { throw annotated_error(*v, "Internal compiler error, compiling variant without penum/variant type: " + show(v) + " :: " + show(v->type())); }
+    if (vty == nullptr) { throw annotated_error(*v, "Internal compiler error, compiling variant without penum/variant type: " + show(v) + " :: " + show(v->type())); }
 
     llvm::Value* p  = compileAllocStmt(sizeOf(mvty), alignment(mvty), ptrType(byteType()));
     llvm::Value* tg = cvalue(vty->id(v->label()));
@@ -261,15 +261,15 @@ public:
     });
   }
 
-  llvm::Value* with(const MkRecord* v) const {
+  llvm::Value* with(const MkRecord* v) const override {
     MonoTypePtr mrty = requireMonotype(v->type());
-    Record*     rty  = is<Record>(mrty);
-    if (!rty) { throw annotated_error(*v, "Internal compiler error, compiling record without record type: " + show(v) + " :: " + show(v->type())); }
+    auto*     rty  = is<Record>(mrty);
+    if (rty == nullptr) { throw annotated_error(*v, "Internal compiler error, compiling record without record type: " + show(v) + " :: " + show(v->type())); }
 
     RecordValue vs = compileRecordFields(v->fields());
 
     // for the odd case where all fields are unit
-    if (vs.size() == 0) {
+    if (vs.empty()) {
       return cvalue(true);
     }
 
@@ -278,10 +278,10 @@ public:
     } else {
       llvm::Value* p = compileAllocStmt(sizeOf(mrty), alignment(mrty), toLLVM(mrty, true));
 
-      for (RecordValue::const_iterator rv = vs.begin(); rv != vs.end(); ++rv) {
-        llvm::Value* fv  = rv->second;
-        llvm::Value* fp  = structFieldPtr(p, rty->alignedIndex(rv->first));
-        MonoTypePtr  fty = rty->member(rv->first);
+      for (const auto &v : vs) {
+        llvm::Value* fv  = v.second;
+        llvm::Value* fp  = structFieldPtr(p, rty->alignedIndex(v.first));
+        MonoTypePtr  fty = rty->member(v.first);
 
         withContext([&](auto&) {
           if (isLargeType(fty)) {
@@ -296,7 +296,7 @@ public:
     }
   }
 
-  llvm::Value* with(const AIndex* v) const {
+  llvm::Value* with(const AIndex* v) const override {
     MonoTypePtr  aity = requireMonotype(v->type());
     llvm::Value* ar   = compile(v->array());
     llvm::Value* ir   = compile(v->index());
@@ -318,22 +318,22 @@ public:
 
   // apply a case expression's default expression across every constructor not accounted for
   void resolveCaseDefault(const Variant* vty, Case* v) const {
-    if (v->defaultExpr().get() != 0) {
+    if (v->defaultExpr().get() != nullptr) {
       std::string pn = freshName();
 
-      for (Variant::Members::const_iterator vm = vty->members().begin(); vm != vty->members().end(); ++vm) {
-        if (!v->hasBinding(vm->selector)) {
-          v->addBinding(vm->selector, pn, v->defaultExpr());
+      for (const auto &vm : vty->members()) {
+        if (!v->hasBinding(vm.selector)) {
+          v->addBinding(vm.selector, pn, v->defaultExpr());
         }
       }
     }
   }
 
-  llvm::Value* with(const Case* v) const {
+  llvm::Value* with(const Case* v) const override {
     MonoTypePtr casety = requireMonotype(v->type());
     MonoTypePtr varty  = requireMonotype(v->variant()->type());
-    Variant*    vty    = is<Variant>(varty);
-    if (!vty) {
+    auto*    vty    = is<Variant>(varty);
+    if (vty == nullptr) {
       throw annotated_error(*v, "Internal compiler error (received non-variant type in case).");
     }
     resolveCaseDefault(vty, const_cast<Case*>(v));
@@ -359,32 +359,32 @@ public:
       return builder()->CreateSwitch(tag, failBlock, v->bindings().size());
     });
 
-    typedef std::pair<llvm::Value*, llvm::BasicBlock*> MergeLink;
-    typedef std::vector<MergeLink> MergeLinks;
+    using MergeLink = std::pair<llvm::Value *, llvm::BasicBlock *>;
+    using MergeLinks = std::vector<MergeLink>;
     MergeLinks mergeLinks;
 
-    for (Case::Bindings::const_iterator b = v->bindings().begin(); b != v->bindings().end(); ++b) {
-      unsigned int      caseID    = vty->id(b->selector);
+    for (const auto &b : v->bindings()) {
+      unsigned int      caseID    = vty->id(b.selector);
       withContext([&](llvm::LLVMContext& c) {
         llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(c, "case_" + str::from(caseID), thisFn);
 
         builder()->SetInsertPoint(caseBlock);
         try {
-          MonoTypePtr valty = vty->payload(b->selector);
+          MonoTypePtr valty = vty->payload(b.selector);
 
           if (isUnit(valty)) {
-            beginScope(b->vname, cvalue(true)); // this is unit, so should never be looked at
+            beginScope(b.vname, cvalue(true)); // this is unit, so should never be looked at
           } else {
             // otherwise the data here is available inline
             // (and functions are stored as pointers)
-            llvm::Type*  lty      = toLLVM(valty, is<Func>(valty));
+            llvm::Type*  lty      = toLLVM(valty, is<Func>(valty) != nullptr);
             llvm::Value* pointval = builder()->CreateBitCast(pval, ptrType(lty));
             llvm::Value* val      = isLargeType(valty) ? pointval : builder()->CreateLoad(pointval, false);
 
-            beginScope(b->vname, val);
+            beginScope(b.vname, val);
           }
 
-          llvm::Value* caseValue = switchOf(b->exp, compileExpF("", this->c));
+          llvm::Value* caseValue = switchOf(b.exp, compileExpF("", this->c));
           mergeLinks.push_back(MergeLink(caseValue, builder()->GetInsertBlock()));
           builder()->CreateBr(mergeBlock);
           endScope();
@@ -400,10 +400,10 @@ public:
 
     // fill in the default (failure) target for variant matching
     llvm::Function* f = this->c->lookupFunction(".failvarmatch");
-    if (!f) { throw std::runtime_error("Internal compiler error -- no default variant match failure handler defined."); }
+    if (f == nullptr) { throw std::runtime_error("Internal compiler error -- no default variant match failure handler defined."); }
 
     auto ltxts = v->la().lines(v->la().p0.first-1, v->la().p1.first);
-    auto ltxt  = ltxts.size() > 0 ? ltxts[0] : "???";
+    auto ltxt  = !ltxts.empty() ? ltxts[0] : "???";
 
     return withContext([&](auto&) -> llvm::Value* {
       builder()->SetInsertPoint(failBlock);
@@ -421,15 +421,15 @@ public:
         return cvalue(true);
       } else {
         llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
-        for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
-          pn->addIncoming(ml->first, ml->second);
+        for (const auto &mergeLink : mergeLinks) {
+          pn->addIncoming(mergeLink.first, mergeLink.second);
         }
         return pn;
       }
     });
   }
 
-  llvm::Value* with(const Switch* v) const {
+  llvm::Value* with(const Switch* v) const override {
     MonoTypePtr casety = requireMonotype(v->type());
 
     // prepare to switch on the discriminant
@@ -448,13 +448,13 @@ public:
       return builder()->CreateSwitch(e, failBlock, v->bindings().size());
     });
 
-    typedef std::pair<llvm::Value*, llvm::BasicBlock*> MergeLink;
-    typedef std::vector<MergeLink> MergeLinks;
+    using MergeLink = std::pair<llvm::Value *, llvm::BasicBlock *>;
+    using MergeLinks = std::vector<MergeLink>;
     MergeLinks mergeLinks;
 
     return withContext([&](auto& c) -> llvm::Value* {
       size_t i = 0;
-      for (auto b : v->bindings()) {
+      for (const auto& b : v->bindings()) {
         size_t caseID = i++;
         llvm::BasicBlock* caseBlock = llvm::BasicBlock::Create(c, "case_" + str::from(caseID), thisFn);
 
@@ -482,17 +482,17 @@ public:
         return cvalue(true);
       } else {
         llvm::PHINode* pn = builder()->CreatePHI(toLLVM(casety, true), mergeLinks.size());
-        for (MergeLinks::const_iterator ml = mergeLinks.begin(); ml != mergeLinks.end(); ++ml) {
-          pn->addIncoming(ml->first, ml->second);
+        for (const auto &mergeLink : mergeLinks) {
+          pn->addIncoming(mergeLink.first, mergeLink.second);
         }
         return pn;
       }
     });
   }
 
-  llvm::Value* with(const Proj* v) const {
-    Record* rty = is<Record>(requireMonotype(v->record()->type()));
-    if (!rty) {
+  llvm::Value* with(const Proj* v) const override {
+    auto* rty = is<Record>(requireMonotype(v->record()->type()));
+    if (rty == nullptr) {
       throw annotated_error(*v, "Internal compiler error (received non-record type in projection).");
     }
 
@@ -508,7 +508,7 @@ public:
     llvm::Value* rp = structFieldPtr(rec, rty->alignedIndex(v->field()));
 
     return withContext([&](auto&) -> llvm::Value* {
-      if (OpaquePtr* op = is<OpaquePtr>(fty)) {
+      if (auto* op = is<OpaquePtr>(fty)) {
         if (op->storedContiguously()) {
           return builder()->CreateBitCast(rp, ptrType(byteType()));
         } else {
@@ -522,21 +522,21 @@ public:
     });
   }
 
-  llvm::Value* with(const Assump* v) const {
+  llvm::Value* with(const Assump* v) const override {
     // because we explicitly discard these type assumptions before compilation, this case should never happen
     return switchOf(v->expr(), *this);
   }
 
-  llvm::Value* with(const Pack* v) const {
+  llvm::Value* with(const Pack* v) const override {
     llvm::Value* ev = compile(v->expr());
     llvm::Type*  et = toLLVM(requireMonotype(v->type()), true);
 
     return withContext([&](auto&) { return builder()->CreateBitCast(ev, et); });
   }
 
-  llvm::Value* with(const Unpack* v) const {
+  llvm::Value* with(const Unpack* v) const override {
     llvm::Value* var  = compile(v->package());
-    llvm::Value* body = 0;
+    llvm::Value* body = nullptr;
 
     try {
       beginScope(v->varName(), var);
@@ -554,7 +554,7 @@ private:
   std::string vname;
 
   llvm::Value* compileConstArray(const MonoTypePtr& ty, const Values& vs) const {
-    auto elemTy = is<Func>(ty) ? ptrType(toLLVM(ty)) : toLLVM(ty);
+    auto *elemTy = is<Func>(ty) != nullptr ? ptrType(toLLVM(ty)) : toLLVM(ty);
     return withContext([&](auto&) {
        // take care to refer to global array constants by reference (a bit awkward!)
        return tryMkConstVarArray(builder(), this->c->module(), elemTy, vs, is<Array>(ty));
@@ -602,10 +602,10 @@ private:
 
   RecordValue compileRecordFields(const MkRecord::FieldDefs& fs) const {
     RecordValue r;
-    for (MkRecord::FieldDefs::const_iterator f = fs.begin(); f != fs.end(); ++f) {
-      if (!isUnit(requireMonotype(f->second->type()))) {
-        llvm::Value* v = compile(f->second);
-        r.push_back(FieldValue(f->first, v));
+    for (const auto &f : fs) {
+      if (!isUnit(requireMonotype(f.second->type()))) {
+        llvm::Value* v = compile(f.second);
+        r.push_back(FieldValue(f.first, v));
       }
     }
     return r;
@@ -622,7 +622,7 @@ private:
       MonoTypePtr  vty = requireMonotype(gv->type());
       llvm::Value* vl  = this->c->lookupVarRef(gv->value());
 
-      if (!vl) {
+      if (vl == nullptr) {
         throw annotated_error(*e, "Failed to get reference to global variable: " + gv->value());
       }
 
@@ -641,8 +641,8 @@ private:
 
       return p;
     } else if (const Proj* rp = is<Proj>(e)) {
-      Record* rty = is<Record>(requireMonotype(rp->record()->type()));
-      if (!rty) {
+      auto* rty = is<Record>(requireMonotype(rp->record()->type()));
+      if (rty == nullptr) {
         throw annotated_error(*e, "Internal compiler error (received non-record type in projection).");
       }
 
@@ -652,7 +652,7 @@ private:
       // switched to using packed records and manually-determined padding
       llvm::Value* p = structFieldPtr(rec, rty->alignedIndex(rp->field()));
 
-      if (OpaquePtr* op = is<OpaquePtr>(fty)) {
+      if (auto* op = is<OpaquePtr>(fty)) {
         if (op->storedContiguously()) {
           return withContext([&](llvm::LLVMContext& c) {
             llvm::PointerType* bty = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(c));
@@ -692,18 +692,18 @@ public:
   std::string vname;
   compileConstExpF(jitcc* c, const std::string& vname) : vname(vname), c(c) { }
 
-  llvm::Constant* with(const Unit*    ) const { return cvalue(true); } // should get optimized away -- unit should have no runtime representation
-  llvm::Constant* with(const Bool*   v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Char*   v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Byte*   v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Short*  v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Int*    v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Long*   v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Int128* v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Float*  v) const { return cvalue(v->value()); }
-  llvm::Constant* with(const Double* v) const { return cvalue(v->value()); }
-
-  llvm::Constant* with(const Var* v) const {
+  llvm::Constant* with(const Unit*    ) const override { return cvalue(true); } // should get optimized away -- unit should have no runtime representation
+  llvm::Constant* with(const Bool*   v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Char*   v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Byte*   v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Short*  v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Int*    v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Long*   v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Int128* v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Float*  v) const override { return cvalue(v->value()); }
+  llvm::Constant* with(const Double* v) const override { return cvalue(v->value()); }
+
+  llvm::Constant* with(const Var* v) const override {
     // possible instructions created during compilation
     // remove them otherwise they may become dangling instructions
     llvm::Value* x = this->c->lookupVar(v->value(), requireMonotype(v->type()));
@@ -714,17 +714,17 @@ public:
     return llvm::dyn_cast<llvm::Constant>(x);
   }
 
-  llvm::Constant* with(const Let*) const {
-    return 0;
+  llvm::Constant* with(const Let*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const LetRec*) const {
-    return 0;
+  llvm::Constant* with(const LetRec*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Fn* v) const {
+  llvm::Constant* with(const Fn* v) const override {
     Func* fty = is<Func>(requireMonotype(v->type()));
-    if (!fty) {
+    if (fty == nullptr) {
       throw annotated_error(*v, "Internal compiler error, not a function type: " + show(v->type()));
     }
 
@@ -739,23 +739,23 @@ public:
     }
   }
 
-  llvm::Constant* with(const App*) const {
-    return 0;
+  llvm::Constant* with(const App*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Assign*) const {
-    return 0;
+  llvm::Constant* with(const Assign*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const MkArray* v) const {
+  llvm::Constant* with(const MkArray* v) const override {
     MonoTypePtr ty  = requireMonotype(v->type());
-    Array*      aty = is<Array>(ty);
-    if (aty == 0) {
+    auto*      aty = is<Array>(ty);
+    if (aty == nullptr) {
       throw annotated_error(*v, "Internal compiler error -- can't make array out of non-array type: " + show(ty));
     }
 
     Constants cs = switchOf(v->values(), *this);
-    for (auto c : cs) { if (!c) return 0; }
+    for (auto *c : cs) { if (c == nullptr) return nullptr; }
 
     llvm::Type* elemTy = toLLVM(aty->type(), false);
     llvm::StructType* saty = varArrayType(elemTy, cs.size());
@@ -774,52 +774,52 @@ public:
     });
   }
 
-  llvm::Constant* with(const MkVariant*) const {
-    return 0;
+  llvm::Constant* with(const MkVariant*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const MkRecord* v) const {
+  llvm::Constant* with(const MkRecord* v) const override {
     MonoTypePtr mrty = requireMonotype(v->type());
-    Record*     rty  = is<Record>(mrty);
-    if (!rty) { throw annotated_error(*v, "Internal compiler error, compiling record without record type: " + show(v) + " :: " + show(v->type())); }
+    auto*     rty  = is<Record>(mrty);
+    if (rty == nullptr) { throw annotated_error(*v, "Internal compiler error, compiling record without record type: " + show(v) + " :: " + show(v->type())); }
 
     Constants rcs;
-    for (auto f : v->fields()) {
+    for (const auto& f : v->fields()) {
       if (llvm::Constant* c = switchOf(f.second, compileConstExpF(this->c, this->vname+"."+f.first))) {
         rcs.push_back(c);
       } else {
-        return 0;
+        return nullptr;
       }
     }
     return withContext([&](auto&) { return constantRecord(this->c->module(), rcs, rty); });
   }
 
-  llvm::Constant* with(const AIndex*) const {
-    return 0;
+  llvm::Constant* with(const AIndex*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Case*) const {
-    return 0;
+  llvm::Constant* with(const Case*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Switch*) const {
-    return 0;
+  llvm::Constant* with(const Switch*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Proj*) const {
-    return 0;
+  llvm::Constant* with(const Proj*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Assump* v) const {
+  llvm::Constant* with(const Assump* v) const override {
     return switchOf(v->expr(), *this);
   }
 
-  llvm::Constant* with(const Pack*) const {
-    return 0;
+  llvm::Constant* with(const Pack*) const override {
+    return nullptr;
   }
 
-  llvm::Constant* with(const Unpack*) const {
-    return 0;
+  llvm::Constant* with(const Unpack*) const override {
+    return nullptr;
   }
 private:
   jitcc* c;
diff --git a/lib/hobbes/eval/cmodule.C b/lib/hobbes/eval/cmodule.C
index 47f879e0e..17e99cb80 100644
--- a/lib/hobbes/eval/cmodule.C
+++ b/lib/hobbes/eval/cmodule.C
@@ -10,6 +10,7 @@
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/util/array.H>
 #include <hobbes/util/str.H>
+#include <memory>
 #include <stdexcept>
 
 namespace hobbes {
@@ -17,7 +18,7 @@ namespace hobbes {
 bool fileExists(const std::string &fname) {
   // not the most elegant, but it does the job
   FILE *f = fopen(fname.c_str(), "r");
-  if (!f)
+  if (f == nullptr)
     return false;
   fclose(f);
   return true;
@@ -28,15 +29,15 @@ bool importObject(cc *e, const std::string &sopath) {
     return false;
   } else {
     void *h = dlopen(sopath.c_str(), RTLD_NOW);
-    if (!h) {
+    if (h == nullptr) {
       throw std::runtime_error(std::string("Failed to load .so file: ") +
                                dlerror());
     }
 
-    typedef void (*InitF)(cc *);
-    InitF initF = reinterpret_cast<InitF>(dlsym(h, "initialize"));
+    using InitF = void (*)(cc *);
+    auto initF = reinterpret_cast<InitF>(dlsym(h, "initialize"));
 
-    if (!initF) {
+    if (initF == nullptr) {
       dlclose(h);
       throw std::runtime_error(std::string("Failed to load .so file init: ") +
                                dlerror());
@@ -56,17 +57,17 @@ bool importScript(cc *e, const std::string &fname) {
   }
 }
 
-typedef std::vector<std::string> ModulePaths;
+using ModulePaths = std::vector<std::string>;
 static ModulePaths &modulePaths() {
   static thread_local ModulePaths mps;
-  if (mps.size() == 0) {
+  if (mps.empty()) {
     mps.push_back(".");
   }
   return mps;
 }
 void pushModuleDir(const std::string &d) { modulePaths().push_back(d); }
 void popModuleDir() {
-  if (modulePaths().size() > 0)
+  if (!modulePaths().empty())
     modulePaths().resize(modulePaths().size() - 1);
 }
 
@@ -98,7 +99,7 @@ struct appTyDefnF : public switchTyFn {
   ModulePtr m;
   cc *e;
   appTyDefnF(const ModulePtr &m, cc *e) : m(m), e(e) {}
-  MonoTypePtr with(const TVar *v) const {
+  MonoTypePtr with(const TVar *v) const override {
     const auto &tn = v->name();
 
     if (isPrimName(tn) || e->isTypeAliasName(tn)) {
@@ -110,12 +111,12 @@ struct appTyDefnF : public switchTyFn {
     }
   }
 
-  MonoTypePtr with(const TApp *ap) const {
+  MonoTypePtr with(const TApp *ap) const override {
     return e->replaceTypeAliases(
         TApp::make(switchOf(ap->fn(), *this), switchOf(ap->args(), *this)));
   }
 
-  MonoTypePtr with(const TExpr *x) const {
+  MonoTypePtr with(const TExpr *x) const override {
     return TExpr::make(applyTypeDefns(
         this->m, this->e, translateExprWithOpts(m->options(), x->expr())));
   }
@@ -141,17 +142,17 @@ MonoTypes applyTypeDefns(const ModulePtr &m, cc *e, const MonoTypes &ts) {
 QualTypePtr applyTypeDefns(const ModulePtr &m, cc *e, const QualTypePtr &t) {
   Constraints cs;
   for (const auto &c : t->constraints()) {
-    cs.push_back(ConstraintPtr(
-        new Constraint(c->name(), applyTypeDefns(m, e, c->arguments()))));
+    cs.push_back(std::make_shared<Constraint>(
+        c->name(), applyTypeDefns(m, e, c->arguments())));
   }
-  return QualTypePtr(new QualType(cs, applyTypeDefns(m, e, t->monoType())));
+  return std::make_shared<QualType>(cs, applyTypeDefns(m, e, t->monoType()));
 }
 
 struct appTyDefnEF : public switchExprTyFn {
   ModulePtr m;
   cc *e;
   appTyDefnEF(const ModulePtr &m, cc *e) : m(m), e(e) {}
-  QualTypePtr withTy(const QualTypePtr &t) const {
+  QualTypePtr withTy(const QualTypePtr &t) const override {
     if (t)
       return applyTypeDefns(this->m, this->e, t);
     else
@@ -166,7 +167,7 @@ struct appTyDefnMF : public switchMDefTyFn {
   ModulePtr m;
   cc *e;
   appTyDefnMF(const ModulePtr &m, cc *e) : m(m), e(e) {}
-  QualTypePtr withTy(const QualTypePtr &t) const {
+  QualTypePtr withTy(const QualTypePtr &t) const override {
     if (t)
       return applyTypeDefns(this->m, this->e, t);
     else
@@ -186,12 +187,12 @@ ModuleDefs applyTypeDefns(const ModulePtr &m, cc *e, const ModuleDefs &mds) {
 }
 
 ModulePtr applyTypeDefns(cc *e, const ModulePtr &m) {
-  return ModulePtr(
-      new Module(m->name(), applyTypeDefns(m, e, m->definitions())));
+  return std::make_shared<Module>(
+      m->name(), applyTypeDefns(m, e, m->definitions()));
 }
 
 // index type variables and sanity check names to ensure no duplicates
-typedef std::map<std::string, int> NameIndexing;
+using NameIndexing = std::map<std::string, int>;
 
 NameIndexing nameIndexing(const str::seq &ns) {
   NameIndexing r;
@@ -210,7 +211,7 @@ NameIndexing nameIndexing(const std::set<std::string> &ns) {
 }
 
 int nameIndex(const NameIndexing &ns, const std::string &vn) {
-  NameIndexing::const_iterator ni = ns.find(vn);
+  auto ni = ns.find(vn);
   if (ni == ns.end()) {
     throw std::runtime_error("Undefined type name, '" + vn + "'");
   } else {
@@ -220,24 +221,24 @@ int nameIndex(const NameIndexing &ns, const std::string &vn) {
 
 std::vector<int> nameIndex(const NameIndexing &ns, const str::seq &vns) {
   std::vector<int> r;
-  for (str::seq::const_iterator vn = vns.begin(); vn != vns.end(); ++vn) {
-    r.push_back(nameIndex(ns, *vn));
+  for (const auto &vn : vns) {
+    r.push_back(nameIndex(ns, vn));
   }
   return r;
 }
 
 MonoTypeSubst substitution(const NameIndexing &ns) {
   MonoTypeSubst s;
-  for (NameIndexing::const_iterator ni = ns.begin(); ni != ns.end(); ++ni) {
-    s[ni->first] = MonoTypePtr(TGen::make(ni->second));
+  for (const auto &n : ns) {
+    s[n.first] = MonoTypePtr(TGen::make(n.second));
   }
   return s;
 }
 
 MonoTypeSubst uvarSubstitution(const NameIndexing &ns) {
   MonoTypeSubst s;
-  for (NameIndexing::const_iterator ni = ns.begin(); ni != ns.end(); ++ni) {
-    s[ni->first] = freshTypeVar();
+  for (const auto &n : ns) {
+    s[n.first] = freshTypeVar();
   }
   return s;
 }
@@ -246,17 +247,15 @@ MonoTypeSubst uvarSubstitution(const NameIndexing &ns) {
 void resolveNames(const NameIndexing &ns, const CFunDepDef &nfdep,
                   FunDeps *out) {
   VarIDs lhs = nameIndex(ns, nfdep.first);
-  for (str::seq::const_iterator vn = nfdep.second.begin();
-       vn != nfdep.second.end(); ++vn) {
-    out->push_back(FunDep(lhs, nameIndex(ns, *vn)));
+  for (const auto &vn : nfdep.second) {
+    out->push_back(FunDep(lhs, nameIndex(ns, vn)));
   }
 }
 
 FunDeps resolveNames(const NameIndexing &ns, const CFunDepDefs &nfdeps) {
   FunDeps r;
-  for (CFunDepDefs::const_iterator fd = nfdeps.begin(); fd != nfdeps.end();
-       ++fd) {
-    resolveNames(ns, *fd, &r);
+  for (const auto &nfdep : nfdeps) {
+    resolveNames(ns, nfdep, &r);
   }
   return r;
 }
@@ -351,7 +350,7 @@ void compile(const ModulePtr &m, cc *e, const InstanceDef *id) {
     UnqualifierPtr tyc = e->typeEnv()->lookupUnqualifier(id->className());
     TClassPtr c = std::dynamic_pointer_cast<TClass>(tyc);
 
-    if (c.get() == 0) {
+    if (c.get() == nullptr) {
       throw std::runtime_error("Cannot define overload in '" + id->className() +
                                "', class does not exist.");
     }
@@ -360,7 +359,7 @@ void compile(const ModulePtr &m, cc *e, const InstanceDef *id) {
 
     NameIndexing tns = nameIndexing(tvarNames(id->args()));
     MonoTypes targs = id->args();
-    bool asfn = id->constraints().size() > 0 || tvarNames(targs).size() > 0;
+    bool asfn = !id->constraints().empty() || !tvarNames(targs).empty();
     MemberMapping ms = compileMembers(m, &u, c, targs, e, id->members(), asfn);
 
     // is this a ground instance or an instance function?
@@ -369,7 +368,7 @@ void compile(const ModulePtr &m, cc *e, const InstanceDef *id) {
       try {
         c->insert(
             e->typeEnv(),
-            TCInstancePtr(new TCInstance(id->className(), targs, ms, id->la())),
+            std::make_shared<TCInstance>(id->className(), targs, ms, id->la()),
             &ds);
         e->drainUnqualifyDefs(ds);
       } catch (...) {
@@ -377,8 +376,8 @@ void compile(const ModulePtr &m, cc *e, const InstanceDef *id) {
         throw;
       }
     } else {
-      c->insert(TCInstanceFnPtr(new TCInstanceFn(
-          id->className(), id->constraints(), targs, ms, id->la())));
+      c->insert(std::make_shared<TCInstanceFn>(
+          id->className(), id->constraints(), targs, ms, id->la()));
     }
   } catch (annotated_error &) {
     throw;
@@ -446,7 +445,7 @@ void compile(const ModulePtr &m, cc *e, const MVarDef *mvd) {
 
   // make sure that globals with inaccessible names (evaluated for side-effects)
   // have monomorphic type (otherwise they'll quietly fail to run)
-  if (mvd->varWithArgs().size() >= 1 && mvd->varWithArgs()[0].size() > 0 &&
+  if (!mvd->varWithArgs().empty() && !mvd->varWithArgs()[0].empty() &&
       mvd->varWithArgs()[0][0] == '.') {
     requireMonotype(e->typeEnv(),
                     e->unsweetenExpression(mvd->varWithArgs()[0], vde));
@@ -564,7 +563,7 @@ struct UnsafeRefs : public SafeExpr::UnsafeDefs {
     SafeExpr::template with<void>(
         e,
         [&](const SafeExpr::UnsafeDefs &unsafeDef) {
-          for (auto &f : unsafeDef.unSafeRefs()) {
+          for (const auto &f : unsafeDef.unSafeRefs()) {
             if (v.second.find(f) == v.second.end()) {
               v.first.push_back(f);
             }
@@ -595,7 +594,7 @@ struct UnsafeRefs : public SafeExpr::UnsafeDefs {
   auto show(std::ostream &os) -> void {
     os << la().filename() << ", " << la().lineDesc() << ": " << varName()
        << " is not allowed";
-    if (unSafeRefs().size() > 0)
+    if (!unSafeRefs().empty())
       os << ", its transitive closure has disabled expressions: "
          << str::show(unSafeRefs());
     os << "." << exprDef() << std::endl;
@@ -643,7 +642,7 @@ struct Bool {
   Bool(bool v) : i(v ? 1 : 0) {}
   auto operator=(Bool const &) -> Bool & = default;
   auto operator=(bool v) -> Bool & { return (*this = Bool(v)); }
-  operator bool() const { return (i == 0 ? false : true); }
+  operator bool() const { return (i != 0); }
 
 private:
   Bool(int i) : i(i) {}
@@ -667,8 +666,8 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<details::Bool> {
   }
   MVarDef const &mvd;
 
-  virtual details::Bool withConst(const Expr *) const { return true; };
-  virtual details::Bool with(const Var *v) const {
+  details::Bool withConst(const Expr *) const override { return true; };
+  details::Bool with(const Var *v) const override {
     return SafeExpr::with<bool>(
         v->value(),
         [&](const SafeExpr::UnsafeDefs &) {
@@ -690,12 +689,12 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<details::Bool> {
         },
         []() { return false; });
   }
-  virtual details::Bool with(const Let *v) const {
+  details::Bool with(const Let *v) const override {
     switchOf(v->varExpr(), *this);
     switchOf(v->bodyExpr(), *this);
     return true;
   }
-  virtual details::Bool with(const LetRec *v) const {
+  details::Bool with(const LetRec *v) const override {
     str::set vns = toSet(v->varNames());
     LetRec::Bindings bs;
     for (const auto &b : v->bindings()) {
@@ -704,50 +703,49 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<details::Bool> {
     switchOf(v->bodyExpr(), *this);
     return true;
   }
-  virtual details::Bool with(const Fn *v) const {
+  details::Bool with(const Fn *v) const override {
     switchOf(v->body(), *this);
     return true;
   }
-  virtual details::Bool with(const App *v) const {
+  details::Bool with(const App *v) const override {
     switchOf(v->fn(), *this);
     switchOf(v->args(), *this);
     return true;
   }
-  virtual details::Bool with(const Assign *v) const {
+  details::Bool with(const Assign *v) const override {
     switchOf(v->left(), *this);
     switchOf(v->right(), *this);
     return true;
   }
-  virtual details::Bool with(const MkArray *v) const {
+  details::Bool with(const MkArray *v) const override {
     switchOf(v->values(), *this);
     return true;
   }
-  virtual details::Bool with(const MkVariant *v) const {
+  details::Bool with(const MkVariant *v) const override {
     switchOf(v->value(), *this);
     return true;
   }
-  virtual details::Bool with(const MkRecord *v) const {
+  details::Bool with(const MkRecord *v) const override {
     switchOf(v->fields(), *this);
     return true;
   }
-  virtual details::Bool with(const AIndex *) const { return true; }
-  virtual details::Bool with(const Case *v) const {
+  details::Bool with(const AIndex *) const override { return true; }
+  details::Bool with(const Case *v) const override {
     const Case::Bindings &cbs = v->bindings();
     Case::Bindings rcbs;
-    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end();
-         ++cb) {
-      switchOf(cb->exp, *this);
+    for (const auto &cb : cbs) {
+      switchOf(cb.exp, *this);
     }
     ExprPtr de = v->defaultExpr();
-    if (de.get()) {
+    if (de.get() != nullptr) {
       switchOf(de, *this);
     }
     switchOf(v->variant(), *this);
     return true;
   }
-  virtual details::Bool with(const Switch *v) const {
+  details::Bool with(const Switch *v) const override {
     Switch::Bindings rsbs;
-    for (auto sb : v->bindings()) {
+    for (const auto& sb : v->bindings()) {
       switchOf(sb.exp, *this);
     }
     ExprPtr de = v->defaultExpr();
@@ -757,19 +755,19 @@ struct buildTransitiveUnsafePragmaClosure : public switchExprC<details::Bool> {
     switchOf(v->expr(), *this);
     return true;
   }
-  virtual details::Bool with(const Proj *v) const {
+  details::Bool with(const Proj *v) const override {
     switchOf(v->record(), *this);
     return true;
   }
-  virtual details::Bool with(const Assump *v) const {
+  details::Bool with(const Assump *v) const override {
     switchOf(v->expr(), *this);
     return true;
   }
-  virtual details::Bool with(const Pack *v) const {
+  details::Bool with(const Pack *v) const override {
     switchOf(v->expr(), *this);
     return true;
   }
-  virtual details::Bool with(const Unpack *v) const {
+  details::Bool with(const Unpack *v) const override {
     switchOf(v->package(), *this);
     switchOf(v->expr(), *this);
     return true;
@@ -797,7 +795,7 @@ void compile(const ModulePtr &, cc *, const MSafePragmaDef *mpd) {
 // environment
 //   (this disallows things like mutual recursion)
 void compile(cc *e, const ModulePtr &m) {
-  for (auto tmd : m->definitions()) {
+  for (const auto& tmd : m->definitions()) {
     auto md = applyTypeDefns(m, e, tmd);
 
     if (const MImport *imp = is<MImport>(md)) {
@@ -822,21 +820,21 @@ void compile(cc *e, const ModulePtr &m) {
   }
 
   // compile unsafe pragma
-  for (auto tmd : m->definitions()) {
+  for (const auto& tmd : m->definitions()) {
     if (const MUnsafePragmaDef *vpd = is<MUnsafePragmaDef>(tmd)) {
       compile(m, e, vpd);
     }
   }
 
   // compile safe pragma
-  for (auto tmd : m->definitions()) {
+  for (const auto& tmd : m->definitions()) {
     if (const MSafePragmaDef *vpd = is<MSafePragmaDef>(tmd)) {
       compile(m, e, vpd);
     }
   }
 
   // generate unsafe transitive closure
-  for (auto tmd : m->definitions()) {
+  for (const auto& tmd : m->definitions()) {
     if (const MVarDef *vd = is<MVarDef>(tmd)) {
       switchOf(vd->varExpr(), buildTransitiveUnsafePragmaClosure(*vd));
     }
@@ -849,7 +847,7 @@ std::vector<std::string> getDefaultOptions() { return str::strings(); }
 struct makeSafe : public switchExprC<ExprPtr> {
   std::map<std::string, UnsafeRefs> collectUnsafes;
 
-  makeSafe() {}
+  makeSafe() = default;
 
   auto show() -> std::string {
     std::stringstream ss;
@@ -859,14 +857,14 @@ struct makeSafe : public switchExprC<ExprPtr> {
     return ss.str();
   }
 
-  ExprPtr withConst(const Expr *v) const { return ExprPtr(v->clone()); }
+  ExprPtr withConst(const Expr *v) const override { return ExprPtr(v->clone()); }
 
-  ExprPtr with(const Var *v) const {
+  ExprPtr with(const Var *v) const override {
     return SafeExpr::template with<ExprPtr>(
         v->value(),
         [&, this](const SafeExpr::UnsafeDefs &unsafeDef) {
           ExprPtr vc(v->clone());
-          if (auto vcc = is<Var>(vc.get())) {
+          if (const auto *vcc = is<Var>(vc.get())) {
             if (not unsafeDef.safeFn().empty()) {
               const_cast<Var *>(vcc)->value(unsafeDef.safeFn());
             } else {
@@ -883,12 +881,12 @@ struct makeSafe : public switchExprC<ExprPtr> {
         [&]() { return ExprPtr(v->clone()); });
   }
 
-  ExprPtr with(const Let *v) const {
+  ExprPtr with(const Let *v) const override {
     return ExprPtr(new Let(v->var(), switchOf(v->varExpr(), *this),
                            switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const LetRec *v) const {
+  ExprPtr with(const LetRec *v) const override {
     str::set vns = toSet(v->varNames());
     LetRec::Bindings bs;
     for (const auto &b : v->bindings()) {
@@ -897,58 +895,57 @@ struct makeSafe : public switchExprC<ExprPtr> {
     return ExprPtr(new LetRec(bs, switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const Fn *v) const {
+  ExprPtr with(const Fn *v) const override {
     return ExprPtr(new Fn(v->varNames(), switchOf(v->body(), *this), v->la()));
   }
 
-  ExprPtr with(const App *v) const {
+  ExprPtr with(const App *v) const override {
     return ExprPtr(
         new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
   }
 
-  ExprPtr with(const Assign *v) const {
+  ExprPtr with(const Assign *v) const override {
     return ExprPtr(new Assign(switchOf(v->left(), *this),
                               switchOf(v->right(), *this), v->la()));
   }
 
-  ExprPtr with(const MkArray *v) const {
+  ExprPtr with(const MkArray *v) const override {
     return ExprPtr(new MkArray(switchOf(v->values(), *this), v->la()));
   }
 
-  ExprPtr with(const MkVariant *v) const {
+  ExprPtr with(const MkVariant *v) const override {
     return ExprPtr(
         new MkVariant(v->label(), switchOf(v->value(), *this), v->la()));
   }
 
-  ExprPtr with(const MkRecord *v) const {
+  ExprPtr with(const MkRecord *v) const override {
     return ExprPtr(new MkRecord(switchOf(v->fields(), *this), v->la()));
   }
 
-  ExprPtr with(const AIndex *v) const {
+  ExprPtr with(const AIndex *v) const override {
     return fncall(
         var("atm", v->la()),
         list(switchOf(v->array(), *this), switchOf(v->index(), *this)),
         v->la());
   }
 
-  ExprPtr with(const Case *v) const {
+  ExprPtr with(const Case *v) const override {
     const Case::Bindings &cbs = v->bindings();
     Case::Bindings rcbs;
-    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end();
-         ++cb) {
+    for (const auto &cb : cbs) {
       rcbs.push_back(
-          Case::Binding(cb->selector, cb->vname, switchOf(cb->exp, *this)));
+          Case::Binding(cb.selector, cb.vname, switchOf(cb.exp, *this)));
     }
     ExprPtr de = v->defaultExpr();
-    if (de.get()) {
+    if (de.get() != nullptr) {
       de = switchOf(de, *this);
     }
     return ExprPtr(new Case(switchOf(v->variant(), *this), rcbs, de, v->la()));
   }
 
-  ExprPtr with(const Switch *v) const {
+  ExprPtr with(const Switch *v) const override {
     Switch::Bindings rsbs;
-    for (auto sb : v->bindings()) {
+    for (const auto& sb : v->bindings()) {
       rsbs.push_back(Switch::Binding(sb.value, switchOf(sb.exp, *this)));
     }
     ExprPtr de = v->defaultExpr();
@@ -958,19 +955,19 @@ struct makeSafe : public switchExprC<ExprPtr> {
     return ExprPtr(new Switch(switchOf(v->expr(), *this), rsbs, de, v->la()));
   }
 
-  ExprPtr with(const Proj *v) const {
+  ExprPtr with(const Proj *v) const override {
     return ExprPtr(new Proj(switchOf(v->record(), *this), v->field(), v->la()));
   }
 
-  ExprPtr with(const Assump *v) const {
+  ExprPtr with(const Assump *v) const override {
     return ExprPtr(new Assump(switchOf(v->expr(), *this), v->ty(), v->la()));
   }
 
-  ExprPtr with(const Pack *v) const {
+  ExprPtr with(const Pack *v) const override {
     return ExprPtr(new Pack(switchOf(v->expr(), *this), v->la()));
   }
 
-  ExprPtr with(const Unpack *v) const {
+  ExprPtr with(const Unpack *v) const override {
     return ExprPtr(new Unpack(v->varName(), switchOf(v->package(), *this),
                               switchOf(v->expr(), *this), v->la()));
   }
@@ -984,7 +981,7 @@ struct makeSafeArrays : public makeSafe {
       thread_local Map safeArrayTable{
           Map{{{"element", {"element", "elementM"}}}}};
       ExprPtr vc(v->clone());
-      if (auto vcc = is<Var>(vc.get())) {
+      if (const auto *vcc = is<Var>(vc.get())) {
         auto iter = safeArrayTable.find(v->value());
         if (iter != std::end(safeArrayTable)) {
           const_cast<Var *>(vcc)->value(iter->second.safeFn());
@@ -994,7 +991,7 @@ struct makeSafeArrays : public makeSafe {
     }
   };
 
-  ExprPtr with(const Var *v) const { return SafeArray::with(v); }
+  ExprPtr with(const Var *v) const override { return SafeArray::with(v); }
 };
 
 OptDescs getAllOptions() {
@@ -1021,7 +1018,7 @@ ExprPtr translateExprWithOpts(
            [&exceptionFn](std::string const &, const ExprPtr &e) -> ExprPtr {
              auto ms = makeSafe();
              auto r = switchOf(e, ms);
-             if (ms.collectUnsafes.size() != 0) {
+             if (!ms.collectUnsafes.empty()) {
                exceptionFn(ms.show());
              };
              return r;
diff --git a/lib/hobbes/eval/ctype.C b/lib/hobbes/eval/ctype.C
index 6844d2023..39d8c1b8c 100644
--- a/lib/hobbes/eval/ctype.C
+++ b/lib/hobbes/eval/ctype.C
@@ -44,15 +44,15 @@ class translateTypeF : public switchType<llvm::Type*> {
 public:
   translateTypeF(bool asArg) : asArg(asArg) { }
 
-  llvm::Type* with(const Prim* v) const {
-    if (v->representation().get()) {
+  llvm::Type* with(const Prim* v) const override {
+    if (v->representation().get() != nullptr) {
       return switchOf(v->representation(), *this);
     } else {
       return llvmPrim(v->name());
     }
   }
 
-  llvm::Type* with(const OpaquePtr* v) const {
+  llvm::Type* with(const OpaquePtr* v) const override {
     if (!asArg && v->storedContiguously()) {
       return arrayType(byteType(), v->size());
     } else {
@@ -60,19 +60,19 @@ public:
     }
   }
 
-  llvm::Type* with(const TVar* v) const {
+  llvm::Type* with(const TVar* v) const override {
     throw std::runtime_error("Internal compiler error: Cannot translate type variable '" + v->name() + "' to LLVM type");
   }
 
-  llvm::Type* with(const TGen*) const {
+  llvm::Type* with(const TGen*) const override {
     throw std::runtime_error("Internal compiler error: Cannot translate polytype instantiation point to LLVM type.");
   }
 
-  llvm::Type* with(const TAbs* v) const {
+  llvm::Type* with(const TAbs* v) const override {
     throw std::runtime_error("Can't translate to LLVM monotype: " + show(v));
   }
 
-  llvm::Type* with(const TApp* v) const {
+  llvm::Type* with(const TApp* v) const override {
     // TODO: fold these special cases into TApp/TFn applications
     if (const Prim* f = is<Prim>(v->fn())) {
       if (f->name() == "->" && v->args().size() == 2) {
@@ -100,59 +100,59 @@ public:
     throw std::runtime_error("Can't translate to LLVM monotype: " + show(v));
   }
 
-  llvm::Type* with(const FixedArray* v) const {
-    bool innerPtrs = is<Func>(v->type());
+  llvm::Type* with(const FixedArray* v) const override {
+    bool innerPtrs = is<Func>(v->type()) != nullptr;
     return asPtrIf(arrayType(switchOf(v->type(), translateTypeF(innerPtrs)), v->requireLength()), asArg);
   }
 
-  llvm::Type* with(const Array* v) const {
-    bool innerPtrs = is<OpaquePtr>(v->type()) || is<Func>(v->type());
+  llvm::Type* with(const Array* v) const override {
+    bool innerPtrs = (is<OpaquePtr>(v->type()) != nullptr) || (is<Func>(v->type()) != nullptr);
     return asPtrIf(llvmVarArrType(switchOf(v->type(), translateTypeF(innerPtrs))), true);
   }
 
-  llvm::Type* with(const Variant* v) const {
+  llvm::Type* with(const Variant* v) const override {
     return asPtrIf(arrayType(byteType(), v->size()), asArg);
   }
 
-  llvm::Type* with(const Record* v) const {
+  llvm::Type* with(const Record* v) const override {
     const Record::Members& ams = v->alignedMembers();
 
     Types cms;
-    for (Record::Members::const_iterator m = ams.begin(); m != ams.end(); ++m) {
+    for (const auto &am : ams) {
       // some types go into records as pointers
-      if (!isUnit(m->type)) {
-        cms.push_back(switchOf(m->type, translateTypeF(is<Func>(m->type) || is<Array>(m->type))));
+      if (!isUnit(am.type)) {
+        cms.push_back(switchOf(am.type, translateTypeF((is<Func>(am.type) != nullptr) || (is<Array>(am.type) != nullptr))));
       }
     }
 
-    if (cms.size() == 0) {
+    if (cms.empty()) {
       return llvmPrim("unit");
     } else {
       return asPtrIf(packedRecordType(cms), asArg);
     }
   }
 
-  llvm::Type* with(const Func* v) const {
+  llvm::Type* with(const Func* v) const override {
     return asPtrIf(functionType(toLLVM(v->parameters(), true), toLLVM(v->result(), true)), asArg);
   }
 
-  llvm::Type* with(const Exists* v) const {
+  llvm::Type* with(const Exists* v) const override {
     return toLLVM(unpackedType(v), true);
   }
 
-  llvm::Type* with(const Recursive*) const {
+  llvm::Type* with(const Recursive*) const override {
     return ptrType(byteType());
   }
 
-  llvm::Type* with(const TString* v) const {
+  llvm::Type* with(const TString* v) const override {
     throw std::runtime_error("Internal compiler error: Cannot translate value to LLVM type: '" + v->value() + "'");
   }
 
-  llvm::Type* with(const TLong* v) const {
+  llvm::Type* with(const TLong* v) const override {
     throw std::runtime_error("Internal compiler error: Cannot translate value to LLVM type: " + str::from(v->value()));
   }
 
-  llvm::Type* with(const TExpr* v) const {
+  llvm::Type* with(const TExpr* v) const override {
     throw std::runtime_error("Internal compiler error: Cannot translate expression to LLVM type: " + show(v->expr()));
   }
 private:
@@ -173,9 +173,9 @@ llvm::Type* toLLVM(const MonoTypePtr& ty, bool asArg) {
 
 Types toLLVM(const MonoTypes& tys, bool asArg) {
   Types r;
-  for (MonoTypes::const_iterator ty = tys.begin(); ty != tys.end(); ++ty) {
-    if (!asArg || !isUnit(*ty)) {
-      r.push_back(toLLVM(*ty, asArg));
+  for (const auto &ty : tys) {
+    if (!asArg || !isUnit(ty)) {
+      r.push_back(toLLVM(ty, asArg));
     }
   }
   return r;
diff --git a/lib/hobbes/eval/func.C b/lib/hobbes/eval/func.C
index 3ac827dd4..345ef03bb 100644
--- a/lib/hobbes/eval/func.C
+++ b/lib/hobbes/eval/func.C
@@ -224,7 +224,7 @@ BOP(dgte, CreateFCmpOGE, double, double, bool);
 // inline conditional
 class ifexp : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](llvm::LLVMContext& ctx) -> llvm::Value* {
       llvm::Function* thisFn = c->builder()->GetInsertBlock()->getParent();
       llvm::Value*    cond   = c->compile(es[0]);
@@ -268,7 +268,7 @@ public:
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static PolyTypePtr ifty(new PolyType(1, qualtype(Func::make(tuplety(list(MonoTypePtr(Prim::make("bool")), tg0, tg0)), tg0))));
     return ifty;
@@ -278,13 +278,13 @@ public:
 // array-length lookup
 class alenexp : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([c, &es](auto&) {
       return c->builder()->CreateLoad(structOffset(c->builder(), c->compile(es[0]), 0), false, "at");
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tlong(Prim::make("long"));
     static PolyTypePtr alenty(new PolyType(1, qualtype(Func::make(tuplety(list(MonoTypePtr(Array::make(tg0)))), tlong))));
@@ -296,8 +296,8 @@ public:
 // array concatenation
 class aconcatexp : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
-    Array* aty = is<Array>(tys[0]);
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
+    auto* aty = is<Array>(tys[0]);
     if (aty == nullptr) {
       throw annotated_error(*es[0], "Internal compiler error -- can't make array out of non-array type: " + show(tys[0]));
     }
@@ -328,7 +328,7 @@ public:
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr earr(Array::make(tg0));
     static PolyTypePtr fty(new PolyType(1, qualtype(Func::make(tuplety(list(earr,earr)), earr))));
@@ -339,9 +339,9 @@ public:
 
 // unsafe set array length
 class asetlen : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
-    Array* aty = is<Array>(tys[0]);
-    if (aty == 0) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
+    auto* aty = is<Array>(tys[0]);
+    if (aty == nullptr) {
       throw annotated_error(*es[0], "Internal compiler error -- can't make array out of non-array type: " + show(tys[0]));
     }
 
@@ -351,21 +351,21 @@ class asetlen : public op {
     return cvalue(true);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     return polytype(1, qualtype(functy(list(arrayty(tgen(0)), primty("long")), primty("unit"))));
   }
 };
 
 // static-length array length lookup
 class salenexp : public op {
-  llvm::Value* apply(jitcc*, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc*, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     const FixedArray* aty = is<FixedArray>(tys[0]);
-    if (!aty) { throw annotated_error(*es[0], "Cannot determine length, not a fixed-length array: " + show(tys[0])); }
+    if (aty == nullptr) { throw annotated_error(*es[0], "Cannot determine length, not a fixed-length array: " + show(tys[0])); }
 
     return cvalue(aty->requireLength());
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tlong(Prim::make("long"));
@@ -377,9 +377,9 @@ class salenexp : public op {
 
 // static-length array element lookup
 class saelem : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) override {
     const FixedArray* aty = is<FixedArray>(tys[0]);
-    if (!aty) { throw annotated_error(*es[0], "Cannot index element, not a fixed-length array: " + show(tys[0])); }
+    if (aty == nullptr) { throw annotated_error(*es[0], "Cannot index element, not a fixed-length array: " + show(tys[0])); }
 
     if (isUnit(rty)) {
       c->compile(es[0]);
@@ -398,7 +398,7 @@ class saelem : public op {
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tlong(Prim::make("long"));
@@ -409,9 +409,9 @@ class saelem : public op {
 
 // copy contents of a variable-length array to a static-length array
 class saacopy : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     const FixedArray* aty = is<FixedArray>(tys[0]);
-    if (!aty) { throw annotated_error(*es[0], "Cannot determine length, not a fixed-length array: " + show(tys[0])); }
+    if (aty == nullptr) { throw annotated_error(*es[0], "Cannot determine length, not a fixed-length array: " + show(tys[0])); }
 
     llvm::Value* farr = c->compile(es[0]);
 
@@ -427,7 +427,7 @@ class saacopy : public op {
     return cvalue(true);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0 (TGen::make(0));
     static MonoTypePtr tg1 (TGen::make(1));
     static MonoTypePtr faty(FixedArray::make(tg0, tg1));
@@ -442,14 +442,14 @@ class saacopy : public op {
 // generic contextless function application
 class applyCFn : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     if (const MkRecord* args = is<MkRecord>(es[1])) {
       return c->compile(fncall(es[0], exprs(args->fields()), es[0]->la()));
     } else {
       std::string   tn   = freshName();
       const Record* cfty = is<Record>(requireMonotype(es[1]->type()));
 
-      if (!cfty) {
+      if (cfty == nullptr) {
         throw annotated_error(*es[1], "Internal error, misapplication of low-level function application.");
       }
 
@@ -457,9 +457,9 @@ public:
       tupv->type(es[1]->type());
 
       Exprs argv;
-      for (Record::Members::const_iterator m = cfty->members().begin(); m != cfty->members().end(); ++m) {
-        ExprPtr aprj(new Proj(tupv, m->field, tupv->la()));
-        aprj->type(qualtype(m->type));
+      for (const auto &m : cfty->members()) {
+        ExprPtr aprj(new Proj(tupv, m.field, tupv->la()));
+        aprj->type(qualtype(m.type));
         argv.push_back(aprj);
       }
 
@@ -470,7 +470,7 @@ public:
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tf(Func::make(tg0, tg1));
@@ -483,11 +483,11 @@ public:
 // identity transform -- do nothing
 class idexp : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return c->compile(es[0]);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static PolyTypePtr idty(new PolyType(1, qualtype(Func::make(tuplety(list(tg0)), tg0))));
     return idty;
@@ -497,7 +497,7 @@ public:
 // identity transform, with (unsafe) bit cast
 class castexp : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     llvm::Value* r = c->compile(es[0]);
     if (isUnit(rty)) {
       return cvalue(true);
@@ -508,7 +508,7 @@ public:
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static PolyTypePtr idty(new PolyType(2, qualtype(Func::make(tuplety(list(tg0)), tg1))));
@@ -522,7 +522,7 @@ public:
   newPrimfn(bool zeroMem = false) : zeroMem(zeroMem) {
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs&) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs&) override {
     if (isUnit(rty)) {
       return cvalue(true);
     } else if (!hasPointerRep(rty)) {
@@ -534,7 +534,7 @@ public:
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static PolyTypePtr npty(new PolyType(1, qualtype(Func::make(tuplety(list(prim<void>())), tg0))));
     return npty;
@@ -545,9 +545,9 @@ private:
 
 class newArrayfn : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr& rty, const Exprs& es) override {
     const Array* aty = is<Array>(rty);
-    if (!aty) {
+    if (aty == nullptr) {
       throw annotated_error(*es[0], "Invalid usage, newArray called for non-array type");
     }
 
@@ -561,7 +561,7 @@ public:
     return cmdata;
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tlng = prim<long>();
     static PolyTypePtr npty(new PolyType(1, qualtype(Func::make(tuplety(list(tlng)), arrayty(tg0)))));
@@ -572,13 +572,13 @@ public:
 // adjust a pointer, through a vtbl or not (this should only wind up being used for witnessing subclass relations)
 class adjptr : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     llvm::Value* p = c->compile(es[0]);
     llvm::Value* o = c->compile(es[1]);
     return withContext([&](auto&) { return c->builder()->CreateGEP(p, o); });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tint(Prim::make("int"));
@@ -589,7 +589,7 @@ public:
 
 class adjvtblptr : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     llvm::Type* tppchar = llvm::PointerType::getUnqual(llvm::PointerType::getUnqual(
         withContext([](llvm::LLVMContext& ctx) { return llvm::Type::getInt8Ty(ctx); })));
 
@@ -611,7 +611,7 @@ public:
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static MonoTypePtr tg0(TGen::make(0));
     static MonoTypePtr tg1(TGen::make(1));
     static MonoTypePtr tint(Prim::make("int"));
@@ -623,12 +623,12 @@ public:
 // compile-time record deconstruction
 class recHLabel : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs&) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs&) override {
     if (tys.size() != 1) {
       throw std::runtime_error("Internal error, recordHeadLabel applied incorrectly");
     }
     const Record* rty = is<Record>(tys[0]);
-    if (!rty) {
+    if (rty == nullptr) {
       throw std::runtime_error("Internal error, recordHeadLabel applied to non-record type");
     }
 
@@ -637,7 +637,7 @@ public:
     return c->compile(lbl);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(1, qualtype(functy(list(tgen(0)), arrayty(prim<char>())))));
     return unsafeTy;
   }
@@ -645,12 +645,12 @@ public:
 
 class recHValue : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     if (tys.size() != 1) {
       throw std::runtime_error("Internal error, recordHeadValue applied incorrectly");
     }
-    Record* rty = is<Record>(tys[0]);
-    if (!rty || rty->members().size() == 0) {
+    auto* rty = is<Record>(tys[0]);
+    if ((rty == nullptr) || rty->members().empty()) {
       throw std::runtime_error("Internal error, recordHeadValue applied to non-record type");
     }
 
@@ -659,7 +659,7 @@ public:
     return c->compile(proj);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(2, qualtype(functy(list(tgen(0)), tgen(1)))));
     return unsafeTy;
   }
@@ -667,12 +667,12 @@ public:
 
 class recTail : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     if (tys.size() != 1) {
       throw std::runtime_error("Internal error, recordTail applied incorrectly");
     }
-    Record* rty = is<Record>(tys[0]);
-    if (!rty || rty->members().size() == 0) {
+    auto* rty = is<Record>(tys[0]);
+    if ((rty == nullptr) || rty->members().empty()) {
       throw std::runtime_error("Internal error, recordTail applied to non-record type");
     }
 
@@ -688,7 +688,7 @@ public:
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(2, qualtype(functy(list(tgen(0)), tgen(1)))));
     return unsafeTy;
   }
@@ -696,12 +696,12 @@ public:
 
 class varHLabel : public op {
 public:
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs&) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs&) override {
     if (tys.size() != 1) {
       throw std::runtime_error("Internal error, varHLabel applied incorrectly");
     }
     const Variant* vty = is<Variant>(tys[0]);
-    if (!vty) {
+    if (vty == nullptr) {
       throw std::runtime_error("Internal error, varHLabel applied to non-variant type");
     }
 
@@ -713,19 +713,19 @@ public:
     return c->compile(ExprPtr(mkarray(lbl, LexicalAnnotation::null())));
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(1, qualtype(functy(list(tgen(0)), arrayty(prim<char>())))));
     return unsafeTy;
   }
 };
 
 class varInjH : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr& rty, const Exprs& es) override {
     if (tys.size() != 1) {
       throw std::runtime_error("Internal error, varInjH applied incorrectly");
     }
     const Variant* vty = is<Variant>(rty);
-    if (!vty) {
+    if (vty == nullptr) {
       throw std::runtime_error("Internal error, varInjH applied to non-variant type");
     }
 
@@ -735,7 +735,7 @@ class varInjH : public op {
     return c->compile(inje);
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(2, qualtype(functy(list(tgen(0)), tgen(1)))));
     return unsafeTy;
   }
@@ -788,13 +788,13 @@ public:
     });
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     // make sure we've got our types right
     MonoTypePtr vtyv   = tys[0];
     MonoTypePtr tfntyv = tys[2];
 
-    Variant* vty = is<Variant>(vtyv);
-    if (!vty) {
+    auto* vty = is<Variant>(vtyv);
+    if (vty == nullptr) {
       throw annotated_error(*es[0], "Internal error (received non-variant type in varSplit).");
     }
 
@@ -877,7 +877,7 @@ public:
     });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     static PolyTypePtr unsafeTy(new PolyType(4, qualtype(functy(list(tgen(0), closty(list(tgen(1)), tgen(3)), closty(list(tgen(2)), tgen(3))), tgen(3)))));
     return unsafeTy;
   }
@@ -989,7 +989,7 @@ size_t stdstrsize(const std::string& x)           { return x.size(); }
 char   stdstrelem(const std::string& x, size_t i) { return x[i]; }
 
 class packLongF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](auto&) {
       llvm::Value* c0 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[0]), longType(), false), 56);
       llvm::Value* c1 = c->builder()->CreateShl(c->builder()->CreateIntCast(c->compile(es[1]), longType(), false), 48);
@@ -1005,14 +1005,14 @@ class packLongF : public op {
     });
   }
 
-  PolyTypePtr type(typedb& db) const {
+  PolyTypePtr type(typedb& db) const override {
     MonoTypePtr cty(Prim::make("char"));
     return polytype(0, qualtype(functy(list(cty, cty, cty, cty, cty, cty, cty, cty), lift<long>::type(db))));
   }
 };
 
 class packIntF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](auto&) {
       llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), intType(), false);
       llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), intType(), false);
@@ -1033,14 +1033,14 @@ class packIntF : public op {
     });
   }
 
-  PolyTypePtr type(typedb& db) const {
+  PolyTypePtr type(typedb& db) const override {
     MonoTypePtr cty(Prim::make("char"));
     return polytype(0, qualtype(functy(list(cty, cty, cty, cty), lift<int>::type(db))));
   }
 };
 
 class packShortF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](auto&) {
       llvm::Value* c0 = c->builder()->CreateIntCast(c->compile(es[0]), shortType(), false);
       llvm::Value* c1 = c->builder()->CreateIntCast(c->compile(es[1]), shortType(), false);
@@ -1053,21 +1053,21 @@ class packShortF : public op {
     });
   }
 
-  PolyTypePtr type(typedb& db) const {
+  PolyTypePtr type(typedb& db) const override {
     MonoTypePtr cty(Prim::make("char"));
     return polytype(0, qualtype(functy(list(cty, cty), lift<short>::type(db))));
   }
 };
 
 class cptrrefbyF : public op {
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](auto&) {
       return c->builder()->CreateLoad(
           offset(c->builder(), c->compile(es[0]), c->compile(es[1])), false);
     });
   }
 
-  PolyTypePtr type(typedb& db) const {
+  PolyTypePtr type(typedb& db) const override {
     return polytype(qualtype(functy(list(lift<char*>::type(db), lift<long>::type(db)), lift<char>::type(db))));
   }
 };
diff --git a/lib/hobbes/eval/funcdefs.C b/lib/hobbes/eval/funcdefs.C
index 1c8494360..f7621cc69 100644
--- a/lib/hobbes/eval/funcdefs.C
+++ b/lib/hobbes/eval/funcdefs.C
@@ -16,15 +16,15 @@
 
 namespace hobbes {
 
-static __thread region* threadRegionp = 0;
+static __thread region* threadRegionp = nullptr;
 
-typedef std::pair<std::string, region*> NamedRegion;
-typedef std::vector<NamedRegion> Regions;
-static __thread Regions* threadRegionsp = 0;
+using NamedRegion = std::pair<std::string, region *>;
+using Regions = std::vector<NamedRegion>;
+static __thread Regions* threadRegionsp = nullptr;
 static __thread size_t   currentRegion = 0;
 
 region& threadRegion() {
-  if (threadRegionp == 0) {
+  if (threadRegionp == nullptr) {
     threadRegionp  = new region(32768 /* min page size = 32K */);
     threadRegionsp = new Regions();
     threadRegionsp->push_back(NamedRegion("scratch", threadRegionp));
@@ -34,7 +34,7 @@ region& threadRegion() {
 }
 
 static Regions& threadRegions() {
-  if (threadRegionsp == 0) {
+  if (threadRegionsp == nullptr) {
     threadRegion();
   }
   return *threadRegionsp;
@@ -171,7 +171,7 @@ scoped_pool_reset::~scoped_pool_reset() {
 }
 
 const array<char>* makeString(region& m, const char* s, size_t len) {
-  array<char>* r = reinterpret_cast<array<char>*>(m.malloc(sizeof(long) + len));
+  auto* r = reinterpret_cast<array<char>*>(m.malloc(sizeof(long) + len));
   r->size = len;
   memcpy(r->data, s, len);
   return r;
@@ -199,7 +199,7 @@ std::string makeStdString(const array<char>* x) {
 
 template <typename T>
   struct maybe {
-    typedef variant<unit, T> ty;
+    using ty = variant<unit, T>;
 
     static const maybe<T>::ty* nothing() {
       return new (memalloc(sizeof(ty), alignof(ty))) ty(unit());
@@ -421,7 +421,7 @@ std::ostringstream& stdoutBuffer() {
 
 void stdoutBufferSwap(std::ostream* os) {
   static std::streambuf* b = std::cout.rdbuf();
-  if (os) {
+  if (os != nullptr) {
     std::cout.rdbuf(os->rdbuf());
   } else {
     std::cout.rdbuf(b);
@@ -435,7 +435,7 @@ void captureStdout() {
 const array<char>* releaseStdout() {
   const array<char>* result = makeString(stdoutBuffer().str());
   stdoutBuffer().str("");
-  stdoutBufferSwap(0);
+  stdoutBufferSwap(nullptr);
   return result;
 }
 
@@ -495,8 +495,8 @@ void dumpBytes(char* d, long len) {
 // support fd reading/writing
 //  (mark FDs as bad if there are errors rather than raising an exception and killing the process)
 std::set<int>& badFDs() {
-  static __thread std::set<int>* bfds = 0;
-  if (!bfds) {
+  static __thread std::set<int>* bfds = nullptr;
+  if (bfds == nullptr) {
     bfds = new std::set<int>();
   }
   return *bfds;
@@ -689,7 +689,7 @@ void initStdFuncDefs(cc& ctx) {
   ctx.bind("stdstringAssign", &stdstringAssign);
 
   // a source of randomness (maybe worth revisiting!)
-  srand(::time(0));
+  srand(::time(nullptr));
   ctx.bind("random", &random);
   ctx.bind("lrand",  &lrand);
   ctx.bind("ceil",   &lceil);
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index e8caf497a..e9eb4f416 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -179,14 +179,14 @@ template <typename... Ts> struct VariantLite {
     return *this;
   }
 
-  VariantLite(VariantLite &&rhs) {
+  VariantLite(VariantLite &&rhs) noexcept {
     tag = rhs.tag;
     if (isValid()) {
       VariantLiteMoveCreator<Ts...>::act(N, rhs.tag, &storage, &rhs.storage);
     }
   }
 
-  VariantLite &operator=(VariantLite &&rhs) & {
+  VariantLite &operator=(VariantLite &&rhs) & noexcept {
     if (isValid()) {
       VariantLiteDeletor<Ts...>::act(N, tag, &storage);
     }
@@ -570,7 +570,7 @@ jitcc::jitcc(const TEnvPtr& tenv)
 
 jitcc::~jitcc() {
   // release low-level functions
-  for (auto f : this->fenv) {
+  for (const auto& f : this->fenv) {
     delete f.second;
   }
 }
@@ -850,9 +850,9 @@ public:
   size_t size() const { return this->sz; }
   void NotifyObjectEmitted(const llvm::object::ObjectFile& o, const llvm::RuntimeDyld::LoadedObjectInfo&) {
     for (auto s : o.symbols()) {
-      const llvm::object::ELFSymbolRef* esr = reinterpret_cast<const llvm::object::ELFSymbolRef*>(&s);
+      const auto* esr = reinterpret_cast<const llvm::object::ELFSymbolRef*>(&s);
 
-      if (esr) {
+      if (esr != nullptr) {
         auto nr = esr->getName();
         if (nr) {
           std::string n(nr.get().data(), nr.get().size());
@@ -1147,7 +1147,7 @@ llvm::Value* jitcc::loadConstant(const std::string& vn) {
 void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
   std::string vname = vn.empty() ? (".global" + freshName()) : vn;
   this->globalExprs[vn] = ue;
-  typedef void (*Thunk)();
+  using Thunk = void (*)();
   MonoTypePtr uety = requireMonotype(this->tenv, ue);
 
   if (isUnit(uety)) {
@@ -1206,7 +1206,7 @@ void jitcc::defineGlobal(const std::string& vn, const ExprPtr& ue) {
 
     // compile and run this function, it should then perform the global variable assignment
     // (make sure that any allocation happens in the global context iff we need it)
-    Thunk f = reinterpret_cast<Thunk>(getMachineCode(initfn));
+    auto f = reinterpret_cast<Thunk>(getMachineCode(initfn));
 
     if (hasPointerRep(uety)) {
       size_t oldregion = pushGlobalRegion();
@@ -1292,7 +1292,7 @@ llvm::Value* jitcc::lookupVar(const std::string& vn, const MonoTypePtr& vty) {
   }
 
   // maybe it's an op?
-  if (lookupOp(vn)) {
+  if (lookupOp(vn) != nullptr) {
     return compile(etaLift(vn, vty, LexicalAnnotation::null()));
   }
 
@@ -1395,7 +1395,7 @@ void jitcc::compileFunctions(const LetRec::Bindings& bs, std::vector<llvm::Funct
 
   unsafeCompileFunctions(&fs);
 
-  if (result) {
+  if (result != nullptr) {
     for (const auto& f : fs) {
       result->push_back(f.result);
     }
@@ -1403,7 +1403,7 @@ void jitcc::compileFunctions(const LetRec::Bindings& bs, std::vector<llvm::Funct
 }
 
 void jitcc::compileFunctions(const LetRec::Bindings& bs) {
-  compileFunctions(bs, 0);
+  compileFunctions(bs, nullptr);
 }
 
 void jitcc::unsafeCompileFunctions(UCFS* ufs) {
@@ -1413,24 +1413,24 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
   llvm::BasicBlock* ibb = withContext([this](auto&) { return this->builder()->GetInsertBlock(); });
 
   // prepare the environment for these mutually-recursive definitions
-  for (size_t f = 0; f < fs.size(); ++f) {
-    llvm::Function* fval = allocFunction(fs[f].name.empty() ? ("/" + freshName()) : fs[f].name, fs[f].argtys, requireMonotype(this->tenv, fs[f].exp));
-    if (fval == 0) {
+  for (auto &f : fs) {
+    llvm::Function* fval = allocFunction(f.name.empty() ? ("/" + freshName()) : f.name, f.argtys, requireMonotype(this->tenv, f.exp));
+    if (fval == nullptr) {
       throw std::runtime_error("Failed to allocate function");
     }
 
 #if LLVM_VERSION_MAJOR >= 11
-    this->bindScope(fs[f].name, fval);
+    this->bindScope(f.name, fval);
 #else
-    this->vtenv.back()[fs[f].name] = fval;
+    this->vtenv.back()[f.name] = fval;
 #endif
-    fs[f].result = fval;
+    f.result = fval;
   }
 
   // now compile each function
-  for (size_t f = 0; f < fs.size(); ++f) {
-    llvm::Function*   fval = fs[f].result;
-    const UCF&        ucf  = fs[f];
+  for (const auto &f : fs) {
+    llvm::Function*   fval = f.result;
+    const UCF&        ucf  = f;
     MonoTypePtr       rty  = requireMonotype(this->tenv, ucf.exp);
     llvm::BasicBlock* bb = withContext(
         [fval](llvm::LLVMContext& c) { return llvm::BasicBlock::Create(c, "entry", fval); });
@@ -1456,7 +1456,7 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
         a->setName(ucf.argns[i]);
 
         llvm::Value* argv = &*a;
-        if (is<FixedArray>(ucf.argtys[i])) {
+        if (is<FixedArray>(ucf.argtys[i]) != nullptr) {
           argv = withContext([&](auto&) {
             return cast(this->builder(), ptrType(toLLVM(ucf.argtys[i], false)), argv);
           });
@@ -1486,9 +1486,9 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
 
         // and we're done
         this->popScope();
-        if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
+        if (ibb != nullptr) { this->builder()->SetInsertPoint(ibb); }
       } catch (...) {
-        if (ibb != 0) { this->builder()->SetInsertPoint(ibb); }
+        if (ibb != nullptr) { this->builder()->SetInsertPoint(ibb); }
         this->popScope();
         throw;
       }
@@ -1498,7 +1498,7 @@ void jitcc::unsafeCompileFunctions(UCFS* ufs) {
 
 llvm::Value* jitcc::compileAllocStmt(llvm::Value* sz, llvm::Value* asz, llvm::Type* mty, bool zeroMem) {
   llvm::Function* f = lookupFunction(zeroMem ? "mallocz" : "malloc");
-  if (!f) throw std::runtime_error("Expected heap allocation function as call.");
+  if (f == nullptr) throw std::runtime_error("Expected heap allocation function as call.");
   return withContext([&](auto&) {
     return builder()->CreateBitCast(fncall(builder(), f, f->getFunctionType(), list(sz, asz)), mty);
   });
@@ -1560,15 +1560,15 @@ void* jitcc::reifyMachineCodeForFn(const MonoTypePtr&, const str::seq& names, co
 // compilation shorthand
 Values compile(jitcc* c, const Exprs& es) {
   Values r;
-  for (Exprs::const_iterator exp = es.begin(); exp != es.end(); ++exp) {
-    r.push_back(c->compile(*exp));
+  for (const auto &e : es) {
+    r.push_back(c->compile(e));
   }
   return r;
 }
 
 Values compileArgs(jitcc* c, const Exprs& es) {
   Values r;
-  for (auto e : es) {
+  for (const auto& e : es) {
     MonoTypePtr  et = requireMonotype(c->typeEnv(), e);
     llvm::Value* ev = c->compile(e);
 
@@ -1578,7 +1578,7 @@ Values compileArgs(jitcc* c, const Exprs& es) {
       }
     }
 
-    if (is<Array>(et)) {
+    if (is<Array>(et) != nullptr) {
       // variable-length arrays need to be cast to a single type to pass LLVM's check
       r.push_back(withContext([&](auto&) {
           return c->builder()->CreateBitCast(ev, toLLVM(et));
@@ -1602,6 +1602,6 @@ ExprPtr jitcc::inlineGlobals(const ExprPtr& e) {
   return s;
 }
 
-op::~op() { }
+op::~op() = default;
 
 } // namespace hobbes
diff --git a/lib/hobbes/eval/search.C b/lib/hobbes/eval/search.C
index 14285eab3..a8211d719 100644
--- a/lib/hobbes/eval/search.C
+++ b/lib/hobbes/eval/search.C
@@ -10,45 +10,45 @@ struct findLabelsF : public switchType<unit> {
   std::set<std::string>* lbls;
   findLabelsF(std::set<std::string>* lbls) : lbls(lbls) { }
 
-  unit with(const TString* v) const {
+  unit with(const TString* v) const override {
     this->lbls->insert(v->value());
-    return unit();
+    return {};
   }
 
-  unit with(const Variant* v) const {
+  unit with(const Variant* v) const override {
     for (const auto& m : v->members()) {
       if (!m.selector.empty() && m.selector[0] != '.') {
         this->lbls->insert(m.selector);
       }
       switchOf(m.type, *this);
     }
-    return unit();
+    return {};
   }
 
-  unit with(const Record* v) const {
+  unit with(const Record* v) const override {
     for (const auto& m : v->members()) {
       if (!m.field.empty() && m.field[0] != '.') {
         this->lbls->insert(m.field);
       }
       switchOf(m.type, *this);
     }
-    return unit();
+    return {};
   }
 
-  unit with(const TAbs*       v) const { return switchOf(v->body(), *this); }
-  unit with(const TApp*       v) const { switchOf(v->fn(), *this); switchOf(v->args(), *this); return unit(); }
-  unit with(const FixedArray* v) const { switchOf(v->type(), *this); return switchOf(v->length(), *this); }
-  unit with(const Array*      v) const { return switchOf(v->type(), *this); }
-  unit with(const Func*       v) const { switchOf(v->argument(), *this); return switchOf(v->result(), *this); }
-  unit with(const Exists*     v) const { return switchOf(v->absType(), *this); }
-  unit with(const Recursive*  v) const { return switchOf(v->recType(), *this); }
+  unit with(const TAbs*       v) const override { return switchOf(v->body(), *this); }
+  unit with(const TApp*       v) const override { switchOf(v->fn(), *this); switchOf(v->args(), *this); return {}; }
+  unit with(const FixedArray* v) const override { switchOf(v->type(), *this); return switchOf(v->length(), *this); }
+  unit with(const Array*      v) const override { return switchOf(v->type(), *this); }
+  unit with(const Func*       v) const override { switchOf(v->argument(), *this); return switchOf(v->result(), *this); }
+  unit with(const Exists*     v) const override { return switchOf(v->absType(), *this); }
+  unit with(const Recursive*  v) const override { return switchOf(v->recType(), *this); }
   
-  unit with(const Prim*        ) const { return unit(); }
-  unit with(const OpaquePtr*   ) const { return unit(); }
-  unit with(const TVar*        ) const { return unit(); }
-  unit with(const TGen*        ) const { return unit(); }
-  unit with(const TLong*       ) const { return unit(); }
-  unit with(const TExpr*       ) const { return unit(); }
+  unit with(const Prim*        ) const override { return {}; }
+  unit with(const OpaquePtr*   ) const override { return {}; }
+  unit with(const TVar*        ) const override { return {}; }
+  unit with(const TGen*        ) const override { return {}; }
+  unit with(const TLong*       ) const override { return {}; }
+  unit with(const TExpr*       ) const override { return {}; }
 };
 static void accumLabels(std::set<std::string>* lbls, const MonoTypePtr& t) {
   switchOf(t, findLabelsF(lbls));
@@ -58,8 +58,8 @@ static void accumLabels(std::set<std::string>* lbls, const TEnvPtr& tenv) {
   // (it might be reasonable to gather labels across types in _all_ ground type class instances)
   try {
     auto uq = tenv->lookupUnqualifier("SLookup");
-    if (const TClass* c = dynamic_cast<const TClass*>(uq.get())) {
-      for (auto i : c->instances()) {
+    if (const auto* c = dynamic_cast<const TClass*>(uq.get())) {
+      for (const auto& i : c->instances()) {
         if (i->types().size() > 2) {
           if (const TString* s = is<TString>(i->types()[1])) {
             lbls->insert(s->value());
@@ -75,7 +75,7 @@ static void accumLabels(std::set<std::string>* lbls, const TEnvPtr& tenv) {
     if (!vnt.first.empty() && vnt.first[0] != '.') {
       lbls->insert(vnt.first);
 
-      if (vnt.second->typeVariables() == 0 && vnt.second->qualtype()->constraints().size() == 0) {
+      if (vnt.second->typeVariables() == 0 && vnt.second->qualtype()->constraints().empty()) {
         accumLabels(lbls, vnt.second->qualtype()->monoType());
       }
     }
@@ -135,7 +135,7 @@ struct containsTypeF : public switchType<bool> {
   bool baseC(const MonoType& t) const { return t == *this->ty; }
   bool anyC(const MonoTypes& ts) const { for (const auto& t : ts) { if (switchOf(t, *this)) return true; } return false; }
 
-  bool with(const Variant* v) const {
+  bool with(const Variant* v) const override {
     if (baseC(*v)) return true;
     for (const auto& m : v->members()) {
       if (switchOf(m.type, *this)) {
@@ -145,7 +145,7 @@ struct containsTypeF : public switchType<bool> {
     return false;
   }
 
-  bool with(const Record* v) const {
+  bool with(const Record* v) const override {
     if (baseC(*v)) return true;
     for (const auto& m : v->members()) {
       if (switchOf(m.type, *this)) {
@@ -155,21 +155,21 @@ struct containsTypeF : public switchType<bool> {
     return false;
   }
 
-  bool with(const TAbs*       v) const { return baseC(*v) || switchOf(v->body(), *this); }
-  bool with(const TApp*       v) const { return baseC(*v) || switchOf(v->fn(), *this) || anyC(v->args()); }
-  bool with(const FixedArray* v) const { return baseC(*v) || switchOf(v->type(), *this) || switchOf(v->length(), *this); }
-  bool with(const Array*      v) const { return baseC(*v) || switchOf(v->type(), *this); }
-  bool with(const Func*       v) const { return baseC(*v) || switchOf(v->argument(), *this) || switchOf(v->result(), *this); }
-  bool with(const Exists*     v) const { return baseC(*v) || switchOf(v->absType(), *this); }
-  bool with(const Recursive*  v) const { return baseC(*v) || switchOf(v->recType(), *this); }
+  bool with(const TAbs*       v) const override { return baseC(*v) || switchOf(v->body(), *this); }
+  bool with(const TApp*       v) const override { return baseC(*v) || switchOf(v->fn(), *this) || anyC(v->args()); }
+  bool with(const FixedArray* v) const override { return baseC(*v) || switchOf(v->type(), *this) || switchOf(v->length(), *this); }
+  bool with(const Array*      v) const override { return baseC(*v) || switchOf(v->type(), *this); }
+  bool with(const Func*       v) const override { return baseC(*v) || switchOf(v->argument(), *this) || switchOf(v->result(), *this); }
+  bool with(const Exists*     v) const override { return baseC(*v) || switchOf(v->absType(), *this); }
+  bool with(const Recursive*  v) const override { return baseC(*v) || switchOf(v->recType(), *this); }
   
-  bool with(const Prim*      v) const { return baseC(*v); }
-  bool with(const OpaquePtr* v) const { return baseC(*v); }
-  bool with(const TVar*      v) const { return baseC(*v); }
-  bool with(const TGen*      v) const { return baseC(*v); }
-  bool with(const TLong*     v) const { return baseC(*v); }
-  bool with(const TString*   v) const { return baseC(*v); }
-  bool with(const TExpr*     v) const { return baseC(*v); }
+  bool with(const Prim*      v) const override { return baseC(*v); }
+  bool with(const OpaquePtr* v) const override { return baseC(*v); }
+  bool with(const TVar*      v) const override { return baseC(*v); }
+  bool with(const TGen*      v) const override { return baseC(*v); }
+  bool with(const TLong*     v) const override { return baseC(*v); }
+  bool with(const TString*   v) const override { return baseC(*v); }
+  bool with(const TExpr*     v) const override { return baseC(*v); }
 };
 bool validSearchResult(const SearchEntry& e, const MonoTypePtr& dst) {
   return switchOf(e.ty, containsTypeF(dst));
@@ -177,11 +177,11 @@ bool validSearchResult(const SearchEntry& e, const MonoTypePtr& dst) {
 
 // search for symbols going from one type to another
 SearchEntries search(cc& c, SearchCache& sc, const MonoTypePtr& src, const MonoTypePtr& dst) {
-  if (sc.univByType[src].size() == 0) {
+  if (sc.univByType[src].empty()) {
     sc.univByType[src] = findAll(c, src);
   }
 
-  if (is<TVar>(dst)) {
+  if (is<TVar>(dst) != nullptr) {
     // searching for everything, we already have it
     return sc.univByType[src];
   } else {
diff --git a/lib/hobbes/events/events.C b/lib/hobbes/events/events.C
index 018d8cef0..2c72001af 100644
--- a/lib/hobbes/events/events.C
+++ b/lib/hobbes/events/events.C
@@ -22,7 +22,7 @@ struct eventcbclosure {
   int                      fd;
   std::function<void(int)> fn;
 };
-typedef std::map<int, eventcbclosure*> EventClosures;
+using EventClosures = std::map<int, eventcbclosure *>;
 
 void registerEventHandler(int fd, eventhandler fn, void* ud, bool f) {
   registerEventHandler(fd, [fn,ud](int c){fn(c,ud);}, f);
@@ -31,7 +31,7 @@ void registerEventHandler(int fd, eventhandler fn, void* ud, bool f) {
 #ifdef BUILD_LINUX
 thread_local bool           epInitialized = false;
 thread_local int            epFD          = 0;
-thread_local EventClosures* epClosures    = 0;
+thread_local EventClosures* epClosures    = nullptr;
 
 struct timer {
   timerfunc func;
@@ -43,7 +43,7 @@ bool operator>(const timer& a, const timer& b) {
   return a.callTime > b.callTime;
 }
 
-thread_local std::priority_queue<timer, std::vector<timer>, std::greater<timer>> timers;
+thread_local std::priority_queue<timer, std::vector<timer>, std::greater<>> timers;
 
 int threadEPollFD() {
   if (!epInitialized) {
@@ -70,7 +70,7 @@ void unregisterEventHandler(int fd) {
 void registerEventHandler(int fd, const std::function<void(int)>& fn, bool) {
   int epfd = threadEPollFD();
 
-  eventcbclosure* c = new eventcbclosure(fd, fn);
+  auto* c = new eventcbclosure(fd, fn);
   (*epClosures)[fd] = c;
 
   struct epoll_event evt;
@@ -105,14 +105,14 @@ bool stepEventLoop(int timeoutMS) {
     bool status = true;
     if (fds > 0) {
       for (int fd = 0; fd < fds; ++fd) {
-        eventcbclosure* c = reinterpret_cast<eventcbclosure*>(evts[fd].data.ptr);
+        auto* c = reinterpret_cast<eventcbclosure*>(evts[fd].data.ptr);
         (c->fn)(c->fd);
         resetMemoryPool();
       }
     } else if (fds < 0) {
       if (errno != EINTR) {
         status = false;
-      } else if (epClosures) {
+      } else if (epClosures != nullptr) {
         auto f = epClosures->find(-1);
         if (f != epClosures->end()) {
           f->second->fn(-1);
@@ -174,7 +174,7 @@ void runEventLoop(int microsecondDuration) {
     int fds = epoll_wait(threadEPollFD(), evts, sizeof(evts)/sizeof(evts[0]), timeout);
     if (fds > 0) {
       for (int fd = 0; fd < fds; ++fd) {
-        eventcbclosure* c = reinterpret_cast<eventcbclosure*>(evts[fd].data.ptr);
+        auto* c = reinterpret_cast<eventcbclosure*>(evts[fd].data.ptr);
         (c->fn)(c->fd);
         resetMemoryPool();
       }
diff --git a/lib/hobbes/events/httpd.C b/lib/hobbes/events/httpd.C
index c1cf9441b..934379749 100644
--- a/lib/hobbes/events/httpd.C
+++ b/lib/hobbes/events/httpd.C
@@ -6,14 +6,14 @@
 
 #include <sstream>
 
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
+#include <cstring>
+#include <fcntl.h>
 #include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
 
 namespace hobbes {
 
@@ -131,7 +131,7 @@ private:
 };
 
 void evaluatePartialHTTPRequest(int c, void* ud) {
-  PartialHTTPRequestState* s = reinterpret_cast<PartialHTTPRequestState*>(ud);
+  auto* s = reinterpret_cast<PartialHTTPRequestState*>(ud);
 
   char buf[1024];
   ssize_t m = 0;
@@ -151,15 +151,15 @@ void evaluatePartialHTTPRequest(int c, void* ud) {
 int installHTTPD(int port, HTTPRequestHandler f, void* ud) {
   int s = allocateServer(port);
 
-  typedef std::pair<HTTPRequestHandler, void*> ReqCB;
-  ReqCB* rcb = new ReqCB(f, ud);
+  using ReqCB = std::pair<HTTPRequestHandler, void *>;
+  auto* rcb = new ReqCB(f, ud);
 
   registerEventHandler(
     s,
     [](int s, void* d) {
-      int c = accept(s, 0, 0);
+      int c = accept(s, nullptr, nullptr);
       if (c != -1) {
-        ReqCB* rcb = reinterpret_cast<ReqCB*>(d);
+        auto* rcb = reinterpret_cast<ReqCB*>(d);
         fcntl(c, F_SETFL, fcntl(c, F_GETFL) | O_NONBLOCK);
         registerEventHandler(c, &evaluatePartialHTTPRequest, reinterpret_cast<void*>(new PartialHTTPRequestState(c, rcb->first, rcb->second)));
       }
diff --git a/lib/hobbes/ipc/nbindings.C b/lib/hobbes/ipc/nbindings.C
index 7b10ad199..a93a4b3a1 100644
--- a/lib/hobbes/ipc/nbindings.C
+++ b/lib/hobbes/ipc/nbindings.C
@@ -1,17 +1,18 @@
 
 #include <hobbes/hobbes.H>
-#include <hobbes/lang/preds/class.H>
-#include <hobbes/lang/tyunqualify.H>
 #include <hobbes/ipc/nbindings.H>
 #include <hobbes/ipc/net.H>
+#include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/tyunqualify.H>
 #include <map>
+#include <memory>
 
 namespace hobbes {
 
 /******************
  * global set of client connections
  ******************/
-typedef std::set<Client*> Connections;
+using Connections = std::set<Client *>;
 static Connections connections;
 
 bool isAllocatedConnection(Client* c) {
@@ -19,7 +20,7 @@ bool isAllocatedConnection(Client* c) {
 }
 
 Client* makeConnection(const std::string& hp) {
-  Client* r = new Client(hp);
+  auto* r = new Client(hp);
   connections.insert(r);
   return r;
 }
@@ -40,7 +41,7 @@ Client* decodeConnType(const MonoTypePtr& t) {
       }
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool isPartialConnection(const MonoTypePtr& t) {
@@ -49,7 +50,7 @@ bool isPartialConnection(const MonoTypePtr& t) {
       if (const Prim* apn = is<Prim>(ap->fn())) {
         return apn->name() == "connection";
       } else {
-        return is<TVar>(ap->fn());
+        return is<TVar>(ap->fn()) != nullptr;
       }
     }
   }
@@ -66,7 +67,7 @@ public:
   static std::string constraintName() { return "Connect"; }
   static std::string connectVar() { return "connection"; }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) override {
     MonoTypePtr hostport;
     MonoTypePtr handle;
 
@@ -86,7 +87,7 @@ public:
     return false;
   }
 
-  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const override {
     MonoTypePtr hostport;
     MonoTypePtr handle;
 
@@ -98,16 +99,16 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfiable(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const override {
     MonoTypePtr hostport;
     MonoTypePtr handle;
     
     return decodeConstraint(cst, &hostport, &handle) &&
-           (is<TVar>(hostport) || is<TString>(hostport)) &&
-           (is<TVar>(handle) || isPartialConnection(handle));
+           ((is<TVar>(hostport) != nullptr) || (is<TString>(hostport) != nullptr)) &&
+           ((is<TVar>(handle) != nullptr) || isPartialConnection(handle));
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct StripConnQual : public switchExprTyFn {
@@ -116,13 +117,13 @@ public:
     StripConnQual(const ConstraintPtr& cst) : constraint(cst) {
     }
   
-    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
       ExprPtr result(e);
       result->type(removeConstraint(this->constraint, qty));
       return result;
     }
 
-    ExprPtr with(const Var* v) const {
+    ExprPtr with(const Var* v) const override {
       if (v->value() == connectVar() && hasConstraint(this->constraint, v->type())) {
         return mktunit(v->la());
       } else {
@@ -131,25 +132,25 @@ public:
     }
   };
 
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const {
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const override {
     return switchOf(e, StripConnQual(cst));
   }
 
-  PolyTypePtr lookup(const std::string& vn) const {
+  PolyTypePtr lookup(const std::string& vn) const override {
     if (vn == connectVar()) {
-      return polytype(2, qualtype(list(ConstraintPtr(new Constraint(constraintName(), list(tgen(0), tgen(1))))), tgen(1)));
+      return polytype(2, qualtype(list(std::make_shared<Constraint>(constraintName(), list(tgen(0), tgen(1)))), tgen(1)));
     } else {
       return PolyTypePtr();
     }
   }
 
-  SymSet bindings() const {
+  SymSet bindings() const override {
     SymSet r;
     r.insert(connectVar());
     return r;
   }
 
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     return list(FunDep(list(0), 1), FunDep(list(1), 0));
   }
 private:
@@ -172,11 +173,11 @@ public:
   static std::string constraintName() { return "Invoke"; }
   static std::string netInvoke() { return "invoke"; }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) override {
     MonoTypePtr ch, expr, inty, outty;
     if (decodeConstraint(cst, &ch, &expr, &inty, &outty)) {
       if (const TLong* chv = is<TLong>(ch)) {
-        if (Client* conn = reinterpret_cast<Client*>(chv->value())) {
+        if (auto* conn = reinterpret_cast<Client*>(chv->value())) {
           if (const TExpr* exprv = is<TExpr>(expr)) {
             if (isAllocatedConnection(conn) && !hasFreeVariables(inty)) {
               size_t uc = u->size();
@@ -190,16 +191,16 @@ public:
     return false;
   }
 
-  bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
+  bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const override {
     MonoTypePtr ch, expr, inty, outty;
     if (decodeConstraint(cst, &ch, &expr, &inty, &outty)) {
       if (const TLong* chv = is<TLong>(ch)) {
-        if (Client* conn = reinterpret_cast<Client*>(chv->value())) {
+        if (auto* conn = reinterpret_cast<Client*>(chv->value())) {
           if (const TExpr* exprv = is<TExpr>(expr)) {
             if (isAllocatedConnection(conn) && !hasFreeVariables(inty)) {
               return *outty == *conn->output(exprv->expr(), inty);
-                     hobbes::satisfied(tenv, ConstraintPtr(new Constraint("BlockCodec", list(inty))), ds) &&
-                     hobbes::satisfied(tenv, ConstraintPtr(new Constraint("BlockCodec", list(outty))), ds);
+                     hobbes::satisfied(tenv, std::make_shared<Constraint>("BlockCodec", list(inty)), ds) &&
+                     hobbes::satisfied(tenv, std::make_shared<Constraint>("BlockCodec", list(outty)), ds);
             }
           }
         }
@@ -208,22 +209,22 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
+  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const override {
     MonoTypePtr ch, expr, inty, outty;
     if (!decodeConstraint(cst, &ch, &expr, &inty, &outty)) { return false; }
 
-    TLong* chv = is<TLong>(ch);
-    if (!chv) { return is<TVar>(ch); }
-    Client* conn = reinterpret_cast<Client*>(chv->value());
-    if (!conn || !isAllocatedConnection(conn)) { return false; }
+    auto* chv = is<TLong>(ch);
+    if (chv == nullptr) { return is<TVar>(ch) != nullptr; }
+    auto* conn = reinterpret_cast<Client*>(chv->value());
+    if ((conn == nullptr) || !isAllocatedConnection(conn)) { return false; }
 
-    TExpr* exprv = is<TExpr>(expr);
-    if (!exprv) { return is<TVar>(expr); }
+    auto* exprv = is<TExpr>(expr);
+    if (exprv == nullptr) { return is<TVar>(expr) != nullptr; }
 
     return hasFreeVariables(inty) || satisfied(tenv, cst, ds);
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct RewriteInvokes : public switchExprTyFn {
@@ -233,13 +234,13 @@ public:
     RewriteInvokes(const ConstraintPtr& cst, const std::string& invokeFn) : constraint(cst), invokeFn(invokeFn) {
     }
   
-    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
       ExprPtr result(e);
       result->type(removeConstraint(this->constraint, qty));
       return result;
     }
   
-    ExprPtr with(const Var* v) const {
+    ExprPtr with(const Var* v) const override {
       if (v->value() == netInvoke() && hasConstraint(this->constraint, v->type())) {
         return var(this->invokeFn, removeConstraint(this->constraint, v->type()), v->la());
       } else {
@@ -248,16 +249,16 @@ public:
     }
   };
 
-  ExprPtr unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const {
+  ExprPtr unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const override {
     std::string invokeFn = makeInvokeFn(tenv, cst, ds, e->la());
     return switchOf(e, RewriteInvokes(cst, invokeFn));
   }
 
-  PolyTypePtr lookup(const std::string& vn) const {
+  PolyTypePtr lookup(const std::string& vn) const override {
     if (vn == netInvoke()) {
       // invoke :: (Invoke ch expr inty outty) => (connection ch, quote expr, inty) -> (promise ch outty)
       return polytype(4,
-        qualtype(list(ConstraintPtr(new Constraint(constraintName(), list(tgen(0), tgen(1), tgen(2), tgen(3))))),
+        qualtype(list(std::make_shared<Constraint>(constraintName(), list(tgen(0), tgen(1), tgen(2), tgen(3)))),
           functy(
             list(
               tapp(primty("connection"), list(tgen(0))),
@@ -273,13 +274,13 @@ public:
     }
   }
 
-  SymSet bindings() const {
+  SymSet bindings() const override {
     SymSet r;
     r.insert(netInvoke());
     return r;
   }
 
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     return list(FunDep(list(0, 1, 2), 3));
   }
 private:
@@ -298,7 +299,7 @@ private:
     MonoTypePtr ch, expr, inty, outty;
     if (decodeConstraint(cst, &ch, &expr, &inty, &outty)) {
       if (const TLong* chv = is<TLong>(ch)) {
-        if (Client* c = reinterpret_cast<Client*>(chv->value())) {
+        if (auto* c = reinterpret_cast<Client*>(chv->value())) {
           if (const TExpr* exprv = is<TExpr>(expr)) {
             if (isAllocatedConnection(c) && !hasFreeVariables(inty)) {
               MonoTypePtr retty = tapp(primty("promise"), list(ch, outty));
@@ -309,8 +310,8 @@ private:
               MonoTypePtr urfnty = functy(list(intt), opaqueptr<char>(false));
               MonoTypePtr rfnty  = functy(list(intt), tuplety(list(outty)));
 
-              ConstraintPtr incst  = ConstraintPtr(new Constraint("BlockCodec", list(inty)));
-              ConstraintPtr outcst = ConstraintPtr(new Constraint("BlockCodec", list(tuplety(list(outty)))));
+              ConstraintPtr incst  = std::make_shared<Constraint>("BlockCodec", list(inty));
+              ConstraintPtr outcst = std::make_shared<Constraint>("BlockCodec", list(tuplety(list(outty))));
               ExprPtr qinvokeFn =
                 fn(str::strings(".ch", ".expr", ".x"),
                   // write the 'invoke expression' indicator byte
@@ -355,17 +356,17 @@ public:
   static std::string constraintName() { return "Receive"; }
   static std::string receive()        { return "receive"; }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr&, MonoTypeUnifier*, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr&, MonoTypeUnifier*, Definitions*) override {
     return false;
   }
 
-  bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
+  bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const override {
     MonoTypePtr ch, rty;
     if (decodeConstraint(cst, &ch, &rty)) {
       if (const TLong* chv = is<TLong>(ch)) {
-        if (Client* conn = reinterpret_cast<Client*>(chv->value())) {
+        if (auto* conn = reinterpret_cast<Client*>(chv->value())) {
           if (isAllocatedConnection(conn) && !hasFreeVariables(rty)) {
-            return hobbes::satisfied(tenv, ConstraintPtr(new Constraint("BlockCodec", list(rty))), ds);
+            return hobbes::satisfied(tenv, std::make_shared<Constraint>("BlockCodec", list(rty)), ds);
           }
         }
       }
@@ -373,19 +374,19 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
+  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const override {
     MonoTypePtr ch, rty;
     if (!decodeConstraint(cst, &ch, &rty)) { return false; }
 
-    TLong* chv = is<TLong>(ch);
-    if (!chv) { return is<TVar>(ch); }
-    Client* conn = reinterpret_cast<Client*>(chv->value());
-    if (!conn || !isAllocatedConnection(conn)) { return false; }
+    auto* chv = is<TLong>(ch);
+    if (chv == nullptr) { return is<TVar>(ch) != nullptr; }
+    auto* conn = reinterpret_cast<Client*>(chv->value());
+    if ((conn == nullptr) || !isAllocatedConnection(conn)) { return false; }
 
     return hasFreeVariables(rty) || satisfied(tenv, cst, ds);
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct RewriteReceives : public switchExprTyFn {
@@ -395,13 +396,13 @@ public:
     RewriteReceives(const ConstraintPtr& cst, const std::string& receiveFn) : constraint(cst), receiveFn(receiveFn) {
     }
   
-    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
       ExprPtr result(e);
       result->type(removeConstraint(this->constraint, qty));
       return result;
     }
   
-    ExprPtr with(const Var* v) const {
+    ExprPtr with(const Var* v) const override {
       if (v->value() == receive() && hasConstraint(this->constraint, v->type())) {
         return var(this->receiveFn, removeConstraint(this->constraint, v->type()), v->la());
       } else {
@@ -410,16 +411,16 @@ public:
     }
   };
 
-  ExprPtr unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const {
+  ExprPtr unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const override {
     std::string receiveFn = makeReceiveFn(tenv, cst, ds, e->la());
     return switchOf(e, RewriteReceives(cst, receiveFn));
   }
 
-  PolyTypePtr lookup(const std::string& vn) const {
+  PolyTypePtr lookup(const std::string& vn) const override {
     if (vn == receive()) {
       // receive :: (Receive ch outty) => (promise ch ty) -> ty
       return polytype(2,
-        qualtype(list(ConstraintPtr(new Constraint(constraintName(), list(tgen(0), tgen(1))))),
+        qualtype(list(std::make_shared<Constraint>(constraintName(), list(tgen(0), tgen(1)))),
           functy(
             list(
               tapp(primty("promise"), list(tgen(0), tgen(1)))
@@ -433,13 +434,13 @@ public:
     }
   }
 
-  SymSet bindings() const {
+  SymSet bindings() const override {
     SymSet r;
     r.insert(receive());
     return r;
   }
 
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     return FunDeps();
   }
 private:
@@ -456,7 +457,7 @@ private:
     MonoTypePtr ch, ty;
     if (decodeConstraint(cst, &ch, &ty)) {
       if (const TLong* chv = is<TLong>(ch)) {
-        if (Client* c = reinterpret_cast<Client*>(chv->value())) {
+        if (auto* c = reinterpret_cast<Client*>(chv->value())) {
           if (isAllocatedConnection(c) && !hasFreeVariables(ty)) {
             // our receive function is uniquely determined by its connection and result type
             std::string recvFnName = ".cxn.recvFn." + str::from(chv->value()) + "." + str::from(reinterpret_cast<long>(ty.get()));
@@ -518,7 +519,7 @@ struct printConnectionF : public op {
   printConnectionF(const std::string& showf) : showf(showf) {
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     if (Client* conn = decodeConnType(tys[0])) {
       ExprPtr wfrtfn = var(this->showf, functy(list(primty("long")), primty("unit")), es[0]->la());
       return c->compile(fncall(wfrtfn, list(constant(reinterpret_cast<long>(conn), es[0]->la())), es[0]->la()));
@@ -527,16 +528,15 @@ struct printConnectionF : public op {
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     return polytype(1, qualtype(functy(list(tapp(primty("connection"), list(tgen(0)))), primty("unit"))));
   }
 };
 
 struct remoteHostF : public op {
-  remoteHostF() {
-  }
+  remoteHostF() = default;
 
-  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes& tys, const MonoTypePtr&, const Exprs& es) override {
     if (Client* conn = decodeConnType(tys[0])) {
       return c->compile(ExprPtr(mkarray(conn->remoteHost(), es[0]->la())));
     } else {
@@ -544,7 +544,7 @@ struct remoteHostF : public op {
     }
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     return polytype(1, qualtype(functy(list(tapp(primty("connection"), list(tgen(0)))), arrayty(primty("char")))));
   }
 };
diff --git a/lib/hobbes/ipc/net.C b/lib/hobbes/ipc/net.C
index c3959e782..0b7f3468b 100644
--- a/lib/hobbes/ipc/net.C
+++ b/lib/hobbes/ipc/net.C
@@ -7,10 +7,10 @@
 
 #include <sstream>
 
+#include <cstring>
 #include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
-#include <string.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ -25,7 +25,7 @@ int lookupPort(const std::string &x) {
     return str::to<int>(x);
   } else {
     struct servent *s = getservbyname(x.c_str(), "tcp");
-    if (s != 0) {
+    if (s != nullptr) {
       return ntohs(s->s_port);
     } else {
       throw std::runtime_error("Failed to resolve port name: " + x);
@@ -36,9 +36,9 @@ int lookupPort(const std::string &x) {
 // create a listening socket on a given port and a given host
 int allocateServer(int port, const std::string &host) {
   struct addrinfo *addrs = net::lookupAddrInfo(host, std::to_string(port));
-  struct addrinfo *p = NULL;
+  struct addrinfo *p = nullptr;
   int s;
-  for (p = addrs; p != 0; p = p->ai_next) {
+  for (p = addrs; p != nullptr; p = p->ai_next) {
     if (p->ai_family != AF_INET || p->ai_protocol != IPPROTO_TCP)
       continue;
     s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
@@ -56,7 +56,7 @@ int allocateServer(int port, const std::string &host) {
     close(s);
   }
   freeaddrinfo(addrs);
-  if (p == NULL) {
+  if (p == nullptr) {
     throw std::runtime_error("Unable to bind socket to address: " +
                              std::string(strerror(errno)));
   }
@@ -115,7 +115,7 @@ int connectSocket(int r, sockaddr *saddr, size_t len) {
   FD_ZERO(&wd);
   FD_SET(r, &wd);
 
-  if (select(r + 1, 0, &wd, 0, 0) == -1) {
+  if (select(r + 1, nullptr, &wd, nullptr, nullptr) == -1) {
     std::ostringstream ss;
     ss << "Failed to connect socket while waiting for writeability: "
        << strerror(errno) << std::flush;
@@ -160,7 +160,7 @@ int connectFileSocket(const std::string &filepath) {
 }
 
 int connectSocket(const std::string &host, int port) {
-  if (host.size() > 0 && str::isDigit(host[0])) {
+  if (!host.empty() && str::isDigit(host[0])) {
     return connectSocket(gethostbyaddr(host.c_str(), host.size(), AF_INET),
                          port);
   } else {
@@ -170,7 +170,7 @@ int connectSocket(const std::string &host, int port) {
 
 int connectSocket(const std::string &hostport) {
   str::pair p = str::lsplit(hostport, ":");
-  if (p.second.size() > 0)
+  if (!p.second.empty())
     return connectSocket(p.first, lookupPort(p.second));
   else
     return connectFileSocket(p.first);
@@ -208,7 +208,7 @@ void prepareStrExpr(Server *s, int c, exprid eid, const std::string &expr,
                     const MonoTypes &intys, const MonoTypePtr &outty) {
   auto la = LexicalAnnotation::null();
 
-  if (intys.size() == 0 || (intys.size() == 1 && isUnit(intys[0]))) {
+  if (intys.empty() || (intys.size() == 1 && isUnit(intys[0]))) {
     s->prepare(c, eid,
                assume(s->readExpr(expr), functy(tuplety(intys), outty), la),
                tuplety());
@@ -224,7 +224,7 @@ void prepareStrExpr(Server *s, int c, exprid eid, const std::string &expr,
 }
 
 void evaluateNetREPLRequest(int c, void *d) {
-  Server *s = reinterpret_cast<Server *>(d);
+  auto *s = reinterpret_cast<Server *>(d);
 
   try {
     uint8_t cmd = 0;
@@ -308,7 +308,7 @@ void registerNetREPL(int s, Server *svr) {
   registerEventHandler(
       s,
       [](int s, void *d) {
-        int c = accept(s, 0, 0);
+        int c = accept(s, nullptr, nullptr);
         if (c != -1) {
           try {
             uint32_t version = 0;
@@ -349,12 +349,12 @@ class CCServer : public Server {
 public:
   CCServer(cc *c, ReWriteExprFn const &wrExprFn) : c(c), wrExprFn(wrExprFn) {}
 
-  void connect(int) {}
+  void connect(int) override {}
 
-  ExprPtr readExpr(const std::string &x) { return this->c->readExpr(x); }
+  ExprPtr readExpr(const std::string &x) override { return this->c->readExpr(x); }
 
   MonoTypePtr prepare(int c, exprid eid, const ExprPtr &expr,
-                      const MonoTypePtr &inty) {
+                      const MonoTypePtr &inty) override {
     const auto &la = expr->la();
 
     // E(readFrom(in)::T) :: ?
@@ -382,7 +382,7 @@ public:
     return rty;
   }
 
-  void evaluate(int c, exprid eid) {
+  void evaluate(int c, exprid eid) override {
     auto cfns = this->cnetFns[c];
     auto f = cfns.find(eid);
 
@@ -397,14 +397,14 @@ public:
     }
   }
 
-  void disconnect(int) {}
+  void disconnect(int) override {}
 
 private:
   cc *c;
 
-  typedef void (*NetFn)(int); // socket -> ()
-  typedef std::map<exprid, NetFn> NetFns;
-  typedef std::map<int, NetFns> ConnNetFns;
+  using NetFn = void (*)(int); // socket -> ()
+  using NetFns = std::map<exprid, NetFn>;
+  using ConnNetFns = std::map<int, NetFns>;
   ConnNetFns cnetFns;
   ReWriteExprFn wrExprFn;
 };
diff --git a/lib/hobbes/ipc/prepl.C b/lib/hobbes/ipc/prepl.C
index 37f1f52d8..99e6c732b 100644
--- a/lib/hobbes/ipc/prepl.C
+++ b/lib/hobbes/ipc/prepl.C
@@ -1,30 +1,30 @@
 
+#include <cstring>
+#include <fcntl.h>
 #include <hobbes/hobbes.H>
 #include <hobbes/ipc/prepl.H>
 #include <hobbes/util/codec.H>
 #include <hobbes/util/os.H>
 #include <sstream>
-#include <unistd.h>
-#include <string.h>
-#include <sys/wait.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/mman.h>
-#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
 
 namespace hobbes {
 
 void execProcess(const std::string& cmd) {
   str::seq args = str::trim(str::csplit(cmd, " "));
   std::vector<const char*> argv;
-  for (size_t i = 0; i < args.size(); ++i) {
-    if (!args[i].empty()) {
-      argv.push_back(args[i].c_str());
+  for (const auto &arg : args) {
+    if (!arg.empty()) {
+      argv.push_back(arg.c_str());
     }
   }
-  if (args.size() == 0) return;
+  if (args.empty()) return;
 
-  argv.push_back(0);
+  argv.push_back(nullptr);
   execv(args[0].c_str(), const_cast<char* const*>(&argv[0]));
 }
 
@@ -76,7 +76,7 @@ void spawn(const std::string& cmd, proc* p) {
       memset(&tmout, 0, sizeof(tmout));
       tmout.tv_sec = 30 * 60;
 
-      select(FD_SETSIZE, &fds, NULL, NULL, &tmout);
+      select(FD_SETSIZE, &fds, nullptr, nullptr, &tmout);
 
       if (FD_ISSET(c2p[0], &fds)) {
         int success = 0;
@@ -108,10 +108,10 @@ void spawn(const std::string& cmd, proc* p) {
       p->read_fd  = c2p[0];
     }
   } catch (...) {
-    if (p2c[0]) close(p2c[0]);
-    if (p2c[1]) close(p2c[1]);
-    if (c2p[0]) close(c2p[0]);
-    if (c2p[1]) close(c2p[1]);
+    if (p2c[0] != 0) close(p2c[0]);
+    if (p2c[1] != 0) close(p2c[1]);
+    if (c2p[0] != 0) close(c2p[0]);
+    if (c2p[1] != 0) close(c2p[1]);
     throw;
   }
 }
@@ -129,15 +129,15 @@ long ProcManager::spawnedPid(const std::string& cmd) {
   }
 }
 
-typedef void (*ThunkF)();
-typedef std::vector<ThunkF> ThunkFs;
+using ThunkF = void (*)();
+using ThunkFs = std::vector<ThunkF>;
 
 static int machineREPLLogFD = -1;
 
 void dbglog(const std::string& msg) {
   if (machineREPLLogFD > 0) {
     char buf[256];
-    time_t t = ::time(0);
+    time_t t = ::time(nullptr);
     strftime(buf, sizeof(buf), "%H:%M:%S", localtime(reinterpret_cast<time_t*>(&t)));
 
     std::string logmsg = std::string(buf) + ": " + msg + "\n";
@@ -202,7 +202,7 @@ void printAnnotatedError(cc* eval, std::ostream& out, const hobbes::annotated_er
   for (const auto& m : ae.messages()) {
     out << m.second.lineDesc() << ": " << m.first << "\n";
     for (const auto& c : cs) {
-      if (eval && !satisfied(eval, c)) {
+      if ((eval != nullptr) && !satisfied(eval, c)) {
         out << "  " << hobbes::show(c) << std::endl;
       }
     }
@@ -284,7 +284,7 @@ void runMachineREPLStep(cc* c) {
 
       // buffer the result to remove any accidental internal terminators
       std::ostringstream ss;
-      auto stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
+      auto *stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
       try {
         c->compileFn<void()>("print(" + expr + ")")();
         resetMemoryPool();
@@ -316,7 +316,7 @@ void runMachineREPLStep(cc* c) {
 
       // buffer the result to remove any accidental internal terminators
       std::ostringstream ss;
-      auto stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
+      auto *stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
 
       try {
         std::cout << show(simplifyVarNames(c->unsweetenExpression(c->readExpr(expr))->type()));
@@ -364,7 +364,7 @@ void runMachineREPLStep(cc* c) {
 
       // buffer the result to remove any accidental internal terminators
       std::ostringstream ss;
-      auto stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
+      auto *stdoutbuffer = std::cout.rdbuf(ss.rdbuf());
 
       try {
         c->define(vname, expr);
@@ -399,7 +399,7 @@ void runMachineREPLStep(cc* c) {
       try {
         std::ostringstream ss;
         auto ses = c->search(expr, ty);
-        if (ses.size() > 0) {
+        if (!ses.empty()) {
           std::map<std::string, std::string> stbl;
           for (const auto& se : ses) {
             stbl[se.sym] = show(se.ty);
@@ -439,7 +439,7 @@ void runMachineREPLStep(cc* c) {
   }
 }
 
-typedef std::map<int,const char*> Signames;
+using Signames = std::map<int, const char *>;
 static Signames rsignames;
 static void deadlySignal [[noreturn]] (int sig, siginfo_t*, void*) {
   if (machineREPLLogFD > 0) {
@@ -541,7 +541,7 @@ void procRead(proc* p, std::ostream* o, uint64_t waitUS) {
     tmout.tv_sec  = waitUS / (1000*1000);
     tmout.tv_usec = waitUS % (1000*1000);
 
-    int rv = select(p->read_fd + 1, &fds, 0, 0, (waitUS > 0) ? &tmout : 0);
+    int rv = select(p->read_fd + 1, &fds, nullptr, nullptr, (waitUS > 0) ? &tmout : nullptr);
 
     if (rv < 0) {
       if (errno != EINTR) {
diff --git a/lib/hobbes/ipc/process.C b/lib/hobbes/ipc/process.C
index 10dfd2e47..78736e20c 100644
--- a/lib/hobbes/ipc/process.C
+++ b/lib/hobbes/ipc/process.C
@@ -51,9 +51,9 @@ bool ProcessP::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*)
 bool ProcessP::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   MonoTypePtr cmdt, pidt;
   if (dec(cst, &cmdt, &pidt)) {
-    if (is<TVar>(cmdt)) {
+    if (is<TVar>(cmdt) != nullptr) {
       return true;
-    } else if (is<TVar>(pidt)) {
+    } else if (is<TVar>(pidt) != nullptr) {
       return true;
     } else {
       return satisfied(tenv, cst, ds);
@@ -76,15 +76,15 @@ struct ProcessPUnqualify : public switchExprTyFn {
       throw std::runtime_error("Internal error, invalid constraint for process resolution");
     }
     const TLong* tpid = pidTy(pidt);
-    if (!tpid) { throw std::runtime_error("Internal error, unresolved process constraint for resolution"); }
+    if (tpid == nullptr) { throw std::runtime_error("Internal error, unresolved process constraint for resolution"); }
     this->pid = tpid->value();
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const App* ap) const {
+  ExprPtr with(const App* ap) const override {
     if (const Var* fn = is<Var>(stripAssumpHead(ap->fn()))) {
       if (fn->value() == PROCESS_SPAWN && hasConstraint(this->constraint, fn->type())) {
         return wrapWithTy(ap->type(), new Long(this->pid, fn->la()));
@@ -93,7 +93,7 @@ struct ProcessPUnqualify : public switchExprTyFn {
     return ExprPtr(new App(switchOf(ap->fn(), *this), switchOf(ap->args(), *this), ap->la()));
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       throw std::runtime_error("spawn to lambda NYI (unnecessary?)");
     }
@@ -107,7 +107,7 @@ ExprPtr ProcessP::unqualify(const TEnvPtr&, const ConstraintPtr& cst, const Expr
 
 PolyTypePtr ProcessP::lookup(const std::string& vn) const {
   if (vn == PROCESS_SPAWN) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(ProcessP::constraintName(), list(tgen(0), tgen(1))))), functy(list(tuplety()), tgen(1))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(ProcessP::constraintName(), list(tgen(0), tgen(1)))), functy(list(tuplety()), tgen(1))));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/ipc/procman.C b/lib/hobbes/ipc/procman.C
index 47a71d268..8afd13b56 100644
--- a/lib/hobbes/ipc/procman.C
+++ b/lib/hobbes/ipc/procman.C
@@ -2,6 +2,7 @@
 #include <hobbes/ipc/procman.H>
 #include <hobbes/lang/preds/class.H>
 #include <hobbes/util/str.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -65,11 +66,11 @@ bool ProcManager::satisfiable(const TEnvPtr& tenv, const HasField& hf, Definitio
 
   if (dir == HasField::Write) { return false; }
 
-  if (is<TVar>(rty)) {
+  if (is<TVar>(rty) != nullptr) {
     return true;
-  } else if (!pidTy(rty)) {
+  } else if (pidTy(rty) == nullptr) {
     return false;
-  } else if (is<TVar>(fname) || !isMonoSingular(hasty)) {
+  } else if ((is<TVar>(fname) != nullptr) || !isMonoSingular(hasty)) {
     return true;
   } else {
     return satisfied(tenv, hf, ds);
@@ -85,7 +86,7 @@ struct ProcManUnqualify : public switchExprTyFn {
   ProcManUnqualify(const ProcManager* pthis, const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* defs) : pthis(pthis), tenv(tenv), constraint(cst), defs(defs) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     ExprPtr aresult(new Assump(result, result->type(), result->la()));
@@ -96,16 +97,16 @@ struct ProcManUnqualify : public switchExprTyFn {
   ExprPtr annotateTypes(const ExprPtr& e) const {
     ExprPtr sexp = validateType(this->tenv, e, this->defs);
 
-    if (sexp->type()->constraints().size() == 0) {
+    if (sexp->type()->constraints().empty()) {
       return sexp;
     } else {
       return unqualifyTypes(this->tenv, sexp, this->defs);
     }
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     const Func* fty = is<Func>(v->type()->monoType());
-    if (!fty) {
+    if (fty == nullptr) {
       throw std::runtime_error("Internal error, expected annotated function type");
     }
     return wrapWithTy(v->type(),
@@ -117,7 +118,7 @@ struct ProcManUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return wrapWithTy(v->type(),
       new Let(
         v->var(),
@@ -134,11 +135,11 @@ struct ProcManUnqualify : public switchExprTyFn {
         return &(pthis->lp(pid->value()));
       }
     }
-    return 0;
+    return nullptr;
   }
 
   static ConstraintPtr blockCodecCst(const MonoTypePtr& ty) {
-    return ConstraintPtr(new Constraint("BlockCodec", list(ty)));
+    return std::make_shared<Constraint>("BlockCodec", list(ty));
   }
 
   ExprPtr blockWrite(const proc* p, const ExprPtr& e) const {
@@ -160,7 +161,7 @@ struct ProcManUnqualify : public switchExprTyFn {
   //   readFrom(FD) :: rty
   ExprPtr makeInvocation(const proc* p, const ExprPtr& pe, const std::string& fname, const MonoTypePtr& ftyv, const Exprs& args) const {
     const Func* fty = is<Func>(ftyv);
-    if (!fty) { throw std::runtime_error("Internal error, process RPC call expected function type, not: " + show(ftyv)); }
+    if (fty == nullptr) { throw std::runtime_error("Internal error, process RPC call expected function type, not: " + show(ftyv)); }
 
     MkRecord::FieldDefs argtupv;
     for (size_t i = 0; i < args.size(); ++i) {
@@ -179,7 +180,7 @@ struct ProcManUnqualify : public switchExprTyFn {
       blockRead(p, fty->result()), la), la), la);
   }
 
-  ExprPtr with(const App* v) const {
+  ExprPtr with(const App* v) const override {
     if (const Proj* f = is<Proj>(stripAssumpHead(v->fn()))) {
       if (const proc* p = isProcRef(f)) {
         return makeInvocation(p, switchOf(f->record(), *this), f->field(), f->type()->monoType(), switchOf(v->args(), *this));
@@ -188,7 +189,7 @@ struct ProcManUnqualify : public switchExprTyFn {
     return wrapWithTy(v->type(), new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     // generate a function for this reference to an external function
     if (const proc* p = isProcRef(v)) {
       const Func* fty = is<Func>(v->type()->monoType());
@@ -197,11 +198,11 @@ struct ProcManUnqualify : public switchExprTyFn {
       str::seq  vns;
       Exprs     args;
 
-      for (size_t i = 0; i < argtys.size(); ++i) {
+      for (const auto &argty : argtys) {
         std::string vname = freshName();
 
         vns.push_back(vname);
-        args.push_back(var(vname, qualtype(argtys[i]), v->la()));
+        args.push_back(var(vname, qualtype(argty), v->la()));
       }
 
       return wrapWithTy(v->type(), new Fn(vns, makeInvocation(p, switchOf(v->record(), *this), v->field(), v->type()->monoType(), args), v->la()));
@@ -227,7 +228,7 @@ const TLong* pidTy(const MonoTypePtr& mty) {
       }
     }
   }
-  return 0;
+  return nullptr;
 }
 
 MonoTypePtr mkPidTy(long pid) {
diff --git a/lib/hobbes/lang/closcvt.C b/lib/hobbes/lang/closcvt.C
index d9a3786a9..b698baf92 100644
--- a/lib/hobbes/lang/closcvt.C
+++ b/lib/hobbes/lang/closcvt.C
@@ -49,7 +49,7 @@ MonoTypePtr concreteClosureEnvType(unsigned int size) {
 }
 
 ExprPtr makeClosureOver(const Fn* f, const VarSet& vs) {
-  if (vs.size() == 0) {
+  if (vs.empty()) {
     return ExprPtr(f->clone());
   } else {
     MonoTypePtr              envty   = concreteClosureEnvType(vs.size());
@@ -61,9 +61,9 @@ ExprPtr makeClosureOver(const Fn* f, const VarSet& vs) {
   }
 }
 
-typedef std::set<TEnvPtr> TEnvs;
+using TEnvs = std::set<TEnvPtr>;
 
-static bool hasRootBinding(const std::string& vn, const TEnvPtr& tenv, const TEnvs roots) {
+static bool hasRootBinding(const std::string& vn, const TEnvPtr& tenv, const TEnvs& roots) {
   if (!tenv) {
     return true;
   } else if (tenv->hasImmediateBinding(vn)) {
@@ -96,21 +96,21 @@ struct ClosureConvertF : public switchExprTyFn {
     return r;
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     ExprPtr nbody = switchOf(v->body(), ClosureConvertF(fnFrame(this->tenv, v->varNames()), this->roots));
     const Fn fn(v->varNames(), nbody, v->la());
     return makeClosureOver(&fn, excludeRootVars(setDifference(freeVars(nbody), toSet(v->varNames()))));
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return ExprPtr(new Let(v->var(), switchOf(v->varExpr(), *this), switchOf(v->bodyExpr(), ClosureConvertF(bindFrame(this->tenv, v->var(), tgen(0)), this->roots)), v->la()));
   }
 
-  ExprPtr with(const Unpack* v) const {
+  ExprPtr with(const Unpack* v) const override {
     return ExprPtr(new Unpack(v->varName(), switchOf(v->package(), *this), switchOf(v->expr(), ClosureConvertF(bindFrame(this->tenv, v->varName(), tgen(0)), this->roots)), v->la()));
   }
 
-  ExprPtr with(const Case* v) const {
+  ExprPtr with(const Case* v) const override {
     Case::Bindings cbs;
     for (const auto& b : v->bindings()) {
       cbs.push_back(Case::Binding(b.selector, b.vname, switchOf(b.exp, ClosureConvertF(bindFrame(this->tenv, b.vname, tgen(0)), this->roots))));
@@ -132,7 +132,7 @@ struct ClosureConvertF : public switchExprTyFn {
     return r;
   }
 
-  ExprPtr with(const LetRec* v) const {
+  ExprPtr with(const LetRec* v) const override {
     TEnvPtr lrtenv = letRecFrame(this->tenv, v->bindings());
     TEnvs   recRVS = this->roots;
     recRVS.insert(lrtenv);
diff --git a/lib/hobbes/lang/constraints.C b/lib/hobbes/lang/constraints.C
index a51535726..2b76d3b01 100644
--- a/lib/hobbes/lang/constraints.C
+++ b/lib/hobbes/lang/constraints.C
@@ -17,8 +17,7 @@ void typeSeqForm(const ConstraintPtr& c, MonoTypes* mts) {
   mts->insert(mts->end(), args.begin(), args.end());
 }
 
-ConstraintSet::ConstraintSet() {
-}
+ConstraintSet::ConstraintSet() = default;
 
 MaybePathPoints focusOnFundep(const VarIDs& vs, const MonoTypes& mts) {
   // we have to fudge the input IDs with a +1 offset for constraint names
@@ -40,18 +39,18 @@ void ConstraintSet::insert(const TEnvPtr& tenv, const ConstraintPtr& c, MonoType
   typeSeqForm(c, &cpath);
 
   // if this constraint is already stored, we don't need to insert
-  if (this->csts.lookup(cpath)) {
+  if (this->csts.lookup(cpath) != nullptr) {
     return;
   }
 
   // OK, the constraint seems not to be stored
   // let's apply functional dependencies from this constraint across other constraints in this set
   // that may produce unifications that can further eliminate this constraint
-  for (auto fd : tenv->lookupUnqualifier(c)->dependencies(c)) {
+  for (const auto& fd : tenv->lookupUnqualifier(c)->dependencies(c)) {
     Constraints mcs;
     this->csts.find(focusOnFundep(fd.first, cpath), &mcs);
 
-    for (auto mc : mcs) {
+    for (const auto& mc : mcs) {
       MonoTypes mcpath;
       typeSeqForm(mc, &mcpath);
       mgu(cpath[fd.second+1], mcpath[fd.second+1], s);
@@ -64,7 +63,7 @@ void ConstraintSet::insert(const TEnvPtr& tenv, const ConstraintPtr& c, MonoType
   }
 
   // now only store the constraint if it's still unique
-  if (!this->csts.lookup(cpath)) {
+  if (this->csts.lookup(cpath) == nullptr) {
     this->csts.insert(cpath, c);
   }
 }
diff --git a/lib/hobbes/lang/expr.C b/lib/hobbes/lang/expr.C
index 43ed5f75b..5689fa9db 100644
--- a/lib/hobbes/lang/expr.C
+++ b/lib/hobbes/lang/expr.C
@@ -11,8 +11,8 @@ namespace hobbes {
 
 Exprs clones(const Exprs& es) {
   Exprs r;
-  for (Exprs::const_iterator e = es.begin(); e != es.end(); ++e) {
-    r.push_back(ExprPtr((*e)->clone()));
+  for (const auto &e : es) {
+    r.push_back(ExprPtr(e->clone()));
   }
   return r;
 }
@@ -36,7 +36,7 @@ inline void showTy(std::ostream& out, const QualTypePtr& qty) {
 }
 
 Expr::Expr(int cid, const LexicalAnnotation& la) : LexicallyAnnotated(la), cid(cid) { }
-Expr::~Expr() { }
+Expr::~Expr() = default;
 const QualTypePtr& Expr::type() const { return this->annotatedType; }
 void Expr::type(const QualTypePtr& ty) { this->annotatedType = ty; }
 int Expr::case_id() const { return this->cid; }
@@ -59,7 +59,7 @@ Expr* Bool::clone() const { return new Bool(this->x,la()); }
 void Bool::show(std::ostream& out)          const { out << (this->x ? "true" : "false"); }
 void Bool::showAnnotated(std::ostream& out) const { show(out); showTy(out, type()); }
 bool Bool::equiv(const Bool& rhs)           const { return this->x == rhs.x; }
-bool Bool::lt(const Bool& rhs)              const { return this->x < rhs.x; }
+bool Bool::lt(const Bool& rhs)              const { return static_cast<int>(this->x) < static_cast<int>(rhs.x); }
 MonoTypePtr Bool::primType() const { return MonoTypePtr(Prim::make("bool")); }
 
 Char::Char(char x, const LexicalAnnotation& la) : Base(la), x(x) { }
@@ -214,7 +214,7 @@ Expr* LetRec::clone() const {
 }
 
 void LetRec::show(std::ostream& out) const {
-  if (this->bs.size() == 0) {
+  if (this->bs.empty()) {
     out << "letrec {} in ";
     this->e->show(out);
   } else {
@@ -231,7 +231,7 @@ void LetRec::show(std::ostream& out) const {
 }
 
 void LetRec::showAnnotated(std::ostream& out) const {
-  if (this->bs.size() == 0) {
+  if (this->bs.empty()) {
     out << "letrec {} in ";
     this->e->showAnnotated(out);
   } else {
@@ -250,7 +250,7 @@ void LetRec::showAnnotated(std::ostream& out) const {
 Fn::Fn(const VarNames& vs, const ExprPtr& e, const LexicalAnnotation& la) : Base(la), vs(vs), e(e) {
   // to make type-checking homogeneous, we equate the empty parameter list with a parameter list containing just unit
   //   (unit is compiled away to nothing, so it's equivalent)
-  if (this->vs.size() == 0) {
+  if (this->vs.empty()) {
     this->vs.push_back("_");
   }
 }
@@ -291,7 +291,7 @@ void Fn::showAnnotated(std::ostream& out) const {
 App::App(const ExprPtr& fne, const Exprs& argl, const LexicalAnnotation& la) : Base(la), fne(fne), argl(argl) {
   // to make type-checking homogeneous, we equate the empty parameter list with a parameter list containing just unit
   //   (unit is compiled away to nothing, so it's equivalent)
-  if (this->argl.size() == 0) {
+  if (this->argl.empty()) {
     this->argl.push_back(ExprPtr(new Unit(la)));
   }
 }
@@ -326,8 +326,8 @@ void App::show(std::ostream& out) const {
 
   // show the argl part
   out << "(";
-  if (this->argl.size() > 0) {
-    Exprs::const_iterator e = this->argl.begin();
+  if (!this->argl.empty()) {
+    auto e = this->argl.begin();
     (*e)->show(out);
     while (++e != this->argl.end()) {
       out << ", ";
@@ -344,8 +344,8 @@ void App::showAnnotated(std::ostream& out) const {
 
   // show the argl part
   out << "(";
-  if (this->argl.size() > 0) {
-    Exprs::const_iterator e = this->argl.begin();
+  if (!this->argl.empty()) {
+    auto e = this->argl.begin();
     (*e)->showAnnotated(out);
     while (++e != this->argl.end()) {
       out << ", ";
@@ -398,7 +398,7 @@ Exprs& MkArray::values() { return this->es; }
 Expr* MkArray::clone() const { return new MkArray(clones(this->es),la()); }
 void MkArray::show(std::ostream& out) const {
   out << "[";
-  if (this->es.size() > 0) {
+  if (!this->es.empty()) {
     this->es[0]->show(out);
     for (size_t i = 1; i < this->es.size(); ++i) {
       out << ", ";
@@ -409,7 +409,7 @@ void MkArray::show(std::ostream& out) const {
 }
 void MkArray::showAnnotated(std::ostream& out) const {
   out << "[";
-  if (this->es.size() > 0) {
+  if (!this->es.empty()) {
     this->es[0]->showAnnotated(out);
     for (size_t i = 1; i < this->es.size(); ++i) {
       out << ", ";
@@ -454,11 +454,11 @@ bool MkRecord::operator==(const MkRecord& rhs) const {
 }
 const MkRecord::FieldDefs& MkRecord::fields() const { return this->fs; }
 MkRecord::FieldDefs& MkRecord::fields() { return this->fs; }
-bool MkRecord::isTuple() const { return this->fs.size() > 0 && this->fs[0].first.size() > 0 && this->fs[0].first[0] == '.'; }
+bool MkRecord::isTuple() const { return !this->fs.empty() && !this->fs[0].first.empty() && this->fs[0].first[0] == '.'; }
 Expr* MkRecord::clone() const {
   FieldDefs cfs;
-  for (FieldDefs::const_iterator f = this->fs.begin(); f != this->fs.end(); ++f) {
-    cfs.push_back(FieldDef(f->first, ExprPtr(f->second->clone())));
+  for (const auto &f : this->fs) {
+    cfs.push_back(FieldDef(f.first, ExprPtr(f.second->clone())));
   }
   return new MkRecord(cfs,la());
 }
@@ -478,7 +478,7 @@ void MkRecord::showAnnotated(std::ostream& out) const {
 }
 void MkRecord::showRecord(std::ostream& out) const {
   out << "{";
-  if (this->fs.size() > 0) {
+  if (!this->fs.empty()) {
     out << this->fs[0].first << " = "; this->fs[0].second->show(out);
     for (size_t i = 1; i < this->fs.size(); ++i) {
       out << ", " << this->fs[i].first << " = "; this->fs[i].second->show(out);
@@ -488,7 +488,7 @@ void MkRecord::showRecord(std::ostream& out) const {
 }
 void MkRecord::showRecordAnnotated(std::ostream& out) const {
   out << "{";
-  if (this->fs.size() > 0) {
+  if (!this->fs.empty()) {
     out << this->fs[0].first << " = "; this->fs[0].second->showAnnotated(out);
     for (size_t i = 1; i < this->fs.size(); ++i) {
       out << ", " << this->fs[i].first << " = "; this->fs[i].second->showAnnotated(out);
@@ -550,11 +550,11 @@ bool Case::operator==(const Case& rhs) const {
   if ((this->bs.size() != rhs.bs.size()) || !(*this->v == *rhs.v)) {
     return false;
   } else {
-    if (this->def.get()) {
-      if (!rhs.def.get() || !(*this->def == *rhs.def)) {
+    if (this->def.get() != nullptr) {
+      if ((rhs.def.get() == nullptr) || !(*this->def == *rhs.def)) {
         return false;
       }
-    } else if (rhs.def.get()) {
+    } else if (rhs.def.get() != nullptr) {
       return false;
     }
 
@@ -580,8 +580,8 @@ Case::Bindings& Case::bindings()                       { return this->bs; }
 void            Case::defaultExpr(const ExprPtr& ndef) { this->def = ndef; }
 
 bool Case::hasBinding(const std::string& bn) const {
-  for (Bindings::const_iterator b = this->bs.begin(); b != this->bs.end(); ++b) {
-    if (b->selector == bn) {
+  for (const auto &b : this->bs) {
+    if (b.selector == bn) {
       return true;
     }
   }
@@ -592,16 +592,16 @@ void Case::addBinding(const std::string& selector, const std::string& vname, con
 }
 Expr* Case::clone() const {
   Bindings cbs;
-  for (Bindings::const_iterator b = this->bs.begin(); b != this->bs.end(); ++b) {
-    cbs.push_back(Binding(b->selector, b->vname, ExprPtr(b->exp->clone())));
+  for (const auto &b : this->bs) {
+    cbs.push_back(Binding(b.selector, b.vname, ExprPtr(b.exp->clone())));
   }
-  return new Case(ExprPtr(this->v->clone()), cbs, this->def.get() ? ExprPtr(this->def->clone()) : ExprPtr(),la());
+  return new Case(ExprPtr(this->v->clone()), cbs, this->def.get() != nullptr ? ExprPtr(this->def->clone()) : ExprPtr(),la());
 }
 void Case::show(std::ostream& out) const {
   out << "case (";
   this->v->show(out);
   out << ") {";
-  for (Bindings::const_iterator b = this->bs.begin(); b != this->bs.end(); ++b) {
+  for (auto b = this->bs.begin(); b != this->bs.end(); ++b) {
     if (b != this->bs.begin()) out << ", ";
 
     if (b->selector != b->vname) {
@@ -612,7 +612,7 @@ void Case::show(std::ostream& out) const {
     out << ".";
     b->exp->show(out);
   }
-  if (this->def.get() != 0) {
+  if (this->def.get() != nullptr) {
     out << ",default.";
     this->def->show(out);
   }
@@ -622,7 +622,7 @@ void Case::showAnnotated(std::ostream& out) const {
   out << "case (";
   this->v->showAnnotated(out);
   out << ") {";
-  for (Bindings::const_iterator b = this->bs.begin(); b != this->bs.end(); ++b) {
+  for (auto b = this->bs.begin(); b != this->bs.end(); ++b) {
     if (b != this->bs.begin()) out << ", ";
 
     if (b->selector != b->vname) {
@@ -642,7 +642,7 @@ Switch::Switch(const ExprPtr& v, const Bindings& bs, const ExprPtr& def, const L
   // (only a few primitive types work with no default case)
   bool exhaustive = def != ExprPtr();
 
-  if (bs.size() > 0) {
+  if (!bs.empty()) {
     switch (bs[0].value->case_id()) {
     case Unit::type_case_id:
       exhaustive = true;
@@ -669,14 +669,14 @@ Switch::Switch(const ExprPtr& v, const Bindings& bs, const ExprPtr& def, const L
   // ensure unambiguous selection
   PrimitiveSet selectors;
 
-  for (size_t i = 0; i < bs.size(); ++i) {
-    if (selectors.find(bs[i].value) != selectors.end()) {
+  for (const auto &b : bs) {
+    if (selectors.find(b.value) != selectors.end()) {
       std::ostringstream ss;
       ss << "Duplicate selector in switch expression:\n";
       show(ss);
       throw annotated_error(la, ss.str());
     } else {
-      selectors.insert(bs[i].value);
+      selectors.insert(b.value);
     }
   }
 }
@@ -688,11 +688,11 @@ bool Switch::operator==(const Switch& rhs) const {
   if (this->bs.size() != rhs.bs.size() || !(*this->v == *rhs.v)) {
     return false;
   } else {
-    if (this->def.get()) {
-      if (!rhs.def.get() || !(*this->def == *rhs.def)) {
+    if (this->def.get() != nullptr) {
+      if ((rhs.def.get() == nullptr) || !(*this->def == *rhs.def)) {
         return false;
       }
-    } else if (rhs.def.get()) {
+    } else if (rhs.def.get() != nullptr) {
       return false;
     }
 
@@ -719,7 +719,7 @@ void Switch::defaultExpr(const ExprPtr& x) { this->def = x; }
 Expr* Switch::clone() const {
   ExprPtr cdef = this->def ? ExprPtr(this->def->clone()) : ExprPtr();
   Bindings cbs;
-  for (auto b : this->bs) {
+  for (const auto& b : this->bs) {
     cbs.push_back(Binding(PrimitivePtr(reinterpret_cast<Primitive*>(b.value->clone())), ExprPtr(b.exp->clone())));
   }
   return new Switch(ExprPtr(this->v->clone()), cbs, cdef, la());
@@ -729,7 +729,7 @@ void Switch::show(std::ostream& out) const {
   out << "switch (";
   this->v->show(out);
   out << ") {";
-  for (auto b : this->bs) {
+  for (const auto& b : this->bs) {
     b.value->show(out);
     out << " => ";
     b.exp->show(out);
@@ -747,7 +747,7 @@ void Switch::showAnnotated(std::ostream& out) const {
   out << "switch (";
   this->v->showAnnotated(out);
   out << ") {";
-  for (auto b : this->bs) {
+  for (const auto& b : this->bs) {
     b.value->show(out);
     out << " => ";
     b.exp->showAnnotated(out);
@@ -880,24 +880,24 @@ struct substVarF : public switchExprC<ExprPtr> {
   ExprPtr withoutNames(const str::seq&    ns, const ExprPtr& e) const { return withoutNames(toSet(ns), e); }
   ExprPtr withoutNames(const std::string& n,  const ExprPtr& e) const { return withoutNames(toSet(list(n)), e); }
 
-  ExprPtr withConst(const Expr* v) const { return ExprPtr(v->clone()); }
+  ExprPtr withConst(const Expr* v) const override { return ExprPtr(v->clone()); }
 
-  ExprPtr with(const Var* v) const {
-    VarMapping::const_iterator ve = this->vm.find(v->value());
+  ExprPtr with(const Var* v) const override {
+    auto ve = this->vm.find(v->value());
     if (ve == this->vm.end()) {
       return ExprPtr(v->clone());
     } else {
-      if (mapped) *mapped = true;
+      if (mapped != nullptr) *mapped = true;
 
       return ve->second;
     }
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return ExprPtr(new Let(v->var(), switchOf(v->varExpr(), *this), withoutNames(v->var(), v->bodyExpr()), v->la()));
   }
 
-  ExprPtr with(const LetRec* v) const {
+  ExprPtr with(const LetRec* v) const override {
     str::set vns = toSet(v->varNames());
     LetRec::Bindings bs;
     for (const auto& b : v->bindings()) {
@@ -906,50 +906,50 @@ struct substVarF : public switchExprC<ExprPtr> {
     return ExprPtr(new LetRec(bs, withoutNames(vns, v->bodyExpr()), v->la()));
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     return ExprPtr(new Fn(v->varNames(), withoutNames(v->varNames(), v->body()), v->la()));
   }
 
-  ExprPtr with(const App* v) const {
+  ExprPtr with(const App* v) const override {
     return ExprPtr(new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     return ExprPtr(new Assign(switchOf(v->left(), *this), switchOf(v->right(), *this), v->la()));
   }
 
-  ExprPtr with(const MkArray* v) const {
+  ExprPtr with(const MkArray* v) const override {
     return ExprPtr(new MkArray(switchOf(v->values(), *this), v->la()));
   }
 
-  ExprPtr with(const MkVariant* v) const {
+  ExprPtr with(const MkVariant* v) const override {
     return ExprPtr(new MkVariant(v->label(), switchOf(v->value(), *this), v->la()));
   }
   
-  ExprPtr with(const MkRecord* v) const {
+  ExprPtr with(const MkRecord* v) const override {
     return ExprPtr(new MkRecord(switchOf(v->fields(), *this), v->la()));
   }
 
-  ExprPtr with(const AIndex* v) const {
+  ExprPtr with(const AIndex* v) const override {
     return ExprPtr(new AIndex(switchOf(v->array(), *this), switchOf(v->index(), *this), v->la()));
   }
 
-  ExprPtr with(const Case* v) const {
+  ExprPtr with(const Case* v) const override {
     const Case::Bindings& cbs = v->bindings();
     Case::Bindings rcbs;
-    for (Case::Bindings::const_iterator cb = cbs.begin(); cb != cbs.end(); ++cb) {
-      rcbs.push_back(Case::Binding(cb->selector, cb->vname, withoutNames(cb->vname, cb->exp)));
+    for (const auto &cb : cbs) {
+      rcbs.push_back(Case::Binding(cb.selector, cb.vname, withoutNames(cb.vname, cb.exp)));
     }
     ExprPtr de = v->defaultExpr();
-    if (de.get()) {
+    if (de.get() != nullptr) {
       de = switchOf(de, *this);
     }
     return ExprPtr(new Case(switchOf(v->variant(), *this), rcbs, de, v->la()));
   }
 
-  ExprPtr with(const Switch* v) const {
+  ExprPtr with(const Switch* v) const override {
     Switch::Bindings rsbs;
-    for (auto sb : v->bindings()) {
+    for (const auto& sb : v->bindings()) {
       rsbs.push_back(Switch::Binding(sb.value, switchOf(sb.exp, *this)));
     }
     ExprPtr de = v->defaultExpr();
@@ -959,19 +959,19 @@ struct substVarF : public switchExprC<ExprPtr> {
     return ExprPtr(new Switch(switchOf(v->expr(), *this), rsbs, de, v->la()));
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     return ExprPtr(new Proj(switchOf(v->record(), *this), v->field(), v->la()));
   }
 
-  ExprPtr with(const Assump* v) const {
+  ExprPtr with(const Assump* v) const override {
     return ExprPtr(new Assump(switchOf(v->expr(), *this), v->ty(), v->la()));
   }
 
-  ExprPtr with(const Pack* v) const {
+  ExprPtr with(const Pack* v) const override {
     return ExprPtr(new Pack(switchOf(v->expr(), *this), v->la()));
   }
 
-  ExprPtr with(const Unpack* v) const {
+  ExprPtr with(const Unpack* v) const override {
     return ExprPtr(new Unpack(v->varName(), switchOf(v->package(), *this), withoutNames(v->varName(), v->expr()), v->la()));
   }
 };
@@ -984,7 +984,7 @@ struct substTyF : public switchExprTyFn {
   const MonoTypeSubst& s;
   substTyF(const MonoTypeSubst& s) : s(s) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     if (qt) {
       return substitute(this->s, qt);
     } else {
@@ -998,23 +998,23 @@ ExprPtr substitute(const MonoTypeSubst& s, const ExprPtr& e) {
 }
 
 struct isConstP : switchExprC<bool> {
-  bool withConst(const Expr*)      const { return true; }
-  bool with     (const Var*)       const { return false; }
-  bool with     (const Let*)       const { return false; }
-  bool with     (const LetRec*)    const { return false; }
-  bool with     (const Fn*)        const { return false; }
-  bool with     (const App*)       const { return false; }
-  bool with     (const Assign*)    const { return false; }
-  bool with     (const MkArray*)   const { return false; }
-  bool with     (const MkVariant*) const { return false; }
-  bool with     (const MkRecord*)  const { return false; }
-  bool with     (const AIndex*)    const { return false; }
-  bool with     (const Case*)      const { return false; }
-  bool with     (const Switch*)    const { return false; }
-  bool with     (const Proj*)      const { return false; }
-  bool with     (const Assump*)    const { return false; }
-  bool with     (const Pack*)      const { return false; }
-  bool with     (const Unpack*)    const { return false; }
+  bool withConst(const Expr*)      const override { return true; }
+  bool with     (const Var*)       const override { return false; }
+  bool with     (const Let*)       const override { return false; }
+  bool with     (const LetRec*)    const override { return false; }
+  bool with     (const Fn*)        const override { return false; }
+  bool with     (const App*)       const override { return false; }
+  bool with     (const Assign*)    const override { return false; }
+  bool with     (const MkArray*)   const override { return false; }
+  bool with     (const MkVariant*) const override { return false; }
+  bool with     (const MkRecord*)  const override { return false; }
+  bool with     (const AIndex*)    const override { return false; }
+  bool with     (const Case*)      const override { return false; }
+  bool with     (const Switch*)    const override { return false; }
+  bool with     (const Proj*)      const override { return false; }
+  bool with     (const Assump*)    const override { return false; }
+  bool with     (const Pack*)      const override { return false; }
+  bool with     (const Unpack*)    const override { return false; }
 };
 
 bool isConst(const ExprPtr& e) {
@@ -1033,15 +1033,15 @@ ExprPtr switchExprTyFn::wrapWithTy(const QualTypePtr& qty, Expr* e) const {
 
 Case::Bindings switchOf(const Case::Bindings& bs, const switchExpr<ExprPtr>& f) {
   Case::Bindings r;
-  for (Case::Bindings::const_iterator b = bs.begin(); b != bs.end(); ++b) {
-    r.push_back(Case::Binding(b->selector, b->vname, switchOf(b->exp, f)));
+  for (const auto &b : bs) {
+    r.push_back(Case::Binding(b.selector, b.vname, switchOf(b.exp, f)));
   }
   return r;
 }
 
 Switch::Bindings switchOf(const Switch::Bindings& bs, const switchExpr<ExprPtr>& f) {
   Switch::Bindings r;
-  for (auto b : bs) {
+  for (const auto& b : bs) {
     r.push_back(Switch::Binding(b.value, switchOf(b.exp, f)));
   }
   return r;
@@ -1072,7 +1072,7 @@ ExprPtr switchExprTyFn::with(const LetRec* v) const {
 
 ExprPtr switchExprTyFn::with(const Case* v) const {
   ExprPtr de = v->defaultExpr();
-  if (de.get() != 0) { de = switchOf(de, *this); }
+  if (de.get() != nullptr) { de = switchOf(de, *this); }
 
   return wrapWithTy(v->type(), new Case(switchOf(v->variant(), *this), switchOf(v->bindings(), *this), de, v->la()));
 }
@@ -1086,14 +1086,14 @@ ExprPtr switchExprTyFn::with(const Switch* v) const {
 
 // mutable type-translation in terms
 UnitV switchOf(const Case::Bindings& bs, const switchExprTyFnM& f) {
-  for (Case::Bindings::const_iterator b = bs.begin(); b != bs.end(); ++b) {
-    switchOf(b->exp, const_cast<switchExprTyFnM&>(f));
+  for (const auto &b : bs) {
+    switchOf(b.exp, const_cast<switchExprTyFnM&>(f));
   }
   return unitv;
 }
 
 UnitV switchOf(const Switch::Bindings& bs, const switchExprTyFnM& f) {
-  for (auto b : bs) {
+  for (const auto& b : bs) {
     switchOf(b.exp, const_cast<switchExprTyFnM&>(f));
   }
   return unitv;
@@ -1103,7 +1103,7 @@ QualTypePtr switchExprTyFnM::withTy(const QualTypePtr& qt) const {
   return qt;
 }
 
-UnitV switchExprTyFnM::updateTy(Expr* e) {
+UnitV switchExprTyFnM::updateTy(Expr* e) const {
   if (e->type() != QualTypePtr()) {
     e->type(withTy(e->type()));
   }
@@ -1176,7 +1176,7 @@ UnitV switchExprTyFnM::with(AIndex* v) {
 
 UnitV switchExprTyFnM::with(Case* v) {
   ExprPtr de = v->defaultExpr();
-  if (de.get() != 0) { switchOf(de, *this); }
+  if (de.get() != nullptr) { switchOf(de, *this); }
 
   switchOf(v->variant(), *this);
   switchOf(v->bindings(), *this);
@@ -1221,7 +1221,7 @@ struct liftTypeAsAssumpF : public switchExprTyFn {
     return e;
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     if (qty != QualTypePtr()) {
       return setTy(ExprPtr(new Assump(setTy(ExprPtr(e), qty), qty, e->la())), qty);
     } else {
@@ -1240,7 +1240,7 @@ const MonoTypePtr& requireMonotype(const TEnvPtr& tenv, const ExprPtr& e) {
     throw annotated_error(*e, "Expression '" + show(e) + "' not explicitly annotated.  Internal compiler error.");
   }
 
-  if (e->type()->constraints().size() > 0) {
+  if (!e->type()->constraints().empty()) {
     Constraints cs = expandHiddenTCs(tenv, simplifyVarNames(e->type())->constraints());
     std::ostringstream ss;
     ss << "Failed to compile expression due to unresolved type constraint" << (cs.size() > 1 ? "s" : "");
@@ -1252,7 +1252,7 @@ const MonoTypePtr& requireMonotype(const TEnvPtr& tenv, const ExprPtr& e) {
 
 MonoTypes requireMonotype(const TEnvPtr& tenv, const Exprs& es) {
   MonoTypes r;
-  for (auto e : es) {
+  for (const auto& e : es) {
     r.push_back(requireMonotype(tenv, e));
   }
   return r;
@@ -1263,7 +1263,7 @@ ExprPtr liftTypesAsAssumptions(const ExprPtr& e) {
 }
 
 struct stripAssumpF : public switchExprTyFn {
-  ExprPtr with(const Assump* v) const {
+  ExprPtr with(const Assump* v) const override {
     return switchOf(v->expr(), *this);
   }
 };
@@ -1282,22 +1282,22 @@ const ExprPtr& stripAssumpHead(const ExprPtr& e) {
 
 // find the set of free variables in an expression
 struct freeVarF : public switchExprC<VarSet> {
-  VarSet withConst(const Expr*)        const { return VarSet(); }
-  VarSet with     (const Var* v)       const { return toSet(list(v->value())); }
-  VarSet with     (const Let* v)       const { return setUnion(list(freeVars(v->varExpr()), setDifference(freeVars(v->bodyExpr()), toSet(list(v->var()))))); }
-  VarSet with     (const Fn* v)        const { return setDifference(freeVars(v->body()), toSet(v->varNames())); }
-  VarSet with     (const App* v)       const { return setUnion(cons(freeVars(v->fn()), switchOf(v->args(), *this))); }
-  VarSet with     (const Assign* v)    const { return setUnion(list(freeVars(v->left()), freeVars(v->right()))); }
-  VarSet with     (const MkArray* v)   const { return setUnion(switchOf(v->values(), *this)); }
-  VarSet with     (const MkVariant* v) const { return freeVars(v->value()); }
-  VarSet with     (const MkRecord* v)  const { return setUnion(switchOf(exprs(v->fields()), *this)); }
-  VarSet with     (const AIndex* v)    const { return setUnion(list(freeVars(v->array()), freeVars(v->index()))); }
-  VarSet with     (const Proj* v)      const { return freeVars(v->record()); }
-  VarSet with     (const Assump* v)    const { return freeVars(v->expr()); }
-  VarSet with     (const Pack* v)      const { return freeVars(v->expr()); }
-  VarSet with     (const Unpack* v)    const { return setUnion(list(freeVars(v->package()), setDifference(freeVars(v->expr()), toSet(list(v->varName()))))); }
+  VarSet withConst(const Expr*)        const override { return VarSet(); }
+  VarSet with     (const Var* v)       const override { return toSet(list(v->value())); }
+  VarSet with     (const Let* v)       const override { return setUnion(list(freeVars(v->varExpr()), setDifference(freeVars(v->bodyExpr()), toSet(list(v->var()))))); }
+  VarSet with     (const Fn* v)        const override { return setDifference(freeVars(v->body()), toSet(v->varNames())); }
+  VarSet with     (const App* v)       const override { return setUnion(cons(freeVars(v->fn()), switchOf(v->args(), *this))); }
+  VarSet with     (const Assign* v)    const override { return setUnion(list(freeVars(v->left()), freeVars(v->right()))); }
+  VarSet with     (const MkArray* v)   const override { return setUnion(switchOf(v->values(), *this)); }
+  VarSet with     (const MkVariant* v) const override { return freeVars(v->value()); }
+  VarSet with     (const MkRecord* v)  const override { return setUnion(switchOf(exprs(v->fields()), *this)); }
+  VarSet with     (const AIndex* v)    const override { return setUnion(list(freeVars(v->array()), freeVars(v->index()))); }
+  VarSet with     (const Proj* v)      const override { return freeVars(v->record()); }
+  VarSet with     (const Assump* v)    const override { return freeVars(v->expr()); }
+  VarSet with     (const Pack* v)      const override { return freeVars(v->expr()); }
+  VarSet with     (const Unpack* v)    const override { return setUnion(list(freeVars(v->package()), setDifference(freeVars(v->expr()), toSet(list(v->varName()))))); }
   
-  VarSet with(const LetRec* v) const {
+  VarSet with(const LetRec* v) const override {
     std::vector<VarSet> fvs;
     str::set            vns = toSet(v->varNames());
 
@@ -1309,22 +1309,22 @@ struct freeVarF : public switchExprC<VarSet> {
     return setUnion(fvs);
   }
 
-  VarSet with(const Case* v) const {
+  VarSet with(const Case* v) const override {
     std::vector<VarSet> fvs;
     fvs.push_back(freeVars(v->variant()));
-    for (Case::Bindings::const_iterator b = v->bindings().begin(); b != v->bindings().end(); ++b) {
-      fvs.push_back(setDifference(freeVars(b->exp), toSet(list(b->vname))));
+    for (const auto &b : v->bindings()) {
+      fvs.push_back(setDifference(freeVars(b.exp), toSet(list(b.vname))));
     }
-    if (v->defaultExpr().get()) {
+    if (v->defaultExpr().get() != nullptr) {
       fvs.push_back(freeVars(v->defaultExpr()));
     }
     return setUnion(fvs);
   }
 
-  VarSet with(const Switch* v) const {
+  VarSet with(const Switch* v) const override {
     std::vector<VarSet> fvs;
     fvs.push_back(freeVars(v->expr()));
-    for (auto sb : v->bindings()) {
+    for (const auto& sb : v->bindings()) {
       fvs.push_back(freeVars(sb.exp));
     }
     if (v->defaultExpr()) {
@@ -1348,22 +1348,22 @@ struct etvarNamesF : public switchExprC<UnitV> {
   etvarNamesF(NameSet* out) : out(out) { }
   UnitV an(const Expr* v) const { if (v->type()) { tvarNames(v->type(), this->out); } return unitv; }
 
-  UnitV withConst(const Expr*)        const { return unitv; }
-  UnitV with     (const Var* v)       const { return an(v); }
-  UnitV with     (const Let* v)       const { switchOf(v->varExpr(), *this); switchOf(v->bodyExpr(), *this); return an(v); }
-  UnitV with     (const Fn* v)        const { switchOf(v->body(), *this); return an(v); }
-  UnitV with     (const App* v)       const { switchOf(v->fn(), *this); switchOf(v->args(), *this); return an(v); }
-  UnitV with     (const Assign* v)    const { switchOf(v->left(), *this); switchOf(v->right(), *this); return an(v); }
-  UnitV with     (const MkArray* v)   const { switchOf(v->values(), *this); return an(v); }
-  UnitV with     (const MkVariant* v) const { switchOf(v->value(), *this); return an(v); }
-  UnitV with     (const MkRecord* v)  const { switchOf(exprs(v->fields()), *this); return an(v); }
-  UnitV with     (const AIndex* v)    const { switchOf(v->array(), *this); switchOf(v->index(), *this); return an(v); }
-  UnitV with     (const Proj* v)      const { switchOf(v->record(), *this); return an(v); }
-  UnitV with     (const Assump* v)    const { switchOf(v->expr(), *this); tvarNames(v->ty(), this->out); return an(v); }
-  UnitV with     (const Pack* v)      const { switchOf(v->expr(), *this); return an(v); }
-  UnitV with     (const Unpack* v)    const { switchOf(v->package(), *this); switchOf(v->expr(), *this); return an(v); }
+  UnitV withConst(const Expr*)        const override { return unitv; }
+  UnitV with     (const Var* v)       const override { return an(v); }
+  UnitV with     (const Let* v)       const override { switchOf(v->varExpr(), *this); switchOf(v->bodyExpr(), *this); return an(v); }
+  UnitV with     (const Fn* v)        const override { switchOf(v->body(), *this); return an(v); }
+  UnitV with     (const App* v)       const override { switchOf(v->fn(), *this); switchOf(v->args(), *this); return an(v); }
+  UnitV with     (const Assign* v)    const override { switchOf(v->left(), *this); switchOf(v->right(), *this); return an(v); }
+  UnitV with     (const MkArray* v)   const override { switchOf(v->values(), *this); return an(v); }
+  UnitV with     (const MkVariant* v) const override { switchOf(v->value(), *this); return an(v); }
+  UnitV with     (const MkRecord* v)  const override { switchOf(exprs(v->fields()), *this); return an(v); }
+  UnitV with     (const AIndex* v)    const override { switchOf(v->array(), *this); switchOf(v->index(), *this); return an(v); }
+  UnitV with     (const Proj* v)      const override { switchOf(v->record(), *this); return an(v); }
+  UnitV with     (const Assump* v)    const override { switchOf(v->expr(), *this); tvarNames(v->ty(), this->out); return an(v); }
+  UnitV with     (const Pack* v)      const override { switchOf(v->expr(), *this); return an(v); }
+  UnitV with     (const Unpack* v)    const override { switchOf(v->package(), *this); switchOf(v->expr(), *this); return an(v); }
   
-  UnitV with(const LetRec* v) const {
+  UnitV with(const LetRec* v) const override {
     for (const auto& b : v->bindings()) {
       switchOf(b.second, *this);
     }
@@ -1371,20 +1371,20 @@ struct etvarNamesF : public switchExprC<UnitV> {
     return an(v);
   }
 
-  UnitV with(const Case* v) const {
+  UnitV with(const Case* v) const override {
     switchOf(v->variant(), *this);
-    for (Case::Bindings::const_iterator b = v->bindings().begin(); b != v->bindings().end(); ++b) {
-      switchOf(b->exp, *this);
+    for (const auto &b : v->bindings()) {
+      switchOf(b.exp, *this);
     }
-    if (v->defaultExpr().get()) {
+    if (v->defaultExpr().get() != nullptr) {
       switchOf(v->defaultExpr(), *this);
     }
     return an(v);
   }
 
-  UnitV with(const Switch* v) const {
+  UnitV with(const Switch* v) const override {
     switchOf(v->expr(), *this);
-    for (auto sb : v->bindings()) {
+    for (const auto& sb : v->bindings()) {
       switchOf(sb.exp, *this);
     }
     if (v->defaultExpr()) {
@@ -1410,7 +1410,7 @@ ExprPtr fmtFoldExpr(const ExprPtr& e, const std::string& expr) {
 }
 
 ExprPtr mkFormatExpr(const std::string& fmt, const LexicalAnnotation& la) {
-  if (fmt.size() == 0) {
+  if (fmt.empty()) {
     return ExprPtr(mkarray("", la));
   } else {
     return str::foldWithFormat(str::trimq(fmt, '`'), ExprPtr(mkarray("", la)), &fmtFoldConst, &fmtFoldExpr);
@@ -1465,72 +1465,72 @@ struct encodeExprF : public switchExpr<UnitV> {
   std::ostream& out;
   encodeExprF(std::ostream& out) : out(out) { }
 
-  UnitV with(const Unit*) const {
+  UnitV with(const Unit*) const override {
     encode(Unit::type_case_id, this->out);
     return unitv;
   }
 
-  UnitV with(const Bool* v) const {
+  UnitV with(const Bool* v) const override {
     encode(Bool::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Char* v) const {
+  UnitV with(const Char* v) const override {
     encode(Char::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Byte* v) const {
+  UnitV with(const Byte* v) const override {
     encode(Byte::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Short* v) const {
+  UnitV with(const Short* v) const override {
     encode(Short::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Int* v) const {
+  UnitV with(const Int* v) const override {
     encode(Int::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Long* v) const {
+  UnitV with(const Long* v) const override {
     encode(Long::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Int128* v) const {
+  UnitV with(const Int128* v) const override {
     encode(Int128::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Float* v) const {
+  UnitV with(const Float* v) const override {
     encode(Float::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Double* v) const {
+  UnitV with(const Double* v) const override {
     encode(Double::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const Var* v) const {
+  UnitV with(const Var* v) const override {
     encode(Var::type_case_id, this->out);
     encode(v->value(), this->out);
     return unitv;
   }
   
-  UnitV with(const Let* v) const {
+  UnitV with(const Let* v) const override {
     encode(Let::type_case_id, this->out);
     encode(v->var(),      this->out);
     encode(v->varExpr(),  this->out);
@@ -1538,61 +1538,61 @@ struct encodeExprF : public switchExpr<UnitV> {
     return unitv;
   }
 
-  UnitV with(const LetRec* v) const {
+  UnitV with(const LetRec* v) const override {
     encode(LetRec::type_case_id, this->out);
     encode(v->bindings(), this->out);
     encode(v->bodyExpr(), this->out);
     return unitv;
   }
   
-  UnitV with(const Fn* v) const {
+  UnitV with(const Fn* v) const override {
     encode(Fn::type_case_id, this->out);
     encode(v->varNames(), this->out);
     encode(v->body(),     this->out);
     return unitv;
   }
   
-  UnitV with(const App* v) const {
+  UnitV with(const App* v) const override {
     encode(App::type_case_id, this->out);
     encode(v->fn(),   this->out);
     encode(v->args(), this->out);
     return unitv;
   }
   
-  UnitV with(const Assign* v) const {
+  UnitV with(const Assign* v) const override {
     encode(Assign::type_case_id, this->out);
     encode(v->left(),  this->out);
     encode(v->right(), this->out);
     return unitv;
   }
 
-  UnitV with(const MkArray* v) const {
+  UnitV with(const MkArray* v) const override {
     encode(MkArray::type_case_id, this->out);
     encode(v->values(), this->out);
     return unitv;
   }
 
-  UnitV with(const MkVariant* v) const {
+  UnitV with(const MkVariant* v) const override {
     encode(MkVariant::type_case_id, this->out);
     encode(v->label(), this->out);
     encode(v->value(), this->out);
     return unitv;
   }
 
-  UnitV with(const MkRecord* v) const {
+  UnitV with(const MkRecord* v) const override {
     encode(MkRecord::type_case_id, this->out);
     encode(v->fields(), this->out);
     return unitv;
   }
 
-  UnitV with(const AIndex* v) const {
+  UnitV with(const AIndex* v) const override {
     encode(AIndex::type_case_id, this->out);
     encode(v->array(), this->out);
     encode(v->index(), this->out);
     return unitv;
   }
 
-  UnitV with(const Case* v) const {
+  UnitV with(const Case* v) const override {
     encode(Case::type_case_id, this->out);
     encode(v->variant(), this->out);
     encode(v->bindings(), this->out);
@@ -1605,7 +1605,7 @@ struct encodeExprF : public switchExpr<UnitV> {
     return unitv;
   }
   
-  UnitV with(const Switch* v) const {
+  UnitV with(const Switch* v) const override {
     encode(Switch::type_case_id, this->out);
     encode(v->expr(), this->out);
     encode(v->bindings(), this->out);
@@ -1618,27 +1618,27 @@ struct encodeExprF : public switchExpr<UnitV> {
     return unitv;
   }
  
-  UnitV with(const Proj* v) const {
+  UnitV with(const Proj* v) const override {
     encode(Proj::type_case_id, this->out);
     encode(v->record(), this->out);
     encode(v->field(),  this->out);
     return unitv;
   }
   
-  UnitV with(const Assump* v) const {
+  UnitV with(const Assump* v) const override {
     encode(Assump::type_case_id, this->out);
     encode(v->expr(), this->out);
     encode(v->ty(),   this->out);
     return unitv;
   }
 
-  UnitV with(const Pack* v) const {
+  UnitV with(const Pack* v) const override {
     encode(Pack::type_case_id, this->out);
     encode(v->expr(), this->out);
     return unitv;
   }
   
-  UnitV with(const Unpack* v) const {
+  UnitV with(const Unpack* v) const override {
     encode(Unpack::type_case_id, this->out);
     encode(v->varName(), this->out);
     encode(v->package(), this->out);
@@ -1924,22 +1924,22 @@ void decode(const std::vector<uint8_t>& d, ExprPtr* e) {
 
 // determine whether or not an expression is fully annotated everywhere with a singular type
 struct hasSingularTypeF : public switchExprC<bool> {
-  bool withConst(const Expr* v) const {
+  bool withConst(const Expr* v) const override {
     return d(v);
   }
 
-  bool with(const Var* v) const {
+  bool with(const Var* v) const override {
     return d(v);
   }
 
-  bool with(const Let* v) const {
+  bool with(const Let* v) const override {
     return d(v) && r(v->varExpr()) && r(v->bodyExpr());
   }
 
-  bool with(const LetRec* v) const {
+  bool with(const LetRec* v) const override {
     if (!d(v) || !r(v->bodyExpr())) return false;
 
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       if (!r(b.second)) {
         return false;
       }
@@ -1947,14 +1947,14 @@ struct hasSingularTypeF : public switchExprC<bool> {
     return true;
   }
 
-  bool with(const Fn* v) const {
+  bool with(const Fn* v) const override {
     return d(v) && r(v->body());
   }
 
-  bool with(const App* v) const {
+  bool with(const App* v) const override {
     if (!d(v) || !r(v->fn())) return false;
 
-    for (auto a : v->args()) {
+    for (const auto& a : v->args()) {
       if (!r(a)) {
         return false;
       }
@@ -1962,67 +1962,67 @@ struct hasSingularTypeF : public switchExprC<bool> {
     return true;
   }
 
-  bool with(const Assign* v) const {
+  bool with(const Assign* v) const override {
     return d(v) && r(v->left()) && r(v->right());
   }
 
-  bool with(const MkArray* v) const {
+  bool with(const MkArray* v) const override {
     if (!d(v)) return false;
-    for (auto val : v->values()) {
+    for (const auto& val : v->values()) {
       if (!r(val)) return false;
     }
     return true;
   }
 
-  bool with(const MkVariant* v) const {
+  bool with(const MkVariant* v) const override {
     return d(v) && r(v->value());
   }
 
-  bool with(const MkRecord* v) const {
+  bool with(const MkRecord* v) const override {
     if (!d(v)) return false;
-    for (auto f : v->fields()) {
+    for (const auto& f : v->fields()) {
       if (!r(f.second)) return false;
     }
     return true;
   }
 
-  bool with(const AIndex* v) const {
+  bool with(const AIndex* v) const override {
     return d(v) && r(v->array()) && r(v->index());
   }
 
-  bool with(const Case* v) const {
+  bool with(const Case* v) const override {
     if (!d(v) || !r(v->variant()) || (v->defaultExpr() && !r(v->defaultExpr()))) return false;
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       if (!r(b.exp)) return false;
     }
     return true;
   }
 
-  bool with(const Switch* v) const {
+  bool with(const Switch* v) const override {
     if (!d(v) || !r(v->expr()) || (v->defaultExpr() && !r(v->defaultExpr()))) return false;
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       if (!r(b.exp)) return false;
     }
     return true;
   }
 
-  bool with(const Proj* v) const {
+  bool with(const Proj* v) const override {
     return d(v) && r(v->record());
   }
 
-  bool with(const Assump* v) const {
+  bool with(const Assump* v) const override {
     return d(v) && r(v->expr()) && isMonoSingular(v->ty());
   }
 
-  bool with(const Pack* v) const {
+  bool with(const Pack* v) const override {
     return d(v) && r(v->expr());
   }
 
-  bool with(const Unpack* v) const {
+  bool with(const Unpack* v) const override {
     return d(v) && r(v->package()) && r(v->expr());
   }
 private:
-  bool d(const Expr*    v) const { return v->type().get() && isMonoSingular(v->type()); }
+  bool d(const Expr*    v) const { return (v->type().get() != nullptr) && isMonoSingular(v->type()); }
   bool r(const ExprPtr& v) const { return switchOf(v, *this); }
 };
 
@@ -2032,101 +2032,101 @@ bool hasSingularType(const ExprPtr& e) {
 
 // determine the tgen size of types across an expression
 struct tgenSizeExprF : public switchExprC<int> {
-  int withConst(const Expr* v) const {
+  int withConst(const Expr* v) const override {
     return d(v);
   }
 
-  int with(const Var* v) const {
+  int with(const Var* v) const override {
     return d(v);
   }
 
-  int with(const Let* v) const {
+  int with(const Let* v) const override {
     return c(c(d(v), r(v->varExpr())), r(v->bodyExpr()));
   }
 
-  int with(const LetRec* v) const {
+  int with(const LetRec* v) const override {
     int x = c(d(v), r(v->bodyExpr()));
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       x = c(x, r(b.second));
     }
     return x;
   }
 
-  int with(const Fn* v) const {
+  int with(const Fn* v) const override {
     return c(d(v), r(v->body()));
   }
 
-  int with(const App* v) const {
+  int with(const App* v) const override {
     int x = c(d(v), r(v->fn()));
-    for (auto a : v->args()) {
+    for (const auto& a : v->args()) {
       x = c(x, r(a));
     }
     return x;
   }
 
-  int with(const Assign* v) const {
+  int with(const Assign* v) const override {
     return c(c(d(v), r(v->left())), r(v->right()));
   }
 
-  int with(const MkArray* v) const {
+  int with(const MkArray* v) const override {
     int x = d(v);
-    for (auto val : v->values()) {
+    for (const auto& val : v->values()) {
       x = c(x, r(val));
     }
     return x;
   }
 
-  int with(const MkVariant* v) const {
+  int with(const MkVariant* v) const override {
     return c(d(v), r(v->value()));
   }
 
-  int with(const MkRecord* v) const {
+  int with(const MkRecord* v) const override {
     int x = d(v);
-    for (auto f : v->fields()) {
+    for (const auto& f : v->fields()) {
       x = c(x, r(f.second));
     }
     return x;
   }
 
-  int with(const AIndex* v) const {
+  int with(const AIndex* v) const override {
     return c(c(d(v), r(v->array())), r(v->index()));
   }
 
-  int with(const Case* v) const {
+  int with(const Case* v) const override {
     int x = c(d(v), r(v->variant()));
     if (v->defaultExpr()) x = c(x, r(v->defaultExpr()));
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       x = c(x, r(b.exp));
     }
     return x;
   }
 
-  int with(const Switch* v) const {
+  int with(const Switch* v) const override {
     int x = c(d(v), r(v->expr()));
     if (v->defaultExpr()) x = c(x, r(v->defaultExpr()));
-    for (auto b : v->bindings()) {
+    for (const auto& b : v->bindings()) {
       x = c(x, r(b.exp));
     }
     return x;
   }
 
-  int with(const Proj* v) const {
+  int with(const Proj* v) const override {
     return c(d(v), r(v->record()));
   }
 
-  int with(const Assump* v) const {
+  int with(const Assump* v) const override {
     return c(c(d(v), r(v->expr())), tgenSize(v->ty()));
   }
 
-  int with(const Pack* v) const {
+  int with(const Pack* v) const override {
     return c(d(v), r(v->expr()));
   }
 
-  int with(const Unpack* v) const {
+  int with(const Unpack* v) const override {
     return c(c(d(v), r(v->package())), r(v->expr()));
   }
 private:
-  int d(const Expr*    v) const { return v->type().get() ? tgenSize(v->type()) : 0; }
+  int d(const Expr*    v) const { return v->type().get() != nullptr ? tgenSize(v->type()) : 0; }
   int r(const ExprPtr& v) const { return switchOf(v, *this); }
   int c(int x, int y)     const { return std::max<int>(x, y); }
 };
diff --git a/lib/hobbes/lang/macroexpand.C b/lib/hobbes/lang/macroexpand.C
index fac949486..527119c58 100644
--- a/lib/hobbes/lang/macroexpand.C
+++ b/lib/hobbes/lang/macroexpand.C
@@ -18,28 +18,28 @@ struct macroExpandF : public switchExprC<ExprPtr> {
     return mk(src->type(), out);
   }
 
-  ExprPtr withConst(const Expr* v)  const { return mk(v, v->clone()); }
-  ExprPtr with(const Fn* v)         const { return mk(v, new Fn(v->varNames(), switchOf(v->body(), *this), v->la())); }
-  ExprPtr with(const MkArray* v)    const { return mk(v, new MkArray(switchOf(v->values(), *this), v->la())); }
-  ExprPtr with(const MkVariant* v)  const { return mk(v, new MkVariant(v->label(), switchOf(v->value(), *this), v->la())); }
-  ExprPtr with(const MkRecord* v)   const { return mk(v, new MkRecord(switchOf(v->fields(), *this), v->la())); }
-  ExprPtr with(const AIndex* v)     const { return mk(v, new AIndex(switchOf(v->array(), *this), switchOf(v->index(), *this), v->la())); }
-  ExprPtr with(const Proj* v)       const { return mk(v, new Proj(switchOf(v->record(), *this), v->field(), v->la())); }
-  ExprPtr with(const Assump* v)     const { return mk(v, new Assump(switchOf(v->expr(), *this), v->ty(), v->la())); }
-
-  ExprPtr with(const Case* v) const {
+  ExprPtr withConst(const Expr* v)  const override { return mk(v, v->clone()); }
+  ExprPtr with(const Fn* v)         const override { return mk(v, new Fn(v->varNames(), switchOf(v->body(), *this), v->la())); }
+  ExprPtr with(const MkArray* v)    const override { return mk(v, new MkArray(switchOf(v->values(), *this), v->la())); }
+  ExprPtr with(const MkVariant* v)  const override { return mk(v, new MkVariant(v->label(), switchOf(v->value(), *this), v->la())); }
+  ExprPtr with(const MkRecord* v)   const override { return mk(v, new MkRecord(switchOf(v->fields(), *this), v->la())); }
+  ExprPtr with(const AIndex* v)     const override { return mk(v, new AIndex(switchOf(v->array(), *this), switchOf(v->index(), *this), v->la())); }
+  ExprPtr with(const Proj* v)       const override { return mk(v, new Proj(switchOf(v->record(), *this), v->field(), v->la())); }
+  ExprPtr with(const Assump* v)     const override { return mk(v, new Assump(switchOf(v->expr(), *this), v->ty(), v->la())); }
+
+  ExprPtr with(const Case* v) const override {
     ExprPtr de = v->defaultExpr();
-    if (de.get()) { de = switchOf(de, *this); }
+    if (de.get() != nullptr) { de = switchOf(de, *this); }
     return mk(v, new Case(switchOf(v->variant(), *this), switchOf(v->bindings(), *this), de, v->la()));
   }
 
-  ExprPtr with(const Switch* v) const {
+  ExprPtr with(const Switch* v) const override {
     ExprPtr de = v->defaultExpr();
     if (de) { de = switchOf(de, *this); }
     return mk(v, new Switch(switchOf(v->expr(), *this), switchOf(v->bindings(), *this), de, v->la()));
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (v->value() == "and") {
       return macroEtaLiftAnd(v->la());
     } else if (v->value() == "or") {
@@ -49,11 +49,11 @@ struct macroExpandF : public switchExprC<ExprPtr> {
     }
   }
 
-  ExprPtr with(const Let* v) const {
+  ExprPtr with(const Let* v) const override {
     return mk(v, new Let(v->var(), switchOf(v->varExpr(), *this), switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const LetRec* v) const {
+  ExprPtr with(const LetRec* v) const override {
     LetRec::Bindings bs;
     for (const auto& b : v->bindings()) {
       bs.push_back(LetRec::Binding(b.first, switchOf(b.second, *this)));
@@ -61,26 +61,26 @@ struct macroExpandF : public switchExprC<ExprPtr> {
     return mk(v, new LetRec(bs, switchOf(v->bodyExpr(), *this), v->la()));
   }
 
-  ExprPtr with(const App* v) const {
+  ExprPtr with(const App* v) const override {
     Var* fn = is<Var>(v->fn());
-    if (fn && fn->value() == "and") {
+    if ((fn != nullptr) && fn->value() == "and") {
       return macroExpandAnd(switchOf(v->args(), *this), v->la());
-    } else if (fn && fn->value() == "or") {
+    } else if ((fn != nullptr) && fn->value() == "or") {
       return macroExpandOr(switchOf(v->args(), *this), v->la());
     } else {
       return mk(v, new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
     }
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     return mk(v, new Assign(switchOf(v->left(), *this), switchOf(v->right(), *this), v->la()));
   }
 
-  ExprPtr with(const Pack* v) const {
+  ExprPtr with(const Pack* v) const override {
     return mk(v, new Pack(switchOf(v->expr(), *this), v->la()));
   }
 
-  ExprPtr with(const Unpack* v) const {
+  ExprPtr with(const Unpack* v) const override {
     return mk(v, new Unpack(v->varName(), switchOf(v->package(), *this), switchOf(v->expr(), *this), v->la()));
   }
 
diff --git a/lib/hobbes/lang/module.C b/lib/hobbes/lang/module.C
index 61476b017..8dd9f3a38 100644
--- a/lib/hobbes/lang/module.C
+++ b/lib/hobbes/lang/module.C
@@ -2,6 +2,7 @@
 #include <hobbes/lang/module.H>
 #include <hobbes/util/array.H>
 #include <hobbes/util/lannotation.H>
+#include <memory>
 #include <sstream>
 
 namespace hobbes {
@@ -13,8 +14,8 @@ const ModuleDefs&  Module::definitions() const { return this->defs; }
 
 void Module::show(std::ostream& out) const {
   out << "module " << this->mname << " where" << std::endl;
-  for (ModuleDefs::const_iterator md = this->defs.begin(); md != this->defs.end(); ++md) {
-    (*md)->show(out);
+  for (const auto &def : this->defs) {
+    def->show(out);
     out << std::endl;
   }
 }
@@ -38,7 +39,7 @@ const std::vector<std::string>& Module::options() const {
 /* module defs */
 ModuleDef::ModuleDef(int cid, const LexicalAnnotation& la) : LexicallyAnnotated(la), cid(cid) { }
 int ModuleDef::case_id() const { return this->cid; }
-ModuleDef::~ModuleDef() { }
+ModuleDef::~ModuleDef() = default;
 
 // module imports
 MImport::MImport(const std::string& p, const std::string& n, const LexicalAnnotation& la) : Base(la), p(p), n(n) { }
@@ -56,9 +57,9 @@ const QualTypePtr&   MTypeDef::type()       const { return this->t;     }
 
 void MTypeDef::show(std::ostream& out) const {
   if (this->v == Transparent) {
-    out << "type " << this->tname << (this->targs.size() > 0 ? " " : "") << str::cdelim(this->targs, " ") << " = " << hobbes::show(this->t);
+    out << "type " << this->tname << (!this->targs.empty() ? " " : "") << str::cdelim(this->targs, " ") << " = " << hobbes::show(this->t);
   } else {
-    out << "data " << this->tname << (this->targs.size() > 0 ? " " : "") << str::cdelim(this->targs, " ") << " = " << hobbes::show(this->t);
+    out << "data " << this->tname << (!this->targs.empty() ? " " : "") << str::cdelim(this->targs, " ") << " = " << hobbes::show(this->t);
   }
 }
 
@@ -74,7 +75,7 @@ void MVarTypeDef::show(std::ostream& out) const {
 // variable expression bindings
 str::seq nameBlanks(const str::seq& xs) {
   str::seq r;
-  for (auto x : xs) {
+  for (const auto& x : xs) {
     if (x == "_") {
       r.push_back(freshName());
     } else {
@@ -100,19 +101,19 @@ ClassDef::ClassDef(const Constraints& cs, const std::string& cname, const str::s
 const Constraints&  ClassDef::constraints() const { return this->cs; }
 const std::string&  ClassDef::name() const { return this->cname; }
 const str::seq&     ClassDef::vars() const { return this->tvars; }
-const CFunDepDefs   ClassDef::fundeps() const { return this->fdeps; }
+CFunDepDefs         ClassDef::fundeps() const { return this->fdeps; }
 const MVarTypeDefs& ClassDef::members() const { return this->mvtydefs; }
 
 void ClassDef::show(std::ostream& out) const {
   out << "class " << this->cname << " " << str::cdelim(this->tvars, " ");
-  if (this->fdeps.size() > 0) {
+  if (!this->fdeps.empty()) {
     out << " | ";
     out << hobbes::show(this->fdeps);
   }
   out << " where" << std::endl;
-  for (MVarTypeDefs::const_iterator mvtd = this->mvtydefs.begin(); mvtd != this->mvtydefs.end(); ++mvtd) {
+  for (const auto &mvtydef : this->mvtydefs) {
     out << "  ";
-    (*mvtd)->show(out);
+    mvtydef->show(out);
     out << std::endl;
   }
 }
@@ -129,9 +130,9 @@ const MVarDefs&    InstanceDef::members()     const { return this->mdefs; }
 
 void InstanceDef::show(std::ostream& out) const {
   out << "instance (" << str::cdelim(hobbes::show(this->cs), ", ") << ") => " << this->cname << " " << str::cdelim(hobbes::show(this->targs), " ") << " where" << std::endl;
-  for (MVarDefs::const_iterator mvd = this->mdefs.begin(); mvd != this->mdefs.end(); ++mvd) {
+  for (const auto &mdef : this->mdefs) {
     out << "  ";
-    (*mvd)->show(out);
+    mdef->show(out);
     out << std::endl;
   }
 }
@@ -182,7 +183,7 @@ std::string show(const CFunDepDef& fundep) {
 }
 
 std::string show(const CFunDepDefs& fundeps) {
-  if (fundeps.size() == 0) {
+  if (fundeps.empty()) {
     return "";
   } else {
     std::ostringstream ss;
@@ -197,8 +198,8 @@ std::string show(const CFunDepDefs& fundeps) {
 
 MVarDefs substitute(const MonoTypeSubst& s, const MVarDefs& vds) {
   MVarDefs result;
-  for (MVarDefs::const_iterator vd = vds.begin(); vd != vds.end(); ++vd) {
-    result.push_back(MVarDefPtr(new MVarDef((*vd)->varWithArgs(), substitute(s, (*vd)->varExpr()), (*vd)->la())));
+  for (const auto &vd : vds) {
+    result.push_back(std::make_shared<MVarDef>(vd->varWithArgs(), substitute(s, vd->varExpr()), vd->la()));
   }
   return result;
 }
@@ -213,7 +214,7 @@ ModuleDefPtr switchMDefTyFn::with(const MSafePragmaDef* x) const { return Module
 struct appMTySwitchF : public switchExprTyFn {
   const switchMDefTyFn* f;
   appMTySwitchF(const switchMDefTyFn* f) : f(f) { }
-  QualTypePtr withTy(const QualTypePtr& t) const { if (t) return this->f->withTy(t); else return t; }
+  QualTypePtr withTy(const QualTypePtr& t) const override { if (t) return this->f->withTy(t); else return t; }
 };
 ModuleDefPtr switchMDefTyFn::with(const MVarDef* x) const {
   return ModuleDefPtr(new MVarDef(x->varWithArgs(), switchOf(x->varExpr(), appMTySwitchF(this)), x->la()));
@@ -229,14 +230,14 @@ MonoTypes appMTyTys(const switchMDefTyFn* f, const MonoTypes& ts) {
 Constraints appMTyCS(const switchMDefTyFn* f, const Constraints& cs) {
   Constraints r;
   for (const auto& c : cs) {
-    r.push_back(ConstraintPtr(new Constraint(c->name(), appMTyTys(f, c->arguments()))));
+    r.push_back(std::make_shared<Constraint>(c->name(), appMTyTys(f, c->arguments())));
   }
   return r;
 }
 MVarTypeDefs appMTyMVTDs(const switchMDefTyFn* f, const MVarTypeDefs& tds) {
   MVarTypeDefs r;
   for (const auto& td : tds) {
-    r.push_back(MVarTypeDefPtr(new MVarTypeDef(td->varName(), f->withTy(td->varType()), td->la())));
+    r.push_back(std::make_shared<MVarTypeDef>(td->varName(), f->withTy(td->varType()), td->la()));
   }
   return r;
 }
@@ -247,7 +248,7 @@ ModuleDefPtr switchMDefTyFn::with(const ClassDef* x) const {
 MVarDefs appMTyMVDs(const switchMDefTyFn* f, const MVarDefs& vds) {
   MVarDefs r;
   for (const auto& vd : vds) {
-    r.push_back(MVarDefPtr(new MVarDef(vd->varWithArgs(), switchOf(vd->varExpr(), appMTySwitchF(f)), vd->la())));
+    r.push_back(std::make_shared<MVarDef>(vd->varWithArgs(), switchOf(vd->varExpr(), appMTySwitchF(f)), vd->la()));
   }
   return r;
 }
diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index b4da60eec..57ce8f037 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -25,7 +25,7 @@ stateidx_t LoadVars::nextState() const { return this->next; }
 std::string LoadVars::stamp() {
   std::ostringstream ss;
   ss << "l";
-  for (auto d : this->ds) {
+  for (const auto& d : this->ds) {
     ss << "." << d.first << "=" << reinterpret_cast<void*>(d.second.get()); // assumes that we deliberately share equivalent expressions
   }
   ss << "." << this->next;
@@ -40,7 +40,7 @@ stateidx_t SwitchVal::defaultState() const { return this->def; }
 std::string SwitchVal::stamp() {
   std::ostringstream ss;
   ss << "s." << this->var;
-  for (auto j : this->jmps) {
+  for (const auto& j : this->jmps) {
     ss << ".";
     j.first->show(ss);
     ss << ":" << j.second;
@@ -57,7 +57,7 @@ stateidx_t SwitchVariant::defaultState() const { return this->def; }
 std::string SwitchVariant::stamp() {
   std::ostringstream ss;
   ss << "c." << this->var;
-  for (auto j : this->jmps) {
+  for (const auto& j : this->jmps) {
     ss << "." << j.first << "=" << j.second;
   }
   ss << "." << this->def;
@@ -86,7 +86,7 @@ MStatePtr makeSwitch(const MDFA* dfa, const std::string& switchVar, const Switch
     // if we've only got a default switch and no cases, just use the default case
     // otherwise if this would be a 'switch' on unit, don't bother (just pass the type equality through)
     //  -- only the first option can match for unit (or default if there's only a default)
-    if (jmps.size() == 0) {
+    if (jmps.empty()) {
       return dfa->states[defState];
     } else if (isUnit(jmps[0].first->primType())) {
       return actAndThen(assume(var(switchVar, dfa->rootLA), primty("unit"), dfa->rootLA), jmps[0].second);
@@ -94,7 +94,7 @@ MStatePtr makeSwitch(const MDFA* dfa, const std::string& switchVar, const Switch
       return MStatePtr(new SwitchVal(switchVar, jmps, defState));
     }
   } else {
-    if (jmps.size() > 0) {
+    if (!jmps.empty()) {
       MonoTypePtr sty = jmps[0].first->primType();
 
       if (const Prim* pty = is<Prim>(sty)) {
@@ -148,7 +148,7 @@ ExprPtr varName(MDFA* dfa, const std::string& vn) {
 ExprPtr arrayElement(MDFA* dfa, const std::string& vn, size_t i) {
   VarArrayElem::const_iterator ae = dfa->elementExps.find(vn);
   if (ae != dfa->elementExps.end()) {
-    ArrayElem::const_iterator ie = ae->second.find(i);
+    auto ie = ae->second.find(i);
     if (ie != ae->second.end()) {
       return ie->second;
     }
@@ -162,7 +162,7 @@ ExprPtr arrayElement(MDFA* dfa, const std::string& vn, size_t i) {
 ExprPtr charArrElement(MDFA* dfa, const std::string& packFn, const std::string& vn, size_t i) {
   VarArrayElem::const_iterator ae = dfa->elementExps.find(vn);
   if (ae != dfa->elementExps.end()) {
-    ArrayElem::const_iterator ie = ae->second.find(i);
+    auto ie = ae->second.find(i);
     if (ie != ae->second.end()) {
       return ie->second;
     }
@@ -191,7 +191,7 @@ ExprPtr arraySize(MDFA* dfa, const std::string& vn) {
 ExprPtr field(MDFA* dfa, const std::string& vn, const std::string& fn) {
   VarStructField::const_iterator vsf = dfa->fieldExps.find(vn);
   if (vsf != dfa->fieldExps.end()) {
-    StructField::const_iterator sf = vsf->second.find(fn);
+    auto sf = vsf->second.find(fn);
     if (sf != vsf->second.end()) {
       return sf->second;
     }
@@ -212,15 +212,15 @@ void tableTail(PatternRows* out, const PatternRows& in) {
 
 // eliminate unused columns from a table
 void dropUnusedColumns(PatternRows* out, const PatternRows& in) {
-  if (in.size() == 0) {
+  if (in.empty()) {
     return;
   }
 
   std::set<size_t> usedColumns;
   for (size_t c = 0; c < in[0].patterns.size(); ++c) {
     bool hasUse = false;
-    for (size_t r = 0; r < in.size(); ++r) {
-      if (!is<MatchAny>(in[r].patterns[c])) {
+    for (const auto &r : in) {
+      if (is<MatchAny>(r.patterns[c]) == nullptr) {
         hasUse = true;
         break;
       }
@@ -233,12 +233,12 @@ void dropUnusedColumns(PatternRows* out, const PatternRows& in) {
   if (usedColumns.size() == in[0].patterns.size()) {
     *out = in;
   } else {
-    for (size_t r = 0; r < in.size(); ++r) {
+    for (const auto &r : in) {
       Patterns ps;
-      for (auto c : usedColumns) {
-        ps.push_back(in[r].patterns[c]);
+      for (const auto c : usedColumns) {
+        ps.push_back(r.patterns[c]);
       }
-      out->push_back(PatternRow(ps, in[r].guard, in[r].result));
+      out->push_back(PatternRow(ps, r.guard, r.result));
     }
   }
 }
@@ -317,8 +317,8 @@ template <
   typename SVLT = std::less<SValue>
 >
 MStatePtr makeSplitState(MDFA* dfa, const PatternRows& ps, size_t c) {
-  typedef std::map<SValue, PatternRows, SVLT> Branches;
-  typedef std::map<SValue, size_t>            BranchOrder;
+  using Branches = std::map<SValue, PatternRows, SVLT>;
+  using BranchOrder = std::map<SValue, size_t>;
 
   Branches    bs;
   BranchOrder bos;
@@ -335,7 +335,7 @@ MStatePtr makeSplitState(MDFA* dfa, const PatternRows& ps, size_t c) {
       PatternRows& outrs = bs[sv];
 
       // the first time through this branch, we need to make sure that prior match-any rows are prepended
-      if (outrs.size() == 0) {
+      if (outrs.empty()) {
         for (auto i : anys) {
           makeMatchAnyRow(sv, &outrs, ps[i], c);
         }
@@ -347,7 +347,7 @@ MStatePtr makeSplitState(MDFA* dfa, const PatternRows& ps, size_t c) {
       // record where this match-any came from, then append it to all states recorded so far
       anys.push_back(r);
 
-      for (typename Branches::iterator b = bs.begin(); b != bs.end(); ++b) {
+      for (auto b = bs.begin(); b != bs.end(); ++b) {
         makeMatchAnyRow(b->first, &b->second, ps[r], c);
       }
     } else {
@@ -361,8 +361,8 @@ MStatePtr makeSplitState(MDFA* dfa, const PatternRows& ps, size_t c) {
   }
 
   // finally, pull the branch and default jumps together (in introduction order) and make the new state
-  typedef std::pair<SValue, stateidx_t> Jump;
-  typedef std::vector<Jump>             Jumps;
+  using Jump = std::pair<SValue, stateidx_t>;
+  using Jumps = std::vector<Jump>;
   Jumps jmps;
 
   jmps.resize(bs.size());
@@ -370,7 +370,7 @@ MStatePtr makeSplitState(MDFA* dfa, const PatternRows& ps, size_t c) {
     jmps[bos[b.first]] = Jump(b.first, makeNextState(ps[0].patterns[c]->name(), b.first, dfa, b.second));
   }
 
-  stateidx_t defState = def.size() > 0 ? makeDFAState(dfa, def) : nullState;
+  stateidx_t defState = !def.empty() ? makeDFAState(dfa, def) : nullState;
 
   return makeSwitchState(ps[0].patterns[c]->name(), dfa, jmps, defState);
 }
@@ -489,8 +489,8 @@ MStatePtr makeArrayState(MDFA* dfa, const PatternRows& ps, size_t c) {
 // split on string matching
 size_t maxStringLen(const PatternRows& ps, size_t c) {
   size_t mlen = 0;
-  for (size_t r = 0; r < ps.size(); ++r) {
-    if (const MatchArray* ma = is<MatchArray>(ps[r].patterns[c])) {
+  for (const auto &p : ps) {
+    if (const MatchArray* ma = is<MatchArray>(p.patterns[c])) {
       mlen = std::max<size_t>(ma->size(), mlen);
     }
   }
@@ -554,7 +554,7 @@ MStatePtr makeCharArrayState(MDFA* dfa, const PatternRows& ps, size_t c) {
   static MonoTypePtr longTy(Prim::make("long"));
 
   std::string arrayVar = ps[0].patterns[c]->name();
-  size_t      mlen     = align<size_t>(maxStringLen(ps, c) + 1, 8);
+  auto      mlen     = align<size_t>(maxStringLen(ps, c) + 1, 8);
   size_t      cs       = mlen;
   
   LoadVars::Defs ds;
@@ -574,8 +574,8 @@ MStatePtr makeCharArrayState(MDFA* dfa, const PatternRows& ps, size_t c) {
 
   // generate the successor table
   PatternRows nps;
-  for (size_t r = 0; r < ps.size(); ++r) {
-    addSATableRow(mlen, ps[r], c, &nps);
+  for (const auto &p : ps) {
+    addSATableRow(mlen, p, c, &nps);
   }
 
   // and that's it!
@@ -584,18 +584,18 @@ MStatePtr makeCharArrayState(MDFA* dfa, const PatternRows& ps, size_t c) {
 
 bool canMakeCharArrayState(const PatternRows& ps, size_t c) {
   bool seemsLegit = false;
-  for (size_t r = 0; r < ps.size(); ++r) {
-    if (const MatchArray* ma = is<MatchArray>(ps[r].patterns[c])) {
+  for (const auto &p : ps) {
+    if (const MatchArray* ma = is<MatchArray>(p.patterns[c])) {
       for (size_t i = 0; i < ma->size(); ++i) {
         if (const MatchLiteral* ml = is<MatchLiteral>(ma->pattern(i))) {
-          if (is<Char>(ml->equivConstant())) {
+          if (is<Char>(ml->equivConstant()) != nullptr) {
             seemsLegit = true;
           }
         } else {
           return false;
         }
       }
-    } else if (!is<MatchAny>(ps[r].patterns[c])) {
+    } else if (is<MatchAny>(p.patterns[c]) == nullptr) {
       return false;
     }
   }
@@ -632,15 +632,15 @@ MStatePtr makeRecordState(MDFA* dfa, const PatternRows& ps, size_t c) {
   // eliminate this column and add new columns for field patterns
   PatternRows cdef;
 
-  for (size_t r = 0; r < ps.size(); ++r) {
-    if (const MatchRecord* mr = is<MatchRecord>(ps[r].patterns[c])) {
-      copyRowWithoutColumn(&cdef, ps[r], c);
+  for (const auto &p : ps) {
+    if (const MatchRecord* mr = is<MatchRecord>(p.patterns[c])) {
+      copyRowWithoutColumn(&cdef, p, c);
       prependPatterns(&cdef.back(), recordFieldPatterns(*mr));
-    } else if (is<MatchAny>(ps[r].patterns[c])) {
-      copyRowWithoutColumn(&cdef, ps[r], c);
+    } else if (is<MatchAny>(p.patterns[c]) != nullptr) {
+      copyRowWithoutColumn(&cdef, p, c);
       prependPatterns(&cdef.back(), arrayAnyMatches(defs.size()));
     } else {
-      throw annotated_error(*ps[r].patterns[c], "Internal error, invalid pattern table received");
+      throw annotated_error(*p.patterns[c], "Internal error, invalid pattern table received");
     }
   }
 
@@ -693,7 +693,7 @@ MStatePtr makeRegexState(MDFA* dfa, const PatternRows& ps, size_t c) {
   for (size_t r = 0; r < ps.size(); ++r) {
     if (const MatchRegex* mr = is<MatchRegex>(ps[r].patterns[c])) {
       regexes.push_back(mr->value());
-    } else if (is<MatchAny>(ps[r].patterns[c])) {
+    } else if (is<MatchAny>(ps[r].patterns[c]) != nullptr) {
       matchAnyRows.insert(r);
       regexes.push_back(parseRegex(""));
     } else {
@@ -772,7 +772,7 @@ MStatePtr makeRegexState(MDFA* dfa, const PatternRows& ps, size_t c) {
   for (auto r : matchAnyRows) {
     copyRowWithoutColumn(&def, ps[r], c);
   }
-  stateidx_t defState = def.size() > 0 ? makeDFAState(dfa, def) : nullState;
+  stateidx_t defState = !def.empty() ? makeDFAState(dfa, def) : nullState;
 
   // and that's our state ... a load for the regex call and a branch on its result
   return MStatePtr(new LoadVars(ds, addState(dfa, makeLSSwitch(rcheckVar, dfa, sjmps, defState))));
@@ -791,20 +791,20 @@ struct makeSuccStateF : public switchPattern<MStatePtr> {
   size_t c;
   makeSuccStateF(MDFA* dfa, const PatternRows& ps, size_t c) : dfa(dfa), ps(ps), c(c) { }
 
-  MStatePtr with(const MatchAny* ma) const {
+  MStatePtr with(const MatchAny* ma) const override {
     throw annotated_error(*ma, "Internal error, can't deconstruct wildcard columns in match expression");
   }
 
-  MStatePtr with(const MatchLiteral*) const { return makeLiteralState(dfa, ps, c); }
-  MStatePtr with(const MatchRegex*)   const { return makeRegexState(dfa, regexNormalize(ps, c), c); }
-  MStatePtr with(const MatchRecord*)  const { return makeRecordState(dfa, ps, c); }
-  MStatePtr with(const MatchVariant*) const { return makeVariantState(dfa, ps, c); }
+  MStatePtr with(const MatchLiteral*) const override { return makeLiteralState(dfa, ps, c); }
+  MStatePtr with(const MatchRegex*)   const override { return makeRegexState(dfa, regexNormalize(ps, c), c); }
+  MStatePtr with(const MatchRecord*)  const override { return makeRecordState(dfa, ps, c); }
+  MStatePtr with(const MatchVariant*) const override { return makeVariantState(dfa, ps, c); }
 
   // if we have a 'match array' column but it's got a regex somewhere, then we actually
   // need to apply regex match logic (otherwise we can match as an array)
-  MStatePtr with(const MatchArray*) const {
-    for (size_t r = 0; r < ps.size(); ++r) {
-      if (is<MatchRegex>(ps[r].patterns[c])) {
+  MStatePtr with(const MatchArray*) const override {
+    for (const auto &p : ps) {
+      if (is<MatchRegex>(p.patterns[c]) != nullptr) {
         return makeRegexState(dfa, regexNormalize(ps, c), c);
       }
     }
@@ -815,9 +815,9 @@ struct makeSuccStateF : public switchPattern<MStatePtr> {
   // (this allows mixing of literal matches and regex matches in a single column)
   static PatternRows regexNormalize(const PatternRows& ps, size_t c) {
     PatternRows nps = ps;
-    for (size_t r = 0; r < nps.size(); ++r) {
-      if (const MatchArray* ma = is<MatchArray>(nps[r].patterns[c])) {
-        nps[r].patterns[c] = MatchRegex::toRegex(*ma);
+    for (auto &np : nps) {
+      if (const MatchArray* ma = is<MatchArray>(np.patterns[c])) {
+        np.patterns[c] = MatchRegex::toRegex(*ma);
       }
     }
     return nps;
@@ -834,15 +834,15 @@ struct scorePatternF : public switchPattern<size_t> {
   // don't count the same primitive twice
   mutable PrimitiveSet recprims;
 
-  size_t with(const MatchAny*) const {
+  size_t with(const MatchAny*) const override {
     return 0;
   }
 
-  size_t with(const MatchLiteral* ml) const {
+  size_t with(const MatchLiteral* ml) const override {
     return this->recprims.insert(ml->equivConstant()).second ? 1 : 0;
   }
 
-  size_t with(const MatchArray* ma) const {
+  size_t with(const MatchArray* ma) const override {
     size_t s = 1;
     for (size_t i = 0; i < ma->size(); ++i) {
       s += switchOf(ma->pattern(i), *this);
@@ -850,11 +850,11 @@ struct scorePatternF : public switchPattern<size_t> {
     return s;
   }
 
-  size_t with(const MatchRegex*) const {
+  size_t with(const MatchRegex*) const override {
     return 1;
   }
 
-  size_t with(const MatchRecord* mr) const {
+  size_t with(const MatchRecord* mr) const override {
     size_t s = 0;
     for (size_t i = 0; i < mr->size(); ++i) {
       s += switchOf(mr->pattern(i).second, *this);
@@ -862,7 +862,7 @@ struct scorePatternF : public switchPattern<size_t> {
     return s;
   }
 
-  size_t with(const MatchVariant* mv) const {
+  size_t with(const MatchVariant* mv) const override {
     return 1 + switchOf(mv->value(), *this);
   }
 };
@@ -884,14 +884,14 @@ size_t choosePivotColumn(const PatternRows& ps) {
   size_t bestArrayScore  = std::numeric_limits<size_t>::max();
 
   for (size_t c = 0; c < ps[0].patterns.size(); ++c) {
-    if (!is<MatchAny>(ps[0].patterns[c])) {
+    if (is<MatchAny>(ps[0].patterns[c]) == nullptr) {
       size_t csc = 1 + columnScore(ps, c);
       if (csc < currentScore) {
         chosenColumn = c;
         currentScore = csc;
       }
 
-      if (is<MatchArray>(ps[0].patterns[c]) && csc < bestArrayScore) {
+      if ((is<MatchArray>(ps[0].patterns[c]) != nullptr) && csc < bestArrayScore) {
         bestArrayColumn = c;
         bestArrayScore  = csc;
       }
@@ -914,8 +914,8 @@ bool isPrimSelection(bool alwaysLowerPrimMatchTables, const PatternRows& ps) {
   }
 
   // there can't be any guards in a primitive selection
-  for (size_t r = 0; r < ps.size(); ++r) {
-    if (ps[r].guard) {
+  for (const auto &p : ps) {
+    if (p.guard) {
       return false;
     }
   }
@@ -925,8 +925,8 @@ bool isPrimSelection(bool alwaysLowerPrimMatchTables, const PatternRows& ps) {
   bool seemsLegit = false;
 
   for (size_t c = 0; c < ps[0].patterns.size(); ++c) {
-    for (size_t r = 0; r < ps.size(); ++r) {
-      if (const MatchLiteral* ml = is<MatchLiteral>(ps[r].patterns[c])) {
+    for (const auto &p : ps) {
+      if (const MatchLiteral* ml = is<MatchLiteral>(p.patterns[c])) {
         if (ml->expression()) {
           return false;
         } else {
@@ -934,7 +934,7 @@ bool isPrimSelection(bool alwaysLowerPrimMatchTables, const PatternRows& ps) {
           seemsLegit = true;
           break;
         }
-      } else if (!is<MatchAny>(ps[r].patterns[c])) {
+      } else if (is<MatchAny>(p.patterns[c]) == nullptr) {
         return false;
       }
     }
@@ -947,8 +947,8 @@ bool isPrimSelection(bool alwaysLowerPrimMatchTables, const PatternRows& ps) {
 PrimFArgs makePrimFArgs(const PatternRows& ps) {
   PrimFArgs args;
   for (size_t c = 0; c < ps[0].patterns.size(); ++c) {
-    for (size_t r = 0; r < ps.size(); ++r) {
-      if (const MatchLiteral* ml = is<MatchLiteral>(ps[r].patterns[c])) {
+    for (const auto & p : ps) {
+      if (const MatchLiteral* ml = is<MatchLiteral>(p.patterns[c])) {
         args.push_back(PrimFArg(ml->name(), ml->equivConstant()->primType()));
         break;
       }
@@ -960,7 +960,7 @@ PrimFArgs makePrimFArgs(const PatternRows& ps) {
 // does it make sense and is it worthwhile to decompose this table column-wise?
 bool shouldDecomposeColumnwise(MDFA* dfa, const PatternRows& ps) {
   // it only makes sense to decompose columnwise if the table has at least one row, at least two columns
-  if (ps.size() == 0 || ps[0].patterns.size() <= 1) {
+  if (ps.empty() || ps[0].patterns.size() <= 1) {
     return false;
   }
 
@@ -1066,7 +1066,7 @@ stateidx_t makeColPivotDFAState(MDFA* dfa, const PatternRows& ps) {
 
     PatternRows tail;
     tableTail(&tail, ps);
-    if (tail.size() == 0) {
+    if (tail.empty()) {
       throw annotated_error(*ps[0].guard, "Inexhaustive patterns in match expression after guard");
     }
 
@@ -1120,7 +1120,7 @@ stateidx_t makeDFA(MDFA* dfa, const PatternRows& ps, const LexicalAnnotation& la
 
   // start by adding 0-ref states and placeholder parameters for each final expression
   std::vector<stateidx_t> finalStates;
-  for (auto pr : ps) {
+  for (const auto& pr : ps) {
     stateidx_t fst = addState(dfa, MStatePtr(new FinishExpr(pr.result)), false);
     finalStates.push_back(fst);
     dfa->exprIdxs[pr.result.get()] = fst;
@@ -1140,7 +1140,7 @@ stateidx_t makeDFA(MDFA* dfa, const PatternRows& ps, const LexicalAnnotation& la
       }
     }
 
-    if (unreachableRows.size() > 0) {
+    if (!unreachableRows.empty()) {
       std::ostringstream fss;
       fss << "Unreachable row" << (unreachableRows.size() > 1 ? "s" : "") << " in match expression:\n";
       for (size_t ur : unreachableRows) {
@@ -1165,7 +1165,7 @@ struct liftDFAExprF : public switchMState<ExprPtr> {
   MDFA* dfa;
   liftDFAExprF(MDFA* dfa) : dfa(dfa) { }
 
-  ExprPtr with(const LoadVars* x) const {
+  ExprPtr with(const LoadVars* x) const override {
     const LoadVars::Defs& ds = x->defs();
     ExprPtr b = liftDFAExpr(this->dfa, x->nextState());
 
@@ -1176,7 +1176,7 @@ struct liftDFAExprF : public switchMState<ExprPtr> {
     return b;
   }
 
-  ExprPtr with(const SwitchVal* x) const {
+  ExprPtr with(const SwitchVal* x) const override {
     ExprPtr def = x->defaultState() == nullState ? ExprPtr() : liftDFAExpr(this->dfa, x->defaultState());
 
     const SwitchVal::Jumps& jmps = x->jumps();
@@ -1188,7 +1188,7 @@ struct liftDFAExprF : public switchMState<ExprPtr> {
     return ExprPtr(new Switch(varName(this->dfa, x->switchVar()), bs, def, dfa->rootLA));
   }
 
-  ExprPtr with(const SwitchVariant* x) const {
+  ExprPtr with(const SwitchVariant* x) const override {
     ExprPtr def = x->defaultState() == nullState ? ExprPtr() : liftDFAExpr(this->dfa, x->defaultState());
 
     const SwitchVariant::CtorJumps& jmps = x->jumps();
@@ -1200,16 +1200,16 @@ struct liftDFAExprF : public switchMState<ExprPtr> {
     return ExprPtr(new Case(varName(this->dfa, x->switchVar()), bs, def, dfa->rootLA));
   }
 
-  ExprPtr with(const FinishExpr* x) const {
+  ExprPtr with(const FinishExpr* x) const override {
     return x->expr();
   }
 };
 
-typedef std::pair<ExprPtr, PrimitivePtr> ExprCheck;
-typedef std::vector<ExprCheck> ExprChecks;
+using ExprCheck = std::pair<ExprPtr, PrimitivePtr>;
+using ExprChecks = std::vector<ExprCheck>;
 
 ExprPtr checkExpr(const ExprChecks& cs, const LexicalAnnotation& la) {
-  if (cs.size() == 0) {
+  if (cs.empty()) {
     throw annotated_error(la, "Internal error, can't produce empty check expression");
   } else {
     ExprPtr v = fncall(var("===", la), list(cs[0].first, std::dynamic_pointer_cast<Expr>(cs[0].second)), la);
@@ -1272,7 +1272,7 @@ bool shouldInlineState(const MDFA* dfa, stateidx_t state) {
   } else if (s->refs <= 1) {
     return true;
   } else if (const FinishExpr* fe = is<FinishExpr>(s)) {
-    return isConst(fe->expr()) || is<Var>(fe->expr());
+    return isConst(fe->expr()) || (is<Var>(fe->expr()) != nullptr);
   } else {
     return false;
   }
@@ -1316,7 +1316,7 @@ ExprPtr liftDFAExpr(cc* c, const PatternRows& ps, const LexicalAnnotation& rootL
   stateidx_t initState = makeDFA(&pdfa, ps, rootLA);
   ExprPtr    me        = liftDFAExpr(&pdfa, initState);
 
-  if (pdfa.foldedStates.size() == 0) {
+  if (pdfa.foldedStates.empty()) {
     return me;
   } else {
     LetRec::Bindings bs;
@@ -1328,7 +1328,7 @@ ExprPtr liftDFAExpr(cc* c, const PatternRows& ps, const LexicalAnnotation& rootL
 }
 
 // determine the row/expr set reachable from a DFA state
-typedef std::map<size_t, ExprPtr> RowResults;
+using RowResults = std::map<size_t, ExprPtr>;
 
 struct reachableRowExprsF : public switchMState<UnitV> {
   const MDFA* dfa;
@@ -1336,7 +1336,7 @@ struct reachableRowExprsF : public switchMState<UnitV> {
 
   reachableRowExprsF(const MDFA* dfa, RowResults* results) : dfa(dfa), results(results) { }
 
-  UnitV with(const SwitchVal* x) const {
+  UnitV with(const SwitchVal* x) const override {
     if (x->defaultState() != nullState) {
       switchOf(this->dfa->states[x->defaultState()], *this);
     }
@@ -1346,7 +1346,7 @@ struct reachableRowExprsF : public switchMState<UnitV> {
     return unitv;
   }
 
-  UnitV with(const FinishExpr* x) const {
+  UnitV with(const FinishExpr* x) const override {
     auto ei = this->dfa->exprIdxs.find(x->expr().get());
     if (ei == this->dfa->exprIdxs.end()) {
       throw std::runtime_error("Internal error, match DFA returns non-indexed expression");
@@ -1356,12 +1356,12 @@ struct reachableRowExprsF : public switchMState<UnitV> {
     return unitv;
   }
   
-  UnitV with(const LoadVars* x) const {
+  UnitV with(const LoadVars* x) const override {
     switchOf(this->dfa->states[x->nextState()], *this);
     return unitv;
   }
 
-  UnitV with(const SwitchVariant* x) const {
+  UnitV with(const SwitchVariant* x) const override {
     if (x->defaultState() != nullState) {
       switchOf(this->dfa->states[x->defaultState()], *this);
     }
@@ -1382,8 +1382,8 @@ long asLongRep(long*  x) { return *x; }
 long asLongRep(double x) { return asLongRep(reinterpret_cast<long*>(&x)); }
 
 // derive a primitive search function from a DFA (or sub-DFA) that contains _only_ primitive tests
-typedef std::map<std::string, llvm::Value*>      Args;
-typedef std::map<stateidx_t,  llvm::BasicBlock*> StateBranches;
+using Args = std::map<std::string, llvm::Value *>;
+using StateBranches = std::map<stateidx_t, llvm::BasicBlock *>;
 
 struct makePrimDFASF : public switchMState<UnitV> {
   const Args&    args;
@@ -1402,16 +1402,16 @@ struct makePrimDFASF : public switchMState<UnitV> {
     }
   }
 
-  UnitV with(const SwitchVal* x) const {
+  UnitV with(const SwitchVal* x) const override {
     if (x->defaultState() == nullState) {
-      if (x->jumps().size() == 0) {
+      if (x->jumps().empty()) {
         throw std::runtime_error("Internal error, empty switch statement in primitive match compilation");
       } else {
         throw std::runtime_error("Internal error, switches without default states not supported for primitive match compilation (on switch for " + x->switchVar() + " :: " + show(x->jumps()[0].first->primType()) + " with " + str::from(x->jumps().size()) + " cases)");
       }
     }
 
-    if (x->jumps().size() > 0 && is<Double>(x->jumps().begin()->first)) {
+    if (!x->jumps().empty() && (is<Double>(x->jumps().begin()->first) != nullptr)) {
       llvm::SwitchInst* s = withContext([&](auto&) {
         return this->dfa->c->builder()->CreateSwitch(this->dfa->c->builder()->CreateBitCast(arg(x->switchVar()), longType()), blockForState(x->defaultState()), x->jumps().size());
       });
@@ -1431,7 +1431,7 @@ struct makePrimDFASF : public switchMState<UnitV> {
     return unitv;
   }
 
-  UnitV with(const FinishExpr* x) const {
+  UnitV with(const FinishExpr* x) const override {
     auto ei = this->dfa->exprIdxs.find(x->expr().get());
     if (ei == this->dfa->exprIdxs.end()) {
       throw std::runtime_error("Internal error, primitive match DFA returns non-indexed expression");
@@ -1441,11 +1441,11 @@ struct makePrimDFASF : public switchMState<UnitV> {
     return unitv;
   }
 
-  UnitV with(const LoadVars*) const {
+  UnitV with(const LoadVars*) const override {
     throw std::runtime_error("Internal error, not a primitive match table (load vars)");
   }
 
-  UnitV with(const SwitchVariant*) const {
+  UnitV with(const SwitchVariant*) const override {
     throw std::runtime_error("Internal error, not a primitive match table (switch variant)");
   }
 
@@ -1485,12 +1485,12 @@ llvm::Function* makePrimMatchDFAFunc(const std::string& fname, MDFA* dfa, statei
 
   Args fargs;
   llvm::Function::arg_iterator a = result->arg_begin();
-  for (unsigned int i = 0; i < args.size(); ++i) {
-    if (isUnit(args[i].second)) {
-      fargs[args[i].first] = cvalue(true);
+  for (const auto &arg : args) {
+    if (isUnit(arg.second)) {
+      fargs[arg.first] = cvalue(true);
     } else {
-      a->setName(args[i].first);
-      fargs[args[i].first] = &*a;
+      a->setName(arg.first);
+      fargs[arg.first] = &*a;
       ++a;
     }
   }
@@ -1505,7 +1505,7 @@ class primdfafunc : public op {
 public:
   primdfafunc(llvm::Function* vfn, const PrimFArgs& args) : vfn(vfn) {
     MonoTypes atys;
-    if (args.size() == 0) {
+    if (args.empty()) {
       atys.push_back(MonoTypePtr(Prim::make("unit")));
     } else {
       for (const auto& arg : args) {
@@ -1515,11 +1515,11 @@ public:
     this->ftype = polytype(functy(atys, primty("int")));
   }
 
-  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) {
+  llvm::Value* apply(jitcc* c, const MonoTypes&, const MonoTypePtr&, const Exprs& es) override {
     return withContext([&](auto&) { return fncall(c->builder(), this->vfn, this->vfn->getFunctionType(), compileArgs(c, es)); });
   }
 
-  PolyTypePtr type(typedb&) const {
+  PolyTypePtr type(typedb&) const override {
     return this->ftype;
   }
 private:
@@ -1533,8 +1533,8 @@ void makeCompiledPrimMatchFunction(const std::string& fname, MDFA* dfa, stateidx
 }
 
 // derive a primitive match DFA to run in an interpreted mode, to minimize compilation overhead
-typedef variant<int, long> IDFATransition;
-typedef array< std::pair<long, IDFATransition> > IDFATransitions;
+using IDFATransition = variant<int, long>;
+using IDFATransitions = array<std::pair<long, IDFATransition>>;
 
 struct IDFAState {
   long             reads;
@@ -1560,8 +1560,8 @@ MonoTypePtr dfaStateType() {
   return arrayty(MonoTypePtr(Record::make(dfafns)));
 }
 
-typedef std::unordered_map<std::string, size_t> ArgPos;
-typedef std::unordered_map<size_t, size_t>      GlobalToLocalState;
+using ArgPos = std::unordered_map<std::string, size_t>;
+using GlobalToLocalState = std::unordered_map<size_t, size_t>;
 
 void mapStatesFrom(MDFA* dfa, stateidx_t state, GlobalToLocalState* localstate) {
   if (localstate->find(state) == localstate->end()) {
@@ -1578,7 +1578,7 @@ void mapStatesFrom(MDFA* dfa, stateidx_t state, GlobalToLocalState* localstate)
         throw std::runtime_error("Internal error, primitive DFAs without default states not supported for interpretation");
       }
       mapStatesFrom(dfa, sv->defaultState(), localstate);
-    } else if (!is<FinishExpr>(dfa->states[state])) {
+    } else if (is<FinishExpr>(dfa->states[state]) == nullptr) {
       throw std::runtime_error("Internal error, invalid primitive DFA for interpretation");
     }
   }
@@ -1616,7 +1616,7 @@ void copyStateDef(const ArgPos& argpos, MDFA* dfa, stateidx_t state, const Globa
   const SwitchVal* sv     = is<SwitchVal>(dfa->states[state]);
   size_t           statei = localState(localstate, state);
 
-  if (!sv) {
+  if (sv == nullptr) {
     throw std::runtime_error("Internal error, expected primitive switch for interpreted DFA");
   }
 
@@ -1629,7 +1629,7 @@ void copyStateDef(const ArgPos& argpos, MDFA* dfa, stateidx_t state, const Globa
 }
 
 IDFATransitions* transitions(const ArgPos& argpos, MDFA* dfa, const SwitchVal::Jumps& jmps, const GlobalToLocalState& localstate, std::set<stateidx_t>* dones, array<IDFAState>* dfaStates) {
-  typedef std::map<long, IDFATransition> SortedSVJumps;
+  using SortedSVJumps = std::map<long, IDFATransition>;
 
   SortedSVJumps ssvj;
   for (const auto& jmp : jmps) {
@@ -1641,7 +1641,7 @@ IDFATransitions* transitions(const ArgPos& argpos, MDFA* dfa, const SwitchVal::J
   }
 
   size_t msz = sizeof(long) + (ssvj.size() * sizeof(std::pair<long, IDFATransition>));
-  IDFATransitions* result = reinterpret_cast<IDFATransitions*>(malloc(msz));
+  auto* result = reinterpret_cast<IDFATransitions*>(malloc(msz));
   memset(reinterpret_cast<void*>(result), 0, msz);
   result->size = ssvj.size();
   size_t i = 0;
@@ -1687,7 +1687,7 @@ void makeInterpretedPrimMatchFunction(const std::string& fname, MDFA* dfa, state
 
   // construct the DFA description in a consumable format
   size_t msz = sizeof(long) + (localstate.size() + sizeof(IDFAState));
-  array<IDFAState>* dfaStates = reinterpret_cast<array<IDFAState>*>(malloc(msz));
+  auto* dfaStates = reinterpret_cast<array<IDFAState>*>(malloc(msz));
   memset(reinterpret_cast<void*>(dfaStates), 0, msz);
   dfaStates->size = localstate.size();
 
diff --git a/lib/hobbes/lang/pat/pattern.C b/lib/hobbes/lang/pat/pattern.C
index bc4071271..0f1ef1eed 100644
--- a/lib/hobbes/lang/pat/pattern.C
+++ b/lib/hobbes/lang/pat/pattern.C
@@ -22,7 +22,7 @@ void Pattern::name(const std::string& x) {
 }
 
 // match literal (constant) values
-MatchLiteral::MatchLiteral(const PrimitivePtr& proxy, const LexicalAnnotation& la) : Base(la), p(proxy), e() {
+MatchLiteral::MatchLiteral(const PrimitivePtr& proxy, const LexicalAnnotation& la) : Base(la), p(proxy) {
 }
 
 MatchLiteral::MatchLiteral(const PrimitivePtr& proxy, const ExprPtr& value, const LexicalAnnotation& la) : Base(la), p(proxy), e(value) {
@@ -36,7 +36,7 @@ void MatchLiteral::show(std::ostream& out) const {
 }
 
 bool MatchLiteral::operator==(const Pattern& rhs) const {
-  if (const MatchLiteral* lrhs = is<MatchLiteral>(&rhs)) {
+  if (const auto* lrhs = is<MatchLiteral>(&rhs)) {
     return *this->p == *lrhs->p;
   } else {
     return false;
@@ -51,7 +51,7 @@ const std::string& MatchAny::value() const { return this->vn; }
 void MatchAny::show(std::ostream& out) const { out << this->vn; }
 
 bool MatchAny::operator==(const Pattern& rhs) const {
-  if (const MatchAny* arhs = is<MatchAny>(&rhs)) {
+  if (const auto* arhs = is<MatchAny>(&rhs)) {
     return this->vn == arhs->vn;
   } else {
     return false;
@@ -90,7 +90,7 @@ void MatchArray::indexes(const Idxs& idxs) {
 
 void MatchArray::show(std::ostream& out) const {
   out << "[";
-  if (this->ps.size() > 0) {
+  if (!this->ps.empty()) {
     this->ps[0]->show(out);
     for (unsigned int i = 1; i < this->ps.size(); ++i) {
       out << ", ";
@@ -101,8 +101,8 @@ void MatchArray::show(std::ostream& out) const {
 }
 
 bool MatchArray::operator==(const Pattern& rhs) const {
-  const MatchArray* arhs = is<MatchArray>(&rhs);
-  if (!arhs || this->ps.size() != arhs->ps.size()) return false;
+  const auto* arhs = is<MatchArray>(&rhs);
+  if ((arhs == nullptr) || this->ps.size() != arhs->ps.size()) return false;
 
   for (unsigned int i = 0; i < this->ps.size(); ++i) {
     if (!(*this->ps[i] == *arhs->ps[i])) {
@@ -141,7 +141,7 @@ void MatchRegex::show(std::ostream& out) const {
 }
 
 bool MatchRegex::operator==(const Pattern& rhs) const {
-  if (const MatchRegex* trhs = is<MatchRegex>(&rhs)) {
+  if (const auto* trhs = is<MatchRegex>(&rhs)) {
     return text() == trhs->text();
   }
   return false;
@@ -208,7 +208,7 @@ void MatchRecord::fields(const Fields& fs) {
 
 void MatchRecord::show(std::ostream& out) const {
   out << "{";
-  if (this->fs.size() > 0) {
+  if (!this->fs.empty()) {
     show(out, this->fs[0]);
     for (unsigned int i = 1; i < this->fs.size(); ++i) {
       out << ", ";
@@ -223,8 +223,8 @@ void MatchRecord::show(std::ostream& out, const Field& f) {
 }
 
 bool MatchRecord::operator==(const Pattern& rhs) const {
-  const MatchRecord* rrhs = hobbes::is<MatchRecord>(&rhs);
-  if (!rrhs || this->fs.size() != rrhs->fs.size()) return false;
+  const auto* rrhs = hobbes::is<MatchRecord>(&rhs);
+  if ((rrhs == nullptr) || this->fs.size() != rrhs->fs.size()) return false;
 
   for (unsigned int i = 0; i < this->fs.size(); ++i) {
     if (this->fs[i].first != rrhs->fs[i].first) {
@@ -254,7 +254,7 @@ void MatchVariant::show(std::ostream& out) const {
 }
 
 bool MatchVariant::operator==(const Pattern& rhs) const {
-  if (const MatchVariant* vrhs = is<MatchVariant>(&rhs)) {
+  if (const auto* vrhs = is<MatchVariant>(&rhs)) {
     return this->lbl == vrhs->lbl && *this->p == *vrhs->p;
   } else {
     return false;
@@ -296,7 +296,7 @@ std::string show(const PatternPtr& p) {
 
 std::string show(const Patterns& ps) {
   std::ostringstream ss;
-  if (ps.size() > 0) {
+  if (!ps.empty()) {
     ps[0]->show(ss);
     for (size_t i = 1; i < ps.size(); ++i) {
       ss << " ";
@@ -317,7 +317,7 @@ std::string show(const PatternRow& pr) {
 // allow incomplete sets of field patterns in record cells by expanding all such cases to 'match any' patterns for unnamed fields
 void normalizeRecPatterns(MatchRecord* r, const std::set<std::string>& fnames) {
   MatchRecord::Fields nfs = r->fields();
-  for (auto f : setDifference(fnames, toSet(first(r->fields())))) {
+  for (const auto& f : setDifference(fnames, toSet(first(r->fields())))) {
     nfs.push_back(MatchRecord::Field(f, PatternPtr(new MatchAny(freshName(), r->la()))));
   }
   r->fields(nfs);
@@ -325,13 +325,13 @@ void normalizeRecPatterns(MatchRecord* r, const std::set<std::string>& fnames) {
 
 void normalizeRecPatterns(const Patterns& ps, const std::set<std::string>& fnames) {
   for (const auto& p : ps) {
-    if (MatchRecord* r = is<MatchRecord>(p)) {
+    if (auto* r = is<MatchRecord>(p)) {
       normalizeRecPatterns(r, fnames);
     }
   }
 }
 
-typedef std::map<std::string, Patterns> NamedPatternGroups;
+using NamedPatternGroups = std::map<std::string, Patterns>;
 
 NamedPatternGroups groupRecordPatterns(const Patterns& ps) {
   NamedPatternGroups r;
@@ -369,9 +369,9 @@ Patterns concatArrayPatterns(const Patterns& ps) {
 }
 
 void normalizeRecAccess(const Patterns& ps) {
-  if (ps.size() == 0) {
+  if (ps.empty()) {
     // nothing to normalize
-  } else if (is<MatchRecord>(ps[0])) {
+  } else if (is<MatchRecord>(ps[0]) != nullptr) {
     // this is actually the case we care about
     // first recursively normalize within each field's pattern
     auto gs = groupRecordPatterns(ps);
@@ -381,9 +381,9 @@ void normalizeRecAccess(const Patterns& ps) {
 
     // then normalize within patterns
     normalizeRecPatterns(ps, keys(gs));
-  } else if (is<MatchArray>(ps[0])) {
+  } else if (is<MatchArray>(ps[0]) != nullptr) {
     normalizeRecAccess(concatArrayPatterns(ps));
-  } else if (is<MatchVariant>(ps[0])) {
+  } else if (is<MatchVariant>(ps[0]) != nullptr) {
     for (const auto& g : groupVariantPatterns(ps)) {
       normalizeRecAccess(g.second);
     }
@@ -400,7 +400,7 @@ bool canHoldRecPatterns(const PatternPtr& p) {
       }
     }
     return true;
-  } else if (is<MatchLiteral>(p) || is<MatchRegex>(p)) {
+  } else if ((is<MatchLiteral>(p) != nullptr) || (is<MatchRegex>(p) != nullptr)) {
     // prim matches obviously can't contain record patterns
     return false;
   } else {
@@ -409,24 +409,24 @@ bool canHoldRecPatterns(const PatternPtr& p) {
 }
 
 void normalizeRecAccess(const PatternRows& prs) {
-  size_t maxc = (prs.size() == 0) ? 0 : prs[0].patterns.size();
+  size_t maxc = (prs.empty()) ? 0 : prs[0].patterns.size();
   for (size_t c = 0; c < maxc; ++c) {
     // gather all patterns across this column, normalize record access within the column
     Patterns ps;
 
-    for (size_t r = 0; r < prs.size(); ++r) {
-      const PatternPtr& p = prs[r].patterns[c];
+    for (const auto &pr : prs) {
+      const PatternPtr& p = pr.patterns[c];
 
       // (we can trivially ignore this column if it matches a literal value)
       if (!canHoldRecPatterns(p)) {
         ps.clear();
         break;
-      } else if (!is<MatchAny>(p)) {
+      } else if (is<MatchAny>(p) == nullptr) {
         ps.push_back(p);
       }
     }
 
-    if (ps.size() > 0) {
+    if (!ps.empty()) {
       normalizeRecAccess(ps);
     }
   }
@@ -434,7 +434,7 @@ void normalizeRecAccess(const PatternRows& prs) {
 
 // make sure that the table is "well formed" (all rows have the same number of columns)
 void validateDimensions(size_t c, const PatternRows& ps, const LexicalAnnotation& la) {
-  if (ps.size() == 0) {
+  if (ps.empty()) {
     throw annotated_error(la, "Internal error, pattern sequence cannot be empty");
   } else {
     for (unsigned int i = 0; i < ps.size(); ++i) {
@@ -454,15 +454,15 @@ struct inferTypeF : public switchPattern<MonoTypePtr> {
   MonoTypeUnifier* s;
   inferTypeF(MonoTypeUnifier* s) : s(s) { }
 
-  MonoTypePtr with(const MatchLiteral* v) const {
+  MonoTypePtr with(const MatchLiteral* v) const override {
     return v->equivConstant()->primType();
   }
 
-  MonoTypePtr with(const MatchAny*) const {
+  MonoTypePtr with(const MatchAny*) const override {
     return freshTypeVar();
   }
 
-  MonoTypePtr with(const MatchArray* v) const {
+  MonoTypePtr with(const MatchArray* v) const override {
     if (v->size() == 0) {
       return arrayty(freshTypeVar());
     } else {
@@ -474,11 +474,11 @@ struct inferTypeF : public switchPattern<MonoTypePtr> {
     }
   }
 
-  MonoTypePtr with(const MatchRegex*) const {
+  MonoTypePtr with(const MatchRegex*) const override {
     return arrayty(primty("char"));
   }
 
-  MonoTypePtr with(const MatchRecord* v) const {
+  MonoTypePtr with(const MatchRecord* v) const override {
     Record::Members ms;
     for (size_t i = 0; i < v->size(); ++i) {
       const MatchRecord::Field& f = v->pattern(i);
@@ -487,7 +487,7 @@ struct inferTypeF : public switchPattern<MonoTypePtr> {
     return MonoTypePtr(Record::make(ms));
   }
 
-  MonoTypePtr with(const MatchVariant*) const {
+  MonoTypePtr with(const MatchVariant*) const override {
     // too broad, but for this purpose should be fine
     return freshTypeVar();
   }
@@ -500,8 +500,8 @@ MonoTypes matchRowType(const TEnvPtr& tenv, const PatternRows& ps) {
   // determine the initial row type
   MonoTypes ts;
   const Patterns& pr = ps[0].patterns;
-  for (Patterns::const_iterator p = pr.begin(); p != pr.end(); ++p) {
-    ts.push_back(switchOf(*p, inferTypeF(&u)));
+  for (const auto &p : pr) {
+    ts.push_back(switchOf(p, inferTypeF(&u)));
   }
 
   // unify with subsequent rows
@@ -547,35 +547,35 @@ ExprPtr inLetExp(const str::seq& vns, const Exprs& es, const ExprPtr& b, const L
 struct inferMappingF : public switchPattern<UnitV> {
   VarMapping* vm;
   inferMappingF(VarMapping* vm) : vm(vm) { }
-  UnitV with(const MatchLiteral*) const { return unitv; }
+  UnitV with(const MatchLiteral*) const override { return unitv; }
 
-  UnitV with(const MatchAny* x) const {
+  UnitV with(const MatchAny* x) const override {
     if (x->value() != "_") {
       (*this->vm)[x->value()] = ExprPtr(new Var(x->name(), x->la()));
     }
     return unitv;
   }
 
-  UnitV with(const MatchArray* x) const {
+  UnitV with(const MatchArray* x) const override {
     for (auto i : x->indexes()) {
       switchOf(x->pattern(i), *this);
     }
     return unitv;
   }
 
-  UnitV with(const MatchRegex*) const {
+  UnitV with(const MatchRegex*) const override {
     // regex translation will decide how to conflate binding names
     return unitv;
   }
 
-  UnitV with(const MatchRecord* x) const {
+  UnitV with(const MatchRecord* x) const override {
     for (auto i : x->indexes()) {
       switchOf(x->pattern(i).second, *this);
     }
     return unitv;
   }
 
-  UnitV with(const MatchVariant* x) const {
+  UnitV with(const MatchVariant* x) const override {
     switchOf(x->value(), *this);
     return unitv;
   }
@@ -585,7 +585,7 @@ VarMapping varMapping(const Patterns& ps) {
   // assuming that the input patterns have assigned names,
   // our renaming finds user-names in the input patterns and renames them to assigned names
   VarMapping r;
-  for (auto p : ps) {
+  for (const auto& p : ps) {
     switchOf(p, inferMappingF(&r));
   }
   return r;
@@ -593,23 +593,23 @@ VarMapping varMapping(const Patterns& ps) {
 
 void assignNames(const str::seq& vns, PatternRows& ps, bool* mappedVs) {
   // each row needs to be assigned the same names across columns
-  for (size_t r = 0; r < ps.size(); ++r) {
-    for (size_t c = 0; c < ps[r].patterns.size(); ++c) {
-      ps[r].patterns[c]->name(vns[c]);
+  for (auto &p : ps) {
+    for (size_t c = 0; c < p.patterns.size(); ++c) {
+      p.patterns[c]->name(vns[c]);
     }
   }
 
   // each row expression needs to be renamed consistent with the above name assignment
-  for (size_t r = 0; r < ps.size(); ++r) {
-    VarMapping vm = varMapping(ps[r].patterns);
-    if (vm.size() > 0) {
+  for (auto &p : ps) {
+    VarMapping vm = varMapping(p.patterns);
+    if (!vm.empty()) {
       *mappedVs = true;
 
-      if (ps[r].guard) {
-        ps[r].guard = substitute(vm, ps[r].guard);
+      if (p.guard) {
+        p.guard = substitute(vm, p.guard);
       }
 
-      ps[r].result = substitute(vm, ps[r].result);
+      p.result = substitute(vm, p.result);
     }
   }
 }
@@ -631,7 +631,7 @@ ExprPtr compileMatch(cc* c, const Exprs& es, const PatternRows& ps, const Lexica
 ExprPtr compileMatchTest(cc* c, const ExprPtr& e, const PatternPtr& p, const LexicalAnnotation& rootLA) {
   auto anames = accessibleBindingNames(p);
 
-  if (anames.size() > 0) {
+  if (!anames.empty()) {
     throw annotated_error(*p, "Inaccessible names in 'matches' test: " + str::cdelim(toVector(anames), ", "));
   } else if (!refutable(p)) {
     return ExprPtr(new Bool(true, rootLA));
@@ -644,11 +644,11 @@ ExprPtr compileRegexFn(cc* c, const std::string& regex, const LexicalAnnotation&
   PatternPtr p(new MatchRegex(regex, rootLA));
 
   auto ns = accessibleBindingNames(p);
-  if (ns.size() == 0) {
+  if (ns.empty()) {
     return fn("x", compileMatchTest(c, var("x", rootLA), p, rootLA), rootLA);
   } else {
     MkRecord::FieldDefs fs;
-    for (auto n : ns) {
+    for (const auto& n : ns) {
       fs.push_back(MkRecord::FieldDef(n, var(n, rootLA)));
     }
     return fn("x", compileMatch(c, list(var("x", rootLA)), list(PatternRow(list(p), fncall(var("just", rootLA), mkrecord(fs, rootLA), rootLA)), PatternRow(list(PatternPtr(new MatchAny("_", rootLA))), var("nothing", rootLA))), rootLA), rootLA);
@@ -657,13 +657,13 @@ ExprPtr compileRegexFn(cc* c, const std::string& regex, const LexicalAnnotation&
 
 // a simple test to determine whether or not a pattern can possibly be refuted
 struct refutableP : public switchPattern<bool> {
-  bool with(const MatchLiteral* v) const { return sizeOf(v->equivConstant()->primType()) > 0; } // the only irrefutable literal is unit
-  bool with(const MatchAny*      ) const { return false; }
-  bool with(const MatchArray*    ) const { return true; }
-  bool with(const MatchRegex*    ) const { return true; } // maybe too conservative?  /.*/ is not refutable actually, does it matter?
-  bool with(const MatchVariant*  ) const { return true; }
+  bool with(const MatchLiteral* v) const override { return sizeOf(v->equivConstant()->primType()) > 0; } // the only irrefutable literal is unit
+  bool with(const MatchAny*      ) const override { return false; }
+  bool with(const MatchArray*    ) const override { return true; }
+  bool with(const MatchRegex*    ) const override { return true; } // maybe too conservative?  /.*/ is not refutable actually, does it matter?
+  bool with(const MatchVariant*  ) const override { return true; }
 
-  bool with(const MatchRecord* x) const {
+  bool with(const MatchRecord* x) const override {
     for (auto i : x->indexes()) {
       if (switchOf(x->pattern(i).second, *this)) {
         return true;
@@ -689,36 +689,36 @@ struct accBindingNamesF : public switchPattern<UnitV> {
   str::set* r;
   accBindingNamesF(str::set* r) : r(r) { }
 
-  UnitV with(const MatchLiteral*) const {
+  UnitV with(const MatchLiteral*) const override {
     return unitv;
   }
 
-  UnitV with(const MatchAny* v) const {
-    if (v->value().size() > 0 && v->value() != "_" && v->value()[0] != '.') {
+  UnitV with(const MatchAny* v) const override {
+    if (!v->value().empty() && v->value() != "_" && v->value()[0] != '.') {
       this->r->insert(v->value());
     }
     return unitv;
   }
 
-  UnitV with(const MatchArray* ps) const {
+  UnitV with(const MatchArray* ps) const override {
     for (size_t i = 0; i < ps->size(); ++i) {
       switchOf(ps->pattern(i), *this);
     }
     return unitv;
   }
 
-  UnitV with(const MatchRegex* v) const {
+  UnitV with(const MatchRegex* v) const override {
     auto vbs = bindingNames(v->value());
     this->r->insert(vbs.begin(), vbs.end());
     return unitv;
   }
 
-  UnitV with(const MatchVariant* v) const {
+  UnitV with(const MatchVariant* v) const override {
     switchOf(v->value(), *this);
     return unitv;
   }
 
-  UnitV with(const MatchRecord* ps) const {
+  UnitV with(const MatchRecord* ps) const override {
     for (auto i : ps->indexes()) {
       switchOf(ps->pattern(i).second, *this);
     }
@@ -748,7 +748,7 @@ ExprPtr rpatFunc(cc* c, const PatternPtr& pat, const ExprPtr& cond, const ExprPt
 }
 
 ExprPtr conjoinConds(const Exprs& es, const LexicalAnnotation& la) {
-  if (es.size() == 0) {
+  if (es.empty()) {
     return constant(bool(true), la);
   } else {
     ExprPtr c = es[0];
@@ -761,8 +761,8 @@ ExprPtr conjoinConds(const Exprs& es, const LexicalAnnotation& la) {
 
 ExprPtr desugarComprehension(cc* c, const ExprPtr& e, const CSelection& cs, const LexicalAnnotation& la) {
   if (refutable(cs.pat)) {
-    return fncall(var("ffilterMMap", la), list(rpatFunc(c, cs.pat, cs.conds.size() > 0 ? conjoinConds(cs.conds, la) : ExprPtr(), e, la), cs.seq), la);
-  } else if (cs.conds.size() > 0) {
+    return fncall(var("ffilterMMap", la), list(rpatFunc(c, cs.pat, !cs.conds.empty() ? conjoinConds(cs.conds, la) : ExprPtr(), e, la), cs.seq), la);
+  } else if (!cs.conds.empty()) {
     return fncall(var("ffilterMap", la), list(irpatFunc(c, cs.pat, conjoinConds(cs.conds, la), la), irpatFunc(c, cs.pat, e, la), cs.seq), la);
   } else {
     return fncall(var("fmap", la), list(irpatFunc(c, cs.pat, e, la), cs.seq), la);
@@ -770,7 +770,7 @@ ExprPtr desugarComprehension(cc* c, const ExprPtr& e, const CSelection& cs, cons
 }
 
 Expr* desugarComprehension(cc* c, const ExprPtr& ex, const CSelections& cs, const LexicalAnnotation& la) {
-  if (cs.size() == 0) {
+  if (cs.empty()) {
     return ex->clone();
   } else {
     ExprPtr e = desugarComprehension(c, ex, *cs[cs.size()-1], la);
diff --git a/lib/hobbes/lang/pat/print.C b/lib/hobbes/lang/pat/print.C
index c7763c90a..d83915b21 100644
--- a/lib/hobbes/lang/pat/print.C
+++ b/lib/hobbes/lang/pat/print.C
@@ -26,7 +26,7 @@ void printMatchExp(std::ostream& out, const ExprPtr& e) {
 void printMatchResult(const std::string& indent, std::ostream& out, const ExprPtr& e) {
   if (const Let* le = is<Let>(e)) {
     out << indent << "let " << le->var() << " = ";
-    if (is<Fn>(le->varExpr())) {
+    if (is<Fn>(le->varExpr()) != nullptr) {
       out << "\n";
       printMatchResult(indent + "  ", out, le->varExpr());
       out << indent;
@@ -70,7 +70,7 @@ void printMatchResult(const std::string& indent, std::ostream& out, const ExprPt
     out << indent << "switch (";
     printMatchExp(out, sw->expr());
     out << ") {\n";
-    for (auto b : sw->bindings()) {
+    for (const auto& b : sw->bindings()) {
       out << indent;
       b.value->show(out);
       out << " =>\n";
@@ -92,7 +92,7 @@ void printMatchResult(std::ostream& out, const ExprPtr& e) {
 
 // pretty-print a pattern match table
 void printMatchTable(std::ostream& out, const PatternRows& prs) {
-  if (prs.size() == 0) {
+  if (prs.empty()) {
     out << "{}";
   } else {
     str::seqs ps;
diff --git a/lib/hobbes/lang/pat/regex.C b/lib/hobbes/lang/pat/regex.C
index 2f8a808d5..02b28b6cb 100644
--- a/lib/hobbes/lang/pat/regex.C
+++ b/lib/hobbes/lang/pat/regex.C
@@ -5,6 +5,7 @@
 #include <hobbes/util/str.H>
 #include <hobbes/util/rmap.H>
 
+#include <memory>
 #include <queue>
 
 namespace hobbes {
@@ -13,11 +14,11 @@ namespace hobbes {
  * parse regular expressions into an AST
  ******************/
 
-typedef uint8_t rchar_t;
+using rchar_t = uint8_t;
 
 // epsilon / the empty string
 struct REps : public Regex {
-  void show(std::ostream& out) const { out << "`"; }
+  void show(std::ostream& out) const override { out << "`"; }
 };
 
 // a range of chars [b,e] (inclusive)
@@ -25,7 +26,7 @@ struct RCharRange : public Regex {
   rchar_t b, e;
   RCharRange(rchar_t b, rchar_t e) : b(b), e(e) { }
 
-  void show(std::ostream& out) const {
+  void show(std::ostream& out) const override {
     if (this->b == this->e) {
       out << this->b;
     } else if (this->b == rchar_t(0) && this->e == rchar_t(255)) {
@@ -41,7 +42,7 @@ struct RStar : public Regex {
   RegexPtr v;
   RStar(const RegexPtr& v) : v(v) { }
 
-  void show(std::ostream& out) const { this->v->show(out); out << "*"; }
+  void show(std::ostream& out) const override { this->v->show(out); out << "*"; }
 };
 
 // A|B (either match A, or match B)
@@ -50,7 +51,7 @@ struct REither : public Regex {
   RegexPtr rhs;
   REither(const RegexPtr& lhs, const RegexPtr& rhs) : lhs(lhs), rhs(rhs) { }
 
-  void show(std::ostream& out) const { this->lhs->show(out); out << "|"; this->rhs->show(out); }
+  void show(std::ostream& out) const override { this->lhs->show(out); out << "|"; this->rhs->show(out); }
 };
 
 // AB (match A, then match B)
@@ -59,7 +60,7 @@ struct RSeq : public Regex {
   RegexPtr rhs;
   RSeq(const RegexPtr& lhs, const RegexPtr& rhs) : lhs(lhs), rhs(rhs) { }
 
-  void show(std::ostream& out) const { this->lhs->show(out); this->rhs->show(out); }
+  void show(std::ostream& out) const override { this->lhs->show(out); this->rhs->show(out); }
 };
 
 // (?<x>E) (match E, bind the substring to a variable "x")
@@ -68,7 +69,7 @@ struct RBind : public Regex {
   RegexPtr    def;
   RBind(const std::string& var, const RegexPtr& def) : var(var), def(def) { }
 
-  void show(std::ostream& out) const {
+  void show(std::ostream& out) const override {
     out << "(?<" << this->var << ">";
     this->def->show(out);
     out << ")";
@@ -145,7 +146,7 @@ RegexPtr sequence(const RegexPtr& p0, const RegexPtr& p1) {
 }
 
 RegexPtr anyOf(const Regexes& rs) {
-  if (rs.size() == 0) {
+  if (rs.empty()) {
     return epsilon();
   } else {
     RegexPtr a = rs[0];
@@ -156,11 +157,11 @@ RegexPtr anyOf(const Regexes& rs) {
   }
 }
 
-typedef std::pair<rchar_t, rchar_t> CharRange;
-typedef std::vector<CharRange> CharRanges;
+using CharRange = std::pair<rchar_t, rchar_t>;
+using CharRanges = std::vector<CharRange>;
 
 CharRanges toRanges(const std::set<rchar_t>& cs) {
-  if (cs.size() == 0) {
+  if (cs.empty()) {
     return CharRanges();
   } else {
     auto ci = cs.begin();
@@ -207,17 +208,17 @@ RegexPtr unescapePatChar(rchar_t x) {
 }
 
 // read char sets
-typedef std::pair<size_t, std::set<rchar_t>> DCharset;
+using DCharset = std::pair<size_t, std::set<rchar_t>>;
 
 void charRange(rchar_t i, rchar_t e, std::set<rchar_t>* out) {
-  for (size_t x = static_cast<size_t>(i); x <= static_cast<size_t>(e); ++x) {
+  for (auto x = static_cast<size_t>(i); x <= static_cast<size_t>(e); ++x) {
     out->insert(static_cast<rchar_t>(x));
   }
 }
 
 const std::set<rchar_t>& anyChars() {
   static std::set<rchar_t> r;
-  if (r.size() == 0) {
+  if (r.empty()) {
     charRange(0x00, 0xff, &r);
   }
   return r;
@@ -250,7 +251,7 @@ DCharset readCharset(const std::string& x, size_t i) {
 }
 
 // parse a complete regex
-typedef std::pair<size_t, RegexPtr> DRegex;
+using DRegex = std::pair<size_t, RegexPtr>;
 DRegex diffRegex(const RegexPtr& lhs, const std::string& x, size_t i);
 
 DRegex returnR(const std::string& x, size_t k, const RegexPtr& r) {
@@ -348,21 +349,21 @@ struct bnamesF : public switchRegex<UnitV> {
 
   bnamesF(str::set* bnames) : bnames(bnames) { }
 
-  UnitV with(const REps*) const { return unitv; }
-  UnitV with(const RCharRange*) const { return unitv; }
-  UnitV with(const RStar* x) const { return switchOf(x->v, *this); }
+  UnitV with(const REps*) const override { return unitv; }
+  UnitV with(const RCharRange*) const override { return unitv; }
+  UnitV with(const RStar* x) const override { return switchOf(x->v, *this); }
 
-  UnitV with(const REither* x) const {
+  UnitV with(const REither* x) const override {
     switchOf(x->lhs, *this);
     return switchOf(x->rhs, *this);
   }
 
-  UnitV with(const RSeq* x) const {
+  UnitV with(const RSeq* x) const override {
     switchOf(x->lhs, *this);
     return switchOf(x->rhs, *this);
   }
 
-  UnitV with(const RBind* x) const {
+  UnitV with(const RBind* x) const override {
     this->bnames->insert(x->var);
     return switchOf(x->def, *this);
   }
@@ -377,10 +378,10 @@ str::seq bindingNames(const RegexPtr& rgx) {
 /******************************
  * translate the regex AST to an NFA
  ******************************/
-typedef uint32_t state;
-typedef std::set<state> stateset;
+using state = uint32_t;
+using stateset = std::set<state>;
 
-typedef uint32_t result;
+using result = uint32_t;
 static const result nullResult = static_cast<result>(-1);
 
 struct char_range_ord {
@@ -407,9 +408,9 @@ struct char_range_ord {
   }
 };
 
-typedef range_map<rchar_t, stateset, char_range_ord> ntransitions;
+using ntransitions = range_map<rchar_t, stateset, char_range_ord>;
 
-typedef std::map<result, str::set> srcmarkers;
+using srcmarkers = std::map<result, str::set>;
 
 struct NFAState {
   // transitions to successor states
@@ -424,7 +425,7 @@ struct NFAState {
   void beginMark(result r, const std::string& m) { this->begins[r].insert(m); }
   void endMark  (result r, const std::string& m) {   this->ends[r].insert(m); }
 };
-typedef std::vector<NFAState> NFA;
+using NFA = std::vector<NFAState>;
 
 // for a given set of NFA states, find the set of non-overlapping char ranges
 CharRanges usedCharRanges(const NFA& nfa, const stateset& ss) {
@@ -452,23 +453,23 @@ struct linkStateF : public switchRegex<UnitV> {
 
   state ins(const RegexPtr& p) const { return regexBefore(p, this->succ, this->id, this->nfa); }
 
-  UnitV with(const REps*) const {
+  UnitV with(const REps*) const override {
     s().eps.insert(this->succ);
     return unitv;
   }
 
-  UnitV with(const RCharRange* x) const {
+  UnitV with(const RCharRange* x) const override {
     s().chars.mergeRange(x->b, x->e, [&](stateset& ss){ ss.insert(this->succ); });
     return unitv;
   }
 
-  UnitV with(const RStar* x) const {
+  UnitV with(const RStar* x) const override {
     switchOf(x->v, linkStateF(this->nfa, this->self, this->self, this->id));
     s().eps.insert(this->succ);
     return unitv;
   }
 
-  UnitV with(const REither* x) const {
+  UnitV with(const REither* x) const override {
     state lstate = ins(x->lhs);
     state rstate = ins(x->rhs);
     s().eps.insert(lstate);
@@ -476,13 +477,13 @@ struct linkStateF : public switchRegex<UnitV> {
     return unitv;
   }
 
-  UnitV with(const RSeq* x) const {
+  UnitV with(const RSeq* x) const override {
     state rstate = ins(x->rhs);
     switchOf(x->lhs, linkStateF(this->nfa, this->self, rstate, this->id));
     return unitv;
   }
 
-  UnitV with(const RBind* x) const {
+  UnitV with(const RBind* x) const override {
     s().beginMark(this->id, x->var);
     switchOf(x->def, *this);
     s(this->succ).endMark(this->id, x->var);
@@ -518,7 +519,7 @@ std::set<rchar_t> usedChars(const NFA& nfa) {
  *****************************/
 std::string descStates(const stateset& ss) {
   std::ostringstream out;
-  if (ss.size() > 0) {
+  if (!ss.empty()) {
     auto s = ss.begin();
     out << *s;
     ++s;
@@ -606,9 +607,9 @@ void print(std::ostream& out, const NFA& nfa) {
 /**********************
  * find eps* for an NFA
  **********************/
-typedef std::map<state, stateset> EpsClosure;
+using EpsClosure = std::map<state, stateset>;
 
-typedef std::vector<bool> statemarks;
+using statemarks = std::vector<bool>;
 
 void findEpsClosure(const NFA& nfa, state s, statemarks* sms, EpsClosure* ec) {
   if (!(*sms)[s]) {
@@ -683,7 +684,7 @@ void print(std::ostream& out, const EpsClosure& ec) {
 /**********************
  * convert an NFA to a DFA
  **********************/
-typedef range_map<rchar_t, state, char_range_ord> dtransitions;
+using dtransitions = range_map<rchar_t, state, char_range_ord>;
 struct DFAState {
   dtransitions chars;
 
@@ -693,7 +694,7 @@ struct DFAState {
   // markers to begin and end recording subranges
   srcmarkers begins, ends;
 };
-typedef std::vector<DFAState> DFA;
+using DFA = std::vector<DFAState>;
 
 void insert(stateset* o, const stateset& i) {
   o->insert(i.begin(), i.end());
@@ -711,7 +712,7 @@ stateset nfaTransition(const NFA& nfa, const EpsClosure& ec, const stateset& ss,
 }
 
 // sets of NFA states are mapped to distinct DFA states
-typedef std::map<stateset, state> Nss2Ds;
+using Nss2Ds = std::map<stateset, state>;
 
 // create a DFA state from a set of NFA states
 // (or if it's already been made, just return the existing state)
@@ -932,7 +933,7 @@ static ExprPtr transitionMapping(const std::string& fname, const DFAState& s, co
   //   else use a sequence of range tests
   auto rtns = s.chars.mapping();
 
-  if (rtns.size() == 0) {
+  if (rtns.empty()) {
     // shouldn't happen, but it's the right thing to do
     return defaultResult;
   } else if (rtns.size() == 1 && rtns[0].first.first == 0 && rtns[0].first.second == 255) {
@@ -974,8 +975,8 @@ void makeExprDFAFunc(cc* c, const std::string& fname, const MonoTypePtr& capture
   //   ...
   Switch::Bindings bs;
   MonoTypePtr arrT = freshTypeVar();
-  QualTypePtr qarrElemTy = qualtype(list(ConstraintPtr(new Constraint("Array", list(arrT, primty("char"))))), functy(list(arrT, primty("long")), primty("char")));
-  QualTypePtr qarrT = qualtype(list(ConstraintPtr(new Constraint("Array", list(arrT, primty("char"))))), arrT);
+  QualTypePtr qarrElemTy = qualtype(list(std::make_shared<Constraint>("Array", list(arrT, primty("char")))), functy(list(arrT, primty("long")), primty("char")));
+  QualTypePtr qarrT = qualtype(list(std::make_shared<Constraint>("Array", list(arrT, primty("char")))), arrT);
 
   for (size_t s = 0; s < dfa.size(); ++s) {
     // all transitions out of this state
@@ -1046,9 +1047,9 @@ void makeExprDFAFunc(cc* c, const std::string& fname, const MonoTypePtr& capture
   c->define(fname, assume(fndef, qualtype(qarrT->constraints(), functy(list(captureTy, arrT, primty("long"), primty("long"), primty("int")), primty("int"))), rootLA));
 }
 
-typedef std::pair<char,char>  CRange;
-typedef std::pair<CRange,int> CTransition;
-typedef array<CTransition>    CTransitions;
+using CRange = std::pair<char, char>;
+using CTransition = std::pair<CRange, int>;
+using CTransitions = array<CTransition>;
 
 DEFINE_STRUCT(
   DFAStateRep,
@@ -1057,7 +1058,7 @@ DEFINE_STRUCT(
 );
 
 array<DFAStateRep>* makeDFARep(cc* c, const DFA& dfa) {
-  auto result = c->makeArray<DFAStateRep>(dfa.size());
+  auto *result = c->makeArray<DFAStateRep>(dfa.size());
   for (size_t i = 0; i < dfa.size(); ++i) {
     DFAStateRep& s = result->data[i];
     auto ctnm = dfa[i].chars.mapping();
@@ -1074,8 +1075,8 @@ array<DFAStateRep>* makeDFARep(cc* c, const DFA& dfa) {
 
 void makeInterpDFAFunc(cc* c, const std::string& fname, const MonoTypePtr& captureTy, const DFA& dfa, const LexicalAnnotation& rootLA) {
   MonoTypePtr arrT = freshTypeVar();
-  QualTypePtr qarrElemTy = qualtype(list(ConstraintPtr(new Constraint("Array", list(arrT, primty("char"))))), functy(list(arrT, primty("long")), primty("char")));
-  QualTypePtr qarrT = qualtype(list(ConstraintPtr(new Constraint("Array", list(arrT, primty("char"))))), arrT);
+  QualTypePtr qarrElemTy = qualtype(list(std::make_shared<Constraint>("Array", list(arrT, primty("char")))), functy(list(arrT, primty("long")), primty("char")));
+  QualTypePtr qarrT = qualtype(list(std::make_shared<Constraint>("Array", list(arrT, primty("char")))), arrT);
 
   std::string regexDFADef = ".regexDFA." + freshName();
   c->bind(regexDFADef, makeDFARep(c, dfa));
@@ -1125,9 +1126,9 @@ void mergeCharRangesAndEqResults(DFA* dfa, const RStates& fstates, RStates* rsta
 /**************************
  * compress a DFA by merging equivalent states
  **************************/
-typedef std::map<state, state> EqStates;
+using EqStates = std::map<state, state>;
 
-void visitGraph(const std::vector<std::vector<state>>& g, state m, std::vector<bool>& visited, std::function<void(state)> visitFn) {
+void visitGraph(const std::vector<std::vector<state>>& g, state m, std::vector<bool>& visited, const std::function<void(state)>& visitFn) {
   std::queue<state> q;
 
   q.push(m);
@@ -1263,7 +1264,7 @@ MonoTypePtr regexCaptureBufferType(const Regexes& regexes) {
       ms.push_back(Record::Member(str::from(r) + "_end_"   + b, primty("long")));
     }
   }
-  return ms.size() == 0 ? primty("unit") : MonoTypePtr(Record::make(ms));
+  return ms.empty() ? primty("unit") : MonoTypePtr(Record::make(ms));
 }
 
 ExprPtr makeRegexCaptureBuffer(const Regexes& regexes, const LexicalAnnotation& rootLA) {
diff --git a/lib/hobbes/lang/preds/appendsto.C b/lib/hobbes/lang/preds/appendsto.C
index 8bab3e614..32106173b 100644
--- a/lib/hobbes/lang/preds/appendsto.C
+++ b/lib/hobbes/lang/preds/appendsto.C
@@ -35,12 +35,12 @@ void AppendsToUnqualifier::addEliminator(const std::shared_ptr<ATEliminator>& at
 }
 
 ATEliminator* AppendsToUnqualifier::findEliminator(const TEnvPtr& tenv, const AppendsTo* at) const {
-  for (ATEliminators::const_iterator ate = this->eliminators.begin(); ate != this->eliminators.end(); ++ate) {
-    if ((*ate)->satisfiable(tenv, at->leftType, at->rightType, at->resultType)) {
-      return ate->get();
+  for (const auto &eliminator : this->eliminators) {
+    if (eliminator->satisfiable(tenv, at->leftType, at->rightType, at->resultType)) {
+      return eliminator.get();
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool AppendsToUnqualifier::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions*) {
@@ -65,7 +65,7 @@ bool AppendsToUnqualifier::satisfied(const TEnvPtr& tenv, const ConstraintPtr& c
 
 bool AppendsToUnqualifier::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions*) const {
   AppendsTo at;
-  return dec(cst, &at) && findEliminator(tenv, &at) != 0;
+  return dec(cst, &at) && findEliminator(tenv, &at) != nullptr;
 }
 
 void AppendsToUnqualifier::explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
@@ -82,8 +82,8 @@ ExprPtr AppendsToUnqualifier::unqualify(const TEnvPtr& tenv, const ConstraintPtr
 }
 
 PolyTypePtr AppendsToUnqualifier::lookup(const std::string& vn) const {
-  for (ATEliminators::const_iterator ate = this->eliminators.begin(); ate != this->eliminators.end(); ++ate) {
-    PolyTypePtr ty = (*ate)->lookup(vn);
+  for (const auto &eliminator : this->eliminators) {
+    PolyTypePtr ty = eliminator->lookup(vn);
     if (ty != PolyTypePtr()) {
       return ty;
     }
@@ -93,8 +93,8 @@ PolyTypePtr AppendsToUnqualifier::lookup(const std::string& vn) const {
 
 SymSet AppendsToUnqualifier::bindings() const {
   SymSet result;
-  for (ATEliminators::const_iterator ate = this->eliminators.begin(); ate != this->eliminators.end(); ++ate) {
-    SymSet x = (*ate)->bindings();
+  for (const auto &eliminator : this->eliminators) {
+    SymSet x = eliminator->bindings();
     result.insert(x.begin(), x.end());
   }
   return result;
diff --git a/lib/hobbes/lang/preds/appendsto/record.C b/lib/hobbes/lang/preds/appendsto/record.C
index 43ed1da2e..33fd1382d 100644
--- a/lib/hobbes/lang/preds/appendsto/record.C
+++ b/lib/hobbes/lang/preds/appendsto/record.C
@@ -1,7 +1,8 @@
 
 #include <hobbes/lang/preds/appendsto/record.H>
-#include <hobbes/lang/typeinf.H>
 #include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/typeinf.H>
+#include <memory>
 #include <sstream>
 
 namespace hobbes {
@@ -11,7 +12,7 @@ namespace hobbes {
 #define REF_REC_SUFFIX "recordSuffix"
 
 bool isRecordLike(const MonoTypePtr& mt) {
-  return is<Record>(mt) || isUnit(mt);
+  return (is<Record>(mt) != nullptr) || isUnit(mt);
 }
 
 const Record::Members& recordMembers(const MonoTypePtr& mt) {
@@ -30,19 +31,19 @@ bool isTupleLike(const std::string& fname) {
 }
 
 bool isTupleLike(const Record::Members& ms) {
-  return ms.size() > 0 && isTupleLike(ms[0].field);
+  return !ms.empty() && isTupleLike(ms[0].field);
 }
 
 bool isTupleLike(const MkRecord::FieldDefs& fds) {
-  return fds.size() > 0 && isTupleLike(fds[0].first);
+  return !fds.empty() && isTupleLike(fds[0].first);
 }
 
 Record::Members tupleNormalize(const Record::Members& ms) {
   if (isTupleLike(ms)) {
     Record::Members result;
     size_t i = 0;
-    for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-      result.push_back(Record::Member(".f" + str::from(i++), m->type, m->offset));
+    for (const auto &m : ms) {
+      result.push_back(Record::Member(".f" + str::from(i++), m.type, m.offset));
     }
     return result;
   } else {
@@ -54,8 +55,8 @@ MkRecord::FieldDefs tupleNormalize(const MkRecord::FieldDefs& fds) {
   if (isTupleLike(fds)) {
     MkRecord::FieldDefs result;
     size_t i = 0;
-    for (MkRecord::FieldDefs::const_iterator fd = fds.begin(); fd != fds.end(); ++fd) {
-      result.push_back(MkRecord::FieldDef(".f" + str::from(i++), fd->second));
+    for (const auto &fd : fds) {
+      result.push_back(MkRecord::FieldDef(".f" + str::from(i++), fd.second));
     }
     return result;
   } else {
@@ -64,7 +65,7 @@ MkRecord::FieldDefs tupleNormalize(const MkRecord::FieldDefs& fds) {
 }
 
 MonoTypePtr makeRecordType(const Record::Members& ms) {
-  if (ms.size() == 0) {
+  if (ms.empty()) {
     static MonoTypePtr u(Prim::make("unit"));
     return u;
   } else {
@@ -73,7 +74,7 @@ MonoTypePtr makeRecordType(const Record::Members& ms) {
 }
 
 ExprPtr makeRecord(const MkRecord::FieldDefs& fds, const LexicalAnnotation& la) {
-  if (fds.size() == 0) {
+  if (fds.empty()) {
     return mktunit(la);
   } else {
     return mkrecord(tupleNormalize(fds), la);
@@ -87,8 +88,8 @@ ExprPtr makeRecord(const MkRecord::FieldDefs& fds, const LexicalAnnotation& la)
 }
 
 void importDefs(const Record::Members& ms, Record::Members* out) {
-  for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    out->push_back(Record::Member(m->field, m->type));
+  for (const auto &m : ms) {
+    out->push_back(Record::Member(m.field, m.type));
   }
 }
 
@@ -162,7 +163,7 @@ bool ATRecordEliminator::satisfied(const TEnvPtr&, const MonoTypePtr& lhs, const
 }
 
 void checkSatisfiable(const MonoTypePtr& ty) {
-  if (!isRecordLike(ty) && !is<TVar>(ty)) {
+  if (!isRecordLike(ty) && (is<TVar>(ty) == nullptr)) {
     throw std::runtime_error("Not eligible for record-append relationship: " + show(ty));
   }
 }
@@ -213,11 +214,11 @@ bool ATRecordEliminator::refine(const TEnvPtr& tenv, const MonoTypePtr& lhs, con
 
 PolyTypePtr ATRecordEliminator::lookup(const std::string& vn) const {
   if (vn == REF_REC_APPEND) {
-    return polytype(3, qualtype(list(ConstraintPtr(new Constraint(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2))))), functy(list(tgen(0), tgen(1)), tgen(2))));
+    return polytype(3, qualtype(list(std::make_shared<Constraint>(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2)))), functy(list(tgen(0), tgen(1)), tgen(2))));
   } else if (vn == REF_REC_PREFIX) {
-    return polytype(3, qualtype(list(ConstraintPtr(new Constraint(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2))))), functy(list(tgen(2)), tgen(0))));
+    return polytype(3, qualtype(list(std::make_shared<Constraint>(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2)))), functy(list(tgen(2)), tgen(0))));
   } else if (vn == REF_REC_SUFFIX) {
-    return polytype(3, qualtype(list(ConstraintPtr(new Constraint(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2))))), functy(list(tgen(2)), tgen(1))));
+    return polytype(3, qualtype(list(std::make_shared<Constraint>(AppendsToUnqualifier::constraintName(), list(tgen(0), tgen(1), tgen(2)))), functy(list(tgen(2)), tgen(1))));
   } else {
     return PolyTypePtr();
   }
@@ -244,11 +245,11 @@ void insertFieldDefsSfx(const MkRecord::FieldDefs& ifds, size_t c, MkRecord::Fie
 }
 
 void insertFieldDefsFromProj(const ExprPtr& rec, const Record* rty, MkRecord::FieldDefs* out) {
-  if (!rty) {
+  if (rty == nullptr) {
     throw annotated_error(*rec, "Internal error, can't insert projections out of non-record type: " + show(rec->type()));
   }
 
-  for (Record::Members::const_iterator m = rty->members().begin(); m != rty->members().end(); ++m) {
+  for (auto m = rty->members().begin(); m != rty->members().end(); ++m) {
     out->push_back(MkRecord::FieldDef(m->field, proj(rec, rty, m->field, rec->la())));
   }
 }
@@ -347,7 +348,7 @@ ExprPtr recordPrefixFunction(const MonoTypePtr& recty, const MonoTypePtr& resty,
 ExprPtr recordPrefix(const ExprPtr& rec, const MonoTypePtr& resty) {
   const Record::Members& ms = recordMembers(resty);
 
-  if (ms.size() == 0) {
+  if (ms.empty()) {
     return mktunit(rec->la());
   } else if (const MkRecord* r = is<MkRecord>(rec)) {
     MkRecord::FieldDefs fds;
@@ -374,7 +375,7 @@ ExprPtr recordSuffixFunction(const MonoTypePtr& recty, const MonoTypePtr& resty,
 ExprPtr recordSuffix(const ExprPtr& rec, const MonoTypePtr& resty) {
   const Record::Members& ms = recordMembers(resty);
 
-  if (ms.size() == 0) {
+  if (ms.empty()) {
     return mktunit(rec->la());
   } else if (const MkRecord* r = is<MkRecord>(rec)) {
     MkRecord::FieldDefs fds;
@@ -401,13 +402,13 @@ struct ATRecordUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Var* vn) const {
+  ExprPtr with(const Var* vn) const override {
     if (vn->value() == REF_REC_APPEND) {
       return recordAppendFunction(this->appto.leftType, this->appto.rightType, this->appto.resultType, vn->la());
     } else if (vn->value() == REF_REC_PREFIX) {
@@ -419,7 +420,7 @@ struct ATRecordUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr with(const App* ap) const {
+  ExprPtr with(const App* ap) const override {
     if (const Var* fn = is<Var>(stripAssumpHead(ap->fn()))) {
       if (fn->value() == REF_REC_APPEND) {
         return recordAppendExpr(switchOf(ap->args()[0], *this), switchOf(ap->args()[1], *this));
diff --git a/lib/hobbes/lang/preds/class.C b/lib/hobbes/lang/preds/class.C
index 4cb979b46..30432782f 100644
--- a/lib/hobbes/lang/preds/class.C
+++ b/lib/hobbes/lang/preds/class.C
@@ -1,17 +1,18 @@
 
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/expr.H>
-#include <hobbes/lang/tyunqualify.H>
+#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/lang/typepreds.H>
+#include <hobbes/lang/tyunqualify.H>
 #include <hobbes/util/array.H>
 #include <hobbes/util/codec.H>
 #include <hobbes/util/perf.H>
+#include <memory>
 
 namespace hobbes {
 
 inline bool isHiddenTCName(const std::string& n) {
-  return n.size() == 0 || n[0] == '.';
+  return n.empty() || n[0] == '.';
 }
 
 FunDeps mergeFundeps(const FunDeps& lhs, const FunDeps& rhs) {
@@ -46,7 +47,7 @@ FunDeps inferFundeps(const TEnvPtr& tenv, const Constraints& cs) {
     UnqualifierPtr uq = tenv->lookupUnqualifier(c);
 
     FunDeps cdeps = uq->dependencies(c);
-    for (auto cdep : cdeps) {
+    for (const auto& cdep : cdeps) {
       includeFundep(*c, cdep, &result);
     }
   }
@@ -112,18 +113,18 @@ void TClass::insert(const TCInstanceFnPtr& ifp) {
     std::ostringstream ss;
     size_t errors = 0;
     for (const auto& tcm : this->tcmembers) {
-      if (!mm.count(tcm.first)) {
-        ss << (errors?", ":"") << "expected definition of '" << tcm.first << "'";
+      if (mm.count(tcm.first) == 0u) {
+        ss << (errors != 0u?", ":"") << "expected definition of '" << tcm.first << "'";
         ++errors;
       }
     }
     for (const auto& m : mm) {
-      if (!this->tcmembers.count(m.first)) {
-        ss << (errors?", ":"") << "unexpected definition of '" << m.first << "'";
+      if (this->tcmembers.count(m.first) == 0u) {
+        ss << (errors != 0u?", ":"") << "unexpected definition of '" << m.first << "'";
         ++errors;
       }
     }
-    if (errors) {
+    if (errors != 0u) {
       std::ostringstream ess;
       ess << "Can't introduce instance generator for '" << this->tcname << "': " << ss.str();
       throw annotated_error(*ifp, ess.str());
@@ -166,7 +167,7 @@ TCInstances TClass::matches(const TEnvPtr& tenv, const MonoTypes& mts, MonoTypeU
 
   // if no ground instances match, can we generate a ground instance to match?
   //  (this can only work when we can feed back derived type information)
-  if (r.size() == 0) {
+  if (r.empty()) {
     this->testedInstances.insert(mts, true);
 
     TCInstanceFns ifns;
@@ -179,7 +180,7 @@ TCInstances TClass::matches(const TEnvPtr& tenv, const MonoTypes& mts, MonoTypeU
         const_cast<TClass*>(this)->insert(tenv, ninst, ds);
         r.push_back(ninst);
         break;
-      } else if (ninst.get()) {
+      } else if (ninst.get() != nullptr) {
         r.push_back(ninst);
         break;
       }
@@ -206,8 +207,8 @@ bool TClass::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifi
   }
 
   // apply refinement across all fundeps
-  for (FunDeps::const_iterator fd = this->fundeps.begin(); fd != this->fundeps.end(); ++fd) {
-    r |= refine(tenv, cst, *fd, s, ds);
+  for (const auto &fundep : this->fundeps) {
+    r |= refine(tenv, cst, fundep, s, ds);
   }
   return r;
 }
@@ -230,7 +231,7 @@ bool TClass::refine(const TEnvPtr& tenv, const ConstraintPtr& c, const FunDep& f
 }
 
 bool isLiteralFnTerm(const ExprPtr& e) {
-  return is<Fn>(stripAssumpHead(e));
+  return is<Fn>(stripAssumpHead(e)) != nullptr;
 }
 
 bool TClass::satisfied(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const {
@@ -250,7 +251,7 @@ bool TClass::satisfied(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions*
   }
 
   // finally see if we can get an instance
-  return matches(tenv, c->arguments(), 0, ds).size() == 1;
+  return matches(tenv, c->arguments(), nullptr, ds).size() == 1;
 }
 
 bool TClass::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const {
@@ -265,7 +266,7 @@ bool TClass::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definition
   }
 
   // for empty class definitions, assume allow constraint usage before definitions
-  if (this->tcinstdb.values().size() == 0 && this->tcinstancefns.size() == 0) {
+  if (this->tcinstdb.values().empty() && this->tcinstancefns.empty()) {
     return true;
   }
 
@@ -335,7 +336,7 @@ void TClass::explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPt
       Constraints scs;
       fcs.clear();
       f->explainSatisfiability(tenv, mts, ds, &scs, &fcs);
-      if (scs.size() > maxSuccCount && fcs.size() > 0) {
+      if (scs.size() > maxSuccCount && !fcs.empty()) {
         maxSuccCount = scs.size();
         likelyTarget = f;
       }
@@ -359,7 +360,7 @@ void TClass::explain(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPt
 
 ExprPtr TClass::unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const {
   // we can unqualify iff there's one (ONE!) matching instance for this constraint
-  TCInstances tis = matches(tenv, cst, 0, ds);
+  TCInstances tis = matches(tenv, cst, nullptr, ds);
   if (tis.size() != 1) {
     throw annotated_error(*e, "Cannot unqualify ambiguous or unsatisfiable predicate: " + hobbes::show(cst));
   } else {
@@ -368,16 +369,16 @@ ExprPtr TClass::unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const E
 }
 
 PolyTypePtr TClass::lookup(const std::string& vn) const {
-  Members::const_iterator m = this->tcmembers.find(vn);
+  auto m = this->tcmembers.find(vn);
   if (m != this->tcmembers.end()) {
-    return PolyTypePtr(new PolyType(this->typeVars(), qualtype(list(ConstraintPtr(new Constraint(this->name(), tgens(this->typeVars())))), m->second)));
+    return std::make_shared<PolyType>(this->typeVars(), qualtype(list(std::make_shared<Constraint>(this->name(), tgens(this->typeVars()))), m->second));
   } else {
     return PolyTypePtr();
   }
 }
 
 MonoTypePtr TClass::memberType(const std::string& vn) const {
-  Members::const_iterator m = this->tcmembers.find(vn);
+  auto m = this->tcmembers.find(vn);
   if (m != this->tcmembers.end()) {
     return m->second;
   } else {
@@ -387,8 +388,8 @@ MonoTypePtr TClass::memberType(const std::string& vn) const {
 
 SymSet TClass::bindings() const {
   SymSet r;
-  for (Members::const_iterator m = this->tcmembers.begin(); m != this->tcmembers.end(); ++m) {
-    r.insert(m->first);
+  for (const auto &tcmember : this->tcmembers) {
+    r.insert(tcmember.first);
   }
   return r;
 }
@@ -406,7 +407,7 @@ void showFundep(const FunDep& fd, std::ostream& out) {
 
 void TClass::show(std::ostream& out) const {
   out << "class ";
-  if (this->reqs.size() > 0) {
+  if (!this->reqs.empty()) {
     out << "(";
     this->reqs[0]->show(out);
     for (size_t i = 1; i < this->reqs.size(); ++i) {
@@ -416,7 +417,7 @@ void TClass::show(std::ostream& out) const {
     out << ") => ";
   }
   out << this->tcname;
-  if (this->fundeps.size() > 0) {
+  if (!this->fundeps.empty()) {
     out << " | ";
     showFundep(this->fundeps[0], out);
     for (size_t i = 1; i < this->fundeps.size(); ++i) {
@@ -425,8 +426,8 @@ void TClass::show(std::ostream& out) const {
     }
   }
   out << " where\n";
-  for (Members::const_iterator m = this->tcmembers.begin(); m != this->tcmembers.end(); ++m) {
-    out << "  " << m->first << " :: " << hobbes::show(m->second) << "\n";
+  for (const auto &tcmember : this->tcmembers) {
+    out << "  " << tcmember.first << " :: " << hobbes::show(tcmember.second) << "\n";
   }
 }
 
@@ -435,7 +436,7 @@ const TCInstances& TClass::instances() const {
 }
 
 bool TClass::hasGroundInstanceAt(const MonoTypes& mts) const {
-  return this->tcinstdb.lookup(mts) != 0;
+  return this->tcinstdb.lookup(mts) != nullptr;
 }
 
 const TCInstanceFns& TClass::instanceFns() const {
@@ -466,7 +467,7 @@ bool TCInstance::hasMapping(const std::string& oname) const {
 }
 
 const TCInstance::ExprPtr& TCInstance::memberMapping(const std::string& oname) const {
-  MemberMapping::const_iterator mm = this->mmap.find(oname);
+  auto mm = this->mmap.find(oname);
   if (mm != this->mmap.end()) {
     return mm->second;
   } else {
@@ -485,13 +486,13 @@ struct TCUnqualify : public switchExprTyFn {
   const ConstraintPtr& constraint;
   TCUnqualify(const TCInstance* inst, Definitions* ds, const TEnvPtr& tenv, const ConstraintPtr& constraint) : inst(inst), ds(ds), tenv(tenv), constraint(constraint) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     // if we can resolve this symbol as an overload, replace it
-    MemberMapping::const_iterator mm = inst->memberMapping().find(v->value());
+    auto mm = inst->memberMapping().find(v->value());
 
     if (mm != inst->memberMapping().end() && hasConstraint(this->constraint, v->type())) {
       return mm->second;
@@ -503,8 +504,8 @@ struct TCUnqualify : public switchExprTyFn {
 
 // resolve member definitions ahead of time, so that we can just substitute into use-sites
 void TCInstance::bind(const TEnvPtr& tenv, const TClass* c, Definitions* ds) {
-  for (MemberMapping::iterator mm = this->mmap.begin(); mm != this->mmap.end(); ++mm) {
-    mm->second = unqualifyTypes(tenv, validateType(tenv, assume(mm->second, instantiate(this->itys, c->memberType(mm->first)), mm->second->la()), ds), ds);
+  for (auto &mm : this->mmap) {
+    mm.second = unqualifyTypes(tenv, validateType(tenv, assume(mm.second, instantiate(this->itys, c->memberType(mm.first)), mm.second->la()), ds), ds);
   }
 }
 
@@ -514,8 +515,8 @@ ExprPtr TCInstance::unqualify(Definitions* ds, const TEnvPtr& tenv, const Constr
 
 void TCInstance::show(std::ostream& out) const {
   out << "instance " << this->tcname << " " << str::cdelim(hobbes::show(this->itys), " ") << " where\n";
-  for (MemberMapping::const_iterator mm = this->mmap.begin(); mm != this->mmap.end(); ++mm) {
-    out << "  " << mm->first << " = " << hobbes::show(mm->second) << "\n";
+  for (const auto &mm : this->mmap) {
+    out << "  " << mm.first << " = " << hobbes::show(mm.second) << "\n";
   }
 }
 
@@ -531,7 +532,7 @@ size_t TCInstanceFn::arity() const {
   return this->itys.size();
 }
 
-bool TCInstanceFn::satisfiable(const TEnvPtr& tenv, const MonoTypes& tys, Definitions* rdefs) {
+bool TCInstanceFn::satisfiable(const TEnvPtr& tenv, const MonoTypes& tys, Definitions* rdefs) const {
   // immediately reject arity mismatch (though this should never happen)
   if (this->itys.size() != tys.size()) {
     return false;
@@ -570,7 +571,7 @@ bool TCInstanceFn::satisfiable(const TEnvPtr& tenv, const MonoTypes& tys, Defini
   return true;
 }
 
-void TCInstanceFn::explainSatisfiability(const TEnvPtr& tenv, const MonoTypes& tys, Definitions* rdefs, Constraints* scs, Constraints* fcs) {
+void TCInstanceFn::explainSatisfiability(const TEnvPtr& tenv, const MonoTypes& tys, Definitions* rdefs, Constraints* scs, Constraints* fcs) const {
   if (this->itys.size() != tys.size()) {
     return;
   }
@@ -658,7 +659,7 @@ bool TCInstanceFn::apply(const TEnvPtr& tenv, const MonoTypes& tys, const TClass
   // we've definitely found a complete match
   // merge local bindings to the nested unifier scope
   MonoTypeSubst ms = u.substitution();
-  if (ms.size() > 0 && callsubst) {
+  if (!ms.empty() && (callsubst != nullptr)) {
     for (const auto& m : ms) {
       callsubst->bind(m.first, m.second);
     }
@@ -694,7 +695,7 @@ bool TCInstanceFn::apply(const TEnvPtr& tenv, const MonoTypes& tys, const TClass
   }
 
   // that's it, we've got a new ground type class instance
-  *out = TCInstancePtr(new TCInstance(this->tcname, nitys, mm, la()));
+  *out = std::make_shared<TCInstance>(this->tcname, nitys, mm, la());
   return true;
 }
 
@@ -729,8 +730,8 @@ MonoTypes TCInstanceFn::instantiatedArgs(MonoTypeUnifier* s, const MonoTypes& ty
 
 MemberMapping TCInstanceFn::members(const MonoTypeSubst& s) const {
   MemberMapping result;
-  for (MemberMapping::const_iterator mm = this->mmap.begin(); mm != this->mmap.end(); ++mm) {
-    result[mm->first] = substitute(s, mm->second);
+  for (const auto &mm : this->mmap) {
+    result[mm.first] = substitute(s, mm.second);
   }
   return result;
 }
@@ -782,7 +783,7 @@ void definePrivateClass(const TEnvPtr& tenv, const std::string& memberName, cons
   MemberMapping mm;
   mm[memberName] = expr;
 
-  nclass->insert(TCInstanceFnPtr(new TCInstanceFn(tcname, Constraints(), gtvars, mm, expr->la())));
+  nclass->insert(std::make_shared<TCInstanceFn>(tcname, Constraints(), gtvars, mm, expr->la()));
 
   tenv->bind(tcname, nclass);
 }
@@ -790,12 +791,12 @@ void definePrivateClass(const TEnvPtr& tenv, const std::string& memberName, cons
 // reverse "hidden" type classes to get the original set of constraints
 Constraints expandHiddenTCs(const TEnvPtr& tenv, const Constraints& cs) {
   Constraints r;
-  for (auto c : cs) {
+  for (const auto& c : cs) {
     if (!isHiddenTCName(c->name())) {
       r.push_back(c);
     } else {
       auto uq = tenv->lookupUnqualifier(c->name());
-      if (const TClass* cc = dynamic_cast<const TClass*>(uq.get())) {
+      if (const auto* cc = dynamic_cast<const TClass*>(uq.get())) {
         Constraints ncs = expandHiddenTCs(tenv, instantiate(c->arguments(), cc->constraints()));
         r.insert(r.end(), ncs.begin(), ncs.end());
       } else {
@@ -809,22 +810,22 @@ Constraints expandHiddenTCs(const TEnvPtr& tenv, const Constraints& cs) {
 
 const TClass* findClass(const TEnvPtr& tenv, const std::string& cname) {
   UnqualifierPtr uq = tenv->lookupUnqualifier(cname);
-  if (uq.get() == 0) {
+  if (uq.get() == nullptr) {
     throw std::runtime_error("No such type class: " + cname);
   }
-  const TClass* c = dynamic_cast<const TClass*>(uq.get());
-  if (!c) {
+  const auto* c = dynamic_cast<const TClass*>(uq.get());
+  if (c == nullptr) {
     throw std::runtime_error("Not a type class: " + cname);
   }
   return c;
 }
 
 bool isClassSatisfied(const TEnvPtr& tenv, const std::string& cname, const MonoTypes& tys, Definitions* ds) {
-  return findClass(tenv, cname)->satisfied(tenv, ConstraintPtr(new Constraint(cname, tys)), ds);
+  return findClass(tenv, cname)->satisfied(tenv, std::make_shared<Constraint>(cname, tys), ds);
 }
 
 bool isClassSatisfiable(const TEnvPtr& tenv, const std::string& cname, const MonoTypes& tys, Definitions* ds) {
-  return findClass(tenv, cname)->satisfiable(tenv, ConstraintPtr(new Constraint(cname, tys)), ds);
+  return findClass(tenv, cname)->satisfiable(tenv, std::make_shared<Constraint>(cname, tys), ds);
 }
 
 ExprPtr unqualifyClass(const TEnvPtr& tenv, const std::string& cname, const MonoTypes& tys, const ExprPtr& e, Definitions* ds) {
@@ -874,18 +875,18 @@ void serializeGroundInstance(const TEnvPtr&, const TClass*, const TCInstancePtr&
 
 void serializeGroundInstances(const TEnvPtr& tenv, const TClass* c, const TCInstances& insts, std::ostream& out) {
   encode(insts.size(), out);
-  for (TCInstances::const_iterator inst = insts.begin(); inst != insts.end(); ++inst) {
-    serializeGroundInstance(tenv, c, *inst, out);
+  for (const auto &inst : insts) {
+    serializeGroundInstance(tenv, c, inst, out);
   }
 }
 
-typedef std::vector<const TClass*> Classes;
+using Classes = std::vector<const TClass *>;
 
 void serializeGroundClasses(const TEnvPtr& tenv, const Classes& cs, std::ostream& out) {
   encode(cs.size(), out);
-  for (Classes::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    encode((*c)->name(), out);
-    serializeGroundInstances(tenv, *c, (*c)->instances(), out);
+  for (const auto *c : cs) {
+    encode(c->name(), out);
+    serializeGroundInstances(tenv, c, c->instances(), out);
   }
 }
 
@@ -893,9 +894,9 @@ void serializeGroundClasses(const TEnvPtr& tenv, std::ostream& out) {
   const TEnv::Unqualifiers& uqs = tenv->unqualifiers();
   Classes cs;
 
-  for (TEnv::Unqualifiers::const_iterator uq = uqs.begin(); uq != uqs.end(); ++uq) {
-    if (const TClass* c = dynamic_cast<const TClass*>(uq->second.get())) {
-      if (c->instances().size() > 0) {
+  for (const auto &uq : uqs) {
+    if (const auto* c = dynamic_cast<const TClass*>(uq.second.get())) {
+      if (!c->instances().empty()) {
         cs.push_back(c);
       }
     }
@@ -914,11 +915,11 @@ void deserializeGroundClasses(const TEnvPtr& tenv, std::istream& in, Definitions
     std::string cname;
     decode(&cname, in);
 
-    TClass* c = 0;
+    TClass* c = nullptr;
     try {
       c = dynamic_cast<TClass*>(tenv->lookupUnqualifier(cname).get());
     } catch (std::exception&) {
-      c = 0;
+      c = nullptr;
     }
 
     size_t ic = 0;
@@ -931,9 +932,9 @@ void deserializeGroundClasses(const TEnvPtr& tenv, std::istream& in, Definitions
       MemberMapping mm;
       decode(&mm, in);
 
-      if (c) {
+      if (c != nullptr) {
         if (!c->hasGroundInstanceAt(mts)) {
-          c->insert(tenv, TCInstancePtr(new TCInstance(cname, mts, mm, c->la())), ds);
+          c->insert(tenv, std::make_shared<TCInstance>(cname, mts, mm, c->la()), ds);
         }
       }
     }
diff --git a/lib/hobbes/lang/preds/consrecord.C b/lib/hobbes/lang/preds/consrecord.C
index d6abaab5d..ba3a630a1 100644
--- a/lib/hobbes/lang/preds/consrecord.C
+++ b/lib/hobbes/lang/preds/consrecord.C
@@ -1,11 +1,12 @@
 
+#include <hobbes/lang/expr.H>
+#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/preds/consrecord.H>
 #include <hobbes/lang/preds/hasfield.H>
-#include <hobbes/lang/preds/class.H>
-#include <hobbes/lang/expr.H>
 #include <hobbes/lang/tylift.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -57,7 +58,7 @@ static bool dec(const ConstraintPtr& c, ConsRecord* cr) {
         cr->tailType      = c->arguments()[5];
 
         if (const Record* r = is<Record>(cr->recordType)) {
-          if (r->members().size() > 0) {
+          if (!r->members().empty()) {
             auto lpfx = r->members()[r->members().size()-1].field.substr(0,2);
 
             if (lpfx != ".p" && ((lpfx != ".f" && cr->asTuple) || (lpfx == ".f" && !cr->asTuple))) {
@@ -81,7 +82,7 @@ bool RecordDeconstructor::refine(const TEnvPtr&, const ConstraintPtr& cst, MonoT
   ConsRecord cr;
   if (dec(cst, &cr)) {
     if (const Record* rty = is<Record>(cr.recordType)) {
-      if (rty->members().size() > 0) {
+      if (!rty->members().empty()) {
         MonoTypePtr fname(TString::make(rty->headMember().field));
 
         mgu(fname,                  cr.headFieldName, u);
@@ -119,12 +120,12 @@ bool RecordDeconstructor::satisfied(const TEnvPtr&, const ConstraintPtr& cst, De
   }
 
   const TString* fname = is<TString>(cr.headFieldName);
-  if (!fname) {
+  if (fname == nullptr) {
     return false;
   }
 
   const Record* rty = is<Record>(cr.recordType);
-  if (!rty) {
+  if (rty == nullptr) {
     return false;
   }
   if (cr.asTuple != rty->isTuple()) {
@@ -132,18 +133,18 @@ bool RecordDeconstructor::satisfied(const TEnvPtr&, const ConstraintPtr& cst, De
   }
 
   const Record* tty = is<Record>(cr.tailType);
-  if (!tty && !isUnit(cr.tailType)) {
+  if ((tty == nullptr) && !isUnit(cr.tailType)) {
     return false;
   }
 
   if (cr.asTuple) {
-    if (tty) {
+    if (tty != nullptr) {
       return *stripHiddenFields(rty) == *stripHiddenFields(Record::make(cr.headType, tty->members()));
     } else {
       return *rty->headMember().type == *cr.headType;
     }
   } else {
-    if (tty) {
+    if (tty != nullptr) {
       return *stripHiddenFields(rty) == *stripHiddenFields(Record::make(fname->value(), cr.headType, tty->members()));
     } else {
       return rty->headMember().field == fname->value() && *rty->headMember().type == *cr.headType;
@@ -154,7 +155,7 @@ bool RecordDeconstructor::satisfied(const TEnvPtr&, const ConstraintPtr& cst, De
 bool RecordDeconstructor::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   ConsRecord cr;
   if (dec(cst, &cr)) {
-    return satisfied(tenv, cst, ds) || is<TVar>(cr.recordType) || is<TVar>(cr.headFieldName) || (is<Record>(cr.recordType) && (is<TVar>(cr.headType) || is<TVar>(cr.tailType)));
+    return satisfied(tenv, cst, ds) || (is<TVar>(cr.recordType) != nullptr) || (is<TVar>(cr.headFieldName) != nullptr) || ((is<Record>(cr.recordType) != nullptr) && ((is<TVar>(cr.headType) != nullptr) || (is<TVar>(cr.tailType) != nullptr)));
   } else {
     return false;
   }
@@ -165,13 +166,13 @@ void RecordDeconstructor::explain(const TEnvPtr&, const ConstraintPtr&, const Ex
 
 PolyTypePtr RecordDeconstructor::lookup(const std::string& vn) const {
   if (vn == REF_REC_LABEL) {
-    return polytype(4, qualtype(list(ConstraintPtr(new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3))))), functy(list(tgen(0)), arrayty(prim<char>()))));
+    return polytype(4, qualtype(list(std::make_shared<Constraint>(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3)))), functy(list(tgen(0)), arrayty(prim<char>()))));
   } else if (vn == REF_REC_VALUE) {
-    return polytype(4, qualtype(list(ConstraintPtr(new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3))))), functy(list(tgen(0)), tgen(2))));
+    return polytype(4, qualtype(list(std::make_shared<Constraint>(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3)))), functy(list(tgen(0)), tgen(2))));
   } else if (vn == REF_REC_TAIL) {
-    return polytype(4, qualtype(list(ConstraintPtr(new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3))))), functy(list(tgen(0)), tgen(3))));
+    return polytype(4, qualtype(list(std::make_shared<Constraint>(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), tgen(0), tgen(1), tgen(2), tgen(3)))), functy(list(tgen(0)), tgen(3))));
   } else if (vn == REF_TUP_TAIL) {
-    return polytype(4, qualtype(list(ConstraintPtr(new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(1), tgen(0), tgen(1), tgen(2), tgen(3))))), functy(list(tgen(0)), tgen(3))));
+    return polytype(4, qualtype(list(std::make_shared<Constraint>(RecordDeconstructor::constraintName(), list(tlong(1), tlong(1), tgen(0), tgen(1), tgen(2), tgen(3)))), functy(list(tgen(0)), tgen(3))));
   } else {
     return PolyTypePtr();
   }
@@ -226,11 +227,11 @@ struct RDUnqualify : public switchExprTyFn {
     }
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     if (hasConstraint(this->constraint, v->left()->type())) {
       if (const App* a = is<App>(stripAssumps(v->left()))) {
         if (const Var* f = is<Var>(stripAssumps(a->fn()))) {
@@ -250,7 +251,7 @@ struct RDUnqualify : public switchExprTyFn {
     return wrapWithTy(v->type(), new Assign(switchOf(v->left(), *this), switchOf(v->right(), *this), v->la()));
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       // replace safe functions with 'unsafe' ones
       if (v->value() == REF_REC_LABEL) {
diff --git a/lib/hobbes/lang/preds/consvariant.C b/lib/hobbes/lang/preds/consvariant.C
index aed47dbce..01b8418f4 100644
--- a/lib/hobbes/lang/preds/consvariant.C
+++ b/lib/hobbes/lang/preds/consvariant.C
@@ -1,10 +1,11 @@
 
-#include <hobbes/lang/preds/consvariant.H>
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/consvariant.H>
 #include <hobbes/lang/tylift.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -62,7 +63,7 @@ bool VariantDeconstructor::refine(const TEnvPtr&, const ConstraintPtr& cst, Mono
   ConsVariant cv;
   if (dec(cst, &cv)) {
     if (const Variant* vty = is<Variant>(cv.variantType)) {
-      if (vty->members().size() > 0) {
+      if (!vty->members().empty()) {
         size_t uc = u->size();
         mgu(tstring(vty->headMember().selector), cv.headCtorName, u);
         mgu(vty->headMember().type,              cv.headType, u);
@@ -91,7 +92,7 @@ bool VariantDeconstructor::satisfied(const TEnvPtr&, const ConstraintPtr& cst, D
   ConsVariant cv;
   if (dec(cst, &cv)) {
     if (const Variant* vty = is<Variant>(cv.variantType)) {
-      return (vty->members().size() > 0)                                &&
+      return (!vty->members().empty())                                &&
              (*cv.headCtorName == *tstring(vty->headMember().selector)) &&
              (*cv.headType == *vty->headMember().type)                  &&
              (*normalizeCtorIDs(cv.tailType) == *normalizeCtorIDs(vty->tailType()));
@@ -107,8 +108,8 @@ bool VariantDeconstructor::satisfiable(const TEnvPtr& tenv, const ConstraintPtr&
   ConsVariant cv;
   if (dec(cst, &cv)) {
     return satisfied(tenv, cst, ds) ||
-           is<TVar>(cv.variantType) ||
-           (is<Variant>(cv.variantType) && (is<TVar>(cv.headCtorName) || is<TVar>(cv.headType) || is<TVar>(cv.tailType)));
+           (is<TVar>(cv.variantType) != nullptr) ||
+           ((is<Variant>(cv.variantType) != nullptr) && ((is<TVar>(cv.headCtorName) != nullptr) || (is<TVar>(cv.headType) != nullptr) || (is<TVar>(cv.tailType) != nullptr)));
   } else {
     return false;
   }
@@ -120,13 +121,13 @@ void VariantDeconstructor::explain(const TEnvPtr&, const ConstraintPtr&, const E
 PolyTypePtr VariantDeconstructor::lookup(const std::string& vn) const {
   if (vn == REF_VAR_LABEL) {
     // variantHeadLabel :: (v=|a+vt|) => v -> [char]
-    return polytype(4, qualtype(list(ConstraintPtr(new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3))))), functy(list(tgen(0)), arrayty(prim<char>()))));
+    return polytype(4, qualtype(list(std::make_shared<Constraint>(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3)))), functy(list(tgen(0)), arrayty(prim<char>()))));
   } else if (vn == REF_VAR_SPLIT) {
     // variantSplit :: (v=|a+vt|) => (v, closure a c, closure vt c) -> c
     return
       polytype(5,
         qualtype(
-          list(ConstraintPtr(new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3))))),
+          list(std::make_shared<Constraint>(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3)))),
           functy(list(tgen(0), closty(list(tgen(2)), tgen(4)), closty(list(tgen(3)), tgen(4))), tgen(4))
         )
       );
@@ -135,7 +136,7 @@ PolyTypePtr VariantDeconstructor::lookup(const std::string& vn) const {
     return
       polytype(4,
         qualtype(
-          list(ConstraintPtr(new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3))))),
+          list(std::make_shared<Constraint>(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3)))),
           functy(list(tgen(2)), tgen(0))
         )
       );
@@ -144,7 +145,7 @@ PolyTypePtr VariantDeconstructor::lookup(const std::string& vn) const {
     return
       polytype(4,
         qualtype(
-          list(ConstraintPtr(new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3))))),
+          list(std::make_shared<Constraint>(VariantDeconstructor::constraintName(), list(tlong(1), tgen(0), tgen(1), tgen(2), tgen(3)))),
           functy(list(tgen(3)), tgen(0))
         )
       );
@@ -181,11 +182,11 @@ struct VDUnqualify : public switchExprTyFn {
   const ConstraintPtr& constraint;
   VDUnqualify(const ConstraintPtr& constraint) : constraint(constraint) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       // replace safe functions with 'unsafe' ones
       if (v->value() == REF_VAR_LABEL) {
diff --git a/lib/hobbes/lang/preds/cpptdesc.C b/lib/hobbes/lang/preds/cpptdesc.C
index 589a5298a..e408e71ad 100644
--- a/lib/hobbes/lang/preds/cpptdesc.C
+++ b/lib/hobbes/lang/preds/cpptdesc.C
@@ -1,11 +1,12 @@
 
-#include <hobbes/lang/preds/cpptdesc.H>
 #include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/cpptdesc.H>
 #include <hobbes/lang/typeinf.H>
+#include <memory>
 
 namespace hobbes {
 
-typedef std::vector<std::string> RDefs;
+using RDefs = std::vector<std::string>;
 static void describeCPPTypeMin(std::ostream*, const std::string& tname, const MonoTypePtr& ty, const LexicalAnnotation& la, RDefs*);
 
 struct defineCPPTy : public switchType<UnitV> {
@@ -45,7 +46,7 @@ struct defineCPPTy : public switchType<UnitV> {
   }
   std::string acc(const std::string& pfx, const MonoTypes& ts) const {
     std::ostringstream s;
-    if (ts.size() > 0) {
+    if (!ts.empty()) {
       s << acc(pfx+"_0", ts[0]);
       for (size_t i = 1; i < ts.size(); ++i) {
         s << ", " << acc(pfx+"_"+str::from(i), ts[i]);
@@ -54,7 +55,7 @@ struct defineCPPTy : public switchType<UnitV> {
     return s.str();
   }
 
-  UnitV with(const Prim* v) const {
+  UnitV with(const Prim* v) const override {
     if (v->representation()) {
       *this->out << "DEFINE_TYPE_ALIAS(" << this->tname << ", " << acc(this->tname+"_repr", v->representation()) << ");\n";
     } else {
@@ -63,28 +64,28 @@ struct defineCPPTy : public switchType<UnitV> {
     return unitv;
   }
 
-  UnitV with(const OpaquePtr* v) const {
+  UnitV with(const OpaquePtr* v) const override {
     *this->out << "typedef " << v->name() << (v->storedContiguously() ? "" : "*") << " " << this->tname << ";\n";
     return unitv;
   }
 
-  UnitV with(const TVar*) const {
+  UnitV with(const TVar*) const override {
     throw annotated_error(this->la, "Can't translate type with variables to C++ type.");
   }
 
-  UnitV with(const TGen*) const {
+  UnitV with(const TGen*) const override {
     throw annotated_error(this->la, "Can't translate polymorphic type to C++ type.");
   }
 
-  UnitV with(const TAbs*) const {
+  UnitV with(const TAbs*) const override {
     throw annotated_error(this->la, "Can't translate type abstraction to C++ type.");
   }
 
-  UnitV with(const TApp*) const {
+  UnitV with(const TApp*) const override {
     throw annotated_error(this->la, "Can't translate type application to C++ type.");
   }
 
-  UnitV with(const FixedArray* v) const {
+  UnitV with(const FixedArray* v) const override {
     if (const auto* n = is<TLong>(v->length())) {
       *this->out << "typedef std::array<" << acc(this->tname+"_elem", v->type()) << ", " << n->value() << "> " << this->tname << ";\n";
     } else {
@@ -93,13 +94,13 @@ struct defineCPPTy : public switchType<UnitV> {
     return unitv;
   }
 
-  UnitV with(const Array* v) const {
+  UnitV with(const Array* v) const override {
     *this->out << "typedef hobbes::array<" << acc(this->tname+"_elem", v->type()) << ">* " << this->tname << ";\n";
     return unitv;
   }
 
-  UnitV with(const Variant* v) const {
-    if (v->members().size() == 0) {
+  UnitV with(const Variant* v) const override {
+    if (v->members().empty()) {
       throw annotated_error(this->la, "An empty variant is impossible to construct.");
     } else if (v->isSum()) {
       *this->out << "typedef hobbes::variant<" << acc(this->tname+"_0", v->members()[0].type);
@@ -120,8 +121,8 @@ struct defineCPPTy : public switchType<UnitV> {
     return unitv;
   }
 
-  UnitV with(const Record* v) const {
-    if (v->members().size() == 0) {
+  UnitV with(const Record* v) const override {
+    if (v->members().empty()) {
       *this->out << "typedef hobbes::unit " << this->tname << ";\n";
     } else if (v->isTuple()) {
       if (v->members().size() == 2) {
@@ -146,7 +147,7 @@ struct defineCPPTy : public switchType<UnitV> {
     return unitv;
   }
 
-  UnitV with(const Func* v) const {
+  UnitV with(const Func* v) const override {
     if (const auto* p = is<Prim>(v->result())) {
       if (p->name() == "unit") {
         *this->out << "typedef void (*" << this->tname << ")(" << acc(this->tname, v->parameters()) << ");\n";
@@ -157,23 +158,23 @@ struct defineCPPTy : public switchType<UnitV> {
     return unitv;
   }
 
-  UnitV with(const Exists*) const {
+  UnitV with(const Exists*) const override {
     throw annotated_error(this->la, "Can't translate existential type to C++ type.");
   }
 
-  UnitV with(const Recursive*) const {
+  UnitV with(const Recursive*) const override {
     throw annotated_error(this->la, "Can't translate recursive type to C++ type.");
   }
 
-  UnitV with(const TString*) const {
+  UnitV with(const TString*) const override {
     throw annotated_error(this->la, "Can't translate type string to C++ type.");
   }
 
-  UnitV with(const TLong*) const {
+  UnitV with(const TLong*) const override {
     throw annotated_error(this->la, "Can't translate type number to C++ type.");
   }
 
-  UnitV with(const TExpr*) const {
+  UnitV with(const TExpr*) const override {
     throw annotated_error(this->la, "Can't translate type expression to C++ type.");
   }
 };
@@ -214,7 +215,7 @@ bool CPPTypeDescP::refine(const TEnvPtr&, const ConstraintPtr&, MonoTypeUnifier*
 
 bool CPPTypeDescP::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
   if (cst->arguments().size() == 2 && !hasFreeVariables(cst->arguments()[0])) {
-    return is<TString>(cst->arguments()[0]);
+    return is<TString>(cst->arguments()[0]) != nullptr;
   }
   return false;
 }
@@ -236,11 +237,11 @@ struct CPPTypeDescUnqualify : public switchExprTyFn {
     this->ty    = constraint->arguments()[1];
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* vn) const {
+  ExprPtr with(const Var* vn) const override {
     if (vn->value() == REF_CPPTDESC) {
       return ExprPtr(mkarray(describeCPPType(this->tname, this->ty, vn->la()), vn->la()));
     } else {
@@ -255,7 +256,7 @@ ExprPtr CPPTypeDescP::unqualify(const TEnvPtr&, const ConstraintPtr& cst, const
 
 PolyTypePtr CPPTypeDescP::lookup(const std::string& vn) const {
   if (vn == REF_CPPTDESC) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(CPPTypeDescP::constraintName(), list(tgen(0), tgen(1))))), arrayty(primty("char"))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(CPPTypeDescP::constraintName(), list(tgen(0), tgen(1)))), arrayty(primty("char"))));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/lang/preds/data.C b/lib/hobbes/lang/preds/data.C
index a6ecc9483..6d31e8ebe 100644
--- a/lib/hobbes/lang/preds/data.C
+++ b/lib/hobbes/lang/preds/data.C
@@ -29,7 +29,7 @@ bool DataP::satisfied(const TEnvPtr&, const ConstraintPtr& c, Definitions*) cons
 bool DataP::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions*) const {
   if (c->name() != DataP::constraintName() || c->arguments().size() != 2) {
     return false;
-  } else if (is<TVar>(c->arguments()[0])) {
+  } else if (is<TVar>(c->arguments()[0]) != nullptr) {
     return true;
   } else {
     return unifiable(tenv, repTypeStep(c->arguments()[0]), c->arguments()[1]);
@@ -44,7 +44,7 @@ struct StripCst : public switchExprTyFn {
   StripCst(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/deconstruct.C b/lib/hobbes/lang/preds/deconstruct.C
index e5f52bc5b..7a32514af 100644
--- a/lib/hobbes/lang/preds/deconstruct.C
+++ b/lib/hobbes/lang/preds/deconstruct.C
@@ -9,34 +9,34 @@ std::string DeconstructP::constraintName() {
 }
 
 struct destructType : public switchType<bool> {
-  MonoTypePtr* r = 0;
+  MonoTypePtr* r = nullptr;
   destructType(MonoTypePtr* r) : r(r) { }
 
-  bool with(const Prim*) const {
+  bool with(const Prim*) const override {
     return false;
   }
 
-  bool with(const OpaquePtr*) const {
+  bool with(const OpaquePtr*) const override {
     return false;
   }
 
-  bool with(const TVar*) const {
+  bool with(const TVar*) const override {
     return false;
   }
 
-  bool with(const TGen*) const {
+  bool with(const TGen*) const override {
     return false;
   }
 
-  bool with(const TAbs*) const {
+  bool with(const TAbs*) const override {
     return false;
   }
 
-  bool with(const TApp*) const {
+  bool with(const TApp*) const override {
     return false;
   }
 
-  bool with(const FixedArray* v) const {
+  bool with(const FixedArray* v) const override {
     *this->r = tuplety(list(
       tstring("fixedarray"),
       v->type(),
@@ -45,7 +45,7 @@ struct destructType : public switchType<bool> {
     return false;
   }
 
-  bool with(const Array* v) const {
+  bool with(const Array* v) const override {
     *this->r = tuplety(list(
       tstring("array"),
       v->type()
@@ -53,15 +53,15 @@ struct destructType : public switchType<bool> {
     return true;
   }
 
-  bool with(const Variant*) const {
+  bool with(const Variant*) const override {
     return false;
   }
 
-  bool with(const Record*) const {
+  bool with(const Record*) const override {
     return false;
   }
 
-  bool with(const Func* v) const {
+  bool with(const Func* v) const override {
     auto ps = v->parameters();
 
     *this->r = tuplety(list(
@@ -72,7 +72,7 @@ struct destructType : public switchType<bool> {
     return true;
   }
 
-  bool with(const Exists* v) const {
+  bool with(const Exists* v) const override {
     // again a bit of a hack
     //   exists E.((E,a)->b)*E = (closure a b)
     if (const Record* crec = is<Record>(v->absType())) {
@@ -93,7 +93,7 @@ struct destructType : public switchType<bool> {
     return false;
   }
 
-  bool with(const Recursive* v) const {
+  bool with(const Recursive* v) const override {
     *this->r = tuplety(list(
       tstring("recursive"),
       MonoTypePtr(Recursive::make(v->recTypeName(), v->recType()))
@@ -101,15 +101,15 @@ struct destructType : public switchType<bool> {
     return true;
   }
   
-  bool with(const TString*) const {
+  bool with(const TString*) const override {
     return false;
   }
 
-  bool with(const TLong*) const {
+  bool with(const TLong*) const override {
     return false;
   }
  
-  bool with(const TExpr*) const {
+  bool with(const TExpr*) const override {
     return false;
   }
 };
@@ -120,13 +120,13 @@ static bool asDestruct(const MonoTypePtr& t, MonoTypePtr* dty) {
 
 static bool asRestruct(const MonoTypePtr& t, MonoTypePtr* rty) {
   const Record* r = is<Record>(t);
-  if (!r || !r->isTuple()) return false;
+  if ((r == nullptr) || !r->isTuple()) return false;
 
   const Record::Members& ms = r->members();
-  if (ms.size() == 0) return false;
+  if (ms.empty()) return false;
 
   const TString* ctor = is<TString>(ms[0].type);
-  if (!ctor) return false;
+  if (ctor == nullptr) return false;
 
   if (ctor->value() == "->" && ms.size() == 3) {
     *rty = MonoTypePtr(Func::make(tuplety(list(ms[1].type)), ms[2].type));
@@ -175,7 +175,7 @@ bool DeconstructP::satisfied(const TEnvPtr&, const ConstraintPtr& c, Definitions
     return false;
   }
 
-  if (is<TVar>(c->arguments()[0])) {
+  if (is<TVar>(c->arguments()[0]) != nullptr) {
     return false;
   } else {
     MonoTypePtr dty, rty;
@@ -192,7 +192,7 @@ bool DeconstructP::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Defi
     return false;
   }
 
-  if (is<TVar>(c->arguments()[0]) || is<TVar>(c->arguments()[1])) {
+  if ((is<TVar>(c->arguments()[0]) != nullptr) || (is<TVar>(c->arguments()[1]) != nullptr)) {
     return true;
   } else {
     return satisfied(tenv, c, ds);
@@ -207,7 +207,7 @@ struct StripCst : public switchExprTyFn {
   StripCst(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/equal.C b/lib/hobbes/lang/preds/equal.C
index 0b6b60f57..5b4dc84bf 100644
--- a/lib/hobbes/lang/preds/equal.C
+++ b/lib/hobbes/lang/preds/equal.C
@@ -43,7 +43,7 @@ struct StripEqCst : public switchExprTyFn {
   StripEqCst(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/hasctor.C b/lib/hobbes/lang/preds/hasctor.C
index f90272511..af6247058 100644
--- a/lib/hobbes/lang/preds/hasctor.C
+++ b/lib/hobbes/lang/preds/hasctor.C
@@ -33,7 +33,7 @@ HCEliminator* CtorVerifier::findEliminator(const TEnvPtr& tenv, const HasCtor& h
       return hce.get();
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool CtorVerifier::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions* ds) {
@@ -58,7 +58,7 @@ bool CtorVerifier::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Defi
 
 bool CtorVerifier::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   HasCtor hc;
-  return dec(cst, &hc) && findEliminator(tenv, hc, ds);
+  return dec(cst, &hc) && (findEliminator(tenv, hc, ds) != nullptr);
 }
 
 void CtorVerifier::explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
@@ -71,11 +71,11 @@ struct RewriteMSelect : public switchExprTyFn {
 
   RewriteMSelect(const HasCtor& hc, const ConstraintPtr& cst) : hc(hc), cst(cst) {
     const TString* fn = is<TString>(hc.ctorlbl);
-    if (!fn) { throw std::runtime_error("Internal error, invalid hasctor constraint for unqualification"); }
+    if (fn == nullptr) { throw std::runtime_error("Internal error, invalid hasctor constraint for unqualification"); }
     this->ctor = fn->value();
   }
 
-  ExprPtr with(const App* ap) const {
+  ExprPtr with(const App* ap) const override {
     if (ap->args().size() == 1) {
       if (hasConstraint(this->cst, ap->type())) {
         if (const Var* f = is<Var>(stripAssumpHead(ap->fn()))) {
@@ -90,7 +90,7 @@ struct RewriteMSelect : public switchExprTyFn {
     return wrapWithTy(ap->type(), new App(switchOf(ap->fn(), *this), switchOf(ap->args(), *this), ap->la()));
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->cst, v->type())) {
       if (v->value() == MSELECT_CTOR_FN) {
         std::string vn = freshName();
@@ -122,7 +122,7 @@ PolyTypePtr CtorVerifier::lookup(const std::string& vn) const {
   if (vn == MSELECT_CTOR_FN) {
     // select either the given constructor payload from a variant, or nothing
     // :: (|c/p|::v) => v -> (()+p)
-    return polytype(3, qualtype(list(ConstraintPtr(new Constraint(CtorVerifier::constraintName(), list(tgen(0), tgen(1), tgen(2))))), functy(list(tgen(0)), maybety(tgen(2)))));
+    return polytype(3, qualtype(list(std::make_shared<Constraint>(CtorVerifier::constraintName(), list(tgen(0), tgen(1), tgen(2)))), functy(list(tgen(0)), maybety(tgen(2)))));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/lang/preds/hasctor/variant.C b/lib/hobbes/lang/preds/hasctor/variant.C
index 703540e48..2edc09eb3 100644
--- a/lib/hobbes/lang/preds/hasctor/variant.C
+++ b/lib/hobbes/lang/preds/hasctor/variant.C
@@ -38,12 +38,12 @@ bool HCVariantEliminator::satisfiable(const TEnvPtr& tenv, const HasCtor& hc, De
   if (const Variant* vty = isMaybeNestedVariant(hc.variant)) {
     if (const TString* fname = is<TString>(hc.ctorlbl)) {
       const Variant::Member* vm = vty->mmember(fname->value());
-      return vm != 0 && unifiable(tenv, vm->type, hc.ctorty);
+      return vm != nullptr && unifiable(tenv, vm->type, hc.ctorty);
     } else {
-      return is<TVar>(hc.ctorlbl);
+      return is<TVar>(hc.ctorlbl) != nullptr;
     }
   }
-  return is<TVar>(hc.variant);
+  return is<TVar>(hc.variant) != nullptr;
 }
 
 bool HCVariantEliminator::refine(const TEnvPtr&, const HasCtor& hc, MonoTypeUnifier* s, Definitions*) {
@@ -65,7 +65,7 @@ struct HCVariantUnqualify : public switchExprTyFn {
   HCVariantUnqualify(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/hasfield.C b/lib/hobbes/lang/preds/hasfield.C
index 1200e6346..b696c691f 100644
--- a/lib/hobbes/lang/preds/hasfield.C
+++ b/lib/hobbes/lang/preds/hasfield.C
@@ -39,7 +39,7 @@ bool dec(const ConstraintPtr& c, HasField* hf) {
 
 void upd(const ConstraintPtr& c, const HasField& hf) {
   if (c->name() == FieldVerifier::constraintName() && c->arguments().size() == 5) {
-    MonoTypes& mts = const_cast<MonoTypes&>(c->arguments());
+    auto& mts = const_cast<MonoTypes&>(c->arguments());
     mts[0] = tlong(hf.direction == HasField::Read ? 0 : 1);
     mts[1] = hf.recordType;
     mts[2] = hf.fieldName;
@@ -128,7 +128,7 @@ struct RewriteFnAccess : public switchExprTyFn {
     }
   }
 
-  ExprPtr with(const App* ap) const {
+  ExprPtr with(const App* ap) const override {
     if (ap->args().size() == 1) {
       if (hasConstraint(this->cst, ap->type())) {
         if (const Var* f = is<Var>(stripAssumpHead(ap->fn()))) {
@@ -143,7 +143,7 @@ struct RewriteFnAccess : public switchExprTyFn {
     return wrapWithTy(ap->type(), new App(switchOf(ap->fn(), *this), switchOf(ap->args(), *this), ap->la()));
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->cst, v->type())) {
       if (v->value() == FIELD_VALUE_FN) {
         std::string vn = freshName();
diff --git a/lib/hobbes/lang/preds/hasfield/lookup.C b/lib/hobbes/lang/preds/hasfield/lookup.C
index de16474ae..95240c102 100644
--- a/lib/hobbes/lang/preds/hasfield/lookup.C
+++ b/lib/hobbes/lang/preds/hasfield/lookup.C
@@ -1,9 +1,10 @@
 
-#include <hobbes/lang/preds/hasfield/lookup.H>
 #include <hobbes/lang/preds/class.H>
-#include <hobbes/lang/tyunqualify.H>
+#include <hobbes/lang/preds/hasfield/lookup.H>
 #include <hobbes/lang/typeinf.H>
+#include <hobbes/lang/tyunqualify.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -70,7 +71,7 @@ static ExprPtr rewriteLookup(const TEnvPtr& tenv, const ExprPtr& r, const std::s
     unqualifyTypes(
       tenv,
       fncall(
-        var("lookup", qualtype(list(ConstraintPtr(new Constraint("Lookup", list(xty, rty, fty)))), functy(list(xty, rty), fty)), la),
+        var("lookup", qualtype(list(std::make_shared<Constraint>("Lookup", list(xty, rty, fty))), functy(list(xty, rty), fty)), la),
         list(impliedValue(fieldName, la), r),
         la
       ),
@@ -99,7 +100,7 @@ bool HFLookupEliminator::satisfiable(const TEnvPtr& tenv, const HasField& hf, De
   if (decFieldName(hf.fieldName, &fname)) {
     return mightRewriteToLookup(tenv, rty, fname, fty, ds);
   } else {
-    return is<TVar>(hf.fieldName);
+    return is<TVar>(hf.fieldName) != nullptr;
   }
 }
 
@@ -129,13 +130,13 @@ struct HFLookupUnqualify : public switchExprTyFn {
   HFLookupUnqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* defs) : tenv(tenv), constraint(cst), defs(defs) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     ExprPtr prec = switchOf(v->record(), *this);
 
     if (hasConstraint(this->constraint, v->type()) && rewritesToLookup(this->tenv, prec->type()->monoType(), v->field(), v->type()->monoType(), this->defs)) {
diff --git a/lib/hobbes/lang/preds/hasfield/record.C b/lib/hobbes/lang/preds/hasfield/record.C
index 9ab5d1633..f63e39228 100644
--- a/lib/hobbes/lang/preds/hasfield/record.C
+++ b/lib/hobbes/lang/preds/hasfield/record.C
@@ -22,7 +22,7 @@ static bool isFieldName(const MonoTypePtr& fn, std::string* sfn) {
 
 bool HFRecordEliminator::satisfied(const TEnvPtr& tenv, const HasField& hf, Definitions*) const {
   const Record* r = is<Record>(hf.recordType);
-  if (!r) return false;
+  if (r == nullptr) return false;
 
   std::string fname;
   if (!isFieldName(hf.fieldName, &fname)) return false;
@@ -47,12 +47,12 @@ bool HFRecordEliminator::satisfiable(const TEnvPtr& tenv, const HasField& hf, De
     std::string fname;
     if (isFieldName(hf.fieldName, &fname)) {
       const Record::Member* rm = r->mmember(fname);
-      return rm != 0 && (is<TVar>(hf.fieldType) || is<TVar>(rm->type) || satisfied(tenv, hf, ds));
+      return rm != nullptr && ((is<TVar>(hf.fieldType) != nullptr) || (is<TVar>(rm->type) != nullptr) || satisfied(tenv, hf, ds));
     } else {
-      return is<TVar>(hf.fieldName);
+      return is<TVar>(hf.fieldName) != nullptr;
     }
   }
-  return is<TVar>(hf.recordType);
+  return is<TVar>(hf.recordType) != nullptr;
 }
 
 bool HFRecordEliminator::refine(const TEnvPtr&, const HasField& hf, MonoTypeUnifier* s, Definitions*) {
@@ -79,13 +79,13 @@ struct HFRecordUnqualify : public switchExprTyFn {
   HFRecordUnqualify(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Assign* v) const {
+  ExprPtr with(const Assign* v) const override {
     // hack to assign [char] into <std.string>
     if (hasConstraint(this->constraint, v->type())) {
       if (*v->left()->type()->monoType() == *stdstrty && *v->right()->type()->monoType() == *chararrty) {
diff --git a/lib/hobbes/lang/preds/hasfield/slookup.C b/lib/hobbes/lang/preds/hasfield/slookup.C
index 6263093aa..400b380f3 100644
--- a/lib/hobbes/lang/preds/hasfield/slookup.C
+++ b/lib/hobbes/lang/preds/hasfield/slookup.C
@@ -1,9 +1,10 @@
 
-#include <hobbes/lang/preds/hasfield/slookup.H>
 #include <hobbes/lang/preds/class.H>
-#include <hobbes/lang/tyunqualify.H>
+#include <hobbes/lang/preds/hasfield/slookup.H>
 #include <hobbes/lang/typeinf.H>
+#include <hobbes/lang/tyunqualify.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -24,7 +25,7 @@ static MonoTypePtr impliedType(const MonoTypePtr& fieldName) {
 }
 
 bool mightRewriteToSLookup(const TEnvPtr& tenv, const MonoTypePtr& rty, const MonoTypePtr& fieldName, const MonoTypePtr& fty, Definitions* ds) {
-  if (is<TVar>(rty)) {
+  if (is<TVar>(rty) != nullptr) {
     return true;
   }
 
@@ -62,7 +63,7 @@ ExprPtr rewriteSLookup(const TEnvPtr& tenv, const ExprPtr& r, const std::string&
     unqualifyTypes(
       tenv,
       fncall(
-        var("slookup", qualtype(list(ConstraintPtr(new Constraint("SLookup", list(rty, xty, fty)))), functy(list(rty), fty)), la),
+        var("slookup", qualtype(list(std::make_shared<Constraint>("SLookup", list(rty, xty, fty))), functy(list(rty), fty)), la),
         list(r),
         la
       ),
@@ -75,7 +76,7 @@ bool HFSLookupEliminator::satisfied(const TEnvPtr& tenv, const HasField& hf, Def
   auto fnamet = hf.fieldName;
   auto fty    = hf.fieldType;
 
-  if (is<TString>(fnamet) || is<TLong>(fnamet)) {
+  if ((is<TString>(fnamet) != nullptr) || (is<TLong>(fnamet) != nullptr)) {
     MonoTypePtr efty = rewritesToSLookup(tenv, rty, fnamet, fty, ds);
     return efty != MonoTypePtr() && isMonoSingular(efty) && *efty == *fty;
   } else {
@@ -96,7 +97,7 @@ bool HFSLookupEliminator::refine(const TEnvPtr& tenv, const HasField& hf, MonoTy
   auto fnamet = hf.fieldName;
   auto fty    = hf.fieldType;
 
-  if (is<TString>(fnamet) || is<TLong>(fnamet)) {
+  if ((is<TString>(fnamet) != nullptr) || (is<TLong>(fnamet) != nullptr)) {
     MonoTypePtr efty = rewritesToSLookup(tenv, rty, fnamet, fty, ds);
 
     if (efty != MonoTypePtr() && isMonoSingular(efty)) {
@@ -117,13 +118,13 @@ struct HFSLookupUnqualify : public switchExprTyFn {
   HFSLookupUnqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* defs) : tenv(tenv), constraint(cst), defs(defs) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     ExprPtr prec = switchOf(v->record(), *this);
 
     if (hasConstraint(this->constraint, v->type()) && rewritesToSLookup(this->tenv, prec->type()->monoType(), impliedType(v->field()), v->type()->monoType(), this->defs)) {
diff --git a/lib/hobbes/lang/preds/hasfield/tenvlookup.C b/lib/hobbes/lang/preds/hasfield/tenvlookup.C
index 7e712a39c..ebad89b44 100644
--- a/lib/hobbes/lang/preds/hasfield/tenvlookup.C
+++ b/lib/hobbes/lang/preds/hasfield/tenvlookup.C
@@ -26,7 +26,7 @@ MonoTypes trCons(const MonoTypePtr& hty, const MonoTypes& ttys) {
 }
 
 Exprs trCons(const ExprPtr& hexp, const Exprs& texps) {
-  if (texps.size() == 1 && is<Unit>(texps[0])) {
+  if (texps.size() == 1 && (is<Unit>(texps[0]) != nullptr)) {
     return list(hexp);
   } else {
     return cons(hexp, texps);
@@ -35,7 +35,7 @@ Exprs trCons(const ExprPtr& hexp, const Exprs& texps) {
 
 QualTypePtr underlyingFnType(const TEnvPtr& tenv, const MonoTypePtr& rty, const std::string& fieldName, const MonoTypePtr& fty, MonoTypeUnifier* s) {
   const Func* ffty = is<Func>(fty);
-  if (!ffty) return QualTypePtr();
+  if (ffty == nullptr) return QualTypePtr();
 
   try {
     QualTypePtr vfty = tenv->lookup(fieldName)->instantiate();
@@ -65,9 +65,9 @@ bool HFTEnvLookupEliminator::satisfied(const TEnvPtr& tenv, const HasField& hf,
   const auto& fty    = hf.fieldType;
 
   const Func* ffnty = is<Func>(fty);
-  if (!ffnty) { return false; }
+  if (ffnty == nullptr) { return false; }
   const TString* fname = is<TString>(fnamet);
-  if (!fname) { return false; }
+  if (fname == nullptr) { return false; }
   if (!isMonoSingular(rty) || !isMonoSingular(fty)) { return false; }
   if (!tenv->hasBinding(fname->value())) { return false; }
 
@@ -81,15 +81,15 @@ bool HFTEnvLookupEliminator::satisfiable(const TEnvPtr& tenv, const HasField& hf
 
   if (const TString* fname = is<TString>(fnamet)) {
     const Func* ffnty = is<Func>(fty);
-    if (!ffnty) {
-      return is<TVar>(fty);
+    if (ffnty == nullptr) {
+      return is<TVar>(fty) != nullptr;
     }
     if (!tenv->hasBinding(fname->value())) {
       return false;
     }
     return unifiable(tenv, objViewToFlatView(rty, ffnty), tenv->lookup(fname->value())->instantiate()->monoType());
   } else {
-    return is<TVar>(fnamet);
+    return is<TVar>(fnamet) != nullptr;
   }
 }
 
@@ -99,7 +99,7 @@ bool HFTEnvLookupEliminator::refine(const TEnvPtr& tenv, const HasField& hf, Mon
   auto fty    = hf.fieldType;
 
   // short-circuit refinement -- no need to do anything if there's no information to add
-  if (!is<Func>(fty)) { return false; }
+  if (is<Func>(fty) == nullptr) { return false; }
 
   auto invars = tvarNames(rty).size() + tvarNames(fty).size();
   if (invars == 0) { return false; }
@@ -107,7 +107,7 @@ bool HFTEnvLookupEliminator::refine(const TEnvPtr& tenv, const HasField& hf, Mon
   if (const TString* fname = is<TString>(fnamet)) {
     if (tenv->hasBinding(fname->value())) {
       const Func* ufty = is<Func>(tenv->lookup(fname->value())->instantiate()->monoType());
-      if (!ufty || ufty->parameters().size() == 0) return false;
+      if ((ufty == nullptr) || ufty->parameters().empty()) return false;
 
       MonoTypePtr uobj     = ufty->parameters()[0];
       MonoTypePtr ufieldty = functy(drop(ufty->parameters(), 1), ufty->result());
@@ -131,15 +131,15 @@ struct HFTEnvLookupUnqualify : public switchExprTyFn {
   HFTEnvLookupUnqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* defs) : tenv(tenv), constraint(cst), defs(defs) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     const Func* fty = is<Func>(v->type()->monoType());
-    if (!fty) {
+    if (fty == nullptr) {
       throw annotated_error(*v, "Internal error, expected annotated function type");
     }
     return wrapWithTy(v->type(),
@@ -151,12 +151,12 @@ struct HFTEnvLookupUnqualify : public switchExprTyFn {
     );
   }
 
-  ExprPtr with(const App* v) const {
+  ExprPtr with(const App* v) const override {
     // fixup in application position (the preferred position)
     if (const Proj* p = is<Proj>(stripAssumpHead(v->fn()))) {
       if (hasConstraint(this->constraint, p->type())) {
         const Func* fty = is<Func>(p->type()->monoType());
-        if (!fty) {
+        if (fty == nullptr) {
           throw annotated_error(*p, "Internal error, expected annotated function type");
         }
 
@@ -167,7 +167,7 @@ struct HFTEnvLookupUnqualify : public switchExprTyFn {
         ExprPtr napp(new App(f, switchOf(trCons(p->record(), v->args()), *this), v->la()));
         napp->type(qualtype(append(removeConstraint(this->constraint, v->type())->constraints(), nfty->constraints()), v->type()->monoType()));
 
-        if (napp->type()->constraints().size() > 0) {
+        if (!napp->type()->constraints().empty()) {
           return unqualifyTypes(this->tenv, napp, this->defs);
         } else {
           return napp;
@@ -178,7 +178,7 @@ struct HFTEnvLookupUnqualify : public switchExprTyFn {
     return wrapWithTy(v->type(), new App(switchOf(v->fn(), *this), switchOf(v->args(), *this), v->la()));
   }
 
-  ExprPtr with(const Proj* v) const {
+  ExprPtr with(const Proj* v) const override {
     // this should create a closure
     if (hasConstraint(this->constraint, v->type())) {
       throw annotated_error(*v, "Closure creation from tenv-lookup as record lookup, NYI.");
diff --git a/lib/hobbes/lang/preds/loadref.C b/lib/hobbes/lang/preds/loadref.C
index 2f1676f16..410c55de5 100644
--- a/lib/hobbes/lang/preds/loadref.C
+++ b/lib/hobbes/lang/preds/loadref.C
@@ -1,7 +1,8 @@
 
-#include <hobbes/lang/preds/loadref.H>
 #include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/loadref.H>
 #include <hobbes/lang/typeinf.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -66,18 +67,18 @@ bool DBFileRefLoader::satisfiable(const TEnvPtr&, const ConstraintPtr& cst, Defi
       if (const Prim* f = is<Prim>(ap->fn())) {
         if (f->name() == "fileref" && ap->args().size() == 2) {
           if (const TLong* idf = is<TLong>(ap->args()[0])) {
-            return idf->value() != 0 && (*ap->args()[1] == *fref.ty || is<TVar>(ap->args()[1]) || is<TVar>(fref.ty));
+            return idf->value() != 0 && (*ap->args()[1] == *fref.ty || (is<TVar>(ap->args()[1]) != nullptr) || (is<TVar>(fref.ty) != nullptr));
           } else {
-            return is<TVar>(ap->args()[0]);
+            return is<TVar>(ap->args()[0]) != nullptr;
           }
         } else {
           return false;
         }
       } else {
-        return is<TVar>(ap->fn());
+        return is<TVar>(ap->fn()) != nullptr;
       }
     } else {
-      return is<TVar>(fref.ref);
+      return is<TVar>(fref.ref) != nullptr;
     }
   } else {
     return false;
@@ -97,7 +98,7 @@ struct DBFLUnqualify : public switchExprTyFn {
       if (const TApp* ap = is<TApp>(fref.ref)) {
         if (const Prim* f = is<Prim>(ap->fn())) {
           if (f->name() == "fileref" && ap->args().size() == 2) {
-            if (is<TLong>(ap->args()[0])) {
+            if (is<TLong>(ap->args()[0]) != nullptr) {
               valid = true;
             }
           }
@@ -110,11 +111,11 @@ struct DBFLUnqualify : public switchExprTyFn {
     }
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* vn) const {
+  ExprPtr with(const Var* vn) const override {
     if (vn->value() == REF_LOAD) {
       throw annotated_error(*vn, "load to local function NYI");
     } else {
@@ -122,7 +123,7 @@ struct DBFLUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr with(const App* ap) const {
+  ExprPtr with(const App* ap) const override {
     if (const Var* fn = is<Var>(stripAssumpHead(ap->fn()))) {
       if (fn->value() == REF_LOAD) {
         return wrapWithTy(ap->type(), new App(wrapWithTy(fn->type(), new Var(".dbload", ap->la())), list(switchOf(ap->args()[0], *this)), ap->la()));
@@ -139,7 +140,7 @@ ExprPtr DBFileRefLoader::unqualify(const TEnvPtr&, const ConstraintPtr& cst, con
 
 PolyTypePtr DBFileRefLoader::lookup(const std::string& vn) const {
   if (vn == REF_LOAD) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(DBFileRefLoader::constraintName(), list(tgen(0), tgen(1))))), functy(list(tgen(0)), tgen(1))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(DBFileRefLoader::constraintName(), list(tgen(0), tgen(1)))), functy(list(tgen(0)), tgen(1))));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/lang/preds/not.C b/lib/hobbes/lang/preds/not.C
index 6ada079e5..b28070781 100644
--- a/lib/hobbes/lang/preds/not.C
+++ b/lib/hobbes/lang/preds/not.C
@@ -43,7 +43,7 @@ struct StripCst : public switchExprTyFn {
   StripCst(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/packsto.C b/lib/hobbes/lang/preds/packsto.C
index 83ad32599..ff50e01a9 100644
--- a/lib/hobbes/lang/preds/packsto.C
+++ b/lib/hobbes/lang/preds/packsto.C
@@ -51,7 +51,7 @@ static bool dec(const ConstraintPtr& c, PacksTo* pt) {
   return false;
 }
 static void upd(const ConstraintPtr& c, const PacksTo& pt) {
-  MonoTypes& args = const_cast<MonoTypes&>(c->arguments());
+  auto& args = const_cast<MonoTypes&>(c->arguments());
   if (args.size() == 2) {
     args[0] = pt.underlyingType;
     args[1] = pt.abstractType;
@@ -79,7 +79,7 @@ bool Existentials::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTyp
       }
       pt.abstractType = substitute(lus, pt.abstractType);
       upd(cst, pt);
-      return lus.size() > 0;
+      return !lus.empty();
     }
   }
   return false;
@@ -100,7 +100,7 @@ bool Existentials::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Defi
       NameSet utns = tvarNames(pt.underlyingType);
       NameSet atns = tvarNames(e->absType());
 
-      return utns.size() == 0 && atns.size() == 1 && (e->absTypeName() == *atns.begin());
+      return utns.empty() && atns.size() == 1 && (e->absTypeName() == *atns.begin());
     } else {
       return *pt.underlyingType == *pt.abstractType;
     }
@@ -112,7 +112,7 @@ bool Existentials::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Defi
 bool Existentials::satisfiable(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
   PacksTo pt;
   if (dec(cst, &pt)) {
-    if (is<TVar>(pt.abstractType)) {
+    if (is<TVar>(pt.abstractType) != nullptr) {
       return true;
     } else if (const Exists* e = is<Exists>(pt.abstractType)) {
       if (!isSafeExistentialType(e)) {
@@ -136,7 +136,7 @@ struct UnqualifySafePackF : public switchExprTyFn {
   UnqualifySafePackF(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
@@ -148,13 +148,13 @@ struct StripTransparentPackF : public switchExprTyFn {
   StripTransparentPackF(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Pack* p) const {
+  ExprPtr with(const Pack* p) const override {
     if (hasConstraint(this->constraint, p->type())) {
       return switchOf(p->expr(), *this);
     } else {
@@ -168,7 +168,7 @@ ExprPtr Existentials::unqualify(const TEnvPtr&, const ConstraintPtr& cst, const
   // else, just remove the constraint from terms and let final compilation determine how to do the packing
   PacksTo pt;
   if (dec(cst, &pt)) {
-    if (is<Exists>(pt.abstractType)) {
+    if (is<Exists>(pt.abstractType) != nullptr) {
       return switchOf(e, UnqualifySafePackF(cst));
     } else {
       return switchOf(e, StripTransparentPackF(cst));
diff --git a/lib/hobbes/lang/preds/recty.C b/lib/hobbes/lang/preds/recty.C
index fb8dedfe6..38a44f101 100644
--- a/lib/hobbes/lang/preds/recty.C
+++ b/lib/hobbes/lang/preds/recty.C
@@ -1,7 +1,8 @@
 
-#include <hobbes/lang/preds/recty.H>
 #include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/recty.H>
 #include <hobbes/lang/typeinf.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -31,7 +32,7 @@ bool FixIsoRecur::refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifi
   size_t uc = u->size();
   IsoRecur ir;
   if (dec(cst, &ir)) {
-    if (is<Recursive>(ir.rolled)) {
+    if (is<Recursive>(ir.rolled) != nullptr) {
       mgu(unroll(ir.rolled), ir.unrolled, u);
     }
   }
@@ -41,7 +42,7 @@ bool FixIsoRecur::refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifi
 bool FixIsoRecur::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
   IsoRecur ir;
   if (dec(cst, &ir)) {
-    if (is<Recursive>(ir.rolled)) {
+    if (is<Recursive>(ir.rolled) != nullptr) {
       // make sure that the recursive type unrolls to the unrolled type
       return (*unroll(ir.rolled) == *ir.unrolled);
     }
@@ -52,10 +53,10 @@ bool FixIsoRecur::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definition
 bool FixIsoRecur::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions*) const {
   IsoRecur ir;
   if (dec(cst, &ir)) {
-    if (is<TVar>(ir.rolled)) {
+    if (is<TVar>(ir.rolled) != nullptr) {
       return true;
-    } else if (is<Recursive>(ir.rolled)) {
-      if (is<TVar>(ir.unrolled)) {
+    } else if (is<Recursive>(ir.rolled) != nullptr) {
+      if (is<TVar>(ir.unrolled) != nullptr) {
         return true;
       } else {
         return unifiable(tenv, unroll(ir.rolled), ir.unrolled);
@@ -77,11 +78,11 @@ struct IsoRecUnqualify : public switchExprTyFn {
   IsoRecUnqualify(const ConstraintPtr& constraint) : constraint(constraint) {
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       // replace safe functions with 'unsafe' ones
       if (v->value() == RECTY_ROLL) {
@@ -100,9 +101,9 @@ ExprPtr FixIsoRecur::unqualify(const TEnvPtr&, const ConstraintPtr& cst, const E
 
 PolyTypePtr FixIsoRecur::lookup(const std::string& vn) const {
   if (vn == RECTY_ROLL) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(FixIsoRecur::constraintName(), list(tgen(0), tgen(1))))), functy(list(tgen(1)), tgen(0))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(FixIsoRecur::constraintName(), list(tgen(0), tgen(1)))), functy(list(tgen(1)), tgen(0))));
   } else if (vn == RECTY_UNROLL) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(FixIsoRecur::constraintName(), list(tgen(0), tgen(1))))), functy(list(tgen(0)), tgen(1))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(FixIsoRecur::constraintName(), list(tgen(0), tgen(1)))), functy(list(tgen(0)), tgen(1))));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/lang/preds/sizeof.C b/lib/hobbes/lang/preds/sizeof.C
index 15966986d..54b99fc9b 100644
--- a/lib/hobbes/lang/preds/sizeof.C
+++ b/lib/hobbes/lang/preds/sizeof.C
@@ -1,7 +1,8 @@
 
-#include <hobbes/lang/preds/sizeof.H>
 #include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/sizeof.H>
 #include <hobbes/lang/typeinf.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -41,11 +42,11 @@ struct SizeOfPUnqualify : public switchExprTyFn {
   SizeOfPUnqualify(const ConstraintPtr& constraint) : constraint(constraint) {
   }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* vn) const {
+  ExprPtr with(const Var* vn) const override {
     if (vn->value() == REF_SIZEOF) {
       return constant(static_cast<size_t>(sizeOf(this->constraint->arguments()[0])), vn->la());
     } else {
@@ -60,7 +61,7 @@ ExprPtr SizeOfP::unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprP
 
 PolyTypePtr SizeOfP::lookup(const std::string& vn) const {
   if (vn == REF_SIZEOF) {
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(SizeOfP::constraintName(), list(tgen(0), tgen(1))))), primty("long")));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(SizeOfP::constraintName(), list(tgen(0), tgen(1)))), primty("long")));
   } else {
     return PolyTypePtr();
   }
diff --git a/lib/hobbes/lang/preds/str.C b/lib/hobbes/lang/preds/str.C
index 269e1221a..f149e7a5b 100644
--- a/lib/hobbes/lang/preds/str.C
+++ b/lib/hobbes/lang/preds/str.C
@@ -10,7 +10,7 @@ class SplitP : public Unqualifier {
 public:
   static std::string constraintName() { return "Split"; }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) override {
     // try to refine as a csplit
     {
       std::string str;
@@ -38,7 +38,7 @@ public:
     return false;
   }
 
-  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const override {
     std::string delim;
     str::seq    ss;
     MonoTypePtr result;
@@ -48,7 +48,7 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const {
+  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const override {
     if (c->name() != SplitP::constraintName() || c->arguments().size() != 3) {
       return false;
     }
@@ -57,20 +57,20 @@ public:
     const TString* delim = is<TString>(c->arguments()[1]);
     const Record*  ss    = is<Record>(c->arguments()[2]);
   
-    if (str && delim && ss) {
+    if ((str != nullptr) && (delim != nullptr) && (ss != nullptr)) {
       return satisfied(tenv, c, ds);
-    } else if (!str && !is<TVar>(c->arguments()[0])) {
+    } else if ((str == nullptr) && (is<TVar>(c->arguments()[0]) == nullptr)) {
       return false;
-    } else if (!delim && !is<TVar>(c->arguments()[1])) {
+    } else if ((delim == nullptr) && (is<TVar>(c->arguments()[1]) == nullptr)) {
       return false;
-    } else if (!ss && !is<TVar>(c->arguments()[2])) {
+    } else if ((ss == nullptr) && (is<TVar>(c->arguments()[2]) == nullptr)) {
       return false;
     } else {
       return true;
     }
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct StripCst : public switchExprTyFn {
@@ -78,26 +78,26 @@ public:
     StripCst(const ConstraintPtr& cst) : constraint(cst) {
     }
   
-    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
       ExprPtr result(e);
       result->type(removeConstraint(this->constraint, qty));
       return result;
     }
   };
   
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const {
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const override {
     return switchOf(e, StripCst(cst));
   }
   
-  PolyTypePtr lookup(const std::string&) const {
+  PolyTypePtr lookup(const std::string&) const override {
     return PolyTypePtr();
   }
   
-  SymSet bindings() const {
+  SymSet bindings() const override {
     return SymSet();
   }
   
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     return list(FunDep(list(0, 1), 2), FunDep(list(1, 2), 0));
   }
 private:
@@ -155,7 +155,7 @@ class LsP : public Unqualifier {
 public:
   static std::string constraintName() { return "Ls"; }
 
-  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) {
+  bool refine(const TEnvPtr&, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions*) override {
     if (cst->arguments().size() == 2) {
       if (const TString* dir = is<TString>(cst->arguments()[0])) {
         size_t c = u->size();
@@ -166,7 +166,7 @@ public:
     return false;
   }
 
-  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const {
+  bool satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definitions*) const override {
     if (cst->arguments().size() == 2) {
       if (const TString* dir = is<TString>(cst->arguments()[0])) {
         return *cst->arguments()[1] == *tstrings(str::paths(dir->value()));
@@ -175,11 +175,11 @@ public:
     return false;
   }
 
-  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const {
-    return c->arguments().size() == 2 && (is<TVar>(c->arguments()[0]) || is<TVar>(c->arguments()[1]) || satisfied(tenv, c, ds));
+  bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) const override {
+    return c->arguments().size() == 2 && ((is<TVar>(c->arguments()[0]) != nullptr) || (is<TVar>(c->arguments()[1]) != nullptr) || satisfied(tenv, c, ds));
   }
 
-  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
+  void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) override {
   }
 
   struct StripCst : public switchExprTyFn {
@@ -187,26 +187,26 @@ public:
     StripCst(const ConstraintPtr& cst) : constraint(cst) {
     }
   
-    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+    ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
       ExprPtr result(e);
       result->type(removeConstraint(this->constraint, qty));
       return result;
     }
   };
   
-  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const {
+  ExprPtr unqualify(const TEnvPtr&, const ConstraintPtr& cst, const ExprPtr& e, Definitions*) const override {
     return switchOf(e, StripCst(cst));
   }
   
-  PolyTypePtr lookup(const std::string&) const {
+  PolyTypePtr lookup(const std::string&) const override {
     return PolyTypePtr();
   }
   
-  SymSet bindings() const {
+  SymSet bindings() const override {
     return SymSet();
   }
   
-  FunDeps dependencies(const ConstraintPtr&) const {
+  FunDeps dependencies(const ConstraintPtr&) const override {
     return list(FunDep(list(0), 1));
   }
 };
diff --git a/lib/hobbes/lang/preds/subtype.C b/lib/hobbes/lang/preds/subtype.C
index 1ab6db72e..ddc221e0c 100644
--- a/lib/hobbes/lang/preds/subtype.C
+++ b/lib/hobbes/lang/preds/subtype.C
@@ -16,8 +16,7 @@ bool dec(const ConstraintPtr& c, Subtype* st) {
 }
 
 // the subtype eliminator
-SubtypeUnqualifier::SubtypeUnqualifier() {
-}
+SubtypeUnqualifier::SubtypeUnqualifier() = default;
 
 std::string SubtypeUnqualifier::constraintName() {
   return "Subtype";
@@ -28,12 +27,12 @@ void SubtypeUnqualifier::addEliminator(const std::shared_ptr<SubtypeEliminator>&
 }
 
 SubtypeEliminator* SubtypeUnqualifier::findEliminator(const TEnvPtr& tenv, const Subtype& st) const {
-  for (SubtypeEliminators::const_iterator e = this->eliminators.begin(); e != this->eliminators.end(); ++e) {
-    if ((*e)->satisfiable(tenv, st.lower, st.greater)) {
-      return e->get();
+  for (const auto &eliminator : this->eliminators) {
+    if (eliminator->satisfiable(tenv, st.lower, st.greater)) {
+      return eliminator.get();
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool SubtypeUnqualifier::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* s, Definitions*) {
@@ -58,7 +57,7 @@ bool SubtypeUnqualifier::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst
 
 bool SubtypeUnqualifier::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions*) const {
   Subtype st;
-  return dec(cst, &st) && findEliminator(tenv, st) != 0;
+  return dec(cst, &st) && findEliminator(tenv, st) != nullptr;
 }
 
 void SubtypeUnqualifier::explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) {
@@ -75,8 +74,8 @@ ExprPtr SubtypeUnqualifier::unqualify(const TEnvPtr& tenv, const ConstraintPtr&
 }
 
 PolyTypePtr SubtypeUnqualifier::lookup(const std::string& vn) const {
-  for (SubtypeEliminators::const_iterator e = this->eliminators.begin(); e != this->eliminators.end(); ++e) {
-    PolyTypePtr r = (*e)->lookup(vn);
+  for (const auto &eliminator : this->eliminators) {
+    PolyTypePtr r = eliminator->lookup(vn);
     if (r) {
       return r;
     }
@@ -86,8 +85,8 @@ PolyTypePtr SubtypeUnqualifier::lookup(const std::string& vn) const {
 
 SymSet SubtypeUnqualifier::bindings() const {
   SymSet r;
-  for (SubtypeEliminators::const_iterator e = this->eliminators.begin(); e != this->eliminators.end(); ++e) {
-    SymSet x = (*e)->bindings();
+  for (const auto &eliminator : this->eliminators) {
+    SymSet x = eliminator->bindings();
     r.insert(x.begin(), x.end());
   }
   return r;
diff --git a/lib/hobbes/lang/preds/subtype/obj.C b/lib/hobbes/lang/preds/subtype/obj.C
index 4babe5cb8..f6f49b996 100644
--- a/lib/hobbes/lang/preds/subtype/obj.C
+++ b/lib/hobbes/lang/preds/subtype/obj.C
@@ -1,10 +1,11 @@
 
-#include <hobbes/lang/preds/subtype/obj.H>
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/subtype/obj.H>
 #include <hobbes/lang/typeinf.H>
-#include <hobbes/util/str.H>
 #include <hobbes/util/os.H>
+#include <hobbes/util/str.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -130,7 +131,7 @@ bool Objs::isObjName(const std::string& tn) const {
 }
 
 bool Objs::isObjType(const MonoTypePtr& mt) const {
-  if (OpaquePtr* op = is<OpaquePtr>(mt)) {
+  if (auto* op = is<OpaquePtr>(mt)) {
     return isObjName(op->name());
   } else {
     return false;
@@ -138,7 +139,7 @@ bool Objs::isObjType(const MonoTypePtr& mt) const {
 }
 
 std::string show(const PtrAdjustmentPath& p) {
-  if (p.size() == 0) {
+  if (p.empty()) {
     return "[]";
   } else {
     std::string r = "[";
@@ -157,10 +158,10 @@ void appendPath(PtrAdjustmentPath* p, const PtrAdjustmentPath& sfx) {
 }
 
 PtrAdjustmentPath Objs::adjustment(const MonoTypePtr& derived, const MonoTypePtr& base) const {
-  OpaquePtr* d = is<OpaquePtr>(derived);
-  OpaquePtr* b = is<OpaquePtr>(base);
+  auto* d = is<OpaquePtr>(derived);
+  auto* b = is<OpaquePtr>(base);
 
-  if (!d || !b) {
+  if ((d == nullptr) || (b == nullptr)) {
     throw std::runtime_error("Expected class types for pointer adjustment determination, but received '" + show(derived) + " <: " + show(base));
   } else {
     return adjustment(d->name(), b->name());
@@ -179,7 +180,7 @@ PtrAdjustmentPath Objs::adjustment(const ConstraintPtr& cst) const {
 PolyTypePtr Objs::generalize(const MonoTypePtr& mt) const {
   // for now, just generalize function types
   Func* fty = is<Func>(mt);
-  if (!fty) return polytype(mt);
+  if (fty == nullptr) return polytype(mt);
 
   const MonoTypes&   fatys = fty->parameters();
   const MonoTypePtr& nfrty = fty->result();
@@ -187,14 +188,14 @@ PolyTypePtr Objs::generalize(const MonoTypePtr& mt) const {
   int                tvs = 0;
   Constraints        cs;
 
-  for (unsigned int a = 0; a < fatys.size(); ++a) {
-    if (isObjType(fatys[a])) {
+  for (const auto &faty : fatys) {
+    if (isObjType(faty)) {
       MonoTypePtr tgv(TGen::make(tvs));
       nfatys.push_back(tgv);
-      cs.push_back(ConstraintPtr(new Constraint(SubtypeUnqualifier::constraintName(), list(tgv, fatys[a]))));
+      cs.push_back(std::make_shared<Constraint>(SubtypeUnqualifier::constraintName(), list(tgv, faty)));
       ++tvs;
     } else {
-      nfatys.push_back(fatys[a]);
+      nfatys.push_back(faty);
     }
   }
 
@@ -210,7 +211,7 @@ bool Objs::satisfied(const TEnvPtr&, const MonoTypePtr& lhs, const MonoTypePtr&
   const OpaquePtr* derived = is<OpaquePtr>(lhs);
   const OpaquePtr* base    = is<OpaquePtr>(rhs);
 
-  if (derived && base) {
+  if ((derived != nullptr) && (base != nullptr)) {
     return pathExists(derived->name(), base->name());
   } else {
     return false;
@@ -221,7 +222,7 @@ bool Objs::satisfiable(const TEnvPtr&, const MonoTypePtr& lhs, const MonoTypePtr
   const OpaquePtr* derived = is<OpaquePtr>(lhs);
   const OpaquePtr* base    = is<OpaquePtr>(rhs);
 
-  if (derived && base) {
+  if ((derived != nullptr) && (base != nullptr)) {
     return pathExists(derived->name(), base->name());
   } else {
     return mayBeKnown(lhs) && mayBeKnown(rhs);
@@ -229,13 +230,13 @@ bool Objs::satisfiable(const TEnvPtr&, const MonoTypePtr& lhs, const MonoTypePtr
 }
 
 bool Objs::mayBeKnown(const MonoTypePtr& mt) const {
-  if (OpaquePtr* op = is<OpaquePtr>(mt)) {
+  if (auto* op = is<OpaquePtr>(mt)) {
     // this is a specific C++ type name
     // we can directly tell if it's known
     return this->classDefs.find(op->name()) != this->classDefs.end();
   } else {
     // this type may only be known if it's a type-variable or polytype-arg
-    return is<TGen>(mt) || is<TVar>(mt);
+    return (is<TGen>(mt) != nullptr) || (is<TVar>(mt) != nullptr);
   }
 }
 
@@ -277,8 +278,8 @@ ExprPtr applyAdjustment(const PtrAdjustment& p, const ExprPtr& e) {
 
 ExprPtr applyAdjustments(const PtrAdjustmentPath& p, const ExprPtr& e) {
   ExprPtr r = e;
-  for (unsigned int i = 0; i < p.size(); ++i) {
-    r = applyAdjustment(p[i], r);
+  for (const auto &i : p) {
+    r = applyAdjustment(i, r);
   }
   return r;
 }
@@ -296,13 +297,13 @@ struct ObjUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (!hasConstraint(this->constraint, v->type())) {
       return wrapWithTy(v->type(), v->clone());
     } else if (const Func* fty = is<Func>(v->type()->monoType())) {
@@ -327,9 +328,9 @@ struct ObjUnqualify : public switchExprTyFn {
     }
   }
 
-  ExprPtr with(const Fn* v) const {
+  ExprPtr with(const Fn* v) const override {
     const Func* fty = is<Func>(v->type()->monoType());
-    if (!fty) {
+    if (fty == nullptr) {
       throw std::runtime_error("Internal error, expected annotated function type");
     }
     return wrapWithTy(v->type(),
@@ -341,15 +342,15 @@ struct ObjUnqualify : public switchExprTyFn {
     );
   }
   
-  ExprPtr with(const App* v) const {
+  ExprPtr with(const App* v) const override {
     if (hasConstraint(this->constraint, v->fn()->type())) {
-      ExprPtr f    = is<Var>(v->fn()) ? wrapWithTy(v->fn()->type(), v->fn()->clone()) : switchOf(v->fn(), *this);
+      ExprPtr f    = is<Var>(v->fn()) != nullptr ? wrapWithTy(v->fn()->type(), v->fn()->clone()) : switchOf(v->fn(), *this);
       Exprs   args = switchOf(v->args(), *this);
       Idxs    ixs  = coercionIndexes(this->tenv, v->fn(), this->isa.greater, this->ds);
 
-      for (Idxs::const_iterator ix = ixs.begin(); ix != ixs.end(); ++ix) {
-        if (*args[*ix]->type()->monoType() == *this->isa.lower) {
-          args[*ix] = applyAdjustments(this->objs->adjustment(this->constraint), args[*ix]);
+      for (const unsigned long ix : ixs) {
+        if (*args[ix]->type()->monoType() == *this->isa.lower) {
+          args[ix] = applyAdjustments(this->objs->adjustment(this->constraint), args[ix]);
         }
       }
 
@@ -359,21 +360,21 @@ struct ObjUnqualify : public switchExprTyFn {
     }
   }
 
-  typedef std::vector<size_t> Idxs;
+  using Idxs = std::vector<size_t>;
 
   static Idxs coercionIndexes(const TEnvPtr& tenv, const ExprPtr& fe, const MonoTypePtr& convTo, Definitions* ds) {
     QualTypePtr fty  = validateType(tenv, fe, ds)->type();
     const Func* ffty = is<Func>(fty->monoType());
-    if (!ffty) return Idxs();
+    if (ffty == nullptr) return Idxs();
 
     MonoTypes ctys = convFroms(fty->constraints(), convTo);
-    if (ctys.size() == 0) return Idxs();
+    if (ctys.empty()) return Idxs();
 
     Idxs result;
     const MonoTypes& atys = ffty->parameters();
     for (size_t i = 0; i < atys.size(); ++i) {
-      for (MonoTypes::const_iterator cty = ctys.begin(); cty != ctys.end(); ++cty) {
-        if (*atys[i] == **cty) {
+      for (const auto &cty : ctys) {
+        if (*atys[i] == *cty) {
           result.push_back(i);
         }
       }
@@ -383,9 +384,9 @@ struct ObjUnqualify : public switchExprTyFn {
 
   static MonoTypes convFroms(const Constraints& cs, const MonoTypePtr& convTo) {
     MonoTypes result;
-    for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
+    for (const auto &c : cs) {
       Subtype sc;
-      if (dec(*c, &sc)) {
+      if (dec(c, &sc)) {
         if (*sc.greater == *convTo) {
           result.push_back(sc.lower);
         }
diff --git a/lib/hobbes/lang/preds/typeof.C b/lib/hobbes/lang/preds/typeof.C
index a3fc74bb4..59a6e4563 100644
--- a/lib/hobbes/lang/preds/typeof.C
+++ b/lib/hobbes/lang/preds/typeof.C
@@ -77,7 +77,7 @@ struct StripCst : public switchExprTyFn {
   StripCst(const ConstraintPtr& cst) : constraint(cst) {
   }
 
-  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const {
+  ExprPtr wrapWithTy(const QualTypePtr& qty, Expr* e) const override {
     ExprPtr result(e);
     result->type(removeConstraint(this->constraint, qty));
     return result;
diff --git a/lib/hobbes/lang/preds/vapp.C b/lib/hobbes/lang/preds/vapp.C
index 6496e02de..9bca0d9b4 100644
--- a/lib/hobbes/lang/preds/vapp.C
+++ b/lib/hobbes/lang/preds/vapp.C
@@ -1,10 +1,11 @@
 
-#include <hobbes/lang/preds/vapp.H>
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/vapp.H>
 #include <hobbes/lang/tylift.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -45,7 +46,7 @@ MonoTypePtr variantTypeFromDtor(const Record& rty) {
 }
 
 MonoTypePtr dtorResultFromDtor(const Record& rty) {
-  if (rty.members().size() == 0) {
+  if (rty.members().empty()) {
     throw std::runtime_error("Internal error, impossible variant applicator type: ()");
   } else {
     MonoTypePtr arg, result;
@@ -132,14 +133,14 @@ bool VariantAppP::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definition
 bool VariantAppP::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   VariantAppD va;
   if (dec(cst, &va)) {
-    if (is<Variant>(va.variantType)) {
-      if (is<Record>(va.recordDtorType)) {
+    if (is<Variant>(va.variantType) != nullptr) {
+      if (is<Record>(va.recordDtorType) != nullptr) {
         return hasFreeVariables(va.variantType) || hasFreeVariables(va.recordDtorType) || hasFreeVariables(va.resultType) || satisfied(tenv, cst, ds);
       } else {
-        return is<TVar>(va.recordDtorType);
+        return is<TVar>(va.recordDtorType) != nullptr;
       }
     } else {
-      return is<TVar>(va.variantType);
+      return is<TVar>(va.variantType) != nullptr;
     }
   }
   return false;
@@ -151,7 +152,7 @@ void VariantAppP::explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&,
 PolyTypePtr VariantAppP::lookup(const std::string& vn) const {
   if (vn == REF_VAR_APP) {
     // variantApp :: (VariantApp v f r) => (v,f) -> r
-    return polytype(3, qualtype(list(ConstraintPtr(new Constraint(VariantAppP::constraintName(), list(tgen(0), tgen(1), tgen(2))))), functy(list(tgen(0), tgen(1)), tgen(2))));
+    return polytype(3, qualtype(list(std::make_shared<Constraint>(VariantAppP::constraintName(), list(tgen(0), tgen(1), tgen(2)))), functy(list(tgen(0), tgen(1)), tgen(2))));
   } else {
     return PolyTypePtr();
   }
@@ -175,11 +176,11 @@ struct VAUnqualify : public switchExprTyFn {
   const ConstraintPtr& constraint;
   VAUnqualify(const ConstraintPtr& constraint) : constraint(constraint) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       if (v->value() == REF_VAR_APP) {
         // rewrite this variable to become a function that does the promised case analysis and dispatch to closure calls
@@ -187,7 +188,7 @@ struct VAUnqualify : public switchExprTyFn {
         auto urty = this->constraint->arguments()[1];
 
         if (const Variant* vty = is<Variant>(uvty)) {
-          if (is<Record>(urty)) {
+          if (is<Record>(urty) != nullptr) {
             Case::Bindings cs;
             for (const auto& vm : vty->members()) {
               cs.push_back(Case::Binding(vm.selector, ".x", closcall(proj(var(".f", urty, v->la()), vm.selector, v->la()), list(var(".x", vm.type, v->la())), v->la())));
diff --git a/lib/hobbes/lang/preds/vtrunc.C b/lib/hobbes/lang/preds/vtrunc.C
index 4557adbc9..0e961f47e 100644
--- a/lib/hobbes/lang/preds/vtrunc.C
+++ b/lib/hobbes/lang/preds/vtrunc.C
@@ -1,10 +1,11 @@
 
-#include <hobbes/lang/preds/vtrunc.H>
-#include <hobbes/lang/preds/class.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/preds/class.H>
+#include <hobbes/lang/preds/vtrunc.H>
 #include <hobbes/lang/tylift.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/util/array.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -61,10 +62,10 @@ bool VariantTruncP::satisfied(const TEnvPtr&, const ConstraintPtr& cst, Definiti
 bool VariantTruncP::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
   VariantTruncD vt;
   if (dec(cst, &vt)) {
-    if (!hasFreeVariables(vt.variantType) && is<Variant>(vt.variantType)) {
-      return is<TVar>(vt.enumType) || satisfied(tenv, cst, ds);
+    if (!hasFreeVariables(vt.variantType) && (is<Variant>(vt.variantType) != nullptr)) {
+      return (is<TVar>(vt.enumType) != nullptr) || satisfied(tenv, cst, ds);
     } else {
-      return is<TVar>(vt.variantType);
+      return is<TVar>(vt.variantType) != nullptr;
     }
   }
   return false;
@@ -76,7 +77,7 @@ void VariantTruncP::explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&
 PolyTypePtr VariantTruncP::lookup(const std::string& vn) const {
   if (vn == REF_VAR_TRUNC) {
     // trunc :: (VariantTrunc v e) => v -> e
-    return polytype(2, qualtype(list(ConstraintPtr(new Constraint(VariantTruncP::constraintName(), list(tgen(0), tgen(1))))), functy(list(tgen(0)), tgen(1))));
+    return polytype(2, qualtype(list(std::make_shared<Constraint>(VariantTruncP::constraintName(), list(tgen(0), tgen(1)))), functy(list(tgen(0)), tgen(1))));
   } else {
     return PolyTypePtr();
   }
@@ -99,11 +100,11 @@ struct VTUnqualify : public switchExprTyFn {
   const ConstraintPtr& constraint;
   VTUnqualify(const ConstraintPtr& constraint) : constraint(constraint) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return removeConstraint(this->constraint, qt);
   }
 
-  ExprPtr with(const Var* v) const {
+  ExprPtr with(const Var* v) const override {
     if (hasConstraint(this->constraint, v->type())) {
       if (v->value() == REF_VAR_TRUNC) {
         return wrapWithTy(v->type(), new Var("unsafeCast", v->la()));
diff --git a/lib/hobbes/lang/type.C b/lib/hobbes/lang/type.C
index 5546a3eb5..6d1c75da0 100644
--- a/lib/hobbes/lang/type.C
+++ b/lib/hobbes/lang/type.C
@@ -1,19 +1,20 @@
 
 #include <algorithm>
-#include <hobbes/lang/type.H>
+#include <atomic>
+#include <cstring>
+#include <hobbes/lang/constraints.H>
 #include <hobbes/lang/expr.H>
 #include <hobbes/lang/tylift.H>
+#include <hobbes/lang/type.H>
 #include <hobbes/lang/typepreds.H>
-#include <hobbes/lang/constraints.H>
 #include <hobbes/util/array.H>
 #include <hobbes/util/codec.H>
-#include <hobbes/util/str.H>
 #include <hobbes/util/perf.H>
+#include <hobbes/util/str.H>
+#include <memory>
 #include <sstream>
 #include <stdexcept>
-#include <cstring>
 #include <unordered_map>
-#include <atomic>
 
 namespace hobbes {
 
@@ -43,7 +44,7 @@ template <typename T>
     if (ts.size() == 0) {
       return "{}";
     } else {
-      typedef typename std::set<T>::const_iterator TCIter;
+      using TCIter = typename std::set<T>::const_iterator;
       TCIter t = ts.begin();
       std::string r = "{" + str::from(*t);
       ++t;
@@ -89,7 +90,7 @@ str::seq showNoSimpl(const Constraints& cs) {
 TEnv::TEnv(const TEnvPtr& parent) : parent(parent), dbgCstRefine(false) {
 }
 
-TEnv::TEnv() : parent(), unquals(new UnqualifierSet()), dbgCstRefine(false)  {
+TEnv::TEnv() :  unquals(new UnqualifierSet()), dbgCstRefine(false)  {
 }
 bool TEnv::debugConstraintRefine() const { return this->dbgCstRefine || (parent && parent->debugConstraintRefine()); }
 void TEnv::debugConstraintRefine(bool f) { this->dbgCstRefine = f; }
@@ -119,14 +120,14 @@ void TEnv::bind(const std::string& vname, const MonoTypePtr& t) {
 }
 
 void TEnv::unbind(const std::string& vname) {
-  PolyTypeEnv::iterator b = this->ptenv.find(vname);
+  auto b = this->ptenv.find(vname);
   if (b != this->ptenv.end()) {
     this->ptenv.erase(b);
   }
 }
 
 PolyTypePtr TEnv::lookup(const std::string& vname) const {
-  PolyTypeEnv::const_iterator t = this->ptenv.find(vname);
+  auto t = this->ptenv.find(vname);
   if (t != this->ptenv.end()) {
     return t->second;
   } else if (this->parent) {
@@ -142,7 +143,7 @@ PolyTypePtr TEnv::lookup(const std::string& vname) const {
       str::seq suggestions = str::closestMatches(vname, boundVariables(), 3);
       if (suggestions.size() == 1) {
         ss << " (did you mean '" << suggestions[0] << "'?)";
-      } else if (suggestions.size() > 0) {
+      } else if (!suggestions.empty()) {
         ss << " (did you mean one of: '" << suggestions[0] << "'";
         for (size_t i = 1; i < suggestions.size(); ++i) {
           ss << ", '" << suggestions[i] << "'";
@@ -160,7 +161,7 @@ void TEnv::bind(const std::string& predName, const UnqualifierPtr& uq) {
     this->parent->bind(predName, uq);
   } else {
     // add this unqualifier only if it doesn't introduce conflicting variable definitions
-    for (auto vn : uq->bindings()) {
+    for (const auto& vn : uq->bindings()) {
       if (hasBinding(vn)) {
         throw std::runtime_error("Variable already defined: " + vn);
       }
@@ -203,8 +204,8 @@ TEnv::PolyTypeEnv TEnv::typeEnvTable(std::function<std::string const&(std::strin
   } else {
     PolyTypeEnv pte       = this->ptenv;
     SymSet      overloads = this->unquals->bindings();
-    for (SymSet::const_iterator s = overloads.begin(); s != overloads.end(); ++s) {
-      pte[*s] = this->unquals->lookup(reWriteFn(*s));
+    for (const auto &overload : overloads) {
+      pte[overload] = this->unquals->lookup(reWriteFn(overload));
     }
     return pte;
   }
@@ -306,8 +307,8 @@ bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) {
 }
 
 bool satisfied(const TEnvPtr& tenv, const Constraints& cs, Definitions* ds) {
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    if (!satisfied(tenv, *c, ds)) {
+  for (const auto &c : cs) {
+    if (!satisfied(tenv, c, ds)) {
       return false;
     }
   }
@@ -335,8 +336,8 @@ bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& c, Definitions* ds) {
 }
 
 bool satisfiable(const TEnvPtr& tenv, const Constraints& cs, Definitions* ds) {
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    if (!satisfiable(tenv, *c, ds)) {
+  for (const auto &c : cs) {
+    if (!satisfiable(tenv, c, ds)) {
       return false;
     }
   }
@@ -387,7 +388,7 @@ Constraints& QualType::constraints() { return this->cs; }
 void QualType::monoType(const MonoTypePtr& nt) { this->mt = nt; }
 
 void QualType::show(std::ostream& out) const {
-  if (this->cs.size() == 0) {
+  if (this->cs.empty()) {
     this->mt->show(out);
   } else if (this->cs.size() == 1) {
     this->cs[0]->show(out);
@@ -421,7 +422,7 @@ std::string        Constraint::name()      const { return this->cat; }
 const MonoTypes&   Constraint::arguments() const { return this->mts; }
 
 ConstraintPtr Constraint::instantiate(const MonoTypes& ts) const {
-  return ConstraintPtr(new Constraint(this->name(), hobbes::instantiate(ts, this->arguments())));
+  return std::make_shared<Constraint>(this->name(), hobbes::instantiate(ts, this->arguments()));
 }
 
 NameSet Constraint::tvarNames() const {
@@ -435,7 +436,7 @@ bool Constraint::hasFreeVariables() const {
 }
 
 ConstraintPtr Constraint::substitute(const MonoTypeSubst& s) const {
-  return ConstraintPtr(new Constraint(this->name(), hobbes::substitute(s, this->arguments())));
+  return std::make_shared<Constraint>(this->name(), hobbes::substitute(s, this->arguments()));
 }
 
 void Constraint::update(MonoTypeUnifier* u) {
@@ -466,9 +467,9 @@ void Constraint::show(std::ostream& out) const {
     this->mts[3]->show(out);
   } else {
     out << this->cat;
-    for (size_t i = 0; i < this->mts.size(); ++i) {
+    for (const auto &mt : this->mts) {
       out << " ";
-      this->mts[i]->show(out);
+      mt->show(out);
     }
   }
 }
@@ -491,7 +492,7 @@ bool Constraint::operator==(const Constraint& rhs) const {
 ////////
 MonoType::MonoType(int cid) : cid(cid), tgenCount(0), memorySize(-1) { }
 int MonoType::case_id() const { return this->cid; }
-MonoType::~MonoType() { }
+MonoType::~MonoType() = default;
 
 bool MonoType::operator==(const MonoType& rhs) const {
   return this == &rhs;
@@ -511,7 +512,7 @@ bool isFileRef(const MonoTypePtr& mt) {
 unsigned int alignment(const MonoTypePtr& pty) {
   MonoTypePtr ty = repType(pty);
 
-  if (is<Prim>(ty)) {
+  if (is<Prim>(ty) != nullptr) {
     if (isUnit(ty)) {
       return 1;
     } else {
@@ -525,15 +526,15 @@ unsigned int alignment(const MonoTypePtr& pty) {
     }
   } else if (const FixedArray* farr = is<FixedArray>(ty)) {
     return alignment(farr->type());
-  } else if (is<OpaquePtr>(ty) || is<Array>(ty) || is<Func>(ty)) {
+  } else if ((is<OpaquePtr>(ty) != nullptr) || (is<Array>(ty) != nullptr) || (is<Func>(ty) != nullptr)) {
     return sizeof(void*);
   } else if (const Record* rty = is<Record>(ty)) {
     size_t a = 1;
-    for (auto f : rty->members()) {
+    for (const auto& f : rty->members()) {
       a = std::max<unsigned int>(a, alignment(f.type));
     }
     return a;
-  } else if (is<Recursive>(ty)) {
+  } else if (is<Recursive>(ty) != nullptr) {
     return sizeof(void*);
   } else if (isFileRef(ty)) {
     return sizeof(uint64_t);
@@ -545,48 +546,29 @@ unsigned int alignment(const MonoTypePtr& pty) {
 ////////////
 // manage allocation of mono types so that type pointers are uniquely determined by constructor arguments
 ////////////
-typedef unique_refc_map<const Prim,       std::string, MonoTypePtr>        PrimMem;
-typedef unique_refc_map<const OpaquePtr,  std::string, unsigned int, bool> OpaquePtrMem;
-typedef unique_refc_map<const TVar,       std::string>                     TVarMem;
-typedef unique_refc_map<const TGen,       int>                             TGenMem;
-typedef unique_refc_map<const TAbs,       str::seq,    MonoTypePtr>        TAbsMem;
-typedef unique_refc_map<const TApp,       MonoTypePtr, MonoTypes>          TAppMem;
-typedef unique_refc_map<const FixedArray, MonoTypePtr, MonoTypePtr>        FixedArrayMem;
-typedef unique_refc_map<const Array,      MonoTypePtr>                     ArrayMem;
-typedef unique_refc_map<const Variant,    Variant::Members>                VariantMem;
-typedef unique_refc_map<const Record,     Record::Members>                 RecordMem;
-typedef unique_refc_map<const Func,       MonoTypePtr, MonoTypePtr>        FuncMem;
-typedef unique_refc_map<const Exists,     std::string, MonoTypePtr>        ExistsMem;
-typedef unique_refc_map<const Recursive,  std::string, MonoTypePtr>        RecursiveMem;
-
-typedef unique_refc_map<const TString,    std::string>                     TStringMem;
-typedef unique_refc_map<const TLong,      long>                            TLongMem;
-typedef unique_refc_map<const TExpr,      std::string>                     TExprMem;
-
-typedef
-  unique_refc_maps<
-    PrimMem,
-    OpaquePtrMem,
-    TVarMem,
-    TGenMem,
-    TAbsMem,
-    TAppMem,
-    FixedArrayMem,
-    ArrayMem,
-    VariantMem,
-    RecordMem,
-    FuncMem,
-    ExistsMem,
-    RecursiveMem,
-
-    TStringMem,
-    TLongMem,
-    TExprMem
-  > MTypeCtorMaps;
+using PrimMem = unique_refc_map<const Prim, std::string, MonoTypePtr>;
+using OpaquePtrMem = unique_refc_map<const OpaquePtr, std::string, unsigned int, bool>;
+using TVarMem = unique_refc_map<const TVar, std::string>;
+using TGenMem = unique_refc_map<const TGen, int>;
+using TAbsMem = unique_refc_map<const TAbs, str::seq, MonoTypePtr>;
+using TAppMem = unique_refc_map<const TApp, MonoTypePtr, MonoTypes>;
+using FixedArrayMem = unique_refc_map<const FixedArray, MonoTypePtr, MonoTypePtr>;
+using ArrayMem = unique_refc_map<const Array, MonoTypePtr>;
+using VariantMem = unique_refc_map<const Variant, Variant::Members>;
+using RecordMem = unique_refc_map<const Record, Record::Members>;
+using FuncMem = unique_refc_map<const Func, MonoTypePtr, MonoTypePtr>;
+using ExistsMem = unique_refc_map<const Exists, std::string, MonoTypePtr>;
+using RecursiveMem = unique_refc_map<const Recursive, std::string, MonoTypePtr>;
+
+using TStringMem = unique_refc_map<const TString, std::string>;
+using TLongMem = unique_refc_map<const TLong, long>;
+using TExprMem = unique_refc_map<const TExpr, std::string>;
+
+using MTypeCtorMaps = unique_refc_maps<PrimMem, OpaquePtrMem, TVarMem, TGenMem, TAbsMem, TAppMem, FixedArrayMem, ArrayMem, VariantMem, RecordMem, FuncMem, ExistsMem, RecursiveMem, TStringMem, TLongMem, TExprMem>;
 
 MTypeCtorMaps* tctorMaps() {
-  static MTypeCtorMaps* x = 0;
-  if (x == 0) {
+  static MTypeCtorMaps* x = nullptr;
+  if (x == nullptr) {
     x = new MTypeCtorMaps();
   }
   return x;
@@ -675,7 +657,7 @@ TAbs::TAbs(const str::seq& targns, const MonoTypePtr& b) : targns(targns), b(b)
 }
 
 void TAbs::show(std::ostream& out) const {
-  out << "\\" << (this->targns.size() == 0 ? "()" : str::cdelim(this->targns, " ")) << "." << hobbes::show(this->b);
+  out << "\\" << (this->targns.empty() ? "()" : str::cdelim(this->targns, " ")) << "." << hobbes::show(this->b);
 }
 
 const str::seq&    TAbs::args() const { return this->targns; }
@@ -712,10 +694,10 @@ void TApp::show(std::ostream& out) const {
 
   out << "(";
   this->f->show(out);
-  if (this->targs.size() > 0) {
-    for (size_t i = 0; i < this->targs.size(); ++i) {
+  if (!this->targs.empty()) {
+    for (const auto &targ : this->targs) {
       out << " ";
-      this->targs[i]->show(out);
+      targ->show(out);
     }
   }
   out << ")";
@@ -763,8 +745,8 @@ MonoTypePtr Variant::make(const Members& ms) {
 
 static void resetCtorIDs(Variant::Members* ms) {
   size_t id = 0;
-  for (Variant::Members::iterator m = ms->begin(); m != ms->end(); ++m) {
-    m->id = id++;
+  for (auto &m : *ms) {
+    m.id = id++;
   }
 }
 
@@ -819,7 +801,7 @@ MonoTypePtr Variant::make(const std::string& lbl, const MonoTypePtr& hty, const
 }
 
 Variant::Member::Member(const std::string& selector, const MonoTypePtr& type, unsigned int id) : selector(selector), type(type), id(id) { }
-Variant::Member::Member() : selector(""), type(), id(0) { }
+Variant::Member::Member() :   id(0) { }
 bool Variant::Member::operator==(const Variant::Member& rhs) const { return this->selector == rhs.selector && *this->type == *rhs.type && this->id == rhs.id; }
 
 bool Variant::Member::operator<(const Variant::Member& rhs) const {
@@ -897,8 +879,8 @@ void showSum(const Variant::Members& ms, std::ostream& out) {
 }
 
 bool looksLikeSum(const Variant::Members& ms) {
-  for (size_t i = 0; i < ms.size(); ++i) {
-    if (ms[i].selector.size() > 1 && ms[i].selector[0] == '.' && ms[i].selector[1] == 'f') {
+  for (const auto &m : ms) {
+    if (m.selector.size() > 1 && m.selector[0] == '.' && m.selector[1] == 'f') {
       return true;
     }
   }
@@ -946,7 +928,7 @@ const MonoTypePtr& Variant::payload(const std::string& selector) const {
 
 unsigned int Variant::index(const std::string& selector) const {
   int i = 0;
-  for (Members::const_iterator m = this->ms.begin(); m != this->ms.end(); ++m, ++i) {
+  for (auto m = this->ms.begin(); m != this->ms.end(); ++m, ++i) {
     if (m->selector == selector) {
       return i;
     }
@@ -954,21 +936,21 @@ unsigned int Variant::index(const std::string& selector) const {
   throw std::runtime_error("No selector named '" + selector + "' in the variant '" + hobbes::show(this) + "'.");
 }
 unsigned int Variant::id(const std::string& selector) const {
-  for (Members::const_iterator m = this->ms.begin(); m != this->ms.end(); ++m) {
-    if (m->selector == selector) {
-      return m->id;
+  for (const auto &m : this->ms) {
+    if (m.selector == selector) {
+      return m.id;
     }
   }
   throw std::runtime_error("No selector named '" + selector + "' in the variant '" + hobbes::show(this) + "'.");
 }
 
 const Variant::Member* Variant::mmember(const std::string& selector) const {
-  for (Members::const_iterator m = this->ms.begin(); m != this->ms.end(); ++m) {
-    if (m->selector == selector) {
-      return &(*(m));
+  for (const auto &m : this->ms) {
+    if (m.selector == selector) {
+      return &m;
     }
   }
-  return 0;
+  return nullptr;
 }
 
 Variant::Members tailMembers(const Variant::Members& ms) {
@@ -1007,7 +989,7 @@ MonoTypePtr Variant::tailType() const {
 // we should try to unify this logic with record alignment-determination logic
 unsigned int Variant::payloadOffset() const {
   unsigned int o = sizeof(int);
-  for (auto m : this->ms) {
+  for (const auto& m : this->ms) {
     o = std::max<unsigned int>(o, align<unsigned int>(sizeof(int), alignment(m.type)));
   }
   return o;
@@ -1016,7 +998,7 @@ unsigned int Variant::payloadOffset() const {
 unsigned int Variant::payloadSize() const {
   if (this->payloadSizeM == static_cast<unsigned int>(-1)) {
     this->payloadSizeM = 0;
-    for (auto m : this->ms) {
+    for (const auto& m : this->ms) {
       this->payloadSizeM = std::max(this->payloadSizeM, sizeOf(m.type));
     }
   }
@@ -1026,7 +1008,7 @@ unsigned int Variant::payloadSize() const {
 unsigned int Variant::size() const {
   // align to strictest field
   unsigned int malign = sizeof(int);
-  for (auto m : this->ms) {
+  for (const auto& m : this->ms) {
     malign = std::max<unsigned int>(malign, alignment(m.type));
   }
   return align<unsigned int>(payloadOffset() + payloadSize(), malign);
@@ -1034,7 +1016,7 @@ unsigned int Variant::size() const {
 
 // record types
 Record::Member::Member(const std::string& field, const MonoTypePtr& type, int offset) : field(field), type(type), offset(offset) { }
-Record::Member::Member() : field(""), type(), offset(0) { }
+Record::Member::Member() :   offset(0) { }
 bool Record::Member::operator==(const Record::Member& rhs) const { return this->field == rhs.field && *this->type == *rhs.type && this->offset == rhs.offset; }
 
 bool Record::Member::operator<(const Record::Member& rhs) const {
@@ -1097,8 +1079,8 @@ int findHiddenMember(const std::string& lbl, const Record::Members& ms) {
 }
 
 static void resetFieldOffsets(Record::Members* ms) {
-  for (Record::Members::iterator m = ms->begin(); m != ms->end(); ++m) {
-    m->offset = -1;
+  for (auto &m : *ms) {
+    m.offset = -1;
   }
 }
 
@@ -1121,9 +1103,9 @@ Record::Members consMember(const std::string& lbl, const MonoTypePtr& hty, const
 
 static void normalizeTupleFields(Record::Members* ms) {
   size_t i = 0;
-  for (Record::Members::iterator m = ms->begin(); m != ms->end(); ++m) {
-    if (m->field.substr(0, 2) != ".p") {
-      m->field = ".f" + str::from(i++);
+  for (auto &m : *ms) {
+    if (m.field.substr(0, 2) != ".p") {
+      m.field = ".f" + str::from(i++);
     }
   }
 }
@@ -1183,7 +1165,7 @@ Record::Members Record::withResolvedMemoryLayout(const Members& ms) {
 
   // infer offsets and/or insert padding as necessary
   int o = 0;
-  for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
+  for (auto m = ms.begin(); m != ms.end(); ++m) {
     if (!isMonoSingular(m->type)) {
       return ms;
     }
@@ -1236,7 +1218,7 @@ unsigned int Record::maxFieldAlignment() const {
 
 unsigned int Record::size() const {
   // a record with no members is equivalent to unit
-  if (this->ms.size() == 0) {
+  if (this->ms.empty()) {
     return 0;
   }
 
@@ -1261,15 +1243,15 @@ Record::Members Record::withExplicitPadding(const Members& ms, const std::string
   int     o = 0; // the active determined offset in memory
   int     p = 0; // unique names for pad fields
 
-  for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-    if (m->offset > o) {
-      r.push_back(Member(pfx + str::from(p++), arrayty(prim<char>(), m->offset - o)));
+  for (const auto &m : ms) {
+    if (m.offset > o) {
+      r.push_back(Member(pfx + str::from(p++), arrayty(prim<char>(), m.offset - o)));
     }
-    size_t msz = sizeOf(m->type);
-    o = m->offset + msz;
+    size_t msz = sizeOf(m.type);
+    o = m.offset + msz;
 
     if (msz > 0) {
-      r.push_back(*m);
+      r.push_back(m);
     }
   }
 
@@ -1277,7 +1259,7 @@ Record::Members Record::withExplicitPadding(const Members& ms, const std::string
   unsigned int talign = maxFieldAlignmentF(ms);
 
   if (talign > 0) {
-    unsigned int asz = align<unsigned int>(o, talign);
+    auto asz = align<unsigned int>(o, talign);
     if (int(asz) > o) {
       r.push_back(Member(pfx + str::from(p++), arrayty(prim<char>(), asz - o)));
     }
@@ -1287,8 +1269,8 @@ Record::Members Record::withExplicitPadding(const Members& ms, const std::string
 }
 
 bool isTupleDesc(const Record::Members& ms) {
-  for (unsigned int i = 0; i < ms.size(); ++i) {
-    if (ms[i].field.substr(0, 2) == ".f") {
+  for (const auto &m : ms) {
+    if (m.field.substr(0, 2) == ".f") {
       return true;
     }
   }
@@ -1299,10 +1281,10 @@ void showAsTuple(std::ostream& out, const Record::Members& ms) {
   bool once = false;
 
   out << "(";
-  for (size_t i = 0; i < ms.size(); ++i) {
+  for (const auto &m : ms) {
     if (once) { out << " * "; }
-    if (ms[i].field.size() > 2 && ms[i].field[1] != 'p') {
-      ms[i].type->show(out);
+    if (m.field.size() > 2 && m.field[1] != 'p') {
+      m.type->show(out);
       once = true;
     }
   }
@@ -1310,7 +1292,7 @@ void showAsTuple(std::ostream& out, const Record::Members& ms) {
 }
 
 void showAsRecord(std::ostream& out, const Record::Members& ms) {
-  if (ms.size() == 0) {
+  if (ms.empty()) {
     out << "{}";
   } else {
     out << "{ ";
@@ -1347,7 +1329,7 @@ bool Record::isTuple() const {
 }
 
 const MonoTypePtr& Record::member(const std::string& mn) const {
-  if (auto m = mmember(mn)) {
+  if (const auto *m = mmember(mn)) {
     return m->type;
   }
 
@@ -1361,7 +1343,7 @@ const MonoTypePtr& Record::member(const std::string& mn) const {
   str::seq suggestions = str::closestMatches(mn, selectNames(this->ms), 3);
   if (suggestions.size() == 1) {
     throw std::runtime_error("Field '" + mn + "' (did you mean '" + suggestions[0] + "'?) does not exist in type: " + tdesc.substr(0, truncTyLen) + "...");
-  } else if (suggestions.size() > 0) {
+  } else if (!suggestions.empty()) {
     std::ostringstream ss;
     ss << "Field '" << mn << "' (did you mean one of: '" << suggestions[0] << "'";
     for (size_t i = 1; i < suggestions.size(); ++i) {
@@ -1379,12 +1361,12 @@ unsigned int Record::index(const std::string& mn) const {
 }
 
 const Record::Member* Record::mmember(const std::string& mn) const {
-  for (Members::const_iterator m = this->ms.begin(); m != this->ms.end(); ++m) {
-    if (m->field == mn) {
-      return &(*m);
+  for (const auto &m : this->ms) {
+    if (m.field == mn) {
+      return &m;
     }
   }
-  return 0;
+  return nullptr;
 }
 
 const Record::Members& Record::members() const {
@@ -1401,13 +1383,13 @@ unsigned int Record::alignedIndex(const std::string& mn) const {
 
 unsigned int Record::index(const Members& ms, const std::string& mn) const {
   unsigned int k = 0;
-  for (Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
+  for (const auto &m : ms) {
     // pretend that we don't see fields with unit type
     //   (they don't make it into the final compiled record anyway)
-    if (m->field == mn) {
+    if (m.field == mn) {
       return k;
     }
-    if (!isUnit(m->type)) {
+    if (!isUnit(m.type)) {
       ++k;
     }
   }
@@ -1430,7 +1412,7 @@ const MonoTypePtr& Func::result() const { return this->rty; }
 MonoTypes Func::parameters() const {
   // simplify multi-argument lookup
   const Record* arty = is<Record>(this->aty);
-  if (arty && arty->isTuple()) {
+  if ((arty != nullptr) && arty->isTuple()) {
     return selectTypes(arty->members());
   } else {
     return list(this->aty);
@@ -1525,11 +1507,11 @@ UnitV walkTy::with(const OpaquePtr*   ) const { return unitv; }
 UnitV walkTy::with(const TVar*        ) const { return unitv; }
 UnitV walkTy::with(const TGen*        ) const { return unitv; }
 UnitV walkTy::with(const TAbs*       v) const { switchOf(v->body(), *this); return unitv; }
-UnitV walkTy::with(const TApp*       v) const { switchOf(v->fn(), *this); for (auto a : v->args()) { switchOf(a, *this); } return unitv; }
+UnitV walkTy::with(const TApp*       v) const { switchOf(v->fn(), *this); for (const auto& a : v->args()) { switchOf(a, *this); } return unitv; }
 UnitV walkTy::with(const FixedArray* v) const { switchOf(v->type(), *this); switchOf(v->length(), *this); return unitv; }
 UnitV walkTy::with(const Array*      v) const { switchOf(v->type(), *this); return unitv; }
-UnitV walkTy::with(const Variant*    v) const { for (auto c : v->members()) { switchOf(c.type, *this); } return unitv; }
-UnitV walkTy::with(const Record*     v) const { for (auto f : v->members()) { switchOf(f.type, *this); } return unitv; }
+UnitV walkTy::with(const Variant*    v) const { for (const auto& c : v->members()) { switchOf(c.type, *this); } return unitv; }
+UnitV walkTy::with(const Record*     v) const { for (const auto& f : v->members()) { switchOf(f.type, *this); } return unitv; }
 UnitV walkTy::with(const Func*       v) const { switchOf(v->argument(), *this); switchOf(v->result(), *this); return unitv; }
 UnitV walkTy::with(const Exists*     v) const { switchOf(v->absType(), *this); return unitv; }
 UnitV walkTy::with(const Recursive*  v) const { switchOf(v->recType(), *this); return unitv; }
@@ -1564,23 +1546,23 @@ MonoTypePtr clone(const MonoTypePtr& t) { return t; }
 MonoTypePtr clone(const MonoType*    t) { return clone(*t); }
 
 struct cloneF : public switchType<MonoTypePtr> {
-  MonoTypePtr with(const Prim*       v) const { return Prim::make(v->name(), v->representation()); }
-  MonoTypePtr with(const OpaquePtr*  v) const { return OpaquePtr::make(v->name(), v->size(), v->storedContiguously()); }
-  MonoTypePtr with(const TVar*       v) const { return TVar::make(v->name()); }
-  MonoTypePtr with(const TGen*       v) const { return TGen::make(v->id()); }
-  MonoTypePtr with(const TAbs*       v) const { return TAbs::make(v->args(), v->body()); }
-  MonoTypePtr with(const TApp*       v) const { return TApp::make(v->fn(), v->args()); }
-  MonoTypePtr with(const FixedArray* v) const { return FixedArray::make(v->type(), v->length()); }
-  MonoTypePtr with(const Array*      v) const { return Array::make(v->type()); }
-  MonoTypePtr with(const Variant*    v) const { return Variant::make(v->members()); }
-  MonoTypePtr with(const Record*     v) const { return Record::make(v->members()); }
-  MonoTypePtr with(const Func*       v) const { return Func::make(v->argument(), v->result()); }
-  MonoTypePtr with(const Exists*     v) const { return Exists::make(v->absTypeName(), v->absType()); }
-  MonoTypePtr with(const Recursive*  v) const { return Recursive::make(v->recTypeName(), v->recType()); }
+  MonoTypePtr with(const Prim*       v) const override { return Prim::make(v->name(), v->representation()); }
+  MonoTypePtr with(const OpaquePtr*  v) const override { return OpaquePtr::make(v->name(), v->size(), v->storedContiguously()); }
+  MonoTypePtr with(const TVar*       v) const override { return TVar::make(v->name()); }
+  MonoTypePtr with(const TGen*       v) const override { return TGen::make(v->id()); }
+  MonoTypePtr with(const TAbs*       v) const override { return TAbs::make(v->args(), v->body()); }
+  MonoTypePtr with(const TApp*       v) const override { return TApp::make(v->fn(), v->args()); }
+  MonoTypePtr with(const FixedArray* v) const override { return FixedArray::make(v->type(), v->length()); }
+  MonoTypePtr with(const Array*      v) const override { return Array::make(v->type()); }
+  MonoTypePtr with(const Variant*    v) const override { return Variant::make(v->members()); }
+  MonoTypePtr with(const Record*     v) const override { return Record::make(v->members()); }
+  MonoTypePtr with(const Func*       v) const override { return Func::make(v->argument(), v->result()); }
+  MonoTypePtr with(const Exists*     v) const override { return Exists::make(v->absTypeName(), v->absType()); }
+  MonoTypePtr with(const Recursive*  v) const override { return Recursive::make(v->recTypeName(), v->recType()); }
   
-  MonoTypePtr with(const TString* v) const { return TString::make(v->value()); }
-  MonoTypePtr with(const TLong*   v) const { return TLong::make(v->value()); }
-  MonoTypePtr with(const TExpr*   v) const { return TExpr::make(v->expr()); }
+  MonoTypePtr with(const TString* v) const override { return TString::make(v->value()); }
+  MonoTypePtr with(const TLong*   v) const override { return TLong::make(v->value()); }
+  MonoTypePtr with(const TExpr*   v) const override { return TExpr::make(v->expr()); }
 };
 MonoTypePtr clone(const MonoType& t) { return switchOf(t, cloneF()); }
 
@@ -1597,11 +1579,11 @@ MonoTypePtr cloneP(const MonoTypePtr& p) {
 ///////////////////
 QualTypePtr lookupFieldType(const QualTypePtr& qt, const std::string& fieldName) {
   MonoTypePtr mt = lookupFieldType(qt->monoType(), fieldName);
-  return QualTypePtr(new QualType(qt->constraints(), mt));
+  return std::make_shared<QualType>(qt->constraints(), mt);
 }
 
 MonoTypePtr lookupFieldType(const MonoTypePtr& mt, const std::string& fieldName) {
-  if (Record* rt = is<Record>(mt)) {
+  if (auto* rt = is<Record>(mt)) {
     return rt->member(fieldName);
   } else {
     throw std::runtime_error("Cannot index field '" + fieldName + "' in non-record type: " + show(mt));
@@ -1619,8 +1601,8 @@ Constraints mergeConstraints(const Constraints& lhs, const Constraints& rhs) {
 }
 
 void mergeConstraints(const Constraints& fcs, Constraints* tcs) {
-  for (Constraints::const_iterator c = fcs.begin(); c != fcs.end(); ++c) {
-    tcs->push_back(*c);
+  for (const auto &fc : fcs) {
+    tcs->push_back(fc);
   }
 }
 
@@ -1658,8 +1640,8 @@ MonoTypes freshen(const MonoTypes& ts) {
   MonoTypeSubst s;
 
   NameSet tvns = tvarNames(ts);
-  for (NameSet::const_iterator n = tvns.begin(); n != tvns.end(); ++n) {
-    s[*n] = freshTypeVar();
+  for (const auto &tvn : tvns) {
+    s[tvn] = freshTypeVar();
   }
 
   return substitute(s, ts);
@@ -1668,8 +1650,8 @@ MonoTypes freshen(const MonoTypes& ts) {
 ConstraintPtr freshen(const ConstraintPtr& cst) {
   NameSet cvns = tvarNames(cst);
   MonoTypeSubst s;
-  for (NameSet::const_iterator cvn = cvns.begin(); cvn != cvns.end(); ++cvn) {
-    s[*cvn] = freshTypeVar();
+  for (const auto &cvn : cvns) {
+    s[cvn] = freshTypeVar();
   }
   return substitute(s, cst);
 }
@@ -1677,16 +1659,16 @@ ConstraintPtr freshen(const ConstraintPtr& cst) {
 Constraints freshen(const Constraints& cs) {
   NameSet cvns = tvarNames(cs);
   MonoTypeSubst s;
-  for (NameSet::const_iterator cvn = cvns.begin(); cvn != cvns.end(); ++cvn) {
-    s[*cvn] = freshTypeVar();
+  for (const auto &cvn : cvns) {
+    s[cvn] = freshTypeVar();
   }
   return substitute(s, cs);
 }
 
 MonoTypes typeVars(const Names& ns) {
   MonoTypes r;
-  for (Names::const_iterator n = ns.begin(); n != ns.end(); ++n) {
-    r.push_back(TVar::make(*n));
+  for (const auto &n : ns) {
+    r.push_back(TVar::make(n));
   }
   return r;
 }
@@ -1700,12 +1682,12 @@ MonoTypes tgens(int c) {
 }
 
 // determine whether or not a monotype actually contains references to any type variables or variable generator points
-bool isMonoSingular(const MonoType& mt)    { return mt.freeTVars.size() == 0 && mt.tgenCount == 0; }
+bool isMonoSingular(const MonoType& mt)    { return mt.freeTVars.empty() && mt.tgenCount == 0; }
 bool isMonoSingular(const MonoType* mt)    { return isMonoSingular(*mt); }
 bool isMonoSingular(const MonoTypePtr& mt) { return isMonoSingular(*mt); }
 
 bool isMonoSingular(const QualTypePtr& qt) {
-  return qt->constraints().size() == 0 && isMonoSingular(qt->monoType());
+  return qt->constraints().empty() && isMonoSingular(qt->monoType());
 }
 
 // find the highest TGen reference (useful for deducing the number of type variables required to generalize a mono type)
@@ -1715,8 +1697,8 @@ int tgenSize(const MonoTypePtr& mt) {
 
 int tgenSize(const MonoTypes& mts) {
   int x = 0;
-  for (MonoTypes::const_iterator mt = mts.begin(); mt != mts.end(); ++mt) {
-    x = std::max<int>(x, tgenSize(*mt));
+  for (const auto &mt : mts) {
+    x = std::max<int>(x, tgenSize(mt));
   }
   return x;
 }
@@ -1734,7 +1716,7 @@ struct tgenVarsF : public walkTy {
   TGenVarSet* s;
   tgenVarsF(TGenVarSet* s) : s(s) { }
 
-  UnitV with(const TGen* v) const {
+  UnitV with(const TGen* v) const override {
     this->s->insert(v->id());
     return unitv;
   }
@@ -1759,13 +1741,13 @@ MonoTypePtr   instantiate(int vs, const MonoTypePtr& mt)     { if (vs == 0 || is
 MonoTypes     instantiate(int vs, const MonoTypes& ts)       { if (vs == 0)                       { return ts;     } else { return instantiate(freshTypeVars(vs), ts);     } }
 
 QualTypePtr instantiate(const MonoTypes& ts, const QualTypePtr& scheme) {
-  return QualTypePtr(new QualType(instantiate(ts, scheme->constraints()), instantiate(ts, scheme->monoType())));
+  return std::make_shared<QualType>(instantiate(ts, scheme->constraints()), instantiate(ts, scheme->monoType()));
 }
 
 Constraints instantiate(const MonoTypes& ts, const Constraints& cs) {
   Constraints r;
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    r.push_back(instantiate(ts, *c));
+  for (const auto &c : cs) {
+    r.push_back(instantiate(ts, c));
   }
   return r;
 }
@@ -1778,7 +1760,7 @@ class instantiateF : public switchTyFn {
 public:
   instantiateF(const MonoTypes& ts) : ts(ts) { }
 
-  MonoTypePtr with(const TGen* v) const {
+  MonoTypePtr with(const TGen* v) const override {
     return MonoTypePtr(this->ts[v->id()]);
   }
 private:
@@ -1795,7 +1777,7 @@ MonoTypePtr instantiate(const MonoTypes& ts, const MonoTypePtr& mt) {
 
 MonoTypes instantiate(const MonoTypes& ts, const MonoTypes& sts) {
   MonoTypes result;
-  for (auto st : sts) {
+  for (const auto& st : sts) {
     result.push_back(instantiate(ts, st));
   }
   return result;
@@ -1850,8 +1832,8 @@ void tvarNames(const QualTypePtr& qt, NameSet* out) {
 }
 
 void tvarNames(const Constraints& cs, NameSet* out) {
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    tvarNames(*c, out);
+  for (const auto &c : cs) {
+    tvarNames(c, out);
   }
 }
 
@@ -1893,8 +1875,8 @@ bool hasFreeVariables(const QualTypePtr& qt) {
 }
 
 bool hasFreeVariables(const Constraints& cs) {
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    if (hasFreeVariables(*c)) {
+  for (const auto &c : cs) {
+    if (hasFreeVariables(c)) {
       return true;
     }
   }
@@ -1910,8 +1892,8 @@ bool hasFreeVariables(const MonoTypePtr& mt) {
 }
 
 bool hasFreeVariables(const MonoTypes& mts) {
-  for (MonoTypes::const_iterator mt = mts.begin(); mt != mts.end(); ++mt) {
-    if (hasFreeVariables(*mt)) {
+  for (const auto &mt : mts) {
+    if (hasFreeVariables(mt)) {
       return true;
     }
   }
@@ -1926,31 +1908,31 @@ std::string show(const MonoTypeSubst& s) {
   stbl[1].push_back("");
   stbl[2].push_back("Type");
 
-  for (MonoTypeSubst::const_iterator si = s.begin(); si != s.end(); ++si) {
-    stbl[0].push_back(si->first);
+  for (const auto &si : s) {
+    stbl[0].push_back(si.first);
     stbl[1].push_back(" = ");
-    stbl[2].push_back(show(si->second));
+    stbl[2].push_back(show(si.second));
   }
 
   return str::showLeftAlignedTable(stbl);
 }
 
 void show(const MonoTypeSubst& s, std::ostream& out) {
-  for (MonoTypeSubst::const_iterator si = s.begin(); si != s.end(); ++si) {
-    out << si->first << " = " << std::flush;
-    si->second->show(out);
+  for (const auto &si : s) {
+    out << si.first << " = " << std::flush;
+    si.second->show(out);
     out << std::endl;
   }
 }
 
 // simplifying substitution from free type variables
 QualTypePtr substitute(const MonoTypeSubst& s, const QualTypePtr& qt) {
-  return QualTypePtr(new QualType(substitute(s, qt->constraints()), substitute(s, qt->monoType())));
+  return std::make_shared<QualType>(substitute(s, qt->constraints()), substitute(s, qt->monoType()));
 }
 
 inline bool in(const ConstraintPtr& c, const Constraints& cs) {
-  for (Constraints::const_iterator ci = cs.begin(); ci != cs.end(); ++ci) {
-    if (*c == **ci) {
+  for (const auto &ci : cs) {
+    if (*c == *ci) {
       return true;
     }
   }
@@ -1959,10 +1941,10 @@ inline bool in(const ConstraintPtr& c, const Constraints& cs) {
 
 Constraints substitute(const MonoTypeSubst& s, const Constraints& cs) {
   Constraints r;
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    ConstraintPtr sc = substitute(s, *c);
+  for (const auto &c : cs) {
+    ConstraintPtr sc = substitute(s, c);
     if (!in(sc, r)) {
-      r.push_back(substitute(s, *c));
+      r.push_back(substitute(s, c));
     }
   }
   return r;
@@ -1976,8 +1958,8 @@ class substituteF : public switchTyFn {
 public:
   substituteF(bool transitive, const MonoTypeSubst& s) : transitive(transitive), s(s) { }
 
-  MonoTypePtr with(const TVar* v) const {
-    MonoTypeSubst::const_iterator si = this->s.find(v->name());
+  MonoTypePtr with(const TVar* v) const override {
+    auto si = this->s.find(v->name());
     if (si != this->s.end()) {
       if (this->transitive) {
         return switchOf(si->second, *this);
@@ -1989,7 +1971,7 @@ public:
     }
   }
 
-  MonoTypePtr with(const Exists* v) const {
+  MonoTypePtr with(const Exists* v) const override {
     if (this->s.find(v->absTypeName()) == this->s.end()) {
       return Exists::make(v->absTypeName(), switchOf(v->absType(), *this));
     } else {
@@ -1999,7 +1981,7 @@ public:
     }
   }
 
-  MonoTypePtr with(const Recursive* v) const {
+  MonoTypePtr with(const Recursive* v) const override {
     if (this->s.find(v->recTypeName()) == this->s.end()) {
       return Recursive::make(v->recTypeName(), switchOf(v->recType(), *this));
     } else {
@@ -2039,8 +2021,8 @@ MonoTypePtr substitute(const MonoTypeSubst& s, const MonoType& mt) {
 
 MonoTypes substitute(const MonoTypeSubst& s, const MonoTypes& ts) {
   MonoTypes r;
-  for (MonoTypes::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-    r.push_back(substitute(s, *t));
+  for (const auto &t : ts) {
+    r.push_back(substitute(s, t));
   }
   return r;
 }
@@ -2053,12 +2035,12 @@ PolyTypePtr generalize(const QualTypePtr& qt) {
   // [(v, TGen i) | (v, i) <- zip vnames [0..]]
   MonoTypeSubst s;
   int i = 0;
-  for (NameSet::const_iterator n = fnames.begin(); n != fnames.end(); ++n) {
-    s[*n] = TGen::make(i);
+  for (const auto &fname : fnames) {
+    s[fname] = TGen::make(i);
     ++i;
   }
 
-  return PolyTypePtr(new PolyType(fnames.size(), substitute(s, qt)));
+  return std::make_shared<PolyType>(fnames.size(), substitute(s, qt));
 }
 
 // simplify ugly generated variable names
@@ -2074,11 +2056,11 @@ TVName canonicalName(int v) {
 MonoTypeSubst canonicalNameSubst(const NameSet& ns) {
   MonoTypeSubst r;
   int v = 0;
-  for (NameSet::const_iterator n = ns.begin(); n != ns.end(); ++n) {
+  for (const auto &n : ns) {
     TVName cn = canonicalName(v);
     // avoid making substitution cycles
-    if (*n != cn) {
-      r[*n] = TVar::make(cn);
+    if (n != cn) {
+      r[n] = TVar::make(cn);
     }
     ++v;
   }
@@ -2087,9 +2069,9 @@ MonoTypeSubst canonicalNameSubst(const NameSet& ns) {
 
 QualTypePtr   simplifyVarNames(const PolyType&      t) { return simplifyVarNames(t.instantiate()); }
 QualTypePtr   simplifyVarNames(const PolyTypePtr&   t) { return simplifyVarNames(*t); }
-ConstraintPtr simplifyVarNames(const Constraint&    c) { return simplifyVarNames(ConstraintPtr(new Constraint(c))); }
+ConstraintPtr simplifyVarNames(const Constraint&    c) { return simplifyVarNames(std::make_shared<Constraint>(c)); }
 ConstraintPtr simplifyVarNames(const ConstraintPtr& c) { return substitute(canonicalNameSubst(tvarNames(c)), c); }
-QualTypePtr   simplifyVarNames(const QualType&      t) { return simplifyVarNames(QualTypePtr(new QualType(t.constraints(), t.monoType()))); }
+QualTypePtr   simplifyVarNames(const QualType&      t) { return simplifyVarNames(std::make_shared<QualType>(t.constraints(), t.monoType())); }
 QualTypePtr   simplifyVarNames(const QualTypePtr&   t) { return substitute(canonicalNameSubst(tvarNames(t)), t); }
 MonoTypePtr   simplifyVarNames(const MonoType&      t) { return substitute(canonicalNameSubst(tvarNames(t)), t); }
 MonoTypePtr   simplifyVarNames(const MonoTypePtr&   t) { return substitute(canonicalNameSubst(tvarNames(t)), t); }
@@ -2127,13 +2109,13 @@ MonoTypePtr repTypeStep(const MonoTypePtr& t) {
 }
 
 // compute the size of a monotype (in bytes)
-typedef unsigned int nat;
+using nat = unsigned int;
 nat nadd(nat lhs, nat rhs) { return lhs + rhs; }
 nat nmax(nat lhs, nat rhs) { return std::max<nat>(lhs, rhs); }
 
 class sizeOfF : public switchType<nat> {
 public:
-  nat with(const Prim* v) const {
+  nat with(const Prim* v) const override {
     if (v->representation()) {
       return r(v->representation());
     } else {
@@ -2141,22 +2123,22 @@ public:
     }
   }
 
-  nat with(const OpaquePtr*  v) const { return v->storedContiguously() ? v->size() : sizeof(void*); }
-  nat with(const TVar*       v) const { throw std::runtime_error("Can't determine size of type variable '" + v->name() + "'"); }
-  nat with(const TGen*       v) const { throw std::runtime_error("Can't determine size of polytype argument #" + str::from(v->id())); }
-  nat with(const FixedArray* v) const { return r(v->type()) * v->requireLength(); }
-  nat with(const Array*       ) const { return sizeof(void*); }
-  nat with(const Variant*    v) const { return rv(v); }
-  nat with(const Record*     v) const { return rv(v); }
-  nat with(const Func*        ) const { return sizeof(void*); }
-  nat with(const Exists*      ) const { return sizeof(void*); }
-  nat with(const Recursive*   ) const { return sizeof(void*); }
+  nat with(const OpaquePtr*  v) const override { return v->storedContiguously() ? v->size() : sizeof(void*); }
+  nat with(const TVar*       v) const override { throw std::runtime_error("Can't determine size of type variable '" + v->name() + "'"); }
+  nat with(const TGen*       v) const override { throw std::runtime_error("Can't determine size of polytype argument #" + str::from(v->id())); }
+  nat with(const FixedArray* v) const override { return r(v->type()) * v->requireLength(); }
+  nat with(const Array*       ) const override { return sizeof(void*); }
+  nat with(const Variant*    v) const override { return rv(v); }
+  nat with(const Record*     v) const override { return rv(v); }
+  nat with(const Func*        ) const override { return sizeof(void*); }
+  nat with(const Exists*      ) const override { return sizeof(void*); }
+  nat with(const Recursive*   ) const override { return sizeof(void*); }
 
-  nat with(const TAbs* v) const {
+  nat with(const TAbs* v) const override {
     throw std::runtime_error("Can't determine size of type abstraction: " + show(v));
   }
 
-  nat with(const TApp* v) const {
+  nat with(const TApp* v) const override {
     // uncurry type function applications
     while (const TApp* lv = is<TApp>(v->fn())) {
       v = lv;
@@ -2194,9 +2176,9 @@ public:
   }
 
   // type-level values/expressions have no runtime content (they're equivalent to unit)
-  nat with(const TString* ) const { return 0; }
-  nat with(const TLong*   ) const { return 0; }
-  nat with(const TExpr*   ) const { return 0; }
+  nat with(const TString* ) const override { return 0; }
+  nat with(const TLong*   ) const override { return 0; }
+  nat with(const TExpr*   ) const override { return 0; }
 private:
   nat withPrim(const std::string& pn) const {
     if (pn == "unit") {
@@ -2267,8 +2249,8 @@ bool isPrimName(const std::string& tn) {
     "->", "closure", "fseq", "file"
   };
   
-  for (unsigned int i = 0; i < sizeof(prims)/sizeof(prims[0]); ++i) {
-    if (tn == prims[i]) {
+  for (const auto &prim : prims) {
+    if (tn == prim) {
       return true;
     }
   }
@@ -2300,7 +2282,7 @@ PolyTypePtr nulltypedb::generalize(const MonoTypePtr& mt) const { return polytyp
 nulltypedb nulltdb;
 
 bool isMonotype(const QualTypePtr& qt) {
-  return qt->constraints().size() == 0;
+  return qt->constraints().empty();
 }
 
 bool isMonotype(const PolyTypePtr& pt) {
@@ -2325,8 +2307,8 @@ MonoTypePtr requireMonotype(const PolyTypePtr& pt) {
 
 MonoTypes requireMonotype(const PolyTypes& pts) {
   MonoTypes r;
-  for (PolyTypes::const_iterator pt = pts.begin(); pt != pts.end(); ++pt) {
-    r.push_back(requireMonotype(*pt));
+  for (const auto &pt : pts) {
+    r.push_back(requireMonotype(pt));
   }
   return r;
 }
@@ -2351,7 +2333,7 @@ QualTypePtr unpackedType(const QualTypePtr& qty) {
 }
 
 // support an efficient binary codec for type descriptions
-typedef std::vector<unsigned char> bytes;
+using bytes = std::vector<unsigned char>;
 
 void write(bool b,               bytes* out) { out->push_back(b ? 0x01 : 0x00); }
 void write(char c,               bytes* out) { out->push_back(c); }
@@ -2435,7 +2417,7 @@ class encodeMonoTypeF : public switchType<UnitV> {
 public:
   encodeMonoTypeF(bytes* out) : out(out) { }
 
-  UnitV with(const Prim* v) const {
+  UnitV with(const Prim* v) const override {
     write(Prim::type_case_id, this->out);
     write(v->name(),          this->out);
     if (v->representation()) {
@@ -2447,7 +2429,7 @@ public:
     return unitv;
   }
 
-  UnitV with(const OpaquePtr* v) const {
+  UnitV with(const OpaquePtr* v) const override {
     write(OpaquePtr::type_case_id, this->out);
     write(v->name(),               this->out);
     write(v->size(),               this->out);
@@ -2455,26 +2437,26 @@ public:
     return unitv;
   }
 
-  UnitV with(const TGen* v) const {
+  UnitV with(const TGen* v) const override {
     write(TGen::type_case_id, this->out);
     write(v->id(),            this->out);
     return unitv;
   }
 
-  UnitV with(const TVar* v) const {
+  UnitV with(const TVar* v) const override {
     write(TVar::type_case_id, this->out);
     write(v->name(),          this->out);
     return unitv;
   }
 
-  UnitV with(const TAbs* v) const {
+  UnitV with(const TAbs* v) const override {
     write(TAbs::type_case_id, this->out);
     write(v->args(), this->out);
     switchOf(v->body(), *this);
     return unitv;
   }
 
-  UnitV with(const TApp* v) const {
+  UnitV with(const TApp* v) const override {
     write(TApp::type_case_id, this->out);
 
     switchOf(v->fn(), *this);
@@ -2485,7 +2467,7 @@ public:
     return unitv;
   }
 
-  UnitV with(const FixedArray* v) const {
+  UnitV with(const FixedArray* v) const override {
     write(FixedArray::type_case_id, this->out);
 
     switchOf(v->type(),   *this);
@@ -2493,53 +2475,53 @@ public:
     return unitv;
   }
 
-  UnitV with(const Array* v) const {
+  UnitV with(const Array* v) const override {
     write(Array::type_case_id, this->out);
 
     switchOf(v->type(), *this);
     return unitv;
   }
 
-  UnitV with(const Variant* v) const {
+  UnitV with(const Variant* v) const override {
     write(Variant::type_case_id, this->out);
 
     const Variant::Members& ms = v->members();
     write(ms.size(), this->out);
 
-    for (Variant::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-      write(m->selector, this->out);
-      write(m->id,       this->out);
+    for (const auto &m : ms) {
+      write(m.selector, this->out);
+      write(m.id,       this->out);
 
-      switchOf(m->type, *this);
+      switchOf(m.type, *this);
     }
 
     return unitv;
   }
 
-  UnitV with(const Record* v) const {
+  UnitV with(const Record* v) const override {
     write(Record::type_case_id, this->out);
 
     const Record::Members& ms = v->members();
     write(ms.size(), this->out);
 
-    for (Record::Members::const_iterator m = ms.begin(); m != ms.end(); ++m) {
-      write(m->field,  this->out);
-      write(m->offset, this->out);
+    for (const auto &m : ms) {
+      write(m.field,  this->out);
+      write(m.offset, this->out);
 
-      switchOf(m->type, *this);
+      switchOf(m.type, *this);
     }
 
     return unitv;
   }
 
-  UnitV with(const Func* v) const {
+  UnitV with(const Func* v) const override {
     write(Func::type_case_id, this->out);
     switchOf(v->argument(), *this);
     switchOf(v->result(),   *this);
     return unitv;
   }
 
-  UnitV with(const Exists* v) const {
+  UnitV with(const Exists* v) const override {
     write(Exists::type_case_id, this->out);
     write(v->absTypeName(),     this->out);
 
@@ -2547,7 +2529,7 @@ public:
     return unitv;
   }
 
-  UnitV with(const Recursive* v) const {
+  UnitV with(const Recursive* v) const override {
     write(Recursive::type_case_id, this->out);
     write(v->recTypeName(),        this->out);
 
@@ -2555,19 +2537,19 @@ public:
     return unitv;
   }
 
-  UnitV with(const TString* v) const {
+  UnitV with(const TString* v) const override {
     write(TString::type_case_id, this->out);
     write(v->value(),            this->out);
     return unitv;
   }
 
-  UnitV with(const TLong* v) const {
+  UnitV with(const TLong* v) const override {
     write(TLong::type_case_id, this->out);
     write(v->value(),          this->out);
     return unitv;
   }
 
-  UnitV with(const TExpr* v) const {
+  UnitV with(const TExpr* v) const override {
     write(TExpr::type_case_id, this->out);
     std::vector<uint8_t> ebs;
     encode(stripAssumpHead(v->expr()), &ebs);
@@ -2608,7 +2590,7 @@ MonoTypePtr decodePrim(const bytes& in, unsigned int* n) {
 
 MonoTypePtr decodeOpaquePtr(const bytes& in, unsigned int* n) {
   std::string  s  = read<std::string>(in, n);
-  unsigned int sz = read<unsigned int>(in, n);
+  auto sz = read<unsigned int>(in, n);
   bool         sc = read<bool>(in, n);
 
   return OpaquePtr::make(s, sz, sc);
@@ -2631,7 +2613,7 @@ MonoTypePtr decodeTApp(const bytes& in, unsigned int* n) {
   MonoTypePtr f = decodeFrom(in, n);
 
   MonoTypes args;
-  size_t sz = read<size_t>(in, n);
+  auto sz = read<size_t>(in, n);
   for (size_t i = 0; i < sz; ++i) {
     args.push_back(decodeFrom(in, n));
   }
@@ -2661,10 +2643,10 @@ MonoTypePtr decodeArr(const bytes& in, unsigned int* n) {
 MonoTypePtr decodeVariant(const bytes& in, unsigned int* n) {
   Variant::Members ms;
 
-  size_t c = read<size_t>(in, n);
+  auto c = read<size_t>(in, n);
   for (size_t i = 0; i < c; ++i) {
     std::string  ctor = read<std::string>(in, n);
-    unsigned int id   = read<unsigned int>(in, n);
+    auto id   = read<unsigned int>(in, n);
     MonoTypePtr  ty   = decodeFrom(in, n);
 
     ms.push_back(Variant::Member(ctor, ty, id));
@@ -2676,10 +2658,10 @@ MonoTypePtr decodeVariant(const bytes& in, unsigned int* n) {
 MonoTypePtr decodeRecord(const bytes& in, unsigned int* n) {
   Record::Members ms;
 
-  size_t c = read<size_t>(in, n);
+  auto c = read<size_t>(in, n);
   for (size_t i = 0; i < c; ++i) {
     std::string  field  = read<std::string>(in, n);
-    unsigned int offset = read<unsigned int>(in, n);
+    auto offset = read<unsigned int>(in, n);
     MonoTypePtr  ty     = decodeFrom(in, n);
 
     ms.push_back(Record::Member(field, ty, offset));
@@ -2786,7 +2768,7 @@ void decode(MonoTypePtr* mty, std::istream& in) {
   std::vector<unsigned char> cs;
   decode(&cs, in);
 
-  if (cs.size() == 0) {
+  if (cs.empty()) {
     throw std::runtime_error("Type data corrupted in source file");
   }
 
@@ -2795,7 +2777,7 @@ void decode(MonoTypePtr* mty, std::istream& in) {
 
 // open opaque type aliases not defined by this library
 struct unaliasPrimTypesF : public switchTyFn {
-  MonoTypePtr with(const Prim* t) const {
+  MonoTypePtr with(const Prim* t) const override {
     if (t->representation()) {
       // well this is awkward ...
       if (t->name() != "time" && t->name() != "datetime" && t->name() != "timespan") {
@@ -2810,7 +2792,7 @@ MonoTypePtr unalias(const MonoTypePtr& ty) {
   if (isMonoSingular(ty)) {
     return switchOf(ty, unaliasPrimTypesF());
   } else {
-    if (!ty->unaliasedType.get()) {
+    if (ty->unaliasedType.get() == nullptr) {
       ty->unaliasedType = switchOf(ty, unaliasPrimTypesF());
     }
     return ty->unaliasedType;
diff --git a/lib/hobbes/lang/typeinf.C b/lib/hobbes/lang/typeinf.C
index d0fd56673..d01752d20 100644
--- a/lib/hobbes/lang/typeinf.C
+++ b/lib/hobbes/lang/typeinf.C
@@ -1,8 +1,9 @@
+#include <hobbes/lang/constraints.H>
 #include <hobbes/lang/typeinf.H>
 #include <hobbes/lang/typepreds.H>
-#include <hobbes/lang/constraints.H>
 #include <hobbes/util/array.H>
 #include <hobbes/util/perf.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -23,7 +24,7 @@ const UTypeRec& MoreDefinedType::apply(const UTypeRec& lhs, const UTypeRec& rhs)
       return rhs;
     }
   } else {
-    if (is<TVar>(rhs.ty)) {
+    if (is<TVar>(rhs.ty) != nullptr) {
       return lhs;
     } else {
       return (tvarNames(lhs.ty).size() < tvarNames(rhs.ty).size()) ? lhs : rhs;
@@ -60,13 +61,13 @@ void MonoTypeUnifier::suppress(const std::string& vn) {
 }
 
 void MonoTypeUnifier::suppress(const str::seq& vns) {
-  for (str::seq::const_iterator vn = vns.begin(); vn != vns.end(); ++vn) {
-    suppress(*vn);
+  for (const auto &vn : vns) {
+    suppress(vn);
   }
 }
 
 void MonoTypeUnifier::unsuppress(const std::string& vn) {
-  SuppressVarCounts::iterator vnc = this->suppressVarCounts.find(vn);
+  auto vnc = this->suppressVarCounts.find(vn);
 
   if (vnc != this->suppressVarCounts.end()) {
     if (--vnc->second == 0) {
@@ -76,13 +77,13 @@ void MonoTypeUnifier::unsuppress(const std::string& vn) {
 }
 
 void MonoTypeUnifier::unsuppress(const str::seq& vns) {
-  for (str::seq::const_iterator vn = vns.begin(); vn != vns.end(); ++vn) {
-    unsuppress(*vn);
+  for (const auto &vn : vns) {
+    unsuppress(vn);
   }
 }
 
 bool MonoTypeUnifier::suppressed(const std::string& vn) const {
-  SuppressVarCounts::const_iterator vnc = this->suppressVarCounts.find(vn);
+  auto vnc = this->suppressVarCounts.find(vn);
   return vnc != this->suppressVarCounts.end() && vnc->second > 0;
 }
 
@@ -112,27 +113,27 @@ struct encodeCtorForm : public switchType<std::string> {
 
   encodeCtorForm(const MonoTypePtr& forTy, MonoTypes* targs, str::seq* ignvs) : forTy(forTy), targs(targs), ignvs(ignvs) { }
 
-  std::string with(const Prim* v) const {
+  std::string with(const Prim* v) const override {
     return "prim:" + v->name();
   }
 
-  std::string with(const OpaquePtr* v) const {
+  std::string with(const OpaquePtr* v) const override {
     return "ptr" + std::string(v->storedContiguously() ? "c" : "") + ":" + v->name();
   }
 
-  std::string with(const TVar* v) const {
+  std::string with(const TVar* v) const override {
     return "var:" + v->name();
   }
 
-  std::string with(const TGen* v) const {
+  std::string with(const TGen* v) const override {
     return "tgen:" + str::from(v->id());
   }
 
-  std::string with(const TAbs* v) const {
+  std::string with(const TAbs* v) const override {
     return "tabs:" + show(v);
   }
 
-  std::string with(const TApp* v) const {
+  std::string with(const TApp* v) const override {
     this->targs->push_back(v->fn());
     for (const auto& arg : v->args()) {
       this->targs->push_back(arg);
@@ -140,64 +141,64 @@ struct encodeCtorForm : public switchType<std::string> {
     return "tapp";
   }
 
-  std::string with(const FixedArray* v) const {
+  std::string with(const FixedArray* v) const override {
     this->targs->push_back(v->type());
     this->targs->push_back(v->length());
     return "farray";
   }
 
-  std::string with(const Array* v) const {
+  std::string with(const Array* v) const override {
     this->targs->push_back(v->type());
     return "array";
   }
 
-  std::string with(const Variant* v) const {
+  std::string with(const Variant* v) const override {
     std::ostringstream vn;
     vn << "variant:";
-    for (Variant::Members::const_iterator c = v->members().begin(); c != v->members().end(); ++c) {
-      vn << c->selector << "=" << ";";
-      this->targs->push_back(c->type);
+    for (const auto &c : v->members()) {
+      vn << c.selector << "=" << ";";
+      this->targs->push_back(c.type);
     }
     return vn.str();
   }
 
-  std::string with(const Record* v) const {
+  std::string with(const Record* v) const override {
     std::ostringstream rn;
     rn << "record:";
-    for (Record::Members::const_iterator f = v->members().begin(); f != v->members().end(); ++f) {
-      rn << f->field << "=" << ";";
-      this->targs->push_back(f->type);
+    for (const auto &f : v->members()) {
+      rn << f.field << "=" << ";";
+      this->targs->push_back(f.type);
     }
     return rn.str();
   }
 
-  std::string with(const Func* v) const {
+  std::string with(const Func* v) const override {
     this->targs->push_back(v->argument());
     this->targs->push_back(v->result());
     return "->";
   }
 
-  std::string with(const Exists* v) const {
+  std::string with(const Exists* v) const override {
     this->ignvs->push_back(v->absTypeName());
     this->targs->push_back(v->absType());
     return "exists";
   }
   
-  std::string with(const Recursive* v) const {
+  std::string with(const Recursive* v) const override {
     this->ignvs->push_back(v->recTypeName());
     this->targs->push_back(v->recType());
     return "recur";
   }
 
-  std::string with(const TString* v) const {
+  std::string with(const TString* v) const override {
     return "string:" + v->value();
   }
 
-  std::string with(const TLong* v) const {
+  std::string with(const TLong* v) const override {
     return "long:" + str::from(v->value());
   }
 
-  std::string with(const TExpr* v) const {
+  std::string with(const TExpr* v) const override {
     return "expr:" + show(v);
   }
 };
@@ -217,7 +218,7 @@ void MonoTypeUnifier::unify(const MonoTypePtr& lhs, const MonoTypePtr& rhs) {
 
   if (lhsv != rhsv) {
     // unify the constituents of these types (if applicable)
-    if (!is<TVar>(lhsv) && !is<TVar>(rhsv)) {
+    if ((is<TVar>(lhsv) == nullptr) && (is<TVar>(rhsv) == nullptr)) {
       str::seq ignvs;
 
       std::string lhscn;
@@ -258,22 +259,22 @@ struct substituteInto : public switchTyFn {
   UTypeRec&        uty;
   substituteInto(MonoTypeUnifier* s, UTypeRec& uty) : s(s), uty(uty) { }
 
-  MonoTypePtr with(const TVar* v) const {
+  MonoTypePtr with(const TVar* v) const override {
     return this->s->binding(v->name());
   }
 
-  MonoTypePtr with(const TApp* v) const {
+  MonoTypePtr with(const TApp* v) const override {
     this->uty.visited = true;
     MonoTypePtr f = this->s->substitute(v->fn());
     MonoTypes args;
-    for (auto& arg : v->args()) {
+    for (const auto& arg : v->args()) {
       args.push_back(this->s->substitute(arg));
     }
     this->uty.visited = false;
     return MonoTypePtr(TApp::make(f, args));
   }
 
-  MonoTypePtr with(const FixedArray* v) const {
+  MonoTypePtr with(const FixedArray* v) const override {
     this->uty.visited = true;
     MonoTypePtr t = this->s->substitute(v->type());
     MonoTypePtr l = this->s->substitute(v->length());
@@ -281,14 +282,14 @@ struct substituteInto : public switchTyFn {
     return MonoTypePtr(FixedArray::make(t, l));
   }
 
-  MonoTypePtr with(const Array* v) const {
+  MonoTypePtr with(const Array* v) const override {
     this->uty.visited = true;
     MonoTypePtr e = this->s->substitute(v->type());
     this->uty.visited = false;
     return MonoTypePtr(Array::make(e));
   }
 
-  MonoTypePtr with(const Variant* v) const {
+  MonoTypePtr with(const Variant* v) const override {
     this->uty.visited = true;
     Variant::Members vms;
     for (const auto& c : v->members()) {
@@ -298,7 +299,7 @@ struct substituteInto : public switchTyFn {
     return MonoTypePtr(Variant::make(vms));
   }
 
-  MonoTypePtr with(const Record* v) const {
+  MonoTypePtr with(const Record* v) const override {
     this->uty.visited = true;
     Record::Members rms;
     for (const auto& f : v->members()) {
@@ -308,7 +309,7 @@ struct substituteInto : public switchTyFn {
     return MonoTypePtr(Record::make(rms));
   }
 
-  MonoTypePtr with(const Func* v) const {
+  MonoTypePtr with(const Func* v) const override {
     this->uty.visited = true;
     MonoTypePtr a = this->s->substitute(v->argument());
     MonoTypePtr r = this->s->substitute(v->result());
@@ -316,21 +317,21 @@ struct substituteInto : public switchTyFn {
     return MonoTypePtr(Func::make(a, r));
   }
 
-  MonoTypePtr with(const Exists* v) const {
+  MonoTypePtr with(const Exists* v) const override {
     this->uty.visited = true;
     MonoTypePtr at = this->s->substitute(v->absType());
     this->uty.visited = false;
     return MonoTypePtr(Exists::make(v->absTypeName(), at));
   }
 
-  MonoTypePtr with(const Recursive* v) const {
+  MonoTypePtr with(const Recursive* v) const override {
     this->uty.visited = true;
     MonoTypePtr rt = this->s->substitute(v->recType());
     this->uty.visited = false;
     return MonoTypePtr(Recursive::make(v->recTypeName(), rt));
   }
 
-  MonoTypePtr with(const TExpr* v) const {
+  MonoTypePtr with(const TExpr* v) const override {
     this->uty.visited = true;
     ExprPtr e = substitute(this->s, v->expr());
     this->uty.visited = false;
@@ -357,8 +358,8 @@ MonoTypePtr MonoTypeUnifier::substitute(const MonoTypePtr& ty) {
 
 MonoTypes MonoTypeUnifier::substitute(const MonoTypes& ts) {
   MonoTypes result;
-  for (MonoTypes::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-    result.push_back(substitute(*t));
+  for (const auto &t : ts) {
+    result.push_back(substitute(t));
   }
   return result;
 }
@@ -395,8 +396,8 @@ MonoTypePtr substitute(MonoTypeUnifier* u, const MonoTypePtr& ty) {
 
 MonoTypes substitute(MonoTypeUnifier* u, const MonoTypes& tys) {
   MonoTypes r;
-  for (MonoTypes::const_iterator ty = tys.begin(); ty != tys.end(); ++ty) {
-    r.push_back(u->substitute(*ty));
+  for (const auto &ty : tys) {
+    r.push_back(u->substitute(ty));
   }
   return r;
 }
@@ -407,8 +408,8 @@ ConstraintPtr substitute(MonoTypeUnifier* u, const ConstraintPtr& cst) {
 }
 
 Constraints substitute(MonoTypeUnifier* u, const Constraints& cs) {
-  for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    substitute(u, *c);
+  for (const auto &c : cs) {
+    substitute(u, c);
   }
   return cs;
 }
@@ -423,7 +424,7 @@ struct exprTypeSubst : public switchExprTyFnM {
   MonoTypeUnifier* u;
   exprTypeSubst(MonoTypeUnifier* u) : u(u) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return substitute(this->u, qt);
   }
 };
@@ -452,7 +453,7 @@ bool unifiable(const TEnvPtr& tenv, const MonoTypePtr& t0, const MonoTypePtr& t1
 bool unifiable(const TEnvPtr& tenv, const MonoTypes& ts0, const MonoTypes& ts1) {
   if (ts0.size() != ts1.size()) {
     return false;
-  } else if (ts0.size() == 0) {
+  } else if (ts0.empty()) {
     return true;
   } else {
     try {
@@ -504,8 +505,8 @@ bool refine(const TEnvPtr& tenv, const Constraints& cs, MonoTypeUnifier* s, Defi
   bool upd = true;
   while (upd) {
     upd = false;
-    for (Constraints::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-      upd |= refine(tenv, *c, s, ds);
+    for (const auto &c : cs) {
+      upd |= refine(tenv, c, s, ds);
     }
   }
   return false;
@@ -514,7 +515,7 @@ bool refine(const TEnvPtr& tenv, const Constraints& cs, MonoTypeUnifier* s, Defi
 bool refine(const TEnvPtr& tenv, const QualTypePtr& qty, MonoTypeUnifier* s, Definitions* ds) {
   // first reduce this set of constraints as much as possible
   ConstraintSet cs;
-  for (auto c : qty->constraints()) {
+  for (const auto& c : qty->constraints()) {
     cs.insert(tenv, c, s);
   }
 
@@ -535,7 +536,7 @@ bool refine(const TEnvPtr& tenv, const ExprPtr& e, MonoTypeUnifier* s, Definitio
 Record::Members makeRecordMembers(const MkRecord::FieldDefs& fds, const MonoTypes& mts) {
   Record::Members r;
   int i = 0;
-  for (MkRecord::FieldDefs::const_iterator f = fds.begin(); f != fds.end(); ++f, ++i) {
+  for (auto f = fds.begin(); f != fds.end(); ++f, ++i) {
     r.push_back(Record::Member(f->first, mts[i]));
   }
   return r;
@@ -562,23 +563,23 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Unit* v)   { return mkprim(v, "unit"); }
-  UnitV with(Bool* v)   { return mkprim(v, "bool"); }
-  UnitV with(Char* v)   { return mkprim(v, "char"); }
-  UnitV with(Byte* v)   { return mkprim(v, "byte"); }
-  UnitV with(Short* v)  { return mkprim(v, "short"); }
-  UnitV with(Int* v)    { return mkprim(v, "int"); }
-  UnitV with(Long* v)   { return mkprim(v, "long"); }
-  UnitV with(Int128* v) { return mkprim(v, "int128"); }
-  UnitV with(Float* v)  { return mkprim(v, "float"); }
-  UnitV with(Double* v) { return mkprim(v, "double"); }
+  UnitV with(Unit* v) override   { return mkprim(v, "unit"); }
+  UnitV with(Bool* v) override   { return mkprim(v, "bool"); }
+  UnitV with(Char* v) override   { return mkprim(v, "char"); }
+  UnitV with(Byte* v) override   { return mkprim(v, "byte"); }
+  UnitV with(Short* v) override  { return mkprim(v, "short"); }
+  UnitV with(Int* v) override    { return mkprim(v, "int"); }
+  UnitV with(Long* v) override   { return mkprim(v, "long"); }
+  UnitV with(Int128* v) override { return mkprim(v, "int128"); }
+  UnitV with(Float* v) override  { return mkprim(v, "float"); }
+  UnitV with(Double* v) override { return mkprim(v, "double"); }
 
-  UnitV with(Var* v) {
+  UnitV with(Var* v) override {
     v->type(this->tenv->lookup(v->value())->instantiate());
     return unitv;
   }
 
-  UnitV with(Let* v) {
+  UnitV with(Let* v) override {
     switchOf(v->varExpr(), *this);
     switchOf(v->bodyExpr(), expTypeInfF(bindFrame(this->tenv, v->var(), v->varExpr()->type()), this->u, this->ds));
 
@@ -596,7 +597,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return r;
   }
 
-  UnitV with(LetRec* v) {
+  UnitV with(LetRec* v) override {
     TEnvPtr lrtenv = letRecFrame(this->tenv, v->bindings());
 
     Constraints cs;
@@ -613,7 +614,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Fn* v) {
+  UnitV with(Fn* v) override {
     MonoTypes argl = freshTypeVars(v->varNames().size());
     switchOf(v->body(), expTypeInfF(fnFrame(this->tenv, v->varNames(), argl), this->u, this->ds));
 
@@ -621,17 +622,17 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(App* v) {
+  UnitV with(App* v) override {
     switchOf(v->fn(), *this);
 
     Constraints csts;
     mergeConstraints(v->fn()->type()->constraints(), &csts);
 
     MonoTypes atys;
-    for (Exprs::iterator a = v->args().begin(); a != v->args().end(); ++a) {
-      switchOf(*a, *this);
-      mergeConstraints((*a)->type()->constraints(), &csts);
-      atys.push_back((*a)->type()->monoType());
+    for (auto &a : v->args()) {
+      switchOf(a, *this);
+      mergeConstraints(a->type()->constraints(), &csts);
+      atys.push_back(a->type()->monoType());
     }
 
     MonoTypePtr irty = freshTypeVar();
@@ -640,7 +641,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Assign* v) {
+  UnitV with(Assign* v) override {
     switchOf(v->left(),  *this);
     switchOf(v->right(), *this);
 
@@ -688,15 +689,15 @@ struct expTypeInfF : public switchExprM<UnitV> {
     }
   }
 
-  UnitV with(MkArray* v) {
+  UnitV with(MkArray* v) override {
     Constraints cs;
     MonoTypePtr ety  = freshTypeVar();
     QualTypePtr qety = qualtype(ety);
 
-    for (Exprs::iterator e = v->values().begin(); e != v->values().end(); ++e) {
-      switchOf(*e, *this);
-      mgu(*e, qety, this->u);
-      cs = mergeConstraints((*e)->type()->constraints(), cs);
+    for (auto &e : v->values()) {
+      switchOf(e, *this);
+      mgu(e, qety, this->u);
+      cs = mergeConstraints(e->type()->constraints(), cs);
     }
 
     v->type(qt(cs, arrayty(ety)));
@@ -704,18 +705,18 @@ struct expTypeInfF : public switchExprM<UnitV> {
   }
 
   // V hasfield x:T => <:x:T:> :: V
-  UnitV with(MkVariant* v) {
+  UnitV with(MkVariant* v) override {
     switchOf(v->value(), *this);
 
     MonoTypePtr   vty  = freshTypeVar();
-    ConstraintPtr c    = ConstraintPtr(new Constraint(CtorVerifier::constraintName(), list(vty, MonoTypePtr(TString::make(v->label())), v->value()->type()->monoType())));
+    ConstraintPtr c    = std::make_shared<Constraint>(CtorVerifier::constraintName(), list(vty, MonoTypePtr(TString::make(v->label())), v->value()->type()->monoType()));
     Constraints   cs   = mergeConstraints(v->value()->type()->constraints(), list(c));
 
     v->type(qt(cs, vty));
     return unitv;
   }
 
-  UnitV with(MkRecord* v) {
+  UnitV with(MkRecord* v) override {
     QualTypes ftys;
     str::set fnames;
 
@@ -733,7 +734,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(AIndex* v) {
+  UnitV with(AIndex* v) override {
     v->index(assume(fncall(var("convert", v->index()->la()), list(v->index()), v->index()->la()), primty("long"), v->index()->la()));
 
     switchOf(v->array(), *this);
@@ -766,7 +767,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
 
       cbs.push_back(Case::Binding(b->selector, b->vname, b->exp));
       cs = mergeConstraints(cs, b->exp->type()->constraints());
-      vcs.push_back(ConstraintPtr(new Constraint(CtorVerifier::constraintName(), list(v->variant()->type()->monoType(), MonoTypePtr(TString::make(b->selector)), bty))));
+      vcs.push_back(std::make_shared<Constraint>(CtorVerifier::constraintName(), list(v->variant()->type()->monoType(), MonoTypePtr(TString::make(b->selector)), bty)));
     }
     v->variant()->type(qt(mergeConstraints(vcs, v->variant()->type()->constraints()), v->variant()->type()->monoType()));
 
@@ -781,9 +782,9 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Case* v) {
+  UnitV with(Case* v) override {
     // if a default case is specified, the set of variant constructors is open
-    if (v->defaultExpr().get() != 0) {
+    if (v->defaultExpr().get() != nullptr) {
       return withGenericMeaning(v);
     }
 
@@ -794,15 +795,15 @@ struct expTypeInfF : public switchExprM<UnitV> {
     Constraints      cs;
     int              cidx = 0;
 
-    for (Case::Bindings::iterator b = v->bindings().begin(); b != v->bindings().end(); ++b) {
+    for (auto &b : v->bindings()) {
       MonoTypePtr bty = freshTypeVar();
-      switchOf(b->exp, expTypeInfF(bindFrame(this->tenv, b->vname, bty), this->u, this->ds));
+      switchOf(b.exp, expTypeInfF(bindFrame(this->tenv, b.vname, bty), this->u, this->ds));
 
-      mgu(b->exp, qualtype(rty), this->u);
+      mgu(b.exp, qualtype(rty), this->u);
 
-      cbs.push_back(Case::Binding(b->selector, b->vname, b->exp));
-      vms.push_back(Variant::Member(b->selector, bty, cidx++));
-      cs = mergeConstraints(cs, b->exp->type()->constraints());
+      cbs.push_back(Case::Binding(b.selector, b.vname, b.exp));
+      vms.push_back(Variant::Member(b.selector, bty, cidx++));
+      cs = mergeConstraints(cs, b.exp->type()->constraints());
     }
 
     switchOf(v->variant(), *this);
@@ -810,9 +811,9 @@ struct expTypeInfF : public switchExprM<UnitV> {
     // now we need to infer the variant type, but as a bit of a hack, let's see if the lhs actually has a type on it
     // and if so then we can patch up the inferred constructor IDs
     if (const Variant* vty = is<Variant>(v->variant()->type()->monoType())) {
-      for (size_t i = 0; i < vms.size(); ++i) {
+      for (auto &vm : vms) {
         try {
-          vms[i].id = vty->id(vms[i].selector);
+          vm.id = vty->id(vm.selector);
         } catch (...) {
         }
       }
@@ -825,7 +826,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Switch* v) {
+  UnitV with(Switch* v) override {
     switchOf(v->expr(), *this);
     mgu(v->expr(), qualtype(v->bindings()[0].value->primType()), this->u);
 
@@ -853,7 +854,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
   }
 
   // E.f => (E::R).f :: R hasfield f:t => t
-  UnitV with(Proj* v) {
+  UnitV with(Proj* v) override {
     switchOf(v->record(), *this);
 
     MonoTypePtr   fty  = freshTypeVar();
@@ -864,7 +865,7 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Assump* v) {
+  UnitV with(Assump* v) override {
     switchOf(v->expr(), *this);
     mgu(v->expr(), v->ty(), this->u);
 
@@ -899,18 +900,18 @@ struct expTypeInfF : public switchExprM<UnitV> {
     return unitv;
   }
 
-  UnitV with(Pack* v) {
+  UnitV with(Pack* v) override {
     switchOf(v->expr(), *this);
 
     MonoTypePtr   packedType = freshTypeVar();
-    ConstraintPtr pcst       = ConstraintPtr(new Constraint(Existentials::constraintName(), list(v->expr()->type()->monoType(), packedType)));
+    ConstraintPtr pcst       = std::make_shared<Constraint>(Existentials::constraintName(), list(v->expr()->type()->monoType(), packedType));
 
     Constraints cs = mergeConstraints(v->expr()->type()->constraints(), list(pcst));
     v->type(qt(cs, packedType));
     return unitv;
   }
 
-  UnitV with(Unpack* v) {
+  UnitV with(Unpack* v) override {
     switchOf(v->package(), *this);
     switchOf(v->expr(), expTypeInfF(bindFrame(this->tenv, v->varName(), unpackedType(substitute(this->u, v->package()->type()))), this->u, this->ds));
 
@@ -926,7 +927,7 @@ struct applySubstitutionF : public switchExprTyFnM {
   MonoTypeUnifier* s;
   applySubstitutionF(MonoTypeUnifier* s) : s(s) { }
 
-  QualTypePtr withTy(const QualTypePtr& qt) const {
+  QualTypePtr withTy(const QualTypePtr& qt) const override {
     return substitute(this->s, qt);
   }
 };
@@ -1017,9 +1018,9 @@ void mgu(const ConstraintPtr& c0, const ConstraintPtr& c1, MonoTypeUnifier* u) {
 // utilities for dealing with qualified types
 QualLiftedMonoTypes liftQualifiers(const QualTypes& qts) {
   QualLiftedMonoTypes r;
-  for (QualTypes::const_iterator qt = qts.begin(); qt != qts.end(); ++qt) {
-    mergeConstraints((*qt)->constraints(), &r.first);
-    r.second.push_back((*qt)->monoType());
+  for (const auto &qt : qts) {
+    mergeConstraints(qt->constraints(), &r.first);
+    r.second.push_back(qt->monoType());
   }
   return r;
 }
diff --git a/lib/hobbes/lang/typemap.C b/lib/hobbes/lang/typemap.C
index ea25dac2e..1be872799 100644
--- a/lib/hobbes/lang/typemap.C
+++ b/lib/hobbes/lang/typemap.C
@@ -15,14 +15,14 @@ struct mtyLT : public switchType<bool> {
       return r;
     }
 
-  bool with(const Prim*    v) const { return v->name() < right<Prim>()->name(); }
-  bool with(const TVar*    v) const { return v->name() < right<TVar>()->name(); }
-  bool with(const TGen*    v) const { return v->id() < right<TGen>()->id(); }
-  bool with(const Array*   v) const { return MonoTypeLT()(v->type(), right<Array>()->type()); }
-  bool with(const TString* v) const { return v->value() < right<TString>()->value(); }
-  bool with(const TLong*   v) const { return v->value() < right<TLong>()->value(); }
-
-  bool with(const TAbs* v) const {
+  bool with(const Prim*    v) const override { return v->name() < right<Prim>()->name(); }
+  bool with(const TVar*    v) const override { return v->name() < right<TVar>()->name(); }
+  bool with(const TGen*    v) const override { return v->id() < right<TGen>()->id(); }
+  bool with(const Array*   v) const override { return MonoTypeLT()(v->type(), right<Array>()->type()); }
+  bool with(const TString* v) const override { return v->value() < right<TString>()->value(); }
+  bool with(const TLong*   v) const override { return v->value() < right<TLong>()->value(); }
+
+  bool with(const TAbs* v) const override {
     if (v->args() < right<TAbs>()->args()) {
       return true;
     } else if (right<TAbs>()->args() < v->args()) {
@@ -32,7 +32,7 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const TApp* v) const {
+  bool with(const TApp* v) const override {
     const MonoTypes& largs = v->args();
     const MonoTypes& rargs = right<TApp>()->args();
 
@@ -56,13 +56,13 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const OpaquePtr* v) const {
-    const OpaquePtr* r = right<OpaquePtr>();
+  bool with(const OpaquePtr* v) const override {
+    const auto* r = right<OpaquePtr>();
 
     if (v->name() != r->name()) {
       return v->name() < r->name();
     } else if (v->storedContiguously() != r->storedContiguously()) {
-      return v->storedContiguously() < r->storedContiguously();
+      return static_cast<int>(v->storedContiguously()) < static_cast<int>(r->storedContiguously());
     } else if (v->storedContiguously()) {
       return v->size() < r->size();
     } else {
@@ -70,8 +70,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const FixedArray* v) const {
-    const FixedArray* r = right<FixedArray>();
+  bool with(const FixedArray* v) const override {
+    const auto* r = right<FixedArray>();
 
     if (MonoTypeLT()(v->type(), r->type())) {
       return true;
@@ -86,7 +86,7 @@ struct mtyLT : public switchType<bool> {
     }
   }
   
-  bool with(const Func* v) const {
+  bool with(const Func* v) const override {
     const Func* r = right<Func>();
 
     if (MonoTypeLT()(v->argument(), r->argument())) {
@@ -102,8 +102,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const Variant* v) const {
-    const Variant* r = right<Variant>();
+  bool with(const Variant* v) const override {
+    const auto* r = right<Variant>();
 
     if (v->members().size() != r->members().size()) {
       return v->members().size() < r->members().size();
@@ -126,8 +126,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const Record* v) const {
-    const Record* r = right<Record>();
+  bool with(const Record* v) const override {
+    const auto* r = right<Record>();
 
     if (v->members().size() != r->members().size()) {
       return v->members().size() < r->members().size();
@@ -150,8 +150,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const Exists* v) const {
-    const Exists* r = right<Exists>();
+  bool with(const Exists* v) const override {
+    const auto* r = right<Exists>();
 
     if (v->absTypeName() != r->absTypeName()) {
       return v->absTypeName() < r->absTypeName();
@@ -160,8 +160,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const Recursive* v) const {
-    const Recursive* r = right<Recursive>();
+  bool with(const Recursive* v) const override {
+    const auto* r = right<Recursive>();
 
     if (v->recTypeName() != r->recTypeName()) {
       return v->recTypeName() < r->recTypeName();
@@ -170,8 +170,8 @@ struct mtyLT : public switchType<bool> {
     }
   }
 
-  bool with(const TExpr* v) const {
-    const TExpr* r = right<TExpr>();
+  bool with(const TExpr* v) const override {
+    const auto* r = right<TExpr>();
 
     // this may not be sound ...
     if (v->expr().get() == r->expr().get()) {
diff --git a/lib/hobbes/lang/typepreds.C b/lib/hobbes/lang/typepreds.C
index 9cdde6474..ff3067e77 100644
--- a/lib/hobbes/lang/typepreds.C
+++ b/lib/hobbes/lang/typepreds.C
@@ -36,7 +36,7 @@ bool UnqualifierSet::refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoT
 }
 
 bool UnqualifierSet::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
-  Unqualifiers::const_iterator uq = this->uqs.find(cst->name());
+  auto uq = this->uqs.find(cst->name());
   if (uq == this->uqs.end()) {
     return false;
   } else {
@@ -45,7 +45,7 @@ bool UnqualifierSet::satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, De
 }
 
 bool UnqualifierSet::satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const {
-  Unqualifiers::const_iterator uq = this->uqs.find(cst->name());
+  auto uq = this->uqs.find(cst->name());
   if (uq == this->uqs.end()) {
     return false;
   } else {
@@ -61,7 +61,7 @@ void UnqualifierSet::explain(const TEnvPtr& tenv, const ConstraintPtr& cst, cons
 }
 
 ExprPtr UnqualifierSet::unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const {
-  Unqualifiers::const_iterator uq = this->uqs.find(cst->name());
+  auto uq = this->uqs.find(cst->name());
   if (uq == this->uqs.end()) {
     throw annotated_error(*e, "Unknown predicate '" + cst->name() + "' can't be unqualified.");
   } else {
@@ -70,8 +70,8 @@ ExprPtr UnqualifierSet::unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst,
 }
 
 PolyTypePtr UnqualifierSet::lookup(const std::string& vn) const {
-  for (Unqualifiers::const_iterator uq = this->uqs.begin(); uq != this->uqs.end(); ++uq) {
-    PolyTypePtr pt = uq->second->lookup(vn);
+  for (const auto &uq : this->uqs) {
+    PolyTypePtr pt = uq.second->lookup(vn);
     if (pt != PolyTypePtr()) {
       return pt;
     }
@@ -81,15 +81,15 @@ PolyTypePtr UnqualifierSet::lookup(const std::string& vn) const {
 
 SymSet UnqualifierSet::bindings() const {
   SymSet r;
-  for (Unqualifiers::const_iterator uq = this->uqs.begin(); uq != this->uqs.end(); ++uq) {
-    SymSet qr = uq->second->bindings();
+  for (const auto &uq : this->uqs) {
+    SymSet qr = uq.second->bindings();
     r.insert(qr.begin(), qr.end());
   }
   return r;
 }
 
 FunDeps UnqualifierSet::dependencies(const ConstraintPtr& cst) const {
-  Unqualifiers::const_iterator uq = this->uqs.find(cst->name());
+  auto uq = this->uqs.find(cst->name());
   if (uq == this->uqs.end()) {
     return FunDeps();
   } else {
@@ -99,8 +99,8 @@ FunDeps UnqualifierSet::dependencies(const ConstraintPtr& cst) const {
 
 bool hasConstraint(const ConstraintPtr& c, const Constraints& cs) {
   Constraints r;
-  for (Constraints::const_iterator ci = cs.begin(); ci != cs.end(); ++ci) {
-    if (*c == **ci) {
+  for (const auto &ci : cs) {
+    if (*c == *ci) {
       return true;
     }
   }
@@ -113,9 +113,9 @@ bool hasConstraint(const ConstraintPtr& c, const QualTypePtr& qt) {
 
 Constraints removeConstraint(const ConstraintPtr& c, const Constraints& cs) {
   Constraints r;
-  for (Constraints::const_iterator ci = cs.begin(); ci != cs.end(); ++ci) {
-    if (!(*c == **ci)) {
-      r.push_back(*ci);
+  for (const auto &ci : cs) {
+    if (!(*c == *ci)) {
+      r.push_back(ci);
     }
   }
   return r;
diff --git a/lib/hobbes/lang/tyunqualify.C b/lib/hobbes/lang/tyunqualify.C
index 5d7480b20..0d17191e4 100644
--- a/lib/hobbes/lang/tyunqualify.C
+++ b/lib/hobbes/lang/tyunqualify.C
@@ -20,7 +20,7 @@ ExprPtr unqualifyTypes(const TEnvPtr& tenv, const ExprPtr& e, Definitions* ds) {
         "Internal compiler error, cannot unqualify expression without explicit type annotations "
         "(did you forget to perform type-inference first?): " + show(result)
       );
-    } else if (eqt->constraints().size() > 0) {
+    } else if (!eqt->constraints().empty()) {
       // resolve satisfiable, satisfied predicates in this expression
       const Constraints& cs = eqt->constraints();
       for (const auto& c : cs) {
@@ -29,7 +29,7 @@ ExprPtr unqualifyTypes(const TEnvPtr& tenv, const ExprPtr& e, Definitions* ds) {
         if (!satisfiable(uq, tenv, c, ds)) {
           annmsgs msgs;
           uq->explain(tenv, c, e, ds, &msgs);
-          if (msgs.size() > 0) {
+          if (!msgs.empty()) {
             throw annotated_error(msgs);
           } else {
             throw annotated_error(*e, "Unsatisfiable predicate: " + show(c));
diff --git a/lib/hobbes/parse/data.C b/lib/hobbes/parse/data.C
index aebb1798b..60eeecd02 100644
--- a/lib/hobbes/parse/data.C
+++ b/lib/hobbes/parse/data.C
@@ -30,7 +30,7 @@ void linedb::reset() {
 }
 
 linedb::LineCol linedb::pos(nat i) const {
-  nats::const_iterator np = std::lower_bound(this->lp.begin(), this->lp.end(), i);
+  auto np = std::lower_bound(this->lp.begin(), this->lp.end(), i);
   nat k = std::distance(this->lp.begin(), np);
   
   if (k == 0) {
diff --git a/lib/hobbes/parse/grammar.C b/lib/hobbes/parse/grammar.C
index 917047442..0f5873231 100644
--- a/lib/hobbes/parse/grammar.C
+++ b/lib/hobbes/parse/grammar.C
@@ -4,7 +4,7 @@
 
 namespace hobbes {
 
-typedef std::map<std::string, terminal*> symbols;
+using symbols = std::map<std::string, terminal *>;
 
 terminal* sym(symbols* ss, const std::string& x) {
   auto si = ss->find(x);
@@ -17,7 +17,7 @@ terminal* sym(symbols* ss, const std::string& x) {
   }
 }
 
-typedef std::map<char, terminal*> chars;
+using chars = std::map<char, terminal *>;
 
 terminal* chr(chars* cs, char x) {
   auto ci = cs->find(x);
@@ -33,7 +33,7 @@ terminal* chr(chars* cs, char x) {
 ParseRule::Bindings toParseRuleBindings(symbols* ss, chars* cs, const BoundGrammarValues& gvs) {
   ParseRule::Bindings r;
   for (const auto& gv : gvs) {
-    if (const GSymRef* x = dynamic_cast<const GSymRef*>(gv.element.get())) {
+    if (const auto* x = dynamic_cast<const GSymRef*>(gv.element.get())) {
       r.push_back(ParseRule::Binding(gv.varname, sym(ss, x->value())));
     } else if (const GStr* x = dynamic_cast<const GStr*>(gv.element.get())) {
       for (auto c : x->value()) {
diff --git a/lib/hobbes/parse/lalr.C b/lib/hobbes/parse/lalr.C
index 827937bf8..010b46506 100644
--- a/lib/hobbes/parse/lalr.C
+++ b/lib/hobbes/parse/lalr.C
@@ -8,17 +8,17 @@ namespace hobbes {
  * basic grammar/rule analysis
  */
 void removeRuleDefs(terminal* s, grammar* g) {
-  grammar::iterator r = g->find(s);
+  auto r = g->find(s);
   if (r != g->end()) {
     g->erase(r);
   }
 }
 
 void removeRuleRefs(terminal* s, grammar* g) {
-  for (grammar::iterator sd = g->begin(); sd != g->end(); ++sd) {
-    for (nat r = 0; r < sd->second.size();) {
-      if (in(s, sd->second[r])) {
-        sd->second.erase(sd->second.begin() + r);
+  for (auto &sd : *g) {
+    for (nat r = 0; r < sd.second.size();) {
+      if (in(s, sd.second[r])) {
+        sd.second.erase(sd.second.begin() + r);
       } else {
         ++r;
       }
@@ -58,10 +58,10 @@ terminalset topLevelSymbols(const grammar& g) {
   terminalset result;
   terminalset dsyms = definedSymbols(g);
 
-  for (terminalset::const_iterator t = dsyms.begin(); t != dsyms.end(); ++t) {
-    terminalset users = symbolsUsing(g, *t);
-    if (users.size() == 0 || (users.size() == 1 && in(*t, users))) {
-      result.insert(*t);
+  for (auto *dsym : dsyms) {
+    terminalset users = symbolsUsing(g, dsym);
+    if (users.empty() || (users.size() == 1 && in(dsym, users))) {
+      result.insert(dsym);
     }
   }
 
@@ -69,24 +69,24 @@ terminalset topLevelSymbols(const grammar& g) {
 }
 
 void symbolsUsed(const grammar& g, const rule& r, terminalset* ss) {
-  for (rule::const_iterator t = r.begin(); t != r.end(); ++t) {
-    if (hasRule(g, *t)) {
-      if (!in(*t, *ss)) {
-        ss->insert(*t);
-        symbolsUsed(g, *t, ss);
+  for (auto *t : r) {
+    if (hasRule(g, t)) {
+      if (!in(t, *ss)) {
+        ss->insert(t);
+        symbolsUsed(g, t, ss);
       }
     }
   }
 }
 
 void symbolsUsed(const grammar& g, const rules& rs, terminalset* ss) {
-  for (rules::const_iterator r = rs.begin(); r != rs.end(); ++r) {
-    symbolsUsed(g, *r, ss);
+  for (const auto &r : rs) {
+    symbolsUsed(g, r, ss);
   }
 }
 
 void symbolsUsed(const grammar& g, terminal* s, terminalset* ss) {
-  grammar::const_iterator sd = g.find(s);
+  auto sd = g.find(s);
   if (sd != g.end()) {
     symbolsUsed(g, sd->second, ss);
   }
@@ -102,9 +102,9 @@ terminalset symbolsUsing(const grammar& g, terminal* s) {
   terminalset result;
   terminalset dsyms = definedSymbols(g);
 
-  for (terminalset::const_iterator t = dsyms.begin(); t != dsyms.end(); ++t) {
-    if (in(s, symbolsUsed(g, *t))) {
-      result.insert(*t);
+  for (auto *dsym : dsyms) {
+    if (in(s, symbolsUsed(g, dsym))) {
+      result.insert(dsym);
     }
   }
 
@@ -116,7 +116,7 @@ bool hasRule(const grammar& g, terminal* t) {
 }
 
 const rules* aggRules(const grammar& g, terminal* t) {
-  grammar::const_iterator ad = g.find(t);
+  auto ad = g.find(t);
   if (ad == g.end()) {
     throw std::runtime_error("Internal error, no such aggregate defined.");
   } else {
@@ -134,20 +134,20 @@ const rule& nthRule(const rules* rs, nat n) {
 
 terminal* ruleElement(const rule& r, nat i) {
   if (i >= r.size()) {
-    return 0;
+    return nullptr;
   } else {
     return r[i];
   }
 }
 
 bool directlyDerivesNull(const rule& r) {
-  return r.size() == 0;
+  return r.empty();
 }
 
 bool directlyDerivesNull(const grammar& g, terminal* s) {
   const rules* rs = aggRules(g, s);
-  for (rules::const_iterator r = rs->begin(); r != rs->end(); ++r) {
-    if (directlyDerivesNull(*r)) {
+  for (const auto &r : *rs) {
+    if (directlyDerivesNull(r)) {
       return true;
     }
   }
@@ -155,8 +155,8 @@ bool directlyDerivesNull(const grammar& g, terminal* s) {
 }
 
 bool derivesNull(const terminalset& nullAggs, const rule& r) {
-  for (rule::const_iterator v = r.begin(); v != r.end(); ++v) {
-    if (nullAggs.find(*v) == nullAggs.end()) {
+  for (auto *v : r) {
+    if (nullAggs.find(v) == nullAggs.end()) {
       return false;
     }
   }
@@ -165,8 +165,8 @@ bool derivesNull(const terminalset& nullAggs, const rule& r) {
 
 bool derivesNull(const grammar& g, const terminalset& nullAggs, terminal* s) {
   const rules* rs = aggRules(g, s);
-  for (rules::const_iterator r = rs->begin(); r != rs->end(); ++r) {
-    if (derivesNull(nullAggs, *r)) {
+  for (const auto & r : *rs) {
+    if (derivesNull(nullAggs, r)) {
       return true;
     }
   }
@@ -174,8 +174,8 @@ bool derivesNull(const grammar& g, const terminalset& nullAggs, terminal* s) {
 }
 
 bool derivesNull(const grammar& g, const terminalset& nullAggs, const terminals& ss) {
-  for (terminals::const_iterator s = ss.begin(); s != ss.end(); ++s) {
-    if (!derivesNull(g, nullAggs, *s)) {
+  for (auto *s : ss) {
+    if (!derivesNull(g, nullAggs, s)) {
       return false;
     }
   }
@@ -193,7 +193,7 @@ terminalset symbolsDerivingNull(const grammar& g) {
 
   while (changed) {
     changed = false;
-    for (terminalset::const_iterator s = potentials.begin(); s != potentials.end(); ++s) {
+    for (auto s = potentials.begin(); s != potentials.end(); ++s) {
       if (nulls.find(*s) == nulls.end() && derivesNull(g, nulls, *s)) {
         nulls.insert(*s);
         potentials.erase(*s);
@@ -238,8 +238,8 @@ void show(std::ostream& out, const grammar& g, const item& i) {
   if (i.p == r.size()) {
     out << "#";
     out << " [";
-    if (i.la.size() > 0) {
-      terminalset::const_iterator lat = i.la.begin();
+    if (!i.la.empty()) {
+      auto lat = i.la.begin();
       (*lat)->show(out);
       ++lat;
       while (lat != i.la.end()) {
@@ -254,8 +254,8 @@ void show(std::ostream& out, const grammar& g, const item& i) {
 }
 
 void show(std::ostream& out, const grammar& g, const itemset& is) {
-  for (itemset::const_iterator i = is.begin(); i != is.end(); ++i) {
-    show(out, g, *i);
+  for (const auto &i : is) {
+    show(out, g, i);
   }
 }
 
@@ -286,8 +286,8 @@ terminal* next(const grammar& g, const item& i) {
 
 terminalset next(const grammar& g, const itemset& is) {
   terminalset r;
-  for (itemset::const_iterator i = is.begin(); i != is.end(); ++i) {
-    if (terminal* t = next(g, *i)) {
+  for (const auto &i : is) {
+    if (terminal* t = next(g, i)) {
       r.insert(t);
     }
   }
@@ -296,8 +296,8 @@ terminalset next(const grammar& g, const itemset& is) {
 
 terminalset nextPrim(const grammar& g, const itemset& is) {
   terminalset r;
-  for (itemset::const_iterator i = is.begin(); i != is.end(); ++i) {
-    if (terminal* v = next(g, *i)) {
+  for (const auto &i : is) {
+    if (terminal* v = next(g, i)) {
       if (!hasRule(g, v)) {
         r.insert(v);
       }
@@ -308,9 +308,9 @@ terminalset nextPrim(const grammar& g, const itemset& is) {
 
 itemset follow(const grammar& g, const itemset& is, terminal* v) {
   itemset r;
-  for (itemset::const_iterator i = is.begin(); i != is.end(); ++i) {
-    if (next(g, *i) == v) {
-      r.insert(succ(*i));
+  for (const auto &i : is) {
+    if (next(g, i) == v) {
+      r.insert(succ(i));
     }
   }
   return r;
@@ -318,8 +318,8 @@ itemset follow(const grammar& g, const itemset& is, terminal* v) {
 
 itemsets follow(const grammar& g, const itemset& is, const terminals& vs) {
   itemsets r;
-  for (terminals::const_iterator v = vs.begin(); v != vs.end(); ++v) {
-    r.push_back(follow(g, is, *v));
+  for (auto *v : vs) {
+    r.push_back(follow(g, is, v));
   }
   return r;
 }
@@ -331,9 +331,9 @@ void gclosure(const grammar& g, itemset* is) {
     changed = false;
 
     terminalset ts = next(g, *is);
-    for (terminalset::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-      if (*t && hasRule(g, *t)) {
-        changed |= ruleItems(g, *t, is);
+    for (auto *t : ts) {
+      if ((t != nullptr) && hasRule(g, t)) {
+        changed |= ruleItems(g, t, is);
       }
     }
   }
@@ -358,7 +358,7 @@ nat parserState(const itemset& s, parserdef* p) {
 }
 
 const itemset& parserStateDef(const parserdef& p, nat n) {
-  state_definitions::const_iterator sd = p.state_defs.find(n);
+  auto sd = p.state_defs.find(n);
   if (sd == p.state_defs.end()) {
     throw std::runtime_error("Internal error, invalid state referenced.");
   } else {
@@ -368,9 +368,9 @@ const itemset& parserStateDef(const parserdef& p, nat n) {
 
 state_transitions follow(const grammar& g, const itemset& is, const terminalset& vs, parserdef* p) {
   state_transitions r;
-  for (terminalset::const_iterator v = vs.begin(); v != vs.end(); ++v) {
-    if (*v != endOfFile::value()) {
-      r[*v] = parserState(gclosure(g, follow(g, is, *v)), p);
+  for (auto *v : vs) {
+    if (v != endOfFile::value()) {
+      r[v] = parserState(gclosure(g, follow(g, is, v)), p);
     }
   }
   return r;
@@ -406,8 +406,8 @@ parserdef lr0parser(const grammar& g, terminal* s) {
 
 transitionset transitions(const parserdef& p) {
   transitionset r;
-  for (parser_state_transitions::const_iterator pst = p.transitions.begin(); pst != p.transitions.end(); ++pst) {
-    for (state_transitions::const_iterator st = pst->second.begin(); st != pst->second.end(); ++st) {
+  for (auto pst = p.transitions.begin(); pst != p.transitions.end(); ++pst) {
+    for (auto st = pst->second.begin(); st != pst->second.end(); ++st) {
       if (hasRule(p.g, st->first)) {
         r.insert(transition(pst->first, st->first));
       }
@@ -417,7 +417,7 @@ transitionset transitions(const parserdef& p) {
 }
 
 const state_transitions& transitions(const parserdef& p, nat q) {
-  parser_state_transitions::const_iterator r = p.transitions.find(q);
+  auto r = p.transitions.find(q);
   if (r == p.transitions.end()) {
     throw std::runtime_error("Internal error, invalid state given for finding transitions.");
   } else {
@@ -434,7 +434,7 @@ bool follows(const parserdef& p, nat q, terminal* t) {
 }
 
 nat follow(const state_transitions& st, terminal* t) {
-  state_transitions::const_iterator x = st.find(t);
+  auto x = st.find(t);
   if (x == st.end()) {
     throw std::runtime_error("Internal error, invalid symbol given for determining state transition.");
   } else {
@@ -452,8 +452,8 @@ nat follow(const parserdef& p, const transition& x) {
 
 nat follow(const parserdef& p, nat s, const terminals& ts) {
   nat r = s;
-  for (terminals::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-    r = follow(p, r, *t);
+  for (auto *t : ts) {
+    r = follow(p, r, t);
   }
   return r;
 }
@@ -464,10 +464,10 @@ bool lookback(const parserdef& p, nat q, terminal* r, const rule& w, const trans
     return false;
   } else {
     nat s = t.first;
-    for (rule::const_iterator t = w.begin(); t != w.end(); ++t) {
+    for (auto *t : w) {
       const state_transitions& st = transitions(p, s);
-      if (follows(st, *t)) {
-        s = follow(st, *t);
+      if (follows(st, t)) {
+        s = follow(st, t);
       } else {
         return false;
       }
@@ -477,7 +477,7 @@ bool lookback(const parserdef& p, nat q, terminal* r, const rule& w, const trans
 }
 
 // for a rule w and sym A, find all prefixes b such that w = bAs, s =>* eps
-typedef std::vector<terminals> prefixes;
+using prefixes = std::vector<terminals>;
 
 prefixes endingAt(const parserdef& p, const rule& w, terminal* a) {
   prefixes r;
@@ -498,10 +498,10 @@ prefixes endingAt(const parserdef& p, const rule& w, terminal* a) {
 // x=(s,A) includes y=(s',B) if B -> wAg, g =>* eps, and s' --w--> s
 bool includes(const parserdef& p, const transition& x, const transition& y) {
   const rules* rs = aggRules(p.g, y.second);
-  for (rules::const_iterator r = rs->begin(); r != rs->end(); ++r) {
-    prefixes pr = endingAt(p, *r, x.second);
-    for (prefixes::const_iterator pfx = pr.begin(); pfx != pr.end(); ++pfx) {
-      if (follow(p, y.first, *pfx) == x.first) {
+  for (const auto &r : *rs) {
+    prefixes pr = endingAt(p, r, x.second);
+    for (const auto & pfx : pr) {
+      if (follow(p, y.first, pfx) == x.first) {
         return true;
       }
     }
@@ -522,7 +522,7 @@ terminalset directReads(const parserdef& p, const transition& x) {
 // a utility to make it easier to create closures
 template <typename E, typename X0, typename R>
   struct clos1 {
-    typedef R (*PFN)(const E&, const X0&);
+    using PFN = R (*)(const E &, const X0 &);
     const E& env;
     PFN      fn;
     
@@ -532,7 +532,7 @@ template <typename E, typename X0, typename R>
 
 template <typename E, typename X0, typename X1, typename R>
   struct clos2 {
-    typedef R (*PFN)(const E&, const X0&, const X1&);
+    using PFN = R (*)(const E &, const X0 &, const X1 &);
     const E& env;
     PFN      fn;
 
@@ -541,13 +541,13 @@ template <typename E, typename X0, typename X1, typename R>
   };
 
 // typedefs to work around type inference failure for the below digraph expressions
-typedef terminalset (*ptsappend)(const terminalset&, const terminalset&);
+using ptsappend = terminalset (*)(const terminalset &, const terminalset &);
 
-typedef clos1<parserdef, transition,             terminalset> DRT;
-typedef clos2<parserdef, transition, transition, bool>        readsT;
+using DRT = clos1<parserdef, transition, terminalset>;
+using readsT = clos2<parserdef, transition, transition, bool>;
 
-typedef clos1<transition_lookahead, transition,             terminalset> RT;
-typedef clos2<parserdef,            transition, transition, bool>        includesT;
+using RT = clos1<transition_lookahead, transition, terminalset>;
+using includesT = clos2<parserdef, transition, transition, bool>;
 
 // compute Read(x=(s,A)) = directReads(s,A) + (Read(q,B) | (s,A) reads (q,B))
 transition_lookahead Reads(const parserdef& p, const transitionset& ts) {
@@ -562,13 +562,13 @@ transition_lookahead Follow(const parserdef& p, const transitionset& ts) {
 
 // apply transition lookahead to every applicable completed item in an LR(0) parser
 void apply(const transition_lookahead& tl, parserdef* p) {
-  for (parser_states::iterator s = p->states.begin(); s != p->states.end(); ++s) {
-    for (itemset::iterator i = s->first.begin(); i != s->first.end(); ++i) {
+  for (auto s = p->states.begin(); s != p->states.end(); ++s) {
+    for (auto i = s->first.begin(); i != s->first.end(); ++i) {
       // if this is a completed item, then we need to give it lookahead terminals
-      if (next(p->g, *i) == 0) {
-        for (transition_lookahead::const_iterator tli = tl.begin(); tli != tl.end(); ++tli) {
-          if (lookback(*p, s->second, i->agg, nthRule(aggRules(p->g, i->agg), i->r), tli->first)) {
-            const_cast<item*>(&(*(i)))->la.insert(tli->second.begin(), tli->second.end());
+      if (next(p->g, *i) == nullptr) {
+        for (const auto &tli : tl) {
+          if (lookback(*p, s->second, i->agg, nthRule(aggRules(p->g, i->agg), i->r), tli.first)) {
+            const_cast<item*>(&(*(i)))->la.insert(tli.second.begin(), tli.second.end());
           }
         }
       }
@@ -587,23 +587,23 @@ parserdef lalr1parser(const grammar& g, terminal* s) {
 
 terminal* reduceOpTerminal(const parserdef& pd, const action& a) {
   const rule& r = nthRule(aggRules(pd.g, a.reduceSym()), a.reduceRule());
-  for (rule::const_reverse_iterator e = r.rbegin(); e != r.rend(); ++e) {
+  for (auto e = r.rbegin(); e != r.rend(); ++e) {
     if (!hasRule(pd.g, *e)) {
       return *e;
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool shiftInstead(const parserdef& pd, const precedence& px, nat, terminal* t, const action& a) {
   terminal* u = reduceOpTerminal(pd, a);
 
-  if (!u) {
+  if (u == nullptr) {
     throw ambiguity_conflict("Unable to resolve shift/reduce conflict in grammar", t);
   }
 
-  precedence::const_iterator tp = px.find(t);
-  precedence::const_iterator up = px.find(u);
+  auto tp = px.find(t);
+  auto up = px.find(u);
 
   if (tp == px.end() || up == px.end()) {
     throw ambiguity_conflict("Unable to resolve shift/reduce conflict in grammar", t);
@@ -614,11 +614,7 @@ bool shiftInstead(const parserdef& pd, const precedence& px, nat, terminal* t, c
   } else if (up->second.level < tp->second.level) {
     return true;
   } else if (tp->second.asc == up->second.asc && tp->second.asc != assoc::non) {
-    if (tp->second.asc == assoc::left) {
-      return false;
-    } else {
-      return true;
-    }
+    return tp->second.asc != assoc::left;
   } else {
     throw ambiguity_conflict("Unable to resolve shift/reduce conflict in grammar", t);
   }
@@ -630,7 +626,7 @@ lrtable lalrTable(const grammar& g, terminal* s, const precedence& px) {
 }
 
 void addAction(const parserdef& pd, lrstate& s, terminal* t, const action& a, const precedence& px) {
-  lrstate::iterator sc = s.find(t);
+  auto sc = s.find(t);
   if (sc == s.end()) {
     s.insert(std::make_pair(t, a));
   } else if (sc->second != a) {
@@ -655,8 +651,8 @@ void addAccept(lrstate& s, terminal* t) {
 }
 
 void addReduce(const parserdef& pd, lrstate& s, const terminalset& ts, terminal* agg, nat rule, nat len, const precedence& px) {
-  for (terminalset::const_iterator t = ts.begin(); t != ts.end(); ++t) {
-    addAction(pd, s, *t, action::reduce(agg, rule, len), px);
+  for (auto *t : ts) {
+    addAction(pd, s, t, action::reduce(agg, rule, len), px);
   }
 }
 
@@ -672,7 +668,7 @@ lrtable lalrTable(const parserdef& p, const precedence& px) {
   lrtable r;
   r.resize(p.states.size());
 
-  for (parser_states::const_iterator s = p.states.begin(); s != p.states.end(); ++s) {
+  for (auto s = p.states.begin(); s != p.states.end(); ++s) {
     // each item in this state's set translates to an LR parser action (goto, shift, reduce, or accept)
     const itemset& is = s->first;
     nat            n  = s->second;
@@ -680,12 +676,12 @@ lrtable lalrTable(const parserdef& p, const precedence& px) {
 
     // if we fail to compile a table row, report the itemset that failed
     try {
-      for (itemset::const_iterator i = is.begin(); i != is.end(); ++i) {
-        terminal* t = next(p.g, *i);
+      for (const auto & i : is) {
+        terminal* t = next(p.g, i);
   
-        if (t == 0) {
+        if (t == nullptr) {
           // reduce
-          addReduce(p, ps, i->la, i->agg, i->r, i->p, px);
+          addReduce(p, ps, i.la, i.agg, i.r, i.p, px);
         } else if (hasRule(p.g, t)) {
           // goto
           addGoto(ps, t, follow(p, n, t));
@@ -705,14 +701,14 @@ lrtable lalrTable(const parserdef& p, const precedence& px) {
   return r;
 }
 
-ambiguity_conflict::ambiguity_conflict(const std::string& ex, terminal* t) throw() : std::runtime_error(ex), t(t) {
+ambiguity_conflict::ambiguity_conflict(const std::string& ex, terminal* t) noexcept : std::runtime_error(ex), t(t) {
 }
 
 terminal* ambiguity_conflict::failedTerminal() const {
   return this->t;
 }
 
-compile_table_failure::compile_table_failure(const std::string& msg, const grammar& g, const itemset& faileditems, terminal* t) throw() : std::runtime_error(msg), g(g), faileditems(faileditems), t(t) {
+compile_table_failure::compile_table_failure(const std::string& msg, const grammar& g, const itemset& faileditems, terminal* t) noexcept : std::runtime_error(msg), g(g), faileditems(faileditems), t(t) {
 }
 
 const grammar& compile_table_failure::failedGrammar() const {
@@ -732,9 +728,9 @@ inline bool referencesSym(const grammar& g, const item& i, terminal* t) {
 }
 
 void compile_table_failure::print(std::ostream& out) const {
-  for (itemset::const_iterator i = this->faileditems.begin(); i != this->faileditems.end(); ++i) {
-    if (referencesSym(this->g, *i, this->t)) {
-      print(out, *i);
+  for (const auto &faileditem : this->faileditems) {
+    if (referencesSym(this->g, faileditem, this->t)) {
+      print(out, faileditem);
     }
   }
 }
@@ -780,8 +776,8 @@ void compile_table_failure::print(std::ostream& out, const item& i) const {
   if (i.p == r.size()) {
     out << "#";
     out << " [";
-    if (i.la.size() > 0) {
-      terminalset::const_iterator lat = i.la.begin();
+    if (!i.la.empty()) {
+      auto lat = i.la.begin();
       showHLTerm(out, *lat, this->t);
       ++lat;
       while (lat != i.la.end()) {
@@ -796,8 +792,7 @@ void compile_table_failure::print(std::ostream& out, const item& i) const {
 }
 
 // lr tables / actions
-action::action() {
-}
+action::action() = default;
 
 action action::goTo(nat s) {
   action a;
@@ -893,7 +888,7 @@ terminals dispOrd(const terminalset& ts) {
         } else {
           return true;
         }
-      } else if (dynamic_cast<character*>(b)) {
+      } else if (dynamic_cast<character*>(b) != nullptr) {
         return false;
       } else {
         std::ostringstream as, bs;
@@ -909,7 +904,7 @@ terminals dispOrd(const terminalset& ts) {
 void show(std::ostream& out, const lrtable& tbl) {
   auto      ts = dispOrd(definedSymbols(tbl));
   str::seqs stbl;
-  for (auto t : ts) {
+  for (auto *t : ts) {
     stbl.push_back(str::seq());
     str::seq& c = stbl.back();
 
diff --git a/lib/hobbes/parse/parser.C b/lib/hobbes/parse/parser.C
index 5dab5bdca..63975fd37 100644
--- a/lib/hobbes/parse/parser.C
+++ b/lib/hobbes/parse/parser.C
@@ -6,6 +6,7 @@
 
 // useful for debugging generated expressions
 #include <hobbes/lang/pat/print.H>
+#include <memory>
 
 namespace hobbes {
 
@@ -41,7 +42,7 @@ struct ParserEvalInfo {
   parserdef   pdef;
   lrtable     table;
 
-  typedef std::map<terminal*, Exprs> ReduceExprs;
+  using ReduceExprs = std::map<terminal *, Exprs>;
   ReduceExprs reduceExprs;
 };
 
@@ -128,7 +129,7 @@ str::seq varNames(size_t n) {
 
 size_t parseDepth(const ParserEvalInfo& pei, size_t i) {
   auto sd = pei.pdef.state_defs.find(i);
-  if (sd == pei.pdef.state_defs.end() || sd->second.size() == 0) {
+  if (sd == pei.pdef.state_defs.end() || sd->second.empty()) {
     throw std::runtime_error("Internal error, can't find depth for invalid state #" + str::from(i));
   } else {
     size_t d = 0;
@@ -265,7 +266,7 @@ ExprPtr doAction(const ParserEvalInfo& pei, size_t i, const action& act) {
 }
 
 ExprPtr makeInputParserState(const ParserEvalInfo& pei, size_t i) {
-  const action* eofAct = 0;
+  const action* eofAct = nullptr;
   PatternRows prs;
   for (const auto& sp : pei.table[i]) {
     if (sp.first == endOfFile::value()) {
@@ -281,7 +282,7 @@ ExprPtr makeInputParserState(const ParserEvalInfo& pei, size_t i) {
     fn(append(str::strings(".arr", ".i", ".sd"), varNames(parseDepth(pei, i))),
       // if (i == size(arr)) then eval-$ else eval-char
       fncall(var("if", pei.la), list(fncall(var("leq", pei.la), list(var(".i", pei.la), lengthOf(assume(var(".arr", pei.la), pei.arrty, pei.la), pei.la)), pei.la),
-        eofAct ? doAction(pei, i, *eofAct) : parseFailure(pei, i),
+        eofAct != nullptr ? doAction(pei, i, *eofAct) : parseFailure(pei, i),
         compileMatch(pei.c, list(elementOf(var(".arr", pei.la), var(".i", pei.la), pei.la)), prs, pei.la)
       ), pei.la),
       pei.la
@@ -328,13 +329,13 @@ ExprPtr makeParser(cc* c, const Parser& p, terminal* root, const precedence& pre
   return
     assume(
       fn(str::strings(".arr"), e, la),
-      qualtype(list(ConstraintPtr(new Constraint("Array", list(pei.arrty, primty("char"))))), functy(list(pei.arrty), parseResultType(pei))),
+      qualtype(list(std::make_shared<Constraint>("Array", list(pei.arrty, primty("char")))), functy(list(pei.arrty), parseResultType(pei))),
       la
     );
 }
 
 ExprPtr makeParser(cc* c, const Parser& p, const precedence& prec, const LexicalAnnotation& la) {
-  if (p.size() > 0) {
+  if (!p.empty()) {
     return makeParser(c, p, p[0].symbol, prec, la);
   } else {
     throw std::runtime_error("Internal error, cannot produce parser from empty definition");
diff --git a/lib/hobbes/parse/terminal.C b/lib/hobbes/parse/terminal.C
index 46ef56e94..fae090465 100644
--- a/lib/hobbes/parse/terminal.C
+++ b/lib/hobbes/parse/terminal.C
@@ -37,7 +37,7 @@ void symbol::show(std::ostream& out) const {
 }
 
 // eof
-endOfFile::endOfFile() { }
+endOfFile::endOfFile() = default;
 
 void endOfFile::show(std::ostream& out) const {
   out << "$";
diff --git a/lib/hobbes/read/parser.C b/lib/hobbes/read/parser.C
index 72104433f..a64313524 100644
--- a/lib/hobbes/read/parser.C
+++ b/lib/hobbes/read/parser.C
@@ -1,18 +1,18 @@
 
-#include <hobbes/lang/module.H>
+#include <cstdio>
+#include <fstream>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/module.H>
 #include <hobbes/lang/pat/pattern.H>
 #include <hobbes/parse/grammar.H>
-#include <hobbes/read/pgen/hexpr.parse.H>
 #include <hobbes/read/parser.H>
+#include <hobbes/read/pgen/hexpr.parse.H>
 #include <hobbes/util/autorelease.H>
+#include <iostream>
 #include <mutex>
-#include <string>
-#include <stdexcept>
 #include <stack>
-#include <iostream>
-#include <fstream>
-#include <stdio.h>
+#include <stdexcept>
+#include <string>
 
 // protect access to lexer/parser globals (blech)
 static std::recursive_mutex parse_mutex;
@@ -39,7 +39,7 @@ extern YYLTYPE         yyErrPos;
 extern int yyparse();
 #define YY_BUF_SIZE 16384
 struct yy_buffer_state;
-typedef yy_buffer_state* YY_BUFFER_STATE;
+using YY_BUFFER_STATE = yy_buffer_state *;
 extern YY_BUFFER_STATE yy_scan_string(const char*);
 extern YY_BUFFER_STATE yy_create_buffer(FILE*, int);
 extern void yy_switch_to_buffer(YY_BUFFER_STATE);
@@ -89,7 +89,7 @@ void runParserOnBuffer(cc* c, int initTok, YY_BUFFER_STATE bs) {
   yy_delete_buffer(bs);
   if (!activeParseBuffers.empty()) { yy_switch_to_buffer(activeParseBuffers.top()); }
 
-  if (yyVexpLexError.size() > 0) {
+  if (!yyVexpLexError.empty()) {
     std::string msg = yyVexpLexError;
     yyVexpLexError = "";
     throw std::runtime_error(msg);
@@ -98,7 +98,7 @@ void runParserOnBuffer(cc* c, int initTok, YY_BUFFER_STATE bs) {
 
 void runParserOnFile(cc* c, int initTok, const std::string& fname) {
   FILE* f = fopen(fname.c_str(), "r");
-  if (!f) {
+  if (f == nullptr) {
     throw std::runtime_error("Failed to open file for reading, '" + fname + "'");
   }
   try {
@@ -134,21 +134,21 @@ void runParserOnString(cc* c, int initTok, const char* s) {
 ModulePtr defReadModuleFile(cc* c, const std::string& file) {
   LOCK_PARSER;
 
-  yyParsedModule = 0;
+  yyParsedModule = nullptr;
   yyModulePath = str::rsplit(file, "/").first;
   runParserOnFile(c, TPARSEMODULE, file);
   yyModulePath = "";
 
-  return checkReturn(yyParsedModule ? ModulePtr(yyParsedModule) : ModulePtr());
+  return checkReturn(yyParsedModule != nullptr ? ModulePtr(yyParsedModule) : ModulePtr());
 }
 
 ModulePtr defReadModule(cc* c, const char* text) {
   LOCK_PARSER;
 
-  yyParsedModule = 0;
+  yyParsedModule = nullptr;
   runParserOnString(c, TPARSEMODULE, text);
 
-  return checkReturn(yyParsedModule ? ModulePtr(yyParsedModule) : ModulePtr());
+  return checkReturn(yyParsedModule != nullptr ? ModulePtr(yyParsedModule) : ModulePtr());
 }
 
 ModulePtr defReadModule(cc* c, const std::string& text) {
@@ -159,19 +159,19 @@ ExprDefn defReadExprDefn(cc* c, const std::string& expr) {
   LOCK_PARSER;
 
   yyParsedVar  = "";
-  yyParsedExpr = 0;
+  yyParsedExpr = nullptr;
   runParserOnString(c, TPARSEDEFN, expr.c_str());
 
-  return ExprDefn(yyParsedVar, checkReturn(yyParsedExpr ? ExprPtr(yyParsedExpr) : ExprPtr()));
+  return ExprDefn(yyParsedVar, checkReturn(yyParsedExpr != nullptr ? ExprPtr(yyParsedExpr) : ExprPtr()));
 }
 
 ExprPtr defReadExpr(cc* c, const std::string& expr) {
   LOCK_PARSER;
 
-  yyParsedExpr = 0;
+  yyParsedExpr = nullptr;
   runParserOnString(c, TPARSEEXPR, expr.c_str());
 
-  return checkReturn(yyParsedExpr ? ExprPtr(yyParsedExpr) : ExprPtr());
+  return checkReturn(yyParsedExpr != nullptr ? ExprPtr(yyParsedExpr) : ExprPtr());
 }
 
 // allow variable and pattern variable overloading
diff --git a/lib/hobbes/read/pgen/hexpr.lex.C b/lib/hobbes/read/pgen/hexpr.lex.C
index 42a06871d..17ee6afab 100644
--- a/lib/hobbes/read/pgen/hexpr.lex.C
+++ b/lib/hobbes/read/pgen/hexpr.lex.C
@@ -990,11 +990,11 @@ YY_DECL
 		YY_USER_INIT;
 #endif
 
-    /* Create the reject buffer large enough to save one state per allowed character. */
-    if ( ! (yy_state_buf) )
-      (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
-    if ( ! (yy_state_buf) )
-      YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+        /* Create the reject buffer large enough to save one state per allowed character. */
+      if ( ! (yy_state_buf) )
+        (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
+      if ( ! (yy_state_buf) )
+        YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
 
 		if ( ! (yy_start) )
 			(yy_start) = 1;	/* first start state */
diff --git a/lib/hobbes/read/pgen/hexpr.parse.C b/lib/hobbes/read/pgen/hexpr.parse.C
index 319b2067c..91e0dcb97 100644
--- a/lib/hobbes/read/pgen/hexpr.parse.C
+++ b/lib/hobbes/read/pgen/hexpr.parse.C
@@ -72,12 +72,12 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
-typedef struct YYLTYPE {
+using YYLTYPE = struct YYLTYPE {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} YYLTYPE;
+};
 #define YYLTYPE_IS_DECLARED 1
 
 #define YYLLOC_DEFAULT(L, R, N) \
@@ -92,32 +92,32 @@ typedef struct YYLTYPE {
   }
 #line 25 "hexpr.y"
 
-#include <hobbes/lang/module.H>
+#include <cstdio>
+#include <hobbes/db/bindings.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/module.H>
 #include <hobbes/lang/pat/pattern.H>
 #include <hobbes/lang/type.H>
 #include <hobbes/lang/typepreds.H>
-#include <hobbes/db/bindings.H>
-#include <hobbes/util/autorelease.H>
-#include <hobbes/util/str.H>
-#include <hobbes/util/array.H>
 #include <hobbes/parse/grammar.H>
 #include <hobbes/parse/lalr.H>
 #include <hobbes/read/pgen/hexpr.parse.H>
-#include <string>
+#include <hobbes/util/array.H>
+#include <hobbes/util/autorelease.H>
+#include <hobbes/util/str.H>
 #include <stdexcept>
+#include <string>
 #include <vector>
-#include <stdio.h>
 
 using namespace hobbes;
 
-typedef std::pair<PatternPtr, ExprPtr> LetBinding;
-typedef std::vector<LetBinding>        LetBindings;
+using LetBinding = std::pair<PatternPtr, ExprPtr>;
+using LetBindings = std::vector<LetBinding>;
 
 cc*         yyParseCC;
-Module*     yyParsedModule = 0;
+Module*     yyParsedModule = nullptr;
 std::string yyParsedVar;
-Expr*       yyParsedExpr   = 0;
+Expr*       yyParsedExpr   = nullptr;
 std::string yyMatchDiagram;
 std::string yyModulePath;
 YYLTYPE     yyErrPos;
@@ -146,7 +146,7 @@ LexicalAnnotation m(const YYLTYPE& p0, const YYLTYPE& p1) {
 #define TAPP3(fn,x0,x1,x2,la) new App(fn, list(ExprPtr(x0),ExprPtr(x1),ExprPtr(x2)), la)
 
 Expr* pickNestedExp(Exprs* exprs, const LexicalAnnotation& la) {
-  if (exprs->size() == 0) {
+  if (exprs->empty()) {
     return new Unit(la);
   } else if (exprs->size() == 1) {
     return (*exprs)[0]->clone();
@@ -160,7 +160,7 @@ Expr* pickNestedExp(Exprs* exprs, const LexicalAnnotation& la) {
 }
 
 Pattern* pickNestedPat(Patterns* pats, const LexicalAnnotation& la) {
-  if (pats->size() == 0) {
+  if (pats->empty()) {
     return new MatchLiteral(PrimitivePtr(new Unit(la)), la);
   } else {
     MatchRecord::Fields fds;
@@ -172,7 +172,7 @@ Pattern* pickNestedPat(Patterns* pats, const LexicalAnnotation& la) {
 }
 
 PatternRows normPatternRules(PatternRows rs, const LexicalAnnotation& la) {
-  if (rs.size() > 0 && !rs.back().result) {
+  if (!rs.empty() && !rs.back().result) {
     throw annotated_error(la, "match table can't end with fall-through row");
   }
 
@@ -186,7 +186,7 @@ PatternRows normPatternRules(PatternRows rs, const LexicalAnnotation& la) {
 
 Expr* compileNestedLetMatch(const LetBindings& bs, const ExprPtr& e, const LexicalAnnotation& la) {
   ExprPtr r = e;
-  for (LetBindings::const_reverse_iterator b = bs.rbegin(); b != bs.rend(); ++b) {
+  for (auto b = bs.rbegin(); b != bs.rend(); ++b) {
     r = compileMatch(yyParseCC, list(b->second), list(PatternRow(list(b->first), r)), la);
   }
   return r->clone();
@@ -265,7 +265,7 @@ MonoTypePtr monoTypeByName(const std::string& tn) {
 }
 
 MonoTypePtr accumTApp(const MonoTypes& ts) {
-  if (ts.size() == 0) {
+  if (ts.empty()) {
     throw std::runtime_error("Internal parser error for type applications");
   } else if (ts.size() == 1) {
     return ts[0];
@@ -349,8 +349,8 @@ str::seq tupSectionFields(const std::string& x) {
 
 // override var and pat-var construction
 namespace hobbes {
-typedef Expr* (*VarCtorFn)(const std::string&, const LexicalAnnotation&);
-typedef Pattern* (*PatVarCtorFn)(const std::string&, const LexicalAnnotation&);
+using VarCtorFn = Expr *(*)(const std::string &, const LexicalAnnotation &);
+using PatVarCtorFn = Pattern *(*)(const std::string &, const LexicalAnnotation &);
 extern VarCtorFn varCtorFn;
 extern PatVarCtorFn patVarCtorFn;
 }
diff --git a/lib/hobbes/read/pgen/hexpr.y b/lib/hobbes/read/pgen/hexpr.y
index 9406ff357..b1bc0b152 100644
--- a/lib/hobbes/read/pgen/hexpr.y
+++ b/lib/hobbes/read/pgen/hexpr.y
@@ -2,12 +2,12 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
-typedef struct YYLTYPE {
+using YYLTYPE = struct YYLTYPE {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} YYLTYPE;
+};
 #define YYLTYPE_IS_DECLARED 1
 
 #define YYLLOC_DEFAULT(L, R, N) \
@@ -23,32 +23,32 @@ typedef struct YYLTYPE {
 %}
 
 %{
-#include <hobbes/lang/module.H>
+#include <cstdio>
+#include <hobbes/db/bindings.H>
 #include <hobbes/lang/expr.H>
+#include <hobbes/lang/module.H>
 #include <hobbes/lang/pat/pattern.H>
 #include <hobbes/lang/type.H>
 #include <hobbes/lang/typepreds.H>
-#include <hobbes/db/bindings.H>
-#include <hobbes/util/autorelease.H>
-#include <hobbes/util/str.H>
-#include <hobbes/util/array.H>
 #include <hobbes/parse/grammar.H>
 #include <hobbes/parse/lalr.H>
 #include <hobbes/read/pgen/hexpr.parse.H>
-#include <string>
+#include <hobbes/util/array.H>
+#include <hobbes/util/autorelease.H>
+#include <hobbes/util/str.H>
 #include <stdexcept>
+#include <string>
 #include <vector>
-#include <stdio.h>
 
 using namespace hobbes;
 
-typedef std::pair<PatternPtr, ExprPtr> LetBinding;
-typedef std::vector<LetBinding>        LetBindings;
+using LetBinding = std::pair<PatternPtr, ExprPtr>;
+using LetBindings = std::vector<LetBinding>;
 
 cc*         yyParseCC;
-Module*     yyParsedModule = 0;
+Module*     yyParsedModule = nullptr;
 std::string yyParsedVar;
-Expr*       yyParsedExpr   = 0;
+Expr*       yyParsedExpr   = nullptr;
 std::string yyMatchDiagram;
 std::string yyModulePath;
 YYLTYPE     yyErrPos;
@@ -77,7 +77,7 @@ LexicalAnnotation m(const YYLTYPE& p0, const YYLTYPE& p1) {
 #define TAPP3(fn,x0,x1,x2,la) new App(fn, list(ExprPtr(x0),ExprPtr(x1),ExprPtr(x2)), la)
 
 Expr* pickNestedExp(Exprs* exprs, const LexicalAnnotation& la) {
-  if (exprs->size() == 0) {
+  if (exprs->empty()) {
     return new Unit(la);
   } else if (exprs->size() == 1) {
     return (*exprs)[0]->clone();
@@ -91,7 +91,7 @@ Expr* pickNestedExp(Exprs* exprs, const LexicalAnnotation& la) {
 }
 
 Pattern* pickNestedPat(Patterns* pats, const LexicalAnnotation& la) {
-  if (pats->size() == 0) {
+  if (pats->empty()) {
     return new MatchLiteral(PrimitivePtr(new Unit(la)), la);
   } else {
     MatchRecord::Fields fds;
@@ -103,7 +103,7 @@ Pattern* pickNestedPat(Patterns* pats, const LexicalAnnotation& la) {
 }
 
 PatternRows normPatternRules(PatternRows rs, const LexicalAnnotation& la) {
-  if (rs.size() > 0 && !rs.back().result) {
+  if (!rs.empty() && !rs.back().result) {
     throw annotated_error(la, "match table can't end with fall-through row");
   }
 
@@ -117,7 +117,7 @@ PatternRows normPatternRules(PatternRows rs, const LexicalAnnotation& la) {
 
 Expr* compileNestedLetMatch(const LetBindings& bs, const ExprPtr& e, const LexicalAnnotation& la) {
   ExprPtr r = e;
-  for (LetBindings::const_reverse_iterator b = bs.rbegin(); b != bs.rend(); ++b) {
+  for (auto b = bs.rbegin(); b != bs.rend(); ++b) {
     r = compileMatch(yyParseCC, list(b->second), list(PatternRow(list(b->first), r)), la);
   }
   return r->clone();
@@ -196,7 +196,7 @@ MonoTypePtr monoTypeByName(const std::string& tn) {
 }
 
 MonoTypePtr accumTApp(const MonoTypes& ts) {
-  if (ts.size() == 0) {
+  if (ts.empty()) {
     throw std::runtime_error("Internal parser error for type applications");
   } else if (ts.size() == 1) {
     return ts[0];
@@ -280,8 +280,8 @@ str::seq tupSectionFields(const std::string& x) {
 
 // override var and pat-var construction
 namespace hobbes {
-typedef Expr* (*VarCtorFn)(const std::string&, const LexicalAnnotation&);
-typedef Pattern* (*PatVarCtorFn)(const std::string&, const LexicalAnnotation&);
+using VarCtorFn = Expr *(*)(const std::string &, const LexicalAnnotation &);
+using PatVarCtorFn = Pattern *(*)(const std::string &, const LexicalAnnotation &);
 extern VarCtorFn varCtorFn;
 extern PatVarCtorFn patVarCtorFn;
 }
diff --git a/lib/hobbes/util/lannotation.C b/lib/hobbes/util/lannotation.C
index 23c434aad..d82ee0723 100644
--- a/lib/hobbes/util/lannotation.C
+++ b/lib/hobbes/util/lannotation.C
@@ -1,14 +1,15 @@
 
+#include <fstream>
 #include <hobbes/util/lannotation.H>
-#include <stack>
+#include <memory>
 #include <sstream>
-#include <fstream>
+#include <stack>
 
 namespace hobbes {
 
 LexicalAnnotation::LexicalAnnotation() {
-  static BuffOrFilenamePtr* n = 0;
-  if (n == 0) {
+  static BuffOrFilenamePtr* n = nullptr;
+  if (n == nullptr) {
     n = new BuffOrFilenamePtr(new BuffOrFilename(false, "???"));
   }
   this->bfptr = *n;
@@ -73,18 +74,17 @@ LexicalAnnotation LexicalAnnotation::merge(const LexicalAnnotation& a0, const Le
   return r;
 }
 
-typedef std::stack<BuffOrFilenamePtr> AnnContextStack;
+using AnnContextStack = std::stack<BuffOrFilenamePtr>;
 
 static AnnContextStack& annotationCtxStack() {
-  static __thread AnnContextStack* actxs = 0;
-  if (!actxs) {
+  static __thread AnnContextStack* actxs = nullptr;
+  if (actxs == nullptr) {
     actxs = new AnnContextStack();
   }
   return *actxs;
 }
 
-LexicallyAnnotated::LexicallyAnnotated(const LexicallyAnnotated& rhs) : lannotation(rhs.lannotation) {
-}
+LexicallyAnnotated::LexicallyAnnotated(const LexicallyAnnotated& rhs) = default;
 
 LexicallyAnnotated::LexicallyAnnotated(const LexicalAnnotation& la) : lannotation(la) {
 }
@@ -100,11 +100,11 @@ const LexicalAnnotation& LexicallyAnnotated::la() const {
 }
 
 void LexicallyAnnotated::pushFileContext(const std::string& fname) {
-  annotationCtxStack().push(BuffOrFilenamePtr(new BuffOrFilename(true, fname)));
+  annotationCtxStack().push(std::make_shared<BuffOrFilename>(true, fname));
 }
 
 void LexicallyAnnotated::pushLiteralContext(const std::string& txt) {
-  annotationCtxStack().push(BuffOrFilenamePtr(new BuffOrFilename(false, txt)));
+  annotationCtxStack().push(std::make_shared<BuffOrFilename>(false, txt));
 }
 
 void LexicallyAnnotated::popContext() {
@@ -115,7 +115,7 @@ LexicalAnnotation LexicallyAnnotated::make(const Pos& p0, const Pos& p1) {
   auto& s = annotationCtxStack();
 
   LexicalAnnotation r;
-  r.bfptr = s.size() > 0 ? s.top() : BuffOrFilenamePtr(new BuffOrFilename(false, "???"));
+  r.bfptr = !s.empty() ? s.top() : std::make_shared<BuffOrFilename>(false, "???");
   r.p0    = p0;
   r.p1    = p1;
   return r;
@@ -145,7 +145,7 @@ std::string annotated_error::plainDesc(const annmsgs& amsgs) {
 
 annotated_error annotated_error::fileError(const std::string& fn, const Pos& p0, const Pos& p1, const std::string& etxt) {
   LexicalAnnotation a;
-  a.bfptr = BuffOrFilenamePtr(new BuffOrFilename(true, fn));
+  a.bfptr = std::make_shared<BuffOrFilename>(true, fn);
   a.p0    = p0;
   a.p1    = p1;
   return annotated_error(list(annmsg(etxt, a)));
@@ -153,7 +153,7 @@ annotated_error annotated_error::fileError(const std::string& fn, const Pos& p0,
 
 annotated_error annotated_error::bufferError(const std::string& b, const Pos& p0, const Pos& p1, const std::string& etxt) {
   LexicalAnnotation a;
-  a.bfptr = BuffOrFilenamePtr(new BuffOrFilename(false, b));
+  a.bfptr = std::make_shared<BuffOrFilename>(false, b);
   a.p0    = p0;
   a.p1    = p1;
   return annotated_error(list(annmsg(etxt, a)));
diff --git a/lib/hobbes/util/region.C b/lib/hobbes/util/region.C
index c7bc292d3..760b0ce7a 100644
--- a/lib/hobbes/util/region.C
+++ b/lib/hobbes/util/region.C
@@ -1,9 +1,9 @@
 
+#include <algorithm>
+#include <cstdlib>
+#include <hobbes/util/ptr.H>
 #include <hobbes/util/region.H>
 #include <hobbes/util/str.H>
-#include <hobbes/util/ptr.H>
-#include <stdlib.h>
-#include <algorithm>
 
 namespace hobbes {
 
@@ -11,9 +11,9 @@ void dbglog(const std::string&);
 
 region::region(size_t minPageSize, size_t initialFreePages, size_t maxPageSize) :
   minPageSize(minPageSize), maxPageSize(maxPageSize), lastAllocPageSize(minPageSize),
-  abortOnOOM(false), maxTotalAllocation(0), totalAllocation(0), usedp(0), freep(0)
+  abortOnOOM(false), maxTotalAllocation(0), totalAllocation(0), usedp(nullptr), freep(nullptr)
 {
-  this->usedp = newpage(0, minPageSize);
+  this->usedp = newpage(nullptr, minPageSize);
 
   for (size_t i = 0; i < initialFreePages; ++i) {
     this->freep = newpage(this->freep, minPageSize);
@@ -37,7 +37,7 @@ void* region::malloc(size_t sz, size_t asz) {
   } else {
     allocpage(sz + asz);
 
-    uint8_t* uresult = reinterpret_cast<uint8_t*>(this->usedp->base);
+    auto* uresult = reinterpret_cast<uint8_t*>(this->usedp->base);
     size_t   afixup  = align(reinterpret_cast<size_t>(uresult), asz) - reinterpret_cast<size_t>(uresult);
     uint8_t* result  = uresult + afixup;
 
@@ -50,9 +50,9 @@ void region::clear() {
   freepages(this->freep);
   freepages(this->usedp->succ);
 
-  this->freep       = 0;
+  this->freep       = nullptr;
   this->usedp->read = 0;
-  this->usedp->succ = 0;
+  this->usedp->succ = nullptr;
 
   this->lastAllocPageSize = this->minPageSize;
 }
@@ -62,17 +62,17 @@ void region::reset() {
   // link the final used page to the initial free page
   // finally set free to used, having computed free' = used ++ free
   mempage* p = this->usedp;
-  while (p != 0) {
+  while (p != nullptr) {
     mempage* np = p->succ;
 
     p->read = 0;
-    if (np == 0) {
+    if (np == nullptr) {
       p->succ = this->freep;
     }
     p = np;
   }
   this->freep = this->usedp->succ;
-  this->usedp->succ = 0;
+  this->usedp->succ = nullptr;
 }
 
 namespace pattr {
@@ -87,20 +87,20 @@ size_t sumAttr(const mempage* p, pattr::E a) {
   size_t r = 0;
   switch (a) {
   case pattr::allocated:
-    while (p) {
+    while (p != nullptr) {
       r += p->size;
       p = p->succ;
     }
     break;
   case pattr::used:
-    while (p) {
+    while (p != nullptr) {
       r += p->read;
       p = p->succ;
     }
     break;
   case pattr::wasted:
-    p = p ? p->succ : p;
-    while (p) {
+    p = p != nullptr ? p->succ : p;
+    while (p != nullptr) {
       r += p->size - p->read;
       p = p->succ;
     }
@@ -126,12 +126,12 @@ std::string showPage(mempage* p) {
 }
 
 std::string showPages(mempage* ps) {
-  if (ps == 0) {
+  if (ps == nullptr) {
     return "[]";
   } else {
     std::string r = showPage(ps);
     ps = ps->succ;
-    while (ps != 0) {
+    while (ps != nullptr) {
       r += "; ";
       r += showPage(ps);
       ps = ps->succ;
@@ -165,7 +165,7 @@ mempage* region::newpage(mempage* succ, size_t sz) {
     abort();
   }
 
-  mempage* p = new mempage;
+  auto* p = new mempage;
   p->size = psz;
   p->base = ::malloc(p->size);
   p->read = 0;
@@ -175,7 +175,7 @@ mempage* region::newpage(mempage* succ, size_t sz) {
 }
 
 void region::allocpage(size_t sz) {
-  if (this->freep != 0 && sz <= this->freep->size) {
+  if (this->freep != nullptr && sz <= this->freep->size) {
     // used = head free : used
     mempage* usednp = this->freep;
     mempage* freenp = this->freep->succ;
@@ -198,7 +198,7 @@ void region::freepage(mempage* p) {
 }
 
 void region::freepages(mempage* p) {
-  while (p != 0) {
+  while (p != nullptr) {
     mempage* np = p->succ;
     freepage(p);
     p = np;
diff --git a/lib/hobbes/util/str.C b/lib/hobbes/util/str.C
index 59f8a8132..46b5b42b0 100644
--- a/lib/hobbes/util/str.C
+++ b/lib/hobbes/util/str.C
@@ -8,7 +8,7 @@ namespace hobbes { namespace str {
 
 std::string env(const std::string& varname) {
   char* gv = getenv(varname.c_str());
-  return gv ? std::string(gv) : std::string("");
+  return gv != nullptr ? std::string(gv) : std::string("");
 }
 
 void env(const std::string& varname, const std::string& value) {
@@ -41,8 +41,8 @@ unsigned int maxStrLen(const seq& col) {
 
 lengths maxStrLen(const seqs& tbl) {
   lengths r;
-  for (unsigned int c = 0; c < tbl.size(); ++c) {
-    r.push_back(maxStrLen(tbl[c]));
+  for (const auto &c : tbl) {
+    r.push_back(maxStrLen(c));
   }
   return r;
 }
@@ -71,8 +71,8 @@ seq leftAlign(const seq& col) {
   size_t w = maxStrLen(col);
   seq r;
   r.reserve(col.size());
-  for (seq::const_iterator s = col.begin(); s != col.end(); ++s) {
-    r.push_back(leftAlign(w, *s));
+  for (const auto &s : col) {
+    r.push_back(leftAlign(w, s));
   }
   return r;
 }
@@ -81,8 +81,8 @@ seq rightAlign(const seq& col) {
   size_t w = maxStrLen(col);
   seq r;
   r.reserve(col.size());
-  for (seq::const_iterator s = col.begin(); s != col.end(); ++s) {
-    r.push_back(rightAlign(w, *s));
+  for (const auto &s : col) {
+    r.push_back(rightAlign(w, s));
   }
   return r;
 }
@@ -90,7 +90,7 @@ seq rightAlign(const seq& col) {
 seqs leftAlign(const seqs& tbl) {
   seqs r;
   r.reserve(tbl.size());
-  for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
+  for (auto c = tbl.begin(); c != tbl.end(); ++c) {
     r.push_back(c == tbl.end()-1 ? *c : leftAlign(*c));
   }
   return r;
@@ -99,14 +99,14 @@ seqs leftAlign(const seqs& tbl) {
 seqs rightAlign(const seqs& tbl) {
   seqs r;
   r.reserve(tbl.size());
-  for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
-    r.push_back(rightAlign(*c));
+  for (const auto &c : tbl) {
+    r.push_back(rightAlign(c));
   }
   return r;
 }
 
 bool validTable(const seqs& tbl) {
-  if (tbl.size() == 0) {
+  if (tbl.empty()) {
     return false;
   } else {
     size_t rsz = tbl[0].size();
@@ -122,13 +122,13 @@ bool validTable(const seqs& tbl) {
 void printAlignedTable(std::ostream& out, const seqs& tbl) {
   if (validTable(tbl)) {
     // draw the header
-    for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
-      out << (*c)[0] << " ";
+    for (const auto &c : tbl) {
+      out << c[0] << " ";
     }
     out << "\n";
 
     // draw the divider
-    for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
+    for (auto c = tbl.begin(); c != tbl.end(); ++c) {
       auto N = (c < tbl.end() - 1 ? (*c)[0].size() : maxStrLen(*c));
       out << std::string(N, '-') << " ";
     }
@@ -136,8 +136,8 @@ void printAlignedTable(std::ostream& out, const seqs& tbl) {
 
     // draw the data
     for (size_t r = 1; r < tbl[0].size(); ++r) {
-      for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
-        out << (*c)[r] << " ";
+      for (const auto &c : tbl) {
+        out << c[r] << " ";
       }
       out << "\n";
     }
@@ -156,8 +156,8 @@ void printHeadlessAlignedTable(std::ostream& out, const seqs& tbl) {
   if (validTable(tbl)) {
     for (size_t r = 0; r < tbl[0].size(); ++r) {
       if (r > 0) out << "\n";
-      for (seqs::const_iterator c = tbl.begin(); c != tbl.end(); ++c) {
-        out << (*c)[r] << " ";
+      for (const auto &c : tbl) {
+        out << c[r] << " ";
       }
     }
   }
@@ -184,14 +184,14 @@ std::string showRightAlignedTable(const seqs& tbl) {
 }
 
 std::string demangle(const char* tn) {
-  if (tn == 0) {
+  if (tn == nullptr) {
     return "";
   }
 
   int   s   = 0;
-  char* dmn = abi::__cxa_demangle(tn, 0, 0, &s);
+  char* dmn = abi::__cxa_demangle(tn, nullptr, nullptr, &s);
 
-  if (dmn == 0) {
+  if (dmn == nullptr) {
     return std::string(tn);
   } else {
     std::string r(dmn);
@@ -231,7 +231,7 @@ pair rsplit(const std::string& s, const std::string& ss) {
 }
 
 seq csplit(const std::string& str, const std::string& pivot) {
-  typedef std::string::size_type size_type;
+  using size_type = std::string::size_type;
 
   seq       ret;
   size_type mp = 0;
@@ -304,8 +304,8 @@ std::string hex(unsigned char x) {
 std::string hex(const std::vector<unsigned char>& cs) {
   std::ostringstream ss;
   ss << "0x";
-  for (std::vector<unsigned char>::const_iterator c = cs.begin(); c != cs.end(); ++c) {
-    ss << hex(*c);
+  for (const unsigned char c : cs) {
+    ss << hex(c);
   }
   return ss.str();
 }
@@ -398,12 +398,12 @@ bool endsWith(const std::string& s, const std::string& sfx) {
 }
 
 std::string show(const set& ss) {
-  if (ss.size() == 0) {
+  if (ss.empty()) {
     return "{}";
   } else {
     std::ostringstream r;
     r << "{";
-    set::const_iterator s = ss.begin();
+    auto s = ss.begin();
     r << *s;
     ++s;
     while (s != ss.end()) {
@@ -417,12 +417,12 @@ std::string show(const set& ss) {
 }
 
 std::string show(const named_strings& cfg) {
-  if (cfg.size() == 0) {
+  if (cfg.empty()) {
     return "{}";
   } else {
     std::ostringstream r;
     r << "{";
-    named_strings::const_iterator f = cfg.begin();
+    auto f = cfg.begin();
     r << f->first << "=" << f->second;
     ++f;
     while (f != cfg.end()) {
@@ -436,7 +436,7 @@ std::string show(const named_strings& cfg) {
 }
 
 char readCharDef(const std::string& x) {
-  if (x.size() == 0) {
+  if (x.empty()) {
     return 0;
   } else if (x[0] != '\'') {
     return x[0]; // ?
@@ -484,7 +484,7 @@ unsigned int firstFailIndex(bool (*P)(char), const std::string& s) {
 }
 
 std::string cdelim(const seq& ss, const std::string& d) {
-  if (ss.size() == 0) {
+  if (ss.empty()) {
     return "";
   } else {
     std::ostringstream r;
@@ -556,7 +556,7 @@ public:
       if (child != n->children.end()) {
         n = child->second.get();
       } else {
-        ptnode* nc = new ptnode();
+        auto* nc = new ptnode();
         n->children[c] = std::unique_ptr<ptnode>(nc);
         n = nc;
       }
@@ -581,7 +581,7 @@ public:
     return r;
   }
 private:
-  typedef std::map<char, std::unique_ptr<ptnode>> Children;
+  using Children = std::map<char, std::unique_ptr<ptnode>>;
   Children children;
 
   // does this node complete a valid word?
@@ -678,7 +678,7 @@ seq prefix_tree::closestMatches(const std::string& x, size_t maxDist) const {
 size_t editDistance(const std::string& x, const std::string& y) {
   std::map<size_t, seq> r = prefix_tree(strings(y)).rankedMatches(x, std::max<size_t>(x.size(), y.size()));
 
-  if (r.size() > 0) {
+  if (!r.empty()) {
     return r.begin()->first;
   } else {
     return std::max<size_t>(x.size(), y.size()); // seems unlikely ...
@@ -707,7 +707,7 @@ std::string mustEndWith(const std::string& x, const std::string& sfx) {
 // get a set of filesystem objects matching a pattern
 str::seq paths(const std::string& p) {
   glob_t g;
-  if (glob(p.c_str(), 0, 0, &g) != 0) {
+  if (glob(p.c_str(), 0, nullptr, &g) != 0) {
     return str::seq();
   } else if (g.gl_pathc == 0) {
     globfree(&g);
diff --git a/test/Arrays.C b/test/Arrays.C
index bcb5ee57f..7bbd7f8a9 100644
--- a/test/Arrays.C
+++ b/test/Arrays.C
@@ -63,9 +63,9 @@ TEST(Arrays, CppRAIIConsistency) {
 }
 
 TEST(Arrays, Alignment) {
-  short*        s = reinterpret_cast<short*>(threadRegion().malloc(sizeof(short), alignof(short)));
+  auto*        s = reinterpret_cast<short*>(threadRegion().malloc(sizeof(short), alignof(short)));
   int*          i = reinterpret_cast<int*>(threadRegion().malloc(sizeof(int)), alignof(int));
-  double*       d = reinterpret_cast<double*>(threadRegion().malloc(sizeof(double)), alignof(double));
+  auto*       d = reinterpret_cast<double*>(threadRegion().malloc(sizeof(double)), alignof(double));
   array<int>*   a = makeArray<int>(100);
 
   EXPECT_EQ(reinterpret_cast<size_t>(s)%sizeof(short),  size_t(0));
diff --git a/test/Compiler.C b/test/Compiler.C
index 76ec580bc..5f701ee31 100644
--- a/test/Compiler.C
+++ b/test/Compiler.C
@@ -5,9 +5,9 @@
 #include "test.H"
 
 using namespace hobbes;
-static cc& c() { static __thread cc* x = 0; if (!x) { x = new cc(); } return *x; }
+static cc& c() { static __thread cc* x = nullptr; if (x == nullptr) { x = new cc(); } return *x; }
 
-typedef std::pair<const char*, size_t> BufferView;
+using BufferView = std::pair<const char *, size_t>;
 
 TEST(Compiler, compileToSupportsMoreThanSixArgs) {
   std::string expression =
@@ -15,33 +15,24 @@ TEST(Compiler, compileToSupportsMoreThanSixArgs) {
     "| \"carrots\" \"parsley\" \"lemon\" \"ossobuco\" _ \"braising\" \"everyday\" \"basic\" \"wine\" \"polenta\" -> 10 \n"
     "| _ _ _ _ _ _ _ _ _ _ -> -1";
 
-  typedef int (*MatchFunPtr)(const BufferView*,   // vegetables
-                             const BufferView*,   // spices
-                             const BufferView*,   // fruits
-                             const BufferView*,   // meat
-                             const BufferView*,   // cheese
-                             const BufferView*,   // technique
-                             const BufferView*,   // occasion
-                             const BufferView*,   // skill
-                             const BufferView*,   // drink
-                             const BufferView*);  // side
+  using MatchFunPtr = int (*)(const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *, const BufferView *);  // side
   
   hobbes::cc compiler;
 
-  MatchFunPtr funPtr = hobbes::compileTo<MatchFunPtr>(
+  auto funPtr = hobbes::compileTo<MatchFunPtr>(
     &compiler,
     hobbes::list<std::string>("vegetables", "spices", "fruits",
                               "meat","cheese", "technique",
                               "occasion", "skill", "drink", "side"),
     expression);
   
-  EXPECT_TRUE(NULL != funPtr);
+  EXPECT_TRUE(nullptr != funPtr);
 }
 
 TEST(Compiler, charArrExpr) {
   char buffer[256];
   strncpy(buffer, "\"hello world\"\0", sizeof(buffer));
-  EXPECT_TRUE(c().compileFn<const array<char>*()>(buffer) != 0);
+  EXPECT_TRUE(c().compileFn<const array<char>*()>(buffer) != nullptr);
 }
 
 class BV { };
@@ -97,12 +88,12 @@ TEST(Compiler, ccInManyThreads) {
       badChecks += c.compileFn<int()>("sum([1..100])-100*101/2")(); // just 0, but complex enough to hit many areas of the compiler
     })));
   }
-  for (auto p : ps) { p->join(); delete p; }
+  for (auto *p : ps) { p->join(); delete p; }
   EXPECT_EQ(badChecks, size_t(0));
 }
 
-typedef std::array<int,10> IArr;
-typedef std::array<IArr,10> IMat;
+using IArr = std::array<int, 10>;
+using IMat = std::array<IArr, 10>;
 
 DEFINE_STRUCT(ArrTest,
   (short,  a),
@@ -128,7 +119,7 @@ TEST(Compiler, liftStdArray) {
   EXPECT_EQ((c().compileFn<int(ArrTest*)>("s","sum(concat([[x|x<-xs[0:]]|xs<-s.xss[0:]]))")(&atst)), 900);
 }
 
-typedef std::chrono::duration<int64_t, std::micro> ctimespanT;
+using ctimespanT = std::chrono::duration<int64_t, std::micro>;
 
 std::ostream& operator<<(std::ostream& out, ctimespanT dt) {
   out << *reinterpret_cast<int64_t*>(&dt) << "us";
@@ -142,7 +133,7 @@ TEST(Compiler, liftChronoTimespan) {
 
 // verify that types are lifted as expected for values without "return value optimization" (or "copy elision")
 TEST(Compiler, liftWithoutRVO) {
-  typedef hobbes::fileref<const hobbes::array<char>*> strref;
+  using strref = hobbes::fileref<const hobbes::array<char> *>;
 
   EXPECT_EQ(c().compileFn<strref(int)>("x", "unsafeCast(42L)")(0).index, strref(42UL).index);
 }
diff --git a/test/Convert.C b/test/Convert.C
index 056492c3c..c5c69e870 100644
--- a/test/Convert.C
+++ b/test/Convert.C
@@ -6,7 +6,7 @@ namespace hobbes {
 template <typename T, size_t N>
   std::ostream& operator<<(std::ostream& o, const std::array<T,N>& x) {
     o << "[";
-    if (x.size() > 0) {
+    if (!x.empty()) {
       o << x[0];
       for (size_t i = 1; i < x.size(); ++i) {
         o << ", " << x[i];
@@ -23,7 +23,7 @@ template <typename T, size_t N>
 using namespace hobbes;
 
 // the type we want to convert FROM (the type we receive)
-typedef std::array<int, 5> IArr;
+using IArr = std::array<int, 5>;
 
 DEFINE_VARIANT(
   Friend,
@@ -40,7 +40,7 @@ DEFINE_STRUCT(
 );
 
 // the type we want to convert TO
-typedef std::array<size_t,5> LArr;
+using LArr = std::array<size_t, 5>;
 
 DEFINE_VARIANT(
   NewFriend,
diff --git a/test/Definitions.C b/test/Definitions.C
index feea689d5..635f921f8 100644
--- a/test/Definitions.C
+++ b/test/Definitions.C
@@ -3,7 +3,7 @@
 #include "test.H"
 
 using namespace hobbes;
-static cc& c() { static __thread cc* x = 0; if (!x) { x = new cc(); } return *x; }
+static cc& c() { static __thread cc* x = nullptr; if (x == nullptr) { x = new cc(); } return *x; }
 
 TEST(Definitions, Basic) {
   c().define("defInt",      "42");
diff --git a/test/MC.C b/test/MC.C
index ab8f84126..20fc9f087 100644
--- a/test/MC.C
+++ b/test/MC.C
@@ -65,7 +65,7 @@ std::set<std::string> varNames(const mc::VarUniverse<mc::RInstM>& vu, const std:
 std::string show(const std::set<std::string>& xs) {
   std::ostringstream ss;
   ss << "{";
-  if (xs.size() > 0) {
+  if (!xs.empty()) {
     auto x = xs.begin();
     ss << "\"" << *x << "\"";
     ++x;
diff --git a/test/Main.C b/test/Main.C
index 15b37ea50..6e0e3b06c 100644
--- a/test/Main.C
+++ b/test/Main.C
@@ -103,7 +103,7 @@ std::string TestCoord::toJSON() {
 }
 
 void listTest() {
-  for (auto & test : TestCoord::instance().testGroupNames()) {
+  for (const auto & test : TestCoord::instance().testGroupNames()) {
     std::cout << test << std::endl;
   }
 }
@@ -118,7 +118,7 @@ Args parseArgs(int argc, char** argv) {
     {"list_tests", no_argument,       nullptr, 'l'},
     {"tests",      required_argument, nullptr, 't'},
     {"json",       required_argument, nullptr, 'r'},
-    {0,            no_argument,       nullptr, ' '}
+    {nullptr,            no_argument,       nullptr, ' '}
   };
 
   Args args;
diff --git a/test/Net.C b/test/Net.C
index 645ac46b8..126121041 100644
--- a/test/Net.C
+++ b/test/Net.C
@@ -39,7 +39,7 @@ static void runTestServer(int ps, int pe) {
 int testServerPort() {
   if (serverPort < 0) {
     std::unique_lock<std::mutex> lk(serverMtx);
-    std::thread serverProc(std::bind(&runTestServer, 8765, 9500));
+    std::thread serverProc([] { return runTestServer(8765, 9500); });
     serverProc.detach();
     serverStartup.wait(lk);
     if (serverPort < 0) {
@@ -76,7 +76,7 @@ int testServerWithHostPort(const std::string &host = "") {
   if (serverPortWithHost < 0) {
     std::unique_lock<std::mutex> lk(serverMtxWithHost);
     std::thread serverWithHostProc(
-        std::bind(&runTestServerWithHost, 9501, 10500, host));
+        [host] { return runTestServerWithHost(9501, 10500, host); });
     serverWithHostProc.detach();
     serverWithHostStartup.wait(lk);
     if (serverPortWithHost < 0) {
@@ -88,8 +88,8 @@ int testServerWithHostPort(const std::string &host = "") {
 /**************************
  * types/data for net communication
  **************************/
-typedef std::map<std::string, size_t> NameCounts;
-typedef std::pair<std::string, size_t> NC;
+using NameCounts = std::map<std::string, size_t>;
+using NC = std::pair<std::string, size_t>;
 bool operator==(const NameCounts &ncs, const std::vector<NC> &ncsc) {
   for (const auto &nc : ncsc) {
     auto i = ncs.find(nc.first);
@@ -107,7 +107,7 @@ std::ostream &operator<<(std::ostream &os, const NC &nc) {
 template <typename T>
 std::ostream &operator<<(std::ostream &os, const std::vector<T> &xs) {
   os << "[";
-  if (xs.size() > 0) {
+  if (!xs.empty()) {
     os << xs[0];
     for (size_t i = 1; i < xs.size(); ++i)
       os << ", " << xs[i];
@@ -132,7 +132,7 @@ std::ostream &operator<<(std::ostream &os, const NameCounts &ncsc) {
 DEFINE_ENUM(Kid, (Jim), (Bob));
 
 DEFINE_STRUCT(Group, (std::string, id), (Kid, kid), (double, aa), (size_t, bb));
-typedef std::vector<Group> Groups;
+using Groups = std::vector<Group>;
 std::ostream &operator<<(std::ostream &os, const Group &g) {
   os << "{id=\"" << g.id
      << "\", kid=" << ((g.kid == Kid::Jim()) ? "|Jim|" : "|Bob|")
@@ -183,7 +183,7 @@ template <> struct io<CustomIDEnum> {
     io<uint32_t>::read(s, reinterpret_cast<uint32_t *>(x));
   }
 
-  typedef io<uint32_t>::async_read_state async_read_state;
+  using async_read_state = io<uint32_t>::async_read_state;
   static void prepare(async_read_state *o) { io<uint32_t>::prepare(o); }
   static bool accum(int s, async_read_state *o, CustomIDEnum *x) {
     return io<uint32_t>::accum(s, o, reinterpret_cast<uint32_t *>(x));
diff --git a/test/Objects.C b/test/Objects.C
index 61d064434..d249d96a1 100644
--- a/test/Objects.C
+++ b/test/Objects.C
@@ -24,7 +24,7 @@ class Left : public virtual Top {
 public:
   Left(int x, double y, int z) : Top(x, y, z) { }
 
-  int foo(int,double,char) { return 10; }
+  int foo(int,double,char) override { return 10; }
   int bar()                { return 1111; }
 };
 
@@ -32,7 +32,7 @@ class Right : public virtual Top {
 public:
   Right(int x, double y, int z) : Top(x, y, z) { }
 
-  int foo(int,double,char) { return 20; }
+  int foo(int,double,char) override { return 20; }
   int baz()                { return 2222; }
 };
 
@@ -40,7 +40,7 @@ class Bottom : public Left, public Right {
 public:
   Bottom(int x, double y, int z) : Top(x, y, z), Left(x*z, y*y, z*x), Right(x*x, y*y, z*z) { }
 
-  int foo(int,double,char) { return 30; }
+  int foo(int,double,char) override { return 30; }
   int zzz()                { return 3333; }
 };
 
@@ -59,7 +59,7 @@ array<ArrObjV*>* arrobjs(int n) {
 // verify compilation of simple single-inheritance
 class SIBase {
 public:
-  virtual ~SIBase() { }
+  virtual ~SIBase() = default;
 
   virtual int doblah() {
     return 42;
@@ -71,7 +71,7 @@ public:
 
 class SIDerived : public SIBase {
 public:
-  int doblah() {
+  int doblah() override {
     return 20;
   }
 };
@@ -87,8 +87,8 @@ static cc& c() {
     x.bind("arrobjs", &arrobjs);
 
     static Left*   l = new Left  (1, 2.0, 3);
-    static Right*  r = new Right (4, 5.0, 6);
-    static Bottom* b = new Bottom(7, 8.0, 9);
+    static auto*  r = new Right (4, 5.0, 6);
+    static auto* b = new Bottom(7, 8.0, 9);
 
     x.bind("foo",  memberfn(&Top::foo));
     x.bind("getX", memberfn(&Top::getX));
@@ -103,7 +103,7 @@ static cc& c() {
     x.bind("r", r);
     x.bind("b", b);
 
-    static SIDerived* sid = new SIDerived();
+    static auto* sid = new SIDerived();
     x.bind("doblah", memberfn(&SIBase::doblah));
     x.bind("doit",   memberfn(&SIBase::doit));
     x.bind("sid",    sid);
diff --git a/test/Prelude.C b/test/Prelude.C
index 4ffbdd61d..c92451970 100644
--- a/test/Prelude.C
+++ b/test/Prelude.C
@@ -3,7 +3,7 @@
 #include "test.H"
 
 using namespace hobbes;
-static cc& c() { static __thread cc* x = 0; if (!x) { x = new cc(); } return *x; }
+static cc& c() { static __thread cc* x = nullptr; if (x == nullptr) { x = new cc(); } return *x; }
 
 #define EXPTEST(s) EXPECT_TRUE(c().compileFn<bool()>(s)())
 
diff --git a/test/Python.C b/test/Python.C
index 48250c0b1..34fac67f7 100644
--- a/test/Python.C
+++ b/test/Python.C
@@ -20,7 +20,7 @@ class PythonProc {
 public:
   PythonProc(const std::string& py, const std::string& moddir, const std::string& script, const std::string& db) : py(py), moddir(moddir), script(script), db(db)
   {
-    if(this->py == "")
+    if(this->py.empty())
       this->py = "/usr/bin/python"; // Give a default python execute path
     this->argv.push_back(this->py.c_str());
     this->argv.push_back(this->script.c_str());
@@ -59,7 +59,7 @@ static std::string mkFName(const std::string& ext = "db") {
 }
 #endif
 
-typedef std::array<int, 10> IArr;
+using IArr = std::array<int, 10>;
 DEFINE_STRUCT(
   TestStruct,
   (int, x),
diff --git a/test/Storage.C b/test/Storage.C
index 933dfd0ea..96745a624 100644
--- a/test/Storage.C
+++ b/test/Storage.C
@@ -44,7 +44,7 @@ template <typename T>
 
 static bool fileExists(const char* fileName) {
   FILE* fd = fopen(fileName, "r");
-  if (fd != NULL) {
+  if (fd != nullptr) {
     fclose(fd);
     return true;
   } else {
@@ -98,7 +98,7 @@ TEST(Storage, Create) {
 
     int n = 1020;
     array<int>* vs = f.define<int>("vs", n);
-    EXPECT_TRUE(vs != 0);
+    EXPECT_TRUE(vs != nullptr);
     EXPECT_TRUE(vs->size == 1020);
 
     initSeq(vs, 0, 0, n);
@@ -248,11 +248,11 @@ TEST(Storage, Alignment) {
   std::string fname = mkFName();
   try {
     writer f(fname);
-    short*        s = f.define<short>("s");
+    auto*        s = f.define<short>("s");
     int*          i = f.define<int>("i");
-    double*       d = f.define<double>("d");
+    auto*       d = f.define<double>("d");
     array<int>*   a = f.define<int>("a", 100);
-    fileref<int>* r = f.define<fileref<int>>("r");
+    auto* r = f.define<fileref<int>>("r");
 
     EXPECT_EQ(reinterpret_cast<size_t>(s)%sizeof(short),  size_t(0));
     EXPECT_EQ(reinterpret_cast<size_t>(i)%sizeof(int),    size_t(0));
@@ -562,7 +562,7 @@ DEFINE_VARIANT(
   (just,    std::string)
 );
 
-typedef std::array<std::string,2> FRStrArr;
+using FRStrArr = std::array<std::string, 2>;
 
 DEFINE_STRUCT(
   FRTest,
@@ -583,9 +583,9 @@ TEST(Storage, FRegionCompatibility) {
       FRTest t;
       t.x = static_cast<int>(i);
       t.y = 3.14159*static_cast<double>(i);
-      t.z.push_back("a");
-      t.z.push_back("b");
-      t.z.push_back("c");
+      t.z.emplace_back("a");
+      t.z.emplace_back("b");
+      t.z.emplace_back("c");
       t.u = FRTestFood::HotDog();
       t.v = MStr::just("chicken");
       t.w[0] = "a";
@@ -657,7 +657,7 @@ DEFINE_ENUM(
   (Magenta)
 );
 
-typedef std::vector<std::string> strs;
+using strs = std::vector<std::string>;
 
 DEFINE_STRUCT(
   MyStruct,
@@ -897,8 +897,8 @@ TEST(Storage, FRegionCArrays) {
 
     // verify memcopyable carrays can be accessed by reference
     //   'carray (int*double) 20'
-    typedef std::pair<int,double> IandD;
-    typedef hobbes::carray<IandD, 20> XS;
+    using IandD = std::pair<int, double>;
+    using XS = hobbes::carray<IandD, 20>;
 
     auto& xs = *w.define<XS>("xs");
     for (size_t i = 0; i < 10; ++i) {
@@ -908,10 +908,10 @@ TEST(Storage, FRegionCArrays) {
     
     // verify that non-memcopyable can be written
     //     'carray (int * [char]@? * [int+double]@?) 20'
-    typedef hobbes::variant<int,double> IorD;
-    typedef std::vector<IorD>   IorDs;
-    typedef hobbes::tuple<int, std::string, IorDs> Y;
-    typedef hobbes::carray<Y, 20> YS;
+    using IorD = hobbes::variant<int, double>;
+    using IorDs = std::vector<IorD>;
+    using Y = hobbes::tuple<int, std::string, IorDs>;
+    using YS = hobbes::carray<Y, 20>;
 
     IorDs idi; idi.push_back(IorD(100)); idi.push_back(IorD(3.14159)); idi.push_back(IorD(200));
     IorDs ddi; ddi.push_back(IorD(2.1)); ddi.push_back(IorD(4.2));     ddi.push_back(IorD(29));
@@ -924,7 +924,7 @@ TEST(Storage, FRegionCArrays) {
     // expect to be able to read back the carray data from C++
     hobbes::fregion::reader r(fname);
 
-    auto& rxs = *r.definition<XS>("xs");
+    const auto& rxs = *r.definition<XS>("xs");
     EXPECT_EQ(rxs.size, 10UL);
     for (size_t i = 0; i < rxs.size; ++i) {
       EXPECT_EQ(rxs[i].first, static_cast<int>(i));
@@ -1058,7 +1058,7 @@ TEST(Storage, AvoidTornRead) {
     while (rlog.next());
 
     // if we get here, we are good
-    EXPECT_TRUE(ss.str().size() > 0);
+    EXPECT_TRUE(!ss.str().empty());
 
     unlink(fname.c_str());
   } catch (...) {
diff --git a/test/Structs.C b/test/Structs.C
index e37e65606..14b7b6fc0 100644
--- a/test/Structs.C
+++ b/test/Structs.C
@@ -81,8 +81,8 @@ TEST(Structs, Consts) {
   EXPECT_TRUE(c().compileFn<bool()>("(1,\"jimmy\",13L).1 == \"jimmy\"")());
   EXPECT_TRUE(c().compileFn<bool()>("(if (0 == 0) then (1,2) else (3,4)).0 == 1")());
 
-  typedef std::pair<unsigned char, double> FWeight;
-  typedef array<FWeight>                   FWeights;
+  using FWeight = std::pair<unsigned char, double>;
+  using FWeights = array<FWeight>;
   EXPECT_EQ(c().compileFn<FWeights*()>("[(0XAE, 1.2),(0XBD, 2.4),(0XFF, 5.9)]")()->data[1].second, 2.4);
 }
 
@@ -101,7 +101,7 @@ TEST(Structs, Bindings) {
   EXPECT_TRUE(c().compileFn<bool()>("bob.z == \"Hello!\"")());
   EXPECT_TRUE(c().compileFn<bool()>("bob.w == 'c'")());
 
-  EXPECT_TRUE(c().compileFn<array<char>*()>("show(genstruct)") != 0);
+  EXPECT_TRUE(c().compileFn<array<char>*()>("show(genstruct)") != nullptr);
 }
 
 TEST(Structs, NoDuplicateFieldNames) {
@@ -193,8 +193,8 @@ TEST(Structs, LiftTuple) {
   EXPECT_TRUE(c().compileFn<bool(const hobbes::tuple<short,int,std::string>&)>("p", "p==(42,314159,\"jimmy\")")(p));
 }
 
-typedef variant<unit, AlignA> MaybeAlignA;
-typedef variant<unit, AlignB> MaybeAlignB;
+using MaybeAlignA = variant<unit, AlignA>;
+using MaybeAlignB = variant<unit, AlignB>;
 
 DEFINE_STRUCT(AlignTest,
   (MaybeAlignA, ma),
diff --git a/test/TypeInf.C b/test/TypeInf.C
index a1113c3ab..8829a01dd 100644
--- a/test/TypeInf.C
+++ b/test/TypeInf.C
@@ -1,11 +1,12 @@
 
-#include <hobbes/hobbes.H>
 #include "test.H"
+#include <hobbes/hobbes.H>
+#include <memory>
 
 using namespace hobbes;
 
 TEST(TypeInf, Unification) {
-  MonoTypeUnifier u(TEnvPtr(new TEnv()));
+  MonoTypeUnifier u(std::make_shared<TEnv>());
 
   // test unification and substitution between recursive types
   MonoTypePtr t0(Recursive::make("x", sumtype(primty("unit"), tuplety(list(tvar("a"), tvar("x"))))));
diff --git a/test/Variants.C b/test/Variants.C
index 8e6c3d2d6..5f00e4ad1 100644
--- a/test/Variants.C
+++ b/test/Variants.C
@@ -6,13 +6,13 @@ using namespace hobbes;
 
 extern const char leftLBL[];
 extern const char rightLBL[];
-typedef label<leftLBL, int> leftCtor;
-typedef label<rightLBL, double> rightCtor;
+using leftCtor = label<leftLBL, int>;
+using rightCtor = label<rightLBL, double>;
 const char leftLBL[] = "left";
 const char rightLBL[] = "right";
 
 int intCastVariant(const variant<leftCtor, rightCtor>* bv) {
-  if (const leftCtor* lv = bv->get<leftCtor>()) {
+  if (const auto* lv = bv->get<leftCtor>()) {
     return lv->value;
   } else {
     return static_cast<int>(bv->get<rightCtor>()->value);
@@ -20,7 +20,7 @@ int intCastVariant(const variant<leftCtor, rightCtor>* bv) {
 }
 
 int sumCtorID(const variant<char, unsigned char>* bv) {
-  if (bv->get<char>()) {
+  if (bv->get<char>() != nullptr) {
     return 0;
   } else {
     return 1;
@@ -75,8 +75,8 @@ TEST(Variants, Binding) {
 TEST(Variants, MemoryLayout) {
   typedef unsigned char uuid[16];
 
-  typedef variant<unit, char> MChar;
-  typedef variant<unit, uuid> MUuid;
+  using MChar = variant<unit, char>;
+  using MUuid = variant<unit, uuid>;
 
   EXPECT_EQ(sizeof(MChar), sizeOf(lift<const MChar*>::type(nulltdb)));
   EXPECT_EQ(sizeof(MUuid), sizeOf(lift<const MUuid*>::type(nulltdb)));
@@ -119,7 +119,7 @@ TEST(Variants, WithFunctions) {
   EXPECT_TRUE(c().compileFn<bool()>("either((\\|1=f|.f(1L,0L))(just(if (0 > 0) then llt else lgt)), false, id)")());
 }
 
-typedef variant<unit, std::pair<const char*, size_t>*> BadT;
+using BadT = variant<unit, std::pair<const char *, size_t> *>;
 TEST(Variants, DontLiftInlineRefs) {
   EXPECT_NEQ(show(lift<const BadT*>::type(c())), "(() + (<char> * long))");
 }
diff --git a/test/test.H b/test/test.H
index d2e00de93..b7759f839 100644
--- a/test/test.H
+++ b/test/test.H
@@ -77,7 +77,7 @@ struct Result final {
 
 class TestCoord {
 public:
-  typedef void (*PTEST)();
+  using PTEST = void (*)();
   static TestCoord& instance();
   bool installTest(const std::string& group, const std::string& test, PTEST pf);
   std::set<std::string> testGroupNames() const;
@@ -85,10 +85,10 @@ public:
 
 private:
   std::string toJSON();
-  typedef std::vector<std::pair<std::string, PTEST>> Tests;
-  typedef std::map<std::string, Tests> GroupedTests;
-  typedef std::vector<Result> Results;
-  typedef std::map<std::string, Results> GroupedResults;
+  using Tests = std::vector<std::pair<std::string, PTEST>>;
+  using GroupedTests = std::map<std::string, Tests>;
+  using Results = std::vector<Result>;
+  using GroupedResults = std::map<std::string, Results>;
   GroupedTests tests;
   GroupedResults results;
 };

From b05d3e74469fa48f87590c1554c8ea4b3bdc8dff Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 13 Oct 2021 13:45:39 +0000
Subject: [PATCH 21/40] Revert "move llvm include to end of search path to
 prevent cxxabi.h conflicts (#425)" (#427)

This conflicts llvm headers installed in default include locations

This reverts commit 8a1af17316c3f55272595c41197914ae6fa284e2.
---
 CMakeLists.txt | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 714e13445..10b30a169 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,13 +14,7 @@ find_package(Curses REQUIRED)
 include_directories(${CURSES_INCLUDE_DIRS})
 
 find_package(LLVM REQUIRED CONFIG)
-if (CMAKE_COMPILER_IS_GNUCXX)
-  # if libc++abi is installed, cxxabi.h in llvm path will be used
-  # have to lower llvm include path search order
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -idirafter ${LLVM_INCLUDE_DIRS}")
-else()
-  include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
-endif()
+include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
 
 set(CMAKE_CXX_STANDARD 14)

From f9122b01d849386a7133ac68158b0298d3a49486 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 13 Oct 2021 13:53:37 +0000
Subject: [PATCH 22/40] fix reading before initialization (#428)

* fix reading before initialization

* fix uninitalized elems in std::array as a map key
---
 include/hobbes/cfregion.H | 2 +-
 include/hobbes/fregion.H  | 2 +-
 test/Storage.C            | 6 ++----
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/include/hobbes/cfregion.H b/include/hobbes/cfregion.H
index 8d87f9d50..518ec069e 100644
--- a/include/hobbes/cfregion.H
+++ b/include/hobbes/cfregion.H
@@ -362,7 +362,7 @@ struct crbitstream {
   }
 
   // the current batch and segment we're compressing out of
-  const cbatch*    buffer;
+  const cbatch*    buffer = nullptr;
   const cbatchseg* seg;
 
   // the (read) arithmetic encoder state
diff --git a/include/hobbes/fregion.H b/include/hobbes/fregion.H
index 411d10444..ceddd78b5 100644
--- a/include/hobbes/fregion.H
+++ b/include/hobbes/fregion.H
@@ -2247,7 +2247,7 @@ template <typename T>
     file_watch fwatch;
     size_t     batchSize;
 
-    const uint64_t* headLen;   // the mapped array count
+    const uint64_t* headLen = nullptr;   // the mapped array count
     const uint8_t*  head;      // pointer into mapped array data (advanced as we read)
     size_t          headIndex; // read index into mapped array
 
diff --git a/test/Storage.C b/test/Storage.C
index 96745a624..2c1380686 100644
--- a/test/Storage.C
+++ b/test/Storage.C
@@ -976,8 +976,7 @@ TEST(Storage, KeySeries) {
     writer w(fname);
     keyseries<std::array<char,10>, Quote> ticks(&c(), &w, "ticks", 10000, StoredSeries::Compressed);
 
-    std::array<char,10> bob;
-    strcpy(bob.data(), "bob");
+    std::array<char,10> bob{'b', 'o', 'b', '\0'};
     for (size_t i = 0; i < 20000; ++i) {
       Quote q;
       q.bpx = 3.14159;
@@ -987,8 +986,7 @@ TEST(Storage, KeySeries) {
       ticks.record(bob, q);
     }
 
-    std::array<char,10> jim;
-    strcpy(jim.data(), "jim");
+    std::array<char,10> jim{'j', 'i', 'm', '\0'};
     for (size_t i = 0; i < 20000; ++i) {
       Quote q;
       q.bpx = 4.2;

From a766a8182f8b3cb5ead656ea70858ef1eb20667f Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 14 Oct 2021 17:34:06 +0000
Subject: [PATCH 23/40] fix headers included inside namespace (#429)

---
 include/hobbes/storage.H | 72 +++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 42 deletions(-)

diff --git a/include/hobbes/storage.H b/include/hobbes/storage.H
index 4b619a98f..84864b605 100644
--- a/include/hobbes/storage.H
+++ b/include/hobbes/storage.H
@@ -44,15 +44,6 @@
 
 namespace hobbes { namespace storage { namespace internal {
 
-// a few things have to be OS-specific here
-//  * available waiting strategy in shared memory
-//  * default waiting strategy
-#if defined(__APPLE__) && defined(__MACH__)
-// macOS doesn't support this flag to mmap so we can just 0 it out
-#ifndef MAP_POPULATE
-#define MAP_POPULATE 0
-#endif
-
 namespace spin {
 
 #if defined(CLOCK_REALTIME)
@@ -75,6 +66,26 @@ inline long poll_tickNS() {
 }
 #endif
 
+static inline void wakeN(volatile uint32_t*, int) {
+  // assume the waiter is polling, nothing to do
+}
+
+} // namespace spin
+}}} // namespace hobbes { namespace storage { namespace internal
+
+// a few things have to be OS-specific here
+//  * available waiting strategy in shared memory
+//  * default waiting strategy
+#if defined(__APPLE__) && defined(__MACH__)
+// macOS doesn't support this flag to mmap so we can just 0 it out
+#ifndef MAP_POPULATE
+#define MAP_POPULATE 0
+#endif
+
+namespace hobbes { namespace storage { namespace internal {
+
+namespace spin {
+
 static inline void waitForUpdate(volatile uint32_t* p, int eqV) {
   while (true) {
     for (size_t c = 0; c < 4096; ++c) {
@@ -108,36 +119,21 @@ static inline void waitForUpdate(volatile uint32_t* p, int eqV, size_t timeoutNS
     usleep(500);
   }
 }
-static inline void wakeN(volatile uint32_t* p, int c) {
-  // assume the waiter is polling, nothing to do
-}
 
 } // namespace spin
+
+namespace platform = spin;
+
+}}} // namespace hobbes { namespace storage { namespace internal
+
 #else
+
 #include <linux/futex.h>
 #include <sys/syscall.h>
 
-namespace spin {
+namespace hobbes { namespace storage { namespace internal {
 
-#if defined(CLOCK_REALTIME)
-inline long poll_tickNS() {
-  timespec ts;
-  if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
-    return ts.tv_sec * 1000000000L + ts.tv_nsec;
-  } else {
-    return 0;
-  }
-}
-#else
-inline long poll_tickNS() {
-  struct timeval t;
-  if (gettimeofday(&t, 0) == 0) {
-    return ((t.tv_sec * 1000000) + t.tv_usec) * 1000;
-  } else {
-    return 0;
-  }
-}
-#endif
+namespace spin {
 
 static inline void waitForUpdate(volatile uint32_t* p, int eqV) {
   while (true) {
@@ -170,10 +166,6 @@ static inline void waitForUpdate(volatile uint32_t* p, int eqV, size_t timeoutNS
     }
   }
 }
-static inline void wakeN(volatile uint32_t*, int) {
-  // assume the waiter is polling, nothing to do
-}
-
 } // namespace spin
 
 namespace futex {
@@ -209,15 +201,11 @@ static inline void wakeN(volatile uint32_t* p, int c) {
 }
 
 } // namespace futex
-#endif
 
-#if defined (__APPLE__) && defined (__MACH__)
-namespace platform = spin;
-#else
 namespace platform = futex;
-#endif
 
-}}}
+}}} // namespace hobbes { namespace storage { namespace internal
+#endif
 
 namespace hobbes { namespace storage {
 

From 30b5c3cca16a4e4c3f86e41379e7ca5090636e10 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Sat, 23 Oct 2021 13:43:09 +0000
Subject: [PATCH 24/40] fix resource leaks when child process takes too long to
 sent init signal (#430)

* prepl.H doesn't have self contained header files

* fix resource leaks if child takes too long to load

* fix confirmExit logic

* add callback to caller when killing fails
---
 CMakeLists.txt             |  1 +
 include/hobbes/ipc/prepl.H |  5 ++-
 lib/hobbes/ipc/prepl.C     | 81 +++++++++++++++++++++++++++++++++++++-
 test/Spawn.C               | 60 ++++++++++++++++++++++++++++
 test/mocks/proc.C          | 48 ++++++++++++++++++++++
 5 files changed, 192 insertions(+), 3 deletions(-)
 create mode 100644 test/Spawn.C
 create mode 100644 test/mocks/proc.C

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 10b30a169..2ccc6e7c4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,6 +106,7 @@ add_executable(hog ${hog_files})
 target_link_libraries(hog PRIVATE hobbes)
 
 enable_testing()
+add_executable(mock-proc test/mocks/proc.C)
 add_executable(hobbes-test ${test_files})
 target_link_libraries(hobbes-test PRIVATE hobbes)
 add_test(hobbes-test hobbes-test)
diff --git a/include/hobbes/ipc/prepl.H b/include/hobbes/ipc/prepl.H
index d9085059c..e01ce834c 100644
--- a/include/hobbes/ipc/prepl.H
+++ b/include/hobbes/ipc/prepl.H
@@ -5,6 +5,8 @@
 #ifndef HOBBES_IPC_REPL_HPP_INCLUDED
 #define HOBBES_IPC_REPL_HPP_INCLUDED
 
+#include "hobbes/lang/type.H"
+
 #include <string>
 #include <unistd.h>
 
@@ -19,7 +21,8 @@ struct proc {
   int         read_fd;  // read from this to get remote proc responses
 };
 
-void spawn(const std::string&, proc*);
+using FailToKillCallback = std::function<void(pid_t, const std::string&)>;
+void spawn(const std::string&, proc*, const FailToKillCallback& fn={});
 void procSearch(proc*, const std::string&, const std::string&);
 void procDefine(proc*, const std::string&, const std::string&);
 void procEval(proc*, const std::string&);
diff --git a/lib/hobbes/ipc/prepl.C b/lib/hobbes/ipc/prepl.C
index 99e6c732b..22969993c 100644
--- a/lib/hobbes/ipc/prepl.C
+++ b/lib/hobbes/ipc/prepl.C
@@ -6,12 +6,85 @@
 #include <hobbes/util/codec.H>
 #include <hobbes/util/os.H>
 #include <sstream>
+#include <string>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+namespace {
+bool doesDirExist(const std::string &name) {
+  struct stat sb {};
+  return stat(name.c_str(), &sb) == 0;
+}
+
+// if "HOBBES_LOADING_TIMEOUT" is undefined or without a valid timeout value
+// def will be returned
+// "HOBBES_LOADING_TIMEOUT" is in seconds
+int getLoadingTimeoutInSecs(int def) {
+  const auto ts = hobbes::str::env("HOBBES_LOADING_TIMEOUT_IN_SECS");
+  if (ts.empty()) {
+    return def;
+  }
+  try {
+    std::size_t pos{};
+    const auto t = std::stoi(ts, &pos);
+    return (pos != ts.size() || t <= 0) ? def : t;
+  } catch (const std::exception &) {
+    return def;
+  }
+}
+
+struct TermResult {
+  std::string reason{};
+  bool ok = false;
+
+  static const TermResult OK;
+};
+
+const TermResult TermResult::OK = {.ok = true};
+
+TermResult killAndWait(pid_t cpid) {
+  const auto killFn = [cpid]() -> TermResult {
+    if (kill(cpid, SIGTERM) != 0) {
+      const auto e = errno;
+      return {.reason = "killing process failed with an error " +
+                        std::string(std::strerror(e))};
+    }
+    return TermResult::OK;
+  };
+
+  const auto waitFn = [cpid]() -> TermResult {
+    if (waitpid(cpid, nullptr, 0) == -1) {
+      const auto e = errno;
+      return {.reason = "waiting process to exit failed with error " +
+                        std::string(std::strerror(e))};
+    }
+    return TermResult::OK;
+  };
+
+  const auto hasProcessExited = [cpid]() -> TermResult {
+    if (doesDirExist("/proc/" + std::to_string(cpid))) {
+      return {.reason = "process remains"};
+    }
+    return TermResult::OK;
+  };
+
+  TermResult r = killFn();
+  if (!r.ok) {
+    return hasProcessExited().ok ? TermResult::OK : r;
+  }
+
+  r = waitFn();
+  if (!r.ok) {
+    return hasProcessExited().ok ? TermResult::OK : r;
+  }
+
+  return hasProcessExited();
+}
+} // namespace
+
 namespace hobbes {
 
 void execProcess(const std::string& cmd) {
@@ -28,7 +101,7 @@ void execProcess(const std::string& cmd) {
   execv(args[0].c_str(), const_cast<char* const*>(&argv[0]));
 }
 
-void spawn(const std::string& cmd, proc* p) {
+void spawn(const std::string& cmd, proc* p, const FailToKillCallback& fn) {
   // launch the process -- set up pipes for communication
   int p2c[2] = {0, 0};
   int c2p[2] = {0, 0};
@@ -74,7 +147,7 @@ void spawn(const std::string& cmd, proc* p) {
 
       struct timeval tmout;
       memset(&tmout, 0, sizeof(tmout));
-      tmout.tv_sec = 30 * 60;
+      tmout.tv_sec = getLoadingTimeoutInSecs(1800);
 
       select(FD_SETSIZE, &fds, nullptr, nullptr, &tmout);
 
@@ -98,6 +171,10 @@ void spawn(const std::string& cmd, proc* p) {
           throw std::runtime_error("Unable to launch process: " + cmd + " (invalid init response), with output:\n" + ss.str());
         }
       } else {
+        const TermResult r = killAndWait(cpid);
+        if (!r.ok && fn) {
+          fn(cpid, r.reason);
+        }
         throw std::runtime_error("Unable to launch process: " + cmd + " (timed out waiting for init signal)");
       }
 
diff --git a/test/Spawn.C b/test/Spawn.C
new file mode 100644
index 000000000..3fe1e93bc
--- /dev/null
+++ b/test/Spawn.C
@@ -0,0 +1,60 @@
+#include <sys/wait.h>
+#include <sys/stat.h>
+
+#include <csignal>
+
+#include <hobbes/ipc/prepl.H>
+
+#include "test.H"
+
+namespace {
+bool exists(const std::string &filename) {
+  struct stat sb {};
+  return stat(filename.c_str(), &sb) == 0;
+}
+
+void startChild(int t, hobbes::proc &p) {
+  execPath([&](const std::string &ep) {
+    const auto execName = [&] {
+      auto name = ep + "/mock-proc";
+      if (exists(name)) {
+        return name;
+      }
+      return ep + "/mock-proc-g";
+    }();
+
+    spawn(execName + " " + std::to_string(t), &p);
+  });
+}
+
+bool hasProcessExited(pid_t pid) {
+  const std::string procDir = "/proc/" + std::to_string(pid);
+  return !exists(procDir);
+}
+
+bool msgInException(const std::exception &e, const std::string &msg) {
+  return std::string(e.what()).find(msg) != std::string::npos;
+}
+
+const char *const KEY = "HOBBES_LOADING_TIMEOUT_IN_SECS";
+} // namespace
+
+TEST(Spawn, TimeoutKill) {
+  hobbes::proc p;
+  hobbes::str::env(KEY, "1"); // this may affect other tests' behavior
+  bool exp = false;
+  try {
+    startChild(2, p);
+  } catch (const std::runtime_error &e) {
+    exp = true;
+    EXPECT_TRUE(msgInException(e, "timed out"));
+  }
+  EXPECT_TRUE(exp);
+  EXPECT_TRUE(hasProcessExited(p.pid));
+}
+
+TEST(Spawn, Normal) {
+  hobbes::proc p;
+  unsetenv(KEY);
+  startChild(2, p); // should not throw any exceptions
+}
diff --git a/test/mocks/proc.C b/test/mocks/proc.C
new file mode 100644
index 000000000..973544681
--- /dev/null
+++ b/test/mocks/proc.C
@@ -0,0 +1,48 @@
+#include <csignal>
+#include <cstdlib>
+#include <iostream>
+#include <unistd.h>
+
+namespace {
+struct Options {
+  int timeout = -1;
+  bool valid = false;
+};
+
+Options getOptions(int argc, char **argv) {
+  if (argc != 2) {
+    return {};
+  }
+  std::size_t pos = 0;
+  const auto g = std::string(argv[1]);
+  const auto t = std::stoi(g, &pos);
+  if (pos != g.size() || t <= 0) {
+    return {};
+  }
+  return {.timeout = t, .valid = true};
+}
+
+extern "C" [[noreturn]] void exitApp(int /* sig */) {
+  std::_Exit(EXIT_SUCCESS);
+}
+} // namespace
+
+// argv[1] is the seconds before process exists
+int main(int argc, char **argv) {
+  const auto o = getOptions(argc, argv);
+  if (!o.valid) {
+    return EXIT_FAILURE;
+  }
+
+  std::signal(SIGTERM, exitApp);
+
+  for (int i = 0; i < o.timeout; ++i) {
+    sleep(1);
+  }
+
+  const int success = 1;
+  const auto rc = write(STDOUT_FILENO, &success, sizeof(success));
+  if (rc == -1) {
+    return EXIT_FAILURE;
+  }
+}

From 31067c7e4f3a2245aa3156c19e538cab1bf77af1 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Tue, 26 Oct 2021 16:32:17 +0000
Subject: [PATCH 25/40] fix a race condition in map[] for new element (#432)

---
 include/hobbes/hobbes.H | 6 ------
 lib/hobbes/eval/jitcc.C | 7 ++++---
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/include/hobbes/hobbes.H b/include/hobbes/hobbes.H
index 6899be9b6..28877000a 100644
--- a/include/hobbes/hobbes.H
+++ b/include/hobbes/hobbes.H
@@ -14,15 +14,9 @@
 
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/StringMap.h>
-#include <llvm/Support/FormatVariadic.h>
 
 namespace hobbes {
 
-LLVM_NODISCARD inline std::string createUniqueName(llvm::StringRef prefix) {
-  static llvm::StringMap<std::atomic_int> m;
-  return llvm::formatv("{0}{1}", prefix, llvm::to_string(m[prefix]++));
-}
-
 // type aliases for common types
 DEFINE_TYPE_ALIAS_AS(timespanT, timespan, int64_t);
 
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index e9eb4f416..2a28bd53e 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -654,10 +654,11 @@ llvm::IRBuilder<>* jitcc::builder() const {
 }
 
 #if LLVM_VERSION_MAJOR >= 11
-llvm::Module* jitcc::module() {
+llvm::Module *jitcc::module() {
   if (this->currentModule == nullptr) {
-    this->currentModule = withContext([](llvm::LLVMContext& c) {
-      return std::make_unique<llvm::Module>(createUniqueName("jitModule"), c);
+    this->currentModule = withContext([](llvm::LLVMContext &c) {
+      static std::atomic_int mc{};
+      return std::make_unique<llvm::Module>("jitModule" + std::to_string(mc++), c);
     });
   }
   return this->currentModule.get();

From 7a4ab88e92e8215117d3eab338b329db7e5e9d15 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 27 Oct 2021 21:49:40 +0000
Subject: [PATCH 26/40] waitpid might block forever (#433)

---
 lib/hobbes/ipc/prepl.C | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/lib/hobbes/ipc/prepl.C b/lib/hobbes/ipc/prepl.C
index 22969993c..3ef762ebe 100644
--- a/lib/hobbes/ipc/prepl.C
+++ b/lib/hobbes/ipc/prepl.C
@@ -55,33 +55,32 @@ TermResult killAndWait(pid_t cpid) {
     return TermResult::OK;
   };
 
-  const auto waitFn = [cpid]() -> TermResult {
-    if (waitpid(cpid, nullptr, 0) == -1) {
-      const auto e = errno;
-      return {.reason = "waiting process to exit failed with error " +
-                        std::string(std::strerror(e))};
-    }
-    return TermResult::OK;
+  const auto waitFn = [cpid]() -> bool {
+    return cpid == waitpid(cpid, nullptr, WNOHANG);
   };
 
-  const auto hasProcessExited = [cpid]() -> TermResult {
-    if (doesDirExist("/proc/" + std::to_string(cpid))) {
-      return {.reason = "process remains"};
-    }
-    return TermResult::OK;
+  const auto hasProcessExited = [cpid]() -> bool {
+    return !doesDirExist("/proc/" + std::to_string(cpid));
   };
 
   TermResult r = killFn();
   if (!r.ok) {
-    return hasProcessExited().ok ? TermResult::OK : r;
+    return hasProcessExited() ? TermResult::OK : r;
   }
 
-  r = waitFn();
-  if (!r.ok) {
-    return hasProcessExited().ok ? TermResult::OK : r;
+  // wait and retry, 10 secs
+  for (int i = 0; i < 10; ++i) {
+    waitFn();
+    if (hasProcessExited()) {
+      return TermResult::OK;
+    }
+    sleep(1);
   }
 
-  return hasProcessExited();
+  if (hasProcessExited()) {
+    return TermResult::OK;
+  }
+  return {.reason = "process " + std::to_string(cpid) + " is still alive"};
 }
 } // namespace
 

From 031331833ab2e069960e431e8cb5269c1938a346 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Tue, 18 Jan 2022 16:56:24 +0800
Subject: [PATCH 27/40] add readInt128 (#434)

* add hobbes func readInt128

* fix an overflow

* add HOBBES_ prefix to macros
---
 include/hobbes/util/stream.H | 38 ++++++++++++++++++++++++++++++------
 lib/hobbes/eval/funcdefs.C   | 19 ++++++++++++++++++
 scripts/hobbes.vim           |  2 +-
 test/Prelude.C               | 14 +++++++++++++
 4 files changed, 66 insertions(+), 7 deletions(-)

diff --git a/include/hobbes/util/stream.H b/include/hobbes/util/stream.H
index c1679be50..9227dedf4 100644
--- a/include/hobbes/util/stream.H
+++ b/include/hobbes/util/stream.H
@@ -72,13 +72,19 @@ template < typename Char = char, typename Traits = std::char_traits<Char> >
 
 }}
 
+#define HOBBES_ABS_INT128_POS ((static_cast<unsigned __int128>(1) << 127) - 1)
+#define HOBBES_ABS_INT128_NEG ( static_cast<unsigned __int128>(1) << 127)
+#define HOBBES_INT128_MIN     (static_cast<__int128>(static_cast<unsigned __int128>(1) << 127))
+
 // show int128 values (should be disabled when/if compiler support for these types is standardized)
 inline void printInt128(std::ostream& out, const __int128& sx) {
   if (sx == 0) {
     out << "0";
+  } else if (sx == HOBBES_INT128_MIN) {
+    out << "-170141183460469231731687303715884105728";
   } else {
     __int128 x = (sx < 0) ? -sx : sx;
-    
+
     char buf[128];
     memset(buf, 0, sizeof(buf));
     char* d = buf;
@@ -102,27 +108,47 @@ inline std::ostream& operator<<(std::ostream& out, const __int128& sx) {
   return out;
 }
 
+// s must not have trailing 'H'
 inline bool readInt128(const std::string& s, __int128* x) {
   if (s.empty()) return false;
 
   bool neg = s[0] == '-';
   std::string n = neg ? s.substr(1) : s;
 
-  *x = 0;
-  __int128 a = 1;
+  unsigned __int128 y = 0U;
+  unsigned __int128 a = 1U;
   for (size_t i = n.size(); i > 0; --i) {
     char d = n[i-1];
 
     if (d >= '0' && d <= '9') {
-      *x += a * (d-'0');
-      a  *= 10;
+      y += a * static_cast<unsigned __int128>(d-'0');
+      if (neg && y > HOBBES_ABS_INT128_NEG) {
+        return false;
+      }
+      if ((!neg) && y > HOBBES_ABS_INT128_POS) {
+        return false;
+      }
+      a *= 10U;
     } else {
       return false;
     }
   }
-  if (neg) *x *= -1;
+
+  if (neg) {
+    if (y == HOBBES_ABS_INT128_NEG) {
+      *x = HOBBES_INT128_MIN;
+    } else {
+      *x = -1 * static_cast<__int128>(y);
+    }
+  } else {
+    *x = static_cast<__int128>(y);
+  }
   return true;
 }
 
+#undef HOBBES_ABS_INT128_POS
+#undef HOBBES_ABS_INT128_NEG
+#undef HOBBES_INT128_MIN
+
 #endif
 
diff --git a/lib/hobbes/eval/funcdefs.C b/lib/hobbes/eval/funcdefs.C
index f7621cc69..cc859cd15 100644
--- a/lib/hobbes/eval/funcdefs.C
+++ b/lib/hobbes/eval/funcdefs.C
@@ -248,6 +248,20 @@ template <typename T>
     }
   }
 
+template <>
+  const typename maybe<int128_t>::ty* readISV<int128_t>(const array<char>* x) {
+    const std::string numbers = [x] {
+      const int suffix_digit = *(x->data + x->size - 1) == 'H' ? 1 : 0;
+      return std::string(x->data, x->data + x->size - suffix_digit);
+    }();
+    int128_t r;
+    if (readInt128(numbers, &r)) {
+      return maybe<int128_t>::just(r);
+    } else {
+      return maybe<int128_t>::nothing();
+    }
+  }
+
 const array<char>* showShort(short s) {
   return makeString(str::from(s) + "S");
 }
@@ -274,6 +288,10 @@ const array<char>* showInt128(int128_t x) {
   return makeString(ss.str());
 }
 
+const maybe<int128_t>::ty* readInt128(const array<char>* x) {
+  return readISV<int128_t>(x);
+}
+
 const maybe<long>::ty* readLong(const array<char>* x) {
   return readISV<long>(x);
 }
@@ -682,6 +700,7 @@ void initStdFuncDefs(cc& ctx) {
   ctx.bind("readShort",  &readShort);
   ctx.bind("readInt",    &readInt);
   ctx.bind("readLong",   &readLong);
+  ctx.bind("readInt128", static_cast<const maybe<int128_t>::ty*(*)(const array<char>*)>(&readInt128));
   ctx.bind("readFloat",  &readFloat);
   ctx.bind("readDouble", &readDouble);
 
diff --git a/scripts/hobbes.vim b/scripts/hobbes.vim
index d91b7252b..d37b85cf0 100644
--- a/scripts/hobbes.vim
+++ b/scripts/hobbes.vim
@@ -6,7 +6,7 @@ endif
 
 " keywords
 syn keyword hKeywords true false
-syn keyword hKeywords bool byte char short int long float double time datetime timespan
+syn keyword hKeywords bool byte char short int long int128 float double time datetime timespan
 syn keyword hKeywords option module import where exists
 syn keyword hKeywords data type class instance
 syn keyword hKeywords pack unpack
diff --git a/test/Prelude.C b/test/Prelude.C
index c92451970..1259e7291 100644
--- a/test/Prelude.C
+++ b/test/Prelude.C
@@ -77,7 +77,21 @@ TEST(Prelude, SScan) {
 
 TEST(Prelude, Int128) {
   EXPECT_EQ(c().compileFn<int128_t()>("40H + 2S")(), 42);
+  EXPECT_EQ(c().compileFn<int128_t()>("40H - 42S")(), -2);
   EXPECT_TRUE((c().compileFn<bool(int128_t)>("x", "x==42")(42)));
   EXPECT_EQ(hobbes::makeStdString(c().compileFn<const hobbes::array<char>*()>("show(42H)")()), "42");
+
+  // INT128_MAX w/  'H'
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"170141183460469231731687303715884105727H\"))")())), "|1=170141183460469231731687303715884105727|");
+  // INT128_MAX w/o 'H'
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"170141183460469231731687303715884105727\"))")())), "|1=170141183460469231731687303715884105727|");
+  // INT128_MIN w/  'H'
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"-170141183460469231731687303715884105728H\"))")())), "|1=-170141183460469231731687303715884105728|");
+  // INT128_MIN w/o 'H'
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"-170141183460469231731687303715884105728\"))")())), "|1=-170141183460469231731687303715884105728|");
+  // underflow
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"-170141183460469231731687303715884105729\"))")())), "|0|");
+  // overflow
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"170141183460469231731687303715884105728\"))")())), "|0|");
 }
 

From d973b454a7d56fd1e37352741492903434fc42ec Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 23 Feb 2022 16:24:17 +0800
Subject: [PATCH 28/40] Add support to use predicate to stop event loop (#435)

---
 include/hobbes/events/events.H |  9 ++++---
 lib/hobbes/events/events.C     | 34 ++++++++++++------------
 test/Net.C                     | 48 ++++++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 19 deletions(-)

diff --git a/include/hobbes/events/events.H b/include/hobbes/events/events.H
index 4272248ac..3a8c0d636 100644
--- a/include/hobbes/events/events.H
+++ b/include/hobbes/events/events.H
@@ -23,11 +23,14 @@ void unregisterEventHandler(int fd);
 void registerInterruptHandler(const std::function<void()>& fn);
 
 // run a single-step or indefinite event loop
-bool stepEventLoop(int timeoutMS = -1);
-void runEventLoop();
+bool stepEventLoop(int timeoutMS = -1, const std::function<bool()>& stopFn = [] { return false; });
+// if stopFn is user defined, a repeatable timer *MUST* be added to trigger the check on stopFn()
+// hobbes::addTimer([] { return true; /* repeatable */}, myTimeout);
+// hobbes::runEventLoop(myStopFn);
+void runEventLoop(const std::function<bool()>& stopFn = [] { return false; });
 
 // run the event loop for some number of microseconds
-void runEventLoop(int microsecondDuration);
+void runEventLoop(int microsecondDuration, const std::function<bool()>& stopFn = [] { return false; });
 
 }
 
diff --git a/lib/hobbes/events/events.C b/lib/hobbes/events/events.C
index 2c72001af..4faa80b71 100644
--- a/lib/hobbes/events/events.C
+++ b/lib/hobbes/events/events.C
@@ -91,8 +91,8 @@ void registerInterruptHandler(const std::function<void()>& fn) {
   (*epClosures)[-1] = c;
 }
 
-bool stepEventLoop(int timeoutMS) {
-  while (true) {
+bool stepEventLoop(int timeoutMS, const std::function<bool()>& stopFn) {
+  while (!stopFn()) {
     if (!timers.empty()) {
       auto next = timers.top().callTime;
       auto timeUntilNext = next - std::chrono::high_resolution_clock::now();
@@ -125,30 +125,31 @@ bool stepEventLoop(int timeoutMS) {
       while(!timers.empty() && timers.top().callTime <= now) {
         auto t = timers.top();
         timers.pop();
-        
+
         bool repeat = t.func();
         resetMemoryPool();
-        
+
         if(repeat) {
           timer newT;
           newT.callTime = std::chrono::high_resolution_clock::now() + t.interval,
           newT.func = t.func,
           newT.interval = t.interval,
-          
+
           newTimers.push_back(newT);
         }
       }
-      
+
       for (auto& timer : newTimers) {
         timers.push(timer);
       }
     }
     return status;
   }
+  return false;
 }
 
-void runEventLoop() {
-  while (stepEventLoop());
+void runEventLoop(const std::function<bool()>& stopFn) {
+  while (stepEventLoop(-1, stopFn));
 }
 
 void addTimer(timerfunc f, int millisecInterval) {
@@ -160,7 +161,7 @@ void addTimer(timerfunc f, int millisecInterval) {
   timers.push(t);
 }
 
-void runEventLoop(int microsecondDuration) {
+void runEventLoop(int microsecondDuration, const std::function<bool()>& stopFn) {
   long t  = hobbes::time();
   long dt = static_cast<long>(microsecondDuration) * 1000L;
   long tf = t + dt;
@@ -180,7 +181,7 @@ void runEventLoop(int microsecondDuration) {
       }
     }
     t = hobbes::time();
-  } while (t < tf);
+  } while (t < tf && !stopFn());
 }
 
 #elif defined(BUILD_OSX)
@@ -236,8 +237,8 @@ void registerInterruptHandler(const std::function<void()>& fn) {
   (*kqClosures)[-1] = c;
 }
 
-bool stepEventLoop(int timeoutMS) {
-  while (true) {
+bool stepEventLoop(int timeoutMS, const std::function<bool()>& stopFn) {
+  while (!stopFn()) {
     struct timespec timeout;
     timeout.tv_sec  = timeoutMS / 1000;
     timeout.tv_nsec = (timeoutMS % 1000) * 1000000UL;
@@ -260,17 +261,18 @@ bool stepEventLoop(int timeoutMS) {
       }
     }
   }
+  return false;
 }
 
-void runEventLoop() {
-  while (stepEventLoop());
+void runEventLoop(const std::function<bool()>& stopFn) {
+  while (stepEventLoop(-1, stopFn));
 }
 
 void addTimer(timerfunc f, int millisecInterval) {
   throw std::runtime_error("addTimer nyi for OSX");
 }
 
-void runEventLoop(int microsecondDuration) {
+void runEventLoop(int microsecondDuration, const std::function<bool()>& stopFn) {
   long t  = hobbes::time();
   long dt = ((long)microsecondDuration) * 1000L;
   long tf = t + dt;
@@ -294,7 +296,7 @@ void runEventLoop(int microsecondDuration) {
       }
     }
     t = hobbes::time();
-  } while (t < tf);
+  } while (t < tf && !stopFn());
 }
 
 #endif
diff --git a/test/Net.C b/test/Net.C
index 126121041..a07d693cb 100644
--- a/test/Net.C
+++ b/test/Net.C
@@ -438,3 +438,51 @@ TEST(Net, asyncClientAPIWithUnConfiguredHostName) {
   }
   EXPECT_EQ(c.pendingRequests(), size_t(0));
 }
+
+namespace {
+template <typename EventLoopFn, typename ExpectPred>
+void eventLoopShutdownWithStopFImpl(EventLoopFn elFn, ExpectPred expectPred) {
+  struct {
+    std::atomic_bool flag{false};
+  } stopper;
+  std::function<bool()> f = [&stopper]() -> bool { return stopper.flag; };
+
+  using namespace std::chrono_literals;
+  using Clock = std::chrono::steady_clock;
+
+  auto t = std::thread([&stopper] {
+    std::this_thread::sleep_for(2s);
+    stopper.flag = true;
+  });
+
+  const auto startTime = Clock::now();
+  elFn(f);
+  const auto endTime = Clock::now();
+  const auto millisecs =
+      std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
+          .count();
+  t.join();
+  EXPECT_TRUE(expectPred(millisecs));
+}
+} // namespace
+
+TEST(Net, eventLoopShutdownWithStopF) {
+  // eventLoopShutdownWithStopFImpl setup a stopFn returns true after 2000 ms
+
+  // a repeatable timer triggers on every 700ms is added to check stopFn periodically
+  // event loop should stop after ~2000 ms
+  eventLoopShutdownWithStopFImpl(
+      [](const std::function<bool()> &stopFn) {
+        hobbes::addTimer([] { return true; }, 700);
+        hobbes::runEventLoop(stopFn);
+      },
+      [](auto millisecs) { return millisecs > 1'500 && millisecs < 2'500; });
+
+  // a timeout at 500ms is set for this "one shot" event loop
+  // event loop should stop after ~500 ms
+  eventLoopShutdownWithStopFImpl(
+      [](const std::function<bool()> &stopFn) {
+        hobbes::runEventLoop(500'000, stopFn);
+      },
+      [](auto millisecs) { return millisecs < 1'000; });
+}

From bb19e9245a7c399deb6e76fb3c02911768b6c19c Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Tue, 22 Mar 2022 00:18:50 +0800
Subject: [PATCH 29/40] add stop function to interrupt compilation

---
 include/hobbes/eval/cmodule.H |  6 +++++-
 lib/hobbes/eval/cmodule.C     | 14 +++++++++++++-
 test/Spawn.C                  | 11 +++--------
 3 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/include/hobbes/eval/cmodule.H b/include/hobbes/eval/cmodule.H
index 037d4e2c0..b79a024b5 100644
--- a/include/hobbes/eval/cmodule.H
+++ b/include/hobbes/eval/cmodule.H
@@ -5,6 +5,8 @@
 #include <hobbes/eval/func.H>
 #include <hobbes/lang/module.H>
 
+#include <functional>
+
 namespace hobbes {
 
 class cc;
@@ -17,7 +19,9 @@ void pushModuleDir(const std::string&);
 void popModuleDir();
 
 // compile a whole module into a cc context
-void compile(cc*, const ModulePtr& m);
+// once stopFn() is true, the compilation stops prematurely,
+//   cc is not valid anymore, all you can do is to destroy it
+void compile(cc*, const ModulePtr& m, std::function<bool()> stopFn=[] { return false; });
 
 // set language options, display language options
 using OptDescs = std::map<std::string, std::string>;
diff --git a/lib/hobbes/eval/cmodule.C b/lib/hobbes/eval/cmodule.C
index 17e99cb80..998b07605 100644
--- a/lib/hobbes/eval/cmodule.C
+++ b/lib/hobbes/eval/cmodule.C
@@ -794,8 +794,11 @@ void compile(const ModulePtr &, cc *, const MSafePragmaDef *mpd) {
 // for now, just treat each definition independently and stick it in the input
 // environment
 //   (this disallows things like mutual recursion)
-void compile(cc *e, const ModulePtr &m) {
+void compile(cc *e, const ModulePtr &m, std::function<bool()> stopFn) {
   for (const auto& tmd : m->definitions()) {
+    if (stopFn()) {
+      return;
+    }
     auto md = applyTypeDefns(m, e, tmd);
 
     if (const MImport *imp = is<MImport>(md)) {
@@ -821,6 +824,9 @@ void compile(cc *e, const ModulePtr &m) {
 
   // compile unsafe pragma
   for (const auto& tmd : m->definitions()) {
+    if (stopFn()) {
+      return;
+    }
     if (const MUnsafePragmaDef *vpd = is<MUnsafePragmaDef>(tmd)) {
       compile(m, e, vpd);
     }
@@ -828,6 +834,9 @@ void compile(cc *e, const ModulePtr &m) {
 
   // compile safe pragma
   for (const auto& tmd : m->definitions()) {
+    if (stopFn()) {
+      return;
+    }
     if (const MSafePragmaDef *vpd = is<MSafePragmaDef>(tmd)) {
       compile(m, e, vpd);
     }
@@ -835,6 +844,9 @@ void compile(cc *e, const ModulePtr &m) {
 
   // generate unsafe transitive closure
   for (const auto& tmd : m->definitions()) {
+    if (stopFn()) {
+      return;
+    }
     if (const MVarDef *vd = is<MVarDef>(tmd)) {
       switchOf(vd->varExpr(), buildTransitiveUnsafePragmaClosure(*vd));
     }
diff --git a/test/Spawn.C b/test/Spawn.C
index 3fe1e93bc..0192c7a51 100644
--- a/test/Spawn.C
+++ b/test/Spawn.C
@@ -27,11 +27,6 @@ void startChild(int t, hobbes::proc &p) {
   });
 }
 
-bool hasProcessExited(pid_t pid) {
-  const std::string procDir = "/proc/" + std::to_string(pid);
-  return !exists(procDir);
-}
-
 bool msgInException(const std::exception &e, const std::string &msg) {
   return std::string(e.what()).find(msg) != std::string::npos;
 }
@@ -40,7 +35,7 @@ const char *const KEY = "HOBBES_LOADING_TIMEOUT_IN_SECS";
 } // namespace
 
 TEST(Spawn, TimeoutKill) {
-  hobbes::proc p;
+  hobbes::proc p{};
   hobbes::str::env(KEY, "1"); // this may affect other tests' behavior
   bool exp = false;
   try {
@@ -50,11 +45,11 @@ TEST(Spawn, TimeoutKill) {
     EXPECT_TRUE(msgInException(e, "timed out"));
   }
   EXPECT_TRUE(exp);
-  EXPECT_TRUE(hasProcessExited(p.pid));
+  //p is invalid when spawn goes wrong, cannot be checked against
 }
 
 TEST(Spawn, Normal) {
-  hobbes::proc p;
+  hobbes::proc p{};
   unsetenv(KEY);
   startChild(2, p); // should not throw any exceptions
 }

From d46b38177f5d6bda4027bc3d98afe6c97399c8fd Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Fri, 22 Apr 2022 11:58:56 +0800
Subject: [PATCH 30/40] data race on wrongMatches

---
 test/Matching.C | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/Matching.C b/test/Matching.C
index b5205b71e..2c69623db 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -387,7 +387,7 @@ TEST(Matching, noRaceInterpMatch) {
                                                         "| \"foo\" -> 0\n"
                                                         "| \"bar\" -> 1\n"
                                                         "| _       -> 2");
-  size_t wrongMatches = 0;
+  std::atomic_size_t wrongMatches{0U};
   std::vector<std::thread> ps;
   for (size_t p = 0; p < 10; ++p) {
     ps.emplace_back([&]() {
@@ -407,6 +407,6 @@ TEST(Matching, noRaceInterpMatch) {
   for (auto &p : ps) {
     p.join();
   }
-  EXPECT_EQ(wrongMatches, size_t(0));
+  EXPECT_EQ(wrongMatches.load(), size_t(0));
   c().buildInterpretedMatches(false);
 }

From a2c0d38d8ef5767657d4315b568b70bd5be06cfd Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 6 Jul 2022 23:01:05 +0800
Subject: [PATCH 31/40] hobbes::variant tag become invalid causes buffer
 overrun during destruction calls

---
 include/hobbes/net.H | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/hobbes/net.H b/include/hobbes/net.H
index 6b7a72a9e..de7918542 100644
--- a/include/hobbes/net.H
+++ b/include/hobbes/net.H
@@ -807,10 +807,10 @@ template <typename ... Fs>
     }
     static bool accum(int s, async_read_state* o, tuple<Fs...>* x) {
       if (o->template apply<bool, tupAsyncAcc, tuple<Fs...>, int, tuple<Fs...>*>(s, x)) {
-        ++o->unsafeTag();
-        if (o->unsafeTag() == sizeof...(Fs)) {
+        if (o->unsafeTag() == sizeof...(Fs)-1) {
           return true;
         } else {
+          ++o->unsafeTag();
           variantApp<void, tupAsyncInit, void, tuple<Fs...>, void*>::apply(o->unsafeTag(), o->unsafePayload(), o->unsafePayload());
           return false;
         }
@@ -1013,6 +1013,7 @@ template <typename R, typename ... Args>
         this->ks.front()(this->r);
         this->ks.pop();
         this->r = R();
+        this->pr = async_read_state();
         io<R>::prepare(&this->pr);
         return true;
       } else {

From 001d14ed02c5c3a44aa9008f09671a55a056dbd5 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Mon, 31 Oct 2022 11:57:57 +0800
Subject: [PATCH 32/40] update github action to silient node.js 12 deprecation
 warnings

---
 .github/workflows/build.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c9dfc1de8..acb5e0441 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,11 +8,11 @@ jobs:
         os: [ubuntu-20.04]
         clang: [8]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
             # Nix Flakes doesn't work on shallow clones
             fetch-depth: 0
-      - uses: cachix/install-nix-action@v12
+      - uses: cachix/install-nix-action@v18
         with:
           install_url: https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20201221_9fab14a/install
           extra_nix_config: |
@@ -37,11 +37,11 @@ jobs:
         os: [ubuntu-20.04]
         clang: [6, 8, 10, 11, 12]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
             # Nix Flakes doesn't work on shallow clones
             fetch-depth: 0
-      - uses: cachix/install-nix-action@v12
+      - uses: cachix/install-nix-action@v18
         with:
           install_url: https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20201221_9fab14a/install
           extra_nix_config: |
@@ -67,11 +67,11 @@ jobs:
         gcc: [10]
         llvm: [6, 8, 10, 11, 12]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
             # Nix Flakes doesn't work on shallow clones
             fetch-depth: 0
-      - uses: cachix/install-nix-action@v12
+      - uses: cachix/install-nix-action@v18
         with:
           install_url: https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20201221_9fab14a/install
           extra_nix_config: |

From 9a4efd0816b5cc2ab0d7a8dc8ad00b38357d2962 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Thu, 27 Oct 2022 18:12:55 +0800
Subject: [PATCH 33/40] stop hobbes from generating large IR functions

---
 include/hobbes/eval/jitcc.H |  4 ----
 include/hobbes/util/llvm.H  | 41 ++++++++++++++++++++++++++++++++++++-
 lib/hobbes/eval/jitcc.C     | 15 ++------------
 lib/hobbes/eval/orcjitcc.C  |  5 ++---
 lib/hobbes/lang/pat/dfa.C   | 17 ++++++++++++++-
 5 files changed, 60 insertions(+), 22 deletions(-)

diff --git a/include/hobbes/eval/jitcc.H b/include/hobbes/eval/jitcc.H
index db1cedd1f..53e5527bf 100644
--- a/include/hobbes/eval/jitcc.H
+++ b/include/hobbes/eval/jitcc.H
@@ -152,17 +152,13 @@ private:
 
 #else
 #if LLVM_VERSION_MINOR == 6 || LLVM_VERSION_MINOR == 7 || LLVM_VERSION_MINOR == 8 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR <= 12
-  llvm::legacy::PassManager* mpm;
-
   // the set of allocated execution engines (each will own a finalized module from the set of modules)
   typedef std::vector<llvm::ExecutionEngine*> ExecutionEngines;
   ExecutionEngines eengines;
 #elif LLVM_VERSION_MINOR == 3
-  llvm::PassManager*         mpm;
   llvm::ExecutionEngine*     eengine;
   llvm::FunctionPassManager* fpm;
 #elif LLVM_VERSION_MINOR == 5
-  llvm::legacy::PassManager*         mpm;
   llvm::ExecutionEngine*             eengine;
   llvm::legacy::FunctionPassManager* fpm;
 #else
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index 7828c1ca8..bb273cc47 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -3,6 +3,7 @@
 #define HOBBES_UTIL_LLVM_HPP_INCLUDED
 
 #include <hobbes/util/array.H>
+#include <llvm/IR/Function.h>
 #if LLVM_VERSION_MAJOR >= 11
 #include <hobbes/lang/type.H>
 #endif
@@ -832,6 +833,44 @@ inline llvm::Value* fncall(llvm::IRBuilder<>* b, llvm::Value* fn, llvm::Type* tf
   return fncall(b, fn, tfn, list(arg));
 }
 
+inline void maybeInlineFunctionsIn(llvm::Module& m) {
+  // If there is an IR function in current module is already large (instructions
+  // > `HOBBES_FUNCTION_INLINE_THRESHOLD`), then keep inlining it makes it even
+  // larger, 10x larger. We simply stop applying FunctionInlining pass on this
+  // module in such kinds of scenario.
+  static const auto allFunctionsAreSmall = [](const llvm::Module& m) {
+    static unsigned fnInliningThreshold = [] {
+      const char* v = std::getenv("HOBBES_FUNCTION_INLINE_THRESHOLD");
+      if (v == nullptr) {
+        return 30'000U; // arbitrarily chosen, but should be conservative enough
+      }
+      return static_cast<unsigned>(strtoul(v, nullptr, 10));
+    }();
+
+    // early llvm versions either don't have
+    // llvm::Function::getInstructionCount() or failed to make it const, so we
+    // provide our simplified version
+    static const auto getFunctionInstructionCount =
+        [](const llvm::Function& f) {
+          unsigned num = 0;
+          for (const auto& b : f.getBasicBlockList()) {
+            num += b.size();
+          }
+          return num;
+        };
+
+    // if any functions in this module has instruction number above threshold,
+    // then should not inline anything
+    return std::none_of(m.begin(), m.end(), [](const llvm::Function& f) {
+      return getFunctionInstructionCount(f) > fnInliningThreshold;
+    });
+  };
+
+  if (allFunctionsAreSmall(m)) {
+    auto mpm = llvm::legacy::PassManager();
+    mpm.add(llvm::createFunctionInliningPass());
+    mpm.run(m);
+  }
+}
 }
-
 #endif
diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index 2a28bd53e..6dd40518b 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -600,15 +600,9 @@ jitcc::jitcc(const TEnvPtr& tenv) :
   this->eengine = makeExecutionEngine(module(), 0);
 
 #if LLVM_VERSION_MINOR >= 5
-  this->mpm = new llvm::legacy::PassManager();
-  this->mpm->add(llvm::createFunctionInliningPass());
-
   this->fpm = new llvm::legacy::FunctionPassManager(module());
   this->fpm->add(new llvm::DataLayoutPass(*this->eengine->getDataLayout()));
 #else
-  this->mpm = new llvm::PassManager();
-  this->mpm->add(llvm::createFunctionInliningPass());
-
   this->fpm = new llvm::FunctionPassManager(module());
   this->fpm->add(new llvm::DataLayout(*this->eengine->getDataLayout()));
 #endif
@@ -620,11 +614,6 @@ jitcc::jitcc(const TEnvPtr& tenv) :
   this->fpm->add(llvm::createTailCallEliminationPass());
   this->fpm->doInitialization();
 #endif
-
-#if LLVM_VERSION_MINOR >= 6 || LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR >= 8
-  this->mpm = new llvm::legacy::PassManager();
-  this->mpm->add(llvm::createFunctionInliningPass());
-#endif
 }
 
 jitcc::~jitcc() {
@@ -795,8 +784,8 @@ void* jitcc::getMachineCode(llvm::Function* f, llvm::JITEventListener* listener)
     fpm.run(*mf);
   }
 
-  // apply module-level optimizations
-  this->mpm->run(*this->currentModule);
+  // may apply FunctionInliningPass depends upon some "scores"
+  maybeInlineFunctionsIn(*this->currentModule);
 
   // but we can still get at it through its execution engine
   this->eengines.push_back(ee);
diff --git a/lib/hobbes/eval/orcjitcc.C b/lib/hobbes/eval/orcjitcc.C
index 332f0f0e0..01afc13b4 100644
--- a/lib/hobbes/eval/orcjitcc.C
+++ b/lib/hobbes/eval/orcjitcc.C
@@ -31,9 +31,8 @@ optimizeModule(llvm::orc::ThreadSafeModule tsm,
       fpm.run(f);
     }
 
-    auto mpm = llvm::legacy::PassManager();
-    mpm.add(llvm::createFunctionInliningPass());
-    mpm.run(m);
+    // may apply FunctionInliningPass depends upon some "scores"
+    hobbes::maybeInlineFunctionsIn(m);
   });
 
   return tsm;
diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index 57ce8f037..408a979af 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -4,6 +4,7 @@
 #include <hobbes/lang/pat/regex.H>
 #include <hobbes/lang/pat/print.H>
 #include <hobbes/util/perf.H>
+#include <limits>
 #include <sstream>
 #include <fstream>
 
@@ -1267,9 +1268,23 @@ ExprPtr liftDFAExprWithSwitchCompression(MDFA* dfa, stateidx_t state) {
 bool shouldInlineState(const MDFA* dfa, stateidx_t state) {
   const MStatePtr& s = dfa->states[state];
 
+  // stop adding state related IR code into current function, if the state value
+  // is above `HOBBES_DFA_INLINE_THRESHOLD`. If a DFA has too many states,
+  // otherwise IR function can get so large that llvm cannot handle
+  static const auto inlineThreshold = [] {
+    // setting it to 0 makes no threshold. It must be a non-negative integer
+    const char* v = std::getenv("HOBBES_DFA_INLINE_THRESHOLD");
+    if (v == nullptr) {
+      return 2'000UL; // empirical data
+    }
+    static_assert(std::is_same<stateidx_t, unsigned long>::value, "");
+    const auto i = strtoul(v, nullptr, 10);
+    return i == 0 ? std::numeric_limits<stateidx_t>::max() : i;
+  }();
+
   if (dfa->states[state]->isPrimMatchRoot) {
     return false;
-  } else if (s->refs <= 1) {
+  } else if (state < inlineThreshold && s->refs <= 1) {
     return true;
   } else if (const FinishExpr* fe = is<FinishExpr>(s)) {
     return isConst(fe->expr()) || (is<Var>(fe->expr()) != nullptr);

From cafb837b63102e7f4e211df7720829ef65ab6270 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Fri, 9 Dec 2022 12:22:48 +0800
Subject: [PATCH 34/40] add partial support for int128

---
 include/hobbes/util/llvm.H | 21 +++++++++++++++++----
 test/Prelude.C             |  8 +++++++-
 2 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index bb273cc47..5308cc41e 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -68,6 +68,12 @@ namespace hobbes {
 
 using int128_t = __int128;
 
+#define INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a(x)                              \
+  const uint64_t aa_aa_aa[] = {                                                \
+      static_cast<uint64_t>(static_cast<unsigned __int128>(x) &                \
+                            0xFFFFFFFFFFFFFFFF),                               \
+      static_cast<uint64_t>(static_cast<unsigned __int128>(x) >> 64U)};        \
+  const auto a_a_a = llvm::ArrayRef<uint64_t> { aa_aa_aa }
 
 #if LLVM_VERSION_MAJOR >= 11
 inline llvm::orc::ThreadSafeContext& threadSafeContext() {
@@ -218,7 +224,8 @@ inline llvm::Constant* cvalue(long x) {
 }
 
 inline llvm::Constant* cvalue(int128_t x) {
-  return llvm::Constant::getIntegerValue(int128Type(), llvm::APInt(128, x, true));
+  INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a(x);
+  return llvm::Constant::getIntegerValue(int128Type(), llvm::APInt(128, a_a_a));
 }
 
 inline llvm::Constant* cvalue(float x) {
@@ -276,7 +283,8 @@ inline llvm::ConstantInt* civalue(long x) {
 
 inline llvm::ConstantInt* civalue(int128_t x) {
   return withContext([x](llvm::LLVMContext& c) {
-    return llvm::ConstantInt::get(llvm::IntegerType::get(c, 128), x); // static_cast<uint64_t>(x));
+    INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a(x);
+    return llvm::ConstantInt::get(c, llvm::APInt(128, a_a_a));
   });
 }
 #else
@@ -431,7 +439,8 @@ inline llvm::Constant* cvalue(long x) {
 }
 
 inline llvm::Constant* cvalue(int128_t x) {
-  return llvm::Constant::getIntegerValue(int128Type(), llvm::APInt(128, x, true));
+  INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a(x);
+  return llvm::Constant::getIntegerValue(int128Type(), llvm::APInt(128, a_a_a));
 }
 
 inline llvm::Constant* cvalue(float x) {
@@ -472,10 +481,14 @@ inline llvm::ConstantInt* civalue(long x) {
 }
 
 inline llvm::ConstantInt* civalue(int128_t x) {
-  return llvm::ConstantInt::get(llvm::IntegerType::get(context(), 128), x); //static_cast<uint64_t>(x));
+  INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a(x);
+  return llvm::ConstantInt::get(context(), llvm::APInt(128, a_a_a));
 }
 
 #endif
+
+#undef INT128_TO_UINT64_ARRAY_REF_NAMED_a_a_a
+
 // an intermediate representation for records
 using FieldValue = std::pair<std::string, llvm::Value *>;
 using RecordValue = std::vector<FieldValue>;
diff --git a/test/Prelude.C b/test/Prelude.C
index 1259e7291..80447d782 100644
--- a/test/Prelude.C
+++ b/test/Prelude.C
@@ -93,5 +93,11 @@ TEST(Prelude, Int128) {
   EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"-170141183460469231731687303715884105729\"))")())), "|0|");
   // overflow
   EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(readInt128(\"170141183460469231731687303715884105728\"))")())), "|0|");
-}
 
+  // INT128_MAX
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(170141183460469231731687303715884105727H)")())), "170141183460469231731687303715884105727");
+  // INT128_MIN, still wrong, needs to be fixed in a separated PR
+  //EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105728H)")())), "-170141183460469231731687303715884105728");
+  // INT128_MIN - 1, better than nothing
+  EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105727H)")())), "-170141183460469231731687303715884105727");
+}
\ No newline at end of file

From 623742cd24daeaf3fa8621985915325e73e0da3f Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Mon, 12 Dec 2022 17:54:51 +0800
Subject: [PATCH 35/40] get cc::unmatchableRowsPtr back

---
 include/hobbes/eval/cc.H  |  2 ++
 lib/hobbes/eval/cc.C      |  1 +
 lib/hobbes/lang/pat/dfa.C | 11 ++++++++
 test/Matching.C           | 57 ++++++++++++++++++++++++++++++++++-----
 4 files changed, 64 insertions(+), 7 deletions(-)

diff --git a/include/hobbes/eval/cc.H b/include/hobbes/eval/cc.H
index 1e7b09986..ed41f8d1f 100644
--- a/include/hobbes/eval/cc.H
+++ b/include/hobbes/eval/cc.H
@@ -318,6 +318,8 @@ public:
   void regexDFAOverNFAMaxRatio(int f);
   int regexDFAOverNFAMaxRatio() const;
 
+  UnreachableMatchRowsPtr unreachableMatchRowsPtr;
+
   // allow low-level functions to be added
   void bindLLFunc(const std::string &, op *);
 
diff --git a/lib/hobbes/eval/cc.C b/lib/hobbes/eval/cc.C
index 6c3eb930e..f128c3bee 100644
--- a/lib/hobbes/eval/cc.C
+++ b/lib/hobbes/eval/cc.C
@@ -45,6 +45,7 @@ cc::cc() :
   readExprDefnF(&defReadExprDefn),
   readExprF(&defReadExpr),
   drainingDefs(false),
+  unreachableMatchRowsPtr(nullptr),
   runModInlinePass(true),
   genInterpretedMatch(false),
   checkMatchReachability(true),
diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index 408a979af..ee32cdc8b 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -1155,6 +1155,17 @@ stateidx_t makeDFA(MDFA* dfa, const PatternRows& ps, const LexicalAnnotation& la
     }
   }
 
+  if (dfa->c->unreachableMatchRowsPtr) {
+    dfa->c->unreachableMatchRowsPtr->reserve(ps.size());
+    for (size_t r = 0; r < ps.size(); ++r) {
+      size_t fs = finalStates[r];
+
+      if (dfa->states[fs]->refs == 0) {
+        dfa->c->unreachableMatchRowsPtr->emplace_back(r, ps[r]);
+      }
+    }
+  }
+
   // OK, this is a good DFA
   return rootS;
 }
diff --git a/test/Matching.C b/test/Matching.C
index 2c69623db..12d48c74b 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -1,4 +1,5 @@
 
+#include "hobbes/lang/pat/pattern.H"
 #include "test.H"
 #include <hobbes/hobbes.H>
 #include <hobbes/util/perf.H>
@@ -239,22 +240,64 @@ TEST(Matching, Regex) {
             4);
 
   // verify unreachable row determination
+  const char* dupMatcher =
+      "match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1";
+  const char* dupRow = "/`foo.*/ -> 1";
+  // default behavior is throwing exception, and no collected info
   bool unreachableExn = false;
   try {
-    c().compileFn<int()>(
-        "match \"foo123ooo\" with | '123|foo.*' -> 0 | 'foo.*' -> 1 | _ -> -1");
-  } catch (std::exception &) {
+    c().compileFn<int()>(dupMatcher);
+  } catch (std::exception&) {
     unreachableExn = true;
   }
   EXPECT_TRUE(unreachableExn &&
               "failed to determine expected unreachable regex row");
 
+  // Two APIs are kept due to backward-compatibility reason
+
+  // if requireMatchReachability is false, then unreachableMatchRowsPtr
+  // stores unreachable rows
+  const bool orgRequireMatchReachability = c().requireMatchReachability();
+  c().requireMatchReachability(false);
+  c().unreachableMatchRowsPtr =
+      std::make_shared<hobbes::UnreachableMatchRowsPtr::element_type>();
+  EXPECT_EQ(c().compileFn<int()>(dupMatcher)(), 0);
+  c().requireMatchReachability(orgRequireMatchReachability);
+  EXPECT_EQ(c().unreachableMatchRowsPtr->size(), 1ULL);
+  EXPECT_EQ((*c().unreachableMatchRowsPtr)[0].first, 1ULL);
+  EXPECT_EQ(hobbes::show((*c().unreachableMatchRowsPtr)[0].second), dupRow);
+
   // verify unreachable rows should not cause error with
-  // IgnoreUnreachableMatches option on
+  // IgnoreUnreachableMatches option on, both unreachableMatchRowsPtr
+  // and getherUnreachableMatches() can be used to retrieve
+  // unmatched rows
   c().ignoreUnreachableMatches(true);
-  EXPECT_EQ(c().compileFn<int()>("match \"foo123ooo\" with | '123|foo.*' -> 0 "
-                                 "| 'foo.*' -> 1 | _ -> -1")(),
-            0);
+  c().unreachableMatchRowsPtr =
+      std::make_shared<std::vector<std::pair<size_t, hobbes::PatternRow>>>();
+  static thread_local auto unreachableMatches = std::vector<std::string>{};
+  c().setGatherUnreachableMatchesFn(
+      [](const hobbes::cc::UnreachableMatches& u) {
+        unreachableMatches.push_back(u.lines);
+      });
+  EXPECT_EQ(c().compileFn<int()>(dupMatcher)(), 0);
+  EXPECT_EQ(unreachableMatches.size(), 1UL);
+  EXPECT_EQ(c().unreachableMatchRowsPtr->size(), 1UL);
+  EXPECT_EQ((*c().unreachableMatchRowsPtr)[0].first, 1UL);
+  EXPECT_EQ(hobbes::show((*c().unreachableMatchRowsPtr)[0].second), dupRow);
+  c().ignoreUnreachableMatches(false);
+
+  // if unreachableMatchRowsPtr is empty, then only getherUnreachableMatches()
+  // can be used
+  c().ignoreUnreachableMatches(true);
+  c().unreachableMatchRowsPtr.reset();
+  unreachableMatches.clear();
+  c().setGatherUnreachableMatchesFn(
+      [](const hobbes::cc::UnreachableMatches& u) {
+        unreachableMatches.push_back(u.lines);
+      });
+  EXPECT_EQ(c().compileFn<int()>(dupMatcher)(), 0);
+  EXPECT_EQ(unreachableMatches.size(), 1UL);
+  EXPECT_TRUE((!c().unreachableMatchRowsPtr));
   c().ignoreUnreachableMatches(false);
 
   // verify binding in regex matches

From a98ff8d65a4bfddf90dc3152346d12fb3632ac30 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 4 Jan 2023 14:34:05 +0800
Subject: [PATCH 36/40] better errors for integral overflow

---
 include/hobbes/convert.H               |   1 +
 include/hobbes/read/pgen/hexpr.parse.H |   4 +-
 include/hobbes/util/hash.H             |   1 +
 include/hobbes/util/llvm.H             |  31 +-
 include/hobbes/util/stream.H           |   7 +-
 lib/hobbes/read/pgen/hexpr.l           |  47 +-
 lib/hobbes/read/pgen/hexpr.lex.C       | 318 +++++----
 lib/hobbes/read/pgen/hexpr.parse.C     | 881 +++++++++++++------------
 test/Compiler.C                        |   7 +-
 test/Prelude.C                         |  55 +-
 test/test.H                            |   6 +-
 11 files changed, 751 insertions(+), 607 deletions(-)

diff --git a/include/hobbes/convert.H b/include/hobbes/convert.H
index f1c77fbd6..448870c9a 100644
--- a/include/hobbes/convert.H
+++ b/include/hobbes/convert.H
@@ -7,6 +7,7 @@
 #define HOBBES_CONVERT_H_INCLUDED
 
 #include "reflect.H"
+#include <functional>
 #include <stdexcept>
 #include <array>
 #include <unordered_map>
diff --git a/include/hobbes/read/pgen/hexpr.parse.H b/include/hobbes/read/pgen/hexpr.parse.H
index c87cd911d..10ed00dd9 100644
--- a/include/hobbes/read/pgen/hexpr.parse.H
+++ b/include/hobbes/read/pgen/hexpr.parse.H
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 3.7.6.  */
+/* A Bison parser, made by GNU Bison 3.8.2.  */
 
 /* Bison interface for Yacc-like parsers in C
 
@@ -242,6 +242,8 @@ struct YYLTYPE
 
 extern YYSTYPE yylval;
 extern YYLTYPE yylloc;
+
 int yyparse (void);
 
+
 #endif /* !YY_YY_HEXPR_PARSE_H_INCLUDED  */
diff --git a/include/hobbes/util/hash.H b/include/hobbes/util/hash.H
index 4b82defc8..ebf8f3c5e 100644
--- a/include/hobbes/util/hash.H
+++ b/include/hobbes/util/hash.H
@@ -5,6 +5,7 @@
 #ifndef HOBBES_UTIL_HASH_H_INCLUDED
 #define HOBBES_UTIL_HASH_H_INCLUDED
 
+#include <cstddef>
 #include <functional>
 #include <unordered_map>
 #include <map>
diff --git a/include/hobbes/util/llvm.H b/include/hobbes/util/llvm.H
index 5308cc41e..4839b7c15 100644
--- a/include/hobbes/util/llvm.H
+++ b/include/hobbes/util/llvm.H
@@ -2,12 +2,6 @@
 #ifndef HOBBES_UTIL_LLVM_HPP_INCLUDED
 #define HOBBES_UTIL_LLVM_HPP_INCLUDED
 
-#include <hobbes/util/array.H>
-#include <llvm/IR/Function.h>
-#if LLVM_VERSION_MAJOR >= 11
-#include <hobbes/lang/type.H>
-#endif
-
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
@@ -19,20 +13,29 @@
 #error "I don't know how to use this version of LLVM"
 #endif
 
+#include <hobbes/lang/type.H>
+#include <hobbes/util/ptr.H>
+#include <hobbes/util/array.H>
+
+#if LLVM_VERSION_MAJOR >= 11
+#include <hobbes/lang/type.H>
+#endif
+
+#include <llvm/Analysis/Passes.h>
+#include <llvm/IR/DataLayout.h>
 #include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/InstIterator.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Module.h>
-#include <llvm/IR/DataLayout.h>
-#include <llvm/IR/InstIterator.h>
-#include <llvm/Analysis/Passes.h>
-#include <llvm/Transforms/Scalar.h>
-#include <llvm/Transforms/Vectorize.h>
+#include <llvm/Support/Signals.h>
+#include <llvm/Support/TargetRegistry.h>
+#include <llvm/Support/TargetSelect.h>
 #include <llvm/Transforms/IPO.h>
+#include <llvm/Transforms/Scalar.h>
 #include <llvm/Transforms/Utils/Cloning.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/TargetRegistry.h>
-#include <llvm/Support/Signals.h>
+#include <llvm/Transforms/Vectorize.h>
 #if LLVM_VERSION_MAJOR == 4 || LLVM_VERSION_MAJOR == 6 || LLVM_VERSION_MAJOR <= 8
 #  include <llvm/Bitcode/BitstreamReader.h>
 #  include <llvm/Bitcode/BitstreamWriter.h>
diff --git a/include/hobbes/util/stream.H b/include/hobbes/util/stream.H
index 9227dedf4..02129fa6c 100644
--- a/include/hobbes/util/stream.H
+++ b/include/hobbes/util/stream.H
@@ -2,6 +2,7 @@
 #ifndef HOBBES_UTIL_STREAM_HPP_INCLUDED
 #define HOBBES_UTIL_STREAM_HPP_INCLUDED
 
+#include <cstring>
 #include <iostream>
 #include <vector>
 
@@ -72,9 +73,9 @@ template < typename Char = char, typename Traits = std::char_traits<Char> >
 
 }}
 
-#define HOBBES_ABS_INT128_POS ((static_cast<unsigned __int128>(1) << 127) - 1)
-#define HOBBES_ABS_INT128_NEG ( static_cast<unsigned __int128>(1) << 127)
-#define HOBBES_INT128_MIN     (static_cast<__int128>(static_cast<unsigned __int128>(1) << 127))
+#define HOBBES_ABS_INT128_POS ((static_cast<unsigned __int128>(1) << 127U) - 1)
+#define HOBBES_ABS_INT128_NEG ( static_cast<unsigned __int128>(1) << 127U)
+#define HOBBES_INT128_MIN     (static_cast<__int128>(static_cast<unsigned __int128>(1) << 127U))
 
 // show int128 values (should be disabled when/if compiler support for these types is standardized)
 inline void printInt128(std::ostream& out, const __int128& sx) {
diff --git a/lib/hobbes/read/pgen/hexpr.l b/lib/hobbes/read/pgen/hexpr.l
index 41489b69b..bdd9b3fd4 100644
--- a/lib/hobbes/read/pgen/hexpr.l
+++ b/lib/hobbes/read/pgen/hexpr.l
@@ -17,16 +17,55 @@ int yycolumn = 1;
 #include <hobbes/util/stream.H>
 #include <hobbes/parse/grammar.H>
 #include <hobbes/read/pgen/hexpr.parse.H>
+#include <limits>
 #include <string>
 #include <iostream>
 
+namespace {
+std::out_of_range make_err(const std::string& s) {
+  return std::out_of_range(std::string("literal ") + s + " is not supported");
+}
+
+int str2int(const std::string& s) {
+  try {
+    return std::stoi(s);
+  } catch (const std::out_of_range&) {
+    throw make_err(s);
+  }
+}
+
+long str2long(const std::string& s) {
+  try {
+    return std::stol(s);
+  } catch (const std::out_of_range&) {
+    throw make_err(s);
+  }
+}
+
+short str2short(const std::string& s) {
+  const auto i = str2int(s);
+  if (i > std::numeric_limits<short>::max()) {
+    throw make_err(s);
+  }
+  return static_cast<short>(i);
+}
+
+__int128 str2int128(const std::string& s) {
+  __int128 i = 0;
+  if (!readInt128(s, &i)) {
+    throw make_err(s);
+  }
+  return i;
+}
+}
+
 #define SAVE_STR    yylval.string = hobbes::autorelease(new std::string(yytext, yytext + yyleng))
 #define SAVE_IDENT  yylval.string = identifier(yytext, yytext + yyleng)
 #define SAVE_BOOL   std::istringstream(std::string(yytext, yytext + yyleng)) >> std::boolalpha >> yylval.boolv
-#define SAVE_SHORT  yylval.shortv = (short)std::stoi(std::string(yytext, yytext + yyleng))
-#define SAVE_INT    yylval.intv = std::stoi(std::string(yytext, yytext + yyleng))
-#define SAVE_LONG   yylval.longv = std::stol(std::string(yytext, yytext + yyleng - 1))
-#define SAVE_INT128 readInt128(std::string(yytext, yytext + yyleng - 1), &yylval.int128v)
+#define SAVE_SHORT  yylval.shortv = str2short(std::string(yytext, yytext + yyleng - 1))
+#define SAVE_INT    yylval.intv = str2int(std::string(yytext, yytext + yyleng))
+#define SAVE_LONG   yylval.longv = str2long(std::string(yytext, yytext + yyleng - 1))
+#define SAVE_INT128 yylval.int128v = str2int128(std::string(yytext, yytext + yyleng - 1))
 #define SAVE_FLOAT  yylval.floatv = std::stof(std::string(yytext, yytext + yyleng))
 #define SAVE_DOUBLE yylval.doublev = std::stod(std::string(yytext, yytext + yyleng))
 
diff --git a/lib/hobbes/read/pgen/hexpr.lex.C b/lib/hobbes/read/pgen/hexpr.lex.C
index 17ee6afab..536356f7f 100644
--- a/lib/hobbes/read/pgen/hexpr.lex.C
+++ b/lib/hobbes/read/pgen/hexpr.lex.C
@@ -1,6 +1,6 @@
-#line 1 "hexpr.lex.C"
+#line 2 "hexpr.lex.C"
 
-#line 3 "hexpr.lex.C"
+#line 4 "hexpr.lex.C"
 
 #define  YY_INT_ALIGNED short int
 
@@ -744,16 +744,55 @@ int yycolumn = 1;
 #include <hobbes/util/stream.H>
 #include <hobbes/parse/grammar.H>
 #include <hobbes/read/pgen/hexpr.parse.H>
+#include <limits>
 #include <string>
 #include <iostream>
 
+namespace {
+std::out_of_range make_err(const std::string& s) {
+  return std::out_of_range(std::string("literal ") + s + " is not supported");
+}
+
+int str2int(const std::string& s) {
+  try {
+    return std::stoi(s);
+  } catch (const std::out_of_range&) {
+    throw make_err(s);
+  }
+}
+
+long str2long(const std::string& s) {
+  try {
+    return std::stol(s);
+  } catch (const std::out_of_range&) {
+    throw make_err(s);
+  }
+}
+
+short str2short(const std::string& s) {
+  const auto i = str2int(s);
+  if (i > std::numeric_limits<short>::max()) {
+    throw make_err(s);
+  }
+  return static_cast<short>(i);
+}
+
+__int128 str2int128(const std::string& s) {
+  __int128 i = 0;
+  if (!readInt128(s, &i)) {
+    throw make_err(s);
+  }
+  return i;
+}
+}
+
 #define SAVE_STR    yylval.string = hobbes::autorelease(new std::string(yytext, yytext + yyleng))
 #define SAVE_IDENT  yylval.string = identifier(yytext, yytext + yyleng)
 #define SAVE_BOOL   std::istringstream(std::string(yytext, yytext + yyleng)) >> std::boolalpha >> yylval.boolv
-#define SAVE_SHORT  yylval.shortv = (short)std::stoi(std::string(yytext, yytext + yyleng))
-#define SAVE_INT    yylval.intv = std::stoi(std::string(yytext, yytext + yyleng))
-#define SAVE_LONG   yylval.longv = std::stol(std::string(yytext, yytext + yyleng - 1))
-#define SAVE_INT128 readInt128(std::string(yytext, yytext + yyleng - 1), &yylval.int128v)
+#define SAVE_SHORT  yylval.shortv = str2short(std::string(yytext, yytext + yyleng - 1))
+#define SAVE_INT    yylval.intv = str2int(std::string(yytext, yytext + yyleng))
+#define SAVE_LONG   yylval.longv = str2long(std::string(yytext, yytext + yyleng - 1))
+#define SAVE_INT128 yylval.int128v = str2int128(std::string(yytext, yytext + yyleng - 1))
 #define SAVE_FLOAT  yylval.floatv = std::stof(std::string(yytext, yytext + yyleng))
 #define SAVE_DOUBLE yylval.doublev = std::stod(std::string(yytext, yytext + yyleng))
 
@@ -789,9 +828,9 @@ std::string* identifier(const char* b, const char* e) {
     return hobbes::autorelease(new std::string(b, e));
   }
 }
-#line 792 "hexpr.lex.C"
+#line 833 "hexpr.lex.C"
 
-#line 794 "hexpr.lex.C"
+#line 835 "hexpr.lex.C"
 
 #define INITIAL 0
 #define BLOCK_COMMENT 1
@@ -991,10 +1030,11 @@ YY_DECL
 #endif
 
         /* Create the reject buffer large enough to save one state per allowed character. */
-      if ( ! (yy_state_buf) )
-        (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
-      if ( ! (yy_state_buf) )
-        YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+        if ( ! (yy_state_buf) ) {
+            (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
+			if ( ! (yy_state_buf) )
+				YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+		}
 
 		if ( ! (yy_start) )
 			(yy_start) = 1;	/* first start state */
@@ -1015,11 +1055,11 @@ YY_DECL
 		}
 
 	{
-#line 71 "hexpr.l"
+#line 111 "hexpr.l"
 
 
 
-#line 75 "hexpr.l"
+#line 115 "hexpr.l"
   /* simulate multiple start symbols in our grammar by supporting a distinguished prefix token to switch on pseudo-start symbol productions */
   if (yyInitToken) {
     int r = yyInitToken;
@@ -1028,7 +1068,7 @@ YY_DECL
   }
 
 
-#line 1031 "hexpr.lex.C"
+#line 1072 "hexpr.lex.C"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1121,616 +1161,616 @@ do_action:	/* This label is used only to access EOF actions. */
 case 1:
 /* rule 1 can match eol */
 YY_RULE_SETUP
-#line 83 "hexpr.l"
+#line 123 "hexpr.l"
 { yycolumn = 1; }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 84 "hexpr.l"
+#line 124 "hexpr.l"
 { }
 	YY_BREAK
 case 3:
 /* rule 3 can match eol */
 YY_RULE_SETUP
-#line 85 "hexpr.l"
+#line 125 "hexpr.l"
 { yycolumn = 2; if (wantIndent()) { return TINDENT; } }
 	YY_BREAK
 case 4:
 /* rule 4 can match eol */
 YY_RULE_SETUP
-#line 86 "hexpr.l"
+#line 126 "hexpr.l"
 { yycolumn = 2; if (wantIndent()) { return TINDENT; } }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 87 "hexpr.l"
+#line 127 "hexpr.l"
 {               if (wantIndent()) { return TINDENT; } }
 	YY_BREAK
 case 6:
 /* rule 6 can match eol */
 YY_RULE_SETUP
-#line 88 "hexpr.l"
+#line 128 "hexpr.l"
 { yycolumn = 2; if (wantIndent()) { return TINDENT; } }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 89 "hexpr.l"
+#line 129 "hexpr.l"
 {               if (wantIndent()) { return TINDENT; } }
 	YY_BREAK
 case 8:
 /* rule 8 can match eol */
 YY_RULE_SETUP
-#line 90 "hexpr.l"
+#line 130 "hexpr.l"
 { yycolumn = 1; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 92 "hexpr.l"
+#line 132 "hexpr.l"
 { BEGIN(BLOCK_COMMENT); }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 93 "hexpr.l"
+#line 133 "hexpr.l"
 { BEGIN(INITIAL); }
 	YY_BREAK
 case 11:
 /* rule 11 can match eol */
 YY_RULE_SETUP
-#line 94 "hexpr.l"
+#line 134 "hexpr.l"
 { yycolumn = 1; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 95 "hexpr.l"
+#line 135 "hexpr.l"
 { }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 97 "hexpr.l"
+#line 137 "hexpr.l"
 { return TOPTION; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 98 "hexpr.l"
+#line 138 "hexpr.l"
 { return TMODULE; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 99 "hexpr.l"
+#line 139 "hexpr.l"
 { return TWHERE; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 100 "hexpr.l"
+#line 140 "hexpr.l"
 { return TIMPORT; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 101 "hexpr.l"
+#line 141 "hexpr.l"
 { return TTYPE; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 102 "hexpr.l"
+#line 142 "hexpr.l"
 { return TDATA; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 103 "hexpr.l"
+#line 143 "hexpr.l"
 { wantIndent(true); return TCLASS; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 104 "hexpr.l"
+#line 144 "hexpr.l"
 { wantIndent(true); return TINST; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 105 "hexpr.l"
+#line 145 "hexpr.l"
 { return TEXISTS; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 106 "hexpr.l"
+#line 146 "hexpr.l"
 { return TUNSAFE; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 107 "hexpr.l"
+#line 147 "hexpr.l"
 { return TSAFE; } 
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 109 "hexpr.l"
+#line 149 "hexpr.l"
 { return TASSIGN; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 110 "hexpr.l"
+#line 150 "hexpr.l"
 { return TEQUALS; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 111 "hexpr.l"
+#line 151 "hexpr.l"
 { return TASSUMP; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 112 "hexpr.l"
+#line 152 "hexpr.l"
 { return TCSTARROW; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 113 "hexpr.l"
+#line 153 "hexpr.l"
 { return TPARROW; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 114 "hexpr.l"
+#line 154 "hexpr.l"
 { return TCOLON; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 115 "hexpr.l"
+#line 155 "hexpr.l"
 { return TARROW; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 116 "hexpr.l"
+#line 156 "hexpr.l"
 { return TEQUIV; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 117 "hexpr.l"
+#line 157 "hexpr.l"
 { return TEQ; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 118 "hexpr.l"
+#line 158 "hexpr.l"
 { return TCIEQ; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 119 "hexpr.l"
+#line 159 "hexpr.l"
 { return TNEQ; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 120 "hexpr.l"
+#line 160 "hexpr.l"
 { return TLT; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 121 "hexpr.l"
+#line 161 "hexpr.l"
 { return TLTE; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 122 "hexpr.l"
+#line 162 "hexpr.l"
 { return TGT; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 123 "hexpr.l"
+#line 163 "hexpr.l"
 { return TGTE; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 124 "hexpr.l"
+#line 164 "hexpr.l"
 { return TNOT; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 125 "hexpr.l"
+#line 165 "hexpr.l"
 { return TNOT; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 126 "hexpr.l"
+#line 166 "hexpr.l"
 { return TLET; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 127 "hexpr.l"
+#line 167 "hexpr.l"
 { return TCASE; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 128 "hexpr.l"
+#line 168 "hexpr.l"
 { return TDEFAULT; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 129 "hexpr.l"
+#line 169 "hexpr.l"
 { return TMATCH; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 130 "hexpr.l"
+#line 170 "hexpr.l"
 { return TMATCHES; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 131 "hexpr.l"
+#line 171 "hexpr.l"
 { return TPARSE; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 132 "hexpr.l"
+#line 172 "hexpr.l"
 { return TWITH; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 133 "hexpr.l"
+#line 173 "hexpr.l"
 { return TOF; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 134 "hexpr.l"
+#line 174 "hexpr.l"
 { return TAND; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 135 "hexpr.l"
+#line 175 "hexpr.l"
 { return TOR; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 136 "hexpr.l"
+#line 176 "hexpr.l"
 { return TIF; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 137 "hexpr.l"
+#line 177 "hexpr.l"
 { return TTHEN; }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 138 "hexpr.l"
+#line 178 "hexpr.l"
 { return TELSE; }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 139 "hexpr.l"
+#line 179 "hexpr.l"
 { SAVE_BOOL; return TBOOL; }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 140 "hexpr.l"
+#line 180 "hexpr.l"
 { SAVE_BOOL; return TBOOL; }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 141 "hexpr.l"
+#line 181 "hexpr.l"
 { return TIN; }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 142 "hexpr.l"
+#line 182 "hexpr.l"
 { return TPACK; }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 143 "hexpr.l"
+#line 183 "hexpr.l"
 { return TUNPACK; }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 144 "hexpr.l"
+#line 184 "hexpr.l"
 { return TDO; }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 145 "hexpr.l"
+#line 185 "hexpr.l"
 { return TRETURN; }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 147 "hexpr.l"
+#line 187 "hexpr.l"
 { return TLPRAGMA; }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 148 "hexpr.l"
+#line 188 "hexpr.l"
 { return TRPRAGMA; }   
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 150 "hexpr.l"
+#line 190 "hexpr.l"
 { pushIndent(); return TLPAREN; }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 151 "hexpr.l"
+#line 191 "hexpr.l"
 { popIndent();  return TRPAREN; }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 152 "hexpr.l"
+#line 192 "hexpr.l"
 { pushIndent(); return TLBRACKET; }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 153 "hexpr.l"
+#line 193 "hexpr.l"
 { popIndent();  return TRBRACKET; }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 154 "hexpr.l"
+#line 194 "hexpr.l"
 { pushIndent(); return TLBRACE; }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 155 "hexpr.l"
+#line 195 "hexpr.l"
 { popIndent();  return TRBRACE; }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 157 "hexpr.l"
+#line 197 "hexpr.l"
 { return TBAR; }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 158 "hexpr.l"
+#line 198 "hexpr.l"
 { return TCOMMA; }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 159 "hexpr.l"
+#line 199 "hexpr.l"
 { return TSEMICOLON; }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 160 "hexpr.l"
+#line 200 "hexpr.l"
 { return TAPPEND; }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 161 "hexpr.l"
+#line 201 "hexpr.l"
 { return TPLUS; }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 162 "hexpr.l"
+#line 202 "hexpr.l"
 { return TMINUS; }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 163 "hexpr.l"
+#line 203 "hexpr.l"
 { return TTIMES; }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 164 "hexpr.l"
+#line 204 "hexpr.l"
 { return TDIVIDE; }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 165 "hexpr.l"
+#line 205 "hexpr.l"
 { return TREM; }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 166 "hexpr.l"
+#line 206 "hexpr.l"
 { return TFN; }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 167 "hexpr.l"
+#line 207 "hexpr.l"
 { return TFNL; }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 168 "hexpr.l"
+#line 208 "hexpr.l"
 { return TCOMPOSE; }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 169 "hexpr.l"
+#line 209 "hexpr.l"
 { return TDOT; }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 170 "hexpr.l"
+#line 210 "hexpr.l"
 { return TUPTO; }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 171 "hexpr.l"
+#line 211 "hexpr.l"
 { return TCARET; }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 172 "hexpr.l"
+#line 212 "hexpr.l"
 { return TAT; }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 173 "hexpr.l"
+#line 213 "hexpr.l"
 { return TDOLLAR; }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 174 "hexpr.l"
+#line 214 "hexpr.l"
 { return TQUESTION; }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 175 "hexpr.l"
+#line 215 "hexpr.l"
 { SAVE_STR;    return (hobbes::str::unescape(hobbes::str::trimq(*yylval.string, '\'')).size() <= 1) ? TCHAR : TREGEX; }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 176 "hexpr.l"
+#line 216 "hexpr.l"
 { return TSQUOTE; }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 177 "hexpr.l"
+#line 217 "hexpr.l"
 { return TEQUOTE; }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 178 "hexpr.l"
+#line 218 "hexpr.l"
 { SAVE_STR;    return TBYTE; }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 179 "hexpr.l"
+#line 219 "hexpr.l"
 { SAVE_STR;    return TBYTES; }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 180 "hexpr.l"
+#line 220 "hexpr.l"
 { SAVE_IDENT;  return TIDENT; }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 181 "hexpr.l"
+#line 221 "hexpr.l"
 { SAVE_STR;    return TTUPSECTION; }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 182 "hexpr.l"
+#line 222 "hexpr.l"
 { SAVE_FLOAT;  return TFLOAT; }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-#line 183 "hexpr.l"
+#line 223 "hexpr.l"
 { SAVE_DOUBLE; return TDOUBLE; }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 184 "hexpr.l"
+#line 224 "hexpr.l"
 { SAVE_DOUBLE; yylval.doublev *= 0.01; return TDOUBLE; }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 185 "hexpr.l"
+#line 225 "hexpr.l"
 { SAVE_INT128; return TINT128; }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 186 "hexpr.l"
+#line 226 "hexpr.l"
 { SAVE_LONG;   return TLONG; }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-#line 187 "hexpr.l"
+#line 227 "hexpr.l"
 { SAVE_SHORT;  return TSHORT; }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-#line 188 "hexpr.l"
+#line 228 "hexpr.l"
 { SAVE_INT;    return TINT; }
 	YY_BREAK
 case 101:
 /* rule 101 can match eol */
 YY_RULE_SETUP
-#line 189 "hexpr.l"
+#line 229 "hexpr.l"
 { SAVE_STR;    return TSTRING; }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-#line 191 "hexpr.l"
+#line 231 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-#line 192 "hexpr.l"
+#line 232 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-#line 193 "hexpr.l"
+#line 233 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-#line 194 "hexpr.l"
+#line 234 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-#line 195 "hexpr.l"
+#line 235 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
-#line 196 "hexpr.l"
+#line 236 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
-#line 197 "hexpr.l"
+#line 237 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
-#line 198 "hexpr.l"
+#line 238 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
-#line 199 "hexpr.l"
+#line 239 "hexpr.l"
 { SAVE_STR;    return TTIMEINTERVAL; }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
-#line 201 "hexpr.l"
+#line 241 "hexpr.l"
 { SAVE_STR; return TTIME; }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
-#line 202 "hexpr.l"
+#line 242 "hexpr.l"
 { SAVE_STR; return TTIME; }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
-#line 203 "hexpr.l"
+#line 243 "hexpr.l"
 { SAVE_STR; return TTIME; }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
-#line 204 "hexpr.l"
+#line 244 "hexpr.l"
 { SAVE_STR; return TTIME; }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
-#line 206 "hexpr.l"
+#line 246 "hexpr.l"
 { SAVE_STR; return TDATETIME; }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
-#line 207 "hexpr.l"
+#line 247 "hexpr.l"
 { SAVE_STR; return TDATETIME; }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
-#line 208 "hexpr.l"
+#line 248 "hexpr.l"
 { SAVE_STR; return TDATETIME; }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
-#line 209 "hexpr.l"
+#line 249 "hexpr.l"
 { SAVE_STR; return TDATETIME; }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
-#line 210 "hexpr.l"
+#line 250 "hexpr.l"
 { SAVE_STR; return TDATETIME; }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
-#line 212 "hexpr.l"
+#line 252 "hexpr.l"
 { yyVexpLexError = "Unknown character: " + std::string(yytext); yyterminate(); if (false) { yyrealloc(0, 0); yyunput(0, 0); } }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
-#line 214 "hexpr.l"
+#line 254 "hexpr.l"
 ECHO;
 	YY_BREAK
-#line 1733 "hexpr.lex.C"
+#line 1774 "hexpr.lex.C"
 			case YY_STATE_EOF(INITIAL):
 			case YY_STATE_EOF(BLOCK_COMMENT):
 				yyterminate();
@@ -2027,7 +2067,7 @@ static int yy_get_next_buffer (void)
 	if ( ! yy_is_jam )
 		*(yy_state_ptr)++ = yy_current_state;
 
-  return yy_is_jam ? 0 : yy_current_state;
+	return yy_is_jam ? 0 : yy_current_state;
 }
 
 #ifndef YY_NO_UNPUT
@@ -2721,7 +2761,7 @@ void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 214 "hexpr.l"
+#line 254 "hexpr.l"
 
 #pragma GCC diagnostic pop
 
diff --git a/lib/hobbes/read/pgen/hexpr.parse.C b/lib/hobbes/read/pgen/hexpr.parse.C
index 91e0dcb97..4b8de887c 100644
--- a/lib/hobbes/read/pgen/hexpr.parse.C
+++ b/lib/hobbes/read/pgen/hexpr.parse.C
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 3.7.6.  */
+/* A Bison parser, made by GNU Bison 3.8.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
@@ -46,10 +46,10 @@
    USER NAME SPACE" below.  */
 
 /* Identify Bison output, and Bison version.  */
-#define YYBISON 30706
+#define YYBISON 30802
 
 /* Bison version string.  */
-#define YYBISON_VERSION "3.7.6"
+#define YYBISON_VERSION "3.8.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -723,12 +723,18 @@ typedef int yy_state_fast_t;
 # define YY_USE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
+# else
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
     _Pragma ("GCC diagnostic push")                                     \
     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# endif
 # define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
     _Pragma ("GCC diagnostic pop")
 #else
@@ -955,7 +961,7 @@ static const yytype_int8 yytranslate[] =
 };
 
 #if YYDEBUG
-  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
        0,   524,   524,   525,   526,   527,   530,   531,   532,   534,
@@ -1051,24 +1057,6 @@ yysymbol_name (yysymbol_kind_t yysymbol)
 }
 #endif
 
-#ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
-   (internal) symbol number NUM (which must be that of a token).  */
-static const yytype_int16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352
-};
-#endif
-
 #define YYPACT_NINF (-603)
 
 #define yypact_value_is_default(Yyn) \
@@ -1079,8 +1067,8 @@ static const yytype_int16 yytoknum[] =
 #define yytable_value_is_error(Yyn) \
   0
 
-  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-     STATE-NUM.  */
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
      383,  1294,  2083,  2083,    45,    52,    52,    52,    77,    77,
@@ -1168,9 +1156,9 @@ static const yytype_int16 yypact[] =
     -603,  2083,   697,  -603,  2083,  -603
 };
 
-  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
-     Performed when YYTABLE does not specify something else to do.  Zero
-     means the default is an error.  */
+/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE does not specify something else to do.  Zero
+   means the default is an error.  */
 static const yytype_int16 yydefact[] =
 {
        0,     9,     0,     0,     0,     0,     0,     0,     0,     0,
@@ -1258,7 +1246,7 @@ static const yytype_int16 yydefact[] =
       36,     0,     0,    37,     0,    38
 };
 
-  /* YYPGOTO[NTERM-NUM].  */
+/* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
     -603,  -603,   663,   512,   -32,  -603,  -603,  -603,  -603,   197,
@@ -1272,7 +1260,7 @@ static const yytype_int16 yypgoto[] =
     -603,  -603,   240,   436
 };
 
-  /* YYDEFGOTO[NTERM-NUM].  */
+/* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
        0,     4,    43,    44,    45,    46,    47,   151,    48,    49,
@@ -1286,9 +1274,9 @@ static const yytype_int16 yydefgoto[] =
      398,   399,   400,    73
 };
 
-  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
-     positive, shift that token.  If negative, reduce the rule whose
-     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule whose
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
       64,    72,   158,   143,   359,   360,   361,   362,    81,    81,
@@ -1905,8 +1893,8 @@ static const yytype_int16 yycheck[] =
       78,    -1,    80
 };
 
-  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-     symbol of state STATE-NUM.  */
+/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
+   state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
        0,     3,     4,     5,    99,     6,     7,     9,    10,    11,
@@ -1994,7 +1982,7 @@ static const yytype_uint8 yystos[] =
      123,    38,   181,   123,    38,   123
 };
 
-  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
 static const yytype_uint8 yyr1[] =
 {
        0,    98,    99,    99,    99,    99,   100,   100,   100,   101,
@@ -2037,7 +2025,7 @@ static const yytype_uint8 yyr1[] =
      180,   180,   180,   180,   181
 };
 
-  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
 static const yytype_int8 yyr2[] =
 {
        0,     2,     2,     4,     2,     2,     3,     4,     1,     0,
@@ -2089,6 +2077,7 @@ enum { YYENOMEM = -2 };
 #define YYACCEPT        goto yyacceptlab
 #define YYABORT         goto yyabortlab
 #define YYERROR         goto yyerrorlab
+#define YYNOMEM         goto yyexhaustedlab
 
 
 #define YYRECOVERING()  (!!yyerrstatus)
@@ -2156,12 +2145,19 @@ do {                                            \
 } while (0)
 
 
-/* YY_LOCATION_PRINT -- Print the location on the stream.
+/* YYLOCATION_PRINT -- Print the location on the stream.
    This macro was not mandated originally: define only if we know
    we won't break user code: when these are the locations we know.  */
 
-# ifndef YY_LOCATION_PRINT
-#  if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+# ifndef YYLOCATION_PRINT
+
+#  if defined YY_LOCATION_PRINT
+
+   /* Temporary convenience wrapper in case some people defined the
+      undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YYLOCATION_PRINT(File, Loc)  YY_LOCATION_PRINT(File, *(Loc))
+
+#  elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 
 /* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
 
@@ -2189,15 +2185,23 @@ yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
         res += YYFPRINTF (yyo, "-%d", end_col);
     }
   return res;
- }
+}
 
-#   define YY_LOCATION_PRINT(File, Loc)          \
-  yy_location_print_ (File, &(Loc))
+#   define YYLOCATION_PRINT  yy_location_print_
+
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT(File, Loc)  YYLOCATION_PRINT(File, &(Loc))
 
 #  else
-#   define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+
+#   define YYLOCATION_PRINT(File, Loc) ((void) 0)
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT  YYLOCATION_PRINT
+
 #  endif
-# endif /* !defined YY_LOCATION_PRINT */
+# endif /* !defined YYLOCATION_PRINT */
 
 
 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
@@ -2225,10 +2229,6 @@ yy_symbol_value_print (FILE *yyo,
   YY_USE (yylocationp);
   if (!yyvaluep)
     return;
-# ifdef YYPRINT
-  if (yykind < YYNTOKENS)
-    YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
-# endif
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   YY_USE (yykind);
   YY_IGNORE_MAYBE_UNINITIALIZED_END
@@ -2246,7 +2246,7 @@ yy_symbol_print (FILE *yyo,
   YYFPRINTF (yyo, "%s %s (",
              yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
 
-  YY_LOCATION_PRINT (yyo, *yylocationp);
+  YYLOCATION_PRINT (yyo, yylocationp);
   YYFPRINTF (yyo, ": ");
   yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
   YYFPRINTF (yyo, ")");
@@ -2703,6 +2703,7 @@ yyparse (void)
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY; /* Cause a token to be read.  */
+
   yylsp[0] = yylloc;
   goto yysetstate;
 
@@ -2729,7 +2730,7 @@ yysetstate:
 
   if (yyss + yystacksize - 1 <= yyssp)
 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
-    goto yyexhaustedlab;
+    YYNOMEM;
 #else
     {
       /* Get the current used size of the three stacks, in elements.  */
@@ -2760,7 +2761,7 @@ yysetstate:
 # else /* defined YYSTACK_RELOCATE */
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
-        goto yyexhaustedlab;
+        YYNOMEM;
       yystacksize *= 2;
       if (YYMAXDEPTH < yystacksize)
         yystacksize = YYMAXDEPTH;
@@ -2771,7 +2772,7 @@ yysetstate:
           YY_CAST (union yyalloc *,
                    YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
         if (! yyptr)
-          goto yyexhaustedlab;
+          YYNOMEM;
         YYSTACK_RELOCATE (yyss_alloc, yyss);
         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
         YYSTACK_RELOCATE (yyls_alloc, yyls);
@@ -2795,6 +2796,7 @@ yysetstate:
     }
 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
+
   if (yystate == YYFINAL)
     YYACCEPT;
 
@@ -2913,787 +2915,787 @@ yyreduce:
   case 2: /* s: "domodule" module  */
 #line 524 "hexpr.y"
                             { yyParsedModule = (yyvsp[0].module);                     }
-#line 2917 "hexpr.parse.C"
+#line 2919 "hexpr.parse.C"
     break;
 
   case 3: /* s: "dodefn" id "=" l0expr  */
 #line 525 "hexpr.y"
                             { yyParsedVar    = *(yyvsp[-2].string); yyParsedExpr = (yyvsp[0].exp); }
-#line 2923 "hexpr.parse.C"
+#line 2925 "hexpr.parse.C"
     break;
 
   case 4: /* s: "dodefn" l0expr  */
 #line 526 "hexpr.y"
                             { yyParsedVar    = "";  yyParsedExpr = (yyvsp[0].exp); }
-#line 2929 "hexpr.parse.C"
+#line 2931 "hexpr.parse.C"
     break;
 
   case 5: /* s: "doexpr" l0expr  */
 #line 527 "hexpr.y"
                             { yyParsedExpr   = (yyvsp[0].exp);                     }
-#line 2935 "hexpr.parse.C"
+#line 2937 "hexpr.parse.C"
     break;
 
   case 6: /* module: "option" id module  */
 #line 530 "hexpr.y"
                                  { (yyval.module) = (yyvsp[0].module); (yyval.module)->setOption(*(yyvsp[-1].string), m((yylsp[-2]))); }
-#line 2941 "hexpr.parse.C"
+#line 2943 "hexpr.parse.C"
     break;
 
   case 7: /* module: "module" id "where" defs  */
 #line 531 "hexpr.y"
                                  { (yyval.module) = new Module(*(yyvsp[-2].string), *(yyvsp[0].mdefs)); }
-#line 2947 "hexpr.parse.C"
+#line 2949 "hexpr.parse.C"
     break;
 
   case 8: /* module: defs  */
 #line 532 "hexpr.y"
                                  { (yyval.module) = new Module(freshName(), *(yyvsp[0].mdefs)); }
-#line 2953 "hexpr.parse.C"
+#line 2955 "hexpr.parse.C"
     break;
 
   case 9: /* defs: %empty  */
 #line 534 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); }
-#line 2959 "hexpr.parse.C"
+#line 2961 "hexpr.parse.C"
     break;
 
   case 10: /* defs: def  */
 #line 535 "hexpr.y"
                     { (yyval.mdefs) = autorelease(new ModuleDefs()); (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2965 "hexpr.parse.C"
+#line 2967 "hexpr.parse.C"
     break;
 
   case 11: /* defs: defs def  */
 #line 536 "hexpr.y"
                     { (yyval.mdefs) = (yyvsp[-1].mdefs);                            (yyval.mdefs)->push_back(ModuleDefPtr((yyvsp[0].mdef))); }
-#line 2971 "hexpr.parse.C"
+#line 2973 "hexpr.parse.C"
     break;
 
   case 12: /* def: importdef  */
 #line 538 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2977 "hexpr.parse.C"
+#line 2979 "hexpr.parse.C"
     break;
 
   case 13: /* def: tydef  */
 #line 539 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2983 "hexpr.parse.C"
+#line 2985 "hexpr.parse.C"
     break;
 
   case 14: /* def: vartybind  */
 #line 540 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mvtydef); }
-#line 2989 "hexpr.parse.C"
+#line 2991 "hexpr.parse.C"
     break;
 
   case 15: /* def: classdef  */
 #line 541 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 2995 "hexpr.parse.C"
+#line 2997 "hexpr.parse.C"
     break;
 
   case 16: /* def: instdef  */
 #line 542 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 3001 "hexpr.parse.C"
+#line 3003 "hexpr.parse.C"
     break;
 
   case 17: /* def: pragmadef  */
 #line 543 "hexpr.y"
                { (yyval.mdef) = (yyvsp[0].mdef); }
-#line 3007 "hexpr.parse.C"
+#line 3009 "hexpr.parse.C"
     break;
 
   case 18: /* def: id "=" l0expr  */
 #line 545 "hexpr.y"
                    { (yyval.mdef) = new MVarDef(list(*(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3013 "hexpr.parse.C"
+#line 3015 "hexpr.parse.C"
     break;
 
   case 19: /* def: id id "=" l0expr  */
 #line 546 "hexpr.y"
                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3019 "hexpr.parse.C"
+#line 3021 "hexpr.parse.C"
     break;
 
   case 20: /* def: id id id "=" l0expr  */
 #line 547 "hexpr.y"
                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3025 "hexpr.parse.C"
+#line 3027 "hexpr.parse.C"
     break;
 
   case 21: /* def: id id id id "=" l0expr  */
 #line 548 "hexpr.y"
                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 3031 "hexpr.parse.C"
+#line 3033 "hexpr.parse.C"
     break;
 
   case 22: /* def: id id id id id "=" l0expr  */
 #line 549 "hexpr.y"
                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-6]), (yylsp[0]))); }
-#line 3037 "hexpr.parse.C"
+#line 3039 "hexpr.parse.C"
     break;
 
   case 23: /* def: id id id id id id "=" l0expr  */
 #line 550 "hexpr.y"
                                   { (yyval.mdef) = new MVarDef(list(*(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 3043 "hexpr.parse.C"
+#line 3045 "hexpr.parse.C"
     break;
 
   case 24: /* def: id id id id id id id "=" l0expr  */
 #line 551 "hexpr.y"
                                      { (yyval.mdef) = new MVarDef(list(*(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-8]), (yylsp[0]))); }
-#line 3049 "hexpr.parse.C"
+#line 3051 "hexpr.parse.C"
     break;
 
   case 25: /* def: id id id id id id id id "=" l0expr  */
 #line 552 "hexpr.y"
                                         { (yyval.mdef) = new MVarDef(list(*(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-9]), (yylsp[0]))); }
-#line 3055 "hexpr.parse.C"
+#line 3057 "hexpr.parse.C"
     break;
 
   case 26: /* def: id id id id id id id id id "=" l0expr  */
 #line 553 "hexpr.y"
                                            { (yyval.mdef) = new MVarDef(list(*(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-10]), (yylsp[0]))); }
-#line 3061 "hexpr.parse.C"
+#line 3063 "hexpr.parse.C"
     break;
 
   case 27: /* def: id id id id id id id id id id "=" l0expr  */
 #line 554 "hexpr.y"
                                               { (yyval.mdef) = new MVarDef(list(*(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-11]), (yylsp[0]))); }
-#line 3067 "hexpr.parse.C"
+#line 3069 "hexpr.parse.C"
     break;
 
   case 28: /* def: id id id id id id id id id id id "=" l0expr  */
 #line 555 "hexpr.y"
                                                  { (yyval.mdef) = new MVarDef(list(*(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-12]), (yylsp[0]))); }
-#line 3073 "hexpr.parse.C"
+#line 3075 "hexpr.parse.C"
     break;
 
   case 29: /* def: id id id id id id id id id id id id "=" l0expr  */
 #line 556 "hexpr.y"
                                                     { (yyval.mdef) = new MVarDef(list(*(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-13]), (yylsp[0]))); }
-#line 3079 "hexpr.parse.C"
+#line 3081 "hexpr.parse.C"
     break;
 
   case 30: /* def: id id id id id id id id id id id id id "=" l0expr  */
 #line 557 "hexpr.y"
                                                        { (yyval.mdef) = new MVarDef(list(*(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-14]), (yylsp[0]))); }
-#line 3085 "hexpr.parse.C"
+#line 3087 "hexpr.parse.C"
     break;
 
   case 31: /* def: id id id id id id id id id id id id id id "=" l0expr  */
 #line 558 "hexpr.y"
                                                           { (yyval.mdef) = new MVarDef(list(*(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-15]), (yylsp[0]))); }
-#line 3091 "hexpr.parse.C"
+#line 3093 "hexpr.parse.C"
     break;
 
   case 32: /* def: id id id id id id id id id id id id id id id "=" l0expr  */
 #line 559 "hexpr.y"
                                                              { (yyval.mdef) = new MVarDef(list(*(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-16]), (yylsp[0]))); }
-#line 3097 "hexpr.parse.C"
+#line 3099 "hexpr.parse.C"
     break;
 
   case 33: /* def: id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 560 "hexpr.y"
                                                                 { (yyval.mdef) = new MVarDef(list(*(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-17]), (yylsp[0]))); }
-#line 3103 "hexpr.parse.C"
+#line 3105 "hexpr.parse.C"
     break;
 
   case 34: /* def: id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 561 "hexpr.y"
                                                                    { (yyval.mdef) = new MVarDef(list(*(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-18]), (yylsp[0]))); }
-#line 3109 "hexpr.parse.C"
+#line 3111 "hexpr.parse.C"
     break;
 
   case 35: /* def: id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 562 "hexpr.y"
                                                                       { (yyval.mdef) = new MVarDef(list(*(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-19]), (yylsp[0]))); }
-#line 3115 "hexpr.parse.C"
+#line 3117 "hexpr.parse.C"
     break;
 
   case 36: /* def: id id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 563 "hexpr.y"
                                                                          { (yyval.mdef) = new MVarDef(list(*(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-20]), (yylsp[0]))); }
-#line 3121 "hexpr.parse.C"
+#line 3123 "hexpr.parse.C"
     break;
 
   case 37: /* def: id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 564 "hexpr.y"
                                                                             { (yyval.mdef) = new MVarDef(list(*(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-21]), (yylsp[0]))); }
-#line 3127 "hexpr.parse.C"
+#line 3129 "hexpr.parse.C"
     break;
 
   case 38: /* def: id id id id id id id id id id id id id id id id id id id id id "=" l0expr  */
 #line 565 "hexpr.y"
                                                                                { (yyval.mdef) = new MVarDef(list(*(yyvsp[-22].string), *(yyvsp[-21].string), *(yyvsp[-20].string), *(yyvsp[-19].string), *(yyvsp[-18].string), *(yyvsp[-17].string), *(yyvsp[-16].string), *(yyvsp[-15].string), *(yyvsp[-14].string), *(yyvsp[-13].string), *(yyvsp[-12].string), *(yyvsp[-11].string), *(yyvsp[-10].string), *(yyvsp[-9].string), *(yyvsp[-8].string), *(yyvsp[-7].string), *(yyvsp[-6].string), *(yyvsp[-5].string), *(yyvsp[-4].string), *(yyvsp[-3].string), *(yyvsp[-2].string)), ExprPtr((yyvsp[0].exp)), m((yylsp[-22]), (yylsp[0]))); }
-#line 3133 "hexpr.parse.C"
+#line 3135 "hexpr.parse.C"
     break;
 
   case 39: /* def: l5expr  */
 #line 568 "hexpr.y"
             { (yyval.mdef) = new MVarDef(list(freshName()), let(freshName(), ExprPtr((yyvsp[0].exp)), mktunit(m((yylsp[0]))), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3139 "hexpr.parse.C"
+#line 3141 "hexpr.parse.C"
     break;
 
   case 40: /* importdef: "import" cppid  */
 #line 571 "hexpr.y"
                           { (yyval.mdef) = new MImport(yyModulePath, *(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3145 "hexpr.parse.C"
+#line 3147 "hexpr.parse.C"
     break;
 
   case 41: /* pragmadef: "{-#" pragmaty "#-}"  */
 #line 574 "hexpr.y"
                                 { (yyval.mdef) = (yyvsp[-1].mdef); }
-#line 3151 "hexpr.parse.C"
+#line 3153 "hexpr.parse.C"
     break;
 
   case 42: /* pragmaty: "UNSAFE" id  */
 #line 575 "hexpr.y"
                       { (yyval.mdef) = new MUnsafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3157 "hexpr.parse.C"
+#line 3159 "hexpr.parse.C"
     break;
 
   case 43: /* pragmaty: "SAFE" id  */
 #line 576 "hexpr.y"
                     { (yyval.mdef) = new MSafePragmaDef(*(yyvsp[0].string), m((yylsp[-1]), (yylsp[0]))); }
-#line 3163 "hexpr.parse.C"
+#line 3165 "hexpr.parse.C"
     break;
 
   case 44: /* tydef: "type" nameseq "=" qtype  */
 #line 579 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Transparent, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3169 "hexpr.parse.C"
+#line 3171 "hexpr.parse.C"
     break;
 
   case 45: /* tydef: "data" nameseq "=" qtype  */
 #line 580 "hexpr.y"
                                 { (yyval.mdef) = new MTypeDef(MTypeDef::Opaque, hobbes::select(*(yyvsp[-2].strings), 0), hobbes::select(*(yyvsp[-2].strings), 1, (int)(yyvsp[-2].strings)->size()), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3175 "hexpr.parse.C"
+#line 3177 "hexpr.parse.C"
     break;
 
   case 46: /* vartybind: name "::" qtype  */
 #line 583 "hexpr.y"
                            { (yyval.mvtydef) = new MVarTypeDef(*(yyvsp[-2].string), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3181 "hexpr.parse.C"
+#line 3183 "hexpr.parse.C"
     break;
 
   case 47: /* vardef: names "=" l0expr  */
 #line 585 "hexpr.y"
                          { (yyval.mvdef) = new MVarDef(*(yyvsp[-2].strings), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3187 "hexpr.parse.C"
+#line 3189 "hexpr.parse.C"
     break;
 
   case 48: /* classdef: "class" cst "=>" id names  */
 #line 588 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-3].tconstraints), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3193 "hexpr.parse.C"
+#line 3195 "hexpr.parse.C"
     break;
 
   case 49: /* classdef: "class" cst "=>" id names "|" fundeps  */
 #line 589 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-6]), (yylsp[0]))); wantIndent(false); }
-#line 3199 "hexpr.parse.C"
+#line 3201 "hexpr.parse.C"
     break;
 
   case 50: /* classdef: "class" cst "=>" id names "where" cmembers  */
 #line 590 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-5].tconstraints), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3205 "hexpr.parse.C"
+#line 3207 "hexpr.parse.C"
     break;
 
   case 51: /* classdef: "class" cst "=>" id names "|" fundeps "where" cmembers  */
 #line 591 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(*(yyvsp[-7].tconstraints), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-8]), (yylsp[0])));            wantIndent(false); }
-#line 3211 "hexpr.parse.C"
+#line 3213 "hexpr.parse.C"
     break;
 
   case 52: /* classdef: "class" id names  */
 #line 592 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].strings), CFunDepDefs(), MVarTypeDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3217 "hexpr.parse.C"
+#line 3219 "hexpr.parse.C"
     break;
 
   case 53: /* classdef: "class" id names "|" fundeps  */
 #line 593 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), *(yyvsp[0].fundeps),           MVarTypeDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3223 "hexpr.parse.C"
+#line 3225 "hexpr.parse.C"
     break;
 
   case 54: /* classdef: "class" id names "where" cmembers  */
 #line 594 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].strings), CFunDepDefs(), *(yyvsp[0].mvtydefs), m((yylsp[-4]), (yylsp[0])));            wantIndent(false); }
-#line 3229 "hexpr.parse.C"
+#line 3231 "hexpr.parse.C"
     break;
 
   case 55: /* classdef: "class" id names "|" fundeps "where" cmembers  */
 #line 595 "hexpr.y"
                                                                  { (yyval.mdef) = new ClassDef(Constraints(), *(yyvsp[-5].string), *(yyvsp[-4].strings), *(yyvsp[-2].fundeps),           *(yyvsp[0].mvtydefs), m((yylsp[-6]), (yylsp[0])));            wantIndent(false); }
-#line 3235 "hexpr.parse.C"
+#line 3237 "hexpr.parse.C"
     break;
 
   case 56: /* fundeps: fundep  */
 #line 597 "hexpr.y"
                             { (yyval.fundeps) = autorelease(new CFunDepDefs()); (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3241 "hexpr.parse.C"
+#line 3243 "hexpr.parse.C"
     break;
 
   case 57: /* fundeps: fundeps "," fundep  */
 #line 598 "hexpr.y"
                             { (yyval.fundeps) = (yyvsp[-2].fundeps);                             (yyval.fundeps)->push_back(*(yyvsp[0].fundep)); }
-#line 3247 "hexpr.parse.C"
+#line 3249 "hexpr.parse.C"
     break;
 
   case 58: /* fundep: idseq "->" idseq  */
 #line 600 "hexpr.y"
                          { (yyval.fundep) = autorelease(new CFunDepDef(*(yyvsp[-2].strings), *(yyvsp[0].strings))); }
-#line 3253 "hexpr.parse.C"
+#line 3255 "hexpr.parse.C"
     break;
 
   case 59: /* cmembers: cmember  */
 #line 602 "hexpr.y"
                            { (yyval.mvtydefs) = autorelease(new MVarTypeDefs()); (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3259 "hexpr.parse.C"
+#line 3261 "hexpr.parse.C"
     break;
 
   case 60: /* cmembers: cmembers cmember  */
 #line 603 "hexpr.y"
                            { (yyval.mvtydefs) = (yyvsp[-1].mvtydefs);                              (yyval.mvtydefs)->push_back(MVarTypeDefPtr((yyvsp[0].mvtydef))); }
-#line 3265 "hexpr.parse.C"
+#line 3267 "hexpr.parse.C"
     break;
 
   case 61: /* cmember: "indent" vartybind  */
 #line 605 "hexpr.y"
                             { (yyval.mvtydef) = (yyvsp[0].mvtydef); }
-#line 3271 "hexpr.parse.C"
+#line 3273 "hexpr.parse.C"
     break;
 
   case 62: /* instdef: "instance" id types  */
 #line 608 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-2]), (yylsp[0]))); wantIndent(false); }
-#line 3277 "hexpr.parse.C"
+#line 3279 "hexpr.parse.C"
     break;
 
   case 63: /* instdef: "instance" cst "=>" id types  */
 #line 609 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-3].tconstraints),           *(yyvsp[-1].string), *(yyvsp[0].mtypes), MVarDefs(), m((yylsp[-4]), (yylsp[0]))); wantIndent(false); }
-#line 3283 "hexpr.parse.C"
+#line 3285 "hexpr.parse.C"
     break;
 
   case 64: /* instdef: "instance" id types "where" imembers  */
 #line 610 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(Constraints(), *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-4]), (yylsp[0])));        wantIndent(false); }
-#line 3289 "hexpr.parse.C"
+#line 3291 "hexpr.parse.C"
     break;
 
   case 65: /* instdef: "instance" cst "=>" id types "where" imembers  */
 #line 611 "hexpr.y"
                                                        { (yyval.mdef) = new InstanceDef(*(yyvsp[-5].tconstraints),           *(yyvsp[-3].string), *(yyvsp[-2].mtypes), *(yyvsp[0].mvdefs), m((yylsp[-6]), (yylsp[0])));        wantIndent(false); }
-#line 3295 "hexpr.parse.C"
+#line 3297 "hexpr.parse.C"
     break;
 
   case 66: /* imembers: imember  */
 #line 613 "hexpr.y"
                            { (yyval.mvdefs) = autorelease(new MVarDefs()); (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3301 "hexpr.parse.C"
+#line 3303 "hexpr.parse.C"
     break;
 
   case 67: /* imembers: imembers imember  */
 #line 614 "hexpr.y"
                            { (yyval.mvdefs) = (yyvsp[-1].mvdefs);                          (yyval.mvdefs)->push_back(MVarDefPtr((yyvsp[0].mvdef))); }
-#line 3307 "hexpr.parse.C"
+#line 3309 "hexpr.parse.C"
     break;
 
   case 68: /* imember: "indent" vardef  */
 #line 616 "hexpr.y"
                          { (yyval.mvdef) = (yyvsp[0].mvdef); }
-#line 3313 "hexpr.parse.C"
+#line 3315 "hexpr.parse.C"
     break;
 
   case 69: /* names: nameseq  */
 #line 619 "hexpr.y"
                { (yyval.strings) = (yyvsp[0].strings); }
-#line 3319 "hexpr.parse.C"
+#line 3321 "hexpr.parse.C"
     break;
 
   case 70: /* names: id opname id  */
 #line 621 "hexpr.y"
                     { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[-1].string)); (yyval.strings)->push_back(*(yyvsp[-2].string)); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3325 "hexpr.parse.C"
+#line 3327 "hexpr.parse.C"
     break;
 
   case 71: /* nameseq: name  */
 #line 623 "hexpr.y"
                       { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3331 "hexpr.parse.C"
+#line 3333 "hexpr.parse.C"
     break;
 
   case 72: /* nameseq: nameseq name  */
 #line 624 "hexpr.y"
                       { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3337 "hexpr.parse.C"
+#line 3339 "hexpr.parse.C"
     break;
 
   case 73: /* name: id  */
 #line 626 "hexpr.y"
          { (yyval.string) = (yyvsp[0].string); }
-#line 3343 "hexpr.parse.C"
+#line 3345 "hexpr.parse.C"
     break;
 
   case 74: /* name: "(" opname ")"  */
 #line 628 "hexpr.y"
                      { (yyval.string) = (yyvsp[-1].string); }
-#line 3349 "hexpr.parse.C"
+#line 3351 "hexpr.parse.C"
     break;
 
   case 75: /* opname: "and"  */
 #line 630 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("and")); }
-#line 3355 "hexpr.parse.C"
+#line 3357 "hexpr.parse.C"
     break;
 
   case 76: /* opname: "or"  */
 #line 631 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("or")); }
-#line 3361 "hexpr.parse.C"
+#line 3363 "hexpr.parse.C"
     break;
 
   case 77: /* opname: "o"  */
 #line 632 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3367 "hexpr.parse.C"
+#line 3369 "hexpr.parse.C"
     break;
 
   case 78: /* opname: "."  */
 #line 633 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("compose")); }
-#line 3373 "hexpr.parse.C"
+#line 3375 "hexpr.parse.C"
     break;
 
   case 79: /* opname: "~"  */
 #line 634 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("~")); }
-#line 3379 "hexpr.parse.C"
+#line 3381 "hexpr.parse.C"
     break;
 
   case 80: /* opname: "=~"  */
 #line 635 "hexpr.y"
                { (yyval.string) = autorelease(new std::string("=~")); }
-#line 3385 "hexpr.parse.C"
+#line 3387 "hexpr.parse.C"
     break;
 
   case 81: /* opname: "==="  */
 #line 636 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("===")); }
-#line 3391 "hexpr.parse.C"
+#line 3393 "hexpr.parse.C"
     break;
 
   case 82: /* opname: "=="  */
 #line 637 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("==")); }
-#line 3397 "hexpr.parse.C"
+#line 3399 "hexpr.parse.C"
     break;
 
   case 83: /* opname: "<"  */
 #line 638 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<")); }
-#line 3403 "hexpr.parse.C"
+#line 3405 "hexpr.parse.C"
     break;
 
   case 84: /* opname: "<="  */
 #line 639 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("<=")); }
-#line 3409 "hexpr.parse.C"
+#line 3411 "hexpr.parse.C"
     break;
 
   case 85: /* opname: ">"  */
 #line 640 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">")); }
-#line 3415 "hexpr.parse.C"
+#line 3417 "hexpr.parse.C"
     break;
 
   case 86: /* opname: ">="  */
 #line 641 "hexpr.y"
               { (yyval.string) = autorelease(new std::string(">=")); }
-#line 3421 "hexpr.parse.C"
+#line 3423 "hexpr.parse.C"
     break;
 
   case 87: /* opname: "in"  */
 #line 642 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("in")); }
-#line 3427 "hexpr.parse.C"
+#line 3429 "hexpr.parse.C"
     break;
 
   case 88: /* opname: "++"  */
 #line 643 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("append")); }
-#line 3433 "hexpr.parse.C"
+#line 3435 "hexpr.parse.C"
     break;
 
   case 89: /* opname: "+"  */
 #line 644 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("+")); }
-#line 3439 "hexpr.parse.C"
+#line 3441 "hexpr.parse.C"
     break;
 
   case 90: /* opname: "-"  */
 #line 645 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("-")); }
-#line 3445 "hexpr.parse.C"
+#line 3447 "hexpr.parse.C"
     break;
 
   case 91: /* opname: "*"  */
 #line 646 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("*")); }
-#line 3451 "hexpr.parse.C"
+#line 3453 "hexpr.parse.C"
     break;
 
   case 92: /* opname: "/"  */
 #line 647 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("/")); }
-#line 3457 "hexpr.parse.C"
+#line 3459 "hexpr.parse.C"
     break;
 
   case 93: /* opname: "%"  */
 #line 648 "hexpr.y"
               { (yyval.string) = autorelease(new std::string("%")); }
-#line 3463 "hexpr.parse.C"
+#line 3465 "hexpr.parse.C"
     break;
 
   case 94: /* idseq: id  */
 #line 650 "hexpr.y"
                 { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3469 "hexpr.parse.C"
+#line 3471 "hexpr.parse.C"
     break;
 
   case 95: /* idseq: idseq id  */
 #line 651 "hexpr.y"
                 { (yyval.strings) = (yyvsp[-1].strings);                          (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 3475 "hexpr.parse.C"
+#line 3477 "hexpr.parse.C"
     break;
 
   case 96: /* types: l0mtype  */
 #line 653 "hexpr.y"
                      { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3481 "hexpr.parse.C"
+#line 3483 "hexpr.parse.C"
     break;
 
   case 97: /* types: types l0mtype  */
 #line 654 "hexpr.y"
                      { (yyval.mtypes) = (yyvsp[-1].mtypes);                           (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 3487 "hexpr.parse.C"
+#line 3489 "hexpr.parse.C"
     break;
 
   case 98: /* l0expr: "\\" patterns "." l0expr  */
 #line 657 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3493 "hexpr.parse.C"
+#line 3495 "hexpr.parse.C"
     break;
 
   case 99: /* l0expr: "fn" patterns "." l0expr  */
 #line 658 "hexpr.y"
                                  { (yyval.exp) = makePatternFn(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3499 "hexpr.parse.C"
+#line 3501 "hexpr.parse.C"
     break;
 
   case 100: /* l0expr: lhexpr "<-" lhexpr  */
 #line 659 "hexpr.y"
                                  { (yyval.exp) = new Assign(ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-2]), (yylsp[0]))); }
-#line 3505 "hexpr.parse.C"
+#line 3507 "hexpr.parse.C"
     break;
 
   case 101: /* l0expr: lhexpr  */
 #line 660 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3511 "hexpr.parse.C"
+#line 3513 "hexpr.parse.C"
     break;
 
   case 102: /* lhexpr: "!" l1expr  */
 #line 662 "hexpr.y"
                                  { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), (yyvsp[0].exp), m((yylsp[-1]),(yylsp[0]))); }
-#line 3517 "hexpr.parse.C"
+#line 3519 "hexpr.parse.C"
     break;
 
   case 103: /* lhexpr: lhexpr "and" lhexpr  */
 #line 663 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("and",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3523 "hexpr.parse.C"
+#line 3525 "hexpr.parse.C"
     break;
 
   case 104: /* lhexpr: lhexpr "or" lhexpr  */
 #line 664 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("or",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3529 "hexpr.parse.C"
+#line 3531 "hexpr.parse.C"
     break;
 
   case 105: /* lhexpr: lhexpr "o" lhexpr  */
 #line 665 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("compose",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3535 "hexpr.parse.C"
+#line 3537 "hexpr.parse.C"
     break;
 
   case 106: /* lhexpr: l1expr "in" l1expr  */
 #line 666 "hexpr.y"
                                  { (yyval.exp) = TAPP2(var("in",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3541 "hexpr.parse.C"
+#line 3543 "hexpr.parse.C"
     break;
 
   case 107: /* lhexpr: l1expr  */
 #line 667 "hexpr.y"
                                  { (yyval.exp) = (yyvsp[0].exp); }
-#line 3547 "hexpr.parse.C"
+#line 3549 "hexpr.parse.C"
     break;
 
   case 108: /* l1expr: "if" l0expr "then" l0expr "else" l0expr  */
 #line 669 "hexpr.y"
                                                 { (yyval.exp) = TAPP3(var("if",m((yylsp[-5]))), (yyvsp[-4].exp), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-5]), (yylsp[0]))); }
-#line 3553 "hexpr.parse.C"
+#line 3555 "hexpr.parse.C"
     break;
 
   case 109: /* l1expr: l2expr  */
 #line 670 "hexpr.y"
                                                 { (yyval.exp) = (yyvsp[0].exp); }
-#line 3559 "hexpr.parse.C"
+#line 3561 "hexpr.parse.C"
     break;
 
   case 110: /* l2expr: l2expr "~" l2expr  */
 #line 672 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("~",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3565 "hexpr.parse.C"
+#line 3567 "hexpr.parse.C"
     break;
 
   case 111: /* l2expr: l2expr "===" l2expr  */
 #line 673 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("===",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3571 "hexpr.parse.C"
+#line 3573 "hexpr.parse.C"
     break;
 
   case 112: /* l2expr: l2expr "==" l2expr  */
 #line 674 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3577 "hexpr.parse.C"
+#line 3579 "hexpr.parse.C"
     break;
 
   case 113: /* l2expr: l2expr "!=" l2expr  */
 #line 675 "hexpr.y"
                             { (yyval.exp) = TAPP1(var("not",m((yylsp[-1]))), TAPP2(var("==",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))), m((yylsp[-2]),(yylsp[0]))); }
-#line 3583 "hexpr.parse.C"
+#line 3585 "hexpr.parse.C"
     break;
 
   case 114: /* l2expr: l2expr "<" l2expr  */
 #line 676 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3589 "hexpr.parse.C"
+#line 3591 "hexpr.parse.C"
     break;
 
   case 115: /* l2expr: l2expr "<=" l2expr  */
 #line 677 "hexpr.y"
                             { (yyval.exp) = TAPP2(var("<=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3595 "hexpr.parse.C"
+#line 3597 "hexpr.parse.C"
     break;
 
   case 116: /* l2expr: l2expr ">" l2expr  */
 #line 678 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">",m((yylsp[-1]))),  (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3601 "hexpr.parse.C"
+#line 3603 "hexpr.parse.C"
     break;
 
   case 117: /* l2expr: l2expr ">=" l2expr  */
 #line 679 "hexpr.y"
                             { (yyval.exp) = TAPP2(var(">=",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3607 "hexpr.parse.C"
+#line 3609 "hexpr.parse.C"
     break;
 
   case 118: /* l2expr: l3expr  */
 #line 680 "hexpr.y"
                             { (yyval.exp) = (yyvsp[0].exp); }
-#line 3613 "hexpr.parse.C"
+#line 3615 "hexpr.parse.C"
     break;
 
   case 119: /* l3expr: l3expr "+" l3expr  */
 #line 682 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("+",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3619 "hexpr.parse.C"
+#line 3621 "hexpr.parse.C"
     break;
 
   case 120: /* l3expr: l3expr "-" l3expr  */
 #line 683 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("-",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3625 "hexpr.parse.C"
+#line 3627 "hexpr.parse.C"
     break;
 
   case 121: /* l3expr: l3expr "++" l3expr  */
 #line 684 "hexpr.y"
                            { (yyval.exp) = TAPP2(var("append",m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]),(yylsp[0]))); }
-#line 3631 "hexpr.parse.C"
+#line 3633 "hexpr.parse.C"
     break;
 
   case 122: /* l3expr: "-" l3expr  */
 #line 685 "hexpr.y"
                            { (yyval.exp) = TAPP1(var("neg",m((yylsp[-1]))), ExprPtr((yyvsp[0].exp)), m((yylsp[-1]),(yylsp[0]))); }
-#line 3637 "hexpr.parse.C"
+#line 3639 "hexpr.parse.C"
     break;
 
   case 123: /* l3expr: l4expr  */
 #line 686 "hexpr.y"
                            { (yyval.exp) = (yyvsp[0].exp); }
-#line 3643 "hexpr.parse.C"
+#line 3645 "hexpr.parse.C"
     break;
 
   case 124: /* l4expr: l4expr "*" l4expr  */
 #line 688 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("*", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3649 "hexpr.parse.C"
+#line 3651 "hexpr.parse.C"
     break;
 
   case 125: /* l4expr: l4expr "/" l4expr  */
 #line 689 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("/", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3655 "hexpr.parse.C"
+#line 3657 "hexpr.parse.C"
     break;
 
   case 126: /* l4expr: l4expr "%" l4expr  */
 #line 690 "hexpr.y"
                           { (yyval.exp) = TAPP2(var("%", m((yylsp[-1]))), (yyvsp[-2].exp), (yyvsp[0].exp), m((yylsp[-2]), (yylsp[0]))); }
-#line 3661 "hexpr.parse.C"
+#line 3663 "hexpr.parse.C"
     break;
 
   case 127: /* l4expr: l5expr  */
 #line 691 "hexpr.y"
                           { (yyval.exp) = (yyvsp[0].exp); }
-#line 3667 "hexpr.parse.C"
+#line 3669 "hexpr.parse.C"
     break;
 
   case 128: /* l5expr: l6expr  */
 #line 693 "hexpr.y"
                { (yyval.exp) = (yyvsp[0].exp); }
-#line 3673 "hexpr.parse.C"
+#line 3675 "hexpr.parse.C"
     break;
 
   case 129: /* l5expr: "let" letbindings "in" l0expr  */
 #line 696 "hexpr.y"
                                       { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-2].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3679 "hexpr.parse.C"
+#line 3681 "hexpr.parse.C"
     break;
 
   case 130: /* l5expr: "let" letbindings ";" "in" l0expr  */
 #line 697 "hexpr.y"
                                           { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[0].exp)), m((yylsp[-4]),(yylsp[0])))->clone(); }
-#line 3685 "hexpr.parse.C"
+#line 3687 "hexpr.parse.C"
     break;
 
   case 131: /* l5expr: "match" l6exprs "with" patternexps  */
 #line 700 "hexpr.y"
                                            { (yyval.exp) = compileMatch(yyParseCC, *(yyvsp[-2].exps), normPatternRules(*(yyvsp[0].patternexps), m((yylsp[-3]),(yylsp[0]))), m((yylsp[-3]),(yylsp[0])))->clone(); }
-#line 3691 "hexpr.parse.C"
+#line 3693 "hexpr.parse.C"
     break;
 
   case 132: /* l5expr: l6expr "matches" pattern  */
 #line 703 "hexpr.y"
                                  { (yyval.exp) = compileMatchTest(yyParseCC, ExprPtr((yyvsp[-2].exp)), PatternPtr((yyvsp[0].pattern)), m((yylsp[-2]),(yylsp[0])))->clone(); }
-#line 3697 "hexpr.parse.C"
+#line 3699 "hexpr.parse.C"
     break;
 
   case 133: /* l5expr: "parse" "{" prules "}"  */
@@ -3708,907 +3710,907 @@ yyreduce:
           throw annotated_error(m((yylsp[-3]),(yylsp[0])), ss.str());
         }
       }
-#line 3712 "hexpr.parse.C"
+#line 3714 "hexpr.parse.C"
     break;
 
   case 134: /* l5expr: "do" "{" dobindings "}"  */
 #line 718 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-1].letbindings), ExprPtr(new Unit(m((yylsp[-3]),(yylsp[0])))), m((yylsp[-3]),(yylsp[0]))); }
-#line 3718 "hexpr.parse.C"
+#line 3720 "hexpr.parse.C"
     break;
 
   case 135: /* l5expr: "do" "{" dobindings "return" l0expr "}"  */
 #line 719 "hexpr.y"
                                                 { (yyval.exp) = compileNestedLetMatch(*(yyvsp[-3].letbindings), ExprPtr((yyvsp[-1].exp)), m((yylsp[-5]),(yylsp[0]))); }
-#line 3724 "hexpr.parse.C"
+#line 3726 "hexpr.parse.C"
     break;
 
   case 136: /* l5expr: l6expr "::" qtype  */
 #line 722 "hexpr.y"
                                 { (yyval.exp) = new Assump(ExprPtr((yyvsp[-2].exp)), QualTypePtr((yyvsp[0].qualtype)), m((yylsp[-2]),(yylsp[0]))); }
-#line 3730 "hexpr.parse.C"
+#line 3732 "hexpr.parse.C"
     break;
 
   case 137: /* letbindings: letbindings ";" letbinding  */
 #line 724 "hexpr.y"
                                         { (yyvsp[-2].letbindings)->push_back(*(yyvsp[0].letbinding)); (yyval.letbindings) = (yyvsp[-2].letbindings); }
-#line 3736 "hexpr.parse.C"
+#line 3738 "hexpr.parse.C"
     break;
 
   case 138: /* letbindings: letbinding  */
 #line 725 "hexpr.y"
                                         { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3742 "hexpr.parse.C"
+#line 3744 "hexpr.parse.C"
     break;
 
   case 139: /* letbinding: irrefutablep "=" l1expr  */
 #line 727 "hexpr.y"
                                     { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-2].pattern)), ExprPtr((yyvsp[0].exp)))); }
-#line 3748 "hexpr.parse.C"
+#line 3750 "hexpr.parse.C"
     break;
 
   case 140: /* dobindings: dobindings dobinding  */
 #line 729 "hexpr.y"
                                  { (yyval.letbindings) = (yyvsp[-1].letbindings); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3754 "hexpr.parse.C"
+#line 3756 "hexpr.parse.C"
     break;
 
   case 141: /* dobindings: dobinding  */
 #line 730 "hexpr.y"
                                  { (yyval.letbindings) = autorelease(new LetBindings()); (yyval.letbindings)->push_back(*(yyvsp[0].letbinding)); }
-#line 3760 "hexpr.parse.C"
+#line 3762 "hexpr.parse.C"
     break;
 
   case 142: /* dobinding: irrefutablep "=" l0expr ";"  */
 #line 732 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr((yyvsp[-3].pattern)), ExprPtr((yyvsp[-1].exp)))); }
-#line 3766 "hexpr.parse.C"
+#line 3768 "hexpr.parse.C"
     break;
 
   case 143: /* dobinding: l0expr ";"  */
 #line 733 "hexpr.y"
                                        { (yyval.letbinding) = autorelease(new LetBinding(PatternPtr(new MatchAny("_",m((yylsp[-1])))), ExprPtr((yyvsp[-1].exp)))); }
-#line 3772 "hexpr.parse.C"
+#line 3774 "hexpr.parse.C"
     break;
 
   case 144: /* cselconds: cselconds "," lhexpr  */
 #line 735 "hexpr.y"
                                 { (yyval.exps) = (yyvsp[-2].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3778 "hexpr.parse.C"
+#line 3780 "hexpr.parse.C"
     break;
 
   case 145: /* cselconds: lhexpr  */
 #line 736 "hexpr.y"
                                 { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 3784 "hexpr.parse.C"
+#line 3786 "hexpr.parse.C"
     break;
 
   case 146: /* cselection: pattern "<-" l0expr "," cselconds  */
 #line 738 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-4].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[-2].exp)); (yyval.cselection)->conds = *(yyvsp[0].exps); }
-#line 3790 "hexpr.parse.C"
+#line 3792 "hexpr.parse.C"
     break;
 
   case 147: /* cselection: pattern "<-" l0expr  */
 #line 739 "hexpr.y"
                                               { (yyval.cselection) = new CSelection(); (yyval.cselection)->pat = PatternPtr((yyvsp[-2].pattern)); (yyval.cselection)->seq = ExprPtr((yyvsp[0].exp)); }
-#line 3796 "hexpr.parse.C"
+#line 3798 "hexpr.parse.C"
     break;
 
   case 148: /* cselections: cselections "|" cselection  */
 #line 741 "hexpr.y"
                                         { (yyval.cselections) = (yyvsp[-2].cselections); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3802 "hexpr.parse.C"
+#line 3804 "hexpr.parse.C"
     break;
 
   case 149: /* cselections: cselection  */
 #line 742 "hexpr.y"
                                         { (yyval.cselections) = autorelease(new CSelections()); (yyval.cselections)->push_back(CSelectionPtr((yyvsp[0].cselection))); }
-#line 3808 "hexpr.parse.C"
+#line 3810 "hexpr.parse.C"
     break;
 
   case 150: /* l6expr: l6expr "(" cargs ")"  */
 #line 745 "hexpr.y"
                                 { (yyval.exp) = new App(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].exps), m((yylsp[-3]), (yylsp[0]))); }
-#line 3814 "hexpr.parse.C"
+#line 3816 "hexpr.parse.C"
     break;
 
   case 151: /* l6expr: id  */
 #line 746 "hexpr.y"
                                 { (yyval.exp) = varCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 3820 "hexpr.parse.C"
+#line 3822 "hexpr.parse.C"
     break;
 
   case 152: /* l6expr: "[" l0expr ".." l0expr "]"  */
 #line 749 "hexpr.y"
                                                           { (yyval.exp) = new App(var("range", m((yylsp[-2]))), list(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3826 "hexpr.parse.C"
+#line 3828 "hexpr.parse.C"
     break;
 
   case 153: /* l6expr: "[" l0expr ".." "]"  */
 #line 750 "hexpr.y"
                                                           { (yyval.exp) = new App(var("iterateS", m((yylsp[-1]))), list(ExprPtr((yyvsp[-2].exp)), fn(str::strings(".x"), fncall(var("+", m((yylsp[-1]))), list(var(".x", m((yylsp[-1]))), ExprPtr(new Int(1, m((yylsp[-1]))))), m((yylsp[-1]))), m((yylsp[-1])))), m((yylsp[-3]), (yylsp[0]))); }
-#line 3832 "hexpr.parse.C"
+#line 3834 "hexpr.parse.C"
     break;
 
   case 154: /* l6expr: "[" l0expr "|" cselections "]"  */
 #line 751 "hexpr.y"
                                                           { (yyval.exp) = desugarComprehension(yyParseCC, ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].cselections), m((yylsp[-4]), (yylsp[0]))); }
-#line 3838 "hexpr.parse.C"
+#line 3840 "hexpr.parse.C"
     break;
 
   case 155: /* l6expr: "[" cargs "]"  */
 #line 752 "hexpr.y"
                                                           { (yyval.exp) = new MkArray(*(yyvsp[-1].exps), m((yylsp[-2]), (yylsp[0]))); }
-#line 3844 "hexpr.parse.C"
+#line 3846 "hexpr.parse.C"
     break;
 
   case 156: /* l6expr: l6expr "[" "timeV" "]"  */
 #line 753 "hexpr.y"
                                                           { (yyval.exp) = maybeArraySliceWithTime(ExprPtr((yyvsp[-3].exp)), *(yyvsp[-1].string), m((yylsp[-3]), (yylsp[0]))); }
-#line 3850 "hexpr.parse.C"
+#line 3852 "hexpr.parse.C"
     break;
 
   case 157: /* l6expr: l6expr "[" l0expr "]"  */
 #line 754 "hexpr.y"
                                                           { (yyval.exp) = mkAIndex(ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-3]), (yylsp[0]))); }
-#line 3856 "hexpr.parse.C"
+#line 3858 "hexpr.parse.C"
     break;
 
   case 158: /* l6expr: l6expr "[" l0expr ":" l0expr "]"  */
 #line 755 "hexpr.y"
                                                           { (yyval.exp) = new App(var("slice", m((yylsp[-2]))), list(ExprPtr((yyvsp[-5].exp)), ExprPtr((yyvsp[-3].exp)), ExprPtr((yyvsp[-1].exp))), m((yylsp[-5]), (yylsp[0]))); }
-#line 3862 "hexpr.parse.C"
+#line 3864 "hexpr.parse.C"
     break;
 
   case 159: /* l6expr: l6expr "[" l0expr ":" "]"  */
 #line 756 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-1]))), list(var(vn,m((yylsp[-4]))), ExprPtr((yyvsp[-2].exp)), fncall(var("size",m((yylsp[-1]))), list(var(vn,m((yylsp[-4])))),m((yylsp[-4])))),m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3868 "hexpr.parse.C"
+#line 3870 "hexpr.parse.C"
     break;
 
   case 160: /* l6expr: l6expr "[" ":" l0expr "]"  */
 #line 757 "hexpr.y"
                                                           { std::string vn = freshName(); (yyval.exp) = new Let(vn, ExprPtr((yyvsp[-4].exp)), fncall(var("slice",m((yylsp[-2]))), list(var(vn,m((yylsp[-4]))), fncall(var("size",m((yylsp[-2]))), list(var(vn,m((yylsp[-2])))),m((yylsp[-4]))), ExprPtr((yyvsp[-1].exp))), m((yylsp[-4]),(yylsp[0]))), m((yylsp[-4]), (yylsp[0]))); }
-#line 3874 "hexpr.parse.C"
+#line 3876 "hexpr.parse.C"
     break;
 
   case 161: /* l6expr: "|" id "=" l0expr "|"  */
 #line 760 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-3].string), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3880 "hexpr.parse.C"
+#line 3882 "hexpr.parse.C"
     break;
 
   case 162: /* l6expr: "|" "intV" "=" l0expr "|"  */
 #line 761 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(".f" + str::from((yyvsp[-3].intv)), ExprPtr((yyvsp[-1].exp)), m((yylsp[-4]), (yylsp[0]))); }
-#line 3886 "hexpr.parse.C"
+#line 3888 "hexpr.parse.C"
     break;
 
   case 163: /* l6expr: "|" id "|"  */
 #line 762 "hexpr.y"
                                                               { (yyval.exp) = new MkVariant(*(yyvsp[-1].string), ExprPtr(new Unit(m((yylsp[-1])))), m((yylsp[-2]), (yylsp[0]))); }
-#line 3892 "hexpr.parse.C"
+#line 3894 "hexpr.parse.C"
     break;
 
   case 164: /* l6expr: "case" l0expr "of" "|" varfields "|"  */
 #line 763 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-4].exp)), *(yyvsp[-1].vfields), m((yylsp[-5]), (yylsp[0]))); }
-#line 3898 "hexpr.parse.C"
+#line 3900 "hexpr.parse.C"
     break;
 
   case 165: /* l6expr: "case" l0expr "of" "|" varfields "|" "default" l0expr  */
 #line 764 "hexpr.y"
                                                               { (yyval.exp) = new Case(ExprPtr((yyvsp[-6].exp)), *(yyvsp[-3].vfields), ExprPtr((yyvsp[0].exp)), m((yylsp[-7]), (yylsp[0]))); }
-#line 3904 "hexpr.parse.C"
+#line 3906 "hexpr.parse.C"
     break;
 
   case 166: /* l6expr: "{" recfields "}"  */
 #line 767 "hexpr.y"
                               { if ((yyvsp[-1].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-1].rfields), m((yylsp[-2]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-2]), (yylsp[0]))); } }
-#line 3910 "hexpr.parse.C"
+#line 3912 "hexpr.parse.C"
     break;
 
   case 167: /* l6expr: "{" recfields "," "}"  */
 #line 768 "hexpr.y"
                               { if ((yyvsp[-2].rfields)->size() > 0) { (yyval.exp) = new MkRecord(*(yyvsp[-2].rfields), m((yylsp[-3]), (yylsp[0]))); } else { (yyval.exp) = new Unit(m((yylsp[-3]), (yylsp[0]))); } }
-#line 3916 "hexpr.parse.C"
+#line 3918 "hexpr.parse.C"
     break;
 
   case 168: /* l6expr: l6expr recfieldpath  */
 #line 769 "hexpr.y"
                               { (yyval.exp) = makeProjSeq((yyvsp[-1].exp), *(yyvsp[0].strings), m((yylsp[-1]), (yylsp[0]))); }
-#line 3922 "hexpr.parse.C"
+#line 3924 "hexpr.parse.C"
     break;
 
   case 169: /* l6expr: recfieldpath  */
 #line 772 "hexpr.y"
                      { (yyval.exp) = new Fn(str::strings("x"), proj(var("x", m((yylsp[0]))), *(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 3928 "hexpr.parse.C"
+#line 3930 "hexpr.parse.C"
     break;
 
   case 170: /* l6expr: "regexV"  */
 #line 775 "hexpr.y"
                  { (yyval.exp) = compileRegexFn(yyParseCC, std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0])))->clone(); }
-#line 3934 "hexpr.parse.C"
+#line 3936 "hexpr.parse.C"
     break;
 
   case 171: /* l6expr: "pack" l6expr  */
 #line 778 "hexpr.y"
                                            { (yyval.exp) = new Pack(ExprPtr((yyvsp[0].exp)), m((yylsp[-1]), (yylsp[0]))); }
-#line 3940 "hexpr.parse.C"
+#line 3942 "hexpr.parse.C"
     break;
 
   case 172: /* l6expr: "unpack" id "=" l6expr "in" l6expr  */
 #line 779 "hexpr.y"
                                            { (yyval.exp) = new Unpack(*(yyvsp[-4].string), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)), m((yylsp[-5]), (yylsp[0]))); }
-#line 3946 "hexpr.parse.C"
+#line 3948 "hexpr.parse.C"
     break;
 
   case 173: /* l6expr: "boolV"  */
 #line 782 "hexpr.y"
                     { (yyval.exp) = new Bool((yyvsp[0].boolv), m((yylsp[0]))); }
-#line 3952 "hexpr.parse.C"
+#line 3954 "hexpr.parse.C"
     break;
 
   case 174: /* l6expr: "charV"  */
 #line 783 "hexpr.y"
                     { (yyval.exp) = new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3958 "hexpr.parse.C"
+#line 3960 "hexpr.parse.C"
     break;
 
   case 175: /* l6expr: "byteV"  */
 #line 784 "hexpr.y"
                     { (yyval.exp) = new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3964 "hexpr.parse.C"
+#line 3966 "hexpr.parse.C"
     break;
 
   case 176: /* l6expr: "bytesV"  */
 #line 785 "hexpr.y"
                     { (yyval.exp) = mkarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 3970 "hexpr.parse.C"
+#line 3972 "hexpr.parse.C"
     break;
 
   case 177: /* l6expr: "shortV"  */
 #line 786 "hexpr.y"
                     { (yyval.exp) = new Short((yyvsp[0].shortv), m((yylsp[0]))); }
-#line 3976 "hexpr.parse.C"
+#line 3978 "hexpr.parse.C"
     break;
 
   case 178: /* l6expr: "intV"  */
 #line 787 "hexpr.y"
                     { (yyval.exp) = new Int((yyvsp[0].intv), m((yylsp[0]))); }
-#line 3982 "hexpr.parse.C"
+#line 3984 "hexpr.parse.C"
     break;
 
   case 179: /* l6expr: "longV"  */
 #line 788 "hexpr.y"
                     { (yyval.exp) = new Long((yyvsp[0].longv), m((yylsp[0]))); }
-#line 3988 "hexpr.parse.C"
+#line 3990 "hexpr.parse.C"
     break;
 
   case 180: /* l6expr: "int128V"  */
 #line 789 "hexpr.y"
                     { (yyval.exp) = new Int128((yyvsp[0].int128v), m((yylsp[0]))); }
-#line 3994 "hexpr.parse.C"
+#line 3996 "hexpr.parse.C"
     break;
 
   case 181: /* l6expr: "floatV"  */
 #line 790 "hexpr.y"
                     { (yyval.exp) = new Float((yyvsp[0].floatv), m((yylsp[0]))); }
-#line 4000 "hexpr.parse.C"
+#line 4002 "hexpr.parse.C"
     break;
 
   case 182: /* l6expr: "doubleV"  */
 #line 791 "hexpr.y"
                     { (yyval.exp) = new Double((yyvsp[0].doublev), m((yylsp[0]))); }
-#line 4006 "hexpr.parse.C"
+#line 4008 "hexpr.parse.C"
     break;
 
   case 183: /* l6expr: "stringV"  */
 #line 792 "hexpr.y"
                     { (yyval.exp) = mkarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4012 "hexpr.parse.C"
+#line 4014 "hexpr.parse.C"
     break;
 
   case 184: /* l6expr: tsseq  */
 #line 793 "hexpr.y"
                     { (yyval.exp) = mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0])))->clone(); }
-#line 4018 "hexpr.parse.C"
+#line 4020 "hexpr.parse.C"
     break;
 
   case 185: /* l6expr: "timeV"  */
 #line 794 "hexpr.y"
                     { (yyval.exp) = mkTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 4024 "hexpr.parse.C"
+#line 4026 "hexpr.parse.C"
     break;
 
   case 186: /* l6expr: "dateTimeV"  */
 #line 795 "hexpr.y"
                     { (yyval.exp) = mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0])))->clone(); }
-#line 4030 "hexpr.parse.C"
+#line 4032 "hexpr.parse.C"
     break;
 
   case 187: /* l6expr: "(" cargs ")"  */
 #line 798 "hexpr.y"
                       { (yyval.exp) = pickNestedExp((yyvsp[-1].exps), m((yylsp[-2]),(yylsp[0]))); }
-#line 4036 "hexpr.parse.C"
+#line 4038 "hexpr.parse.C"
     break;
 
   case 188: /* l6expr: "(" "++" ")"  */
 #line 801 "hexpr.y"
                       { (yyval.exp) = new Var("append", m((yylsp[-1]))); }
-#line 4042 "hexpr.parse.C"
+#line 4044 "hexpr.parse.C"
     break;
 
   case 189: /* l6expr: "(" "+" ")"  */
 #line 802 "hexpr.y"
                       { (yyval.exp) = new Var("+",      m((yylsp[-1]))); }
-#line 4048 "hexpr.parse.C"
+#line 4050 "hexpr.parse.C"
     break;
 
   case 190: /* l6expr: "(" "-" ")"  */
 #line 803 "hexpr.y"
                       { (yyval.exp) = new Var("-",      m((yylsp[-1]))); }
-#line 4054 "hexpr.parse.C"
+#line 4056 "hexpr.parse.C"
     break;
 
   case 191: /* l6expr: "(" "*" ")"  */
 #line 804 "hexpr.y"
                       { (yyval.exp) = new Var("*",      m((yylsp[-1]))); }
-#line 4060 "hexpr.parse.C"
+#line 4062 "hexpr.parse.C"
     break;
 
   case 192: /* l6expr: "(" "/" ")"  */
 #line 805 "hexpr.y"
                       { (yyval.exp) = new Var("/",      m((yylsp[-1]))); }
-#line 4066 "hexpr.parse.C"
+#line 4068 "hexpr.parse.C"
     break;
 
   case 193: /* l6expr: "(" "%" ")"  */
 #line 806 "hexpr.y"
                       { (yyval.exp) = new Var("%",      m((yylsp[-1]))); }
-#line 4072 "hexpr.parse.C"
+#line 4074 "hexpr.parse.C"
     break;
 
   case 194: /* l6expr: "(" "~" ")"  */
 #line 807 "hexpr.y"
                       { (yyval.exp) = new Var("~",      m((yylsp[-1]))); }
-#line 4078 "hexpr.parse.C"
+#line 4080 "hexpr.parse.C"
     break;
 
   case 195: /* l6expr: "(" "===" ")"  */
 #line 808 "hexpr.y"
                       { (yyval.exp) = new Var("===",    m((yylsp[-1]))); }
-#line 4084 "hexpr.parse.C"
+#line 4086 "hexpr.parse.C"
     break;
 
   case 196: /* l6expr: "(" "==" ")"  */
 #line 809 "hexpr.y"
                       { (yyval.exp) = new Var("==",     m((yylsp[-1]))); }
-#line 4090 "hexpr.parse.C"
+#line 4092 "hexpr.parse.C"
     break;
 
   case 197: /* l6expr: "(" "!=" ")"  */
 #line 810 "hexpr.y"
                       { (yyval.exp) = new Var("!=",     m((yylsp[-1]))); }
-#line 4096 "hexpr.parse.C"
+#line 4098 "hexpr.parse.C"
     break;
 
   case 198: /* l6expr: "(" "<" ")"  */
 #line 811 "hexpr.y"
                       { (yyval.exp) = new Var("<",      m((yylsp[-1]))); }
-#line 4102 "hexpr.parse.C"
+#line 4104 "hexpr.parse.C"
     break;
 
   case 199: /* l6expr: "(" ">" ")"  */
 #line 812 "hexpr.y"
                       { (yyval.exp) = new Var(">",      m((yylsp[-1]))); }
-#line 4108 "hexpr.parse.C"
+#line 4110 "hexpr.parse.C"
     break;
 
   case 200: /* l6expr: "(" ">=" ")"  */
 #line 813 "hexpr.y"
                       { (yyval.exp) = new Var(">=",     m((yylsp[-1]))); }
-#line 4114 "hexpr.parse.C"
+#line 4116 "hexpr.parse.C"
     break;
 
   case 201: /* l6expr: "(" "<=" ")"  */
 #line 814 "hexpr.y"
                       { (yyval.exp) = new Var("<=",     m((yylsp[-1]))); }
-#line 4120 "hexpr.parse.C"
+#line 4122 "hexpr.parse.C"
     break;
 
   case 202: /* l6expr: "(" "and" ")"  */
 #line 815 "hexpr.y"
                       { (yyval.exp) = new Var("and",    m((yylsp[-1]))); }
-#line 4126 "hexpr.parse.C"
+#line 4128 "hexpr.parse.C"
     break;
 
   case 203: /* l6expr: "(" "or" ")"  */
 #line 816 "hexpr.y"
                       { (yyval.exp) = new Var("or",     m((yylsp[-1]))); }
-#line 4132 "hexpr.parse.C"
+#line 4134 "hexpr.parse.C"
     break;
 
   case 204: /* l6expr: "(" "in" ")"  */
 #line 817 "hexpr.y"
                       { (yyval.exp) = new Var("in",     m((yylsp[-1]))); }
-#line 4138 "hexpr.parse.C"
+#line 4140 "hexpr.parse.C"
     break;
 
   case 205: /* l6expr: "(" "!" ")"  */
 #line 818 "hexpr.y"
                       { (yyval.exp) = new Var("not",    m((yylsp[-1]))); }
-#line 4144 "hexpr.parse.C"
+#line 4146 "hexpr.parse.C"
     break;
 
   case 206: /* l6expr: "`" l0expr "`"  */
 #line 821 "hexpr.y"
                        { (yyval.exp) = new Assump(fncall(var("unsafeCast", m((yylsp[-1]))), list(mktunit(m((yylsp[-1])))), m((yylsp[-1]))), qualtype(tapp(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp)))))), m((yylsp[-1]))); }
-#line 4150 "hexpr.parse.C"
+#line 4152 "hexpr.parse.C"
     break;
 
   case 207: /* prules: prules prule  */
 #line 823 "hexpr.y"
                      { (yyval.prules) = (yyvsp[-1].prules); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4156 "hexpr.parse.C"
+#line 4158 "hexpr.parse.C"
     break;
 
   case 208: /* prules: prule  */
 #line 824 "hexpr.y"
                      { (yyval.prules) = autorelease(new Grammar()); (yyval.prules)->push_back(*(yyvsp[0].prule)); }
-#line 4162 "hexpr.parse.C"
+#line 4164 "hexpr.parse.C"
     break;
 
   case 209: /* prule: id ":=" prdefs  */
 #line 826 "hexpr.y"
                       { (yyval.prule) = autorelease(new Grammar::value_type(*(yyvsp[-2].string), *(yyvsp[0].prdefs))); }
-#line 4168 "hexpr.parse.C"
+#line 4170 "hexpr.parse.C"
     break;
 
   case 210: /* prdefs: prdefs "|" prdef  */
 #line 828 "hexpr.y"
                          { (yyval.prdefs) = (yyvsp[-2].prdefs); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4174 "hexpr.parse.C"
+#line 4176 "hexpr.parse.C"
     break;
 
   case 211: /* prdefs: prdef  */
 #line 829 "hexpr.y"
                          { (yyval.prdefs) = autorelease(new GrammarRules()); (yyval.prdefs)->push_back(*(yyvsp[0].prdef)); }
-#line 4180 "hexpr.parse.C"
+#line 4182 "hexpr.parse.C"
     break;
 
   case 212: /* prdef: pbelems "{" l0expr "}"  */
 #line 831 "hexpr.y"
                               { (yyval.prdef) = autorelease(new GrammarRule(*(yyvsp[-3].pbelems), ExprPtr((yyvsp[-1].exp)))); }
-#line 4186 "hexpr.parse.C"
+#line 4188 "hexpr.parse.C"
     break;
 
   case 213: /* pbelems: pbelems pbelem  */
 #line 833 "hexpr.y"
                         { (yyval.pbelems) = (yyvsp[-1].pbelems); (yyval.pbelems)->push_back(*(yyvsp[0].pbelem)); }
-#line 4192 "hexpr.parse.C"
+#line 4194 "hexpr.parse.C"
     break;
 
   case 214: /* pbelems: %empty  */
 #line 834 "hexpr.y"
                         { (yyval.pbelems) = autorelease(new BoundGrammarValues()); }
-#line 4198 "hexpr.parse.C"
+#line 4200 "hexpr.parse.C"
     break;
 
   case 215: /* pbelem: id ":" pvalue  */
 #line 836 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue(*(yyvsp[-2].string), GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4204 "hexpr.parse.C"
+#line 4206 "hexpr.parse.C"
     break;
 
   case 216: /* pbelem: pvalue  */
 #line 837 "hexpr.y"
                       { (yyval.pbelem) = autorelease(new BoundGrammarValue("_", GrammarValuePtr((yyvsp[0].pvalue)))); }
-#line 4210 "hexpr.parse.C"
+#line 4212 "hexpr.parse.C"
     break;
 
   case 217: /* pvalue: id  */
 #line 839 "hexpr.y"
                       { (yyval.pvalue) = new GSymRef(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4216 "hexpr.parse.C"
+#line 4218 "hexpr.parse.C"
     break;
 
   case 218: /* pvalue: "stringV"  */
 #line 840 "hexpr.y"
                       { (yyval.pvalue) = new GStr(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4222 "hexpr.parse.C"
+#line 4224 "hexpr.parse.C"
     break;
 
   case 219: /* pvalue: "charV"  */
 #line 841 "hexpr.y"
                       { (yyval.pvalue) = new GStr(std::string(1, str::readCharDef(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4228 "hexpr.parse.C"
+#line 4230 "hexpr.parse.C"
     break;
 
   case 220: /* tsseq: "timespanV"  */
 #line 843 "hexpr.y"
                          { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4234 "hexpr.parse.C"
+#line 4236 "hexpr.parse.C"
     break;
 
   case 221: /* tsseq: tsseq "timespanV"  */
 #line 844 "hexpr.y"
                          { (yyval.strings) = (yyvsp[-1].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4240 "hexpr.parse.C"
+#line 4242 "hexpr.parse.C"
     break;
 
   case 222: /* l6exprs: l6exprs l6expr  */
 #line 846 "hexpr.y"
                         { (yyval.exps) = (yyvsp[-1].exps); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4246 "hexpr.parse.C"
+#line 4248 "hexpr.parse.C"
     break;
 
   case 223: /* l6exprs: l6expr  */
 #line 847 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4252 "hexpr.parse.C"
+#line 4254 "hexpr.parse.C"
     break;
 
   case 224: /* patternexps: patternexps patternexp  */
 #line 849 "hexpr.y"
                                     { (yyval.patternexps) = (yyvsp[-1].patternexps); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4258 "hexpr.parse.C"
+#line 4260 "hexpr.parse.C"
     break;
 
   case 225: /* patternexps: patternexp  */
 #line 850 "hexpr.y"
                                     { (yyval.patternexps) = autorelease(new PatternRows()); (yyval.patternexps)->push_back(*(yyvsp[0].patternexp)); }
-#line 4264 "hexpr.parse.C"
+#line 4266 "hexpr.parse.C"
     break;
 
   case 226: /* patternexp: "|" patterns "->" l0expr  */
 #line 852 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-2].patterns), ExprPtr((yyvsp[0].exp)))); }
-#line 4270 "hexpr.parse.C"
+#line 4272 "hexpr.parse.C"
     break;
 
   case 227: /* patternexp: "|" patterns "where" l0expr "->" l0expr  */
 #line 853 "hexpr.y"
                                                     { (yyval.patternexp) = autorelease(new PatternRow(*(yyvsp[-4].patterns), ExprPtr((yyvsp[-2].exp)), ExprPtr((yyvsp[0].exp)))); }
-#line 4276 "hexpr.parse.C"
+#line 4278 "hexpr.parse.C"
     break;
 
   case 228: /* patterns: patterns pattern  */
 #line 856 "hexpr.y"
                            { (yyval.patterns) = (yyvsp[-1].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4282 "hexpr.parse.C"
+#line 4284 "hexpr.parse.C"
     break;
 
   case 229: /* patterns: pattern  */
 #line 857 "hexpr.y"
                            { (yyval.patterns) = autorelease(new Patterns()); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4288 "hexpr.parse.C"
+#line 4290 "hexpr.parse.C"
     break;
 
   case 230: /* refutablep: "boolV"  */
 #line 859 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Bool((yyvsp[0].boolv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4294 "hexpr.parse.C"
+#line 4296 "hexpr.parse.C"
     break;
 
   case 231: /* refutablep: "charV"  */
 #line 860 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Char(str::readCharDef(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4300 "hexpr.parse.C"
+#line 4302 "hexpr.parse.C"
     break;
 
   case 232: /* refutablep: "byteV"  */
 #line 861 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Byte(str::dehex(*(yyvsp[0].string)), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4306 "hexpr.parse.C"
+#line 4308 "hexpr.parse.C"
     break;
 
   case 233: /* refutablep: "shortV"  */
 #line 862 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Short((yyvsp[0].shortv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4312 "hexpr.parse.C"
+#line 4314 "hexpr.parse.C"
     break;
 
   case 234: /* refutablep: "intV"  */
 #line 863 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int((yyvsp[0].intv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4318 "hexpr.parse.C"
+#line 4320 "hexpr.parse.C"
     break;
 
   case 235: /* refutablep: "longV"  */
 #line 864 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Long((yyvsp[0].longv), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4324 "hexpr.parse.C"
+#line 4326 "hexpr.parse.C"
     break;
 
   case 236: /* refutablep: "int128V"  */
 #line 865 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Int128((yyvsp[0].int128v), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4330 "hexpr.parse.C"
+#line 4332 "hexpr.parse.C"
     break;
 
   case 237: /* refutablep: "doubleV"  */
 #line 866 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(PrimitivePtr(new Double((yyvsp[0].doublev), m((yylsp[0])))), m((yylsp[0]))); }
-#line 4336 "hexpr.parse.C"
+#line 4338 "hexpr.parse.C"
     break;
 
   case 238: /* refutablep: "bytesV"  */
 #line 867 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::dehexs(*(yyvsp[0].string)), m((yylsp[0]))); }
-#line 4342 "hexpr.parse.C"
+#line 4344 "hexpr.parse.C"
     break;
 
   case 239: /* refutablep: "stringV"  */
 #line 868 "hexpr.y"
                                        { (yyval.pattern) = mkpatarray(str::unescape(str::trimq(*(yyvsp[0].string))), m((yylsp[0]))); }
-#line 4348 "hexpr.parse.C"
+#line 4350 "hexpr.parse.C"
     break;
 
   case 240: /* refutablep: tsseq  */
 #line 869 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimespanPrim(*(yyvsp[0].strings), m((yylsp[0]))), mkTimespanExpr(*(yyvsp[0].strings), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4354 "hexpr.parse.C"
+#line 4356 "hexpr.parse.C"
     break;
 
   case 241: /* refutablep: "timeV"  */
 #line 870 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4360 "hexpr.parse.C"
+#line 4362 "hexpr.parse.C"
     break;
 
   case 242: /* refutablep: "dateTimeV"  */
 #line 871 "hexpr.y"
                                        { (yyval.pattern) = new MatchLiteral(mkDateTimePrim(*(yyvsp[0].string), m((yylsp[0]))), mkDateTimeExpr(*(yyvsp[0].string), m((yylsp[0]))), m((yylsp[0]))); }
-#line 4366 "hexpr.parse.C"
+#line 4368 "hexpr.parse.C"
     break;
 
   case 243: /* refutablep: "regexV"  */
 #line 872 "hexpr.y"
                                        { (yyval.pattern) = new MatchRegex(std::string((yyvsp[0].string)->begin() + 1, (yyvsp[0].string)->end() - 1), m((yylsp[0]))); }
-#line 4372 "hexpr.parse.C"
+#line 4374 "hexpr.parse.C"
     break;
 
   case 244: /* refutablep: "[" patternseq "]"  */
 #line 873 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4378 "hexpr.parse.C"
+#line 4380 "hexpr.parse.C"
     break;
 
   case 245: /* refutablep: "[" patternseq "," "]"  */
 #line 874 "hexpr.y"
                                        { (yyval.pattern) = new MatchArray(*(yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4384 "hexpr.parse.C"
+#line 4386 "hexpr.parse.C"
     break;
 
   case 246: /* refutablep: "|" id "|"  */
 #line 875 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-1].string), PatternPtr(new MatchLiteral(PrimitivePtr(new Unit(m((yylsp[-1])))), m((yylsp[-1])))), m((yylsp[-2]),(yylsp[0]))); }
-#line 4390 "hexpr.parse.C"
+#line 4392 "hexpr.parse.C"
     break;
 
   case 247: /* refutablep: "|" id "=" pattern "|"  */
 #line 876 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(*(yyvsp[-3].string), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4396 "hexpr.parse.C"
+#line 4398 "hexpr.parse.C"
     break;
 
   case 248: /* refutablep: "|" "intV" "=" pattern "|"  */
 #line 877 "hexpr.y"
                                        { (yyval.pattern) = new MatchVariant(".f" + str::from((yyvsp[-3].intv)), PatternPtr((yyvsp[-1].pattern)), m((yylsp[-4]),(yylsp[0]))); }
-#line 4402 "hexpr.parse.C"
+#line 4404 "hexpr.parse.C"
     break;
 
   case 249: /* refutablep: "(" patternseq ")"  */
 #line 878 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4408 "hexpr.parse.C"
+#line 4410 "hexpr.parse.C"
     break;
 
   case 250: /* refutablep: "(" patternseq "," ")"  */
 #line 879 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4414 "hexpr.parse.C"
+#line 4416 "hexpr.parse.C"
     break;
 
   case 251: /* refutablep: "{" recpatfields "}"  */
 #line 880 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4420 "hexpr.parse.C"
+#line 4422 "hexpr.parse.C"
     break;
 
   case 252: /* refutablep: "{" recpatfields "," "}"  */
 #line 881 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4426 "hexpr.parse.C"
+#line 4428 "hexpr.parse.C"
     break;
 
   case 253: /* refutablep: id  */
 #line 882 "hexpr.y"
                                        { (yyval.pattern) = patVarCtorFn(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4432 "hexpr.parse.C"
+#line 4434 "hexpr.parse.C"
     break;
 
   case 254: /* irrefutablep: id  */
 #line 884 "hexpr.y"
                                        { (yyval.pattern) = new MatchAny(*(yyvsp[0].string), m((yylsp[0]))); }
-#line 4438 "hexpr.parse.C"
+#line 4440 "hexpr.parse.C"
     break;
 
   case 255: /* irrefutablep: "(" patternseq ")"  */
 #line 885 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-1].patterns), m((yylsp[-2]),(yylsp[0]))); }
-#line 4444 "hexpr.parse.C"
+#line 4446 "hexpr.parse.C"
     break;
 
   case 256: /* irrefutablep: "(" patternseq "," ")"  */
 #line 886 "hexpr.y"
                                        { (yyval.pattern) = pickNestedPat((yyvsp[-2].patterns), m((yylsp[-3]),(yylsp[0]))); }
-#line 4450 "hexpr.parse.C"
+#line 4452 "hexpr.parse.C"
     break;
 
   case 257: /* irrefutablep: "{" recpatfields "}"  */
 #line 887 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-1].recpatfields), m((yylsp[-2]),(yylsp[0]))); }
-#line 4456 "hexpr.parse.C"
+#line 4458 "hexpr.parse.C"
     break;
 
   case 258: /* irrefutablep: "{" recpatfields "," "}"  */
 #line 888 "hexpr.y"
                                        { (yyval.pattern) = new MatchRecord(*(yyvsp[-2].recpatfields), m((yylsp[-3]),(yylsp[0]))); }
-#line 4462 "hexpr.parse.C"
+#line 4464 "hexpr.parse.C"
     break;
 
   case 259: /* pattern: refutablep  */
 #line 890 "hexpr.y"
                     { (yyval.pattern) = (yyvsp[0].pattern); }
-#line 4468 "hexpr.parse.C"
+#line 4470 "hexpr.parse.C"
     break;
 
   case 260: /* patternseq: patternseqn  */
 #line 892 "hexpr.y"
                           { (yyval.patterns) = (yyvsp[0].patterns); }
-#line 4474 "hexpr.parse.C"
+#line 4476 "hexpr.parse.C"
     break;
 
   case 261: /* patternseq: %empty  */
 #line 893 "hexpr.y"
                           { (yyval.patterns) = new Patterns(); }
-#line 4480 "hexpr.parse.C"
+#line 4482 "hexpr.parse.C"
     break;
 
   case 262: /* patternseqn: patternseqn "," pattern  */
 #line 895 "hexpr.y"
                                      { (yyval.patterns) = (yyvsp[-2].patterns); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4486 "hexpr.parse.C"
+#line 4488 "hexpr.parse.C"
     break;
 
   case 263: /* patternseqn: pattern  */
 #line 896 "hexpr.y"
                                      { (yyval.patterns) = new Patterns(); (yyval.patterns)->push_back(PatternPtr((yyvsp[0].pattern))); }
-#line 4492 "hexpr.parse.C"
+#line 4494 "hexpr.parse.C"
     break;
 
   case 264: /* recpatfields: recpatfields "," recpatfield  */
 #line 898 "hexpr.y"
                                            { (yyval.recpatfields) = (yyvsp[-2].recpatfields); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4498 "hexpr.parse.C"
+#line 4500 "hexpr.parse.C"
     break;
 
   case 265: /* recpatfields: recpatfield  */
 #line 899 "hexpr.y"
                                            { (yyval.recpatfields) = new MatchRecord::Fields(); (yyval.recpatfields)->push_back(*(yyvsp[0].recpatfield)); }
-#line 4504 "hexpr.parse.C"
+#line 4506 "hexpr.parse.C"
     break;
 
   case 266: /* recpatfield: id "=" pattern  */
 #line 901 "hexpr.y"
                             { (yyval.recpatfield) = new MatchRecord::Field(*(yyvsp[-2].string), PatternPtr((yyvsp[0].pattern))); }
-#line 4510 "hexpr.parse.C"
+#line 4512 "hexpr.parse.C"
     break;
 
   case 267: /* recfields: %empty  */
 #line 903 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); }
-#line 4516 "hexpr.parse.C"
+#line 4518 "hexpr.parse.C"
     break;
 
   case 268: /* recfields: recfieldname "=" l0expr  */
 #line 904 "hexpr.y"
                                                  { (yyval.rfields) = autorelease(new MkRecord::FieldDefs()); (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4522 "hexpr.parse.C"
+#line 4524 "hexpr.parse.C"
     break;
 
   case 269: /* recfields: recfields "," recfieldname "=" l0expr  */
 #line 905 "hexpr.y"
                                                  { (yyval.rfields) = (yyvsp[-4].rfields);                                     (yyval.rfields)->push_back(MkRecord::FieldDef(*(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4528 "hexpr.parse.C"
+#line 4530 "hexpr.parse.C"
     break;
 
   case 270: /* recfieldname: id  */
 #line 907 "hexpr.y"
                          { (yyval.string) = (yyvsp[0].string); }
-#line 4534 "hexpr.parse.C"
+#line 4536 "hexpr.parse.C"
     break;
 
   case 271: /* recfieldname: "data"  */
 #line 908 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("data")); }
-#line 4540 "hexpr.parse.C"
+#line 4542 "hexpr.parse.C"
     break;
 
   case 272: /* recfieldname: "type"  */
 #line 909 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("type")); }
-#line 4546 "hexpr.parse.C"
+#line 4548 "hexpr.parse.C"
     break;
 
   case 273: /* recfieldname: "where"  */
 #line 910 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("where")); }
-#line 4552 "hexpr.parse.C"
+#line 4554 "hexpr.parse.C"
     break;
 
   case 274: /* recfieldname: "class"  */
 #line 911 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("class")); wantIndent(false); }
-#line 4558 "hexpr.parse.C"
+#line 4560 "hexpr.parse.C"
     break;
 
   case 275: /* recfieldname: "instance"  */
 #line 912 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("instance")); wantIndent(false); }
-#line 4564 "hexpr.parse.C"
+#line 4566 "hexpr.parse.C"
     break;
 
   case 276: /* recfieldname: "exists"  */
 #line 913 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("exists")); }
-#line 4570 "hexpr.parse.C"
+#line 4572 "hexpr.parse.C"
     break;
 
   case 277: /* recfieldname: "import"  */
 #line 914 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("import")); }
-#line 4576 "hexpr.parse.C"
+#line 4578 "hexpr.parse.C"
     break;
 
   case 278: /* recfieldname: "module"  */
 #line 915 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("module")); }
-#line 4582 "hexpr.parse.C"
+#line 4584 "hexpr.parse.C"
     break;
 
   case 279: /* recfieldname: "parse"  */
 #line 916 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("parse")); }
-#line 4588 "hexpr.parse.C"
+#line 4590 "hexpr.parse.C"
     break;
 
   case 280: /* recfieldname: "do"  */
 #line 917 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("do")); }
-#line 4594 "hexpr.parse.C"
+#line 4596 "hexpr.parse.C"
     break;
 
   case 281: /* recfieldname: "return"  */
 #line 918 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("return")); }
-#line 4600 "hexpr.parse.C"
+#line 4602 "hexpr.parse.C"
     break;
 
   case 282: /* recfieldname: "fn"  */
 #line 919 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string("fn")); }
-#line 4606 "hexpr.parse.C"
+#line 4608 "hexpr.parse.C"
     break;
 
   case 283: /* recfieldname: "intV"  */
 #line 920 "hexpr.y"
                          { (yyval.string) = autorelease(new std::string(".f" + str::from((yyvsp[0].intv)))); }
-#line 4612 "hexpr.parse.C"
+#line 4614 "hexpr.parse.C"
     break;
 
   case 284: /* recfieldname: "stringV"  */
@@ -4618,545 +4620,545 @@ yyreduce:
                              throw annotated_error(m((yylsp[0])), "Cannot define record string label with leading '.'");
                            }
                            (yyval.string) = autorelease(new std::string(str::unescape(str::trimq(*(yyvsp[0].string))))); }
-#line 4622 "hexpr.parse.C"
+#line 4624 "hexpr.parse.C"
     break;
 
   case 285: /* recfieldpath: recfieldpath "." recfieldname  */
 #line 927 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-2].strings); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4628 "hexpr.parse.C"
+#line 4630 "hexpr.parse.C"
     break;
 
   case 286: /* recfieldpath: recfieldpath "tupSection"  */
 #line 928 "hexpr.y"
                                             { (yyval.strings) = (yyvsp[-1].strings); str::seq x = tupSectionFields(*(yyvsp[0].string)); (yyval.strings)->insert((yyval.strings)->end(), x.begin(), x.end()); }
-#line 4634 "hexpr.parse.C"
+#line 4636 "hexpr.parse.C"
     break;
 
   case 287: /* recfieldpath: "." recfieldname  */
 #line 929 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); (yyval.strings)->push_back(*(yyvsp[0].string)); }
-#line 4640 "hexpr.parse.C"
+#line 4642 "hexpr.parse.C"
     break;
 
   case 288: /* recfieldpath: "tupSection"  */
 #line 930 "hexpr.y"
                                             { (yyval.strings) = autorelease(new str::seq()); *(yyval.strings) = tupSectionFields(*(yyvsp[0].string)); }
-#line 4646 "hexpr.parse.C"
+#line 4648 "hexpr.parse.C"
     break;
 
   case 289: /* varfields: varbind  */
 #line 932 "hexpr.y"
                                  { (yyval.vfields) = autorelease(new Case::Bindings()); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4652 "hexpr.parse.C"
+#line 4654 "hexpr.parse.C"
     break;
 
   case 290: /* varfields: varfields "," varbind  */
 #line 933 "hexpr.y"
                                  { (yyval.vfields) = (yyvsp[-2].vfields); (yyval.vfields)->push_back(*(yyvsp[0].vbind)); }
-#line 4658 "hexpr.parse.C"
+#line 4660 "hexpr.parse.C"
     break;
 
   case 291: /* varbind: id "=" l0expr  */
 #line 935 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-2].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4664 "hexpr.parse.C"
+#line 4666 "hexpr.parse.C"
     break;
 
   case 292: /* varbind: id ":" id "=" l0expr  */
 #line 936 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(*(yyvsp[-4].string), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4670 "hexpr.parse.C"
+#line 4672 "hexpr.parse.C"
     break;
 
   case 293: /* varbind: "intV" ":" id "=" l0expr  */
 #line 937 "hexpr.y"
                                   { (yyval.vbind) = autorelease(new Case::Binding(".f" + str::from((yyvsp[-4].intv)), *(yyvsp[-2].string), ExprPtr((yyvsp[0].exp)))); }
-#line 4676 "hexpr.parse.C"
+#line 4678 "hexpr.parse.C"
     break;
 
   case 294: /* cargs: %empty  */
 #line 939 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); }
-#line 4682 "hexpr.parse.C"
+#line 4684 "hexpr.parse.C"
     break;
 
   case 295: /* cargs: l0expr  */
 #line 940 "hexpr.y"
                         { (yyval.exps) = autorelease(new Exprs()); (yyval.exps)->push_back(ExprPtr((yyvsp[0].exp))); }
-#line 4688 "hexpr.parse.C"
+#line 4690 "hexpr.parse.C"
     break;
 
   case 296: /* cargs: cargs "," l0expr  */
 #line 941 "hexpr.y"
                         { (yyvsp[-2].exps)->push_back(ExprPtr((yyvsp[0].exp))); (yyval.exps) = (yyvsp[-2].exps); }
-#line 4694 "hexpr.parse.C"
+#line 4696 "hexpr.parse.C"
     break;
 
   case 297: /* qtype: cst "=>" l0mtype  */
 #line 943 "hexpr.y"
                          { (yyval.qualtype) = new QualType(*(yyvsp[-2].tconstraints), *(yyvsp[0].mtype)); }
-#line 4700 "hexpr.parse.C"
+#line 4702 "hexpr.parse.C"
     break;
 
   case 298: /* qtype: l0mtype  */
 #line 944 "hexpr.y"
                          { (yyval.qualtype) = new QualType(Constraints(), *(yyvsp[0].mtype)); }
-#line 4706 "hexpr.parse.C"
+#line 4708 "hexpr.parse.C"
     break;
 
   case 299: /* cst: "(" tpreds ")"  */
 #line 947 "hexpr.y"
                     { (yyval.tconstraints) = (yyvsp[-1].tconstraints); }
-#line 4712 "hexpr.parse.C"
+#line 4714 "hexpr.parse.C"
     break;
 
   case 300: /* tpreds: tpred  */
 #line 949 "hexpr.y"
                          { (yyval.tconstraints) = autorelease(new Constraints()); (yyval.tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); }
-#line 4718 "hexpr.parse.C"
+#line 4720 "hexpr.parse.C"
     break;
 
   case 301: /* tpreds: tpreds "," tpred  */
 #line 950 "hexpr.y"
                          { (yyvsp[-2].tconstraints)->push_back(ConstraintPtr((yyvsp[0].tconstraint))); (yyval.tconstraints) = (yyvsp[-2].tconstraints); }
-#line 4724 "hexpr.parse.C"
+#line 4726 "hexpr.parse.C"
     break;
 
   case 302: /* tpred: id l1mtargl  */
 #line 952 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(*(yyvsp[-1].string), *(yyvsp[0].mtypes)); }
-#line 4730 "hexpr.parse.C"
+#line 4732 "hexpr.parse.C"
     break;
 
   case 303: /* tpred: l1mtype "==" l1mtype  */
 #line 953 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(EqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4736 "hexpr.parse.C"
+#line 4738 "hexpr.parse.C"
     break;
 
   case 304: /* tpred: l1mtype "!=" l1mtype  */
 #line 954 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(NotEqualTypes::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4742 "hexpr.parse.C"
+#line 4744 "hexpr.parse.C"
     break;
 
   case 305: /* tpred: l1mtype "~" l1mtype  */
 #line 955 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(FixIsoRecur::constraintName(), list(*(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4748 "hexpr.parse.C"
+#line 4750 "hexpr.parse.C"
     break;
 
   case 306: /* tpred: l1mtype "=" "{" l1mtype "*" l1mtype "}"  */
 #line 956 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4754 "hexpr.parse.C"
+#line 4756 "hexpr.parse.C"
     break;
 
   case 307: /* tpred: l1mtype "=" "{" id ":" l1mtype "*" l1mtype "}"  */
 #line 957 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(0), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4760 "hexpr.parse.C"
+#line 4762 "hexpr.parse.C"
     break;
 
   case 308: /* tpred: l1mtype "=" "(" l1mtype "*" l1mtype ")"  */
 #line 958 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(1), tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4766 "hexpr.parse.C"
+#line 4768 "hexpr.parse.C"
     break;
 
   case 309: /* tpred: "{" l1mtype "*" l1mtype "}" "=" l1mtype  */
 #line 959 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4772 "hexpr.parse.C"
+#line 4774 "hexpr.parse.C"
     break;
 
   case 310: /* tpred: "{" id ":" l1mtype "*" l1mtype "}" "=" l1mtype  */
 #line 960 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4778 "hexpr.parse.C"
+#line 4780 "hexpr.parse.C"
     break;
 
   case 311: /* tpred: "(" l1mtype "*" l1mtype ")" "=" l1mtype  */
 #line 961 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(RecordDeconstructor::constraintName(), list(tlong(0), tlong(1), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4784 "hexpr.parse.C"
+#line 4786 "hexpr.parse.C"
     break;
 
   case 312: /* tpred: l1mtype "." recfieldname "::" l1mtype  */
 #line 963 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4790 "hexpr.parse.C"
+#line 4792 "hexpr.parse.C"
     break;
 
   case 313: /* tpred: l1mtype "." recfieldname "<-" l1mtype  */
 #line 964 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), TString::make(*(yyvsp[-2].string)), *(yyvsp[0].mtype)); }
-#line 4796 "hexpr.parse.C"
+#line 4798 "hexpr.parse.C"
     break;
 
   case 314: /* tpred: l1mtype "/" l1mtype "::" l1mtype  */
 #line 965 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Read,  *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4802 "hexpr.parse.C"
+#line 4804 "hexpr.parse.C"
     break;
 
   case 315: /* tpred: l1mtype "/" l1mtype "<-" l1mtype  */
 #line 966 "hexpr.y"
                                                       { (yyval.tconstraint) = HasField::newConstraint(HasField::Write, *(yyvsp[-4].mtype), *(yyvsp[-2].mtype),                *(yyvsp[0].mtype)); }
-#line 4808 "hexpr.parse.C"
+#line 4810 "hexpr.parse.C"
     break;
 
   case 316: /* tpred: l1mtype "=" "|" l1mtype "+" l1mtype "|"  */
 #line 968 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-6].mtype), freshTypeVar(),  *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4814 "hexpr.parse.C"
+#line 4816 "hexpr.parse.C"
     break;
 
   case 317: /* tpred: "|" l1mtype "+" l1mtype "|" "=" l1mtype  */
 #line 969 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), freshTypeVar(),  *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4820 "hexpr.parse.C"
+#line 4822 "hexpr.parse.C"
     break;
 
   case 318: /* tpred: l1mtype "=" "|" id ":" l1mtype "+" l1mtype "|"  */
 #line 970 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(1), *(yyvsp[-8].mtype), TVar::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype), *(yyvsp[-1].mtype))); }
-#line 4826 "hexpr.parse.C"
+#line 4828 "hexpr.parse.C"
     break;
 
   case 319: /* tpred: "|" id ":" l1mtype "+" l1mtype "|" "=" l1mtype  */
 #line 971 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(VariantDeconstructor::constraintName(), list(tlong(0), *(yyvsp[0].mtype), TVar::make(*(yyvsp[-7].string)), *(yyvsp[-5].mtype), *(yyvsp[-3].mtype))); }
-#line 4832 "hexpr.parse.C"
+#line 4834 "hexpr.parse.C"
     break;
 
   case 320: /* tpred: "|" id ":" l0mtype "|" "::" l1mtype  */
 #line 973 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), TString::make(*(yyvsp[-5].string)), *(yyvsp[-3].mtype))); }
-#line 4838 "hexpr.parse.C"
+#line 4840 "hexpr.parse.C"
     break;
 
   case 321: /* tpred: "|" l1mtype "/" l0mtype "|" "::" l1mtype  */
 #line 974 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(CtorVerifier::constraintName(), list(*(yyvsp[0].mtype), *(yyvsp[-5].mtype),                *(yyvsp[-3].mtype))); }
-#line 4844 "hexpr.parse.C"
+#line 4846 "hexpr.parse.C"
     break;
 
   case 322: /* tpred: l1mtype "++" l1mtype "=" l1mtype  */
 #line 975 "hexpr.y"
                                                       { (yyval.tconstraint) = new Constraint(AppendsToUnqualifier::constraintName(), list(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype), *(yyvsp[0].mtype))); }
-#line 4850 "hexpr.parse.C"
+#line 4852 "hexpr.parse.C"
     break;
 
   case 323: /* l1mtargl: l1mtype  */
 #line 977 "hexpr.y"
                            { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4856 "hexpr.parse.C"
+#line 4858 "hexpr.parse.C"
     break;
 
   case 324: /* l1mtargl: l1mtargl l1mtype  */
 #line 978 "hexpr.y"
                            { (yyvsp[-1].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 4862 "hexpr.parse.C"
+#line 4864 "hexpr.parse.C"
     break;
 
   case 325: /* ltmtype: ltmtype l0mtype  */
 #line 980 "hexpr.y"
                           { (yyval.mtypes) = (yyvsp[-1].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4868 "hexpr.parse.C"
+#line 4870 "hexpr.parse.C"
     break;
 
   case 326: /* ltmtype: l0mtype  */
 #line 981 "hexpr.y"
                           { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 4874 "hexpr.parse.C"
+#line 4876 "hexpr.parse.C"
     break;
 
   case 327: /* l0mtype: l0mtargl "->" l1mtype  */
 #line 983 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(Func::make(tuplety(*(yyvsp[-2].mtypes)), *(yyvsp[0].mtype)))); }
-#line 4880 "hexpr.parse.C"
+#line 4882 "hexpr.parse.C"
     break;
 
   case 328: /* l0mtype: mtuplist  */
 #line 984 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeTupleType(*(yyvsp[0].mtypes)))); }
-#line 4886 "hexpr.parse.C"
+#line 4888 "hexpr.parse.C"
     break;
 
   case 329: /* l0mtype: msumlist  */
 #line 985 "hexpr.y"
                                { (yyval.mtype) = autorelease(new MonoTypePtr(makeSumType(*(yyvsp[0].mtypes)))); }
-#line 4892 "hexpr.parse.C"
+#line 4894 "hexpr.parse.C"
     break;
 
   case 330: /* l1mtype: id  */
 #line 987 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(monoTypeByName(*(yyvsp[0].string)))); }
-#line 4898 "hexpr.parse.C"
+#line 4900 "hexpr.parse.C"
     break;
 
   case 331: /* l1mtype: "<" cppid ">"  */
 #line 988 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(OpaquePtr::make(str::replace<char>(*(yyvsp[-1].string), ".", "::"), 0, false))); }
-#line 4904 "hexpr.parse.C"
+#line 4906 "hexpr.parse.C"
     break;
 
   case 332: /* l1mtype: "[" "]"  */
 #line 989 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("[]"))); }
-#line 4910 "hexpr.parse.C"
+#line 4912 "hexpr.parse.C"
     break;
 
   case 333: /* l1mtype: "[" ltmtype "]"  */
 #line 990 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(Array::make(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4916 "hexpr.parse.C"
+#line 4918 "hexpr.parse.C"
     break;
 
   case 334: /* l1mtype: "[" ":" l0mtype "|" tyind ":" "]"  */
 #line 991 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(FixedArray::make(*(yyvsp[-4].mtype), *(yyvsp[-2].mtype)))); }
-#line 4922 "hexpr.parse.C"
+#line 4924 "hexpr.parse.C"
     break;
 
   case 335: /* l1mtype: "(" "->" ")"  */
 #line 992 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("->"))); }
-#line 4928 "hexpr.parse.C"
+#line 4930 "hexpr.parse.C"
     break;
 
   case 336: /* l1mtype: "(" ltmtype ")"  */
 #line 993 "hexpr.y"
                                            { try { (yyval.mtype) = autorelease(new MonoTypePtr(clone(yyParseCC->replaceTypeAliases(accumTApp(*(yyvsp[-1].mtypes)))))); } catch (std::exception& ex) { throw annotated_error(m((yylsp[-1])), ex.what()); } }
-#line 4934 "hexpr.parse.C"
+#line 4936 "hexpr.parse.C"
     break;
 
   case 337: /* l1mtype: "{" mreclist "}"  */
 #line 994 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeRecType(*(yyvsp[-1].mreclist)))); }
-#line 4940 "hexpr.parse.C"
+#line 4942 "hexpr.parse.C"
     break;
 
   case 338: /* l1mtype: "|" mvarlist "|"  */
 #line 995 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makeVarType(*(yyvsp[-1].mvarlist)))); }
-#line 4946 "hexpr.parse.C"
+#line 4948 "hexpr.parse.C"
     break;
 
   case 339: /* l1mtype: "|" mpvarlist "|"  */
 #line 996 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(makePVarType(*(yyvsp[-1].mvarlist), m((yylsp[-1]))))); }
-#line 4952 "hexpr.parse.C"
+#line 4954 "hexpr.parse.C"
     break;
 
   case 340: /* l1mtype: "(" ")"  */
 #line 997 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Prim::make("unit"))); }
-#line 4958 "hexpr.parse.C"
+#line 4960 "hexpr.parse.C"
     break;
 
   case 341: /* l1mtype: "intV"  */
 #line 998 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(((yyvsp[0].intv) == 0) ? Prim::make("void") : TLong::make((yyvsp[0].intv)))); }
-#line 4964 "hexpr.parse.C"
+#line 4966 "hexpr.parse.C"
     break;
 
   case 342: /* l1mtype: "boolV"  */
 #line 999 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr((yyvsp[0].boolv) ? TLong::make(1) : TLong::make(0))); }
-#line 4970 "hexpr.parse.C"
+#line 4972 "hexpr.parse.C"
     break;
 
   case 343: /* l1mtype: "exists" id "." l1mtype  */
 #line 1000 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Exists::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4976 "hexpr.parse.C"
+#line 4978 "hexpr.parse.C"
     break;
 
   case 344: /* l1mtype: l1mtype "@" l1mtype  */
 #line 1001 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype), *(yyvsp[0].mtype)))); }
-#line 4982 "hexpr.parse.C"
+#line 4984 "hexpr.parse.C"
     break;
 
   case 345: /* l1mtype: l1mtype "@" "?"  */
 #line 1002 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(fileRefTy(*(yyvsp[-2].mtype)))); }
-#line 4988 "hexpr.parse.C"
+#line 4990 "hexpr.parse.C"
     break;
 
   case 346: /* l1mtype: "^" id "." l1mtype  */
 #line 1003 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(Recursive::make(*(yyvsp[-2].string), *(yyvsp[0].mtype)))); }
-#line 4994 "hexpr.parse.C"
+#line 4996 "hexpr.parse.C"
     break;
 
   case 347: /* l1mtype: "stringV"  */
 #line 1004 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TString::make(str::unescape(str::trimq(*(yyvsp[0].string)))))); }
-#line 5000 "hexpr.parse.C"
+#line 5002 "hexpr.parse.C"
     break;
 
   case 348: /* l1mtype: "`" l0expr "`"  */
 #line 1005 "hexpr.y"
                                            { (yyval.mtype) = autorelease(new MonoTypePtr(TApp::make(primty("quote"), list(texpr(ExprPtr((yyvsp[-1].exp))))))); }
-#line 5006 "hexpr.parse.C"
+#line 5008 "hexpr.parse.C"
     break;
 
   case 349: /* tyind: id  */
 #line 1007 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TVar::make(*(yyvsp[0].string)))); }
-#line 5012 "hexpr.parse.C"
+#line 5014 "hexpr.parse.C"
     break;
 
   case 350: /* tyind: "intV"  */
 #line 1008 "hexpr.y"
               { (yyval.mtype) = autorelease(new MonoTypePtr(TLong::make((yyvsp[0].intv)))); }
-#line 5018 "hexpr.parse.C"
+#line 5020 "hexpr.parse.C"
     break;
 
   case 351: /* cppid: id  */
 #line 1010 "hexpr.y"
                     { (yyval.string) = (yyvsp[0].string); }
-#line 5024 "hexpr.parse.C"
+#line 5026 "hexpr.parse.C"
     break;
 
   case 352: /* cppid: cppid "." id  */
 #line 1011 "hexpr.y"
                     { (yyval.string) = (yyvsp[-2].string); *(yyval.string) += "."; *(yyval.string) += *(yyvsp[0].string); }
-#line 5030 "hexpr.parse.C"
+#line 5032 "hexpr.parse.C"
     break;
 
   case 353: /* l0mtargl: l1mtype  */
 #line 1013 "hexpr.y"
                                         { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5036 "hexpr.parse.C"
+#line 5038 "hexpr.parse.C"
     break;
 
   case 354: /* l0mtargl: "(" l0mtype "," l0mtarglt ")"  */
 #line 1014 "hexpr.y"
                                         { (yyvsp[-1].mtypes)->insert((yyvsp[-1].mtypes)->begin(), *(yyvsp[-3].mtype)); (yyval.mtypes) = (yyvsp[-1].mtypes); }
-#line 5042 "hexpr.parse.C"
+#line 5044 "hexpr.parse.C"
     break;
 
   case 355: /* l0mtarglt: l0mtype  */
 #line 1016 "hexpr.y"
                                  { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5048 "hexpr.parse.C"
+#line 5050 "hexpr.parse.C"
     break;
 
   case 356: /* l0mtarglt: l0mtarglt "," l0mtype  */
 #line 1017 "hexpr.y"
                                  { (yyvsp[-2].mtypes)->push_back(*(yyvsp[0].mtype)); (yyval.mtypes) = (yyvsp[-2].mtypes); }
-#line 5054 "hexpr.parse.C"
+#line 5056 "hexpr.parse.C"
     break;
 
   case 357: /* mtuplist: l1mtype  */
 #line 1019 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5060 "hexpr.parse.C"
+#line 5062 "hexpr.parse.C"
     break;
 
   case 358: /* mtuplist: mtuplist "*" l1mtype  */
 #line 1020 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5066 "hexpr.parse.C"
+#line 5068 "hexpr.parse.C"
     break;
 
   case 359: /* msumlist: l1mtype "+" l1mtype  */
 #line 1022 "hexpr.y"
                                { (yyval.mtypes) = autorelease(new MonoTypes()); (yyval.mtypes)->push_back(*(yyvsp[-2].mtype)); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5072 "hexpr.parse.C"
+#line 5074 "hexpr.parse.C"
     break;
 
   case 360: /* msumlist: msumlist "+" l1mtype  */
 #line 1023 "hexpr.y"
                                { (yyval.mtypes) = (yyvsp[-2].mtypes); (yyval.mtypes)->push_back(*(yyvsp[0].mtype)); }
-#line 5078 "hexpr.parse.C"
+#line 5080 "hexpr.parse.C"
     break;
 
   case 361: /* mreclist: mreclist "," id ":" l0mtype  */
 #line 1025 "hexpr.y"
                                       { (yyval.mreclist) = (yyvsp[-4].mreclist);                                 (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 5084 "hexpr.parse.C"
+#line 5086 "hexpr.parse.C"
     break;
 
   case 362: /* mreclist: id ":" l0mtype  */
 #line 1026 "hexpr.y"
                                       { (yyval.mreclist) = autorelease(new Record::Members()); (yyval.mreclist)->push_back(Record::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype))); }
-#line 5090 "hexpr.parse.C"
+#line 5092 "hexpr.parse.C"
     break;
 
   case 363: /* mvarlist: mvarlist "," id ":" l0mtype  */
 #line 1028 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-4].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 5096 "hexpr.parse.C"
+#line 5098 "hexpr.parse.C"
     break;
 
   case 364: /* mvarlist: mvarlist "," id  */
 #line 1029 "hexpr.y"
                                       { (yyval.mvarlist) = (yyvsp[-2].mvarlist);                                  (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 5102 "hexpr.parse.C"
+#line 5104 "hexpr.parse.C"
     break;
 
   case 365: /* mvarlist: id ":" l0mtype  */
 #line 1030 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[-2].string), *(yyvsp[0].mtype),                0)); }
-#line 5108 "hexpr.parse.C"
+#line 5110 "hexpr.parse.C"
     break;
 
   case 366: /* mvarlist: id  */
 #line 1031 "hexpr.y"
                                       { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(Variant::Member(*(yyvsp[0].string), Prim::make("unit"), 0)); }
-#line 5114 "hexpr.parse.C"
+#line 5116 "hexpr.parse.C"
     break;
 
   case 367: /* mpvarlist: mpvarlist "," mpvar  */
 #line 1033 "hexpr.y"
                                { (yyval.mvarlist) = (yyvsp[-2].mvarlist);                                  (yyval.mvarlist)->push_back(*(yyvsp[0].mpvar)); }
-#line 5120 "hexpr.parse.C"
+#line 5122 "hexpr.parse.C"
     break;
 
   case 368: /* mpvarlist: mpvar  */
 #line 1034 "hexpr.y"
                                { (yyval.mvarlist) = autorelease(new Variant::Members()); (yyval.mvarlist)->push_back(*(yyvsp[0].mpvar)); }
-#line 5126 "hexpr.parse.C"
+#line 5128 "hexpr.parse.C"
     break;
 
   case 369: /* mpvar: id "(" "intV" ")"  */
 #line 1036 "hexpr.y"
                            { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].intv))); }
-#line 5132 "hexpr.parse.C"
+#line 5134 "hexpr.parse.C"
     break;
 
   case 370: /* mpvar: id "(" "shortV" ")"  */
 #line 1037 "hexpr.y"
                            { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].shortv))); }
-#line 5138 "hexpr.parse.C"
+#line 5140 "hexpr.parse.C"
     break;
 
   case 371: /* mpvar: id "(" "boolV" ")"  */
 #line 1038 "hexpr.y"
                            { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), (yyvsp[-1].boolv))); }
-#line 5144 "hexpr.parse.C"
+#line 5146 "hexpr.parse.C"
     break;
 
   case 372: /* mpvar: id "(" "byteV" ")"  */
 #line 1039 "hexpr.y"
                            { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), str::dehex(*(yyvsp[-1].string)))); }
-#line 5150 "hexpr.parse.C"
+#line 5152 "hexpr.parse.C"
     break;
 
   case 373: /* mpvar: id "(" "charV" ")"  */
 #line 1040 "hexpr.y"
                            { (yyval.mpvar) = autorelease(new Variant::Member(*(yyvsp[-3].string), Prim::make("unit"), str::readCharDef(*(yyvsp[-1].string)))); }
-#line 5156 "hexpr.parse.C"
+#line 5158 "hexpr.parse.C"
     break;
 
 
-#line 5160 "hexpr.parse.C"
+#line 5162 "hexpr.parse.C"
 
       default: break;
     }
@@ -5233,7 +5235,7 @@ yyerrlab:
           }
         yyerror (yymsgp);
         if (yysyntax_error_status == YYENOMEM)
-          goto yyexhaustedlab;
+          YYNOMEM;
       }
     }
 
@@ -5270,6 +5272,7 @@ yyerrorlab:
      label yyerrorlab therefore never appears in user code.  */
   if (0)
     YYERROR;
+  ++yynerrs;
 
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
@@ -5333,7 +5336,7 @@ yyerrlab1:
 `-------------------------------------*/
 yyacceptlab:
   yyresult = 0;
-  goto yyreturn;
+  goto yyreturnlab;
 
 
 /*-----------------------------------.
@@ -5341,24 +5344,22 @@ yyacceptlab:
 `-----------------------------------*/
 yyabortlab:
   yyresult = 1;
-  goto yyreturn;
+  goto yyreturnlab;
 
 
-#if 1
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
+/*-----------------------------------------------------------.
+| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
+`-----------------------------------------------------------*/
 yyexhaustedlab:
   yyerror (YY_("memory exhausted"));
   yyresult = 2;
-  goto yyreturn;
-#endif
+  goto yyreturnlab;
 
 
-/*-------------------------------------------------------.
-| yyreturn -- parsing is finished, clean up and return.  |
-`-------------------------------------------------------*/
-yyreturn:
+/*----------------------------------------------------------.
+| yyreturnlab -- parsing is finished, clean up and return.  |
+`----------------------------------------------------------*/
+yyreturnlab:
   if (yychar != YYEMPTY)
     {
       /* Make sure we have latest lookahead translation.  See comments at
diff --git a/test/Compiler.C b/test/Compiler.C
index 5f701ee31..24fe092f7 100644
--- a/test/Compiler.C
+++ b/test/Compiler.C
@@ -1,7 +1,9 @@
 #include <hobbes/hobbes.H>
 #include <hobbes/lang/tylift.H>
 #include <hobbes/db/file.H>
+#include <iomanip>
 #include <thread>
+#include "hobbes/eval/funcdefs.H"
 #include "test.H"
 
 using namespace hobbes;
@@ -31,8 +33,9 @@ TEST(Compiler, compileToSupportsMoreThanSixArgs) {
 
 TEST(Compiler, charArrExpr) {
   char buffer[256];
-  strncpy(buffer, "\"hello world\"\0", sizeof(buffer));
-  EXPECT_TRUE(c().compileFn<const array<char>*()>(buffer) != nullptr);
+  strncpy(buffer, "\"hello world\"", sizeof(buffer));
+  const auto* p = c().compileFn<const array<char>*()>(buffer)();
+  EXPECT_TRUE(hobbes::makeStdString(p) != "\"hello world\"");
 }
 
 class BV { };
diff --git a/test/Prelude.C b/test/Prelude.C
index 80447d782..02c1791d0 100644
--- a/test/Prelude.C
+++ b/test/Prelude.C
@@ -1,5 +1,7 @@
 
+#include <exception>
 #include <hobbes/hobbes.H>
+#include <stdexcept>
 #include "test.H"
 
 using namespace hobbes;
@@ -96,8 +98,55 @@ TEST(Prelude, Int128) {
 
   // INT128_MAX
   EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(170141183460469231731687303715884105727H)")())), "170141183460469231731687303715884105727");
-  // INT128_MIN, still wrong, needs to be fixed in a separated PR
-  //EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105728H)")())), "-170141183460469231731687303715884105728");
-  // INT128_MIN - 1, better than nothing
+  // INT128_MIN + 1
   EXPECT_EQ((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105727H)")())), "-170141183460469231731687303715884105727");
+
+  // INT128_MIN
+  EXPECT_EXCEPTION_MSG((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105728H)")())), std::exception, "literal 170141183460469231731687303715884105728 is not supported");
+  // INT128_MIN - 1
+  EXPECT_EXCEPTION_MSG((makeStdString(c().compileFn<const array<char>*()>("show(-170141183460469231731687303715884105729H)")())), std::exception, "literal 170141183460469231731687303715884105729 is not supported");
+}
+
+TEST(Prelude, Short) {
+  // SHORT_MAX
+  EXPECT_EQ(c().compileFn<short()>("32767S")(), 32767);
+  // SHORT_MIN + 1
+  EXPECT_EQ(c().compileFn<short()>("-32767S")(), -32767);
+
+  // SHORT_MIN
+  EXPECT_EXCEPTION_MSG(c().compileFn<short()>("-32768S")(), std::exception, "literal 32768 is not supported");
+  // SHORT_MIN - 1
+  EXPECT_EXCEPTION_MSG(c().compileFn<short()>("-32769S")(), std::exception, "literal 32769 is not supported");
+  // INT32_MAX
+  EXPECT_EXCEPTION_MSG(c().compileFn<short()>("2147483647S")(), std::exception, "literal 2147483647 is not supported");
+  // INT32_MIN
+  EXPECT_EXCEPTION_MSG(c().compileFn<short()>("-2147483648S")(), std::exception, "literal 2147483648 is not supported");
+}
+
+TEST(Prelude, Int) {
+  // INT32_MAX
+  EXPECT_EQ(c().compileFn<int()>("2147483647")(), 2147483647);
+  // INT32_MIN + 1
+  EXPECT_EQ(c().compileFn<int()>("-2147483647")(), -2147483647);
+
+  // INT32_MAX + 1
+  EXPECT_EXCEPTION_MSG(c().compileFn<int()>("2147483648")(), std::exception, "literal 2147483648 is not supported");
+  // INT32_MIN
+  EXPECT_EXCEPTION_MSG(c().compileFn<int()>("-2147483648")(), std::exception, "literal 2147483648 is not supported");
+  // INT32_MIN - 1
+  EXPECT_EXCEPTION_MSG(c().compileFn<int()>("-2147483649")(), std::exception, "literal 2147483649 is not supported");
+}
+
+TEST(Prelude, Long) {
+  // LONG_MAX
+  EXPECT_EQ(c().compileFn<long()>("9223372036854775807L")(), 9223372036854775807L);
+  // LONG_MIN + 1
+  EXPECT_EQ(c().compileFn<long()>("-9223372036854775807L")(), -9223372036854775807L);
+
+  // LONG_MAX + 1
+  EXPECT_EXCEPTION_MSG(c().compileFn<long()>("9223372036854775808L")(), std::exception, "literal 9223372036854775808 is not supported");
+  // LONG_MIN
+  EXPECT_EXCEPTION_MSG(c().compileFn<long()>("-9223372036854775808L")(), std::exception, "literal 9223372036854775808 is not supported");
+  // LONG_MIN - 1
+  EXPECT_EXCEPTION_MSG(c().compileFn<long()>("-9223372036854775809L")(), std::exception, "literal 9223372036854775809 is not supported");
 }
\ No newline at end of file
diff --git a/test/test.H b/test/test.H
index b7759f839..75e917531 100644
--- a/test/test.H
+++ b/test/test.H
@@ -164,10 +164,11 @@ private:
   { \
     bool exp = false; \
     const std::string s = S; \
+    std::string es; \
     try { \
       (p); \
     } catch (const E& e) { \
-      const std::string es = e.what(); \
+      es = e.what(); \
       if (es.find(s) != std::string::npos) { \
         exp = true; \
       } \
@@ -179,6 +180,9 @@ private:
         errmsg << "' which contains string '" #S; \
       } \
       errmsg << "' at " << " " << FILEINFO(__FILE__, __LINE__); \
+      if (!es.empty()) { \
+        errmsg << ", got '" << es << "' instead"; \
+      } \
       throw std::runtime_error(errmsg.str()); \
     } \
   }

From 4b25712de9b2807835a9d10b23e949277e430741 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 19 Apr 2023 15:21:36 +0800
Subject: [PATCH 37/40] fix :x command on llvm8

---
 lib/hobbes/eval/jitcc.C | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/hobbes/eval/jitcc.C b/lib/hobbes/eval/jitcc.C
index 6dd40518b..9aec8f24a 100644
--- a/lib/hobbes/eval/jitcc.C
+++ b/lib/hobbes/eval/jitcc.C
@@ -838,7 +838,11 @@ public:
   size_t sz;
   explicit LenWatch(const std::string &fname) : fname(fname), sz(0) {}
   size_t size() const { return this->sz; }
-  void NotifyObjectEmitted(const llvm::object::ObjectFile& o, const llvm::RuntimeDyld::LoadedObjectInfo&) {
+#if LLVM_VERSION_MAJOR >= 8
+  void notifyObjectLoaded(ObjectKey, const llvm::object::ObjectFile &o, const llvm::RuntimeDyld::LoadedObjectInfo &) override {
+#else
+  void NotifyObjectEmitted(const llvm::object::ObjectFile& o, const llvm::RuntimeDyld::LoadedObjectInfo&) override {
+#endif
     for (auto s : o.symbols()) {
       const auto* esr = reinterpret_cast<const llvm::object::ELFSymbolRef*>(&s);
 

From fb9ac7b98656e423ad00bdbc4b3a26ceaec3ea86 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Wed, 17 May 2023 12:16:16 +0800
Subject: [PATCH 38/40] fix hog serven listens only on localhost

---
 include/hobbes/net.H | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/include/hobbes/net.H b/include/hobbes/net.H
index de7918542..8fff2d104 100644
--- a/include/hobbes/net.H
+++ b/include/hobbes/net.H
@@ -160,9 +160,16 @@ inline addrinfo* lookupAddrInfo(const std::string& host, const std::string& port
   memset(&h, 0, sizeof(h));
   h.ai_family   = AF_UNSPEC;
   h.ai_socktype = SOCK_STREAM;
+  const bool isServer = host.empty();
+  const char* hostname = isServer ? nullptr : host.c_str();
+  const char* service = port.empty() ? nullptr : port.c_str();
+  assert(!(hostname == nullptr && service == nullptr));
+  if (isServer) {
+    h.ai_flags = AI_PASSIVE;
+  }
 
   struct addrinfo* addrs = nullptr;
-  switch (getaddrinfo(host.empty()? nullptr : host.c_str(), port.empty() ? nullptr : port.c_str(), &h, &addrs)) {
+  switch (getaddrinfo(hostname, service, &h, &addrs)) {
   case 0:              return addrs;
   case EAI_ADDRFAMILY: throw std::runtime_error("Cannot make socket connection to " + host + ":" + port);
   case EAI_AGAIN:      throw std::runtime_error(host + ":" + port + " is temporarily unavailable");

From 82c108cd0faf954e0cda9ae86dd16187b8b8da39 Mon Sep 17 00:00:00 2001
From: Mo Xiaoming <2188767+mo-xiaoming@users.noreply.github.com>
Date: Sat, 12 Aug 2023 09:26:53 +0800
Subject: [PATCH 39/40] variant like |Close| cause "Internal error, not a
 primitive match table (load vars)" if `isPrimSelection` is on

---
 lib/hobbes/lang/pat/dfa.C |  3 +++
 test/Matching.C           | 14 ++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/lib/hobbes/lang/pat/dfa.C b/lib/hobbes/lang/pat/dfa.C
index ee32cdc8b..16bba1ae0 100644
--- a/lib/hobbes/lang/pat/dfa.C
+++ b/lib/hobbes/lang/pat/dfa.C
@@ -90,6 +90,9 @@ MStatePtr makeSwitch(const MDFA* dfa, const std::string& switchVar, const Switch
     if (jmps.empty()) {
       return dfa->states[defState];
     } else if (isUnit(jmps[0].first->primType())) {
+      if (dfa->inPrimSel) {
+        return dfa->states[jmps[0].second];
+      }
       return actAndThen(assume(var(switchVar, dfa->rootLA), primty("unit"), dfa->rootLA), jmps[0].second);
     } else {
       return MStatePtr(new SwitchVal(switchVar, jmps, defState));
diff --git a/test/Matching.C b/test/Matching.C
index 12d48c74b..fcb5677ca 100644
--- a/test/Matching.C
+++ b/test/Matching.C
@@ -453,3 +453,17 @@ TEST(Matching, noRaceInterpMatch) {
   EXPECT_EQ(wrongMatches.load(), size_t(0));
   c().buildInterpretedMatches(false);
 }
+
+TEST(Matching, isPrimSelectionWithVariant) {
+  std::ostringstream rows;
+  rows << "(\\a b.match a b with\n";
+  rows << "| |Close| _ -> 1\n";
+  for (size_t i = 0; i < 499; ++i) {
+    rows << "| _ " << i << " -> " << i+2 << "\n";
+  }
+  rows << "| _ _ -> -1\n";
+  rows << ")(|Open|::|Open, Close|, 9)";
+  auto f = c().compileFn<int()>(rows.str());
+  EXPECT_EQ(f(), 11);
+}
+

From 924b71fca06c61e606792cc8db8521fb499d4237 Mon Sep 17 00:00:00 2001
From: annalee <150648636+a-n-n-a-l-e-e@users.noreply.github.com>
Date: Thu, 25 Jan 2024 05:47:24 +0000
Subject: [PATCH 40/40] array.H: include cstdint to fix llvm 12+ build

---
 include/hobbes/util/array.H | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/hobbes/util/array.H b/include/hobbes/util/array.H
index 916da009f..065eb517f 100644
--- a/include/hobbes/util/array.H
+++ b/include/hobbes/util/array.H
@@ -3,6 +3,7 @@
 #define HOBBES_UTIL_ARRAY_HPP_INCLUDED
 
 #include <algorithm>
+#include <cstdint>
 #include <cstring>
 #include <functional>
 #include <map>