code: function Do() {
      if(arguments.length)
          throw new TypeError("Arguments given to Do. Proper usage: Do()(arguments)");
  
      var env = this,
          oldDoQueue = doQueue;
  
      doQueue = [];
      return function(n) {
          var op, x, i;
          if(!doQueue.length) {
              doQueue = oldDoQueue;
              return n;
          }
  
          if(n === true) op = 'flatMap'; // >=
          if(n === false) op = 'map'; // <
          if(n === 0) op = 'kleisli'; // >>
          if(n === 1) op = 'ap'; // *
          if(n === doQueue.length) op = 'concat'; // +
  
          if(!op) {
              doQueue = oldDoQueue;
              throw new Error("Couldn't determine Do operation. Could be ambiguous.");
          }
  
          x = doQueue[0];
          for(i = 1; i < doQueue.length; i++) {
              x = env[op](x, doQueue[i]);
          }
  
          doQueue = oldDoQueue;
          return x;
      };
  }
docs: ## Do()(a)
  
  Creates a new syntax scope. The `a` expression is allowed multiple
  usages of a single operator per `Do` call:
  
  `>=` - flatMap
  `>>` - kleisli
  `<` - map
  `*` - ap
  `+` - concat
  
  The associated name will be called on the bilby environment with
  the operands. For example:
  
  bilby.Do()(bilby.some(1) + bilby.some(2))
  
  Desugars into:
  
  bilby.concat(bilby.some(1), bilby.some(2))