寻观「标准库」之书。

寻观「编译器核心」之「编译步骤」之「语法分析」之「具体语法树」之书。

寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「总集」之书。

寻观「编译器核心」之「编译数据」之「操作符」之「操作符操作」之书。

寻「编译器核心」之「编译步骤」之「语法分析」之「函数合集」之书。

寻观「编译器核心」之「编译数据」之「操作符」之「操作符数据结构」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「内建操作符」之「总集」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「内建操作符」之「文言符集」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「内建操作符」之「内建操作符对象定义」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「内建操作符」之「内建操作符类型定义」之书。

寻观「编译器核心」之「编译数据」之「编译配置」之「编译期输出」之书。

寻观「编译器核心」之「编译步骤」之「语法分析」之「表达式解析输入分析」之书。
寻观「编译器核心」之「编译步骤」之「语法分析」之「注释操作」之书。

「操作符在集合中」乃化「操作符」而化（「列」于「操作符」）而「爻」也。
「操作符在集合中」者会「符」而会「集合」而
  （「存在吗」授以「操作符」）于（会「候选」而「等」于（「获取标号」于「符」）于（「获取标号」于「候选」））于「集合」
也。

「结构操作符们」乃「列」于「操作符」也。
「结构操作符们」者
  「列」【
    「顶层寻操作符」，
    「顶层寻观操作符」，
    「顶层寻诵操作符」，
    「顶层寻观诵操作符」，
    「顶层观操作符」，
    「顶层观诵操作符」，
    「顶层诵操作符」，
    「顶层构造声明操作符」，
    「顶层类型声明操作符」，
    「顶层不透明定义声明操作符」，
    「顶层透明定义声明操作符」
  】
也。

「类型操作符们」乃「列」于「操作符」也。
「类型操作符们」者
  「列」【
    「普通函数类型操作符」，
    「派函数类型操作符」，
    「隐派函数类型操作符」，
    「隐派函数无类型类型操作符」，
    「对子类型操作符」，
    「类型判断操作符」
  】
也。

「控制操作符们」乃「列」于「操作符」也。
「控制操作符们」者
  「列」【
    「模式匹配分支符」，
    「模式匹配分支汇总符」，
    「模式匹配符」，
    「爻分支符」，
    「过期的不动点操作符」，
    「递归内联虑操作符」，
    「拉姆达操作符」，
    「有类型的拉姆达操作符」，
    「隐拉姆达操作符」，
    「内联虑操作符」
  】
也。

「操作符标记种类」乃化「操作符」而化「字符串」而「语义标记种类」也。
「操作符标记种类」者会「符」而会「关键词」而
  若「操作符在集合中」于「符」于「结构操作符们」则「结构操作符标记」否则
    若「操作符在集合中」于「符」于「类型操作符们」则「类型操作符标记」否则
      若「操作符在集合中」于「符」于「控制操作符们」则「控制操作符标记」否则
        若「串开头是它吗」于『《《内建类型：』于「关键词」则「内建类型标记」否则
          若「串开头是它吗」于『《《内建函数：』于「关键词」则「内建函数标记」否则
            若「串开头是它吗」于『《《内建』于「关键词」则「内建常量标记」否则「普通操作符标记」
也。

「规约组件语义标记」乃化「操作符」而化（「列」于「栈素」）而化（「列」于「组件」）而「列」于「语义标记草稿」也。
「规约组件语义标记」者会「符」而会「栈素们」而会「组件们」而
  鉴「栈素们」与「组件们」而
    有「罄」与「罄」则「罄」
    或有（「缀」于「素」于「素尾」）与（「缀」于「件」于「件尾」）
    则（虑「当前标记」者（「列」于「语义标记草稿」也鉴
          「素」与「件」而
          有（「栈操作符」于「忽略符序们」于「关键词」）与（「字符串组件」于「忽略组件串」）则
            （「列」【（「构造语义标记草稿」于（「操作符标记种类」于「符」于「关键词」）于「关键词」）】）
          或有（「栈绑定」于「名称」于「忽略前注释」于「忽略后注释」）与「绑定组件」则
            （「列」【（「构造语义标记草稿」于「绑定标识符标记」于「名称」）】）
          或有（「栈绑定」于「名称」于「忽略前注释」于「忽略后注释」）与「元素组件」则
            （「列」【（「构造语义标记草稿」于「绑定标识符标记」于「名称」）】）
          或有（「栈式」于「忽略式」于「标记们」）与「元素组件」则「标记们」
          或有「其他素」与「其他件」则「罄」
      ）
        而
        （「附加」授以「语义标记草稿」）于「当前标记」于（「规约组件语义标记」于「符」于「素尾」于「件尾」））
    或有「其他」则「发生事故」于『规约组件与栈素数量不一致』
