— #kt
duangsuse, [2023/10/12 00:02]
序列化器也是元类该充当的。

没看到各种T.serializer()组装和typeof满天飞

duangsuse, [2023/10/12 08:12]
问题不是在static变量上，而是 Int is Class 不成立，类没有类型

感觉有点变扭，我的想法是伴生对象的interface 应该公开，而不是搞什么新语法（何况是与C#里的语意冲突

duangsuse, [2023/10/12 08:14]
这种事情我一开始就想到了，kt语言初创时竟然没有预案，只有一个反射API可以强转伴生例
（而且Ruby里的元类就是。虽然rb不需要序列化等反射）

duangsuse, [2023/10/12 08:25]
随版本迭代增加语法，真的太逊了

设计语法框架时，就没有考虑过各种流行的用途和弱类型语言里的技巧
fun interface, context(T,T1) vs ()-> vs vararg
sealed-data object 这些通通都是抄也抄不齐，后来又改正的。 仔细想想就能发现，C#的密封类，不适合搭配kt 数据类。kt并没有努力还原真正的 idiom写法

其实把vararg,private,data 这些都做成注解，然后简化@语法，也没什么问题，而且能减少{}和fun的不一致性，避免一些语法上的不可复用

duangsuse, [2023/10/12 08:31]
像Ruby,Py这样弱类型的语言， 都知道 "Int"和 Int(1)是两个类型。更聪明的语言，应该直接削掉 static 继承这样不合直觉的“小问题”，甚至直接让 this 的隐式域不涉及 Companion.XX ，以及用元类取代反射

rust 却还在用 impl {static}
kt 进步了却不完整。 现在的compaion，才只是namespace吧？

duangsuse, [2023/10/12 08:35]
唉，都是历史问题

最重要的是，在被serializer() 这样的冗余代码解决后， 没人会记起“这是问题”

duangsuse, [2023/10/12 08:48]
这样按元类组装序列化器后，还有个外部扩展问题

Data等类的格式是可以分module的
真是个好东西🌝

Loney Chou, [2023/10/12 08:50]
感觉 kotlin 不应该用 T::class 这种写法来表达一个类的 class，而应该用与 T.namespace 相近的 T.class，T::x 应该只用来表达 T 的成员，而 class 显然不是成员

duangsuse, [2023/10/12 08:55]
kt的 T::x , x::value 也有点混淆
前者是创建为SAM，后者是 "取消链接访问"
背后完全没有核心思想

如果kt的语言特性，真的让companion这个术语“与众不同”的话，(a::b) 倒像是切换a的语意，取b

可惜它只是为了实现“static” 而搞了一个术语，这种程度而已。

duangsuse, [2023/10/12 08:57]
val x by 的用法

duangsuse, [2023/10/12 08:59]
既然本质不同，写法也必须差异很大
而如果是同类，就应该归到一种API或语法里

否则就是语法设计的锅

duangsuse, [2023/10/12 09:02]
很简单，只要把kt可变闭包在使用的 IntRef 公开为 Var<Int>

就可以把 x强转为Var 的子类。 反射Property也可以暴露为(OBJ)->Var<T> 之类

只需要加一点API ，许多语法层面的东西就不会是魔法，而且能帮助开发者思考（比如模式匹配/解构 的本质）

这样的“静态类型”才真正比弱类型有用，而不是有些莫名其妙的设计模式

duangsuse, [2023/10/12 09:06]
我是说，如果要为inline fun 或反射的可变数据创建类型的话，统一的Var 接口更合理

duangsuse, [2023/10/12 09:12]
我说的Var是包含 var get;set, operator fun get 的情况的，所以说它最好为inline宏所用

因此， var by T() 也不应该用 override operator fun 来实现。应该直接把属性视为具名的Var， 而不是拿“属性”这种特例去理解“变数作为值”的意义

它并不是一种反射工具，更类似于codegen,KSP的概念

duangsuse, [2023/10/12 09:19]
但这就是android-er在 MutableStateFlow 里做的技巧，以及Solid比React的“进步”

本来，这是像{}闭包一样理所应当的概念

duangsuse, [2023/10/12 09:30]
def f(x, *) 真的有意义吗
只是分隔符的话，js的字典也能做到

duangsuse, [2023/10/12 09:32]
kt里 fun f()=fun()= 应该比这个好玩

它也支持位置+kw参数，而且理论上，这样的kw更方便从ini动态加载，因为 f(a=1,) 是对象

duangsuse, [2023/10/12 09:36]
是fun()={}
我觉得把 def 写成bash CLI 式传参，只是种限制

这种限制还没有JS里的配置字典/参数默认解构 聪明
JS的这种函数，是可以用类型来描述的，但(*,y) 只是个严苛的语法糖

duangsuse, [2023/10/12 09:39]
单纯验证* 后面不能直传意义不大

它的本质是，你有一大堆kwarg无法排序吧？ 那就该用对象。

duangsuse, [2023/10/12 09:44]
当然更正常的做法，是就用 f(a=1)(2) 两个括号，函数式inline优化。

这样方便kwarg完全相同的调用，你用bash想想就知道很常见

还有一个好处，就是免费支持 Map<Str,Any> 的反序列化，就像**python

—
Silence Acappella, [2023/10/12 12:12]
如果序列化全部都是靠serialize和deserialize这两个方法，那么descriptor是干啥的
还有那一堆element

duangsuse, [2023/10/12 12:21]
这不是自动生成的吗？ 有什么需要你自己实现的功能？
你是想压缩，还是读取 Any,Number 等分支类型？

sealed class 序列化是支持的
是你的数据类型有问题吧， UUID.serizer() 不会很难，如果全都需要手写，应该是你的类型树本身「不好用」

总之，你的数据应该可以理解为嵌套的 Pair<AB>, Either<Int,Str> 这种形式

这样它不仅支持读写保存，而且，勉强是能用的； 不然就会很坑

既然你都觉得descriptor 很不好写，就不要碰它们。 你应该在反序列化后，做init,check()等预处理

duangsuse, [2023/10/12 12:33]
JsonElement 本该映射到 readAny is Map<*,*> 这样的形式的，我也不赞成他们的「强类型」搞法

序列化不就是给 Num/Any,Str/Enum, User, List<T> 这些类型外附上 s.readObj(T) { obj,k读写器,v->v.set } 这种读写器吗

好像也没什么中介的必要，class,List 本身就可理解为JSON

而Any,Num 可以理解为 typed={User: {name}} 这样的JSON

最好不要在Object树里，再套一层union 。 其实添加 fun Object.深遍历 并不难

duangsuse, [2023/10/12 12:48]
描述符是对「类型标注」的冗余吧？

这不是自动生成的吗，为什么要手动从JSON AST 转换？
你的手写，应该是做 Str- UUID 验证 这种逻辑吧？

..好吧，除了 val field=Str get()= ， 貌似没有不做的方法，这也只能手写

isekiのChannel, [2023/10/12 12:50]
不是，比如说我的entity和我的序列化目标结构不同的，我不想把DTO暴露到程序里，所以就嵌入到序列化器里

duangsuse, [2023/10/12 12:51]
SerialName 那种？ 结构不同.. 如果是我，会先用JS做一遍 tree walk ，因为Kt的序列化器太不规范了
这么多T.serializer(), descriptor 和 element ，结果实际上还要手写 read,write ，而且好像是和 Encoder 耦合的(就是不能同时支持 json,csv, BSON/CORBA 这样)，这不叫不规范？

JSON 是理解数据格式的很好方法，如果只是要吧数据加载为class{}，来做脚本，我会选择预处理的间接层

duangsuse, [2023/10/12 12:58]
最好的做法就是手写 JSON parser ，然后你就会发现，它只是吧 [] , {},int/str/keyword 这些语法规则，分给 Any, Int, User 这些类型去创建或匹配分支而已

当然，这涉及如何为 User::class, List<?> 外部扩展 Serializer 接口，以及赋值"key"=Any?、检查键值是否完整的问题。 最终要组织的是一个「元类单例」，它实现了流读写 ，同时也可以被其他类型引用

总的来说，就像解析器创建Any类型的 {},[] ，序列化器要据类型读取{}, 123,1.5 等值，同时也要支持判定并读取 Any,{type:User,}

