#statement #kt #dalao 为何退出..
>可惜JDK没有 @android.webkit.JavascriptInterface

不然小dataobj用html form 应该挺好改
我的天哪 frame.add(this, BorderLayout.NORTH)
AI真的get到我说的apply{} 是咋回事了吗,反正我是很讨厌语句式UI

我还专门写了个编译期 append框架弄Tkinter
现在想想，还是用DOM吧，H5最有前途

duangsuse, [2023/10/19 18:38]
https://github.com/duangsuse-valid-projects/TkGUI/blob/master/tkgui/codegen.py#L162
大概是拿DSL模拟py的obj访问和调用 ，然后把值代换回变量名

>编译期 append
^ ice1k 大佬决定推群，因为怕被回复
我不是想强调我做过什么 😅

这种东西现在看起来也很屎
我只是注释，因为你提到了这个问题
实现方式，对我而已言是为代码桥接的。只要语法或心智模型一样，就行

当年写的东西，虽然很烂，但当时也确实没想到更好的

duangsuse, [2023/10/19 18:42]
那这么玻璃心。我有啥办法呢？ 我一直在这里，我不需要与任何菜鸟隔一层 阶 级 😓
真是对自由讨论非常不友好的， 连tg都没考虑到的情况
这个人能看到我的消息，我却不能回复他

而且不是静态检查的不能， 是圈他以后，他会抛下一句话退群
检查类型了，但没完全检查

不过，tg的黑名单真的有待改进

isekiのChannel, [2023/10/19 18:47]
你的思维呈现极端的跳跃性

duangsuse, [2023/10/19 18:48]
哦，不就是否决了你们的一些落后观点， 就说我捉摸不透了
>是啊，我们这边实在跟不上您的思路

我是要用这些知识真正做事情的人
可不是像你们这样，拿着，然后不说也不用

duangsuse, [2023/10/19 18:50]
你们今天懂的，或许我不懂
但我懂的，就一定让它变成儿童编程一样的复杂度

你们觉得不严谨，反感，我无所谓
我非常乐意和冰封大佬在一个群里
但这次是他主动退出的，我没办法

法不可知则威不可测， 他一直在回复我，我以为他又正常了呢

—不过当年写的，确实涉及许多不相干的东西
本来可以用确定性较强的 for x in: constEval(x)

我却创建了一个能uneval() 的“虚拟树”
不过对DOM树，这些语法糖就都无所谓了

duangsuse, [2023/10/19 18:56]
不是的，在Tk 里支持XML式的EKV树，需要手写遍历

我是想纯生成append代码，也不要有调用栈，就是节点ID和配置+子级
所以在调用时，+值->名 替换的副作用，刚好能输出代码，但其实不够优雅

现在我也没想到其他做法，但设想的 js evalFun 对纯常量(split,.)的0开销还是做得到

duangsuse, [2023/10/19 19:04]
另外冰封也写过C-binding + View DSL

他自己应该也有些UI框架，有别人做了 java DSL ，初次提起TkGUI 当时他就回复我这个

对我而言，这几百行代码的份量，相当于刚才我一句话里的语意， 甚至还不如，因为那时我不知道 form input[types]，被不广泛的心智模型带偏了

今天的我，搞不懂为什么你们以无法被解读的代码为傲
你们未必能完成最初GPT能实现的目标，却完全丧失了「软件工程」 的优势。你们做的能用的项目，和那些抽象的概念间是没有一致性的，它们不代表你们编程力的成长。 这种习得性的正确记忆，难道能称为懂理论，或者有思想吗？

元编程也不过是编程， 类型推导也不过是「变数关系式DFS编程」， 你把编程语言当问题，只会在正事上一事无成