也。

「：给定组件的操作符标号，栈（缩减且，反转过的）和组件，其中栈和组件必须是相同长度，
    若匹配成功，返回元素或绑定组件的参数，
    若匹配失败，返回可无：」
「匹配组件获取参数」乃化「整数」而化（「列」于「栈素」）而化（「列」于「组件」）而「或可有」
  于（「列」于「表达式」）也。
「匹配组件获取参数」者（会「符标号」而会「栈素们」而会「组件们」而
  若（「不等于」于（「长度」于「栈素们」）于（「长度」于「组件们」））
  则
    「发生事故」于『栈与组件长度必须相等』
  否则
    （虑「匹配字符串操作符」者
        （化（「列」于（「操作符」合「整数」））而化「字符串」而「爻」也
            （会「符序们」而会「组符名」而
              （「存在吗」授以（「操作符」合「整数」））于（会「符序」而
                虑「栈整符」者（「二对子取零」授以「操作符」授以「整数」）于「符序」而
                虑「栈组序号」者（「二对子取一」授以「操作符」授以「整数」）于「符序」而
                「且」于（「串相等」于（「获取操作符组件字符串」于「栈整符」于「栈组序号」）于「组符名」）
                    于（「等」于（「获取标号」于「栈整符」）于「符标号」））于「符序们」
            ））
      而
      （「从左折叠」授以（「栈素」合「组件」）授以（「或可有」于（「列」于「表达式」）））
      于（会「素组」而遇（「或可有」于（「列」于「表达式」））者「当前参数」而
        鉴「当前参数」而
          有「可无」则「可无」
          或有（「可有」于「当前参数内容」）则（鉴（「栈素」合「组件」也「素组」）而
            有（「栈操作符」于「符序们」于「忽略关键词」）与（「字符串组件」于「组符名」）则（若（「匹配字符串操作符」于
                  「符序们」于「组符名」
              ）
            则
              「可有」授以（「列」于「表达式」）于（「当前参数内容」）
            否则
              「可无」
            ）
            或有「其他」与（「字符串组件」于「名」）则「可无」
            或有「素」与「绑定组件」则（鉴「素」而
              有「栈绑定」于「串」于「前注释」于「后注释」则（「可有」
                  于（（「附加」授以「表达式」）于
                  「当前参数内容」于（（（「列」于「表达式」）也（（「列」【（「添加注释列到表达式」于（「自由变量」于「串」）于「前注释」于「后注释」）】））））））
                  「：要做：这两项我们应该支持，但目前可能会产生多种唯一解
                                或许我们应该比较解析是否生成了结构相同的抽象语法树，
                                    如果是的话则可不报错：」
              或有「其他」则「可无」 「：注：是否要propogate原因？：」
            ）
            或有「素」与「元素组件」则（ 「：COPY Paste：」
              鉴「素」而
                有「栈绑定」于「串」于「前注释」于「后注释」则（「可有」
                  于（（「附加」授以「表达式」）于
                  「当前参数内容」于（（（「列」于「表达式」）也（（「列」【（「添加注释列到表达式」于（「自由变量」于「串」）于「前注释」于「后注释」）】））））））
                或有「栈式」于「式」于「忽略标记们」则（「可有」
                  于（（「附加」授以「表达式」）于「当前参数内容」于（（（「列」于「表达式」）也（（「列」【「式」】））））））
                或有「其他」则「可无」 「：注：是否要propogate原因？：」
            ）
            或有「其他」则（「发生事故」于『表192？』）））
                于（「可有」授以（「列」于「表达式」）于「罄」）
                于（（「拉链合并」授以「栈素」授以「组件」）于「栈素们」于「组件们」）））也。

