寻观「标准库」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树数据」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树基础操作」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树表示」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「内建常量数据」之书。

寻观「拓展库」之「顺序标识符」之「顺序标识符」之书。

「参数节点式」乃化「参数形式」而化（「列」于「表达式」）而「表达式」也。
「参数节点式」者会「形」而会「参数们」而
  「式节点」于（「参数节点」于「形」）于「参数们」也。

「函数调用式」乃化「表达式」而化（「列」于「表达式」）而「表达式」也。
「函数调用式」者会「函数」而会「参数节点们」而
  「式节点」于「函数调用」于（（「缀」授以「表达式」）于「函数」于「参数节点们」）也。

「分组函数调用式」乃化「参数形式」而化「表达式」而化（「列」于「表达式」）而「表达式」也。
「分组函数调用式」者会「形」而会「函数」而会「参数们」而
  「函数调用式」于「函数」于（（「列」【（「参数节点式」于「形」于「参数们」）】））也。

「解构函数调用式」乃化「表达式」而「表达式」合（「列」于「表达式」）也。
「解构函数调用式」者会「式」而
  鉴「式」而
    有（「式节点」于「函数调用」于（「缀」于「头」于「参数节点们」））则
      「头」与（「串联」于（（「态射」）于「参数节点们」于（会「参数节点式」而
        鉴「参数节点式」而
          有（「式节点」于（「参数节点」于「忽略形」）于「参数们」）则「参数们」
          或有「其他」则「发生事故」于『函数调用脊不是参数节点』）））
    或有「其他」则「发生事故」于『不是函数调用式』
也。

「添加函数调用参数」乃化「表达式」而化「参数形式」而化「表达式」而「表达式」也。
「添加函数调用参数」者会「函数」而会「形」而会「参数」而
  虑「新参数节点」者「参数节点式」于「形」于（（「列」【「参数」】））而
  鉴「函数」而
    有（「式节点」于「函数调用」于「项们」）则
      「式节点」于「函数调用」于（「附加」于「项们」于（（「列」【「新参数节点」】）））
    或有「其他」则
      「函数调用式」于「函数」于（（「列」【「新参数节点」】））
也。

「拆分函数调用末参数」乃化「表达式」而「表达式」合「参数形式」合「表达式」也。
「拆分函数调用末参数」者会「式」而
  鉴「式」而
    有（「式节点」于「函数调用」于「项们」）则（鉴（「反转」于「项们」）而
      有（「缀」于（「式节点」于（「参数节点」于「形」）于（（「列」【「参数」】）））于「反前项们」）
      则（虑「前项们」
        者「反转」于「反前项们」而
          鉴「前项们」
          而
            有（（「列」【「头」】））则「头」与「形」与「参数」
            或有（「缀」于「头」于（「缀」于「次」于「余」））则（「式节点」于「函数调用」于「前项们」）与「形」与
            「参数」
            或有「罄」则「发生事故」于『函数调用必须有头』
      ）
      或有「其他」则「发生事故」于『函数调用必须有头和至少一个单参数节点』
    ）
    或有「其他」则「发生事故」于『不是函数调用』
也。

「函数类型」乃化「表达式」而化「表达式」而「表达式」也。
「函数类型」者会「定义域」而会「值域」而
  鉴「值域」而
    有（「式节点」于「箭头类型节点」于「后类型们」）则
      「式节点」于「箭头类型节点」于（「缀」于「定义域」于「后类型们」）
    或有「其他值域」则
      「式节点」于「箭头类型节点」于（（「列」【「定义域」，「值域」】））
也。

「多参数函数类型」乃化（「列」于「表达式」 「：非空定义域列：」
）而化「表达式」而「表达式」也。
「多参数函数类型」者会「定义域们」而会「值域」而
  鉴「定义域们」而
    有「罄」则「发生事故」于『函数类型必须至少有一个显式参数』
    或有「非空定义域们」则「式节点」于「箭头类型节点」于（「附加」于「定义域们」于（（「列」【「值域」】）））
也。

