豫言源码浏览器

yuyan · 523 行 · 25253 字节 · UTF-8
寻观「标准库」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树数据」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树基础操作」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「抽象语法树表示」之书。
寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「内建常量数据」之书。

寻观「编译器核心」之「顺序标识符」之「顺序标识符」之书。

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

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

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

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

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

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

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

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

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

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

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

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

「整数类型」者「内建」于「内建类型整数」也。

「爻类型」者「内建」于「内建类型爻」也。

「字符串类型」者「内建」于「内建类型字符串」也。

「动态分类值类型」者「内建」于「内建类型动态分类值」也。

「有类型」者「内建」于「内建类型有」也。

「自由变量类型」者遇「字符串」者「名」而「自由变量」于「名」也。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

也。

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

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

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

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

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

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

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