duangsuse, [2023/10/19 19:10]
不要管了，实在不行就拒绝用Logger
Log4Shell (CVE-2021-44228
24 November 2021; 22 months ago

#learn #js #kt #java 🧵 📥
借机聊下线程、协程间的对应性，以及UI/UX应用与单次脚本间因何不同。（全栈）

调用返回要靠 -Xss 指定大小的线程栈，数组
调用异步要靠 ret() 参数指定的回调栈，链表， 也可以封装为 new Promise((ok,err)=>ok(0)) 。内部执行前都要传入then步骤，但不需要看调用栈
你可以把异步栈保存到[]{}里按需执行，称为调度。协程(async stack)和linux调度器的区别，仅仅是后者能跑死循环(分时复用CPU)
总之 线程栈=调用栈，异步栈=回调栈。

ps|head -n1 这样的管道write() 其实就是yield。这时read()不会等待/dev/disk/的CPU.IO信号，而视ps下一块缓冲的bytes (C对象的Channel)
信号，不是死循环轮询poll，它看注册推送push。不过Looper,HTTP-epoll请求响应 这种ddloop(detect-dispatch) 模式会混合两者
本来，为了不卡死主线每次IO或延时也要 launchThread{b=f.read(); rest(b)} 。封装为 f.read(回调) 就异步了：线程无关
生成器， yield(x, Ret) 会保留首次调用偷偷建的状态机Ret，第二次next(v)，调Ret(v如异步结果)后即可返回x。 asyncFn=(args, op=0, Ret=(v)=>switch(op++){} )=>相当于协程对象

主线程sleep()往往要卡死UX，但 yield ret=>setTiemout(ret,1s) 却会立刻返回，同时允许ret()上文切换到其他线程池(ddloop,scheduler)继续执行
造成以上区别，是因为push比poll有普适性，它跨CPU地执行同一个函数，且有event/flow based 范式帮助模块复用。libuv和DOM就是对os.read,sleep.. 跨平台的线程池优化

既然如此，好像有UI+IO两个线程就够了，你干嘛~要多开线程
上文切换，只因，为能更好地压榨多核线程池
DOM代替大家做了划分，为多线提供了内存安全的Worker，但kt,go,py里暴露的技术细节有点多！

线程和 asyncio/suspend 相比有何劣势？ linux上进程内是创建慢的进程组(fork)。在不调用OS资源时，永远使用协程"套娃"能减少到内核态的上文切换和内存消耗。像线程池存在的意义，就是免线程创建http连接等单任务
需要mutex锁的独占性资源，用协程读写更节省轮换
单协程轻量到1个回调就能保存，并发控制如 join(coroutineScope),go select,channel 可以用Promise.all,race,postMsg来"阻塞"，因为它提供了进程模型所缺少的返回值。
线程即共享内存的进程，无需手动封送(marshall RPC)就能互调用，而json本意是保存会话(对象树)。 如果内存会话和机器都要隔离，就需要 Proxy(by=cookie酷卡/fd句柄) 验证对象API权限了
通过句柄而非密码访问API，是因为句柄能定期吊销，也便于审计。代理有时叫注入,Mapper,绑定

那么jdk19 虚拟线程 又如何？ 有100w级的并发1s内完成的低开销，类似py的GIL
但绕过JDK的IO走 JNI Unsafe 读写文件或网络是无法实现异步调度，未实现 suspendCoroutine{it.resumeWith(Ok(0))} 这样的yield的扩展性

var vs = Executors.newVirtualThreadPerTaskExecutor(); //Executors.newFixedThreadPool(200)
for(var Y= new int[]{0}; Y[0]<3;Y[0]++)
vs.submit(() -> { int y=Y[0];  try{Thread.sleep(java.time.Duration.ofSeconds(y*1));} catch(InterruptedException e){}
  System.out.print(y + " "); }).get();

最后，再了解经典的「并发模型」 就能读懂90%的企业级服务了

- ForkJoin,MapReduce 如把文件预分块(shader) 读http区间多线程下载
- Actor 直接按函数参数，自顶向下来分块(RPC)
- CSP 是上面说的多进程，靠 Channel<in T>, chan<- T 递交任务，流式的 make -j8
- 线程&锁 互斥资源不能被linux多核调度改乱套了，所以得加锁(synchronized)

#learn #kt Benny霍评论区
协程 async。自动传回调、var都打包到其class因为，比如传给sleep()后自己要return。协程对象就比()->闭包多留个switch(nthStmt){}

把sleep()外提为赋值语句，以保留和恢复调用栈而已，linux单核调度多线程，甚至你调用IO时为了鉴权，也会这么干。 cat|head 不就会await您的键盘吗？ read()就会suspend 1个C语言的“有栈”协程。
之所以要async，只是想节省pthread_create，因为你要拿mainloop去poll(定期/卡http的轮询) 触摸屏事件，设备资源是独占的。这和内核驱动(/dev/WebUSB) 才能导致死机蓝屏是一个道理

如果系统，比如Web APIs吧，只提供回调而禁止while(1)，哪怕只支持epoll(查看监听)/select(poll多项)，就根本不存在线程一词 -就像C里你并不知道read()本质上await在pipe前“生成器”的write()
--也有人叫它yield，那是因为我们不能靠return写入“文件变量”、不能重赋值函数参数以返回多个值.. 为此jspy还发明了“async*()=>生成器”..
完美复刻UI层State(val).onvar[]的轮子呢！可惜是难用难复用的阉割版。

VSCode只加两个js线程，就能运行得很稳，这难道不是App设计的常态吗？难道那些小程序比code更“架构”？
至于免锁或基于资源.transferTo()的多线程，WebGL/numpy/MapReduce(ForkJoin) 不需要重造OS 1Dispatcher:N Continuation(该叫class CPU: ()->isFinished吧)的轮子配什么池化，就能实现前后端们无法想象的性能提升。

ES5的 yield cont=>setTimeout(cont,1s) ，由awaiter链接timeout和g.next，已经是免编译协程API的巅峰了，Promise.then 只是省得你传cont回调。 当然，timeout也可能返回cont=> 所以then要能接受async()

另：JS是视 fetch(u,{abort:Signal}) 取消任务的，我不认为app里会需要一堆 coroScope{} 这样图文不符的结构。kt在UIUX界敢能和H5相比么？为什么语言多项功能，app的功能却少的可怜！

kt的结构化并发不比Go的WaitGroup(semaphore)有用，但新词一大堆，初心全忘了，开始比java还八股了。真可笑，屠龙者终成恶龙
那些比Promise更繁琐的，是毫无语意的知识，迟早被py AI自动完成。看来科学界也不喜欢代码圈整这些无聊的class

就问 https://python-future.org/ 2to3这么聪明又简洁的lib，java人们啥时候能学会？态度问题，不是智商低 #statement

协程线程进程，都是Job
jobs的管理上，除了^Z SIGHUP再 fg bg 恢复，内核还支持swap(整个系统的)内存页到SSD，甚至用CRIU直接把进程快照为文件。 这样的快照不仅能多拍，还可通过网络传输，简直易如截屏，又像 Termux.dev / Waydro.id / webvm.io 那样神奇；然而这样超越运行期的“时间魔法”，90%的编译器根本做不到，只能用reflect或asm模板这样的残次品搪塞；同理90%的语言里“函数值”都没有相等性--所谓闭包“值捕获”却并不能自动内联JSON，所谓RPC,protobuf还不如微软的COM,pwsh.NET普适
#os 在这一点上可比 #plt 的孤岛、围城，先进太多了
https://t.me/dsuse/19341

https://kotlinlang.org/docs/coroutines-overview.html
https://github.com/youngyangyang04/TechCPP/blob/master/problems/为什么用户态和内核态的相互切换过程开销比较大.md
http://cht.sh/podman

podman run -dt -name cnt busybox /bin/sh -c 'i=0; while true; do echo $i; i=$((i + 1)); sleep 1; done'
podman container checkpoint cnt
podman container restore cnt

https://t.bilibili.com/948850441406382096

#think #web #tool
https://cssgridgenerator.io/
https://crocotile3d.com/
https://fixupx.com/Oroshibu/status/1808500235263418441?t=BtGGBHj9jnN2AReHW2VTWA&s=19
三視圖？

有趣的建模工具
帅啊！
螺莉莉的黑板报:
(๑•‌ㅂ•‌)و✧
https://dataset.wav.pub/

https://brython.info/demo.html
https://github.com/Distributive-Network/PythonMonkey
#py
螺莉莉的黑板报:
https://github.com/baskerville/plato/blob/master/README.md

你们 rust 真是啥都能干……

https://www.sea-ql.org/SeaORM/

这东西好用么……求教……

https://gitlab.com/coolreader-ng/crengine-ng

有趣的引擎

https://chinese-font.netlify.app/ font
https://typst.app/universe/package/bob-draw
#svg

https://ivanceras.github.io/svgbob-editor/

#code
duangsuse:
大量复制粘贴十分抽象
list有那么难用吗
难道你没注意到近十行只变了1个参数
AIGC也没脚本化得这么严重吧

我看还是用list first!null好了，这么八股文…… 大家现在都是用get null取代预判has的

这种到处预判的风格，很像你找大佬问问题，先发「您在不在」，他只好回个在，然后你不在线……

表达式化比你想的要多哦：

>Spring如何把 @Autowired T xx; 换为 var xx=find(T.class)

var Ts = [T.class].map( applicationContext::getBean);

你在class{}里加那一堆定义，如果只引用了一次，就完全不应该引用。 到底都是要查bean的

从code smell来看，只使用了1次的变量名是无效的；如果只是为了易读新建变量，只能证明你的helper fn命名的有问题

kt已经有!! 了，还想要更多
Java 一大特色，注解属于元数据，和函数调用有重大区别

duangsuse:
那这是定义“随用随扔”变量名的理由吗
函数和变量是这么用的？
java以省略[""] 为由引入太多常量复杂度的优化了，都要所谓框架来解决

纯粹是make compiler happy，把一个schema弄成它能读懂的class，然后再强转Any来构造class而已

js里一个字典让java用就是这么麻烦，其实能用几次呢？ init完就扔了，根本不是性能瓶颈。

注解的本意，应该和py的 @decorator 一样，是接受class元数据的编译期函数才对

而不是等到运行时才去查什么field有哪些@属性 然后逐个.set()

要动态生成一个类型，来获取注入，简直无理取闹。 明明就该在编译期产生Registry.get&fillNew的样板函数

这是属于既把元编程的路封死了，还不让基于注解的注入框架提供统一的“反射”方法

其实jawa懂这个道理，但它偏偏就做得很烂，就会个@Override
duangsuse:
为了编译速度这也太幽默了，其实，jvm作为栈机 基本就是带类型签名的GNU dc计算器，不需要什么编译优化

如果递归下降一遍，校验下类型 生成个push call 就能花什么编译时间，属于是用PHP的方式搞算法了

而且javac的能力还远没有到c预处理器的程度，为了优化？ 我看是他们不在乎程序/类定义的优雅性

什么序列化啊，也没有做规范，和py能 import json,yaml,toml,marshal 能比？就一个用来RPC的ObjStream，还被业界遗忘，哈哈

汤姆猫是大专必学

虽然汤姆猫的Biz程度也就比Node http-server强半点吧

所以问题就是Result类型为何没有重载 !!， 让它看起来仿佛只是带有错误消息是null

凭什么!! 只能校验 Type? 呢？
assert也是乐观/悲观路径
Exception也是，为什么不能一起判定了？
还非得搞个ifEmpty, ifBlank.. ifNullOrBlank..
莫名其妙

duangsuse:
这不是废话吗？例如买30天大会员，肯定是30* 24*60*60秒后失效，这才是世俗意义上的电脑时间

看到py关于时间和日期/时差有3个API
我就觉得抽象

audit就是一个不懂AOP的，其实unix可以靠strace审查syscall，win32的 sysinternals.com 也有进程日志功能

与其自己搞个无人知晓的轮子，不如封装别人的，两全其美
把OS的活都包揽了，难道py是要运行在Ring0把内核驱动都带上？ 那必须支持啊

绷不住了，抽象程度直逼jawa

一开始就不该搞所谓orNull
默认 first{}!! 就够了

我在js里都是把Error视为object返回值的特例，和null是一个意思
这样就不存在什么orNull orElse的，catch表达式也免了

就是语言设计者对值体系的理解不过关，例如NaN就是numbers的null才对，而不是什么number?
这样才能用统一的方法去报错/换默认值

可悲的是一开始就没把悲伤/快乐路径当问题啊，真是异常搞心态

duangsuse:
幽默IDE
完全相信它的API有一大堆根本用不上的class
忸怩作态的软件没必要去维护

kcp是这样的，可 import ast 自 https://python-future.org 就没变过😋
py只是用:隔离一个表达式先于=执行，就实现了高贵语言们的静态检查

既可以用于静态分析，也能在运行时查看f.annotation ，完备的数据不需要反射

btw. 大佬应该会做一个DSL
Message.invoke{ id==mid }
Message.select{ id==mid }//多项

可是这种写法才是真正的SQL逻辑式

既然Msg(id=)能构造数据， Msg{id==} 就能查询
这不是很合理么 #kt

很简单，如果做得太标准，以至于移植到任何一门语言里都没必要修改的话
就没人给官方docs贡献流量了

duangsuse:
https://www.liuwj.me/posts/ktorm-introduction/
🤔 一个SQL函数.xml codegen 能被吹爆，还有人卖课是我没想到的
ES6里一句 sql${} 解决的东西，哈哈

「没想到他文化程度那么低」……

怎么会呢，语句能缓存，再怎么也比一次加载完dao好

你要是不喜欢，或者不相信语法糖有缓存，可以做成生成函数的形式
例如
updateId=f=sqlFn2{a,b-> Pair{B/b, A/a}}
f("bye",0)

所以说，如果你不相信DSL能被缓存，可以转为生成sql函数的形式啊

这不是MyBatis++ ?

https://github.com/JetBrains/Exposed/blob/main/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt#L184

我只能说，缓存键要么是调用点或次数
要么是函数
似乎很难单独缓存DSL对象，除非对它们的构造器
幸运的是， key eq x 里x的修改能缓存，因为它是参数

https://jetbrains.github.io/Exposed/frequently-asked-questions.html#q-how-to-get-a-plain-sql-query-which-will-be-executed

https://stackoverflow.com/questions/74821893/postgresql-arrays-instead-of-extra-table-in-a-many-to-many-relationship
涨姿势了，以后 1:N用数组json N:N用join

duangsuse: #fp
要是kt能允许编译期生成一部分表达式，就没这问题了😅😅😅

可惜啊， unquote{bash(q(trim("trimedStr")))} 这当然是lisp的专利
其中q() 被生成为一个字面量，就像闭包捕获：
fun bash(s)=trim(s).let:
paste {system(it)}

并没有所谓的编译期，因为编译器能访问所有lib API


0开销不是瓶颈问题，但事关语言的脸面

明明就很有用，可被一些人理解为「并非瓶颈的东西」
然后被rustc拿来完魔法

要我说他们就是傻屌，只不过是把闭包「捕获」的实现方式，改为内联字面量(unquote)
就能轻松突破编译、运行的动静边界，根本没有引入任何新API ，没有什么循环展开和 kotlinpoet javapoet的区别

他们做成什么样了？ 正则的缓存还不如py的拿dict查😅

duangsuse: #kt #book 元编程
http://www.bilibili.com/video/BV1XH4y1w7mT
https://drive.bennyhuo.com/zh-CN/talks/2018.11.17-%E4%BC%98%E9%9B%85%E5%9C%B0%E4%BD%BF%E7%94%A8%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B_final.pdf

https://weread.qq.com/web/reader/f7632a00813ab82d6g017b14ke4d32d5015e4da3b7fbb1fa
可以一起读
虽然我不觉得这点值65😊

如果numpy那种API/DSL都设计不出来
修改class的结构也只是给开发者们徒增烦恼罢了

举个例子，此章节的 gh/user/_name
如果只是把它当成URL路径，需要绑定，显然造成代码重复，与元编程的本意违背

而如果像 import fire 那样，知道URL的本质是class路径与def GET,POST等，也就是另一种CLI调用
就不需要写什么注解和函数名
甚至模块化都省了，一个文件足矣

不过是修理servlet.xml繁琐和不支持argbind和的“弱类型”问题
但何必要制造那么多问题呢？sql,http，那么简单的工具还用学

#parser #learn
说起来，AST也就是多方法的 ()->Any 而已
你甚至可以把方法名enum化，从而完全避免使用class
例如 sum(L(1), L(2)) ()==3 只需要两个fun
Object Algebra.. 嘛，用虚表override取代if，稍微快点，只是要parse两次

至于在js里，我一般用 [[JSON ',' +] '()' /] 这样的模式写ast
描述 (1, 2, 3) 这种正则
甚至连函数式都没用到。 数据结构本身就蕴含了for if流控，运算符重载本身就是编程语言

不需要任何范式来实现他们，“数据结构与程序语意直观对应”，这就是CS。
这……应该是一件很难听懂的东西吗？ 为什么DSL都设计得那么刻意和拉垮？

甚至，构造函数也应该取代class{} 或tuple才对，为什么把参数传递到堆而不是栈里，就需要写所谓的struct? 它们都是把args打包复用而已
为什么把yield 外提为语句，变成
let then=回调=()=>switch{} 里的编号，就需要学什么func*和async，堆和栈，难道不是天生一体的么？ 分页数组、“缓冲区”，难道不应该是跨语言的？

然而支持kwarg的python 却需要Namespace来实现这种等量代换😒 反而是Haskell可以这么写
然而它是真正的笨蛋美女😅

#oop
元编程，首先就要明白obj的本质是通过enum分派逻辑的(vararg Any)->Any ，也就是一个when(x)in constMap+super..
这样才方便添加和绑定方法签名

这样在语法上也就能理解为什么是{}包裹，以及filter{}为什么优于lambda和匿名override

py可以通过vars(o)实现静转动态
typing.Namespace(kw)反向
除了小写类型不能扩充，哪怕是Ruby元编程在直观上也无法和它相比了

duangsuse:
oop和rust go就是pp的扩充
不算重新学习过过程试

编程语言只不过就一张加减乘除节点图，问题是领域和API

看这本书的“层次结构”，就想到拿identifier叫name，拿classifier叫tag，拿些辞藻和皮毛当本质，哎
无聊
好像早点拿到电脑，多写代码

#kt #code 😊之前，v8 blog说Promise就是Continuation(含续体的回调)，我还觉得多此一举
和Kotlin“强大”的API一比，我却要变成ES6吹了。Web的先驱者们简直是先知啊！ 代码越复杂，成品功能越简陋。这就是为什么安卓app体积不断膨胀，功能却越来越卡。

interface Promise_<R,T> {
fun then(ret:OrErr<R>) //delay() 后应该这么做，那之前只需调用它并return。它通过cpu{}排队，另一种排法是yield Promise
//launch(ctx=Main+CoroName("val")) Map状链表DSL。Job等元素
var cpu:(Runnable)->Unit; name=""
fun go(:T?):R
fun stop(:ErrStop)
stdState=0,1完成,2取消
//不要使用截获器和Key环境变量。组合优于继承，go 的WaitGroup比不伦鸡肋的scope明确多了，Android的curl比js的fetch流更复杂吗？
}
type OrErr<R>=Or<R,Err>, Err=Exception
val OrErr<R>.!!: R
sealed Or<out A,B> {
data A(:A) data B(:B)
fun as(A->R?, B->R?={null}): R?
val A:A? val B:B?
}
fun T?.as(R, T->R):R
fun T?.as(T->R):R?


😊顺带把阿K没有统一的err/null错处也搞了，还要什么 o?.x?.y ?: 1
https://www.bennyhuo.com/book/kotlin-coroutines/12-why-so-called-lightweight-thread.html

上面说协程=Thread.asCallback() 只是一种go/lua的罕见情况，好理解嘛。
kt里协程是通过retAddr()作为参数，实现的链表化调用栈，其第0项一般是 runBlocking{}或thisCPU.nextJob
这样可以在主循环注册任意个delay()或flow{}的回调，优化 Promise.all。这是虚拟线程所不擅长的
https://www.bennyhuo.com/book/kotlin-coroutines/13-implementations.html

duangsuse:
此callback非彼回调
这个cb是编译器自动生成的class

web apis从一开始就线程无关
有什么平台和语言敢说自己的异步API比Promise经受更多用户考验？

那个是动态语言所必须的，kt有编译期，完全可以不染色
然而只有suspend fun是和正常函数完全相同的，业务上完全没有比js优秀
https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/
algebra effect https://t.me/dsuse/19174

coroutine这个词不需要存在，即便是在脚本里，最多需要await和numpy的真正并发并行计算

而且即便存在，霍老也不应该说什么magic
不过就是把return()变成值，通过callLater{delay.then(me)}构成链表，要么就简单到 Thread.asCallback

可以知道，Coroutine(而非Closure), Dispatcher/awaiter 都只是为确保函数return后能正常复活的东西，和调用栈完全一致
强调它们不同的，不是蠢就是坏

堆栈互转的玩意，说的跟迷因似的术语一大堆，严重被高估了。OOP构造函数同理
还有元编程、xml ，完全是语法太复杂导致的无效学习。你看 compose DSL需不需要拖拽设计器

coroutine是在搞特殊，因为linux的read() write()就是自己的await和yield，linux没有说协程
多线程是为了IO多路(evpull)和分块计算之类的，linux没法掩藏这些细节，但语言不掩藏就是语言愚蠢了

反倒是lua以后那么多年没有语言跟进，都在回调地狱，这是问题。

lisper 在把 @Adder(x=2) 生成为 (unquote '(+ 1 x)) 时可不会觉得是魔法
他们写 (let '([x y] ary)) 时也很清楚，这不过是一种list(str) 的循环处理
kt写inline也不会觉得很难理解

也罢，毕竟字符串模板目前还是ES6的专利，php都还在sql注入呢
所以java语法比嵌套的括号还低端吗

我是说无缝RPC其他语言脚本的这回事
sql``select ${1} 是不会注入，那为啥sql里有个 ?参数的概念呢？

PHP通过ORM和prepare语句确实不会注入，那么php跨语言调用js脚本呢？
只能用reflect.invoke那种API吧？

ES6可以随便调用任何py js rb JSON接口而无惧注入

不仅如此，js还可以靠eval('var ..') 自己注入自己，顺带实现codegen

想不想注入，都是开发者说了算😊🤓

#statement 我一开始就说了啊，讨厌magic

作者在后面的章节明明有更大体的理解，却不懂知识重构
反而把这些含语言设计者私心的API拿来讲课

两句话说明白的东西，何必浪费读者时间。后面讲Channel,sequence,flow 时读者懵是不是还要复习一遍？

最讨厌与语言、与CS术语耦合的私货了。 谈算法不离编程语言的，两句话不离语意模糊的术语的，可能是称职的程序员，但绝对没有准备好设计优秀的框架

这让我怀念 coolshell.cn 的耗子，虽然他过劳死了，但不到50不写书的工匠精神确实值得钦佩，因为知识布道者确实要这样谨慎。
要是编译原理/元编程界的多数人都这么有格局，lua zig的这些优点也不会雪藏那么多年， http连双端绑定都做不到的框架也不会活那么久

duangsuse:
#kt coroutine 和现在js async func* 的情况一样，一开始没有flow，后来加进去就是。。一言难尽

我不觉得把分页数组和Reactive混为一谈是好的
就像现在flow也需要buffered()或只留最后一项
这不太能统一化缓冲区

🌚flow模仿数组好像也说得过去，但总觉得有点像C数组或指针，是在搞混淆

flow如果和sequence{}统一就更好了，使用可调的默认bufsize而不是yield一次一个值。

这样和linux的iostream就合体了，而且也能实现vue ref()的效果，两个不耽误
太过重视调度线程是在模糊要点

#kt #歪点子 inline class 来了，const fun 就端上来罢🤓🤏 https://youtrack.jetbrains.com/issue/KT-14652
https://kotlinlang.org/docs/inline-classes.html


const val x = encrypt("password")
const val hash = md5(File("config.file")

val routes = arrayOf(
get("/hello", (req, res) -> "Hello World");
get("/fizz", (req, res) -> "bazz");
);
dispatch(routes); //2* if

const val MEMORY_SIZE = 640.kb //fails now
const fun p(num: Int) = it == 0
typealias Zero = Int / ::p
//现在的带验证类型
value class Even(val num: Int) {
companion object {
operator fun contains(num: Int) = num % 2 == 0
}
}
& being able to use the return value of a constexpr function as an annotation


replies Andrey Breslav:
The main use-case is 'documentation'. See the resent example of discussion for "nameof" here: https://discuss.kotlinlang.org/t/nameof-to-get-names-of-program-elements/1518/4

https://github.dev/rust-lang/rust/tree/master/library/std

there are apparently 990 functions in their stdlib that have been converted as const fns

https://tech.youzan.com/java-metaprograming/ #learn 元编程是什么？为什么js人搞JSON不需要靠元编程？

编程，就是用SDK给的套路解决问题。
元编程，就是突破病态类型(仅编译期可见的静态类型) 的桎梏，编写能写代码的代码，即codegen函数，从而实现编译器没有自带的功能，例如打印“class指针”里的内容

☺️我有一个绝妙的点子替掉 https://square.github.io/kotlinpoet/ ，只是手里的屏幕有点小，写不下
https://github1s.com/bennyhuo/Kotlin-Trim-Indent/blob/master/trimindent-compiler/src/main/java/com/bennyhuo/kotlin/trimindent/compiler/TrimIndentIrGenerator.kt#L34-L81

瞄了一眼，发现截获覆盖字面量调用是挺简单的

哎，没有心情看 #kt #book
看了下codegen技法，只能说近十例子里anko的风格相对优越，和html一样是用twig(类似erb)模板，然后作者函数复用还行，但也没有到90分的程度。

例如“贯穿全文”的DeepCopy(x:T)吧
js里相当于x就是T的反射，又一切皆可变，可以直接读写{...x}[ID], 只需
mapEachMember{if(it.isPrim) it else DeepCopy(it)}

kt里需要用构造器复制，先拿到 T.vars[ID].get(x)而非 x[ID]，但依旧是 mapEachArg{getattr(x,it).primOrCopy} 的模式，这个至少适用于 Tuple$N的toMut和url参数绑定
这就是个小学算法，反射和List API 的良莠不齐却让它很难看。

重要的是独宠XXpoet 真的无力吐槽，和那个 https://t.me/dsuse/17514 一样，就一个不用导包，然后自带formatter。简直可以说是一碟醋级别的算法，甚至应该叫搞错重点

和我的tkgui https://t.me/dsuse/19768（py基于getattr等元编程，运行期生成等效调用赋值图代码）
都没法比，何况最近我在设计表达式级(fun{}内计算图)都能建模的跨语言、带裸类型推理、动静合一OOP元编程范式了，这种拙劣的"xml模板"实在写不起来

java确实是“病态类型”，而非什么静态检查。 连数据树的验证和walkDeep都要靠魔法，有什么资格谈类型签名的那些好处？
靠被默认值参数替掉的重载吗？

只能说，如果手头有电脑，我应该去吧那个sql dsl写了😒 而不是在这看java人像手写sql或xml那样拼接字符串
不知道 unquote(ast) 这种函数式代码生成，起码吧 quote(litOrID)做一下，免得被注入弄出无效代码啊

再说说全书结构，首先就没有谈元编程是什么，而是java老三套：环境配置、难题、抄代码

好吧，可是一个优秀的老师应该选循序渐进，但却对知识体系至关重要的例题： #learn #plt

- 为什么是靠C的#define 自主研发出易语言？预处理比str.replace多了哪些？ 高亮分词后，灵活解释“常量字面”吧
> eval("[1,$x]") 是一种JSON解析器，可是x="][0]"时似乎有bug。 修好它，然后把js爆改为你希望的“易”语言（复用猜数游戏的REPL）。 完成后类似的bug应该仍然存在！
其实，js源码也有它的JSON.parse，它就是反射的原型。
- 比较下SQL的'?'、C printf、ERB/ES6模板，kt元编程最缺少的语法为什么反而是"$str"? 控制变量，就能明白pwsh和ts为何比bash和js有长期编程时的优越性

- if os==nt6: class: 与#ifdef _WIN7 凭什么是同构的？ 动态类型，依旧是Java式的类型。宏，并不需要魔法
- 为什么Java8让 invokedynamic负责创建lambda，getMethod不也能.invoke吗
- 局部fun 一定要 ::引用的背后，藏着一种元编程，T.(A)与(T,A)->、(T?)!!的强转背后也是！ 原来除了消除重复，她还让语言提供更有价值的“值类型”
- 为什么“闭包是穷人的对象”？ C语言里回调函数去哪了？SAM接口又为何比到处new.object{}流行？ 原来返回函数、重写接口也能费内存啊

- 为什么pyjs里很少人研究元编程，但却又有 python-future.org 与vue,babel这样的全民应用。 二者有何区别
- Proxy(obj)掉包属性，是动态类型元编程的专利吗？ reflect.Proxy 能生成函数，还不止于DSL或AOP！
- 能不能通过函数重命名，用py风格的反射API实现KAPT的 @decorator ？哪怕只是封装Reflect？这能让你学习跨平台移植，收获超越本次需求的心智模型和视野
- Kotlin对dynamic类型表达式链条的“零修改”生成规则可以怎么实现，numpy里也可以吗？ 这能帮你理解DSL和编译优化的本质

- “优秀的程序与其读写数据的结构直观对应”。纯函数式编程(例如rust的enum和if let) 做对了什么？ 为什么你仍然选择不够纯的Kotlin？ 这种enum能表示JSON乃至HTML的序列化结构。
- bash风格的参数有3种，其中一种如 ls -ar(all reverse) 传入enum:BitSet。用fun demo()出完整函数签名
- 以上问题和codegen无关，也没有教你具体怎么生成url/json/sql绑定类或函数，却给你了设计相关框架的能力！这次由我来回答，为什么javapoet是对pyjs里闭包list/dict的拙劣模仿，以及反射调用为什么就是在codegen！

所以。。 虽然《Ruby元编程》教你的只是一些OOP特性的“工作原理”，而案例较少，但我更喜欢它 --它让读者真正建立起了对"class"这个dict的理解，加上dyn(*arg,**kw) 本就可以用名字动态查，让读者对“把def和class 视为一种constObj去查询、实现复制粘贴、...”有了把握

而不是一个看似什么搞法和IR,ASM都贴出来了
实际上对你没有用，只是让工作失去焦点的troublemaker🌚🌝

https://x.com/whyyoutouzhele/status/1816770434508976560 #kt

Kotlin Multiplatform 是迄今为止最优秀的跨平台方案
https://bytedance.host/231204/

#db https://tangdh.life/posts/database/duckdb-file/
http://blog.asleson.org/2024/07/24/bcachefs-an-introduction/exploration/

#kt #元编程 嗯。。我有个点子，有没有懂ktx序列化的人批判一下😊

基于Visitor实现json/toml.. 的读写，data class 只提供零参构造和 KVlit.see(instance,"field",jsonVisiter)接口

数据类的KVlit，就是给dict支持了个拆箱赋值，结合零构造和field Visitor自然而然就实现了序列化
设计CLI解析器时想出来的，就挺像xmlpull

const N=Double
data Num2(x:N,y:N)

interface KVlit {
fit(o:Any?, k:StrInt, v:LitSeer)
companion 注册表: IType<KVlit>
}
next=File(..).jsonLits

typeof<Num2>
(KVlit).fit object:LitSeer {
see(x:N):N =next.Float
//我们要read,所以忽略旧x
see(o:Any?, T:KVlit) = skip'{', T.fit(o, next.Str, this).. defaults(o);return o
see(o:Any?) //null模仿动态类型、Any.kvlit.testy 不为空

//BDFL optimize (Boxed ints, Date/Decimal/UUID, float[]s, List Map<,Any>
o.(Integer x)仍调用int返回的重载; int[]在长度不变时返回自身

see(o:MutKV<*,*>, K:Class,T:KVlit?) //传入Class.INT等常量即可
see(pair:Any?, T:Class, vararg Ts:KVlit?).. //可通过实现 typeof<Pair>(f2Any)转接list,base64
}

这是读取，写入的话接口一样是
x=fit(jsonStream,x) 。如果 T.seal? 字典不为空，就先读个'type'键 然后同上。 期间 T.setLit Bitset用于检测是否需赋默认值

扩展的话，直接 override Visitor 的最后一个函数！ 数据、格式、模块，完全解耦

codegen上就是一个大when{}的语句字典
然后对diff update(亦可DeepCopy)
以及CSV(KVlit能实现.eachIndex)很友好，这点是我最满意的

想支持ClassFile等binfmt，除了重写list,sealed编码还要支持 UInt,bitstruct,Magic012,CPool<> 等类型，但比从头开始好

实现上， T.fit(o,key,this) 应外提为线程局部 T.fit(o,key,)KVlit.seer
T.fit(map,T,)KVlit.mapK
应支持创建iterList.setEach{}随访问更新流

#OOP #plt 学点设计模式
https://iota.huohuo.moe/OO-in-C.html#:~:text=一种设计模式对应一种语言特性%20%20By%20千里冰封

函数式人有许多「过度设计」，例如美 kotlin.Any.let 其名曰 #FP Functor.fmap (Arrow-KT.io)。这种(私货+算法)的泛滥，给IT带来了灾难，让许多初学者不明觉厉，也当然不能提升其应用能力（毕竟只是"指针别名"嘛）
https://kotlinlang.org/docs/scope-functions.html
https://www.ruanyifeng.com/blog/2017/02/fp-tutorial.html

但OOP也有自己的“私货”——用于弥补语法不足的“优雅的”设计模式
例如 Builder,Utils,Adapter,Delegate.. 它们是对this参数、对interface扩展不够灵活的变通

这个长文，我会用短 #kt demo 让大家看到 refactoring.guru 🐿收录的10种流行 Design Pattern 掩盖了哪些语言特性的缺失
以及科普"OVDEP" Observer Visitor(深先iterator) decorator(单参compose) EitherAB Proxy 等不逊色于箭头函数的，超越语言的优秀工具

## 创建性-Creational

这些模式是 new 构造器() 的变体，在Rust里被 fn new=Pair{A:1, B:2} 构造字面和 impl T for T1{} //mixin T1: T 混入取代

1. StructBuilder

有一个很长的SQL row需要new，可以使用默认值，插入前也有检查

class RwCol2<A,B> {
  var A:A?; var B:B?
  constructor(x:A,y:B){A=x;B=y}
  constructor(){A=null;B=null} //默认值
}

我们把构造器中A=x;B=y; 拆成 newThis.A(x).B(y) 两个函数，就能实现初始值的解偶
填完数据可能要验证，如编译期验证不可变 fun build()=this as Col2

与它对立的是默认参数
和 RwCol2(0,0).apply {B=B+1}.B; buildList{} this参数上扩展 apply(T.()->*): T
K2 value class{init{}} 也实现了构造后验证，不过大部分人仍在使用专门的反序列化和data verify框架

2. (Abstract)Factory

常见误区是，Factory类似 Pair.of(1,2) 是为了重命名掉new，或者只把构造器集结起来: doc.createElement("div")
安卓 content.Context 与Button等View(ctx)的关系更像工厂的本意： 基于(操作系统)上文验证和保留数据

interface DataJVM {
  fun <A,B>List(a:A,b:B): Pair<A,B>
  fun <T>List(vararg x:T): List<T>
}
val kt=object: DataJVM {
  override fun <A,B>List(a:A,b:B)=Pair(a,b)
  override fun <T>List(vararg x:T)=mutableListOf(*x)
}
//val py=object:DataJVM{}

与它对立的是全局对象、元类trait。
全局fun弥补constructor钉死了 open fun 且难于校验的问题。当然！它也消灭了 object Singleton{} 和“双检锁”的样板
元类允许了 static (类名上)接口，而不是让可覆盖的函数代理一下构造器：
https://docs.oracle.com/javase/8/docs/api/javax/script/ScriptEngineFactory.html

3. Prototype

Linux对pwd等环境变量的fork()是最著名的原型模式，这使得父子进程间有了T1继承T 的关系
JS里 {} 等价于 {__proto__: Object.prototype} 函数表，函数表也可以随时添加继承。有 new.target 的构造函数()只是设置原型+赋值到this的简写
一切皆对象，除了 Object(1).valueOf() 里装了又拆箱的1。无原型的，只有更慢的 Obj.create(null)

data class 会自动实现 fun copy()，但它不能继承，因为无法拷贝父类的变量。Java里很难把对象加构成更大的子类(除了 inner class)

sealed class Box<T>(val A:T) {
  inner class Pair(val B:T): Box<T>(A)
}
val x=Box(1).Pair(2)

按道理是x.A=1，那么Box(1)单例就是这些Pair的原型

另外，我刚又又设计了一种新的元编程方式： QuineQuoted (馈硬是一种 eval(s)==s 的测试，它和FP系的ast宏还有点区别： qq需要编译器支持， QQ自己就是编译器) #plt #kt
https://github.com/mame/quine-relay

我几年前用这类技术弄了Tk的DSL，forin展开 https://github.com/duangsuse-valid-projects/TkGUI ，但没有意识到值:名替换 是把运算符重载变成编译器的要点 ： 首先 kstSel=Fn(2, ([A,B])=> KST? A:B ) 就可以用read自源码+值名替换 生成出 "(A,B)=>{" "A" "}"

想必是比XML魔法优雅不少吧……

这样Kt的循环展开可以这么写：

val [T Array].constFor = F.PASTE { op: (T)->pass/*[T pass F.n1]*/ ->
  indices { i -> quote { op(`$`(this).get(i)) } }
  //(this as KtScope).quote "op(x1.get(1))"
  //(this as KtScope).quote "op(x1.get(2.. ))"
  // str += " inlineOp(${arr}.get(${2})) " 是否和 quote { op($this[i]) } 雷同？ Java STR|SQL. 提案的真正面貌来了。
  //也可以来return repr(字面量均可序列化)， inline("bin/file")... 宿主有多强，宏就有多强。不在五行之中，却不会生成非法结构
} 

看起来相当简单，而且和Proxy({}, {get:genFn}), 和lang.invoke属于同款！ 但是，因为能处理左值，创建函数、修改class{}字典也是可能的。 运行时反射，编译时留字面，运行即编译，但比起JIT所有不知名的「编译优化」，eval后留字面可不是魔法，只是元循环函数而已，就像numpy和taichi 的"C DSL"
Quine比之poet等EL就像SpringBoot比SpringXML一样， 不需要切出本语言的思维，就可以突破 o.key() o."key"() 的隔离， 避免了人们关于「静态类型」一直以来的一个很大的误会
但我就从来没见「最佳实践」们用过…… kt 在用仅能自动import而且个性贼大的poet。 lombok 甚至重造javac的轮子，就为了显得自己懂栈字节码了
和我那个拟态类型不谋而合，相信再强化下反射API，很快就能替代TS了！？ 🤔

val $T_Array.constFor = F.PASTE(n=1) { op:any -> when(var T,){ this typ([T Array]) && op typ([T pass F.n1]) -> pass
  else -> TypeError("某些人觉得很厉害的编译原理和OOP，唉，还是比eval和原型链棋差一着")
  //把for/if 这些函数的语意，重载成只执行1遍/2侧都执行就够了， 这是Lisp说的道理：语言们没什么语法，只有传参法、求值序、回调或栈的区别罢了。 类型检查和webpack什么的，何必呢，直接在编译期黑盒测试：TDDtc调试运行即编译！
  //Kt 不太能按inferDFS(T)分重载，你 val=::print 就一目了然，方程的形式就只有 {T:?0, R:?1} 这样的解构匹配而已，却卡的要死，真不懂是JVM拖了K2的后腿吗？ 还是某些预制人比起为用户着想，更爱虚伪的代数呢？
  //因此以上代码已经是JB级别的 type inference 了，Prolog数据库的helloworld而已。 F(n1,T,pass). v(this,T,array):-is(T,any?),F(n1,T,pass). >>> v(变量名,...模板参数)

  //btw. Kt 没 match{case+} 也不是大问题，如果支持真正纯函数式的解构匹配，怕是val和var语法和那高开低走的@Compose都要退役了。 Svelte的rune、C的返回到指针都不会抄，还真是仅此一家别的不看了
}}

Lisp也有类似的能力，Haskell系的 quasi-quote 准引用 ，包括Rust!()也是这个意思，不过它们都是简单的eval（comptime eval 又怎样？不成熟），甚至搞一些因为反射API不稳定、母语语法空洞而贫瘠，而使用的模式匹配重新造parser，还有递归限制
C++ template<T> 扩充的#define呢，类型体操(比如printf的静态检查)呢，也是这个意思，但它们非常丑陋，它们总是让上下游在 💩味的代码和代码味的💩间二选一，明明试图用解构匹配重新实现调包和# define就能解决的任务，还自我感觉良好，仿佛一眼概况程序的能力已输给AI，但只要Tab补齐的类型写对了，就能强化自己的正确率似的。 丑陋的黑魔法只会诞生丑陋，没有例外。

Quine就不一样了。它揭示了函数的本质只是复用了几个变量的计算树，和JSON一样是跨平台的， 借此允许我们审视和消灭重复的类型签名，创造更好的SWIG、rustdoc、lint、minify等工具，甚至是[拟态评判lityping]这样更直观的检查与推理
这一切都不需要魔法，它和Proxy+getMethod一样是自举的，可以在任何编程语言-尤其是在缺乏this支持（并且傲慢地唯独不支持this隐写）的pyjs里发生。 这是最重要的点，我的跨语言RPC新JSON需要这种codegen框架。 解决一种问题，肯定要把所有上游复杂性全消灭掉，对不对？

#java https://t.me/hyi0618/7581?comment=12882
https://t.me/hyi0618/7581?comment=12886

🤓 🤔https://www.yinwang.org/blog-cn/2016/06/08/java-value-type

Valhalla
OpenJDK的一个重要项目，致力于为Java编程语言带来一系列深度改进，其主要特点包括：

引入值类型（Value Types） ：这是对现有的Java对象模型的一种扩展，允许数据类型直接在栈上存储，减少不必要的内存开销和引用带来的额外成本，从而提高性能。

值类型在Java中没有ID标识，其相等性是基于深度的比较，而不是ID缓存的比较。

支持交集类型（mixin Intersection Types） ：允许定义一个类型的子集，提供更加灵活的类型约束和接口设计。更精确地表达类型之间的关系，例如一个类可以同时实现多个接口，这些接口的组合可以形成一个新的类型。

改进泛型（Generics） ：Valhalla项目对Java的泛型系统进行了改进，使其能够更好地支持值类型。通过引入泛型专业化（template<> Specialization），可以为带不同类型参数的变量，提供特定的编译.class，从而提高泛型代码的性能。

GraalVM 应该都支持了。 从OpenJDK的表述看，他们本来对 new Pair(1 2) 的 inline &JIT支持的不够好，减缓启动，现在Java也是抄了 #kt 的一大堆特性🤣 Int 不是class，自动un/boxing(栈内/栈外化) 也抄了

背景知识:
https://t.me/dsuse/21164
https://t.me/dsuse/21126
https://t.me/kotlin_cn/134152

JVM给我的反馈太差了

洋洋洒洒写几百行，给人感觉全是形式主义

https://t.me/dsuse/21177

Creative Coding 包括了整个Web开发，还能5行一个小功能

java里为了标一个List什么鬼写半天，还不如把docs完善一下

对项目结构没有自顶向下掌握，typehint是没意义的

如果不是组合某些API、注册某些Hook或回调需要java

我真的不想碰有编译步骤的语言

HTTP就是为了给java提供跨语言API的，说明java的心智模型本身语意性很差， 不适合做创新和设计

Ruby贡献了Github(Pages)
Rust贡献了Ruffle和许多新的开源CMS程序
JS贡献的 Reactive 比template高到不知哪里去了，还用JSON提了爬虫效率，减少无效的XML流量费
Python是现在的大热门，Rust都模拟不出numpy,Jupyter, torch 和各种跨界应用的语法 ，尽管py在DSL上是输给kt的

Java 除了大公司（谷歌都在抛弃、被众多H5替代）的屎山SQL代码鉴权验正则，还有什么技术力？ 我觉得它最好的命运就是成为.class的运行时， 放弃这个丑陋的应付💩山专用的语法

Java那个 STR."" (var _1=ourSQL."SELECT {1}" ) 提案

算是给Batis这种弱智XML怪物一个正规化的方向，然而臃肿的垃圾JEP连自家的支柱业务都没法执行。

不难猜测，他们是对资深程序员的title路径依赖了，需要被Rust原神拉下神坛一下，才肯对自己作文跑题一般的API删繁就简，悔改🤣

dnaugsuz:
Java连个标准event冒泡都没有，UNIX Signal都是残的

和responsive+Reactive的适应性根本没法比
Compose和web生态比都不够格

ES6悔改了，接纳了箭头函数和解构，加上原来的原型链、反射Proxy

已经可以实现vue这样的大框架，而且还在进化

#kt #design

用中文读代码，是一个【语法+视觉边界感】的设计问题，同时是一个【写比读难优化】的踩坑问题，而不只是词法和语序的替换。

这方面典型的负面案例，就是OOP和FP的始祖——Smalltalk、Lisp，可以拿 emojicode.org 的 say(🔤Hi!🔤) 来形容——对，读起来就是这种感觉。甚至你没有输入法。 许多 #PLT 人只知道词法语法，为了写个亲爱的parser用尽全身力气（写“虚拟机壳”），却不明白人眼人脑的【感知】。

语感差异在编程里，不是特别重要，尤其是不值得为了套皮而打乱语序。

比如 for x in 图表xs: 或 对xs里的x: ，我的选择是让所有套皮都基于数据流/管道感，for降级为函数，而不是制造分裂

类似的事情，其实决策并不是很容易。 😨

比如 OOP this 的写法(u参数)，我近几年改了五版 （可能是黑历史了，但确实在全语言全文化killer诞生之前，都在纠结）

- 像Kotlin那样，给 class T{fun op} 和 extfun T.op; T.()->Res 分开的
- 去掉箭头类型，用 hex: [Int Str F.n1] 或 toHex: [Int Str F.u1] 区分函数vs方法的 （从typer的实现反向优化的语法设计）
- 在js里用 (1).[_ => toStr(16)] 希望在库层面实现改绑定到首参数_的，还希望把div(p())的DSL也绑上

- 认为3参可以用ABC指代，所以 F.u1 是 An 而 F.n1 是A的，那时还叫 F.n1 vs N1, F.An1 vs F.n1 ，还和vec2的N2(x,y)撞车……
- A,An反过来指代的。因为咱发现， f.map(x=>) 一旦x是对象就会多写"x." 索性it默认this。 这里有Groovy的一个坑

直到：咱发现 u=you, ur 的网络语言，以及，把list,map从各种玄学优化(addr,表,行..)改到统称为 are,am,isMounter(diff赋值) ，这段历史，才彻底结束。

现在的OOP就是纯粹的封装。任何叫u的参数都免前缀（BELT作用域-而非LEGB），全局用 imp.alert() 调，成了和Ruby一样的约定优于配置。

可以直接加 fun op(u: T) 当extfun，F.u1只是FFI提示，让 .let .run 的差异彻底成为历史，[1 2 3]?.(u=>u+1) 和are(*对象)没差别

——就只是this变成u，simple but lethal。 为了这一碟醋，就可以百搭一堆配套。就像现代安卓把安装页变成安装框那样，够脑残，但直接消灭一堆额外需求。let/run/apply/also/with，直接合并吞掉。

全局进 imp.，裸名不可能是全局；u 是有名字的参数，被内层遮蔽报错了，外层随时能改叫 x =>，或者干脆写 u.field——永远有逃生口； —— 但你不需要明白这些深奥逻辑，就能知道you，这是合理设计。BELT这个想法比UFCS还好

这个经历让我深刻的理解了《人月神话》的程序员与普通的A player，有什么思想的不同，并且让我专心为【人类可解释】探索边界。 🤗