另外，这个好像也是可以用 arrow function 的吧？

print( ((u, v) =>
Fmt(u).setVerbose(v).show()) (duangsuse, true));

我讨厌这种写法，而且不知道为什么要用 !function(...){...}(...) ... 听起来 ! 的宾语应该是 function(...)... 可我不知道 (!T): T 是什么意思，它的类型简直莫名其妙
忘记 IIFE 是干什么的了…… 好像是『局部作用域』，算

如果你去看看 Kotlin.JS，你会发现他们好像也是默认用这种方式来传递 Kotlin 对象

比如经常有类似这种

function(k) {
  k.io |= {};
  k.io.stream |= {};
  k.io.stream.buffered |= {};
  k.io.stream.buffered.BufferedInput = function(...){...};  
}(window.Kotiln)

;

#net 全大写的 RADIUS 不是 Remote Access Dail-In User Service 吗，是应用层协议啊，之前忘记了，这个名字太奇葩

长时间 Connecting，然后出错。

机房里的 Ethernet 貌似也无法连线（？）

（WiFi 这个是不是 RADIUS 炸了 XD

#Android 🤔 什么叫做分离…… 不会是弄个 repr ORM 存储的规则的 Collection instance 吧
duangsuse 当时想，比较简单的结构在这种情况可以不用麻烦 SQL 查询了

Dir 扫描引擎重构中.. 为日后兼容存储重定向做准备。同时把 ORM 的规则和扫描结果（内存中）的规则做分离。

#statement #dev

同意，所以我建议为了学习的目的，同样的一个软件模块最少要写两遍
只有开始写第二遍，你才会发现有什么地方很难看、没理解、需要简化

即便不是这样，过度用脑也是不好的……
我短期记忆能力比较差，然而经常需要思考一些可视化的东西…… 而且总是想 N 遍，所以感觉越来越累了
而且对实际编程感觉也没有什么帮助，可见要『适配』是比较麻烦……

听说过以前老冯（冯诺伊曼，控制论的创始者）经常说不能用 assembler，因为它浪费 CPU Cycle！

T = I * CPI / Cycles

现在岂止是 Assembler，我们连 lint 和 intellisense 都用上了，不知道老冯看到今天会是怎么样的想法

树状图？压力测试？Dynamic Programming？

树、DP 应该还可以建模的吧…… 性能优化可能更加困难

状压DP见祖宗，直接爆零。

#Python #code 大家保存好，绝版了。

头疼，看起来一些简单的控制流逻辑也不会看了，不过至少是能够看……

新的解析器框架，虽然还是很简单而且不支持容错什么的，但又支持了 PEG 文法…… 打算用 Java 重写个

为什么不用 #Kotlin 呢？因为 Kotlin 本身对我这类辣鸡程序员就已经很极限了
何况还是要写可复用性要求这么大的东西
如果用 Kotlin，我感觉我会驾驭不住甚至不知道怎么抽象好……

但我觉得上 Python 用动态类型不好…… 而且类型检查好像的确没有…… 我去找过有静态类型检查器，但是 Python3 是渐进类型的啊…… 不能多态淡疼
写成 #Java 会优雅一万倍。

再加上之前的 auxfun 模块，就完美了！虽然没有经过完整的属性测试

#Python 不配写太好的测试……

🤔 我觉得大家不能白吃我的代码，要不然被妮妮萌萌那样的人抄了，岂不没命？ 上 GPL 吧

https://github.com/duangsuse-valid-projects/MontagePY/blob/master/helper/parser.py

可用的解析组合子模块，340 行，提供了 seq, br, repeat 等必要的 PEG 结构

和 FP.js 解析组合子的区别是，这个原则上不仅专门为非字符输入流兼容（这样你就可以手写 argparse 之类的）
而且还支持 mark/reset

inp = ParserStream("def deepDarkFun(): return 'Oh, *****'") #内容过于不忍直视
with inp.positional():
  print(inp.consume())
  inp.skip(5)
  print(inp.view())

所以它就可以处理这种结构

from helper.parser import *
from helper.auxfun import concat, op_postfix
wdict = lambda s: s.strip().split(' ')
wdp = lambda wds: elem( list(concat(map(op_postfix('.capitalize()'), wds), wds) ))

wordict = '''
shoulder jam door
f**king s*it hard hot
we you us van billy
can f**k comming
oh ah ahh eh
ass deepDark
my next
'''
n, a, r, v, e, nr, r_uj = map(wdict, wordict.strip().split('\n'))

# Ass(nr) we(r) can(v)
# Oh(e) my(r_uj) f**king(a) shoulder(n)
deepDark = br(seq(wdp(nr), wdp(r), wdp(v)),
  seq(wdp(e), wdp(r_uj), wdp(n)))
#darkParse = curry(Parser.run)(deepDark)
dark = lambda s: Parser.run(deepDark, s.split(' '))[1][1]

写了一天也只有 889 行代码……

In [2]: dark('oh my shoulder')
Out[2]: ['oh', 'my', 'shoulder']

In [3]: dark('ass we can')
Out[3]: ['ass', 'we', 'can']

In [4]: deepDark
Out[4]: (([Ass:Deepdark:ass:deepDark] . [We:You:Us:Van:Billy:we:you:us:van:billy] . [Can:F**k:Comming:can:f**k:comming])|([Oh:Ah:Ahh:Eh:oh:ah:ahh:eh] . [My:Next:my:next] . [Shoulder:Jam:Door:shoulder:jam:door]))

—

In [2]: dark('oh my door')
Out[2]: ['oh', 'my', 'door']

In [3]: dark('Ah my door')
Out[3]: ['Ah', 'my', 'door']

In [4]: dark('Ah my shoulder')
Out[4]: ['Ah', 'my', 'shoulder']

In [5]: Try(lambda: dark('Fucking comming'), err=Func.idp)
Out[5]: 
<string>:0:1: All 2 branch failed
  [] (Fucking)

这里你可以看到，MontagePY 里的 parser 是 PEG 文法的，不必拘泥于一个两个字符，如果超过一个项目的组合失败了，自然会 reset 到原位负责地重试到完成

def accept(self, ins):
  for parser in self.subs:
    with ins.positional():
      res0 = Parser.run(parser, ins)
    if PsP.matchedq(res0): return PsP.Matched(res0)
  ins.eissue(self.errfmt, self.subs, None)
  return PsP.Unmatched

唉，不知道什么时候 auxfun 不是 module 了，真是莫名其妙，Python 的 class 啊
所谓的『灵活』，有时候也不过尔尔，还不如自动多态呢