「拆分多参数函数类型」乃化「表达式」而（「或可有」于（（「列」于「表达式」）合「表达式」））也。
「拆分多参数函数类型」者会「类」而
  鉴「类」而
    有（「式节点」于「箭头类型节点」于「类型们」）则（鉴（「反转」于「类型们」）而
      有（「缀」于「值域」于「反定义域们」）则（鉴「反定义域们」而
        有「罄」则「发生事故」于『箭头类型节点必须至少包含一个定义域和一个值域』
        或有「非空反定义域们」则「可有」于（（「反转」于「反定义域们」）与「值域」））
      或有「罄」则「发生事故」于『箭头类型节点不可以为空』
    ）
    或有「其他」则「可无」授以（（「列」于「表达式」）合「表达式」）
也。

「拆分首函数类型参数」乃化「表达式」而（「或可有」于（「表达式」合「表达式」））也。
「拆分首函数类型参数」者会「类」而
  鉴「类」而
    有（「式节点」于「箭头类型节点」于（「缀」于「定义域」于「后类型们」））则（鉴「后类型们」而
      有「罄」则「发生事故」于『箭头类型节点缺少值域』
      或有（（「列」【「值域」】））则「可有」于（「定义域」与「值域」）
      或有（「缀」于「次定义域」于「再后类型们」）则
        「可有」于（「定义域」与（「式节点」于「箭头类型节点」于「后类型们」）））
    或有「其他」则「可无」授以（「表达式」合「表达式」）
也。

「隐式类型函数类型」乃化「字符串」而化「表达式」而「表达式」也。
「隐式类型函数类型」者会「参数名」而会「值域」而
  鉴「值域」而
    有（「式节点」于（「隐式派类型节点」于「参数个数」）于（（「列」【「绑定值域」】）））则
      「式节点」于（「隐式派类型节点」于（「加」于「参数个数」于「一」））
        于（（「列」【（「进行抽象」于「参数名」于「绑定值域」）】））
    或有「其他值域」则
      「式节点」于（「隐式派类型节点」于「一」）于（（「列」【（「进行抽象」于「参数名」于「值域」）】））
也。

「应用首隐式类型参数」乃化「表达式」而化「表达式」而「表达式」也。
「应用首隐式类型参数」者会「类」而会「参数」而
  鉴「类」而
    有（「式节点」于（「隐式派类型节点」于「参数个数」）于（（「列」【「绑定值域」】）））
    则（虑「后值域」者「式替换」于
      「参数」于「绑定值域」
        而
        若（「等」于「参数个数」于「一」）则「后值域」否则
          （「式节点」于（「隐式派类型节点」于（「减」于「参数个数」于「一」））于（（「列」【「后值域」】））））
    或有「其他」则「发生事故」于『只能向隐式派类型应用隐式类型参数』
也。

「整数类型」者「内建」于「内建类型整数」也。
「爻类型」者「内建」于「内建类型爻」也。
「字符串类型」者「内建」于「内建类型字符串」也。
「动态分类值类型」者「内建」于「内建类型动态分类值」也。
「有类型」者「内建」于「内建类型有」也。
「自由变量类型」者遇「字符串」者「名」而「自由变量」于「名」也。

「内建物类型」乃化「内建常量」而「表达式」也。 「：Self - referential 包含对于自我的引用， used to initialize context 用来初始化命名环境 ：」
  「内建物类型」者会「量」而鉴「量」而
    有「内建类型字符串」则「内建元类型式」
    或有「内建类型整数」则「内建元类型式」
    或有「内建类型小数」则「内建元类型式」
    或有「内建类型动态分类值」则「内建元类型式」
    或有「内建类型有」则「内建元类型式」
    或有「内建类型爻」则「内建元类型式」
    或有「内建类型元类型」则「内建元类型式」
    或有「内建爻阳」则「内建」于「内建类型爻」
    或有「内建爻阴」则「内建」于「内建类型爻」
    或有「内建有元」则「内建」于「内建类型有」
    或有「内建函数整数相等」则「函数类型」于（「整数类型」）于（「函数类型」于（「整数类型」）于「爻类型」）
    或有「内建函数整数大于」则「函数类型」于（「整数类型」）于（「函数类型」于（「整数类型」）于「爻类型」）
    或有「内建函数整数减」则「函数类型」于（「整数类型」）于（「函数类型」于（「整数类型」）于「整数类型」）
    或有「内建函数抛出异常」则
      （「隐式类型函数类型」于『乙』于（「函数类型」于（「字符串类型」）于（「自由变量类型」于『乙』）））
    或有「内建函数尝试运行」则（「隐式类型函数类型」于『乙』于（「函数类型」
          于（「式节点」
            于（「元组类型节点」）于（（「列」【（「函数类型」于（「有类型」）于（「自由变量类型」于『乙』）），（「函数类型」于（「字符串类型」）于（「自由变量类型」于『乙』））】）））
            于（「自由变量类型」于『乙』）））
    或有「内建函数以当前续延调用」则（「隐式类型函数类型」于『乙』
      于（「函数类型」于（「函数类型」于（「隐式类型函数类型」于
          『丙』于（「函数类型」于（「自由变量类型」于『乙』）于（「自由变量类型」于『丙』）））
          于（「自由变量类型」于『乙』））于（「自由变量类型」于『乙』）））
    或有「其他」则（「式节点」于「待定节点」于「罄」）
