#HR - 做过哪些项目，用过哪些 Android 开发相关的东西
没有，H5赛高


- 「大学生活质量指北」是什么
不过VS Alt-S 同行数多光标可以列粘贴, 但含换行的要 s/(^- .*)\n(.*?)/$1-NL-$2/g


- Java 里 LinkedList 和 ArrayList 的区别

链表不需要resize (1 (2 null))
+ LinkedList 和 ArrayList 是 Java 中两种常见的 List 实现方式。ArrayList 是基于数组实现的，它的随机访问速度很快，但插入、删除元素比较慢；LinkedList 是基于链表实现的，它的插入、删除速度比较快，但随机访问比较慢。

- 栈和队列的区别，如何用栈实现队列，Android 里哪些地方用到队列

Queue.add-pollFirst 队列 add-poll 栈。Looper Handler.post Stk.poll()=len==1? pop() : (x=pop(),r=递归,add(x),r) 。转换的话，LIFO两次==FIFO
+ 栈和队列都是数据结构。栈是一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作；队列是一种先进先出（FIFO）的数据结构，允许在队尾进行插入操作，在队头进行删除操作。可以使用两个栈实现一个队列，在队尾插入元素时，将所有元素都压入栈1中，在队头删除元素时，将栈1中所有元素依次弹出并压入栈2中，然后从栈2中弹出队头元素。在 Android 中，队列常用于消息队列、任务队列等场景。

- 上面我提到了 LRU 缓存，所以什么是 LRU 缓存

eg.已满100项{arg:ret}则删掉最早1项
+ LRU（Least Recently Used） 缓存是一种缓存淘汰策略，根据最近使用时间淘汰长时间未使用的缓存。常见的实现方式是使用哈希表和双向链表实现。

- HTTP 和 HTTPS 的区别

HTTP(SSL(connect(IP:port) )) 公钥加密的有无
+ HTTP（HyperText Transfer Protocol）和 HTTPS（HTTP Secure）都是用于在客户端和服务器之间传输数据的协议。HTTP 是明文传输，安全性不高，HTTPS 通过使用 SSL/TLS 协议对数据进行加密、签名和鉴别来保证传输安全。

- 进程和线程的区别

有无内存,fd资源隔离
+ 进程和线程都是程序执行的基本单位。进程是资源分配的最小单位，包括代码、数据、内存空间、文件和设备资源等。线程是程序运行的最小单位，每个进程至少包含一个线程。线程共享进程的资源，但各自有独立的栈空间和程序计数器，因此线程之间的切换比进程之间的切换更快。

- 有哪些方式保证线程安全

原子和锁，或者向量化 各自隔离
+ 保证线程安全的方式有很多，常见的包括用 synchronized 和 ReentrantLock 实现同步，使用 volatile 关键字保证可见性，使用原子类和并发集合等数据结构，避免使用共享资源等。

- 堆内存和栈内存的区别

堆new的对象不会在return时删除、栈很小(Linux 8M)
+ 堆内存和栈内存都是程序运行时的内存空间，不同之处在于堆内存由 JVM 进行管理，用于存储对象和数组等动态分配的内存空间，而栈内存用于保存方法执行时的局部变量、方法参数和返回地址等信息。

- StackOverflow 和 OOM 分别会在什么时候发生，如何避免


-Xms:8G -Xss:1G(划掉) 栈爆只会在DFS的输入太大或无基线，类似的OOM是BFS没有记忆而无限回环
+ StackOverflow（栈溢出）通常发生在方法递归调用层数过深或者死循环等情况下，导致栈空间不足，程序无法继续执行。OOM（OutOfMemoryError）通常发生在程序申请内存空间过多、频繁分配内存导致堆内存不足时，导致无法继续进行内存分配，程序出现异常退出。避免 StackOverflow 可以使用迭代或其他方式代替递归，避免无限循环。避免 OOM 可以通过优化程序算法、降低内存消耗、调整 JVM 堆内存大小等方式解决。

- 算 6&5 和 6|5

4+2+1, 0b111&|0b110, 5,6
+ 算 6&5 得到的结果是 4，6|5 得到的结果是 7。

- Activity 里什么时候会保存状态、恢复状态