序列化器，就是通过查询 data class 来剪支的解析器，它读Any时，就像个 json parser , 要先判断Int,Str,Bool,, 再读按类型dict


duangsuse, [2023/10/13 21:27]
py很适合这些 ，当然按键精灵是AutoJS也可以
感觉用str template更好吧

duangsuse, [2023/10/13 21:26]
unsigned 不是用long/BigInt + 读写器就可以吗
>u8可以用byte u64就没有替代品了
给BigInt 做个 load dump 勉强能用吧

duangsuse, [2023/10/13 21:37]
面条点:
header() 不支持null content ，没有 run{}域
method 判断有点奇怪
body为空，提供 ZERO_SHA256
Buider...sign 是通用逻辑，但没有外提为 useRequest{}

但这就是Java..

duangsuse, [2023/10/13 21:38]
我是说，应该用 header(, ?:)

这样也更好看，所以说那个if是面条
Kotlin 虽然一般写法被Java社区带偏了

但和ES6一样有定义式编程的底子（怎么感觉Lisp式调用加点赋值块，就都OK了
算式级不会有样板代码， 顶多class没法被框架化

Java 就是无药可救了，历史包袱

duangsuse, [2023/10/13 11:22]#PLT
继承自值呗， JS 里一个 Object.assign 完的事，一般用于修改函数Mock
《这就是 Kotlin 》
constructor 是OOP的经典操作，Kt都支持 val 构造器你还想怎么样！（

最多 typealias Str=String
或者直接 val action by map

open class(val action) 反而会增多代码量，因为「继承优于组合」。

duangsuse, [2023/10/13 11:26]
OOP 复写真的把光吃不干演绎到了极致，这一点上我支持Rust,Go。 var f: This.(T)->R +推导都比 override 直观， class{inner class Add(Vals)} 都比透传构造val合适

这类型标注明确的好像程序员或者框架是傻逼一样

到底低能到什么程度才会写出 xx:Str="abc" 这样的代码，好像Kt支持了自定义隐转一样。程序员每天都调哪种函数 编程语言找不见吗，为什么总是把骚操作符号化，把常规写法弄得又臭又长呢？ 这大概就是编程吧

open class Base(val x:Int) {
data class Add(x:Int, val y:Int): Base(x)


} 
Base.Add(0,1)

当然，你也可以隐式参数
open class Base(val x:Int) {
inner class Add(val y:Int): Base(x)
}
Base(0).Add(1)

如果重复val>3 ，建议直接 by map

duangsuse, [2023/10/13 12:10]
虽然《组合优于继承》 只是Rust粉喜欢强调的独特点，而且 Rust 的 traits 接口都非常散漫，但OOP实在是太冗了，在组合时甚至不如 struct{}

class 本来应该被视为 interface+constructor ，也就是能暴露局部变量/函数的 fun ，和JS的参数字典差不了多少，但Kt的对象模型，并没有比Java清晰多少，
继承本该理解为2项组合+隐转，但Kotlin及一众OOP语言并没有为这个本质提供语法(比如把 inner class 推广到外部继承)， 反而是执着于 constructor, new, Inject 这些的糖味的障眼法
再比如 fun=object 和 inner class 间并没有统一，许多人不以为SAM接口会保存调用栈的变量； sealed 和 enum 间不一致（反观Rust就都是enum），const 和 inline, val field 等概念也未成体系

by delegate 也没有被做成 extend class:接口 的更合理的形式（与 fun withThis.fn() 时判若两语
实际上， val by 只是掩盖了class级反射和codegen的难用，但Kt在版本迭代中APT,KSP,KCP 等等最佳实践层出不穷，就连 companion 也在 object 和 namespace(interface) 间切来换去，好像元编程问题就没有一个数据模型。

许多功能都是自顾自地加语法，从未反思过是否既存、是否完整，就比如 val() 解构 vs. forEach解构, 再vs for(in)， unboxed IntArray 和JVM的Stream.OfInt 间谁更贴近模板泛型，用重载当隐转是否够用，等等。
整门语言发展得快， 但正是因为发展空间太大， 暴露出作者没有为各种语言构件的应用化，做些基础的铺垫

sN1DPmwfQug, [2023/10/14 11:08]
数学书就没几个词,都是在思考
读数学书无所谓什么语言，学术上来说英语相对有更好的资源可以探索，使用英语术语可以帮助你更好的与其他人交流，检索资料，其他更多的用处我也不列举了，这种讨论毫无意义，爱看不爱，给你中文数学书你不喜欢看也不会看，翻译在数学阅读中影响占比几乎微乎其微，不是说不影响，是和你的努力程度相比，中英文转化是最不起眼的一环。

duangsuse, [2023/10/14 11:28]
你是不能脱离图形或语言符号而思考的。 语言并不是约定俗成，它被设计为紧凑而直观地反映心智模型

你可以用编程/图形/物理的记法体系读数学，会有不同的理解效果
就像你说的， 不同语言的资料集的面向有差异， 也不能说只有“标准写法”是对的

sN1DPmwfQug, [2023/10/14 11:29]
题目都是那个题目，翻译成中文你也不会做

duangsuse, [2023/10/14 11:32]
编程的本质，包含了整理和代换。 虽然大的算法（比如排序、记忆化递归）你搞不清，
但每个步骤的原理是可以说清的。 名字就是对这些步骤的摘要

即便都是中文，如“变数 函数 参数” 也比 “变量 函数 传值” 更体系化，更富有语意（放一块就不存在「函数值」的“特性”了）。不能忽视这些设计

duangsuse, [2023/10/14 11:34]
一些译者纯粹是做“人性化的机翻”，但不代表这个问题是伪需求。

如果你真的喜欢数学，就应该去改进它，而不是重复前人的成就和错误，学习如何成为人肉GPT。

duangsuse, [2023/10/14 11:37]
你的意思是， 把英文文字 译为 中文文字， 不会改变问题的复杂度

而我说的不是问题，或者公式使用的符号。 我说的是「语言」，那是问题建立时依据的心智模型。

翻译时，这个模型是可以被重新设计的（就像编程语言的静态类型），所以不能说只翻译对思考无益

其实我的努力就是“翻译”， 这是易混的一点（
对于你们，可能是努力思考了； 但我不爱思考具体的问题，我思考问题和术语间的关系，也就是所谓转化

sN1DPmwfQug, [2023/10/14 11:40]
哥德巴赫猜想 用英文给你写一遍你不会写你说这是翻译导致的

duangsuse, [2023/10/14 11:41]
我还记得有个人证明了费马大定理，但是一页纸写不下（
我刚才说 我的字典里「翻译」 不是对文字或符号的翻译， 而是对语言或「心智模型」的归纳和重新建立

你说的努力思考应该是解题， 我说的咀嚼知识则是「归类和转化」。 二者应该是不冲突的

duangsuse, [2023/10/14 11:54]
😓感觉这个「翻译」问题上纠结也太杠精了…… 不过这是我写博客的方法，见谅。

我说的翻译，应该是指把东西移植到 desmos.com, sym/numpy,Matlab 上，而不是做中文音译，看不懂英文才无聊呢。

duangsuse, [2023/10/14 12:18]
要是这些B LA书解释下 ndarray(shape A>shape B) 的计算是怎么推广的该多好啊

之前想做一下JS-WebGL的bind，最后发现Nd矩阵比较难做

duangsuse, [2023/10/14 12:21]
我又不想学数学， 我只是物理世界的用户呗
可以移植到计算机上的数学我也是支持的，

比如Var<T>作为值+编译期eval，取代模式解构或匹配，我就很支持

把类型系统做成关系式的函数数据库，只要既能支持「高级特性」又易懂，我也很支持

我谈的不是数学啊， 是你眼中属于数学范畴的东西，在现实世界的影子； 很遗憾，两者就是隔离的

duangsuse, [2023/10/14 12:25]
那请你讲讲你熟悉的Kotlin 和 Haskell 如何为 fmap 这样的算式推导类型的

讲不明白但能用，叫懂吗？

duangsuse, [2023/10/14 12:26]
那不就是查询「支持Var」的关系式数据库吗

也就是，能够求解 [Pair A B]=[Pair Int Str], B=... 这样的逻辑式
只知道 unify 那几个词，却不会把Var推广到更多用途（比如 Reactive,Events) 才是表达力差。