「进行一次栈尾规约」乃化「字符串」而化（「列」于「栈素」）而「列」
  于（「列」于「栈素」）也。
「进行一次栈尾规约」者会「当前文件名」而会「栈」而
  虑「顶栈符序们」者
    鉴「栈」而
      有（「缀」于（「栈操作符」于「顶栈符序们」于「忽略关键词」）于「余下栈」）则
        「：如果栈顶不可能是prefix operator，：」
        「顶栈符序们」
      或有（「缀」于（「栈式」于「顶式」于「忽略标记们」）于（「缀」
        于（「栈操作符」于「顶栈符序们」于「忽略关键词」）于
        「余下栈」
        ））则
        「顶栈符序们」
      或有「其他」则
        （「列」于（「操作符」合「整数」）也「发生事故」于『405无法进行栈尾规约』）而

  （「串联」授以（「列」于「栈素」））于（（「打表态射」授以（「操作符」合「整数」）授以（「列」于（「列」于「栈素」）））
    于（「顶栈符序们」）于（会「顶栈符序」而
      虑「顶栈整符」者「顶栈符序」中「零」而

      虑「符标号」者（「获取标号」于「顶栈整符」）而
      虑「组件们」者「获取所有组件」于「顶栈整符」而
      若（「大于」于（「长度」于「组件们」）于（「长度」于「栈」））
      则
        （「罄」）
      否则
        （虑「栈素们」者（「反转」授以「栈素」）于（（「取」授以「栈素」）于（「长度」于「组件们」）于「栈」）而
          虑「余下栈素」者（「放」授以「栈素」）于（「长度」于「组件们」）于「栈」而
          虑「参数」者（（「或可有」于（「列」于「表达式」））也（「匹配组件获取参数」于「符标号」于
                「栈素们」于「组件们」
            ））而

          虑「结果」者（「列」于（「列」于「栈素」）也
            鉴「参数」而
              有「可无」则（「非常详细调试打印行」于（会「无」而『参数获取失败』）；
                「罄」
              ）
              或有（「可有」于「参数列」）则（「非常详细调试打印行」
                于（会「无」而『参数获取成功』）；
                （虑「可能阐述」者（（「尝试运行」授以（「或可有」于「表达式」））
                      于（会「无」而「获取阐述」于「顶栈整符」于「当前文件名」于「参数列」）
                      于（会
                      「错误信息」而「发生事故」于（「错误信息」附『「：换行：」当前栈是：』附
                      （「栈表示」于「栈」）附『「：换行：」操作符是：』附（「操作符表示」于「顶栈整符」））））
                  而
                  鉴「可能阐述」而
                    有（「可有」于「阐述式」）则（（（「列」于（「列」于「栈素」））也（（「列」【（（「缀」授以「栈素」）于（「栈式」于
                      「阐述式」于（「规约组件语义标记」于「顶栈整符」于「栈素们」于「组件们」））于「余下栈素」）】）））
                    ）
                    或有「可无」则「罄」
                ）））而

          「结果」
        ）））
也。

「：若规约成功，返回有，若规约失败，返回无：」
「：我们规约时会碰到一种情况
A 式 | B，AB没有优先级关系，这种情况下就应该是 A先吃式，还是B先吃式呢？
我们规约会选后者，首先检查 A的优先级没有比B高，
那么B会不会被移位是一个关键问题！如果我们发现B的优先级也没有A高，那么我们应该报错！
但是在这里，为了减少报错，
我们选择移位！之后在总体规约时就会变成B先吃式。

本函数只进行可能规约并返回结果，不进行移位

我们要返回更新的栈操作符，因为规约与否取决于是什么样的栈操作符
：」
「进行操作符规约」乃化「字符串」而化（「列」于「栈素」）而化「栈素」而「列」
  于（（「列」于「栈素」）合「栈素」）也。