onRestore/SaveInstanceState(强类型KV), 请AI实现 V:Parcelable
+ Activity 保存状态、恢复状态和屏幕旋转的生命周期都跟 Activity 生命周期有关。当 Activity 被意外销毁（如系统内存不足）或者用户主动退出时，系统会调用 onSaveInstanceState() 方法保存 Activity 的状态；当 Activity 重新创建或者从后台恢复到前台时，系统会先调用 onRestoreInstanceState() 方法恢复状态，再调用 onCreate() 方法重新创建 Activity。

- Activity 屏幕旋转的时候会经过哪些生命周期

请正读-反读 pause-resume stop-start destory-create
+ 在屏幕旋转的时候，Activity 会先调用 onSaveInstanceState() 保存状态，然后接着走生命周期的 onPause()、onStop()、onDestroy()，接着创建一个新的 Activity，最后调用 onRestoreInstanceState() 恢复状态。

- 如何计算一个图片会占用多少内存

nByte=w*h*单像素bit/8
+ 计算图片占用的内存可以使用以下公式：图片占用的内存 = 宽度 x 高度 x 每个像素占用的字节数。其中，每个像素占用的字节数跟图片的格式有关，如 ARGB_8888 格式的图片每个像素占用 4 个字节。可以使用 BitmapFactory.Options 对象的 inJustDecodeBounds 属性计算图片的宽度和高度。

- 项目中用过哪些第三方库，能否分别给出介绍

没有，安卓生态冗得像罚抄

jueju:刚开始，我们有个功能
say(1+1, end="\n")

^汇编(带数值类型,参数宏)

创建变量
-- pressF2(x)
say(x, end="\n")
明确类型
- sayNum(x:Int)
say(x, end="\n")

用类型里词汇去思考，乃至组合
- sayNum(x:Int)
(x!=0):
say(x)
at opts=[1 2 3]
opts:
(this==x): say("small")

- as(ln:You<Ln<Int>>, :Fun1<Int>)
at now: i 0; N ln.n
N!=0:
fn(ln[i]); loop(i!=N, i=i+1)

type 'T'Ln
at n: Cnt
- get(:Idx)T

^结构化(带list,GC,方法封装)

但是，如何复用at变量？先复用函数吧

- sayNum(x:Int)
say(x)
[1 2 3]{this==x}: say("small")
^now
- 'T'Ln as(:Test, :Fn0)
this:[x] test(x): fn()

然后把私下的^now 简化并公开！
data- SayNum(at, x:Int) Filters
say(x)
[1 2 3].only: say("small")
^now
- 'T'Ln only(do:Fn0)
this:[it] (it==x): do()

增加一点细节，为调用侧。
type 'T'Filters
- Ln only(do:Fn0)@ourpkg impl??

- main=SayNumFilters(0)|: “！读作 to:”
this()
x=3; this()

^面向对象(仅接口多态)

又或者，你的需求太简单，懒得去继承框架呢？
- main
“demo, list filters”
ask(at now Int: num)
at onlyIf=Test{it==num} “覆写”
num:[x] TODO"sayNum"

酷酷地可变量、伪递归
-- Var<Int>++=this|: v=v+1
-- ++(:Var<Int>)=as: v=v+1; v

- noop'ab'(:Int,b=0)=as:
loop(a!=0, a-1,b+1)
b

^函数式(非纯)

类型可以随意扩展
- SayNum odds(max=100)
(0~max by 2):[x]
this.x=x; this()

物类的类型，是一个单例'T'(T Type)。单例自己就是类型，就像 pkg 命名空间
data 'AB'Pair(A:A,B:B)
^named T
at mjs=Pair("Michael","Jackson")

--'AB' A`|`(:B)=Pair(A,B)
at Pair.T.jsm="Jasmine"|"Flower"

T提供了值域，而 T.Def==(name,[T0],{}) 反射其定义域。如果继承自Send，就能让序列化/注入器看到 T.cols,T.conds
- main=Pair: ([mjs jsm]):[A|B]
say("name:${A} family:${B}")

^面向对象

有数据的单例，要保存Enum,Is 等接口，就像Data
when- as
Pair(A:A,B:B)
when- Color
R;G;B
Bad
- Str=error("")

也可以模式匹配
when- 'AB'Way3
A(:A); B(:B); NO

