aram {Function} 包装好的字符串解析回调
 */
function memoize (callback) {
  /**
   * 根据规则来处理当前字符串的回调函数
   *
   * @param {Walker} walker 字符串源码读取工具
   * @param {Rule} rule 字符串解析规则
   * @return {ASTNode} 字符串解析得到的 AST 对象
   */
  return (walker, rule) => {
    // 当查询到有解析结果时，直接返回缓存的解析结果
    let index = walker.index
    let record = walker.query(rule, index)
    if (record) {
      return record[3]
    }
    // 否则执行回调处理字符串，并对解析结果进行存储
    let result = callback(walker, rule)
    walker.record(rule, index, walker.index, result)
    return result
  }
}

/**
 * 当字符串使用当前规则解析失败时，将字符串解析下标恢复到原先的状态
 *
 * @param {Function} callback 字符串解析回调
 * @return {Function} 包装好的字符串解析回调
 */
function restorable (callback) {
  return (walker, rule) => {
    let index = walker.index
    let result = callback(walker, rule)
    // 解析失败只有 undefined（被动解析失败）false（lexer 规则主动判定失败）两种
    // 遇到解析失败时，直接回滚 index
    if (result === undefined || result === false) {
      walker.index = index
    }
    return result
  }
}

/**
 * 对规则属性的工厂方法执行结果做缓存处理
 *
 * @param {Function} callback 字符串解析回调
 * @params {Array.<string>} keys 需要缓存的属性列表
 * @return {Function} 包装好的字符串解析回调
 */
function singleton (callback, keys) {
  let caches = {}
  return (walker, rule) => {
    let cache = caches[rule.type]
    if (!cache) {
      cache = rule
      for (let key of keys) {
        if (typeof cache[key] === 'function') {
          cache[key] = cache[key]()
        }
      }
      caches[rule.type] = cache
    }
    return callback(walker, cache)
  }
}

/**
 * 对字符串执行解析规则
 *
 * @param {Walker} walker 表达式字符串读