//Events, no forwarding indeed
ee.main=()=>html(
  wOp({msg(ev) {ee.say(ev.text)} })
  Inner({})
)
ee.Inner=({it})=>(
  wOp(it.super={msg:1 }),
  btn(sayHello=>{ it.super.msg({text:'morning!'}) })
)

ee.main=({d,time})=>(
  Eq.at([d,time], [1..s.rate], ([t])=>[new Date, t]),
  h1(html`Time is ${d}h24,${[,,,0,2,2]}`)
)

ee.main=({P=N2(0,0)})=>$full(
  N2.ptr(P),
  html`mouse @ ${P.x}y${P.y}`
)
ee.main=({x=0,y=0, k='client'})=>$full(
  wOp({mousemove(ev) { x.v=ev[k.v+'X']; y.v=ev[k.v+'Y'] }  }),
  wOp({tap(){ee.say('Only once') } }, 'once'),
  html`mouse @ ${x}y${y}`
)


api=ee.HI('tutorial/', {
  '*':({text,ok})=> ok? text : Error(text)
})
ee.main=({F5})=>
html(
  button(wOp({tap:F5}), `load Num`),
  Reload({},
    lets({load:[F5,api.random_number]}, x=>html`Rand num is: ${x}`)
)
ee.main=({F5})=>html(
  button(wOp({tap:F5}), `load Num`),
  Reload(
    {load:p(`..Wait`),fail:p(wSty({fg:'red'}), error)},
    lets({async*load() {
      for(;; await F5) yield api.random_number() 
    }},
      x=>html`Rand num is: ${x}`)
  )
)

api=ee.HI('https://jsonplaceholder.typicode.com/', {
  photos(x,{_limit}){}
})
ee.Photos=()=>
html(
  h1(`Photos`),
  grid({of: '5,1fr', gap:8}, wSty`full`,
    lets({load:()=> api.photos(20) },
      ({thumbnailUrl:src, title:alt})=>figure(
        img(wKV({src,alt})), figcaption(alt)
      ))
  )
)

ee.main=({size=42, text='god', L})=>
html(
  sel(size), sel(text),
  p(html`size: ${L.x} h ${L.y}`),
  div(
    wKV({ xy:[0,L, 'absolute!'] }),
    span(wSty({font:{size} }), text)
  )
)

//Form
let active=a=>a.only({done:$N})
ee.main=({
  todos=is.wdoc`
    rewrite Svelte
    build TODO app
    adopt AI
  `.split('\n').lets(x=> ({done:$N, text:x}))
})=>
html(
  h1(`Todos`),
  lets(todos, x=>div(wKV({show:x.done(q=>!q) })
    sel(x.done), sel(x.text, {tip:`Do what?`})
  )),
  p(html`${todos([active,n])} remaining`),
  btn(Add=>{ todos.add({done:$N,text:''}) },  Clear=>{ todos.let(active) ) })
)

ee.main=({pin=''})=>
html(
  h1(wSty({ fg:pin(q=>q? '#333':'#ccc') }),
    pin(x=>x? x.replace(/.(?!$)/g, '•') : 'pls enter' )),
  Keypad({pin}, {submit:alert})
)

ee.Keypad=({pin}, my,
  btr=(tap)=>button(wKV({show:pin(x=>!x)}), wOp({tap}))
)=>
grid({of:'3,5em 4,3em', gap:'.5em'},
  wOp({of: 'button',
    tap(){ pin.v+=this.innerText }
  })
  ...rn(1,9).lets(x=>button(x)),
  btr(()=> pin.v=''),
  button(0),
  btr(my.submit)
)