函数、变数、闭包(对象) 这些都是编程语言的基本成分， 不需要那些术语来解释背书

duangsuse, [2023/10/14 17:16]
🤔 知乎上有两种观点， 有人说前端就是写个分页路由器，哪有竞争力
有人说 Flutter 连Web的吊车尾都够不到

CSS被人诟病不模块化，但它起码有1px这种数据模型和style复用，有成熟的快速原型工具。
拿Qt,各种View Object 比DOM树就像拿canvas去比SVG。虽然用canvas的大佬云集，但它背后的思想毫无设计体系与组合力。 一旦没了API隔离的护城河，很容易被新需求冲烂（就像各种H5 WebView 一样）

不过对于Compose来说，还算是对HTML的进步了，毕竟Linus说过，XML是极少数对机对人都烂的数据语言，JSX模板也是Web的一大憾点

duangsuse, [2023/10/14 16:44]
感觉 NoPosts() 是「搜索结果页」的通用模型吧，应该做成 open class, HomeUI 是它的特例。


总之，不用滥用多态，如果null能实现用 ?.run 也挺好
原来如此，说起来 java.io 版 DataView 的bitconcat读取就是硬编码的


所以我对Java界「工业级」数据模型或算法的直观度观感不高

btw. 前几年我也被带偏了。哪有什么 int long 啊，都是 byte 4,8 ，这些private fun也不好看

Omico l Dev, [2023/10/14 17:16]
[ Album ]
kotlinx datetime 想获得下面的格式难道只能这么写？

duangsuse, [2023/10/14 17:21]
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").run{
LocalDateTime.now().format(this)
}

duangsuse, [2023/10/14 17:25]
你这个需求太奇怪了

KMP没有的接口，如果不想变通
最好是分JVM,JS,libc 去实现，这样还可以封装出去赚star，而不是自己做一个

duangsuse, [2023/10/14 17:39]
说的也是，不就记个小log呗，replace能有多大开销

只要不涉及IO通通视为0开销

duangsuse, [2023/10/14 18:00]
固定位数的 ints load/dump 可以手动divmod:

>请实现固定位数的 fun IntArray.dump(StringBuilder out, vararg n:Int)
例如， [8, 12].dump(sb, 2,2) 显示为 "0812"
请对每项 i0+=n[nth] 用itoa算法实现 out[i0+i]=数位

fun IntArray.dump(out: StringBuilder, vararg n: Int) {
var i0 = 0
for (nth in n.indices) {
val i1 = i0 + n[nth]
for (i in i1 - 1 downTo i0) {
out[i] = '0' + this[nth] % 10
this[nth] /= 10
}
i0 = i1
}
}
—
def dump(self, out: str, *n: int):
i0 = 0
for nth in range(len(n)):
i1 = i0 + n[nth]
for i in range(i1 - 1, i0 - 1, -1):
out[i] = chr(ord('0') + self[nth] % 10)
self[nth] //= 10
i0 = i1

dump([8,12], a:=[0]*4, 2,2)

最近免费AI的智商变低很多

duangsuse, [2023/10/14 18:01]
还好吧，人总是有事干的， AI取代动手我们就做设计 做自老板嘛
不过看起来它越来越笨 了，变成搜索引擎了，我最近一个月都没太用过

在我的想象里，
>请实现固定位数的 fun IntArray.dump(StringBuilder out, vararg n:Int)
例如， [8, 12].dump(sb, 2,2) 显示为 "0812"

就足够清晰了，但AIGC后还需要除错……