也。

「：会包含重复的，rigid variable：」
「读取式自由硬性变量」乃化「表达式」而（「列」于「字符串」）也。
「读取式自由硬性变量」者会「式」而
  鉴「式」而
    有「自由变量」于「名」则（（「列」【「名」】））
    或有「绑定变量」于「名」则「罄」
    或有「式节点」于（「其他节点」）于「参」则「串联」于（（「态射」）于「参」于「读取式自由硬性变量」）
    或有「绑定」于「名」于「下式」则「读取式自由硬性变量」于（「下式」）
也。

「是自由变量」乃化「表达式」而「爻」也。
「是自由变量」者会「式」而鉴「式」而
  有（「自由变量」于「名」）则「阳」
  或有「其他」则「阴」也。

「表达式是绑定」乃化「表达式」而「爻」也。
「表达式是绑定」者会「式」而鉴「式」而
  有「绑定」于「名」于「下式」则「阳」
  或有「其他」则「阴」也。

「表达式是返回自由变量」乃化「表达式」而「爻」也。
「表达式是返回自由变量」者会「式」而鉴「式」而
  有「绑定」于「名」于「下式」则（虑「抽象名及后下式」者「解构抽象」于「式」而
                                  鉴（「抽象名及后下式」中「一」）而
                                    有（「自由变量」于「变量名」）则
                                      （「串相等」于（「抽象名及后下式」中「零」）于「变量名」）
                                    或有「其他」则「阴」
  ）
  或有「其他」则「阴」也。

「：返回的绑定不会重复表达式中的字符串，也不会重复自由变量：」

「模式匹配新变量转自由变量」乃化「表达式」而「表达式」也。
「模式匹配新变量转自由变量」者会「式」而
  鉴「式」而
    有「自由变量」于「名」则「自由变量」于「名」
    或有「绑定变量」于「名」则「绑定变量」于「名」
    或有「式节点」于（「模式匹配新变量」于「名」）于「参」则「自由变量」于「名」
    或有「式节点」于「其他节点」于「参」则「式节点」于（「其他节点」）
      于（（「态射」）于「参」于「模式匹配新变量转自由变量」）
    或有「绑定」于「名」于「下式」则「抽象表达式操作」于「式」于「模式匹配新变量转自由变量」
也。

「式文件引用替换」乃化（化「字符串」而（「或可有」于「表达式」））而化「表达式」而「表达式」也。
「式文件引用替换」者会「替换」而会「式」而
  鉴「式」而
    有「自由变量」于「名」则「自由变量」于「名」
    或有「绑定变量」于「名」则「绑定变量」于「名」
    或有「式节点」于（「文件引用节点」于「文件名」）于「罄」则
      （鉴「替换」于「文件名」而
      有（「可有」于「替换式」）则「替换式」
      或有「可无」则「式」）
    或有「式节点」于「其他节点」于「参」则「式节点」于（「其他节点」）
      于（（「态射」）于「参」于（会「待替换式」而「式文件引用替换」于「替换」于「待替换式」））
    或有「绑定」于「名」于「下式」则「抽象表达式操作」于「式」
      于（会「待替换式」而「式文件引用替换」于「替换」于「待替换式」）