「进行操作符规约」者会「当前文件名」而会「栈」而会「符」而
  虑「递归」者「进行操作符规约」而
  虑「无」者「非常详细调试打印行」于（会「无」而『进行操作符规约中：』附（「栈素表示」于「符」）附『，栈顶：』附（若（「大于」
          于（（「长度」授以「栈素」）于「栈」）于「三」
      ）
  则
    （「栈表示」于（（「取」授以「栈素」）于「三」于「栈」））
  否则
    （「栈表示」于「栈」）））而
  鉴「符」而
    有（「栈操作符」于「符序们」于「当前关键词」）则
          若（「小于」于（（「长度」授以「栈素」）于「栈」）于「二」）
          则
            （（（「列」于（（「列」于「栈素」）合「栈素」））也（「列」【（「栈」与「符」 「：如果栈只有一个或没有元素，原样返回：」）】））
            ）
          否则
            （鉴「栈」而
              有（「缀」于（「栈操作符」于「顶符序们」于「忽略顶关键词」）于「余下栈」）则
                「：如果栈顶不可能是postfix operator，因为移位时会规约：」
                （（（「列」于（（「列」于「栈素」）合「栈素」））也（（「列」【（「栈」与「符」）】））））
              或有（「缀」于（「栈绑定」于「字」于「忽略前注释」于「忽略后注释」）于「余下栈」）则
                （（（「列」于（（「列」于「栈素」）合「栈素」））也（（「列」【（「栈」与「符」）】））））
              或有（「缀」于（「栈式」于「顶式」于「顶式标记们」）
                于（「缀」于（「栈操作符」于「顶栈符序们」于「顶栈关键词」）于「余下栈」））
                则（虑「可以规约条件」者（化（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」）而「爻」
                      也（会「组合」而
                        鉴（「组合」）而有（「整符」与「组件序号」）与（「顶栈整符」与「顶组件序号」）与
                            （「元式」）则若（「等」于「组件序号」于「零」）则
                              （「发生事故」于『后续组件序号不应当等于零』）
                            否则
                              （若（「不等于」
                                    于（「加」于「顶组件序号」于「二」）
                                    于（（「长度」授以「组件」）于（「获取所有组件」于「顶栈整符」））） 「：如果没到结尾，不规约：」
                              则
                                （「阴」）
                              否则
                                （虑「可以规约」者（鉴（（「第N个」授以「组件」）
                                        于（「减」于「组件序号」于「一」）
                                        于（「获取所有组件」于「整符」））
                                    而
                                    有「元素组件」则（若（「大于」于「组件序号」于「一」）则「阳」否则（鉴（「文言优先级关系」
                                            于（「获取符名」于「顶栈整符」）
                                            于（「获取符名」于「整符」））而
                                        有（「可有」于「左规约」）则「阳」
                                        或有（「可有」于「右规约」）则「阴」
                                        或有「可无」则「发生事故」
                                          于（『未定义优先级关系：』附（「获取符名」于「顶栈整符」）附『 与 』附（「获取符名」于
                                              「整符」
                                          ））））
                                    或有「其他」则（「发生事故」授以「爻」）
                                      于（『不可能的组件：299：』附（「组件表示」于「其他」）））而
                                  虑「无」者
                                    「非常详细调试打印行」
                                      于（会
                                      「无」而
                                        『检查可以规约：』
                                          附（「爻表示」于「可以规约」）附『，栈：』附（「栈表示」
                                              于（（「缀」授以「栈素」）于「符」于「栈」）））
                                  而
                                  「可以规约」
                                ））））而
                    虑「所有组合」者（「串联」授以（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」））
                    于（（「打表态射」授以（「操作符」合「整数」）授以（「列」
                          于（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」）））于「符序们」
                          于（会「后续符序」而（（「打表态射」授以（「操作符」合「整数」）授以（（「操作符」合「整数」）
                                  合（「操作符」合「整数」）合
                                  「有」
                              ））于「顶栈符序们」
                                    于（会「顶栈符序」而「后续符序」与「顶栈符序」与「元」））））
                    而
                    虑「可以规约与不可规约组合」者（「条件分类」授以（（「操作符」合「整数」）合（「操作符」合「整数」）
                          合「有」
                      ））于
                      「所有组合」于「可以规约条件」
                    而
                    「：如果全部都可以规约，或者全部都不可以规约，可以采用快速处理：」
                  若（「等」
                    于（（「长度」授以（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」））
                    于（「可以规约与不可规约组合」中「零」））于「零」
                  ）则（
                    「：全部不可以规约，原样返回：」
                    （（「列」于（（「列」于「栈素」）合「栈素」））也（「列」【（「栈」与「符」 「：如果栈只有一个或没有元素，原样返回：」）】））
                  ）
                  否则
                    （若（「等」
                          于（（「长度」授以（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」））
                          于（「可以规约与不可规约组合」中「一」））于「零」
                      ）则（
                        「：全部都可以规约，进行一次规约：」
                          （「串联」授以（（「列」于「栈素」）合「栈素」））
                          于（（「打表态射」授以（「列」于「栈素」）授以（「列」于（（「列」于「栈素」）合「栈素」）））
                            于（「进行一次栈尾规约」于「当前文件名」于「栈」）
                              于（会「后栈」而（「递归」于「当前文件名」于「后栈」于「符」））））
                    否则
                      （
                        「：不一致，全部打散：」
                        （「串联」授以（（「列」于「栈素」）合「栈素」））
                        于（（「打表态射」授以（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」）授以（「列」
                              于（（「列」于「栈素」）合「栈素」）））于
                              「所有组合」
                              于（会「组合」而鉴（（（「操作符」合「整数」）合（「操作符」合「整数」）合「有」）也
                                「组合」
                              ）而有
                              （「整符」与「组件序号」）与（「顶栈整符」与「顶组件序号」）与（「元式」）
                              则
                                「递归」于「当前文件名」
                                  于（（「缀」授以「栈素」）
                                    于（「栈式」于「顶式」于「顶式标记们」）
                                    于（（「缀」授以「栈素」）
                                    于（「栈操作符」于（（（「列」于（「操作符」合「整数」））也（（「列」【（「顶栈整符」与「顶组件序号」）】））））于
                                      「顶栈关键词」）于「余下栈」））
                                        于（「栈操作符」于（（（「列」于（「操作符」合「整数」））也（（「列」【（「整符」与「组件序号」）】））））于
                                          「当前关键词」））））））
              或有「其他栈」则「发生事故」于『栈的格式有问题』
            ）
    或有「其他」则「发生事故」于『不存在』也。