ee.main=({
  name='',
  ten=rn(0,10),
  a=[1,ten],b=[2,ten],c,
  yes=$N,
  flavors=[['Mint choc chip'], menu],
  scoops=[0, is.w`One Two Three`.lets(x=>x+' scoops')],
  order='',
  text='my **dear** Python'
})=>(
Eq.at(c, {a,b},_=>a+b),
Eq.at(order, {flavors,scoops},_=>
   n(flavors)==0? 'need more!'
  :n(flavors)>scoops? 'more scoops!'
  :html`Ordered ${scoops}scoop$ of ${flavors}`.v
),
html(
  sel(name,{tip:`enter your name`}), p(html`Helo ${name (x=>x||'stranger') }`),
  sel(a, {chk:1}), sel(a),
  sel(b, {chk:1}), sel(b),
  p(html`${a}+${b} = ${c}`),
  sel(yes),
  when(yes,
    {$Y: p(`Good boy!`),
     $N: p(`Bad !! must be checked`) })
  button(wKV({show:yes}), `Get Food`),

  h2(`Size`), sel(scoops) 
  h2(`Flavors`), sel(flavors, {of:'many',chk:1}), // of:'' = select[multiple?]
  order,

  textarea(wKV({value: text}), wSty({width:'100%', height:200 })),
  html(text(marked))
)

)
is.use`marked elizabot.Eliza`
let menu = [
  'Cookies and cream',
  'Mint choc chip',
  'Raspberry ripple'
]

Rn.ptr
await 0..s
String.it({
  swapcase(_) {
    /[a-z]/.test(_)? toUpperCase():toLowerCase()
  }
})

删掉了my参数，允许用 ee.fork 定义私有组件、直接添加原型链扩展。爽了，减少了UI设计的噪音

ee.Demo=({n=0, ptr,P}, fmt=({x,y})=>html`(${x},${y})` )=>
div(
  wOp({ mousemove:ev=>ptr }), N2.ptr(P), ()=>其他初始化绑定,

  btn(n, [html`++ ${n.to(x=>x+1)}time$`])
  , b(wOp({tap:n.to(Eq.num(-1))}), `n--`)
  p(ptr(fmt)),
  li(P(fmt))
)

let localUI=ee.fork
ee.Demo.it({
  __n1:_=> _.n+1,
  n: Eq(x=>x+1)
})

我把文章的 #ts #Rust 代码重写了下

when- as
  Automobile'wheels seats manufacturer'(:Cnt1, manu_:Str)
  
- main
  Automobile(4,4,"X"):
    say("My car has ${wheels} wheels and ${seats} seats, and it was made by ${manufacturer}.")

when- MyCar
  Wheels Seats Manfus

- main
  at car=[4 4 "X"].Ary
  car[MyCar.Seats.id].as<Int>

“没什么语法把名字给编号，和类型对应，但 T() Send 可以实现T,Ln<Any>转换”
-! main
  PairN<Cnt1 Cnt1 Str>([4 4 X]):[[Wheels Seats Manfus]]
    Wheels

pkg @RowAsData
“tag和强转的就不写了，太智障。 
struct True,False 的也算了，编译期计算没必要写成类型匹配”
when- Expr
  Const(:Int)
  Op(:Opk, A:Expr, B:Expr)
  when- Opk
    + - * /

- +(e:Expr) = when e:
  Const(x):x
  Op(k,A,B): (+A to +B):
    when k:
      +: A+B

- main
  at e: Expr = (+, (53), (-, (1), (0) ))
  say(+e)

'AB'(get)when- Either
  A(:A) B(:B)

at xx: Either.A<Int>
xx.as<Either<Int Any?>>

“data Nat = Z | S Nat deriving Eq ”

when- Nat
  Z S(:Nat)
  - +(:Nat) = when nat:
    Z: this
    S(x): S(this)+x
- + 'ab'(:Nat) = when a to b:
  Z to n: n
  S(x) to n: x+S(n)

- main
  at:
    one S(Z)
    three (1~3) (Nat: Sum(Z,S))
  one+three

-! printf(fmt:Str) = Fn1<Arg<Any>>{}.as<Fn>
^now
  -! Fn = Type: “constexpr, TypeFamilies”
    FnN(fmt('\\d'):Int )

动|静|绝句
Array 具名?元组,组 when-as,Ln<Str>
Tree union-和类型 when- HtmlNode
Value 具名?泛型 'T'type Ln, Any
for和递归 类型的归纳 'this'type Num
if和匹配 trait重写 - Str as() Int
签名 trait Fn<R> (编译期计算)
实现 impl Fn forT
调用 T as F<>::Out

