#fp 👆 #haskell 入门
#ai https://chirper.ai/
Social Network for AI only.
free to register and create some AI Chirpers for yourself.

#learn 对我而言，编程并不是「专业技术」，只是“另一种母语”和创作方式，所以我很讨厌潦草的代码

最近一直在打磨一门自制语言的语法， 获得一个较大的成功，居然是把它的OOP术语移植到英文.. 😅

事量物例类|公私族组内
fun val data named type|same{,0,type,pkg}
储例判同造|既可未终定
\- enum -when -named made|^,impl{?,??,}

之前的版本是

事量物例类 
fun val thing insta class|
储标例况变 
data anote enum case var|!,impl{?,??,}

虽然不够“面向对象”(obj->data) 了，但实在(英语化)好写不少。 我一直很讨厌 Java 那种八股文式，歪七扭八不一致的语言特质，给数据处理和调试带来很大负担

interface Closable

type Closes
  fun close
  -named
    fun all(:Args<Closes>)... 

data Door(name:Str) Closes
  made(:Idx)=made("# $i")
  ^fun close=say("shut $name")

data class Pair<out A, out B>(val A:A, val B:B): Serializable

'AB'(get) - Pair(A:A,B:B) Send

typealias PairOf<T>=Pair<T,T>

'T'PairOf=Pair<T T>

这个就对标 #haskell data=A|B 和 #rust enum Either<A,B> 了

'AB'(get)-when Either
  A(v:A); B(v:B)
  'R'fun way(err:Fn1<A>, ok:Fn1<B>) = when this:
    A:err(v);; B:ok(v)

就体现另一种 #FP 的价值观：定义式先于不可变

绝句计划把 Var,Type, expr.E 都拉入一等公民，虽然我不清楚怎么做但相信有意义（连scala3都没更灵活的 eval fun: inline arg 还不够全）
总之，OOP 的public-private constructor 麻烦真的很大，
我又不认为 Rust,Go 那样把一切打散和到处pub fn, 冗长化 type Item=int32 就算“优于继承” — py也有自己独占的一亩地, 但它足够 "server side" 吗？
对于视频内代码的重写：

事 阶乘(n:数) 数
  变数，a 1。
  (1~n)，[i] a=「它*i」 。

fun Ary<Int> contains(it:Int) Bool
  this:[x]
    if x==it: return $Y
  return $N

或者更函数式(reduce 和 findIndex)

'N'fun N`!`=(1~this).Sum{*}

'T'fun Seq any(:Test<T>) = this(Sum.from($N): or test(it) )
= first { test(it) }?.i !=NO

(不得不说，绝句的变动太快了.. forEach和尖括号类型都能被删没 (我对那个 对何forall<AB> 的还执着了好久,因为很"函数式"😭 ) , 这两天对于‘带代码’行注释 和事/物 内量的区别对待、C++式iter与可变<T>的统一、 #Kotlin require check 之类“特技”的归一化 也很难抉择 ，所有简写竟都是全新的，而且都能涉及到编译期API)

唯一能确定的是， 绝句最终的语法和std不会保留冗长且含糊的概念，至少中文绝句不会 (比如 try catch finally 就变成语法函数化+试做 接应 皆应+试:可空 , 之前是 尝试 接迎 终焉)
也不会刻意与py,rb,js 的传统术语分离，一定是小更改换大收益 😋

希望它能打破解释和编译的隔离吧 ，虽然我根本不知道咋做.. 语法风格颠覆的太快
不过我还是很高兴学习过弱类型 metaprogramming ，又掌握了解析和编译原理，所以不必受制于既有的 syntax 和 API，或者对象图框架，而能创造DSL

btw. kt 的 Sequence实现 居然和 yield() 无关 ，居然只是 sequence{} 在创建只读的协程吗
😅而且复制给Array,Set,Str.. 信仰崩塌

🤯 Flappy bird 一样的响应式框架…… 回想起被 #haskell, lisp 那种接口支配的恐惧

ww.ShowMouse=({P})=>
div(N2.xy(P),
  html`at ${P}`)

换到函数式里就该是各种B
yB = mouseTopB(document) // B是数值流

btw. awesome vue

cg($dyn) 生成了 ()=>(a=3,f=(a)=>(a+1),r0=[f(1),a]) ，运行正常

- just(a)
  - f()=a
  f
just(0)()

那再来一个

with(DSL)$lex=[[],
  [just, [[a], [f,[[],[a] ]], [f] ]],
  [f,[0, 0,[just]]],
  [0, f]  //“类型推导”差到不能直接调用
]

()=>(just=(a)=>(f=()=>(a),f),f=just(0),f()) 是0而不是3
实际上，()=> 的值会捕获上1层参0='a' 。在动态域里，大家会把"自由变量a"连着全局表整个copy一份
设想下 cg.bind(kv={},ast) 每层都有一张“表”是什么图景。算+-*/可都是要递归的

列表处理不熟的人都能想出 List<Map>, Map<K,List> 并觉得后者“很快”，而C++《龙书》则建议单个KV、每层调用栈暂swap()下冲突的K （这么简单的做法 却放错顺序了）

而JS是以前者链查找重写重载 [{a:1}, {b:2},kv={c:3}].reduce((A,B)=>(B.__proto__=A,B))

这些算法，都是在一个错的心智模型下选择的技术。 参数/局部/捕获的数目是固定的，只有$0$1 的指针可言，AST里哪里有全局键(导入)外的“变量名”？？在通过bash,Lua.org 弄清这点原理前做事，会把一切搞砸。
🌚 但这也是知 名的GADT+HOAS(的最 通 用 的 De Bruijn 指针). 一个给EQ前端框架提鞋的“可变量作为值” #recommend

>请把 at a=1, a+2 写成匿名调用的形式
a就是一个可以重绑定的“洞”, Vue都会:

add=(a,b)=> ()=>[a(),b]

(Fn1:[x] add(x, 2)) (1)
f=assign(()=>[0, ()=>arg[0],2,[add] ]),{arg:[]}) //用“语法树模板”表示箭头函数

