但是动态就有一个好，就是无需任何设计模式就能实现巨高复用

动态系语言不仅支持 coroutine 什么的，还从没有受到 JavaEE 的害，非常纯真
只有必要的定义和事件入口，没有 Adapter 什么的大堆名词

其实我经常用 interface cast(
静态语言当动态的用
但是碰到高复用还是只能反射

类型的显隐式是相对的，强弱是相对的，而动态静态是指有没有独立的检查期，能提前查错就是静态。

是的啊贼不科学
看起来像是傻逼，却比一些 enterprise 的玩意要方便太多

当协程用 不过想想这样也无法把 libc 的 blocking API noblock 化了

llvm 大佬太菜了，连寄存器分配和指令输入输出的模型都不会，非得用 蒟蒻 SSA 😢
还是要负责整个后端才厉害

是挺那啥，初学者觉得 C 是强类型，稍有常识就会觉得 C 比 py 类型更不严谨🌚

对我自己，type hints 就要有 universal 的解法了😋
LiteratePy 预处理器能接受 a!wtf 这种特定前缀(a!) 宏展开语法的话

我就可以结合物理命名法，把 def add(a!sVal, a!iOff) -> int 展开成 (str,int)->int 了
估计会很有用，只是目前没在写那个😢

是啊，哪里是 string 里的那个
char=byte

Lua 是 array|dict 了， table 还有 array 部分和 kv 部分…… 😂看了半天不懂是怎么分配的

说多了感觉内部类型完全没毛病的语言没有啊

type TT = Int
type FT = String
notT :: * -> *
notT 0 = ""
notT "" = 0

p(q) = (forall x. p(x)==not(x))(q)
p(p==not) = (all x. p(px==notx)==not(px==notx))(p==not)
reduce 一层了，推导下， f1=not ，f1 (f1==not) = Yes 再求一次 f1 一致性， 因为 f1 (f1==not) = Yes 所以 f1/=not ，这样大概就能试出

f :: forall a. (forall b. a -> b -> notT a) -> ()
f g = g 0 ""
但是和 Rank N type 有什么关系啊

草，这都能出算法啊
m==n 也不好切吧，如果是奇数会不会有问题

这个真是生草， 3↑↑2=3**3 ； 3↑↑↑2=3↑↑(3↑↑2) …… 天文数字

ackermann 函数和那个大^操作符对计算机科学在什么地方有意义？🤔 能评价算法的优劣吗

真的有太阳爆炸前算不出来的东西的意义吗
看见它实现了 < ，所以说这种数值的意义是比大小吗，取位数或取余也不行吗
可是真的有数学界外的算法 会有这种复杂度吗

为什么靠 REPL call 一个 func 就能得到复杂度呢，因为有 dt 和 call count 吗
可是复杂度是算法意义的，怎么忽略常数呢

感觉数学这么定义一大堆记法和展开式是药丸的
明明就是 nums.fold(0) { a,b -> pow(a,b) } 的问题
非得弄成第一维度第二维度的东西写死了，草

这些东西看起来这么厉害，是不是已经用到实际算法优化中去了
感觉 C++ 是这方面的先遣兵

还有，现在很多人别说手推算法复杂度了，选算法跑个分都懒得跑，因为根本没有好方法可以自动评测、自动选特定程序版本，自动化程度太低
要是构建系统给点力就不会这样

应该教导程序员多写几个 等价版的不同实现方式
提供方便的测试套件确定一致性和 对比性能
感觉好简单却没有啊草

噢才记起来 ACM 算法好像不是针对计算机而言的吧

嘛，如果是要索引我给个逐个 bsearch 算法 #Python #code
def bsearch(x, xs): #xs: (<)sorted
def atSub(iL, iR):
i=(iL+iR)//2; v = xs[i]
return i if v==x else (-1) if (iR-iL)==1 else atSub(i,iR) if v<x else atSub(iL,i) if v>x else (-1)
return atSub(0, len(xs))

ary = ["1 7 12 32", "5 9 18 38", "9 13 19 41", "17 20 32 50"]
ary = [[int(sn) for sn in s.split(" ")] for s in ary]

def search(v, a) -> [int,int]:
for i, xs in enumerate(a):
j = bsearch(v, xs)
if j != -1: return [i,j]
assert search(50,ary) == [3,3]

二维 bsearch (相当于 flatten&bsearch 省内存)的我抽提下代码(头疼)，
itself = lambda x,xs: x
def bsearch(x, xs, key=itself): #xs: (<)sorted
def atSub(iL, iR):
i=(iL+iR)//2; v = key(xs[i])
if isinstance(v, list): ii=v[0]; v=v[1]
resI = i if v==x else None if (iR-iL)==1 else atSub(i,iR) if v<x else atSub(iL,i) if v>x else (-1)
return [resI]+(ii) if isList else resI
return atSub(0, len(xs))

bsearch(50, ary, lambda x,xs: [bsearch(x,xs), sum(xs)/len(xs)]) == [3,3]

啊第一眼看成超级牛， mn 我一时眼花了，写完再看才发现是 (<)序单调增 啊…… 斜二分不能，的确是只能先 list(flatten(xss)) 🤔

如果点用 [i,j] 表示的话的确可行，是 sibling = (n) => [n-1,n,n+1]; iter.product(sibling((iML+iMR)/2), sibling((iNL+iNR)/2)) 3*3个
不过写起来应该有点不方便