ideas to automatically delegate multithreading based on user hints
  somehow specify contingency on certain values?
    do we even need to specify it? use something like PyPy's tainting to track contingency
  use channels like in microthreads but with wrappers that automatically send something over
    the channel and wait for result to return a value, so you never notice the channel. then
    instead of using only microthreads use processes/threads too
  lazy evaluation with threading. when a core is free solve something that's lazy before
    it needs to be solved. this is lazy evaluation in a procedural language, though
  don't use functional programming but track all side-effects, implicitly or explicitly?
  if a loop works on 10000 items and they can all be done concurrently, how do we detect that?
    we could do some sort of virtual loop unrolling, but that only applies when we know the
    max value. otherwise we could just automatically assign to a new core every XXth
    new iteration. the loop conditional would have to be repeated on the other cores.
    knowing contingencies is more complicated when we have conditionals in the loop body.
    a total loop unroll and then proving that each iteration is independent is needless. but
      how do we do it more abstractly? the semantics of the iterator variables needs to be
      compared with the semantics of their use. also maybe comparing two cases can
      be a general proof for the rest of the series, when things are predictable.