#learn #ts #kt 子类型 vs 组合, in/out参数
https://t.me/dsuses/5194

总之，trait类型的交集 还是需要in/out，这不是子类型带来的麻烦。
a=append(a,x) 与 copy(a,src) 类型上是一样的，前者也并不能“把a修正为更窄接口”。 Go必须把list+=单项 写出来, 因为缺少型变

func main() {
var src []interface{} = []any{1, 2, 3, 4, 5}
var dst []int = make([]int, len(src))
copy(src,dst) //错:没有共同接口

func copy[T any](dst []T, src []T) {
for i := range dst {
dst[i] = src[i]
}
}

更多关于 #rust #go #plt 的原理
https://t.me/kotlin_cn/74484

https://rustmagazine.github.io/rust_magazine_2021/chapter_4/ant_trait.html#向上转型upcast #recommend

https://rustmagazine.github.io/rust_magazine_2021/chapter_10/lisp-in-rust.html

举例， #ts 上有”交并集类型“ （有人认为 hs, Rust 没有子类型所以不存在集合论的，确实如此但 in-out 形变是Racket子语言里也有的,我找不到原文但TRack 是有）
(我一点也不羡慕没有重载和this模块等多态技术的圆括号 😅, 模型的缺失是拿宏手动兼容 a.b.c 所弥补不了的, 就像 F# 的 |> 比不上 xx.let{}, kt 的元组 destruct 比不上 ES6 let[x,y]=P, ES6的解构又不如 Prolog 的 unify [x,1]=[2,y]...

观摩王垠《别再欺负我们读书少》:
- int -> int | bool ->bool 表示的确实是一个intersection type(^)，而不是union type(|)
- id(itself) “同时”是int->int和bool->bool，而不是表示它“有时”是int->int，而另外的时候是bool->bool。
- 所以，id(1)一定是int。如果你输入id(True)，它推导出的一定是bool。
- 否则，调用id(1)会报错，因为id的类型有可能是bool->bool，不能接受int的输入。调用id(True)也会报错，左右不是人。


但我习惯拿 成员交=union ，成员并=insect ，绝口不提“同时”“有时” 这种抽象说法乃至术语
- int -> int | bool ->bool 表示的确实是一个重载，而不是Either
- id “必须”是int->int, bool->bool ，而不是“可为” int->int | bool->bool。 when(x) { is Int, is Str } 这种情况才是“x可为二者”
- 否则，调用id(1),id(True)都会报错，因为id的类型有可能是bool->bool，不能接受int的输入，或者反之。

严谨性绝对是次于创造力的，况且，含糊的说法对同时使用和实现不利。
虽然这些都是小小的细节，但每个细节都注重可读性，随着设计的步进，最终会形成巨大的差异。即便都是用AI，我的实现也会有很多不同

#sql #ts Prolog 牛逼！ 正确的关系式搜索+ 同时实现 parse 和 toStr 😱

#zhihu 灵感来源

e(E) -->{E = [I,Ea,Eb]}, %重写规则, 'eX'为优先级

%利用 链|e1(E) 括住内"*/"
e1(Ea), op(I,"+-"), e(Eb); e1(E).
e1(E) -->{E = [I,Ea,Eb]},
e2(Ea), op(I," */"), e1(Eb); e2(E).

e2(X) --> number(X); ("(", e(X), ")"), !. % 单项值/字面
op(I,W) --> [C], { nth0(I0,W,C),nth0(I0,"加减乘除",I) }.

5行就能实现一个str”模板“，写法相对匮乏但功能丰富，吊打 Haskell 的 TextCombinator 🥺

❤️ https://eu.swi-prolog.org/pldoc/man?section=basics
这里还有个Lisp实现

#ts #csharp 😱C++化，来临力 https://zhuanlan.zhihu.com/p/648312212

#py langchain 支持了 pipe

# fib.only{%2==0}.firsts{<40_00000}.Sum 
sum(fib() | where(lambda x: x % 2 == 0) | take_while(lambda x: x < 4000000))

比如(我的天啊， Javaer 怎么入侵 Python 了！我以为AIGC潮能打醒它们的，没想到恰恰相反？ 😱
os.environ['OPENAI_API_KEY'] = ''

from langchain.prompts import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
)
from langchain.schema import (
HumanMessage, output_parser as OutP
)
from langchain.chains import LLMChain

prompt = ChatPromptTemplate.from_messages([
HumanMessagePromptTemplate.from_template("Show me the HEX code of color {color_name}")
])

(prompt|ChatOpenAI()|StrOutputParser() ).invoke({"color_name": "RED"})

另外，基于代码解释器， model.bind(fns )|JsonOutputFunctionsParser 可以让AI调用一段描述文档，并获取返回值

#huawei #js #ts 最近很火的 ArkUI 跨平台版 (UI语言doc )
商店示例：
https://gitee.com/arkui-x/samples/blob/master/Shopping/entry/src/main/ets/model/homeModel.ets

ArkTS和Java没有相互调用的能力，需要ArkTS与C++交互，C++再与Java交互（剪贴板、文件,.），反之亦然。
看起来和方舟无关，也不需要Dart那样的虚拟机或 jvm ，基于 Node-API 但自己做绘制? 还是自己又弄了DOM?

但是 puerts (js,lua) 可以.. 虽然都不如 import cffi 直接解析.h头文件 强 😅

好像也没有很火，在文件名都需要审核的 Gitee 上以 Apache2 开源，想必也没什么正经人看.. 😓

btw. 人家还讲了 状态注入, MVVM

反正我只认同 type UI=({dataVars})=>HTMLvar

#py 周刊

#ts Mypy: 1.5
Mypy 是 Python 的静态类型检查工具，1.5 版本主要功能有： @overrride 、更灵活的 TypedDict(字面创建的 dataclass) 创建和更新、可显示错误代码的文档、改进了泛型函数的类型推断、__slots__ 的优化、步进 Python 3.12

#ai 整理和预处理pdf文件，让GPT访问

from bot import Retriever, llm_reply

#backend 用 numpy, 线程池 优化数学区间求和函数

- 杀死 ProcessPoolExecutor
Python 自身不适合处理 CPU 密集型任务，文章中项目原本使用进程池来规避 GIL 问题，后使用线程、C++ 扩展，内存使用量减少 50%，CPU 使用量减少约 20%

- 观点: Py 不适合编写100行以上的软件，因为弱类型、重构难和性能

from contextlib import suppress
with suppress(FileNotFoundError):

的妙用

- 上下文管理器

from tenacity import Retrying, stop_after_attempt #AbortSignal
for attempt in Retrying(3):
  with attempt

:

骗你的。Java式接口让人难以评价：

for i in Retrying(stop=stop_after_attempt(3)):
  with i:
    print(f"🧨炸弹{'真的'*i.retry_state.attempt_number} 要炸了！")
    try: time.sleep(2)  # 按Ctrl+C !
    except:pass
    else: raise Exception("💥！")

#visualize #plt LibCST: 遍历Python3代码树
btw. 你可以用 %%showast 和 astor 查看算式的树状图和代码形式
- viztracer 提供了 DevTools profile 页

#datas 绘制多个直方图、折线图表
- #tex 对比"星星旗帜"的海龟画图 Python 来学习 PostScript
PostScript 广泛用于打印机、出版和图形设备。文章将可被 convert -page 720x480 flag.ps flag.png 的程序，直译成对接到 matplotlib 的 Python 代码


#java 如何编写简单的C模块，篡改 CPython 解释器的数字
导入一个模块后，如何让 print(8) 会打印出 9？只需要拿到整数对象池，交换两个大整数引用的值

swap( (PyLongObject*)PyLong_FromLong(8)->ob_digit[0] , (9)  )

#os #linux 在 execvp(["python3", “Hello World.py”]) 时，会发生什么？
在 py 文件中写上一句，执行这个文件，幕后都发生了什么呢？文章使用了 readelf 、strace 、ldd 、debugfs 、/proc 、ltrace 、dd 和 stat 等工具，详细解释了脚本被执行的过程。
主要涉及操作系统,GNU libc 相关的内容
推荐阅读

—
#js htmx: 强化的 form table dialog，交互式界面扩展

<form hx-put="/contact/1" hx-target="this" hx-swap="outerHTML">

#php 🤯 Slack: 我们认真觉得PHP好用

#js #design 那我也不算讨厌 Vue （虽没有React那样奇怪, 但毕竟XML是不可触碰之物）， 我来黑一下 Vue yyx 对一个“不知天高地厚”的年轻朋友的反黑

如何评价前端框架Yox？ - 尤雨溪的回答 - 知乎
<template v-if="name">
你好，{{ name }}
..v-else
请登录
</template>

{{ name ? `你好, ${name}` : `请登录` }}

单举这个例子，有点鸡贼，但对EQ刚刚好，因为它的数据模型继承自我打草稿的半OOP语言，可谓高射炮打蚊子

p(
  when(name, {$Y: html`你好 ${name}`, $N: `请登录` })
)
p(
  wKV({ if: name }), html`你好 ${name}`
)

<div :id="id" :class="class || 'default'">

另外EQ还支持 div$css 的 _mix，即类的继承；如果说id是动态的，用wKV(ES6)就更方便了

div__id(wSty`${class||'default'}`)
$navbar(wKV({id,class}))

ee.main=({todos=[], tag='good'})=>lets(
  todos(a=> a.only({tag}) ),
  //EQ不需要靠编译和'signal'得出 todos,tag 变更时要做什么，我们不和DOM抢地盘
  x=>$todo()
)

省下的行数可以拿来设计几个颜色主题啊 😄
- 怼黑子有什么用，不如多写几个单页玩玩， 招牌是干嘛的？不如把代码放首页，提升一下Web圈的创作欲
- 我就要怼天怼地，尤其是对我设计有明显启发性的老东西， 任何的僵化都不能放过，你留着它过年，重构甚至跟风都是一定会炸的，功能越加越难用，还妨碍别人按时睡觉
- 别人的成熟设计，里面的取舍一定是受领域的刻板印象窄化过的，也是被 CRUD20年的市场 Boys 虚荣地夸过的， 所以我只从最终用户的角度看框架 ，编程领域 我不关心，我圈外，靠内心的语言思考问题就够了。
(e.g. 我可以把Vue3 的ref 等 anti-feature 都解读成和 #ts 等额外特性有关，但为了类型损害程序表达的可读性，仍然是蠢做法；因为正确的框架，该靠明确性，而非机械正确，实现治未病
- JQ和Svelte都觉得自己“代码少少功能多多”，但不请XML这一尊滚出Web，不善用CSS那睥睨native的先天丽质，思路如诗-ref(),是会被牛得逼成渣的

#py 周刊
- 《优雅不是奢侈品》
- nogil 最新情报
- #web Django ORM 最佳实践
- Django 自带的JWT 路径验证和登录页
- #ts 阮一峰 入门, 纯JS入门

- #linux #rust Nush: 不是 Powershell
- #js npm依赖图
- #ai #tool realsizer4x 超分辨
- #rust pixi add cowpy 强化pip
- #ui Toga: 跨平台的 TkGUI

- #ml Viberary: 开源书籍检索引擎
- Khan 为何从Py2移植到 kt,go
- #parallel 用asyncio分享查询，防止缓存失效时并发卡爆
- #plt Rust vs Idris,Zig: 渐强类型的解药 #1

单进程 cron：

from apscheduler.schedulers.background import BackgroundScheduler

cron = BackgroundScheduler(jobstores=sqlite)
.add_job(print, 'interval', seconds=5)
.start()

并行 multiprocessing: #2

with mpire.WorkerPool(n_jobs=5) as pool:
    results = pool.map(getFiles, range(10), progress_bar=True)

- 修改语法ASDL，实现 map( (x)=>x*x, [1]) [Parser/Python.asdl] [30行实现]
- 奇怪的for赋值， 魔术方法
from xx import* 的明确化：设置好 xx.__all__ = [exports]

实现 lazy load:

importlib.import_module

⭐️import pyforest 自动导入np,pd 等变量
#code 修改语法 __import__('cv2') -

from lazy import cv2

import types,sys

class lazy(types.ModuleType):
  def __getattr__(self, mod):
    import importlib.util as _
    if None==(r:=sys.modules.get(mod)): 
        id = _.find_spec(mod)
        # get it inserted into sys.modules.
        _.LazyLoader(id.loader).exec_module(r:=_.module_from_spec(id))
    return r

sys.modules['lazy']=lazy('-L imports')

— 仅供学习，import 语句本可以是局部。 (GPT怎么变蠢了
#ts
#1为什么静态类型的C,Go,C++ 不是弱检查 就是太复杂

代码练习： 不需要 type WTF<> = 就可以检查 htmlTag, funcPipe, nthArg, printf("\d") 等调用的类型

int[10] 的实质、 #Kt 类型推导的原理

#book #ts The Little Typer
1. 类型签名是命题，程序的语意是用+,[],. 构造int,void.
2. 命题的条件和自身，都是值；依赖类型可以把值放到类型(int[2],. )中去，从而构造关于值的命题。
3.Prolog 缺少抽象 refl_ID(X,X). 的模式，它的条件表都是全局给定，不能构造类型
4. 类型也可以有类型， #haskell HigherKind *->*, TypeFamilies 就是指这个（虽然和 #ts 一样过度设计

从结果上看，反而像 类型签名是证明，类型构造器是调用命题……

data Equal : a -> b -> Type where
     Refl : Equal x x
fiveIsFive : 5 = 5
fiveIsFive = Refl = Equal 5 5

如果我换个语序，会更合理。
data'ab' _=_
- x=x Refl() 成立
- five() 5=5 Refl
这样，类型依然是命题，程序依然用Refl证明并构造了Equal，而且删掉了查重率60%的冗余语法
Refl : 右是一段程序。用这种隐晦的方法传变量是错误的。这个语法的问题远不止「类型含糊」， 对语序的修改，只算一种局部的优化。

为什么用 (

Refl : Equal

) 呢：它的亲戚，逻辑式语言都连「调用树」都不会组织，反而觉得 add-out(1,2,3) 更好看，加个类型学了“调用”，语序却远输OOP，真可谓一盘散沙

https://ksqsf.moe/posts/2019-02-18-dt-fun.html
https://mxm.ink/dependent-type/#依赖于类型的类型：list
https://agda-zh.github.io/PLFA-zh/Induction/#第一个证明结合律

https://www.idris-lang.org/pages/example.html

-- showOrRev(isInt, x) when isInt:
  $Y: x.Str ; $N: x.flipLR

因为是宏，当然就不需要类型作为值了。内联后直接推导就知道

-- printf(:Str, :[Arg Str])
直接在编译期生成loop，也不需要什么ts体操+js强转了

when--'T' Link
Nil; Add(:T, :Link)

-'T' Link`+`(y:Link) when this:
Nil: y ; Add(x0,x): Add(x0, x+y)

-- useInline 可以直接计算Link拼接或解构后的值，避免手动分期求值

#java #ts https://www.zhihu.com/question/659506359/answer/3538805082?utm_id=0
看到“高级编程语言”的数据结构我就捉急呀。

类型就是表格。纵行是其变种，横列是其数据， obj :. A(x):; B(x) 手动模拟if isinstance多态性
表格可以相互混入，传参时只要有覆盖该表就能调用
若无构造器，默认定义为纯模板 fn?? ，亦可含fn?项
否则表格默认全员锁定!fn，相当于struct。 写明的fn用于扩充既有类型或seal接口
- f(x.[Int Str may2]) Col2(1 2).A
?? 'AB'Row fn
Col2(A.A B.B)
?? 'AB'may2
A(x.A); B(x.B)

这不轻松把OOP interface abstract open final enum ADT match 给讲明白了，顺便消除了“代数”数据与子类型的鸿沟，易读和扩展性全都要。本身就是小学生都能搞懂的把戏嘛，真是啰啰嗦嗦一大堆啊

什么积类型和类型，你是Prolog？ 给你俩Byte你能穷举出256**2个值，那才叫 prod type！ 然而自称支持这些的，你的 patten match 等号两边能反过来写吗？
moonbit和仓颉，主流语言的那些小九九一个也没落下。 您是为计算机系开心写代码，还是为使用者开心而写？

再比如Go的 struct mixin。OOP的inner class本意也是一样，可惜被执行坏了，结果反而不如FP的tuple拼接

其实哪有什么构造器呢？拿函数签名生成的新类型吧。不过就是你们在模仿gpt该做的烂活，或者请IDE“代码生成”。。明明语言从语法API就必须解决掉的东西

如果从更大的复用性来看“class”，90% 的情况都是把重复的args打包起来，避免传一大堆参、允许部分修改，比如那寥寥无几的 open fun，“函数值参数”

因此py即便不爱用class也不瓶颈到工程的规模、Go早期干脆不做泛型。捆绑几个参数嘛，dict更好做

至于协程(N:M线程)，await和yield(then vs next)其实是一个东西，但前者更合理，因为它只是把回调交出去，然后自己return
yield看似符合直觉，但缺少了重要的东西，例如buffer N项一页yield 大家都不支持。我们真的缺语言级iter吗？
spawn{}隐藏了调度级的“异步”，线程随便开，这很好

cj的过程宏，目前 import std.ast.* 后可以parse FuncDecl 啥的，也有quote()内插，还算比rust易用

我们程序员的奇技淫巧很超前，我们的软件工艺落后太远。

btw. 官方文档注 https://zhuanlan.zhihu.com/p/704858976?utm_id=0
https://www.zhihu.com/question/523049017/answer/3537896490?utm_id=0

https://www.fxzhihu.com/question/528403706/answer/73201328199 #ts

再见了，丑陋的类型体操
通过在JS上使用eval留字面的二段求值，任何这样支持反射的语言，都可以有编译期的预处理器，和# define一样简单
再也不需要理解类型了，解释即编译

Inc=F.QUINE((quote,x)=>(quote`${{x}}+=${1};`, x))
acc=2; dd=Inc[acc]
//dd=Inc.scop(s=>eval(s)).MEMO1(acc)
//dd=((x)=>{x+=1; return 3 })(acc)

//展开结果
acc=2; dd=3

#AI #statement
我发现 R1-32B 和 claude.ai/Sonet 202406 完全不能帮我完成框架设计😡

目前看来，它们的独立作业能力， 甚至比 docs by example 略低，但是对单一科班任务，尤其是游戏开发、全栈模板、UIUX 等全凭信息差任务，依然能很便利的完成，

尤其是在选型阶段能demo出很多有用的可拼接snippet，但需求稍微有点大化（比iOS脚本复杂点的那种） 就丢三落四，给你巨大的甲方压力，

很多程序员并不喜欢为这样的小问题反复修改chat上文的。当然，对于框架设计，自己自顶向下找出功能难点test好，再问ai代码裁缝，也是一种高效的用法。

>请用fetch 基于 toncenter, blocksout API 实现 getRecentTx(addr,n=10) 检测并查询此区块链地址的USDT出账，示例输出[{to,v:1400}, {to,v:200}] 为 $14,$2 的转账
>请支持 usdc协议，按时间顺序拼接在结果上

R1输出了莫名其妙的http API，也无力修正TON需要?lt 的时间戳参数
Claude甚至完全忽视了我兼容两种API的功能点（当然问题2 它完成的还可以）
它们似乎看不懂示例的1400=$14， 而如果我是看API返回值照猫画虎，那我怎么不自己写呢？ 更别说还有 $USDT 和CNY等汇率换算的「简单」代码、缓存问题等等

如果只是这样的话，我还要进一步接入需要油猴插件来访问的 oklink.com API ，这需要AI无法建议的平台选择指标、接口爬取。 我还谷歌到了 currency-api 这一npm日更免key数据源。可见需求不平常一点，找AI列举就内耗的要死，甚至不如自己搜。

这样，还有一些人觉得「啊，我单凭Claude代工和 AI aided X 课就能拳打阮尤贺，脚踢 Jeff Dean, C#TS之父, Bellard.org 」，天呐，这样你们的创造力怎么发展啊？ 只靠消灭信息差吗？

如果说API是用 chat with swagger.io 能解决的，shell 文件处理的编写也有问题。

>
实现 cpToBy Movies/ ff.toMKV Downloads/*.mp4
相当于
ff.toMKV Downloads/a.mp4 Movies/a

这个也是，除了对sh的双引号问题习惯的很好， 实际上没有营养。 我还要求了js支持的重命名 'noExt(u)+i+"#.mkv"' ，这也实现不了，完全没提到 node -p

实际上稍有常识的同事都会知道，这么参数化是为了兼容 thunar -B ，而不仅仅只能转码某个fileTree(/) ，别说设计高表达力的API了，它们连按要求完成都要我指指点点，反复协商补充上文，我相信找人外包是不需要解释的，因为格式工厂就™是一个常见需求

再进一步，例如和make一样的编译缓存？文件夹监听？多CPU ？ AI都不会提醒你要加进去。 其实这些前瞻性都是《程序员的自我修养》。
这居然是top1程序员的小帮手，其实它根本不能帮你完成软件架构的策划！

https://t.me/hyi0618/7238?comment=12049 #ts #rust 类型检查

许多学问，只是跨端、跨期之时，对同一种语言结构或「语意」的扭曲。 我甚至觉得比Python晦涩的编程语言不应该存在，因为人人皆可编程，这才是编程语言和IT的本意。

Guido用 @pipe(x) def y: +1 和lambda:的若智语法compose块，但他的哲学刚好弥补了这一部分。

如果你是个高级的元编程研究者， 你的眼中不会有「高级特性」，因为那正是语言设计要消灭的问题。 许多“特性”，只是与App接触不良的“关联性”。

#ruby #ts #plt
https://t.me/hacker_news_zh/17476

其实，JS社区的抱怨和Matz是正确的， static types 并不需要标记，甚至不需要一个幽灵一样复杂的检查器。

#ai探讨 https://x.com/i/grok/share/tvj0HpktTWAGat7NDIBdDoMlG

#plt #ts 《〈Go To语句被认为有害〉被认为有害》（1987年3月）

二维矩阵中查找第一个全为零的行？
有没有一种可能，dijkstra提供了基于tailrec或def子程序的方法，做所谓的 break outer？

PCQ加持过的布尔变量？EWD当年并不认识声明式eDSL和tailrec(return continue vs while c)，这不能怪他。

可是状态变量实在太过丑陋了！这和控制x86的eip没有本质区别，这就像把PEG写成DFA一样，证明不了什么，因为负责证明的是人，结构化和编译器只能是助手。
我推崇的那种“状态变量”是
chkstk=(n, r=0)=>{Loop(n-1,r+1) : n==0; /*so*/ return r}
或者说
f(x, y=0): if(x==0) y else f(x-1,y+1)

f(1)=1

不是EWD那种结构化的编程……

“循环不变量”这几个字本身就像鬼画符一样难猜，前置条件？应该是让人一眼能demo出来边界条件的，不需要EWD要的那种数学去证明。靠爱就能感觉出来。

我的思维本质上是关系式的，反对返回bool，支持BitSet、T? 和Hole（x=y有交换律）
结构化编程的信息量太低了，真正的数学不是表演sinx的磁悬浮，而是把海浪画出来。

他曾想要程序的验证变成一堆01（循环不变量--反正执行也是循环），就像Lean希望assert变成“真理集”，对J规则(LR transport)的丑陋视而不见。

我想要的，是结构性正确，可探索解释，不是while 0和1，不需要 off by one，正确性会广播。


然而你仔细想想，我和HoTT、TLA+ 完全走的不是一个路线。海浪很美，别忘了人才是那个“美学引力”。

EWD的灵魂会支持我的。
没错，验证本身就是像可探索解释那样。因为解释在生命体本身，必然是元循环的。

Goto有用论非常荒谬。RAII和defer甚至只是finally可以轻松干掉错误处理和retearly的问题，宏、crossinline和闭包组合很容易弱化时序流控。

时序是有罪的，它永远不可能和numpy或fffmpeg“滤镜脚本”那样优雅

#ai探讨