「移位或规约一步」乃化「字符串」而化（「列」于「栈素」）而化（「列」于「栈素」）而「列」
  于（「列」于「栈素」）也。
「移位或规约一步」者会「当前文件名」而会「已有」而会「次字们」而
  （ 「：我们更新了次字匹配，匹配的次字永远可以移位：」
    虑「无」者（「详细调试打印行」于（会「无」而『移位或规约一步：』附（「栈表示」
            于（（「反转」授以「栈素」）于「次字们」））））而
    虑「递归」者「移位或规约一步」而
    鉴（「已有」与「次字们」）而
      有「全栈」与「罄」则（（（「列」于（「列」于「栈素」））也（（「列」【「全栈」】））））
    「：绑定：」
      或有（「栈」）与（「缀」于（「栈绑定」于「甲」于「前注释」于「后注释」）于「后次字们」）则（「递归」于
        「当前文件名」于（（「缀」授以「栈素」）于（「栈绑定」于「甲」于「前注释」于「后注释」）于（「栈」））于
        「后次字们」
      ）
    「：表达式：」
      或有（「栈」）与（「缀」于（「栈式」于「式」于「标记们」）于「后次字们」）则（「递归」于「当前文件名」
        于（（「缀」授以「栈素」）于（「栈式」于「式」于「标记们」）于（「栈」））于
        「后次字们」
      ）
    「：普通操作符：」
    「：TODO进行规约后更新绑定信息？？？：」
      或有（「栈」）与（「缀」于（「栈操作符」于「先符序们」于「先关键词」）于「后次字们」）则 「：TODO 进行多次移位规约：」
    （（「串联」授以（「列」于「栈素」））于（（「打表态射」授以（（「列」于「栈素」）合「栈素」）授以（「列」
              于（「列」于「栈素」）））于（「进行操作符规约」于「当前文件名」于「栈」
              于（「栈操作符」于「先符序们」于「先关键词」））
              于（会「规约后栈及符」而
                鉴（「规约后栈及符」）而
              有「规约后栈」与（「栈操作符」于「符序们」于「关键词」）
              则（虑「无」者「非常详细调试打印行」
                于（会「无」而『进行操作符规约后栈之一：』附（「栈表示」于「规约后栈」））
                  而
                  虑「末尾符序们及非末尾符序们」者（（「条件分类」授以（「操作符」合「整数」））于「符序们」
                    于（会「符序」而鉴「符序」而有「整符」与「组件序号」则（「等」于
                      「组件序号」
                      于（「减」于（（「长度」授以「组件」）于（「获取所有组件」于（「整符」）））于「一」））））
                  而
                  「：分开处理末尾符序与非末尾符序：」
                      虑「末尾符序们」者「末尾符序们及非末尾符序们」中「零」而
                      虑「非末尾符序们」者「末尾符序们及非末尾符序们」中「一」
                      而
                      （「附加」授以（「列」于「栈素」））
                      于（若（「大于」于（（「长度」授以（「操作符」合「整数」））于「末尾符序们」）于「零」）则（（「串联」
                            授以（「列」于「栈素」））
                            于（（「打表态射」授以（「列」于「栈素」）授以（「列」于（「列」于「栈素」）））
                            于（「进行一次栈尾规约」于「当前文件名」
                            于（（「缀」授以「栈素」）于（「栈操作符」于「末尾符序们」于「关键词」）于「规约后栈」））
                            于（会「后栈」而（「递归」于「当前文件名」于「后栈」于「后次字们」））））
                      否则
                        「罄」）
                        于（若（「等」于（（「长度」授以（「操作符」合「整数」））于「非末尾符序们」）于「零」）则
                          （「罄」）
                        否则
                          （「递归」于「当前文件名」
                            于（（「缀」授以「栈素」）于（「栈操作符」于「非末尾符序们」于「关键词」）于「规约后栈」）于
                              「后次字们」
                          ））））））
      「：结束：」
      或有「栈」与（（「列」【「栈文件结尾」】））则（若（「大于」于（（「长度」授以「栈素」）于「栈」）于「一」）
      则
        （（「串联」授以（「列」于「栈素」））于（（「打表态射」授以（「列」于「栈素」）授以（「列」
                于（「列」于「栈素」）））于（「进行一次栈尾规约」于「当前文件名」于「栈」）
                于（会「后栈」而（「递归」于「当前文件名」于「后栈」于「次字们」））））
      否则
        （（「列」于（「列」于「栈素」））也（（「列」【（（「缀」授以「栈素」）于「栈文件结尾」于「栈」）】）））
      ）
          「：其他故障：」
      或有「其他」与「输入」则「发生事故」于（『库/编译器核心/编译步骤/语法分析/表达式解析。豫:210 表达式解析遇到故障，在输入』
          附（「栈表示」于（（「反转」授以「栈素」）于「输入」））附『「：换行：」当前栈是：』附（「栈表示」于「其他」））
      或有「其他」则「发生事故」于『解表91』
  ）也。