#ts #PLT 每次看Py花猫的周刊，都能帮助自己改良设计…… 谈到 typed printf, 又不知绝句类型上什么写法最好了。 这些内容，可以理解为用“声明式“的方法 生成要eval() 的代码

- htmlTag("div", attrs..) 如何查到元素类型，和限制attr{k:v}
- int[10] 的 get(i), +int[5] 如何只在标准库实现
- pipe(num=Eq<Str Int>, aList=Eq<Int Any>) 如何得到 Eq<Str Any>, 或者提供 aList=Fn1:a[it] 的类型信息

绝句不会用上文里 C++,Rust 用的那种编译期模板，甚至比 Nim 的编译期计算走的更远。 -! evalFun(:Arg<*>)=arg[1] 本就是分段求值的

也就是通过监听已知参数上的执行，来推测「变量」的类型， at! kv=[:"a" 1 "b" 2.0] 这些“字典类型”也不需要专门做支持，因为'!'就是编译期内联的意思，只会在与变量同算式 或自身非:Send时，真正保留

这样看， -! printf(fmt:Str, :Arg<*>) = fmt('\\d').Ln:[regexSpan i] arg[i] 是不需要额外标注类型(函数)的，反正用了依赖类型，也只是把函数体 按「变量」而非「值」再复述一遍

高端在哪呢？ 不过是 Box<T>,or:T, Fn1<T R> 的R既能从Box里推导，也能是抽象的<T>被listOf()组装 ，再查个重载。关系式编程并没有很难。
那么 int[10] 可表达为 'T'AryN(N:Cnt,:Ary) ， fn(:AryN<Int>{N=10}), 构造和解构时检查下就好了，功能和纯函数式一样，还避免直接写 check() require()。

一些语言把递归匹配和类型运算符混在一起写 (都用上递归了,还不好做“反向查询”..)，显得类型体操是个又难、又有用的技巧，但各个击破的话，这些强类型的魔法其实是没事找事…… 语言贫瘠造成的逻辑炸弹

但这样有问题，不能给 String.format() 标注类型；如果要的话，要组合出 Type: Fn1(Int, Str) 这种动态泛型 ，我不喜欢这种手动算类型的 ，但如何优化掉呢？？

#design 刚才审核绝句 句级跳转&主语域时，意识到 break continue 这些必须和 if 搭配使用，以及
- 因为使用 (0~9):[i] break i==5 的语法函数化， break n 必须=return^n*2+1^ ，就像 this=you^0
- tailrec 是 at xxx=let: return^0^ any 里的(ret赋值&break) 的平替

fun IntRan.forEach(fn:(Int)->Unit) {
var i=first
do { fn(i);i+=1 } while(i<=last)
}

- Rn<Int>.`|`(:Fn1<Int>)
at now: i A
let:
fn(i)
loop(i+1): i!>B //i<=B

// AI的编程效率高于补齐，阅读速度上还在用 map-forEach, let-apply 这些的话是不够的
((0~9) : +1) == (1~10)
(1~10)|: [x]
say(x-1)

at now: i 0
loop $Y:
breaks i<10
break i==100
say(i)
when i:
5: 这里才允许; break
else{}

太棒了，终于摆脱流控了！
但，正在考虑应该强制带上“跳过 跳出^0^” 以防止在单层循环体滥用

不少人在用 if continue 实现filter，但绝句会歧视过程式编程.. (0~9){>5}: say(this) 是绝句里单项和列表通用的搞法
"a arm bar ada".Sep.firsts{it[0]=='a': if !this{say("End")} } 则关于break

if break 可以视为 while(cond) 的扩充，但考虑CLI程序：
let:
at str=input("> ")
str:
in('(\d+)'):[[d]] say(d.Int+1)
loop(): str!="q"

二层循环（本该用函数跳转）

- Str find(sub:Str) Idx
at N=sub.Cnt
(0~Cnt-N):[i] //N=1,则 i=0~iLast
(0~~N):[iS]
break^0^ this[i+iS]!=sub[iS] //也可以每次iS=i 然后blabla..
return i
return -1

