- Limbo is a programming language exclusive to the Inferno operating
  system which has been developed by the same people as Plan9
  (although it's now maintained by a different team)
- Inferno can be installed in hosted mode on Linux, this gives you the
  necessary tools, standard lib and environment to run compiled code
- While you can run the `limbo` compiler from your Linux shell, you
  can execute the `.dis` files only from within `emu`
- For this reason the `run` script does some magic with `bind` to make
  the relevant parts of the host system accessible in the guest system
- An oddity about the `init` procedure is that you must provide an
  argument for drawing graphics, even if you write a textual program
- The language itself feels very much like Go and has most of its
  features, including light-weight threads, channels, garbage
  collection, strings as value types, slices, etc.
- While you have function references and can pass/return them, you
  cannot create anonymous functions (closures aren't a thing either)
- There is syntax for variadic args (as seen in `sys.m`), but no way
  to retrieve them, so in effect, only built-in modules have variadic
  functions and there is no way to define your own
- You must declare modules, much like in C, however duplicate
  declarations from multiple imports are considered an error
- Import of modules is done at runtime which leads to the curious
  idiom of each declaring a `PATH` constant pointing to an absolute
  path.  This means that some tweaking of include paths is a must,
  however this is relatively simple to do with bind mounts.
- The compiler is pretty smart and can figure out type mismatches and
  infer types at compile-time for you
- It's not so good at runtime failures, like bogus imports and
  dereferencing `nil`
- The grammar for declarations doesn't cover all possible
  combinations, so you'll have to declare your own types for anything
  complicated
- I'm not terribly happy with the existing hash table implementations,
  so I might have to do my own (one has a struct as value that holds
  all three possible value types, the other allows generic types only
  and is missing a method for retrieving keys/values)
- The language has a `T` type for generics, but it only works on
  reference types (and strings for some reason)
- `regex.m` is very basic and doesn't support predefined character
  classes