「：一定会消耗输入：」
「单一步骤」乃化「字符串」而化（「列」于「栈素」）而化（「列」于「表达式」）而化（化「字符串」而化（「列」于「栈素」）而
    「有」
）而「列」于（（「列」于「栈素」）合（「列」于「表达式」））也。
「单一步骤」者会「当前文件名」而会「已有」而会「输入」而会「调试」而
  鉴「输入」而
    有「罄」则「发生事故」于『输入不可为空105』
    或有「其他」则（虑「无」者「详细调试打印行」于（会「无」而『正在执行单一步骤，输入是：』附（「表达式列表示」于
            「输入」
        ）附
        『， 栈是』附（「栈表示」于「已有」））而
                    虑「输入解析」者「分析输入」于「已有」于「输入」于「调试」而

                    虑「结果」者（「串联」授以（（「列」于「栈素」）合（「列」于「表达式」）））
                    于（（「态射」）于
                    「输入解析」
                    于（会「甲」而
                      鉴（（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」））也「甲」）而
                        有「更新已有」与「次字们」与「剩余输入」则（鉴（「移位或规约一步」于「当前文件名」于「更新已有」于
                              「次字们」
                          ）而
                          有「罄」则（「调试」于『无规约：』
                            于（（「附加」授以「栈素」）
                            于（（「反转」授以「栈素」）于「次字们」）于
                            「已有」 「：栈永远是反着的，打印时顺序会颠倒：」）；
                            （「罄」授以（（「列」于「栈素」）合（「列」于「表达式」））））
                          或有「新已有列」则（（「打表态射」授以（「列」于「栈素」）授以（（「列」于「栈素」）合（「列」于
                                    「表达式」
                                ）））于
                                「新已有列」于（会「新已有」而「新已有」与「剩余输入」）））
                        或有「其他2」则（「发生事故」于『匹配失误116』）））而

                    「结果」
    ）也。