也。

「是直接变量」乃化「表达式」而「爻」也。
「是直接变量」者会「式」而鉴「式」而
  有（「自由变量」于「名」）则「阳」
  或有「式节点」于（「自由变量标注节点」于「标注」）于（（「列」【「内式」】））则（「是直接变量」于「内式」）
  或有「式节点」于（「非自由变量节点」于「名」）于「罄」则「阳」
  或有「其他」则「阴」也。

「读取直接变量」乃化「表达式」而「字符串」也。
「读取直接变量」者会「式」而鉴「式」而
  有（「自由变量」于「名」）则「名」
  或有「式节点」于（「自由变量标注节点」于「标注」）于（（「列」【「内式」】））则（「读取直接变量」于「内式」）
  或有「式节点」于（「非自由变量节点」于「名」）于「罄」则「名」
  或有「其他」则「发生事故」于（『不是直接变量，而是』附（「表达式表示」于「式」））也。

「是文件引用节点」乃化「表达式」而「爻」也。
「是文件引用节点」者会「式」而鉴「式」而
  有（「式节点」于（「文件引用节点」于「文件名」）于「罄」）则「阳」
  或有「式节点」于（「自由变量标注节点」于「标注」）于（（「列」【「内式」】））则（「是文件引用节点」于「内式」）
  或有「其他」则「阴」也。

「读取文件引用节点」乃化「表达式」而「字符串」也。
「读取文件引用节点」者会「式」而鉴「式」而
  有（「式节点」于（「文件引用节点」于「文件名」）于「罄」）则「文件名」
  或有「式节点」于（「自由变量标注节点」于「标注」）于（（「列」【「内式」】））则（「读取文件引用节点」于「内式」）
  或有「其他」则「发生事故」于（『不是文件引用节点，而是』附（「表达式表示」于「式」））也。

「文件定义引用式」乃化「字符串」而化「字符串」而化「整数」而「表达式」也。
「文件定义引用式」者会「文件名」而会「定义名」而会「序数」而
  「式节点」于（「文件定义引用节点」于「文件名」于「定义名」于「序数」）于「罄」也。

「树组找到定义」乃化「表达式树组」而化「字符串」而「爻」合「表达式」也。
「树组找到定义」者会「树组」而会「搜索串」而
  「尝试运行」于（会「无」而（（「爻」合「表达式」）也（「列表搜索」之「列表读取二」于「树组」于「搜索串」）））
    于（会
      「错误」而
      「发生事故」于「错误」附『「：换行：」在找定义时：』附（「间合」于『，』
        于（（「态射」）于「树组」于「三对子取零」）））
也。

「简单内联虑变换」乃化「表达式」 「：当前简单式：」而
  化（「或可有」于（化「字符串」而「表达式」）） 「：继续，见求值正则变换：」而
  「表达式」也。
「简单内联虑变换」者会「式」而会「继续」而
  （虑「名」者（「下个字符序数」于『变_』）而
    「式节点」于「内联虑」于（（「列」【「式」，（「进行抽象」
            于（「名」）于（鉴「继续」而
            有（「可有」于「继续操作」）则「继续操作」于「名」
            或有「可无」则「自由变量」于「名」））】）））

也。

「解构抽象并继续」乃承「甲」而化「表达式」 「：绑定式：」而
  化（化「字符串」而化「表达式」 「：解构后的绑定式：」而
      「甲」
  ）而「甲」也。
「解构抽象并继续」者会「绑定式」而会「后续」而
  虑「绑定名及后绑定式」者「解构抽象」于「绑定式」而
  「后续」于（「绑定名及后绑定式」中「零」）于（「绑定名及后绑定式」中「一」）也。

「解构多抽象并继续」乃承「甲」而化「整数」而化（「列」于「字符串」）而化「表达式」 「：绑定式：」而
  化（化（「列」于「字符串」）而化「表达式」 「：解构后的绑定式：」而
      「甲」
  ）而「甲」也。