- 文 找(:文) 针
在N=文的计
(0~计-N):[i]
首否(文、i) 去路，回i。
回-1

呃，这个是命题 all， any 的才能提前break

- Ln<Ln<Int>> firstZero
at now: i; j
this:[i a] a:[j x]
break^1^ x==0
say([i j])

应当把鸡肋的流控和过度return，扔进历史的垃圾桶了。 向物理公式看齐，而且没有数学的那些希腊字符，没有 __dunder__，但 +-*/ 都可由用户定义
比Py更激进，只有文件和(主语)函数域，不可以无缘无故加{}号分号

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

'T'data Linked(x:T, xs:Linked?)
-'T' last(a:Linked) = a:
loop(xs): xs!=NO
x

fun move(a,b) = if(a!=0)move(a-1,b+1) else b

data class Linked<T>(val x:T,val xs:Linked<T>?)
fun<T> last(a:Linked<T>) = a.run { if(xs!=NO)last(xs) else x }

#blog 看到易语言还在VB++ 的范式旁徘徊，并且觉得编程语言是种必须特色和备案的「核心技术」… 我想复刻下这2007年文章的口吻：

“绝句.ju”十分钟入门教程
作者：转载必须注明出处

亲爱的朋友，您愿意花十分钟的时间，来了解一门全新的编程语言“绝句.未公开”吗？

#1
只有十分钟，时间紧迫，让我们立刻开始，不多说一句废话（这一句话本身算不算废话？哈哈）。
请去拜读易语言官方提供的《“易语言.飞扬”白皮书》——这本书写的很好，文笔比我强多了！本文大量参考该白皮书。

#2
绝句的大概：
- 物类面向对象，具有名词动词、同名例的概念（忘掉函数式编程吧
- 支持宿主语言的GC（Str Int 都是 Any 指针，能自动优化，轻松多了
- 源代码将被编译为全面西化的语言（当然还是比不上“仓颉”“木兰”了
- 用 data- JVM as 接口 跨平台编译为多个操作系统（微信OS/Homo/郭继承...）的可执行
- 可将源代码压缩为AST类库，以达到代码复用。
- 将会有一个包括“可视化函数设计”的集成开发环境（IDE），其将用js编写

我想有必要再强调一遍：“绝句”跟原来的Kotlin（1.x - 1.4.x）是完全不同的两个编程语言（如果非要找出相同点话，它们都能够用英文编程，作者都不是吴涛）

#3
物 启动类
同名例
- 起点
说("祖国您好！")

juc hello.ju_zh .java

启动类.class 的执行结果是在屏幕上输出：祖国您好！

还记得吗？吴涛教给我们的第一个易语言（旧版）程序不过是一句淡淡的问候而已，哪象“祖国您好！”这样饱含深情？
中国永远不缺少国际🇹🇼主义者，但我们急需的是 民族主义者🇨🇳！

#5
类 游戏
- 猜

- 起点(猜：游戏=猜数字()) @JVM
猜去猜

物 猜数字 私下(内定数字 = 66) 游戏
|- 猜
重复 非(猜数字(“不可”))，。

- 猜数字()@私下 真假
在n=获取数()
说(n、 NL="")
回 判n去较(内定数字)，
首中，说("猜对了，恭喜")；真。
首大，说("太大了")；假。
首小，说("太小了")；假。

- 获取数 @可定 = 听("请猜1-100中的一个数：")去数

物 全自动猜数字 私下(可变_n=1) 猜数字()
|- 获取数 @终定 = n移右

#6
- 类是指接口，公开是一种注解
- 起点 启动 入口 主要 面 可以是文件函数
- 造于 私下(内定数字) 指明构造量
- 循环、如果 换成重复非、若判(表达式)了
- 继承和 Go 一样，写括号后面就好

#7
起点(全自动猜数字()) 自动用线性查找 内定数字
也可以改为 读：函0<数> 参数

#8
友好名称——用类自然语言格式书写程序：

'T'物 `将`(：T) “名记平权”
- 将<文>`写到屏幕` = 说(它)