「：返回可能的解：」
「所有步骤」乃化「字符串」而化（「列」于（「表达式」合（「列」于「语义标记草稿」））） 「：已完成的：」而
  化（「列」于（（「列」于「栈素」）合（「列」于「表达式」））） 「：待探索的：」而
  化（化「字符串」而化（「列」于「栈素」）而「有」） 「：调试：」而
  「列」于（「表达式」合（「列」于「语义标记草稿」））也。
「所有步骤」者会「当前文件名」而会「已有结果」而会「待处理理解」而会「调试」而
  鉴「待处理理解」而
    有「罄」则「已有结果」
    或有（「缀」于（「已有」与「输入」）于「待处理尾」）则（鉴「输入」而
      有「罄」则（虑「最终结果」者
                    （「列」于（「表达式」合（「列」于「语义标记草稿」））也
            （「串联」授以（「表达式」合（「列」于「语义标记草稿」）））
                  于（（「打表态射」授以（「列」于「栈素」）
                    授以（「列」于（「表达式」合（「列」于「语义标记草稿」））））
                    于（「移位或规约一步」于「当前文件名」于「已有」
                      于（（（「列」于「栈素」）也（（「列」【「栈文件结尾」】）））））
                      于（会
                      「结果」而
                      鉴「结果」而
                      有「全栈」则（鉴「全栈」而
                        有（（「列」【「栈文件结尾」】））则（（（「列」于（「表达式」合（「列」于「语义标记草稿」）））也（（「列」【（（「式节点」于「空缺」于「罄」）与「罄」）】）））
                        ）
                        或有（（「列」【「栈文件结尾」，（「栈式」于「式」于「标记们」）】））
                        则
                          （（（「列」于（「表达式」合（「列」于「语义标记草稿」）））也（（「列」【（「式」与「标记们」）】））））
                        或有「其他」则（「调试」于『全栈非单一表达式：』于「其他」；
                          「罄」
                        ） 「：解析失败：」
                      ）
                      「： 或有「可无」则（调试于『无尾规约』于「已有」；空） ：」
）））而
                  「所有步骤」于「当前文件名」于（（「附加」授以（「表达式」合（「列」于「语义标记草稿」）））于
                  「已有结果」于「最终结果」）于「待处理尾」于「调试」
      ）
      或有「其他」则（
        「： 粗略调试打印行于（会无而『表达式解析调试信息：当前已有表达式数：』附（整数表示于（长度于已有结果））附『，待处理理解个数：』附（整数表示于（长度于待处理理解））
                    附『，当前剩余输入长度：』附（整数表示于（长度于输入））
                    附『，当前输入头：』附（若（长度于输入）大于二
                                            则（「表达式列表示」于（取于二于输入））
                                            否则（「表达式列表示」于（输入）））
                    附『，当前栈头：』附（若（长度于已有）大于二
                                            则（「栈表示」于（取于二于已有））
                                            否则（「栈表示」于（已有））））。 ：」
        虑「下步」者「单一步骤」于「当前文件名」于「已有」于「输入」于「调试」而
        虑「结果」者（「所有步骤」于「当前文件名」于「已有结果」
          于（（「附加」授以（（「列」于「栈素」）合（「列」于「表达式」）））于「待处理尾」于「下步」）于
          「调试」
        ）而
        「结果」
      ））也。