call=(f,...a)=>(f.arg=a, cg(f))

call(匿名f,1)

#statement 变量关系式编程天天用 文化输出成解构+类型体操+Reactive响应算式/约束逻辑后就变🐮逼了，而函数式的闭包+回调(栈转堆,return地址转闭包) 输出变成协程/yield{(then=>),} 后也TM🐮逼了，内联return变goto变尾递归时,又比break更平等了，纯的 if(a,a,puts) a&&puts() 又和自动闭包宏不一样了
文本-AST-Scratch VM_IR-SSA-节点图 又隔离了，AST就不能是赋值图了。 这叫原地踏步式的前沿🥰 怀旧你🦄呢
(Kt 1..2对int,long 乃至Iter,Seq都有不同的(模板性)重载 ，连(Java8 stream 里也有的)去除装箱都没推广到语言层面。a=x?.f() 的?像一个修饰器，在f代表语句时外提为(Cont的捕获:switch化也需要) _f=x?f(x):x; a=_f

而反观那些ANTLR,YaCC 会逼你再来浅先遍历1次，以解析栈内存，否则会增大解释器开销
--因为它们是靠LALR等“虚拟机”而不用现成的调用栈递归。 小众领域的白象总是揉杂到夸张

其他玩法:

$=(...x)=>cg([[],...x])()
with(DSL)$([x,3], [a,1,x])
with(DSL)$([0, 1, [[x], [x]] ])
with(DSL)$([0, 1,[[x], [0, 2,[[y], [0,x,y,'+']] ] ]] )

cg() 短的原因是，它只是把语法解构再构了一遍(或者说穷举了输入=>输出的对应性)，就像 noop=(a,b=0)=>a==0? b :移动 一样基础
但这就是编程语言的本质： 如果抢了应用或功能点的风头，沉迷于无尽循环的轮子，那必然是种设计错误

想测试自己元编程能力，可以做些改进：
1. vararg和可选参数, forEach, 自动支持await
2. 把“静态”检查的f(a,b,c) 回退到弱类型 [..,3,f] 且不与既有AST冲突
3. 把重赋值扩展到py式 (,自动新建变量)=>,, ，变量表可以直接用原型链，注意 f(a=[]) 是能被f修改的
4. 常量折叠，循环展开 [for,x, [[1,2,3]], [0,[x,print]] ] 为3次print
5. 用词法域，把调用和递归转为push；|用CPS，把调用栈闭包成堆内链表 ，转化到这一步代码就剥离开JS的ABI了

台湾的翻译的heap,stack就是从 malloc(), alloca(stack) 意译的吧
函数级的存储空间就像push(struct)，是能静态计算。
btw. 惰性Proxy(可变<函数>) 是环形依赖的组织方法。 f=>(a,b)=>a? f(a-1,b+1):b 你可以试试用 fref(f=>f).set( Y组合子) 和蹦床函数(伪递归) 计算下

如果不会写，可以用「费曼算法」：上面说了
>请把程序写成数组的形式
🥰GPT就是费曼算法的一种实现，但它不能替你踩坑啊。

很想给点引文:mal lambda书, decaf-lang C书, Craft 书, 闭包详解, JVM R佬科普, c4:极简栈解释器,minipy
Lox实现图解, js工具库, astexpo, godbolt.org , tio.run , 语言花名册

👍20页纯示例 http://rigaux.org/language-study/syntax-across-languages.html#:~:text=Bags%20and%20Lists
http://rigaux.org/language-study/scripting-language/#:~:text=compile%20what%20must%20be
其他 code.golf:
重构浣熊 多语言
https://blog.vero.site/post/noulith#:~:text=The%20Cube
https://github.com/eclipse-archived/ceylon-lang.org/blob/master/blog/2015-10-27-why.md#reified-generics
https://ruslanspivak.com/lsbasi-part1/

但那么多都TMD在讲BNF讲分词，还有人把py的缩进往回{}改 😅中文圈就没个做基建的
(正则吃数|读树)都不会是吧。 BNF也就比XML好看一丁点，单知道输入数据长什么样，对理解语言做元编程帮助很少

#haskell 上也有
https://okmij.org/ftp/tagless-final/index.html#:~:text=class%20Symantics 称为GADT https://stackoverflow.com/questions/33928608/typed-abstract-syntax-and-dsl-design-in-haskell
我是说
Lit(Int): T<Int>
Add(A,B): T<Int>
toStr(this:T<*>): T<Str>
本质是把fun提升为class。套一层Lit<R>是方便另加接口，比如统一能eval():R ，当然这也是OOP比FP扩展性强的一个中心思想
能直接DSL或弱类型when就不要做无意义的装箱套壳，建起来终究是要执行的

甚至 fun<R> lit(:R): ()->R 组合器都能起到和AST同样的效果，OO和FP只是复用参数的一种手段，重点是你对目标树型有没有最常见的心智模型

#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拼接或解构后的值，避免手动分期求值

#design #plt
最近在整理的编程范式有点让我头疼…… 这个或许对学OOP有帮助吧：

//行列状多态，就是说一个类型由 字典C=A+B 定义
?? C A
  b1 Str
  - b2 Int

//以上声明里没写，故需要另加构造器
?? C
  Cat(name:Str, b1="demo")
    - b2  b1.(0).Int
  Camel(ver=0)
    b1 "Hi"
    - b2 0

这样的好处是 sealed,data class 都非常简单-甚至多种子类都语法一致，与 #Haskell GADT 不同的是，它支持附带函数与隐式this

?? 'AB'Columns //泛型,单位状类型
  Pair(:A,:B)
  Triple(:A,:B,:C)

?? 'AB'way2
  posL [A mayNO] //val posL: A?
  posR [B mayNO]
  Left(v:A) ; Right(v:B)

如果是新类型，还可以定义Enum甚至表格

?? RGB
  R;G;B
?? 调料
  甜 Int ; 咸 Int
  - 咸  id==1 or 咸>1
  醋 (0 0)
  盐 (0 1)

学起来有点让人费解（当然这是我设计的）， 虽说类型和值都是「构造器」，这样的大杂烩也太奇怪了（但，比用到再单独地学好吧？）

^1笑点解析

#linux rootfs容器化的潮流下，$ mount 跟不上时代了
apt-get; systemd 做梦也没想到有人把挂载当cp 和pm2用 😅，效仿 apk, Magisk 了，直接放弃文件读写

（其实就是OS提供给 read,write,readdir 函数的 hook ，archlinux 一直是如此做 PKGBUILD ，玩得这么花 不就是为了免 systemctl start 免分渠道发包呗
天下苦OS碎片化久矣

^2 #plt #learn
CPS变换=ES6无栈协程=自动传回调
OS调度器=有栈C语言协程=单核多任务 免回调

#haskell Cont等Monad能够和do管道链配合，实现异步、伪随机等其他语言里稀松平常的「纯函数」特技
'入'演算里，CPS变换必须不直接求值，改接受回调k ，这样它们就能跨线程组装返回值. 用人话翻译下：

(x): k=>x(k)  # 常量或sleep(1s) (k),read 等基元
(x=>A): k=>k (x=>A)
A(Arg): k=>A (K=>K(Arg))(k) #大K用来求值参数，小k回调

第二行就很抽象，「拿到流水线需要的东西」就是CPS，那么调用栈-返回也是CPS了， 但那是编程的基础课
他的本意，应该是指CPS 就像 fetch(://fn/args).then(ret=> 可以实现RPC。 kt 的 withContext(Dispatcher.IO) 和 "use server" 就是这个意思，可惜这术语也说了，用处却列不清楚

第三行的定义，按 Reactjs,Rx 都是CPS框架，只是不止能"return" 一次。 这个和指针关系不大，比如swap(a,b)是宏能定义的语法糖

^3
玩梗是很有新意，但希望各位订户记住： “高尚的是人，不是职业”

聪明的是人，不是编程语言；解决问题的是范式，不是语法规范

^4
推荐云风的Unity 3D教程。 u3d和GL使用左手y-up座标系，而不是数学的z-up
这利于2.5D横版游戏的开发
但z是“近大远小”的，和DOM翻转y理由一样。另外 cv2 是使用 bmp[y,x] 坐标，好奇怪的语法？

#algorithm 动态规划 dynamic programming
eg. lcs公共子串, knapack背包最佳配重, edit-distance编辑距离
http://www.bilibili.com/video/BV1FJ4m1M7RJ

🌚这是连“二参记忆化递归”这个常识都没说出来啊。
其实DP的经典案例是fib f x=x if x<2 else f(x-1)+f(x-2)
转化为一维的 f=[0,0]; f.i=f.(i-1)+f.(i-2)
这样，动归比递归的主要难度，是确立基线，以及用抽象的2D数组.ij取代fib()思考「状态转移方程」

二者的相似，好比「积分傅里叶变换」与离散DFT
动归比 @memo def fib 只优化了常量时间
fib只需要朝0的方向计算两个子问题，可以 iter 优化

实现上，如 lcs
f(,)=0
f(a,ab)=1
f(b,ab)=1
来，可视化一个corner case!
\ a b
a 1 0
b 0 2
可见，参数网格

r.(0 0)= A0==B0
r.(i j)= (Ai==Bj? 1:0)+
try max( r.(i-1) r.(j-1))
i==0: r.(0 j-1) #第0行没法再减
j==0: r.(i-1 0)

晦涩就对了，因为它等效这个：
lcs([A],[B])=A==B
lcs([A,a],[B,b])=
max(lcs(a,b) lcs(b,a))+(A==B? 1:0)
lcs([A,a],[B])= lcs(a)+(A==B? 1:0)
+2分支

f(a,ab)=1 直接匹配AaBb +1
f(b,ab)=1 则匹配ABb，居然也与表格等效

更易懂了吗？见仁见智，尤其是 (a,b)(b,a)是干啥？ 当然，因为lcs本身就有交换律啊..
不过我要指出，这个语法是有问题的(尽管 #haskell 在红黑树/快排上比cpp可易读不止一半)，如果专门对DP设计，一定有 np.einsum 那样更优雅的表述

DP教学总是涉及表格[i,j] 而可视化并不方便，不过解「编辑距离」，你总得先学diff(abc, aBc)=[1: -1+B] 怎么计算吧

* https://t.me/dsuses/5335 基于memo的lcs，人不如AI
* https://t.me/dsuse/18877?single fib流

只能先留个坑🌝触摸屏累死了

https://ray-eldath.me/programming/three-important-ideas/ #statement #PLT
Ray: 我的一位朋友如此评论这些文章：他说真正理解抽象的唯一方式是通过抽象本身，而不是通过并不准确的类比。
「为了充分地（"有用处"地）学习这些抽象，你必须去学数学，而不是通过一些糊里糊涂的文章，它们除了类比还是类比」
Dr: 要找到 “哪些代码遵循此抽象” 并不是必须的。像 Monad 这样的概念是非常抽象和通用的：它是一个描述了一套广泛的编程模式、数据结构、库和 API 的概念，其强大之处在于它们，是对如何设计和使用这种抽象的指导原则
成为高效的程序员并不需要理解全部的联系。其他人自然会强烈反对 :-)

Ray: "可仅仅知道 JavaScript 里的 Promise 本质上是 Monad，而 Functor “又是一个盒子” 并不能帮助你成为更好地程序员，而在你自己的库中使用这些词语只会让你的下游觉得不舒服"

...概念是非常抽象和通用的
等等，
逻辑学告诉我，抽象是通用的反面，就像社会是丛林的反面： 您的知识若是通用的，它一定能与各应用领域紧密联系，学生如何觉得它抽象！？

人们就是讨厌空谈，所以设计各种简洁而通用的API；人民就是讨厌丛林，所以组织出了社会。 现在竟有人觉得存在通用抽象和丛林社会？？ 这就像是说javadoc等机翻的玩意，比各种demo, test甚至产品更能展示项目的价值！
“靠代码行数来衡量软件功能的进度，就像是凭零件重量来衡量飞机制造的进度——Gates
靠知识点的难度衡量价值，同理。😅

我看这种观念者，确实是够抽象。 “类比”的本质是抽象，而「学习」只是用自己领域的思维，去「组合」「代换」出别人说的那种东西，带给你工具和知识图谱上的价值。
大家来到世上都是白痴，没有谁拥有无法被代换给别人的知识「原子」。写文爱用「未定义就使用的概念」，想设计新的抽象，却不谈理由？那就是 lier
无论我们用什么领域的「原子」组合出了CS的知识点，那都是潜在的价值，为空洞的术语绑定了新的语意，更摒弃了其中被“凭空捏造”的哲学。让IT人说话，天塌不下来！

难者，不会也。作者已死，凭什么说的道你就是「高等抽象」，大家能跟上的就是"糊里糊涂"的抽象？ Einstein, Feynman 说物理的最前沿应该教高中生搞懂，难道你们的方法论比爱翁还科学？
人们给车设计的引擎，能达到原理极限的98%，那么 #CS 对IT的指导，除了让空指针反复造成十亿美元bug，就是让功能不变的软件，随着更新越来越臃肿和慢？ 这算什么CS！

Monad很图论，很优雅啊！ 但它能从 x+1==2 得出x=1吗？ does it run backwards?
数学的精度是无限的、数学的等号是有交换律的。 #Haskell 里有模式匹配，但有"Var(x)作为值"吗？
只要变量是值，模式匹配、类型推理、响应式，甚至函数的编译，就真是小孩都会写的栏大街了。让 let(['x','y'],a) 生成 x=a[0],y=a[1] 谁不会啊 也配叫语言特性
FP们连正反函数如 show-out(1, "1"); show(res, "1"); res==1 都没建模，无精度int、向量、矩阵和微分都不如numpy sympy，也好意思谈数学性？ 起码把Fortran的矩阵搞明白再说吧

https://arendjr.nl/blog/2024/07/post-architecture-premature-abstraction-is-the-root-of-all-evil/#:~:text=achieved%20through%20a%20much%20simpler%20function

费曼家有一套《大英百科全书》，父亲常让费曼坐在他的膝上，给他念里边的章节。

有一次念到恐龙，书里说，“恐龙的身高有 25 英尺， 头有 6 英尺宽。” 父亲停顿了念书， 对费曼说，
“唔，让我们想一下这是什么意思。这也就是说，要是恐龙站在门前的院子里，那么它的身高足以使它的脑袋凑着咱们这两层楼的窗户，可它的脑袋却伸不进窗户，因为它比窗户还宽呢！”

就是这样， 他总是把所教的概念变成可触可摸， 有实际意义的东西。

“个体的经历，不过是一个庞大的（形式主义）系统下极其表面化的闪烁而已”

可那个闪烁对某一天的用户来说就是一切。 自然原理，亘古不变。如果只是发现他们就能改变世界？ 工业革命可以提早数百年。
人一思考，上帝就发笑。 你们的抽象，永远概括不了现实的领域、具体的人所提供独有的组合与可能性。

知其变，守其恒，为天下式？
穷其变，悟不穷，以明我志！
不能为每个人产生普世价值，是理论的悲哀。

#PLT #learn 文中提到一个Futa对应关系(第一类二村映射 first Futamura projection)， 展开讲讲还蛮有趣 🙉
首先，js人都会写计算器的，和 echo input/server 一样的难度

1+2*3
十(1, X(2,3)) -7

十=(A,B)=>A+B

这被称为「前缀式polish notation」，是Lisp的国是
教个小诀窍：js里函数只是一种字面常量，可以被for生成

Object.entries("十一Xノ").forEach(([i,x])=>
  this[x]=eval(`(A,B)=>A${"+-*/"[i]}B`))

为了更像“语言”，可以用列表(进一步就是"1+2"的代码)实现语法，便于糖化

Eval([十,1, X,2,3]) -7
Eval=([f,...x])=>(!f.call)? [f,x] : //基线返回两项，递归就都是两项
  (([A,b]=Eval(x),[B,c]=Eval(b))=>[f(A,B), c] )()

Monadic递归下降是这样AbBc的，因为不能右移流指针。不如逆波兰好看！不过这种程度的递归可以学学。

再看下「解释器interpreter」比计算器强在哪： 能够“在调用时传值”，也就是要有 argument[0] 这种“环境变量”
很厉害！现在有常数外的“语法”了，有变量了，高阶了！或许你需要学动态作用域(原型链?)、调用栈call-ret、惰性求值如&&|| blabla，还有深不可测的编译优化呢！

不就加一个箭头么。

十=(A,B)=> (env=>A(env)+B(env)) //现在知道为啥该用for生成函数？
Lit=x=> env=>x
Arg=i=> env=>env[i] //PHP写作 $x, 模仿bash的$1~$*
Fun=(n,f)=>f(Array(n).fill(0).map((x,i)=> Arg(i)))

env被称为运行时，它可以是JVM, import dis 或者别的bytecode解释器，这能减少tree-walk对递归栈的频繁依赖
这种 formSytanx.bind(consts=lit/arg/global/Types..) 的"部分传参"函数，称为编译器，而它的返回就是classFile等类型。
编译器并不需要与DSL这些技巧隔离，如果我们把 env=>x 写作 JSON(x) 而 env=>env[i] 写作$i ，既 Lit=x=> gcc? CBor.dumps(x) : (env=>x)
以这种人类或机器可读的结构序列化一些函数被"bind"到的lit，就得到了对应的代码。jvm的 lconst 1, aload_0 this参数, iadd (2->1)甚至是自动分配参数寄存器的！
https://www.yinwang.org/blog-cn/2014/01/04/authority#:~:text=partial%20evaluator。其实并不是特别神奇的东西，只需要在普通解释器里面改一两行代码就行，可是有人

二段求值。代码是流动的数据，内存是暂停的程序。本文甚至比赢王更直观： https://www.yinwang.org/blog-cn/2012/08/01/interpreter
定义个“元循环加法”吧？

十1=Fun(1, ([A])=>十(A, Lit(1)))
十1([232]) -233

//[Lit(f),x] 补丁下Eval"解析器"。计算器、解释器、编译器间，其实并非泾渭分明
Eval([十,1, X,2,X,1,3])[0]([2]) -7

如果你乐意，还可以支持基于全局表的递归 fib=f(x)=x<2? 1 : f(x-1)+f(x-2)
这一切都不会突破以上的定义框架。 If 不会，Call(f,x-1) 不会.. 这就是java的反射嘛。
我不想再写什么了。 我看过许多“编译原理书”，他们连这个=>都写不明白。 更何谈用Visitor实现(反)序列化 这些既理论又实践的approach
#haskell data Val=L Int|Op Char Val Val deriving(Show)
(Op '+' (L 1) (Op '*' (L 2) (L 3) ))
这类基于list或class{子类多型} 的 Eval(e=^^, env={proto:{..}})，与本文使用的闭包法是等价的。「闭包是穷人的对象」，Promise 给它暴露到了 obj.then(Continuation)

> 高阶的思想或许是本文的所有思想中最为重要的那一个 https://ray-eldath.me/programming/three-important-ideas/
你们知道函数的函数、类型的类型、语言的语法，却难以创造「语言中的语言」—跨越用途与界限而一致的语意。
我看numpy和 taichi-lang.org 就用的很好，比LLVM好一个世代
顺带一提，上文还使用了 Tagless Final 和 De Bruijn 索引 😇 。只是…… 你甚至不需要知道它们的名字。([A])=> 经常被实现为KV["A"]，但点明它的本质，却比写解释器更简单！

说到底，元编程也只是编程。就像“学会学习”只是一种策略，它对学习而言，并非例外情况。难者，不会也，譬如在谈"bind(x=1)后函数值字面是否改变"时提起「颗粒化curryArg」 当然会让人迷糊
node,graal会编译js,jvm代码（这也是为何Chrome页偶尔会segfault）； JVM会使用汇编模板+JIT 的混合式优化，Cython则把“甜妹语言”翻译到C，LLVM则是个伪装成NodeGraph虚拟机的codegen
如果只用"是否该调用javac"来区分语言，认为C类型总比python更快的话，你会发现程序员钟意的都是freak！

宏，macro码可揉，是传入与生成class{}等字面的函数。和+-*/一样只是函数，而函数、类型，只是值，别被“静态分析”骗了，它们送你的class只是病态类型。
入，lambda栏目答，看x,A,B等栏目回答的算式
这点篇幅放前言都觉得寒碜吧？ 可就是没人做到啊。 扶她投影？不知道的还以为是HP projector 的娘化版呢。。
PLT能对dev点化到的可谓寥寥， 但100%都是必要且急需的知识和"抽象"，像Prolog的模板与响应式html编程("FRP") 什么的。 Monadic错误处理我不想吐槽什么，只能说不怕不识货，只怕和Kotlin比！

跑题了。当然，聪明的你会发现Fun的返回违背了"基线指明了递归的类型"这一原则，没生成 env=>
那C语言函数指针是这样的，env由*rbp[0:2]=[retRbp,retAddr]这些CPU变量提供，但JS里的闭包可以从env偷变量(Var作为值,mut ref)，所以说「闭包是穷人的(单方法)对象」

C里还有"函数符号"，那是由ld.so实现的全局表，让.o对象能先被mmap到任意地址，再去回填calls
真正的那个全局表叫 $PATH: ，以及没定义main的对象的 $LD_LIBRARY_PATH 。

#algorithm #防自学 🤓 让我来示范一下怎么概括算法思路
要介绍的是在stdlib里，用于组织集合类、JSON的3个重要结构: b"ytesPtr", {K:V}, sorted([0 2 1])=[0 1 2]
它们对各种app和其他算法性能效能的重要性，好比json(cbor.me)之于REST、zip之于jvm和pip。 因为是涉及SDK实现的内容，也主观评价下语法设计

下面用胖指针(x64上void*是8b, 胖指16b)、链表、快速排序简单的实现3者 #code

#define Col(...) typedef struct{__VA_ARGS__;} T;

#define T Str
Col(size_t n; char* buf) //C的类型本应默认为指针, *胖指针，像kt那样对Int等类型免链接化。简洁的UNIX里，Type* 快成为public那样的形式主义啦

#define T_Link(E,T) struct T{E x; T* xs;}
T_Link(int,Nums)  //template<T> 允许类型推理，即一致化调用和返回处的<T>。可怜gcc/clang无论对宏还是模板的报错皆如内容农场，不具有可读性

https://colobu.com/2023/06/29/replace-std-map-faster/chunk-index-memory.jpg
用例和 #haskell #code https://gist.github.com/duangsuse/26b80c39e1d8f7549b9cf244d8de1ce4
题外话，闭包值和 x.interface_cast(T) 的双指针&dyn 随结构传入T的函数表

qsort :: (Ord a) => [a] -> [a]
qsort [] = []  
qsort (x:xs) = 
    let smallerSorted = qsort [a | a <- xs, a <= x]
        largerSorted = qsort [a | a <- xs, a > x]
    in smallerSorted ++ [x] ++ largerSorted

UmbraString 和上文Str{n,buf}胖指针一样是16b，但它的.n和jvm一样只寻址[4b:int]的长度，其后最少随4b的免链接char 用于比大小
对于n>12的buf，剩下8b换成指针，指针的高2位用于标记GC信息： 持久pin、临时ref、用后即焚val

很明显！这是一种灵活利用了x86内存布局的b"length"实现，和x32压缩指针一样，节省了sort解指针的时间

SwissTable 是对Hash预分组查表的免链接。我们知道， dict/HashMap/lua.Table 这样的{K:V, K1:V} 单映射常被用于查找和缓存，在C++里更是会区分 unordered_map, rb_map(以排序radix,SortedSet,而非hash作为预分组线索)
它的最简实现是lisp里的链表 T_Link(struct {int A,B;}, int_LnKV) ：没留任何线索来减枝！

即便8b hashCode，也是一定会冲突的，哪怕是int.hash也会因 buck[hash%nBuck] 有限而退化为线性查找，负载因子(kv/nBuck 过大)，这时就要扩容。Go的扩容基于一种空间换时间的优化(图1, 为了减少求余数的冲突，除数都会采用2的指数)
扩容后的冲突集，可以用链表(UnionFind)或数组(slot), 从那往右找
Swiss 更聪明，它对每slot对应1b的元数据，最高位0x80=无效项 ，0xFF=null结尾 ，低7位用于存储hashcode的高7位，这么摘要是为了SIMD128bit 1次对比8个KV
不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

快速求余(x,n)= uint32((uint64(x) * uint64(n)) >> 32)
#dalao https://init.blog/fast-newton-sqrt/

float InvSqrt(float x) {
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

最近的一种基于partition(区间而非idx)的快排也很有趣： less than pivotL | between pivotL and pivotR | greater than pivotR

#PLT

我想吐槽 #Haskell 根生的可用性问题。f(1+1) 里int(2)的懒求值是蛤丝的“特点”，而 add=(\a \b a+b) 的强制“解耦合”是纯FP风俗，异曲同工

这是在制造“熵增”。

我们都知道 @autoclosure，即 f(1+1) 等效 f(lambda:1+1) 是Lazy<T>的必须（时间换空间，这是混淆求值阶段的代价），懒有什么好处呢？

允许自定义 if(Q,A,B) 和 and(A_or_break, B) “函数”？单子宏？这是在乱搞。

((1)+1)==(1+1) 吗？哲学上来说，PL把自己当成“递等式”，过程和答案是等价且相等的。但“熵增”就是丢垃圾，蛤丝喜欢垃圾！ 这是为啥呢？

对于上面的“递等式”，显然有比 2==2 更高性能的证法，但符号的好处正如列表字典之于JSON——有得必有失。在Lisp继Fortran诞生后，这个【失】就是GC。

Thunk就是另一个“GC”，只是它屁用没有。GC至少能用“链表状图”帮你算出“字节数”状图在某天有多大，

Thunk（0参函数）知道“1天”是什么维度的值吗？

栏目答演算的本质是什么？字面量替换。这也是为什么ML99能用 #define （配合 if_##A##B 式模式匹配）的写出一个无编译期插件的DSL，所以无论是SKI、栈语言、Prolog（DFS）的替换都是同阶的，不存在哪种“血统”更高

Church老祖在写自然数 N=Z|N+1 和“神奇”的，不用struct{}写程序的组合子时，他只是把tuple放进了(*arg,)闭包里，通过.then(续延)的“链表线程栈”的方法，以及从arg里选续延。纯函数是另一种OOP编程而已。

所以“懒人”是和自己过不去：如果说 (add 0)=(\b 0+b) 无法被压缩（即更接近停机/靠近main的帧），是因为 b :: Int 值还有“极大”的潜在空间，无法在“Runtime”之前剪枝，(add 0 1) 或 0+1 凭什么不是字节(=0x1)呢？

Currying 是因为int(x)所示所有x的空间，4GB也装不下，Thunk，比如 Monad “解释器”和Haskell蛤丝引以为傲的 do(>>=) notation 的情况不同！ 🤔💭

#FP 纯函数其实就一句话：“编程的人不调用「结果不一样的函数」”。

input(">>>") 和 random.pick(*"AB") 结果只在测试环境下一样，print() 在caller不能读取它（stdout流）时结果不一样，yield在耗时上结果不一样。

那么他们是怎么把代数搬到电脑里的呢？不是写vec2场函数，也不是挑战Rust宏或平民版comptime func，是把JS里的.then(f)做成“编译期查表出f”。

没错，去掉副作用只靠「不调用0参函数」（拒绝全局this和“立即树相等”），所以他们把任何函数都塞给了一个argLast：我们一般叫“调用栈”、“单步调试或执行”的那参数，还美其名曰高质量工程。数学和计算机就是扯淡，真数学的门（Torch/Taichi）FPer摸不到

用范畴论术语装点门面。范畴的集合可是有N:1箭头函数的，就连物理模拟也有2:1的sqrt(x)计算，哥德尔不喜欢听废话，什么时间和折叠（eval order）没有发生因为“代数生效了”。

Monad和 #Haskell 的Logo(>>=) 又是什么呢？结合律。

(read | greet) | echo 和 read | (greet | echo) 是等同的

(a;b);c == a;(b;c)

窝槽，这不是废话吗？不对。因为 greet(x) 有1个点位，所以FPer就造了整个“链式调用栈”，来发扬Curry和模式匹配GADT&class延迟绑定的精神，
其实 a;(b;c) 根本就是鬼扯，任何一个正常人都看得出Lambda不是这么用的

套那么多层无非是为了实现 if(Q,print,print) 和 if(Q,return,''), print 的“调用侧决定”，引用一大堆有的没的paper，

最后还不如 yield eventTuple 或纯粹的 DSL=(...lit)=>(env)=>{return value}
写操作系统和编译期函数的人早就知道了，DB/DS/CG 领域的人知道的更「纯函数」。

有这点能力不去写些有意义的DSL和“可以不乱的混乱语法”，去屠C++ template<>的龙，却凑一个死寂了70年的数学界的热闹。现在还想证明Dijkstra的软件测试知识是错的。

CS+Math，学术cosplay。 🎓 👎
我不两次踏入同一条河流，任何一个用户都是如此。 πάντα ῥεῖ

1958: Lisp → 解决实际问题（AI, symbolic）
1972: C → 解决实际问题（Unix, 系统）
1974: SQL → 解决实际问题（数据管理）
1983: C++ → 解决实际问题（性能+抽象）
1991: Python→ 解决实际问题（快速开发）
1995: Java → 解决实际问题（企业应用）
2009: Go → 解决实际问题（并发服务）
2015: Rust → 解决实际问题（安全+性能）

世界在变，数学没有意义，或者说数学的语言没有用。数学依靠语言，不是语言依靠数学。

如果代数逻辑都不够母语，还有什么是“整个宇宙的方言”？所以，没有一种有价值的领域，在担保上败给数学。

脱离涌现的几何知识是死的，死枝「挂名不上」活果实，就像量子物理承认了芝诺、费马、贝克莱大主教（牛顿的“好同事”）、高斯曲率定理。断言什么死的正确，真知识就复活来否定它。

就连算力的语言，也很可能是安排不够好而卡慢的。或许走一遍必然是 O(N)，数学无穷里一定有一堆Node可以跑通 A->B，但谁告诉你N一定要有“那么多”？

"If 🍎 + 3 = 5, what is 🍎?" 🍎 = 1.

Accepted.

https://github.com/Kuri-su/yinwang.bak/blob/master/articles/函数式语言的宗教.md#:~:text=这个世界里的所有东西都是“有线”的。你需要绞尽脑汁
幸好我不需要线。没有吃掉苹果的人，才害怕那道线不对。 😊

当然了，我简化了 accept() vs accept(then) 的问题，前者传入了自身pid（或者说整个ret2stack），后者另外传入了一个“代码和数据”双指针。 内核权限对后者是无能为力的，因为一个进程不能长两个头。

这个问题，真正是我说的“用非常愚蠢的方法实现闭包”：把 一个纯粹的token鉴权，和栈(pid)绑死在一起，所以有了各种语言的await。 这是养鸡场只有一个谷堆，一群鸡随机插着队来消化，但谷堆（网卡）本身是事件性的！😂

鸡确实没有两个头，但把进程视为单线的、有栈顶的，这种说法本身是错误的。并没有确定的执行顶部，只是一堆信号变量间的因果链！

😅因为OOP封装和“阅后即焚”式计算太流行了，好像必须要有个栈vs堆一样。其实栈分配只是个内联优化，泄露进了认知里，还成教科书了。 不会真以为栈变量就能阅后即焚吧？

这就好像某人发现了【文件名不占空间，可以拿来做压缩】，或觉得伪递归(continue fn(x-1)) 比for更占内存的“真理”一样让人哭笑不得。for还会死机，递归却允许爆栈时优雅容错怎么不说？

OS就是大一点的JVM，甚至代码解释器而已。 🐧因为sched/vm的内核功能把 “回调链表” 给藏在混乱的procfs统计里，就认为不存在持续态栈消耗这回事?

一个进程不能长两个头。 更深层次的问题是，pthread无法区分出这双指针里谁是“安全”的数据（需要喂给用户态全局sighandler）

uring后来解决了。IOCP可能还简洁点，但如养鸡场一例所说，这是手写闭包和大switch的智障级设计。 为了一个“不能跨域请求污染”的事兴冲冲的把垃圾当成高性能做

😇我就摊开了讲：两个版本accept的本质区别是栈易失vs堆拷贝，是从 pix(x,y, implicit pid) 装箱转换为 enum Stack{Pix(x,y)} and pid {case Pix: .. } 的双指针的组合方法之别，大小写问题。

为了这个内核不能“跨域执行”的手短问题，你们发明了Kay的OOP里没有的毛病，这个模型并没有比“单线程”那个好看，因为仅仅是内核不能去直接eval那个回调而已。它必须区分arg和fun。

这是模块化时的权限问题，其次是ld-linux的ABI问题。让accept自带fork的语意并不会让nice沙盒+mmap的开销更低，何况养鸡场并不适合为了while(1)设计的抢占式调度器。 把pid这个隐藏状态诚实的写成一个参数，怎么就这么难呢？

有多少人知道strace和stap可以像F12网络文件覆盖那样，模拟chroot？ 好像pid和gui本身是不可再编程的最终产物。

这件事的结果是，因为4K页和抢占式调度器太贵物的弊病，libuv 这些东西动态创建线程只为了在accept/read之类的固定行号卡死，然后push给master，后来又有了epoll/uring逐步的“跳步”支持。

本来的模型错了，但它的 dirty hack 碰巧掩盖了这部分。好像线程这东西真是存在的一样，好像“服务”真的都不是单线程的。

他们还经常说什么高并发L3缓存友好，其实就是一个不存在的问题，就像React的vdom vs Svelte的点对点绑定一样，错误的把“回调链表”用timer + while(1) if(ret!=null) 这样的若智逻辑表达，改回来，还长脸了？ 你tm一开始就在无脑GOTO和鬼扯。

还有人又学到了 #FP Continuation，就是【回调链表】asks(A=>B=>C=>...) ， #haskell IO Monad 给整的亲妈都不认识

归根结底，异步编程就是个骗局。是事件的就归事件，不要把谷子堆起来，再责怪鸡怎么挤来挤去数据都乱了

让一切“返回”某种json再去diff减枝真是我听过最搞笑的优化了，JS觉得自己比C++快，C++认为x86中断不懂事件和因果链，编译器觉得机器和指针比人聪明。 根本没有“返回”，编程是点对点的。 🙄

#post #ce #haskell(IO) #os #js CPS是什么（异步和函数式编程 都可以看）
#ai锐评
🌶 https://chat.librechat.ai/share/hjL775AHhAji7HM8K0lFt
🧁 https://chat.librechat.ai/share/SmoUvMiuxY_hfmIcUEK95

故意生成的 emoji 🤗 AI味，看看逆不逆天？原文是手写的

CPS 不是 Clicks Per Second, 而是 Continuation-pass style，后者可用于优化前者。 😉

CPS的理由：CPS产生【回调链表】作为线程栈 📜，可以让单线应用像操作系统那样工作 ⚙️，但不能处理音画同步和多线下载（绿块块下载/暂停/断点续传等），这依然需要 Coroutine 调度器（事件循环/libuv）来补位。之后就和ChromeOS一样完整可用，脱离 C-like 世界的掌控了！🚀

CPS：把所有 return x 换成函数语法如 onRet(x)，因为只是调用，就可以玩两两组合了 🧩，比如 if(x=onCatch(x)) onRet(x) or exit(1) 或 addEventListener('click', ()=>onRet("两个按钮你点了确认"), {once})。没错的！✅ 你甚至能在 throw 错误的行号原位恢复，OR 手动实现 yield✨/callcc-setjmp/Algebraic Effects 依赖注入模式。

CPS变换：如果 return x 都被换掉的 def 只是一个计算图（只包含赋值和 ret 变量），可以直接变成 switch(op++) case 0 case 1.. 的行号调试（每个 case 将不以 break; 而以 return; 结尾，c=a+awit b 变为 _1=wait;c=a+_1） 🔢
否则，需要处理 for if 以及相关的流控，如 throw 和提前 return、爆栈的 DFS 等等，也就是扁平化为 goto(op=xx)，f() 一次就走一句（几行的微任务）。 🚶‍♂️

TCO：在递归时 f=(n, r)=>(n==0)? r : f(n-1,r+1) 是个特例，可以改写为 f(n,r)=return continue(n-1,r+1) or (n==0: r) ，这样的多分支状态机 🤖，所以叫伪递归（TCO）。另有一种将 f(n)=n0? 0 : f(n-1)+1 转为的【自动累加器化】，还有使用TCO（甚至模板解释器）优化 switch(opcode[i]){} VM的标准写法 ➡️ https://t.me/dsuse/21568

Promise与Continuation：(async()=>1)().then(one=> {}) 在一个CPS对象上写个 then 回调。🤝 因为每个 {} 块都有要“返回”到的行号，和此行号周围的【🎁已知变量元组/Upvalue/闭包】，这就称之为 then 值，粗略的认为它是F12面板你按F8暂停时 ➡️ 所指示的一行 【点开可看的函数名】。

将 ()=> 给 async 化变为对象后，它的 return 值就放在了 u._ret 和 rr=u.call(_yield的返回值=null)。rr 值用于优化 await 1 这样不挂起到 libuv 或 syscall 的缓存 ⚡️。 u._ret 即使在完成后调用 .then 也可读取哦！
（这是一个GC引用问题，未完成而被await时，proc在sleep时，内存占用不会消失。c10k问题） 👀
（c10k和y2k一样是个傻逼问题 accept()明明依赖io_token，非要依赖pid，产生4K栈和CPU无效轮换的问题）

通过实现 onYield(i also{i+=1}) 与对应的 forEach，正如 onRet 与另一 Worker 上对应的 then，我们可以定义一个走1024次(4KB)才返回1次的 func* 📜，而不需要和 java 那样弄 iterator(){} 和 BufferedX()，这就是 Kotlin 最近的方向（但它们对响应式 flow 的理解不如 Svelte 🤷）。

有人 alias then值='酷酷的lambda' 或 'pthread线程'，其实它更像 fn.bind(框架已知参数).bind(你的已知).call(运行时参数) 🤔。

这篇文章有点《图文不符》的意思了，其实还是有内容的，只不过AI味特别浓。