- 起点
  将123写到屏幕
  100.123，[x]
    (将x)写到屏幕

没想到吧，绝句记法还可以这么用😅
就是照着能解析Typst和bash设计的

三联判断式：

若x存于0~10， “如果(0 <= x <= 10)”
若x存于(0的右~10的左)， “如果(0 < x < 10)”

多自然呀，为什么其它编程语言就是不支持呢？我想所有程序员学数学都早于学编程，（后面的太矫情，怕被喷就不复制了）

不知道 Python 是否后悔同时支持 range(A,B)和A<x<B ，那么在支持UI框架时， A<x<B 是等于两个滑条吗？

双向赋值运算符“<=>”：

在此刻，a 1；b 2
可变去换(a、b)
必，a是2 & b是1 “既然有解构 a,b=b,a 不就好了.. 绝句是有可变引用”

方法多返回值：

''名龄=俩项<文 计>
- 华夏=("中国"到5_000)

华夏()，[名到龄]
名去作<合法名>“require”


  FIXME "揣摩上意，是更喜欢讲中国台湾，还是给台湾打码"
  必"🐭"，"🦆"! 
  FIXME "这不是国产OS吗？ 上面为什么报错？"

/* FIXME(请领导指示): 台独检查的中文翻译 却有搞台独的风险 *///
''合法名=Str{ "台湾"!in this : "但这个没备案的境外苏联app搞台独啊"}

#9
有了Kotlin，为什么还要重新搞“绝句”？

Kt1.4 已经渐趋成熟和Java化，恢复正常的空间已经很小了。

……有哪些本质改进？

完全面向对象、自动垃圾回收、可自行开发类库、纯文本源代码(?)、多文件工程、与C/C++等语言水乳交(?)融。

已经有很多编程语言了，我们还需要一个全新的编程语言吗？

确实，汇编语言诞生时，C语言诞生时，C++诞生时，Pascal诞生时，Java诞生时，C#诞生时，都有人问这类问题

#10
改自全公网唯一剩下的易语言入门
404官方论坛：https://dywt.com.cn/vbs/

pkg
  sys; random:rand
  cmd:Cmd

- main=猜数字().cmdloop
data 猜数字(x=rand(1_000)/10)Cmd
  made now:
    数 0; 最接近 100
    历史 [数 ]()
  - `#$default`(ln)
    ln.Int?{数=this}or: say()
    历史 add 数; on(数)
  - on(num)
    num==x: say(); exit()
    or:
      say("太${(num>x).way("大","小")}了")
      接近了(): say("不过接近咯")
  - 接近了=历史(Sum: abs(x-it)).min:
    Var.swap(最接近,this): return $Y
    $N

静态解析外语的“jvm”函数签名 到 #TS
让GPT3 压行翻译到Prolog ，省掉了等号和infer
但参数是含变量的值，不是单变量，依然看起来很魔法

arg('', []) :- !. %前缀转列表前
arg('i'||'d'|Xs, [number|R]) :- arg(Xs, R). 
arg('s'||'w'|Xs, [string|R]) :- arg(Xs, R).
arg('v'|Xs, ["ArrayBuffer"|R]) :- arg(Xs, R).
arg('b'|Xs, [bigint|R]) :- arg(Xs, R).
arg('p'|Xs, [bigint|R]) :- arg(Xs, R).

% 明明是样板代码，但AI仍然会写错
argF('', []) :- !.
argF('['||part||']'|Xs, [fnT<part>|R]) :- argF(Xs, R).
argF('i'||'d', [number|R]) :- argF(Xs, R).
argF('s'||'w', [string|R]) :- argF(Xs, R).
argF('v'|Xs, ["ArrayBuffer"|R]) :- argF(Xs, R).
argF('b'|Xs, [bigint|R]) :- argF(Xs, R).
argF('p'|Xs, [bigint|R]) :- argF(Xs, R).

resT('i'||'d', number) :- !.
resT('b'||'p', bigint) :- !.
resT('_', void) :- !.

fnT(args, (Xs, number | void)) :- arg(args, Xs).

