如果用我之前设计的绝句来说，可以这么写（只是说可以，不是说推荐），比较一下：

事 f(数、实): 元二<实、浮> {} 
数据物 S(x: 字、y: 数、z: 实): 存储
常S s = S()
对你s，元三(x、y、z)。里的，它置为1
你s，元三(y、z、x)。批量置为(元三(3、3.2、'x')) — 肯定不是标准库里的
f(*你s，元二(y、z)。)
f(*你s，元二(y、y)。)

……简直写不下去
不过『存储』这个特性蛮高级的，我还没设计好emmm……

https://t.me/dsuse/11777
这是一些随记，还很不成熟，我最近是没时间实现的，不过我在写一个解析组合子框架(ParserKt，已经拿它写了一个JSON解析器尚待修完……)

简而言之，如果把这些代码翻译到绝句可以用这些特性：

事 Name(x: T0, y: T1): R 为……

当然为后面的缩进块是可选的，也可以用 {}

元一<T1> 元二<T1, T2> 元三<T1, T2, T3>…… 元组类型
之所以不说是『一元』『二元』，是因为数字可以这么表达：二十三+二十万二千一百

你，……。 这种『第二人称文法』
当然它和 let 是有区别的，区别在于有 (你a且大b、c) (你x在a且不在b) 这种语法糖

所以C-forall的所有 x.[a, b] 在有存储抽象的绝句上其实都是 你x，元二(a, b)。的形式，我搞不懂的就是何时编译器要选择存储、何时要选择值，打算加入多态特性的。（类型推导麻烦一些）

Name(*Expr) 和 事 …(变长 Name: Type)… 就是变长参数传递了，所有支持 算符的事 项目n 的都可以这么照 * 传

字(Char)、数(Int)、浮(Float)、实(Double)、效果(Unit) 这些
「数据物」，还有基于『分配』（而不是『值』）的「物」
因为我实在不想引入 struct 之类的东西，我觉得它使得语言的数据类型被过分分割了，写起来莫名其妙，继承自分配是等价用 struct 的

不过没有东西等价 struct 的，因为「struct」必须有架构器…… 就是说 数据物 Name(…): 分配 了……

最后的

v.[x, y.[i, j], z.k]

就是（好像很难看了呢，因为逗号简记法不能写在一行里……）

你v，
  元三(x、你y，
    元二(i、j)
  z的k)

最后的 f().[2, 1] 就是

你f()，元二（我[2]、我[1]）。

说白了就是在翻译 Kotlin……

也的确是，不过如果要在类型级别是不是很困难？因为时间可能和输入相关

这方面最典型的例子就是停机问题

halting p = if p then infinity else 1
  where
    infinity = drop Infinity ones
    ones = 1 : ones

这种情况就是 True -> (没有值); False -> Int
当然计算机科学的研究者们是不肯把程序写成这样的，不过还是可以有 Y 组合子……

Y = \f. (\c. f (c c)) (\c. f (c c))

Tcl/tk 嘛（读 tickle）
我觉得它和 Squirrel 一样，没点文档

我讨厌文档不好的语言；Lua 可是一个类似但文档很好的语言

所以说我其实是一个倾向工程派的人，因为我简直无法忍受学术系 Haskell 的风格，都快无法结合那一堆 phi psi mu (>>=) ($) 了……

但我一点都不觉得函数式能够解决更多问题，实际上我只是喜欢混合函数式编程的风格，和纯函数控制那一套无关

套一下呗，举个栗子：

inline fun justA1M2(x: Int) = (x + 1) * 2
fun logic() {
val y = justA1M2(0)
println(y)
}

现在你得到了 AST：

inline fn [justA1M2]
argt: (Formal (Name x) (Type Int))
body: (Expr (InfixChain (Op* (Op+ (NamedRef 'x) (Lit 1) ) 2))

fn [logic]
argt:
locals: (Val 'y (Type Int))
body: (CompStmt[
(Assign (NamedRef 'y) (Call 'justA1M2 [(Lit 0)]))
(ExprStmt (Call 'println [(NamrdRef 'y)]))
])
于是你可以 inline：
body: (CompStmt[
(Assign (NamedRef 'y) (Call 'justA1M2 [0])) -- 注意这里，你调用了 inline fn
然后直接以表达式的形式 subtract（替换）：
body: (CompStmt[
-- (Assign (NamedRef 'y) (Call 'justA1M2 [(Lit 0)]))
(Assign (NamedRef 'y) (Expr (InfixChain (Op* (Op+ (Inlined (Lit 0)) (Lit 1) ) 2)))
(ExprStmt (Call 'println [(NamrdRef 'y)]))
])

然后就内联上了，最终代码是这种形式：
fun logic() {
val y = /*justA1M2(0)*/ @Source(…) (0 + 1) * 2
println(y)
}
是等价的

你的意思是…… 哪个栗子

有些事情就是不能不慢慢理解的……

小时候我妈问我一个问题，『一千克棉花和一千克钢铁哪个重』
我一下就答错了，而且他们怎么教我也还是觉得钢铁重……

其实当时就是真的不知道『重』这个修饰是什么意思，后来一年多以后才能明白。

对心智成熟的成年人来说也是一样的。