「进行解析及语义标记」乃化「字符串」而化（「列」于「表达式」） 「：输入：」而
  （「表达式」合（「列」于「语义标记草稿」））也。
「进行解析及语义标记」者会「当前文件名」而会「输入」而
  「： 打印行于（『表达式解析：进行解析：』附（「表达式列表示」于（输入）））。 ：」
  虑「失败解析」者（（「引用类」于（「列」于（「列」于「栈素」）））也（「新引用」授以（「列」于（「列」于「栈素」）））
    于（「罄」授以（「列」于「栈素」）））而
  虑「调试」者（（化「字符串」而化（「列」于「栈素」）而「有」）也（会「信息」而会「栈列」而
        （虑「无」者（「详细调试打印行」于（会「无」而『分支解析失败，』附「信息」附『，栈：』附（「栈表示」于「栈列」）））
          而
          「写引用」于「失败解析」于（（「缀」授以（「列」于「栈素」））于「栈列」于（「读引用」于「失败解析」）））））
  而
  虑「结果」者（（「表达式」合（「列」于「语义标记草稿」））也（「尝试运行」授以（「表达式」合（「列」于
            「语义标记草稿」
        ）））
        于（会「不要」而鉴（「所有步骤」于「当前文件名」于（「罄」授以（「表达式」合（「列」于「语义标记草稿」）））
              于（（（「列」于（（「列」于「栈素」）合（「列」于「表达式」）））也（（「列」【（（「罄」授以「栈素」）与「输入」）】））））于「调试」
          ）而
            有「罄」则
              「发生事故」于（『无法解析，可能的理解：「：换行：」』附
              （「间合」于『，「：换行：」』于（（「态射」）于（「读引用」于「失败解析」）于「栈表示」）））
              附『「：换行：」输入是：』附（「表达式列表示」于「输入」）
            或有（（「列」【「唯一解」】））则
              （「唯一解」）
            或有「多种解法」则（（「发生事故」于『多于一个解法：「：换行：」』附
                  （「间合」于『「：换行：」』于（（「态射」）
                    于（「多种解法」）于（会「解」而「表达式表示」于（「解」中「零」））））
                    附『「：换行：」输入是：』附（「表达式列表示」于「输入」））））
                    于（会「错误信息」而「发生事故」于（「错误信息」）））
  而
  「结果」
也。

「进行解析」乃化「字符串」而化（「列」于「表达式」） 「：输入：」而
  「表达式」也。
「进行解析」者会「当前文件名」而会「输入」而
  （「进行解析及语义标记」于「当前文件名」于「输入」）中「零」
也。

「解表达式」乃化（「列」于「表达式」）而「表达式」也。
「解表达式」者会「树列」而
  （「进行解析」于『』于「树列」）
也。

「解表达式默认操作符」乃化「字符串」而化（「列」于「表达式」）而「表达式」也。
「解表达式默认操作符」者会「当前文件名」而会「树列」而
  「进行解析」于「当前文件名」于「树列」
也。

「解表达式默认操作符及语义标记」乃化「字符串」而化（「列」于「表达式」）而（「表达式」合（「列」于「语义标记草稿」））
也。
「解表达式默认操作符及语义标记」者会「当前文件名」而会「树列」而
  「进行解析及语义标记」于「当前文件名」于「树列」
也。

（「写引用」授以（「函数合集」之「解表达式类型」））于「函数合集」之「解表达式引用」于「解表达式」。
（「写引用」授以（「函数合集」之「解表达式默认操作符类型」））于「函数合集」之「解表达式默认操作符引用」于
    「解表达式默认操作符」。
