请写一个 type inference ，正确判别以下表达式
toAST.run {
`+`(+1, +1)
`+`(+"Hi", +"World")
say(+"Good"); say(Str)
}
toAST.runCatching {
`+`(+1, +"World")
`+`(+true); `+`(+1)
say(say(+"void"))
F(1){x-> x[0](Str); x[1](`+`(x[0], +1)) }
//编译器只对函数体内调用赋值执行断言，(x:Int,y:Str) 是{dict}的写法而已
}
toAST.run {
`+`(+1, `+`(+2, +3))
F(1){x-> x[0] (3); x[1](`+`(x[0], +1)) }
F(1){x-> x[1](Var(Box,x[0])) }(Int)
F(1){x-> Var(Box,x[1])(x[0]); }(Var(Box,Int))
// ([T])=>T 和 (Str)=> 检查程序相同
}必须基于以下AST 仔细思考
data F(n:Int, arg:(List<VT>)->Unit) {//arg+1 ret(T)
invoke(*arg:List<VT>): T
var next:F?//+1 overload
}
data T(override var type:Class?): VT {
invoke(:Any)=tryFit(T(a::class.java)).isInstance(a).or("lit")
invoke(:VT)=type!!.isAssignableFrom(t.tryFit(type)).or("call")
tryFit(t)=type?:let{ type=t;t }
}
data Var(type,inout=0, vararg v:T): VT {
invoke(:VT)=// 0完全相等，1允许v(out vt) 2允许vt(in v)
}
object toAST {
//Str,Int=T()
//Box=T(null)
//say: F(null,Str)
//`+`: F(2){x-> Int(x[0]); Int(x[1]); Int(x[2]) } or F(2){Str;Str}
}
//其中参考了
fun Bool.or(:Str)=let{if(!it)println("bad $s"); it}
fun Any.unaryPlus()=T(this)
sealed May2<A,B> {
data A(:A)
data B(:B)
way(A:(A)->R, B:(B)->R)
}- https://suijiyun.github.io/FOC.github.io/2022/04/07/blog-06/ 理论基础, 四则解析与闭包可看 https://t.me/dsuse/19097,https://t.me/dsuse/19092 (都没提到typer 只有比JSON还low的ADTs)
- https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html 是js里switch"type":"ID" 的静态化，意味着没有if()class{}宏
- https://jkchao.github.io/typescript-book-chinese/compiler/checker.html 23k行ts代码 另外
- 类型/泛型推理和查询Prolog数据库没有任何区别: print(Str,R) 里参数可以是局部val，(obj as T).k 即查表"k" k(T,R)
- 一种双拟合(unify两次) 系统能避免指定List，实际上它会按依赖图(SAT)做广度搜索。当然这和sympy(SMT)无关
- https://firecodelab.com/blog/subtype-inference-by-example-part-4-the-typechecker-core/#:~:text=值和用
为了简洁就避免使用 单例Visitor（本质是做一次fn.bind常量）和链表式全局域 obj.k 这种语法，看着也像受检查的 obj[k] ，不过obj的类型若非final，传obj相当于传入了一堆函数值，这是静态类型特有的"多态" 同样是代码+bind双指针，OOP组合性比FP差。FP因为太紧凑不被职人习惯。
写java,C++ 这些的时候有种错觉: public 是🔘列表符号 分号和各种不执行的标注也完全喧宾夺主了 以上的 data{} 也有这种感觉。 对于重复率如此高的元组定义，为何不物以类聚呢？