接口随便扩充
- Int8|Int4=this.Int
data- Str|Sorts
^now
at sort=Fn1: it[0]

-'N'(N Num) Half=N.Rn: (A+B)/2.
type 'this'Num
^named T() .Const
type 'this'Const
at Rn:Rn<this>

^定义式编程(ADT)

#kt #FP #PLT duangsuse, [2023/9/27 15:56]
还是H5 <meta name="viewport" 好，就只有基于dpr的 px vw wh, 然后 sp=rem, @media(device-pixel-ratio:1)
不会因为放大到200% 就蹦出一个更新的单位。SVG里都一样

一个毫无意义的区别，让设计师拿来作为特色竞争力，妙呀

duangsuse, [2023/9/27 15:59]
你可以自己常量外提啊，JVM应该会优化

duangsuse, [2023/9/27 16:00]
不要管性能， 能被AI转写的那都是虚的，主要是好写耐看

duangsuse, [2023/9/27 16:00]
我也觉得把两个Int放在堆上很弱智…… 应该直接内联成参数，可是这就是 Java

duangsuse, [2023/9/27 16:02]
Kotlin 的 inline class 已经是种typealias了，你想怎么加？ 我看他们不觉得这是问题

duangsuse, [2023/9/27 16:05]
Kt range 对int,long 都有不同的(模板)重载 ，连(Java8 stream 里也有的)去除装箱都没推广到语言层面，你还指望他们考虑这个。 最多就碎片地优化下惯用法

duangsuse, [2023/9/27 16:06]
不过JS里是有 forEach 比for of 快的一个见解。Kt里这也不失为一种统一风格，可惜如果性能有问题……

duangsuse, [2023/9/27 16:08]
你要理解它们，人家可是重造了LLVM的轮子， 是专业的中间优化层 😁

总之不重造轮子，就不算懂计算呗

duangsuse, [2023/9/27 16:10]
性能不会是我选择工具时的考量，但和你们交流时，我也会被带着跑…… 毕竟代码是要跑的，唉

duangsuse, [2023/9/27 16:10]
inline fun 不就是只针对lam的，包括 forEach 可以跳出两层也是因为有优化

duangsuse, [2023/9/27 16:14]
如果不可变，被捕获的外部var 就不必被绑定为Ref()

duangsuse, [2023/9/27 16:15]
真的有人会在用lambda时注意性能吗…… 不都是类似宏的用途，真要 onclick 那种是绝对无法缓存的

duangsuse, [2023/9/27 16:17]
全局的怎么能叫捕获呢…… 外层函数的栈变量，转堆变量，那才叫捕获

Kt 的fn is Any 应该是种误解，这方面反而是Rust.. 每个函数类型独立，要明确

duangsuse, [2023/9/27 16:19]
没想到 crossinline 竟然被Kt做成了特性，而Kt对这个特性什么教程都没有…… 让人摸不着魔法

duangsuse, [2023/9/27 16:21]
就不应该指明，JS 的闭包就是这样。闭包并不是Any，包括也没有toStr

你甚至不能看到调用栈里，受调用click等闭包的捕获变量。只有JS DevTools能看到那些

duangsuse, [2023/9/27 16:27]
我也想啊，比如协程是挂起，那“休眠”就是在退出重进时保留任务栈了，多香啊
一个语言都能实现操作系统了

可惜kt 里Coroutine和回调闭包是不同的

val hibernate = withContext(Dispatchers.IO) {
delay(10_000L); print("")
}

val hB = ByteArrayOutputStream().apply {
ObjectOutputStream(this).use{writeObject(hibernate)}
}.toByteArray()

val data = ByteArrayInputStream(hB).use {
val input = ObjectInputStream(it)
input.readObject() as Continuation<*>
}

// Resume the coroutine
data.resumeWith(Result.success(Unit))