fnKV(args||'!'||res, Args, R) :- argF(args, Args), resT(res, R).
fnKV(args, Args, void) :- argF(args, Args).

relocated需要{}类型，GPT不会用Prolog查表

duangsuse:
#js #web #Svelte 还没用熟 TypeScript 社区已经开始抛弃了 - 零点CoCo的文章 - 知乎
https://zhuanlan.zhihu.com/p/626237877

看起来他们比我还激进？ （虽然我也是观望，不会为TS专门改设计

我是这么看的，前端也就只有123和abc, [{}] 三个类型

标注太占地方，还不如直接用 {a=0} 或者清晰的名字， EQ 简化了UI部分，让JS函数绑定到一种XML模板，消除了很多人眼障碍
如果编程习惯好的话，没有检查应该不会怎么样

本来以为Svelte这个作者算有两把刷子的，没想到和我的观念相似……

无虚拟 DOM 版 Vue 进行到哪一步了？ - 手撕红黑树的文章 - 知乎
https://zhuanlan.zhihu.com/p/644340806

为什么React一年不发新版了？ - 魔术师卡颂的文章 - 知乎
https://zhuanlan.zhihu.com/p/642766301

（现在AI的智商感觉越来越低了，不知还能不能用来给项目加类型）

JS的常量级类型check是很弱的， 比C好一点

DOM能有什么复杂的API ，都是RPC级别的类型复杂度， TS除了做点{}[] 的类型函数 好像也不需要计算很多

—
#FP 纯函数： 数据皆静止，调用皆惰性：(ok? print : noOp) 的if只是函数, if 必须有 else 。不可以用匹配&重构外的方式计算, 用"单子" "幺元" 结构来做流控
if let 解构，只要”值可以含可变<T>“ 👀，就变成简单的构造器&异常=跳过
可理解为”只能添加(调用) 不能反查“的关系式
子类型接口：
#haskell 使用解耦的 class (Num t) -instance (Num Int) 实现调用按类型，就像 #kt fun T.run(:重载)=按T单分派 ，会比 when-is 好
Visitor 可以把”覆写“隔离成配置对象 map({Int x: x+1, Str:}, 语法树), 连”配置“也是可继承&扩充的

反射：在弱类型里元编程才算直观, Object.values(AnyType) 在 Java就是所谓反射了。
Str的同名例TYPE，包含 f(_隐式this)(arg); _.x; _["x"]=1 的”语法“的实现。 KV<Str Int>.typedArg[0] 同是类型
Str 除了属于Type，还可遍历成员做 toJSON, 0参创建,依赖注入(=按类型.ini) 等接口
@定义() 如果只能生成为传参，就等效于在构造器调用 get("/http") {} 或继承钩子

#ai 也不会用现在的微分编程 #ml 框架
import sklearn.neural_network as ML, numpy as np

XOR = ML.MLPClassifier(
activation='relu' if 'ok' else 'logistic', max_iter=10000, hidden_layer_sizes=(4,2))

csv=np.array([[*x]for x in "000,101,011,110".split(',')])
#csv=np.vectorize(int)(csv)
XOR.fit(X:=csv[:,:2], csv[:,2])
.predict(X) #成功

import torch
import torch.nn as nn
import torch.optim as optim

# 定义 XOR 网络类
class XORNet(nn.Module):
def __init__(self):
super(XORNet, self).__init__()
self.fc1 = nn.Linear(2, 4) # 输入层到隐藏层
self.fc2 = nn.Linear(4, 1) # 隐藏层到输出层
self.activation = nn.Sigmoid() # 隐藏层使用 Sigmoid 激活函数

def forward(self, x):
x = self.fc1(x)
x = self.activation(x)
x = self.fc2(x)
x = self.activation(x)
return x

# 创建 XOR 网络实例
net = XORNet()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.1)

# 输入数据和期望输出
X = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# 训练模型
for epoch in range(1000):
optimizer.zero_grad()
output = net(X)
loss = criterion(output, y)
loss.backward()
optimizer.step()

# 预测
predictions = torch.round(net(X))

# 输出预测结果
print(predictions)

#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

