code: function skip1(previousExpr) {
     
     
        if( previousExpr == always ) {
           /* If there is no previous expression this consume command 
              is at the start of the jsonPath.
              Since JSONPath specifies what we'd like to find but not 
              necessarily everything leading down to it, when running
              out of JSONPath to check against we default to true */
           return always;
        }
  
        /** return true if the ascent we have contains only the JSON root,
         *  false otherwise
         */
        function notAtRoot(ascent){
           return headKey(ascent) != ROOT_PATH;
        }
        
        return lazyIntersection(
                 /* If we're already at the root but there are more 
                    expressions to satisfy, can't consume any more. No match.
  
                    This check is why none of the other exprs have to be able 
                    to handle empty lists; skip1 is the only evaluator that 
                    moves onto the next token and it refuses to do so once it 
                    reaches the last item in the list. */
                 notAtRoot,
                 
                 /* We are not at the root of the ascent yet.
                    Move to the next level of the ascent by handing only 
                    the tail to the previous expression */ 
                 compose2(previousExpr, tail) 
        );
                                                                                                                 
     }
docs: Create an evaluator function that moves onto the next item on the
  lists. This function is the place where the logic to move up a
  level in the ascent exists.
  
  Eg, for JSONPath ".foo" we need skip1(nameClause(always, [,'foo']))