duangsuse, [2023/9/27 16:35]
这个接口其实是 Promise+then时调度器 ，只是不需要yield而直接把自己给delay()，中规中矩。没有写可以序列化
(但其实换调度队列不需要coroCtx, 只有catch要它模拟调用栈+给函数值加名字, 以及让1个fun有两个等待scope..）

如果闭包都不能跨越会话重复调用，Coro就更不可能了

感觉有点可惜，如果可以的话，一门语言就足够支撑起操作系统内核那种复杂的多任务了

duangsuse, [2023/9/27 17:28]
函数序列化还有个好处， 就是若C/S端使用同一份代码（同构），
login(uid,hash) () 可以直接发到另一个全局环境去执行

就是不知道异步seq 是怎么执行的。但至少能用响应式{k:var}来监听

duangsuse, [2023/9/27 22:28]
找到了 ，和Python inspect 一样信息齐全
ObjectOutputStream 是通过这个支持：

(SerializedLambda)  fn.getDeclaredMethod("writeReplace")(fn)  //-readResolve

duangsuse, [2023/9/27 22:27]
对啊，感觉奇奇怪怪的。 我说的是那种两边都有，基于Hash和闭包变量分派的序列化

RPC和RCE真的一字之差啊…… RPC多少还有点接口规范可循吧， 但HTTP,REST,GraphQL 就稍微复杂点了

我说 login(uid,hash) () 可以直接发到另一个全局环境去执行 优点是在语言内部支持RPC，但protobuf这些也是可能的

duangsuse

, [2023/9/28 10:54]
你写了一个 T(x).f(arg): T 的链，并试图标明还未f()的T

你可以把灵感给GPT让它来写

duangsuse, [2023/9/28 10:55]
说到 reduce{A+B} 这类函数，我倒是有个 [0].as(Sum(it, (A,B)=>A+B)) 的封装，用于支持分组过滤

duangsuse, [2023/9/28 10:57]
在没有this的语言里调用链挺好玩的，但java里都有 new ArrayList(){{add(1,2); add(3)}} 这种用法

- add_v1'ab'=a+b
D=add_v1(1,2) “dbg print”

data Adder'ab'(:Int)
  - add()=a+b

say(Adder(1,2).add)

data Adder(list:Ln<Int>)
  - add()=list(Sum).sum

(1~4):
  say(this,Adder(this.Ln).add)

[ALL(1~4)]:
  at val=Adder(this){add}
  say(val())
  add 5; say(val())

type 'T'Gets
  - get()T
type 'this T'Adds
  - add(:T)this

data 'T'CanAdd(at,a:@our T)@impl?? Gets Adds
^now
  - get=a

data I(a:Int)CanAdd()
  - add(b)=a+b
data S(a:Str)CanAdd()
  - add(b)=a.as<Str>+b

data 'T'Adder(list:Ln<CanAdd>)
  ‘测试’ Adder([I(1),I(2)]).add.get
  - add()=(list isEmpty){ CanAdd.None }:
    at now: x list[0]
    1~list.iLast:[i] x=x.add(list[i])
    x

type 'T'CanAddZ CanAdd
  ^named .Consts
  type Consts
    at zero:T
  data I(a:Int) I()CanAddZ
  ^named
    at zero=0

‘TODO’ (CanAddZ: Adder<I>()).get

#java #FP Loney Chou, [2023/10/5 10:50]
只读集合是对 API 作者的极大福音

duangsuse, [2023/10/5 10:47]
如果只读不是在Type期实现的，就会有很大开销。比JS低就是了
只读还会逼你使用map,filter 等写法，对一些程序员可能……太严谨了
可能有人觉得自己用mutable集合，就能做得更快？

duangsuse, [2023/10/5 10:49]
Java 经典的反人类默认值，随地 public final
只能说是Java自身反人类，导致框架难写吧。

duangsuse, [2023/10/5 11:06]
好像是迭代、数组、元组 啥的不好区分

“ 这是整个 API 中最具争议的设计决策。显然，静态（编译时）类型检查是非常可取的，但实现此目标的尝试会导致接口层次结构的大小爆炸
Doug Lea 编写了一个流行的 Java 集合包，该包确实反映了其接口层次结构中的可变性区别，但根据用户对其集合包的体验。用他的话说（来自私人信件）“我很痛苦地说，强静态类型对于 Java 中的集合接口不起作用。”

duangsuse, [2023/10/5 11:07]
Java就是太智障了，你看 Py,Kt 对可变性的实现不就很正常，哪里有那么多特例？

典型的过度工程大佬，已经要被能随意跨界的JS,Py等语言抛在后面了 ，现在又跟不上明确化类型的新语言
Ruby的元类链都没 MutableXX 那么复杂，Java还觉得不行

学了几句算法觉得自己牛了， 但其实那是可以随便替换的，连接口的不标准都有先人犯过

list instanceof Sorted
OOP的正常typetag 组合不会用，反射却挺擅长（
Java当时也就是给数组加个bounds，给指针保存上type ，实在是没必要强到runtime去做Obj.freeze 这么弱的检查

duangsuse, [2023/10/5 11:13]
这就是算法和API的区别啊。运行时凭什么决定设计和编译期的概念呢
编程里就没有一个「有实用价值」的东西是计算机先有，然后设计师才拿出来用的

肯定不能让Java、VB这种垃圾语言，干扰你的思路的

duangsuse, [2023/10/5 11:14]
runtime check 都是外语，FFI 要考虑的事情了……你可以把FFI跨语言的情况，都理解为明确使用了 as cast

你都已经脱离Kotlin编译器了，还想继续使用各种语言和检查特性……(这跟说 private 也不是 private 一样
List和 MList<out T> 都会限制set()的…… (只不过MList不限制reverse)

duangsuse, [2023/10/5 11:38]
你不能说单靠一个类型，去把 list 当作Tuple来用。
单单结构不可变的称为 Array ， 但现在大多数人只会用list 。还是Py的正确，tuple正好能对应上dataclass ，有用法的依据

你说的那种，是纯函数的不可变吧…… 不是类型上

意义真的不大， 无非是把堆里的变量放栈上改写，或者栈变量换伪递归， 那有什么用…… 又麻烦又慢 😓

变量关系式编程(LP)里， 函数式的 Memo f()=x+1 可以直接表达为 f(out y,x) 的细粒度重计算，不仅不存在“赋值”，也不需要那些纯函数的过度检查

一些人觉得 React是什么FRP，functional响应式 。但其实把可变数据，理解为含Var的不可变， 比纠结于List纯不纯好玩的多


类型姑且还是对心智模型的硬化， 纯度这些可都是虚无缥缈的风格格调了。有趣的软件未必靠FP来写。某些函数式lib的样板代码不比rs,go的少 ，代码质量只能是看人，是否憎恨冗余

#china duangsuse, [2023/10/5 22:21]
小丑政客=客人
伟大的政治家=主人

列宁所在国家的体制，都可以算「列宁活着时是国家」了……

Neomonk Zen, [2023/10/5 22:39]
我觉得所谓疫情，也许就是为了消解资本主义过剩产能的手段
地产更是产能过剩呀
我倒是不希望跟美帝搞妥协，那样大陆P民的日子肯定会越来越难受

duangsuse, [2023/10/5 22:42]
《你的VPN有点太城市化了》
从理智就可以得出共存是必然的呗， 病毒清零你 🦄呢

duangsuse, [2023/10/5 22:44]
是啊，这不就暴雷了么？ 这下左了。
！！！ 有意思，美的妨碍华为Mate60 遥遥领先了是吧

duangsuse, [2023/10/5 23:00]
产能什么时候成负担了？？ 多生孩子也都是赔钱货，白吃不干是吧？
怎么又是资本家，又是波士顿清茶的， 不方便资本家赚数字币？

你以为是为了涨价，实际上：
目标 为了抗议英国议会对茶叶征税， "无代表不纳税"。


而且中国农民的水果，运/卖不出去也会喂猪的，这根本无关资本共产

哦，共产主义者只有国家计划，恩赐的白米可以吃，没有季节时蔬啊？ 那算了

duangsuse, [2023/10/5 23:07]
国家的农奴，一辈子被拴在地里，想当「盲流」都不行； 更别提走向更高生产力的职业比率了。

改革开放，可惜「反对资本主义自由化」（

戴着枷锁跳舞的中国普通人和「民族资本家

duangsuse, [2023/10/5 23:09]
不倒，运费你出
经典社会主义的税收，都是免费的， 政府来做是不用花钱的。 左派的政府是个万金油、永动机， 一丝不取😅奉献无穷

而且美国是有 food bank 的，日本我不知道

这些基础设施都不是制度的问题， 只要道德不滑坡……
要是中国的法制没有出问题， 文革时期的老人也还敢讹人吗？ 所以法律不仅仅是道德的底线，而不能反映民意的法就是恶法。

#kt duangsuse, [2023/10/5 21:59]
xx is Any? 一般是可以常量计算的
子类多态的当然不行，inline reified 可以

不是啊，编译期 instanceof 除了TS那种infer解构的，还有啥用呢？x:Int声明不就是用来x=1, Int.canBe(1/Int) 验证的

而且类型constexpr也是对 swi-prolog.org 的混乱模仿

Java支持泛型extends成员交，但我是说 Sorted集合 本身不暴露任何接口，它就是Serializable那样的tag啊

上文：
>SortedSet NavigatableMap，都是实现，不是 API 应该关心的东西
还是不行的，要支持SortedXxx
>list isinstance Sorted
这是运行时决定的，不行
>但运行时凭什么决定设计和编译期的概念呢
哦，你是说把 instanceOf 做到编译时，等等我想起了 TypeScript···

duangsuse, [2023/10/5 22:06]
弄错了，Sorted集合会暴露 ceil()floor() 等只读方法，不是只is一下,还要as

……那你就理解为 S extends Sorted<PairKV/E>&Set 那种泛型吧(这也实现了外部继承)
总之我是觉得 java.util 现在过于复杂了，怎么可能连只读接口都不支持？C#,Kt都有的吧

duangsuse, [2023/10/5 22:15]
https://discuss.kotlinlang.org/t/extension-types-for-kotlin/1390
唉，CLR和Kt(内部地) 都支持用代码复制来调用 int[], IntStream, Array.copy 这种类型或函数

要扩展既定class，Java的交集泛型会擦除，感觉还是不如用 Interface by delegate 。 就连Kotlin都没有优雅解决泛型问题

所谓组合优于继承还真是……

我觉得直接把stdlib 生成IntArray的方法规范化出来就挺好，算是解决了各种泛型开销的问题

Loney Chou, [2023/10/6 00:09]
接口代理不代理所有方法真的有点不符合预期
我相信绝大多数人用接口代理都是为了把代理有定义（覆写）的行为都交给代理，而不是只有抽象成员
https://youtrack.jetbrains.com/issue/KT-55080

isekiのChannel, [2023/10/6 00:33]
话说 Kotlin 为什么不允许 int -> short 的隐式转换来着？有些时候确实挺麻烦的

cubesugarcheese, [2023/10/6 01:07]
kt很不喜欢隐式转换
之前有个扩展实现接口的提案因为没办法避免隐式转换被毙掉了
我更喜欢长程推断
比如

val a = 1 // 这里确定a为整型 Int还是Long需要后续分析
fun foo(num: Long) {}
foo(a) //确定a为Long类型

duangsuse, [2023/10/6 10:59]
这下常量值有?那样的类型标记了

Loney Chou, [2023/10/6 01:22]
扩展接口...感觉会跟现在的扩展的设计（基于函数或属性而非结构）大相径庭。
如果当成独立的类型来调用实现的扩展函数，那就没任何问题
如果被上转为接口类型，就会被包装

duangsuse, [2023/10/6 11:04]
这下Ruby了
当初设置fun T. 时就应该加在 inline class 和隐转的体系里 ，三个愿望扩展、外部接口、隐式宽化 一次满足 ，还附送ts式的用调用的成员推导类型


Jason5Lee, [2023/10/6 21:29]
Integer.equals(Long) 是 false

duangsuse, [2023/10/6 11:27]
可是本来就应该统一到Long来eq吧
总结：
1.模板<reified T> doAdd(a: T, b: T) = a.add(b)
2.To make those explicit adapters less wordy, we could first implement KT-505 136 (delegating by signature), and second — provide some syntax to be able to write Monoid(stringValue) instead of object : Monoid by stringValue {}

😅真的，设计模式先于语法 builder和set链是优秀的了👍

duangsuse, [2023/10/6 22:36]
不过Kt有一大堆 Int.plus(:Long):Long 的重载，就像 to[Typed:Int]Array,IntRange 一样有一大堆，靠重载来隐转可真是太「不隐晦」了。 让我的领结旋转

乍一看是Java风格,operator fun 的无奈之举，但其实就是「过度限制」。 以为不需要C#那种自定义隐转 ，结果进一步导致 inline class 等等“新”特性

— #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)] 的数据结构，我看提需求的人也没重视性能……