>请实现 2intToLong:

long iLong(int a,b){}, iLongA=0x,iLongB

并解释相对于 int[2], aligned class 的优点

使用数组存在一些劣势：

1. 内存空间：数组需要额外的内存空间来存储数组本身的元信息，如数组长度等。而对齐类只包含实际需要的变量，没有额外的开销。
2. 数据访问：对齐类中的变量在内存中的存储位置是连续的，而数组的元素则是离散存储的。这意味着对齐类中变量的访问效率更高，因为可以通过单次内存访问完成对多个变量的访问操作。
3. 代码简洁性：使用对齐类可以提高代码的可读性和可维护性，因为变量的语义更加明确，避免了数组下标的混淆和错误。

总之，相对于 int[2]，对齐类更加高效

AI没解对，那我补足下

val iLongAB = 0xFFFFFFFFL to 0xFFFFFFFFL.shl(32)
fun iLong(a:Int,b:Int) =a.shl(32).or(b)

val(a,b)=iLongAB and 0xFF



infix fun Pair<Long>.and(i:Long)=Pair(first and i, second and i) 

typealias Eq<A,B>=Pair<(A)->B, (B)->A>
val bitsLong:Eq<Array<Boolean>,Long> = {
  bits.foldIndexed(0L) { i, buf, bit ->
    buf or (if (bit) (1L shl i) else 0L)
  }
} to { buf->
  buildList { (0 until SIZE_BITS).forEach{i-> add(buf and 0x1.shl(i)) }
}

如果你的2层KV(比如Grouping)是转为 Pair<K:Array, V:Array> 的话，在嵌套时也可以用浅先访问实现get(k1,k2)

#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 等等“新”特性

不说 单例,迭代器,策略模式,模板方法模式 这些 #FP/定义式/组合式 里不存在的

Factory, Builder, Inject

lib.job( {k:v, ...defaultsOrOld})
prompt("?", 可选参数)

Kt差点就把这种简洁抄到手了，如果没有 let/also, run/apply 那些新术语的话。如果它真心接受了SAM互转等弱类型优势，而不是不断研发出 fun interface; data object 这些小礼包
never is offen better then RIGHT NOW. 如果设计不好语法的话，一开始就用 when(Any)-is 反而比 sealed 强。

Delegate, 元编程
o1={_user:小明}
new Proxy(o, {get:(o,k)=>o1['_'+k] })

你不需要写出编译器能理解的 class{} 等签名性结构，也不需要用异于Map<Str,Any>的模型理解Object，有数据有想法就够了
当然，缺点就是只能使用 import json,yaml 内置的序列化格式，也不能验证或添加funs，因为没有类型

Adapter, Filter拦截器

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):return n if n < 2 else fib(n-1) + fib(n-2)

当然用反射或模板生成也能做到

Visitor
import ast

class T(ast.NodeTransformer):
def visit_Constant(self, node):
if isinstance(node.value, str) and node.value == "":
return ast.Constant(value="x", kind=None)
return node

ast.unparse(T().visit(ast.parse('""')))

同样，也没有什么接口要codegen , Swagger 也不再那么有用了。 你不觉得静态类型70%的代码，都是替编译器推导 读者都能猜到的信息吗

Observer
这个，在JS里，你看 Vue,React 就知道它们做到什么程度了。 Rx和Flow又是什么程度呢
Object.properties() 虽然很智障，但学Py函数化属性 是利大于弊的

Inject其实要涉及按类型查找等步骤，但在HTML/CSS 里都可以解释为属性继承
Builder可以做动态配置，但这点靠 {[is? k:k1]: v}, {...(is&&{k:val }) } 也能规范

JS的代理类，只能是动态的Proxy<T>,不能是T by val
拦截器对应到JSDOM，就是事件冒泡了

DOM有个 MutationObserver 能监听页面编辑，但无人问津， 更有意义的 ResizeObserver 同样用户寥寥，侧面印证了它不好用

Vue等框架用x=ref(),this.x, useWindowSize() 等API提供更原生的写法，在OOP里恐怕没100行办不到吧

— #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.深遍历 并不难