function $parse(exp, interceptorFn, expensiveChecks) {
      var parsedExpression, oneTime, cacheKey;

      expensiveChecks = expensiveChecks || runningChecksEnabled;

      switch (typeof exp) {
        case 'string':
          exp = exp.trim();
          cacheKey = exp;

          var cache = (expensiveChecks ? cacheExpensive : cacheDefault);
          parsedExpression = cache[cacheKey];

          if (!parsedExpression) {
            if (exp.charAt(0) === ':' && exp.charAt(1) === ':') {
              oneTime = true;
              exp = exp.substring(2);
            }
            var parseOptions = expensiveChecks ? $parseOptionsExpensive : $parseOptions;
            var lexer = new Lexer(parseOptions);
            var parser = new Parser(lexer, $filter, parseOptions);
            parsedExpression = parser.parse(exp);
            if (parsedExpression.constant) {
              parsedExpression.$$watchDelegate = constantWatchDelegate;
            } else if (oneTime) {
              parsedExpression.$$watchDelegate = parsedExpression.literal ?
                  oneTimeLiteralWatchDelegate : oneTimeWatchDelegate;
            } else if (parsedExpression.inputs) {
              parsedExpression.$$watchDelegate = inputsWatchDelegate;
            }
            if (expensiveChecks) {
              parsedExpression = expensiveChecksInterceptor(parsedExpression);
            }
            cache[cacheKey] = parsedExpression;
          }
          return addInterceptor(parsedExpression, interceptorFn);

        case 'function':
          return addInterceptor(exp, interceptorFn);

        default:
          return addInterceptor(noop, interceptorFn);
      }
    }
@ngdoc method
@name $parseProvider#setIdentifierFns
@description

Allows defining the set of characters that are allowed in Angular expressions. The function
`identifierStart` will get called to know if a given character is a valid character to be the
first character for an identifier. The function `identifierContinue` will get called to know if
a given character is a valid character to be a follow-up identifier character. The functions
`identifierStart` and `identifierContinue` will receive as arguments the single character to be
identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
mind that the `string` parameter can be two characters long depending on the character
representation. It is expected for the function to return `true` or `false`, whether that
character is allowed or not.

Since this function will be called extensivelly, keep the implementation of these functions fast,
as the performance of these functions have a direct impact on the expressions parsing speed.

@param {function=} identifierStart The function that will decide whether the given character is
  a valid identifier start character.
@param {function=} identifierContinue The function that will decide whether the given character is
  a valid identifier continue character.