duangsuse, [2023/10/14 18:16]
记起来了，这个 for(nth 应该是一个宏，只提供赋值

typealias Add<T>=(T)->Unit


fun IntArray.tuples(to: Str

ingBuilder, vararg n: Int, f:(Int, Add<Int>)->Unit) = {
var i0=0; var i=0
n.withIndex().forEach { (n,nth)-> i=i0; f(this[nth]){ to[i--]=it }; i=0;i0+=n }
}

fun Int.Str(to: Add<T>)

（好像又更复杂了…… 我是想暴露subarray
总之这种buffer 复用是一类优化，有模板

Silence Acappella, [2023/10/14 19:08]
主流的前端框架里

Silence Acappella, [2023/10/14 19:09]
有什么是擅长交互和3d渲染的

duangsuse, [2023/10/14 19:10]
https://spline.design/
https://aframe.io/

duangsuse, [2023/10/14 19:12]
https://github.com/jagenjo/webglstudio.js
https://github.com/tentone/nunuStudio #game
https://github.com/aframevr/aframe-boilerplate

duangsuse, [2023/10/14 19:16]
看起来开源软件还是不行啊， WebGL,three,d3js 不能直接用，流行实现都是闭源的

p5是2D的，DSP比较强的Web也还是比较拉垮

https://animejs.com/
https://photo-sphere-viewer.js.org/
https://splidejs.com/ 那种GL过度特效都能收钱

duangsuse, [2023/10/14 19:23]
印象里Web的3D交互也还比Qt,DX 好一点，可惜框架太少了

除了gamedev, 3D仿佛是上个世纪的技术了

duangsuse, [2023/10/14 19:25]
我觉得最逆天的是， 3b1b manim 这样的开源弹性动画+Py式PPT
都能拔得头筹

前端和脚本界真的是天上地下，牛的牛死
M$的工程师果然牛逼， 凭着C++那种烂语法都能写出各种带3D的WinForm

不过之前看GPT好像会写弹球和植物大战僵尸的，可能就是爱看高级工程师的代码

duangsuse, [2023/10/14 19:33]
感觉还是牛逼的人都去M$, Google 了，做开源的太少
M$的开源率好像比GOOG,FB的低

KODI,OpenWRT,ffmpeg, Blender,Godot 这些都算开源界顶级，勉强能和业界接轨（？
Matlab,CAD,AfterFX,Office 那种就难了（开源界连个 Web Office 都整不出
毕竟愿意无偿写代码的大佬少

duangsuse, [2023/10/14 19:58]
写动态域可以先看我的(不含数据结构
JS 里可以直接用原型链做「嵌套KV」
[{a:1}, {b:2},kv={b:3}].reduce((A,B)=>(B.__proto__=A,B))
实现了 with(kv){
push({b:3})
b==3
pop()
b==2
}

看来你还是不愿意用JDK Nashron 或 Luajava,Rhino

手写这种/命令的话 ，最好不要做局部表
另外
Scope<*> 是无法add的
type 是干什么？隐式this吗？ 那应该保存 Any

duangsuse, [2023/10/14 20:04]
你这个卡牌游戏也有点逆天…… 我拿CLI举例下

首先需要抽象的，是用于执行回合的牌桌

比如，创建每个有手牌、有pt和flag的Player ，消耗手牌也做在上面
手牌的效果，由牌桌来提供选择器、分发

发牌可能要用的概率分布等算法，定义为util fun

你把太多精力花在不必要的序列化和动态加载、「弱类型化」上面，还不如先想想特效和回合流程怎么平衡

如果你不止想做个toy ，这种游戏应该需要大量事件/await，和WebSocket那样的文本流、跨端调用

duangsuse, [2023/10/14 20:15]
所以之前就说了，可以做成组合函数，搞成嵌套数组，不就能序列化了？
a<b? log(1) : c

when(get(op('<'), 'a','b'), call('console.log',1), get('c') )

call=(k,a)=>(局部作用域)=>eval(k)(...a)
get=(...keys,fn)=>fn(keys.map(eval))

op=k=>(a,b)=>eval(a+k+b)
when=(is,a,b)=>is()? a():b()

duangsuse, [2023/10/14 20:17]
（原来ES6 在前端里真的这么不受待见

原来 React 的 tbody.map(tr=>) 真是种装酷的写法，我还以为他们迫不得已呢……

duangsuse, [2023/10/14 20:22]
既然你想做这个游戏，你能把基础玩法和灵感，先写个文档吗？
你的卡牌要有数据库， 那典型的几种选择器和效果，是什么？

这些和代码无关的，反而最值得你优化。 一些复杂性很可能只是你的需求自相矛盾

duangsuse, [2023/10/14 20:24]
感觉get不到嵌套次序
[[ary]] 应该是很少几项吧

这种写法确实很bash式参数

duangsuse, [2023/10/14 20:25]
看错了， [[ary]] 是一个语法糖
TOML 嵌套和JSON差不多

duangsuse, [2023/10/14 20:29]
看了一下， TomlNode.toStr 有700行
是你朋友写的吗？ ps. 头像很福睿

duangsuse, [2023/10/14 20:31]
那你很厉害，Decoder,Encoder 的实现还挺直接

#blog #tr 《PL 表示法有碍于入门》

#PLT 俱乐部的人 Y 组合器身上纹，却被会员评价：字体不好看

符号可以使思维清晰。使用正确的符号，一开始就能轻松地完成工作，让不重要的部分消失
Mike Hicks 认为，像 8÷2(2+2) 这样简单的算术表达式也难倒各种人，妨害 PL 研究的影响力
最好的符号是简洁的；它们在视觉上具有暗示或继承性，

有人抱怨使用函数化命名而不是数学符号看起来不那么 PL
但——这就是简化记法的一个理由！我们作品的美学很重要，但PL已经以深奥的符号而闻名。
大部分论文能将一两个符号改为文字而进步

作者建议：
-增加清晰度/减少混乱将扩大我们工作的范围并减少协作障碍
-标准化设计清晰的单字符体系
-无论类型理论、语言还是 API——都要做复杂性预算， 作为警示
-总是用简单、易发音和众所周知的符号代替，顺序更要自然

比如说，小步语义的 ⟶（暗示“从左到右”），
子类型的 <: （ : 让人清楚构造器的类型,但对于 Java 程序员来说读不懂）

SKI,Y 函数里，I至少表明了恒等(Identity)，但Y()做不到
建议换为rec/递归, fix/不变点

Guy Steele 整理了 POPL 中使用的 28 种不同的等效写法，e[v/x] 的e=v是最常见的

渐有类型和契约的文献，类型转换有3种难看写法，都被内嵌于BNF：
<S=>T>e; <T<=S> e; e : S=>T

C 表示法，(T)e 在泛型里不好用，但这些都是技术细节，问题是没有人认真提出将这些强制转换作为编程语言的一部分
cast(e,S,T) 就更加明确

--评论区后续

><t=>U> <s=>T> e ~= <s=>U> e 比嵌套
cast(cast(e,S,T),T,U) ~= cast(e,S,U) 好看
而且AST上的信息比调用树多不少，难写明

A.中缀运算符很难0基础解析
B.嵌套不易写
目标.写法相同的算式，更能读懂语意联系

e :: S => T 相对简明，但箭头不支持组合
但其实，这种转换根本不存在。作者在POPL2010使用过<>符号，但他想换了

btw. 是在说推导出 e:Int=>Long 应生成 Long(e)
符号形式应是 (e:T):T0 = e:T0, T0=U ， (s:T) 应自动理解为t=>U 里的变量t。另外这里(A~=B)不是指“A可赋B” 所以删了

合约是指 {x:Int|x>0} 这样“给字面量类型”

It’s Time for a New Old Language/2017
Guy L. Steele (Scheme,Emacs 作者)
对比下引文中「通用语言」与绝句术语

• Built-in datatypes: boolean, integer, real, complex, sets, lists, arrays
Str Int4,N YN N2 [Ln,Set,Ary T]
String Int,Long,Float/Double Boolean Vec2 List,Set,Array<T>

• User-declared datatypes: record / abstract data type / symbolic expression
data T(); type 样板为T0; S=[May Str [Ln S]]
绝句实现如 [Ln [Pair Enum Any]] 序列化的“元类扩展”也是一种S-表达式 执行

• Code: Inference rules (Gentzen notation)
相继式演算,和 unify(|,=流过滤) 都能证明逻辑算式
其推导步骤都是一个序列，有一个前提集合和一个结论，就像泛型 'T'(T Sorts) List sort 里的变数T的上界

• Conditionals: rule dispatch via nondeterministic pattern-matching
when, (A==0):return, '(文字匹配)?'/"输入"

• Repetition: overlines and/or ellipsis notations, and sometimes iterators
argv:[[1 rest,.]], Nd([x y z]), Seq.goesR和协程

• Primitive expressions: logic and mathematics
名/记平权: x==100 or (3<x, x!>100, not x==2), x in 4~100
x==100 || 3<x && x<=100 && x!=2

• Capture-free substitution within a symbolic expression (Church)
(λx. x y) z 可以免费把y换成w，w的值不会受到xy的影响，即f.bind(arg)

根据「类函变参皆数」原则，y=[Var Str]， (Fn1:[y]Fn1:[x] x+y)(w) 能实现值上的代换

Expr BNF:

id \x:T. x
(id 1)
add \x:N.\y:N. +1(+ x y)


E=P(['',//分支. P7 都看不懂，符号复用率过低 歧义也太大
  [x, 'Var k'],
  [入,x,sig(T),P, 'Fn ,k,T,e'],
  [':', T,sig(Tk),P, 'TYPE ,T,T0,e']
  [P,P, 'Fx f e'],
])
T=P(['',
  [x, 'TVar k'],
  [入,P,P, 'FnT ,A B'],
  ['变',x,sig(Tk),P, 'TFn ,k,T0,T']
  [P,P, 'TFx P T'],
  //type作为值就省了，因为类型变数间有=,|关系，不应该求值
])
sig=x=>[':',x,'.', (a,x,b)=>x]
//*->* 比如 List<_>
Tk=P(['', '*',[入,P,P, 'Kind ,A B'] ])
入='\\'

说到BNF，以上PRR还支持

x? [1,x] x* [0,x]
x, [0,x,',',{a.push(x)}]
(x) [2,"()",x]

相比COBOL这些老语言的元编程文档， 算是去英文化了，就像 json.org 的图

我看不懂 Γ-> 和两段式，M: τ ×sigma 这些语法从没定义过
而且这符号冗余率也太高了

说句心里话：
这都是什么烂代码啊？行走的同义词典？ 不愧是Emacs那难用编程语言的作者

duangsuse, [2023/10/14 20:22]
既然你想做这个游戏，你能把基础玩法和灵感，先写个文档吗？
你的卡牌要有数据库， 那典型的几种选择器和效果，是什么？

这些和代码无关的，反而最值得你优化。 一些复杂性很可能只是你的需求自相矛盾

duangsuse, [2023/10/14 20:24]
感觉get不到嵌套次序
[[ary]] 应该是很少几项吧

这种写法确实很bash式参数

duangsuse, [2023/10/14 20:25]
看错了， [[ary]] 是一个语法糖
TOML 嵌套和JSON差不多

duangsuse, [2023/10/14 20:29]
看了一下， TomlNode.toStr 有700行
是你朋友写的吗？ ps. 头像很福睿

duangsuse, [2023/10/15 10:54]
https://kotlin.libhunt.com/koda-time-alternatives

val start = now + 5.minutes()
    val end = now + 15.minutes()

看了一下。 我觉得Date的设计就不合理啊…… 它就是一个int2tuple 转换
直接把 plus,minus 推广到Date上，写这些 timespan 库干什么，很像 range/slice 这些同义词 😅

fun lift(op:(N,N)->N): Date.(Date)->Date = { Date.from(op(this,it)) }
plus=lift(Int::plus)

（虽说，工业界都拿 math.sumprod 当np.dot用，不知道向量怎么用 😐

duangsuse, [2023/10/15 10:55]
你直接去py群问
kt能干什么ML？ 连API桥接都没人做

甚至JS都有标准的 AudioBuffer, SpeechRecog,TTS 接口
kt都没重封装JVM的工具库
stdlib https://kotlinlang.org/api/latest/jvm/stdlib/org.w3c.dom.mediacapture/ 的文档还是空页面

kt,C++这些在数理应用上都是废物，一直在阻碍AI的发展
用它们无论写理论还是app都废话多功能少

duangsuse, [2023/10/15 11:07]
看到一个有趣的:tau=2pi 被认为才是真的PI 🤔

哈哈，又是古老的重构…… 如果用 Vec.xy 取代sin,cos 应该就没这个弧度问题了

duangsuse, [2023/10/15 11:09]
以前我 let DEG=2pi=360deg ，方便给vec2设置旋转
没想到这也能叫改进…… 只有PI受伤的世界呢

duangsuse, [2023/10/15 11:12]
主要是又区分 date/time 又新建 timespan 也太离谱了

明明就是，你给long一个单位，进制换算， 结果无数个新数据类型和lib……

isekiのChannel, [2023/10/15 11:12]
你看看Go的 time.Time 和 time.Duration

isekiのChannel, [2023/10/15 11:12]
但使用起来无比丑陋，而且容易出bug

isekiのChannel, [2023/10/15 11:13]
time就是time，不是int

duangsuse, [2023/10/15 11:13]
Time= 自0时(Epoch) 开始的Duration

我就是说time是long的 inline class 嘛
明明一个重用率<5% 的type，却设计得如此膨胀

duangsuse, [2023/10/15 11:14]
是啊，所以只需要用 1.min, 1.hour 来 check就能加减了
Julia Unitful.jl就是这样

duangsuse, [2023/10/15 11:16]
这些所谓的细节(time.h , libc,.)，都是需要支持+-*/ 的

如果是精度就应该用bigint 。这些开销是无法回避的
可惜比较算式化的 python 也没认真设计这些

duangsuse, [2023/10/15 11:17]
我说的不是long vs int ，我是说Date=有单位的 integer

duangsuse, [2023/10/15 11:18]
时区和显示也就是个加减问题了，但Date的本质是整数

所以，其实就是工程界普遍，无法把一个问题解偶， 导致随着App的增加，类型越来越复杂

duangsuse, [2023/10/15 11:19]
你要区分「显示形式」和实质……
物理时间，无论世界的哪个地方都是一样的，只是书写形式不同

就像编程语言，只能用范式，而不是语法糖和API来区分
那些都是跨语言的

duangsuse, [2023/10/15 11:20]
所以说，timespan 这些工具类，应该被理解为 Instant 这样的“数值类型”呗
而Date ，其实只是 from/to 构造器

duangsuse, [2023/10/15 11:22]
IO、UI的问题要分着谈啊，
为什么后端总是搞不懂，用户只会在操作系统里调时区这些设置……

就好像一些 data table 的程序，它们不会把数据给Table组件排序
而都是硬编码

如果这些处理，是分应用、框架、OS层次的， 许多技术和API就会消失

duangsuse, [2023/10/15 11:24]
我只是依照「<5% 复用率的types，都需要更多权衡」这些设计原则

duangsuse, [2023/10/15 11:26]
在JS里，Date基本只是toStr的职责，但Java可能对它做加减和距离比较

但这个类型，其实就是专门方便UI做的， 它本该更广泛， 比如读取 “10万8千” 这样的单位，加权求和

duangsuse, [2023/10/15 11:32]
这其实还是UI的问题，只能提供元祖上的加减法，由被调侧决定有多长
因为>=1month 的加减在数学上是没意义的，自然不可能涉及timespan

duangsuse, [2023/10/15 11:36]
不需要第二个类型，一个支持按tuple加减和读写的 IntVar+DateFmt+Locale 应该就是各种Date了

在用法上都是支持的

duangsuse, [2023/10/15 11:37]
比方说，你显示+1day 的日期， Date().add(days=1).Str 肯定比创建两个span，或setDays 要好看啊

duangsuse, [2023/10/15 11:39]
timespan, 按libc 的概念应该要加法有两个“Date”

duangsuse, [2023/10/15 11:40]
算了，不说这个了，反正Linux的时间API不会改，也没有千年虫问题了

Semver Cmp? Ver Semver? (|| Semver)? --N项树,不是+-*/
Cmp /\^~=|([<>]=?)/
Ver v di(. di)?(. di)?(- Str)?
di /\d+|\*/

semver 判断区间的方法，应该是把 1.20.3 转为 1203 吧，这样大版本不同也不能兼容
最好是每个点固定1_0000等位数，这样也避免判断麻烦

pkg manager问题有那么严重吗，都要上二分bisect了…… lock文件可以缓存吧
>=12 <14 || >10 應挑選 10 这一条我觉得有点奇怪，虽然语法是对的，但这就是个区间过滤器，其实不能当成算式联立去编写。
^12 应该也是>12 的意思吧

其实现在有种观点是，apt那样各种版本限定符太严苛了，npm重得太可怕
pip; pacman; npx 那种全局单版本依赖更流行

duangsuse, [2023/10/16 13:21]
感觉取消不应该抛异常啊…… 比如fetch() 下载文件，主动取消，有什么该处理的呢

duangsuse, [2023/10/16 13:23]
比如上面那个delay的例子，取消就是 Dispatcher 去run（） 时啥都不干了，就叫取消了

就像进程的exit() 一样

duangsuse, [2023/10/16 17:53]
翻译：
骰子是一个 OldVal<AddAttr<Int>>(v, used=false) { fun invoke() }

结果是 N个骰子.groupBy点数.eachCount

duangsuse, [2023/10/16 17:55]
建议你搜索 Trie树
其标准实现是正则匹配
或者 dir.list()

duangsuse, [2023/10/16 17:58]
你看，只支持 trie[a][b] 的嵌套情况，反而比递归的复杂些

duangsuse, [2023/10/16 18:11]
其实就是 Map<X, Map<Y, Z>>.get(X)= get().values
这个重载…… 第二个Y当然可重复啊

不知道是怎么说得那么复杂的， 好像比trie简单。

duangsuse, [2023/10/16 18:12]
Mongo不是 java.util的外置化吗
为啥比SQL厉害

在我看来，直接绑定为 List,Map 就好了，除了 connect("") 就没有差异

duangsuse, [2023/10/16 18:16]
其实呢，你做个 A:User follow B 就知道SQL对1:N的支持更好
用dict-list 的反查需要写 user.filter{ b in it.follows }

TEXT[] '{,}'pg也是支持的

duangsuse, [2023/10/16 18:23]
其实你应该用 operator fun get， 是支持多参的

另外，如果你支持 getVar():MMap.Entry 就不需要支持set+remove了

duangsuse, [2023/10/16 18:25]
kv2.flat{it.entries}.findKey 呗

duangsuse, [2023/10/16 18:25]
可是过度Java化也是没意义的，你都已经kt化了

duangsuse, [2023/10/16 18:26]
python 里list[:] 和numpy的切片甚至是多维的
而你写的复杂度，还没达到算法（实现性差异）隔离的要求

duangsuse, [2023/10/16 18:28]
能自创这样 dict[(a,b)] 的数据结构，我看提需求的人也没重视性能……

duangsuse, [2023/10/16 18:58]
现在有这种 get()= field 子类型的写法了

虽然我觉得很茴字四种写法，但似乎比两个val好

duangsuse, [2023/10/16 19:18]
太逗了，应该 val get 的做成 fun
大概要退化到Qt那样，用 v(), set_v() 好了

duangsuse, [2023/10/16 19:43]
实在是太混乱了，和某些JS“函数式框架”的 freeze()一样，kt集合可变性纯属过度工程

duangsuse, [2023/10/16 19:46]
当一个纯属语义检查的玩意，被附加“缓存池” “纯度高” 等抽象的政确后，就变成似乎是另一门编程语言一样麻烦。

duangsuse, [2023/10/16 21:51]
我是说 List无论是否Mut，都应该映射为 util.List ，因此 toList 不能有复制语义
runtime 时不可变是无意义的

duangsuse, [2023/10/16 21:55]
其实分那么细，没意思了

我有个想法，把 let/run代换成 1.as:[x]
also/apply代换成 user.to: name=""

或者说 1:+1 ; user|: age=:+1

map,forEach同理

duangsuse, [2023/10/16 21:56]
没错，我没打算给这些老语言提建议

它们根本看不见每行开头的冗余

duangsuse, [2023/10/16 21:57]
这就说明你作为程序员，不重视软件的本质
所以你的思考就会被篇幅所占满，

别忘了你用的libs 也一样。 这就像生态系统的毒素一样，是传递性的

duangsuse, [2023/10/16 22:04]
这样滥用as 还有个好处，可以让流控消失掉

for(x in users)
  if(x.isAdmin) print(x)

users:[x]
  x.isAdmin: say(x)

1{>2}==NO //takeIf,f

irst,filterMap
users{name=='Jack',age<10}!
users.if{it.isAdmin}: say(it)

甚至函数式都会消失
"abc".firsts("a")==$Y // takeWhile


[(0~9),. (0~9 by -1),.].firsts{it==0}.N==1

包含跳转:

for(x in users)
  if(x.isAdmin) print(x) else break

users:[x^]
  x.isAdmin { say(x) }: return

duangsuse, [2023/10/16 22:23]
这种语法很变态，但依然有意义，是因为它能够被整理为2个情况

1. if,to,as 多单项函数: filter,forEach,map ，正好是SQL小礼包
2. 1,[1]. as{it==1}, isXX {$Y}:$N, Either{A}{B} 多单项选择

这种可不是语法上的可读性，而是整个编程范式都易学了
比较类似把YAML,SQL,numpy 的功能刻印到kt上，但不干扰之前的OOP体系

为了这样的体系，和旧语法割席还是做得到的

在设计ita函数时，我还在考虑响应式(StateFlow)、树同步( [1,x]=[2,y] 这种) 等情况，

无论是对事件变量，还是树形结构；无论是列表处理，还是单项与流控， as, to (invoke,赋值) 都有正确、一致的语意，其地位也直击要点。
let, also 做不到这些。难怪Kt把这个改进弄销声匿迹了

只拿它区分茴字两种写法实在是暴殄天物(就像它没发现 x as Int 不如 .as<Int> 易写)。with,by 这些助词就是天选之子，偏偏kt把它加在奇怪的位置，用一种老式OOP的方法（当然也比jspy好了

Koshin, [2023/10/17 08:03]
歪个楼，每每关于现有kt语言的观点，（作为日常写业务的菜鸡）有点看不懂，感觉每次吐槽完，也没什么然后。请问，下一步是打算做点什么来弥补所看到的缺陷（比如贡献一些库）？还是说只是在学习这方面的内容真的只是在讨论

duangsuse, [2023/10/17 08:34]
真的只是说一句，反正不会有人听的，而且现在kt支持的 operator fun 也不够用

你觉得GPT味，是因为我说的比较细。 单用YAML的逻辑去理解上面的代码，是容易的

Kotlin 现在不好的，在改良的特性也很多，就比如那个 typed companion(namespace) 和 private Mutable(私用 field:)
我现在在设计一种CLI序列化器
fun main(a:Argv)=a.Dict<Hello>()
class Hello /*:CliktCommand */ (
var name:Str,
var source: Ln<FStr>,
var out: File,
var r:Fire,
var count:Int=1,
var v:Boolean=false,
):CLI("""
c Number of greetings
id The person to greet?Your name?
v enable verbose mode(or .env)??
""", "name id") {
fun main() {
(1..count).forEach{ r+"Hello $name" }
out.Eq("") {it+source.joinToString()} //append
}
}

duangsuse, [2023/10/17 08:36]
如果 filter,map 你看不懂，说明你没写过html模板，或者没尝试“理解”SQL

firsts(takeWhile) 和 users:[x^]return 没懂是可理解的，毕竟和 startsWith 混一起了，而且你们也不会用 forEach{+return}

duangsuse, [2023/10/17 10:25]
>webp对BW纯黑白图片有特殊压缩吗？
WebP 使用了一些特殊的压缩技术，如预测编码和分段压缩等，这些技术可以在一定程度上提高压缩效率。但是，对于纯黑白图片，由于其像素值只有两种可能，因此 WebP 的压缩效果可能不如彩色图片明显。

duangsuse, [2023/10/17 10:26]
>Java 有没有标准 2D Mesh 实现
Java 提供了 java.awt.geom 包来支持 2D 图形操作，其中包括了一些基本的形状类，如 Rectangle2D、Ellipse2D、Line2D 等，以及一些变换类，如 AffineTransform。但是，Java 并没有提供标准的 2D Mesh 实现。

不过，你可以使用第三方库来实现 2D Mesh，比如 trident、jzy3d、jogl 等。这些库提供了丰富的 2D 和 3D 图形渲染功能，包括 Mesh 渲染。你可以根据自己的需求选择合适的库来使用。

duangsuse, [2023/10/17 10:28]
你这个图形在SVG里叫path=""

二维bool数组有点奇怪，bitmap更奇怪，因为你遍历时是要解压的

拿编程的API去理解物理世界的计算，是我没想到的。 GL,SVG都有对应的技术，可以文GPT

duangsuse, [2023/10/17 10:34]
你先编号，不就没这个问题了？？
y*w+x

duangsuse, [2023/10/17 10:35]
既然你想「不可预估的」扩展性，Set+dataclass 好了

duangsuse, [2023/10/17 10:35]
感觉你在做比 Terraria 更复杂的游戏

duangsuse, [2023/10/17 10:36]
如果没有Unity之类物理引擎的使用经验，最好不要

斜着可不止麻烦一点点

duangsuse, [2023/10/17 10:39]
实在不行可以
>用KD-Tree 做坐标集合，但是要连续

import numpy as np
from scipy.spatial import KDTree

# 坐标集合1
coords1 = np.array([[1, 2], [3, 4], [5, 6]])

# 坐标集合2
coords2 = np.array([[7, 8], [9, 10]])

# 连接坐标集合
coords = np.concatenate((coords1, coords2), axis=0)

# 构建 KD 树
tree = KDTree(coords)

duangsuse, [2023/10/17 10:43]
那你这不是典型的 bitmap(canvas) composite 问题吗？

>有两个黑白 A,B: PIL.Image ，C=二者And逻辑门的结果
请使用 composite Mode ，不用循环

from PIL import Image, ImageChops, ImageOps

# 对图像A进行反转操作
img_e = ImageOps.invert(img_a)

# 对图像A和B进行逻辑与操作
img_d = ImageChops.logical_and(img_a, img_b)

# 将图像E和D进行合成
img_c = Image.alpha_composite(img_e, img_d)

duangsuse, [2023/10/17 10:43]
没用过像素图的人把bitset误读成bitmap
偏偏他们是大多数

duangsuse, [2023/10/17 10:45]
往大了说，bitset,map 都是vector，都是 ndarray，但前者是1D的

bits压缩不是没代价的。不要只是 CPU换内存开销

duangsuse, [2023/10/17 10:51]
😒 我以为他真的要「几何」
没想到只是像素

既然只是测试相交的话， bitset也可以实现二维
反正宽度是固定的

duangsuse, [2023/10/17 10:58]
为什么你的实现方法都这么ast啊

tree只是数据结构的一种情况吧

duangsuse, [2023/10/17 11:03]
如果真要这么推广，就到点面相交的碰撞检测了

duangsuse, [2023/10/17 12:09]
我看你是要重造sd函数

duangsuse, [2023/10/17 12:11]
总而言之就是俩字，逆天

这么复杂的东西，想实现起来都未必
即便你搞了个快速原型，其必要性也是存疑的，大概率对软件没有帮助

duangsuse, [2023/10/17 12:14]
我们有一万种理由强化自己对编程和某些项目的理解

但没理由做一些跨界的事，因为那容易把问题搞复杂，
要么你系统性地跨界，要么就换其他的功能点做， 不要做半拉子， 自古以来的垃圾软件和大佬，都是半拉子

真是越想FP,PLT 圈就越来气。 他们浪费了我多少宝贵的创作时间，去理解一些基本的写法和设计模型， 就是因为自己瞎设计一些自己不懂的「跨界术语」导致的

明明有更简洁自然的定义式/关系式手段可以做的框架，偏偏要把一些概念和算法混在一起， 这样拿其他学科领域的功能骗赞的技术，消失也罢

duangsuse, [2023/10/17 12:38]
既然你要的是可变集合，那Set或2D数组就是最好做法

Silence Acappella, [2023/10/17 12:42]
我要是要算两个点之间的具体距离，直接x^2+y^2开平方根不就好了，如果是算走过的格数，我x+y直接求近似值

duangsuse, [2023/10/17 12:59]
不不，换成两个三角形，存Mesh岂不是有C语言担保的快（

太抽象了，你有线性代数的潜质

那些人就是把xyz的集合理解为超平面之类的玩意
但其实，坐标是不设限的集合， 是物理概念，将他们混为一谈，有时就是种负担
—
btw. 澄清一下，我讨厌不简明的线代。 我和所有复杂的东西划清界限
虽然我不懂线代， 但我讨厌没有模型和可视化，就在解题的一些人

我历来反对强调问题复杂的理论。那是与PLT和计算工具相悖的价值观；持有这种思想，学什么都会泯然众人，
“无非是自己搜到资料的多少，决定了问题复杂与简单”， 像这样的缝合不应称为理论。

只要我还碰电脑一天，我就会去用工程的语言消灭这些理论，就像python做的那样
无所谓好不好玩。 shadertoy.com 的DSP才好玩呢

duangsuse, [2023/10/17 18:28]
这就要看价值观了。
- Java里的null和catch问题，Haskell提供“有不同形态”的Maybe，Go则喜欢到处res,err:=，到Kt里就是简单的 ?.run 和 ?: 而已
- C++ 里的头文件根本没法解决，但Kt,Rust 不仅没有这个耦合度，更支持“外部扩展”
- npm,mvn 里复杂的版本管理，在今天被用于各种跨领域模型工具的python 却只是 pip setup ，最多加个venv ，基本没啥可优化的

在安卓里，就存在许多Web没有的问题。 CSS今天有响应式单位、模块化 ，许多“原生排版”甚至只有整数和颜色。 有些人泡图书馆3个月的成果，是H5一上来就会送给他的。

你并没有从最终用户的视角看问题，也没有脱离单一语言的世界观。 编程里许多的范式、魔法和设计模式，都是为了解决「代码自己产生的问题」
随着语言和生态的进步， 它们自然会消失；它们的消失，会让软件更好用。

如果肯静下来，拿笔纸去记录，经常性的反思， 删除一切显得聪明的技巧
并且，标明每行代码对需求 为何必须
你才能直面「根源问题」

duangsuse, [2023/10/17 18:59]
说到「地狱」类问题， 我倒是想起回调地狱一词。

其实答案在50年前就给出了： 传递回调，就是流控-return 的另一种实现法
线程栈vs协程栈。 就像创建SAM函数值时，外部函数要被做成对象；调用协程时，自己也要被做成状态机+回调。

但直到async()=>和同样基于“铺平,只添加return后续”的Promise 出现，异步触发始终是地狱
而一些静态语言里，新的Future, Rx 带来了另一些不一致性

那么函数式这段时间在干嘛呢？把「自动回调化」命名为 CPS,Continuation“续体” (函续..),callcc

然后，就连它们自己也没解决“异步触发return” (delay)的问题，因为纯的世界没有UI,UX
好像细化了。 但还不如协程来得直观

如果函数粉和 JSer一起，运行前/后的，“窄化所带来的地狱”都可以消灭
但它们就是不肯好好说话

duangsuse, [2023/10/17 19:13]
呃。。可能是我看线程（调用栈）的方式不同吧

你知道汇编里，栈必须保存ret_addr
就像调用时，要传回调。 那样的话，就可以让CPU返回主循环，复用一个线程，且保留call-ret 时序

duangsuse, [2023/10/17 19:20]
怎么会呢？

- main Waits: say(f())
- f Wait:
1s; say("good"); 2

补充下， Waits 只是给一个 [Fun1 [Cont *] ] 传递取消阻塞线程的cont

duangsuse, [2023/10/17 19:24]
我是为你能看懂啊
1.sec
return 2

Kotlin 的 {2} 块是有返回值的吧？

[Fun1 [Cont *] ] 你看懂也没看懂
Cont<*>.()->Unit

duangsuse, [2023/10/17 19:30]
named Round
data Obj(radius:N) [impl?]
data Hole(radius) Obj()
- getRadius TODO""
- fits(:Peg) radius!<peg.radius

data Peg(radius) Obj()

duangsuse, [2023/10/17 19:32]
>= 就是不小于
我不是故意这么写的，是为消除 isNotEmpty

duangsuse, [2023/10/17 19:35]
确实，比如 a~b . has(x)
x!>a, x!<b 看起来很丑，这只是被迫

list.!isEmpty()
list: !zero, this[0]=="A"
list !zero

duangsuse, [2023/10/17 19:36]
图中的方法都是冗余，你看看那些函数签名、 class is method.. constructor..

直接把对象，当成共享了构造期局部变量的多函数，不香吗？

duangsuse, [2023/10/17 19:38]
如果复杂度不转移给电脑， 我们就让它解体、消失

duangsuse, [2023/10/17 19:42]
那API设计我也在做啊

你为什么觉得我只做语法糖呢
直接把对象，当成共享了构造期局部变量的多函数，不香吗？

duangsuse, [2023/10/17 19:45]
这种语法的文件级包含：

data now made type named 

语句级: return at now
用于Data,Enum,sealed,隐转适配器: when- when--

也没有流控什么的，还是相对好学的

duangsuse, [2023/10/17 19:55]
涉及非常复杂的比较， 但总之，绝句不是一种OOP 或C-like语言

-- qsort(it:[Ary Int],range=iEach)=range: (A<B): “two”
at now:
mid this[A]
a A+1; b B
as:
a!>B, it[a]<mid loop: a.goesR
b!<A, it[b]>mid loop: b.goesL
loop(a!=b)
less(a,b) “交换逆序ab”
less(A,b“min”)
qsort(it,A~b-1); qsort(it,b+1~B)
^now
at less=Fn2:[A B]Var.swap(it[A],it[B])

duangsuse, [2023/10/17 19:55]
- main
at story Fun1[Animal]: speak()
at c Animal.Cat
c.story
c.水豚.story

type Animal
- speak Str
when-- as
Cat; Dog(name:Str)

when- Dog.to Animal
^now
- speak "good $name"
when- Cat.to Animal
^now
- speak "meow"

when- Animal 水豚
^now
- speak "..."

when--'AB' Way2 “Either”
A(:A); B(:B)

duangsuse, [2023/10/17 19:58]
我上面说了，Wait: 是支持返回值的
只是它 await() 的方法是隐转

在Wait{}块内，是一个以回调为this的函数

duangsuse, [2023/10/17 20:17]
那绝句也有函续作为值啊

data 'T'Seq(do:[Cont _ T], now, got:T,posR=$Y)
- add(:T, :Cont)
got=it “yield=休眠”
- set(:Cont) [our]
do=cont “初始=休眠”
- goesR“ight”() T
do(NO); return got
^named
-'T' as(:[Fn2“双this”[You Seq Cont] ]) this|:
Waits{posR=$N “no hasNext”}:
this: set(); fn()

- main
  at ln [1 2 3].reversed (Sum(A=NO): Link(B,A))
  traverse(ln): say("I got {it}")

data 'T'Link(x:T, xs:Link?)
-'T' traverse(xs:Link?) Seq: when xs:
  NO{}
  Link: add(x); traverse(xs)

duangsuse, [2023/10/17 20:24]
OOP 就是缺乏这种东西，才搞出 Factory

Rust都没有办法简洁地“分支出”新数据

Kt在设计 inner class 时可以稍微思考一下，把它做成一种 ext fun

duangsuse, [2023/10/17 20:36]
是的。比如 水豚 可以从 Cat,Dog 强转
就像
data Rect'wh'(:N) [impl?]
- Square'l' Rect(l,l)

when- Rect Pos'xy'(:N)

- main
Rect(10,20).Pos(0,0)

duangsuse, [2023/10/17 20:38]
Kotlin 的写法：
fun main() {
Rect(10,20).Pos(0,0)
}
typealias N=Double
open class Rect(val w:N, val h:N)
fun Square(l:N)=Rect(l,l)

inner class Rect.Pos(val x:N,val y:N): Rect(w,h)

Loney Chou, [2023/10/17 20:51]

fun Rect.Pos(
    x: Double,
    y: Double
): Pos {
    return Pos(x, y, this)
}

open class Rect(
    val width: Double,
    val height: Double
)

fun Square(dimension: Double): Rect {
    return Rect(dimension, dimension)
)

class Pos(
    val x: Double,
    val y: Double,
    rect: Rect
) : Rect(rect.width, rect.height)

duangsuse, [2023/10/17 20:55]
''N=_N8
''Int=Int4

这个 ''typealias 也不是乱加的
''Cnt=Int{>0}
when-- 'AB'as
Pair(B:A,B:B)

'A'T 代表“T是A类型的单位”
就像 'AB'KV, [KV Int Str]

duangsuse, [2023/10/17 21:00]
背后是有体系的
单位类型、from/to 转换、单组/多组/多种 类型，正好能适配序列化器的创建

Int就被视为单组var
User是多组
Any是多种


'' 这么省是方便移植公式
- lerp'ABt' t*B+(1-t)*A

fun(:Double)= 就不知道有多长了

duangsuse, [2023/10/17 21:03]
Int4,8 也是为了避免麻烦
大家都是按Byte读写

没人会做bitflags 这样的事了

duangsuse, [2023/10/17 21:03]
$Y,$N 是 YN, Bool
NO 是 NO?, Nothing?

duangsuse, [2023/10/17 21:05]
bit 我也重构了，趋向与BitSet一致

1.Bit+2 or
- and not
1.Bit in 1 and交集
xor就是xor, shl8 是 1.Bit(+8)

这样，拼接8bit 的算法可写为

[1 2 3 4](Sum(0x0): A.Bit(+8)+B)

duangsuse, [2023/10/17 23:39]
#FP 读了一篇文章
data 'T'Box(:T)
//map:: (a -> b) -> Container a -> Container b
- 'TR'Box as(:Fn1) Box(fn(it))

Box(2): it+2
Box('flamethrowers'): it.toUpper
Box('bombs'){it+' away'}{it.n} //10

when-- 'T'Maybe
No; Just(:T)
- isNothing as[No]!=NO
-'TR' as(:Fn1) as[Just]?{fn(it)}:No

(0~3):[i]
Maybe('abc'){it.get(i)}: say(it)

when-- 'AB'Either
Left(x:A); Right(x:B)
//Left<A>(): Either<A,*>
-'ABR' flatMap(A:[Fn1 A]-[Either A B], B:[Fn1 B]-[Either A B]) when this:
Left: A(x); Right: B(x)
-'ABR' as(A:[Fn1 A], B:[Fn1 B]) flatMap(Left,Right)

duangsuse, [2023/10/17 23:40]
🤔 剩下两章不看了。 其实绝句的fn{}{}: 比任何语言(比如,do记法)都适合写Functor, 而 '1'(Eq(toInt,toStr)):+1 ，比 T.[Fn A B]->[Fn [T A] [T B]] 更像lift的语意

如果用CPS(调用都返回给'函续')理解Monad，IO,Either的职责就是一个协程调度器，负责链式if,传递catch
纯函数不支持全局(堆)，也难以靠多this这样来组合算式，这么依赖栈来“赋值”和IO，很好理解

从这个角度 我觉得教授Franklin比我狂，他大方表明了PF粉对重赋值的厌恶，即便 ^^从工程的眼光^ 来看，PF函子只是用拙劣的模型实现了注入变数的函数。它们没比逻辑式编程通用到哪去，我观察到F口中的优雅是“>10次出现,未定义”+“定义后未使用”
而且，注入这种烂特技，在Java里都要被模块替代了

范畴论有点奇怪。 既然 f:A->B 是一个1:1的映射，就说明 f: B->A 也该存在，不然强调1:1干嘛呢？直接说调参可memo更严谨。

把反函数补上，就解决了数据绑定乃至IO问题，这正是React的取代者所号称的Signal>State ，然后函数式的身价就会像React诞生时一样飙高。
虽然React,Ramda对定义式编程完全是个白痴，它的写法和术语背后是另起炉灶+东拼西凑。 那些PF粉丝说的优点，他们自己可懒得践行。对代码质量的追求再高点，可不会被纯度挡住定义式的心智模型

不可变的数据树 很“确定”，但你还是要把它绑到参数里memo,重写。直接在参数改变时重算，与调用栈和对象的层次解偶，还用memo什么呢？如果type checker 没副作用，这么做也不算，它只是替调栈做一次模式匹配而已。

duangsuse, [2023/10/17 14:22]
看多了代码，已经不习惯写议论文体了吧

这样的话，你维护的项目，也一定缺少一个大纲或设计思想。

duangsuse, [2023/10/17 14:33]
这种事情GPT比较懂，你问它好了

一般来说，群成员多样化应该是好的。 我见过一些书籍分享群，没几个人说话

duangsuse, [2023/10/17 14:40]
还真是。 我在写的一篇总结文，就打算囊括我这几年整理出的一些术语的定义

基本上，一篇就可以抵过我5年的试错史了；这类文章我每天都在写，不然还真写不出来

Omico l Dev, [2023/10/17 14:42]
其实无外乎就几种情况：
融汇贯通，盖棺定论。
似懂非懂，犹豫不决。
自以为是，似是而非。
不懂装懂，口出狂言。

而上面这种就是第二条，所以看不懂就先放着。

duangsuse, [2023/10/17 14:46]
-科学就是盖棺定论， 不追求代码API的一致性，就会像py2to3, kotlin 那样改来改去
-我刚刚还批评过Silence的犹豫不决， 并且明确说过，我反对不易懂的解法
-比如？ 无论据批评==似是而非
-同上，你的论据？

duangsuse, [2023/10/17 14:49]
我的批评，一般对事不对人

我引用的链接，不代表我懂那些东西。上面也说了，只是观点

duangsuse, [2023/10/17 14:50]
无论据批评==似是而非

看似你批评了，但其实不涉及具体编程问题

duangsuse, [2023/10/17 14:51]
对我来说，只需要有观点和写代码的精力， 哪里有甚么懂不懂的

编程是种模棱两可的抽象， 只要能完成需求，你只用AI也是懂的
懂别人的才叫懂？ 那些软件缺了哪种“优化技巧”，照样转。

duangsuse, [2023/10/17 14:55]
对于既有的理论， 确实有「懂不懂」的说法

但对于解决某种（根源问题）的方法， 就只要有不同的观点，就这

duangsuse, [2023/10/19 17:47]
你也自己处理一点啊， 你这提的点子都是什么地狱灵感

Ketal _Q_ray 🍥, [2023/10/19 17:49]
线程成本太大了复用不香吗

duangsuse, [2023/10/19 17:49]
他讨论 的是并行加速吧

duangsuse, [2023/10/19 17:50]
就像游戏一般用UDP而非流式TCP

如果读写竞争，造成的是浮点级的误差，还是可以忽视的
你想多CPU，就线程， 只是想做事件，就协程

isekiのChannel, [2023/10/19 17:51]
我估计他不知道什么是CPS

duangsuse, [2023/10/19 17:51]
传函续调用，自动回调呗
delay(1s, callback)

如果你连并行(parallels)和并发都分不清，还是不要处理读写竞争问题了
并发是不会有竞争的

Silence Acappella, [2023/10/19 17:54]
那能不能这样，一个scene就一个线程，然后访问啥的，全部由scene内部的这个线程将信息发给玩家

duangsuse, [2023/10/19 17:54]
说起来，如果你需要传Blob
WebTransport https://developer.chrome.com/zh/articles/webtransport/
已经成熟几年了

Silence Acappella, [2023/10/19 17:54]
一个时间点只有一个指定的人能操作

𝗿𝘂𝗮𝘁𝘁𝖽 { 𝗍𝗁𝗋𝗈𝗐 𝗻𝘂𝗹𝗹𝗽𝘁𝗿(𝒊𝒕); }, [2023/10/19 17:54]
你应该考虑把信息交互做成非阻塞而不是考虑用多个线程

duangsuse, [2023/10/19 17:55]
唉，又是这样的伪需求（（

Silence Acappella, [2023/10/19 17:55]
我原本用的是springboot思维，多少个service多少个线程

duangsuse, [2023/10/19 17:57]
>这让我想起了 server-socket() 的 bind() accept(N) 问题

其实这个N很难决定，一般都是框架做调整

—今日玩笑
AI回复我：
🤔👨‍💻💻🔌🔗📡🤝❓

不愧是Java，自己造了一个WS子协议

我以为吧RPC映射到 /http/?params 已经很离谱了，把已经靠“endpoint”拿到的WS，也转换到http路径， 不就又凑到了大量字数？
真的很Enterprise
C线程就是Linux调度的协程
协程不能并行，没有CPU竞争问题，语义上被确定为调用返回

所以，要read()就需要占线程，阻塞它的调用栈； 靠创建线程sleep太耗时了，而且不能返回值
要并行用SIMD和numpy GPU就行
不然应该是要锁和原子加减法
这也是OS在支持 epoll(select) 的原因

理论上，OS就像VSC那样，可以单线程运行和IO，而其他Workers 只负责加速