docs: function fo() {
      var env = squishy,
          prevFoQueue = foQueue;
  
      if(arguments.length) {
          env.error('Expecting no arguments given to fo. Use fo()(arguments)')();
      }
  
      foQueue = [];
  
      //
      //  ## proxy(prop)(a)(b)
      //
      //  Lazy dynamic composing of structures / containers together via a property.
      //
      var proxy = curry(function(prop, a, b) {
          return env[prop](a, b);
      });
  
      return function(n) {
          var op,
              x;
  
          if(!foQueue.length) {
              foQueue = prevFoQueue;
              return n;
          }
  
          // Possible syntax for `chain`
          // `>= > === ==`
          if(n === false) {
              op = proxy('chain');
  
          // Possible syntax for `andThen` (inverted `compose`)
          // `>> >>> &`
          } else if(n === 0) {
              op = andThen;
  
          // Possible syntax for `compose`
          // `<<`
          } else if(n === Math.pow(2, (2 << foQueue.length) - 3)) {
              op = proxy('compose');
  
          // Possible syntax for `ap`
          // `*`
          } else if(n === Math.pow(2, foQueue.length * (foQueue.length + 1) / 2)) {
              op = proxy('ap');
  
          // Possible syntax for `concat`
          // `+ | ^`
          } else if(n === (2 << foQueue.length) - 2) {
              op = proxy('concat');
  
          // Possible syntax for `map`
          // `%`
          } else if(n === 2) {
              op = proxy('map');
  
          // Possible syntax for `minus`
          // `-`
          } else if(n < 0) {
              op = minus;
  
          // Possible syntax for `sequence`
          // `< <= !== !=`
          } else if(n === true) {
              op = sequence;
  
          } else {
              foQueue = prevFoQueue;
              env.error("Couldn't determine operation. Has fo.unsafeSetValueOf been called for all operands?")();
          }
  
          x = env.reduce(foQueue, function(a, b) {
              /* Unbox a overload if it is wrapped in */
              var left = isBox(a) ? a.extract() : a,
                  right = isBox(b) ? b.extract() : b;
  
              return op(left).call(left, right);
          });
  
          foQueue = prevFoQueue;
  
          return x;
      };
  }