「解构多抽象并继续」者会「剩余抽象数」而会「已有绑定名」而会「绑定式」而会「后续」而
  若（「大于」于「剩余抽象数」于「零」）
  则
    （虑「绑定名及后绑定式」者「解构抽象」于「绑定式」而
      「解构多抽象并继续」于（「减」于「剩余抽象数」于「一」）
      于（「附加」于（「已有绑定名」）于（（「列」【（「绑定名及后绑定式」中「零」）】）））
      于（「绑定名及后绑定式」中「一」）于「后续」
    ）
  否则
    （「后续」于「已有绑定名」于「绑定式」）也。

「解构抽象不重复名称」乃化「表达式」而化（「列」于「字符串」）而「字符串」合「表达式」也。
「解构抽象不重复名称」者会「式」而会「已有」而
  「解构抽象名称条件」于「式」于（会「串」而「非」于（（「存在吗」授以「字符串」）
        于（会「已有名」而「串相等」于「串」于「已有名」）于「已有」
    ））
也。

「打开首隐式派类型」乃化「表达式」而化（「列」于「字符串」）而「字符串」合「表达式」也。
「打开首隐式派类型」者会「类」而会「已有名们」而
  鉴「类」而
    有（「式节点」于（「隐式派类型节点」于「参数个数」）于（（「列」【「绑定值域」】）））则（鉴（「解构抽象不重复名称」于
          「绑定值域」于「已有名们」
      ）而有（「参数名」与「开值域」）则（虑「剩余类」者（若（「等」于「参数个数」于「一」）
      则
        「开值域」
      否则
        （「式节点」于（「隐式派类型节点」于（「减」于「参数个数」于「一」））于（（「列」【「开值域」】））））
                                          而
                                          「参数名」与「剩余类」
      ））
    或有「其他」则「发生事故」于『只能打开隐式派类型的首参数』
也。

「解构抽象不重复名并继续」乃承「甲」而化（「列」于「字符串」）而化「表达式」 「：绑定式：」而
  化（化「字符串」而化「表达式」 「：解构后的绑定式：」而
      「甲」
  ）而「甲」也。
「解构抽象不重复名并继续」者会「不重复」而会「绑定式」而会「后续」而
  虑「绑定名及后绑定式」者「解构抽象不重复名称」于「绑定式」于「不重复」而
  若（（「存在吗」授以「字符串」）于（会「已有名」而「串相等」于（「绑定名及后绑定式」中「零」）于「已有名」）于
    「不重复」
  ）
  则
    「发生事故」于（『219不重复』附『，名称：』附（（「多态列表示」授以「字符串」）于（会「甲」而「甲」）于「不重复」）
      附
      『，式：』附（「表达式表示」于「绑定式」））
  否则
    「后续」于（「绑定名及后绑定式」中「零」）于（「绑定名及后绑定式」中「一」）也。

「是直接返回自由变量绑定」乃化「表达式」而「爻」也。
「是直接返回自由变量绑定」者会「式」而
  若（「表达式是绑定」于「式」）
  则
    （「解构抽象并继续」于「式」于（会「名」而会「内式」而
      若（「是直接变量」于「内式」）
      则
        （「串相等」于（「读取直接变量」于「内式」）于「名」）
      否则
        「阴」
      ））
  否则
    「阴」也。

「表达式收集元素」乃承「甲」而化（化「表达式」而（「或可有」于「甲」））而化「表达式」而（「列」于「甲」）也。
「表达式收集元素」者受「甲」而（会「操作」而会「式」而
  虑「当前结果」者（鉴「操作」于「式」
而
    有（「可有」于「值」）则（（（「列」于「甲」）也（（「列」【「值」】））））
    或有「可无」则（「罄」授以「甲」））而
  「附加」于「当前结果」于（鉴「式」而
    有「自由变量」于「名」则「罄」
    或有「绑定变量」于「序数」则「罄」
    或有「绑定」于「名」于「下式」则
      （「解构抽象并继续」于「式」于（会「名」而会「下式」而（「表达式收集元素」授以「甲」）于「操作」于「下式」））
    或有「式节点」于「名称」于「式列」则「串联」于（（「态射」）于
      「式列」于（会「子式」而（「表达式收集元素」授以「甲」）于「操作」于「子式」））
    或有「其他」则「发生事故」于『未有487』
  ））也。
