duangsuse::Echo
711 subscribers
4.24K photos
127 videos
583 files
6.44K links
import this:
美而不丑、明而不暗、短而不凡、长而不乱,扁平不宽,读而后码,行之天下,勿托地上天国。
异常勿吞,难过勿过,叹一真理。效率是很重要,盲目最是低效。
简明是可靠的先验,不是可靠的祭品。
知其变,守其恒,为天下式;穷其变,知不穷,得地上势。知变守恒却穷变知新,我认真理,我不认真。

技术相干订阅~
另外有 throws 闲杂频道 @dsuset
转载频道 @dsusep
极小可能会有批评zf的消息 如有不适可退出
suse小站(面向运气编程): https://WOJS.org/#/
Download Telegram
duangsuse::Echo
我们来对比一下迫真易语言的『容易度』和绝句的『容易度』 这里易语言的代码风格我参考了 Kotlin(1space) 的格式。 引入 apr; 公开 类 启动类 { 公开 静态 启动() { 整数 数量; 控制台.输出行("请输入将要生成的随机数个数:"); 数量 = 控制台.输入整数(); 随机数集合.显示(数量); 随机数集合.显示(); } } 公开 类 随机数集合 { 公开 静态 显示(整数 生成个数=10) { 字节集 临时字节集; 整数 I,J; 内存池 局内存池…
我吃饭回家路上考虑了一下

首先为了能够实现
函数,〖x0〗x0。
函数,〖x0〗
x0
这种逗号表示法的形式,这个样子的逗号表示法类似:
逗号块(逗号修饰, 体)……

同时,我也终于决定抛弃了逗号表示法的 {} 替换:
若p { op0() } 否则 { op1() } “不允许。”
毕竟绝句不需要像 Haskell 那样 \case ox (Some x) -> 切换布局块和非布局块版本的语法,逗号表示法「,、。」是比较简单的。
现在这个开闭符号是『reserved』了。

然后,绝句也可以利用记法、扩物和内联的物兼容传统汉语的表示形式(比如『把(x)加进xs』)
这个扩展将在标准库的 绝句.严格中文 里实现。

然后,绝句的相对Kotlin的一些语法扩展:

「为」布局定义、「其中」布局定义、逗号表示法、第二|三人称的「你」「它」、「的」「去」、『记法』和「」中缀链、『』名字、【】注解、汉字数值常量表示。

""" 为 是对 raw string 的布局化扩展,之间区间 (0,1) 个空格,多了不算。
关于其中是否支持 $, ${} 一说,Kotlin 是支持的,不打算改变。

逗号当然也包括顿号的。比如:对用户里的,好人里去划掉(它)、坏人里去划掉(它)。

一些常见语法:

对…里的(名)……
对…里的你…… “第二人称”
对…里的…… “第三人称”
若你… …… “第二人称「若」” (删掉,这个语法其实是冲突的,而且在正常代码里也无必要。
【无参注解】
【带参注解 参0、参1、...】

判断……
判… ……
(「它」第三人称中缀简写)
判属… ……(于、它)
判存… ……(于、它)

所有判断都可以有语句形式和表达式形式,表达式形式的分支必须有穷举性。
「、」是逗号表示法里常见的语法,只不过不同结构有不同表现形式。
提供的「上皆……」都是副作用的形式,表达式里不允许。
「否则……」在表达式里也允许,这时预期的不是效果而是值。

一些规范化修订:

解量、解对、判属于、判存于、「空则」逗号表示法

重复若、重复……若。

绝句的面向文件定义结构:

包、记法(定、引) 、引(成)、引全(除)
属别名、类物别名、常参、类、物(造于、初)、例、事、量(取者、置者、代者)、变参。

突然想起来,:: 是引用文件级事和架构器?
架构器不是函数??? 🤪
那么就没必要区分属别名和类物别名了,都一样。

我决定了,第一设计稿应该把「变」初始化的 = Expr
改成 初 Expr,要不然显示不出参量变化的精髓。
变参现在是
变 属名 角括名字 初 Expr
变 属名 名字 ws1 初 Expr
变数 和 初0
的形式

还有,「包」在汉语里不应该还是原来的 package (qualified-name); 形式
包 (复名) 为
这样(其中,复名是复合名称的意思)

PKNF(ParserKt Normal Form) 是一种形式化文法描述语言,它可以为 ParserKt 生成有效化、优化的代码(比如合并前驱、分支遮盖式前驱重排序)
合并前驱的功能可以让
变 属名 角括名字 初 Expr
变 属名 名字 ws1 初 Expr
变成利用 ParserKt 递归下降上下文相关解析来判断翻译成类似这样:
变量 ('变' 属名)|变参 后继:(anychar) where
后继:(run c) caseA|caseB
caseA lookahead:('『' ) 角括名字 '初' Expr
caseB 名字 '初' Expr
它只需要能够对任意两个子结构取 succeeder union (交集)和 succeeder complement (补集)就可以启发式合并分支了
complement 角括名字 名字 = setOf('『')
complement 名字 角括名字 = setOf()

— 所以只要出现的字符是'『',就只可能是角括,否则只可能是普通名字。

但是PKNF开发比较复杂,而且理论上的很多东西暂时不完善(也别指望它们太完善)
所以一时间ParserKt是不可能用上PKNF来定义自己的上下文敏感语法的,尽管PKNF已经被我完全形式化定义好了(以它自己描述它自己……),要用可能是一年后了。

令做(run)、令为(let)、令置为、顺手(also, (T)效果)、交给(支持 (T)* 的 also)
有若(takeIf)
成文(toString) 成码(hashCode)

滤出(filter)、映至(map)

存一(find+不空)、存仅一(single)、皆是(all)、皆非(none)

后来我发现它们有点不规范。
令为(let)、令做(run)、令试(runCatching)、顺便(also)
有若(takeIf)、有非(takeUnless)
对(to)
化文(toString)、化记码(hashCode)
滤出(filter)、映至(map)
存一(find)、存仅一(single)、皆是(all)、皆非(none)

apply, use 比较让中国人不明所以、with 已该被换为let。

—取此即值(get)、置值于此()
……我突然觉得绝句的『直接值代理』有很大问题了,我不知道它是为了什么,根本不应该让程序员能够做出这种定义。
代为取值(getValue)、代为置值(setValue)

语言结构方面,术语统一为:
常量(literal)、言(expression)、句(statement)、体(block)、构(syntax structures)、书(file)

然后继承方面,顶部类型最好还是『分配』而不是值(即便这样有点『结构化编程』式了……)。

包『绝句』为
开放的物『分配』为
【内建】、待例、算符的事 问全等(另:分配)
类『可度』为
量 大小:计数
扩物『可度』为
记法「之为」的量 之为空 “……”
类『可度长』为
量 长度:计数

本来我打算让 none 变成「存零」的,可是那样 all 就不好命名了,只好引入记法「皆」。

未来绝句标准化到一定程度后我会开始考虑如何将他实现,以何种单位编译、要翻译到什么语言。

rust 在还没有编译器的时候,它的第一个编译器被起名为 rustboot
虽然绝句还不能怎么样呢(大概可能只暂时会做符号解析的工作)
我觉得,第一个只能输出Kotlin源代码的翻译器就叫『绝句 序』吧……
duangsuse::Echo
https://www.yinwang.org/blog-cn/2019/12/26/success
我从很早的时候就藐视所有试图给我打分的人。我从来没有觉得竞赛的主办者有任何资格来评价我,所以从大学开始我就没参加过任何竞赛:ACM,IOI…… 现在一看到这种东西,看看他们的主办者,出题人和裁判们是什么水平,都觉得可笑。当然我就更加不会在乎任何人说我是否“成功”。

不支持,人只有追求更好和自己不在乎的事情,有舍有得而已。这么说太绝对,何况你怎么能武断他们技术不怎么样。

淫王也是可怜,估计他经常被一些清华的校友嘲讽什么的,还好我估计本科都上不了,不担心被别人唾弃。
duangsuse::Echo pinned «🤔duangsuse 昨天晚上想到了一些话,愿意分享给大家。 #statement duangsuse(虽然一点也不好)是如何编程的呢? 他编程,是一个从整到零,再从零到整的过程。 首先是把一个相对比较大的目标,拆分成许多能够比较简单实现的小目标。 比如,把一个操作纷繁复杂的类(class),抽提出实现了很多接口的类。 接着是和自己争论实现的难点和复杂性,继续重新拆分和重新组织继承、数据依赖这样的关联,偶尔还会为一些经常联系在一起的东西(比如 Database, Controller) 起一些首字母简写,记住。…»
duangsuse::Echo
我吃饭回家路上考虑了一下 首先为了能够实现 函数,〖x0〗x0。 函数,〖x0〗 x0 这种逗号表示法的形式,这个样子的逗号表示法类似: 逗号块(逗号修饰, 体)…… 同时,我也终于决定抛弃了逗号表示法的 {} 替换: 若p { op0() } 否则 { op1() } “不允许。” 毕竟绝句不需要像 Haskell 那样 \case ox (Some x) -> 切换布局块和非布局块版本的语法,逗号表示法「,、。」是比较简单的。 现在这个开闭符号是『reserved』了。 然后,绝句也可以利…
本来不该就这么快结束的,可我觉得思路和细节已经基本在我上面写的例子里显示出来了(比如量『a』=1;变文『s』这种不带空格的类词法解析定义),所以我觉得还是继续写我的 e2im-2、Binarie、ParserKt 吧……


嗯……其实不对,我还有许多设计笔记没有发的,而且最重要的中缀操作符、优先级,我都没任何定义。
下次吧,毕竟一时半会也实现不了。
Forwarded from 布丁 包
@duangsuse 话说最近那个文言语言是你的嘛?
Forwarded from dnaugsuz
那不是文言啊,那是现代文。每次我去学校的时候偶尔会有机会设计一下,目前也就完善了两次(第二次还没发上网)

最近我有 Kotlin Multiplatform 二进制序列化组合子库 Binarie 和解析组合子库 ParserKt 要写,暂时没时间实现它

因为绝句程序设计语言依赖很多上下文相关的语法(主要是实现『布局』语义特性的,比如逗号表示法、「为」文法,那是必须的。)
所以我绝对不能使用一些比较老式的解析器实现方式,比如ANTLR来实现它。

也只能慢慢看喽,何时有了 ParserKt,我打算先弄个 prototype(原型) 翻译到Kotlin。至于 1.0 的语言特性我得先实现另外一门「脚本语言」再考虑。

如果你感兴趣可以来看看之前的一些设计笔记,不算太严谨。
#zhihu https://zhuanlan.zhihu.com/p/91353256

https://t.me/dsuset/6816; https://t.me/dsuse/12085 @吴烜 你说的大概上没有问题,可略微有点无力,如果不嫌长的话可以看看我的。如果你想了解关于布局文法上下文相关解析(也可以在分词的阶段做)或可动态扩展中缀链解析(infix subparser)或汉字数值解析和格式化输出的内容我可以帮说几句,上面的链接可能要科学地上网才能访问。


我觉得没有必要呀。
编程,其实是符号编程,比如汇编,就是明显的符号。
后来高级语言了,使用有语义的符号。
比如if,for,case
其实他们还是符合.。
查查英文字典,case是啥意思,和代码里的case有关系吗?
英文更适合表示符号。
中文不适合“符号”这种表达方式。
再来看命名。
这个看项目。
以前做过一个工程车辆的销售项目,他们有n多表格,表格都要做到数据库里面。
那么字段名就直接用表格里的名字好了。
(有点表格是中文,有点表格是英文,有的表格是中英文双语的。)
于是用英文还是中文,就是一件很自然的事情了,没必要强求,也没必要强推。

"case this object of" 在 Google Translate 里是『案此对象(为)』的意思。

我们所有有点英文语感的人都会觉得它是『判此对象为』,案『情况(case)』处理的意思。


难道存但仅存一点点语义上的关系就不叫关系?照这个逻辑类似 ES6 的 let { name: its_name } = obj; Python 的 ''.join([1,2,3]) 这样罕见的颠倒情况(很不好找,因为英文中文语序的确区别很大,英文时基本不会让人觉得和自然语言区别很大)本该再多加设计、等号也不该分长等号赋值和短等号判定了。


而 for (name in iterable) 这个算是直接对应了吧?为什么中文就不能用非『符号』的表达形式 对iterable里的name……?语言不是符号?


至于强推什么的,其实哪怕是之前 5kw 的易语言我也没见人迫害 521,『中文编程』一直以来都是很克制的。(当然,也是很少有人愿意观看的)


中文命名不需要驼峰命名: https://zhuanlan.zhihu.com/p/40098652

在有类型声明的代码中, 类型前缀并不建议使用. 一定要的话, 中文前缀照样可以.

连字符, 与驼峰同理.

看到的中文命名实例中, 命名风格大同小异. 母语同是中文, 用词风格趋同只是时间问题. 还是那句话, 路是走出来的, 规范更是实践中形成的.

是的,比如最经典的 "abc".startsWith("a"),要在中文的思维方式里自然地表达出来就得使用「以」这个介词来连接两个对象。

如果这一点设计好了(比如 Z语言的序列式函数应用,比如 "abc"以("a")始()),绝对是不需要驼峰英文分词的。

否则的话 "abc".以始("a")或者好一点,"abc".开头为("a") 这种,那只能说是暴殄天物了,好歹也是所谓『夜鬼哭』的汉字啊。


命名规范怎么考虑中文呀。
中文没有大小写,那么什么驼峰了啥的完全用不上。
类型前缀(比如intAge)也没法弄前缀。
vue里面的连字符,比如v-if,my-form,的-也,对于中文来说这个减号也没用。
总之,基本没法用。

>v-if,my-form


那个 '-' 不叫减号,这里是破折号(dash)的意思,详情 Scheme 命名风格。

比如:

scheme

(define (histogram vector-of-words)
(define hash (make-hash))
(for ([word (in-vector vector-of-words)])
(hash-set! hash word (add1 (hash-ref hash word 0))))
hash)


好吧,你开心就好。另外听过无代码吗?

无代码nocode 是一些 别有用心 的前端们的笑话,没有啥实际效用。


只要人活着就得吃饭,它试图否定目标的价值(比如,活着。)而没有任何理由,然后提醒你只要不活了就可以不吃饭,当然只是个笑话啊。


我赌五毛弄出这个项目的前端不知道 JSON 形式化文法是啥子。
引记法 绝句.符号 「与」
引记法 绝句.符号 「止」
引记法 绝句.符号 「步长」

量 人物类型 = 表一("唐僧"对"人"、"孙悟空"对"猴")
解对人物类型里的(人、型),说("$型 $人")。

“人 唐僧”
“猴 孙悟空”

量 人物 = 行一("唐僧"、"孙悟空"、"猪八戒"、"沙僧")
解对人物与索引里的(人、引),说("$引 $人")。 “记法「与」的事 与索引……”

“0 唐僧”
“1 孙悟空”
“2 猪八戒”
“3 沙僧”

量 问题 = 行一("名字"、"追求"、"喜爱颜色")
量 答案 = 行一("玄奘"、"真经"、空)

解对问题与(答案)里的(问物、回复), “对何<另项>皆有事 「与」(另:可迭<另项>:可迭<元二<项、另项>>)”
说("你的${问物}是什么?答曰,${回复}")

对零止10步长2里的,说(它)。


“with open(file) as f: f.close()”
尝试文件(径)去开启()成书,书去写文("emmm")。
接迎打开失败不常,告警("emmmmm: $径")。
“终焉,书去关闭()。”

对何<项> 项:有序<项> 皆有
事 冒泡排序(动片:动切片<项>) 为
对动片的索引里的『某针』,
对(某针后..动片的末引)里的『此试』,
若动片[此试]小动片[某针],动片去交换(此试、某针)。
对何<项>皆有
扩物 动切片<项> 为
事 交换(甲:引数、乙:引数) 为
我[甲] = 我[乙];我[乙] = 老甲
其中,
量 老甲 = 我[甲]


例 『某易语言而不是易飞扬程序』: 应用程序() “还有『带参应用程序』” 为
实现的事 入口() 为
量 a = 听去数一()
量 b = 听去数一()
若a大b,交换(a、b)。“假设这是1.0,绝句有存储抽象”
a定「不大b」
说("$a $b") “绝句可没有啥『调试说』”
回效果 “当然是不必显式写出来的”

def 妖精(能耐, 名字='白骨精', 降服者='孙悟空', 原形='骷髅'):
print("尽管善于" + 能耐 + ", "
+ 名字 + "仍被" + 降服者 + "制服,"
+ " 变回" + 原形)

事 说妖精(妖精:文、原型:文、能耐:文、降服者:文) 为
说("尽管善于${能耐},${妖精名}仍被${降服者}制服,变回${原型}")
例 西游记: 应用程序() 为
实现的事 入口() = 说妖精("白骨精"、"白骨"、能耐="变化"、降服者="孙悟空")
“绝句暂时不打算支持 partial application”
量 说白骨精:(文)效果 = 函数,〖能耐〗说妖精("白骨精"、"白骨"、能耐、降服者="孙悟空")。

看来设计类型推导方法是个苦差事啊,学术派一点要用 unification 归一化,而且逻辑式 miniKanren 好像不也是用 unification state&goals?
看来多态推导有点麻烦…… 大概还是写的出吧。

“Java:”
“if (true) { System.out.println("OK"); }”
“「易」语言:”
“如果 真 那么打印"OK"结束如果”
若真,说("OK")。
若组件[i]之为已创建,组件[i]去销毁()。
若你组件[i]之为已创建,你去销毁()。 -- 不能这样!改回

“我这时觉得绝句真的是美得像天使一样,干净利落不带空白,和没有逗号表示法的语言比。”

记法,是绝句里为了拟自然语言加入的自定义介词。
一般来讲,它的处理过程不必多加空格,所以词法类似+-*/等符号,必须在标识符读取过程里时刻检查,往往会用动态 Trie 树进行这种解析。

定记法 「问」
引记法 绝句.额联 藏「对」
引记法 绝句.额联 藏「+」 “尽管这可能是绝句语法上的华点之一,它们不特殊、所有和语法结构无关的东西(那些东西一般都是全角或中文词)都不特殊。”



包 绝句.标量
定记法「+」
定记法「-」
“……”

物『数』 为
“……”
【内建】【名字合法化】待例、记法「+」的事『+』(另:数):数
“这时,尽管+已经是一种记法,它依然可以被『』括住作为名字的一部分甚至全部,而在符号解析过程中这是有效的。”
“『』形式的名字不被称为合法化,只是叫『角括号名字』而已,合法化的意思是即便它对目标语言不合法,也自动mangle这个name而不是报错。”


但是以上好像是在朝着Scala的方向走,原因仅仅是为了支持标准库怎么这么地(而且大家都不知道『数』是不是该在标准库定义一个),实在是必须多想想。
而且这样,「算符」这个修饰,还有1去加(2)这种用法就泡汤了,运算符优先级实现也本不是记法会考虑的事情,那如何呢……

定义基于中缀记法的事(当然必须是中缀单参数的方法「」啊,噢不,介于「之为」这样的记法导致的问题它也可以记「量」)时候,可以选择:
记法「之」的事 之存一(条件:命题<项>):真假
其中『之存一』这个函数名必须以中缀字面开头。或者,
记法「对」的事 对(另:项):元二<项、项>
绝句里,「~上」这种后缀记法只允许使用「的」访问的属性使用。
记法「~上」的量 上面:位置

绝句没有Kolin的infix关键字,就是因为它用的是不必加空格的记法系统,虽然这个方式的结合性、优先级也基本是没改。

解析的结果是记法(也就是「的」「去」的替换符)的字面形式(比如他对她他上里,「对」和后缀的「~上」)
基本可以说是等价 他去对(她)他的上
语言类型分析过后,就有机会找到前表达式base对应的记法定义,进行进一步的处理。

记法访问(左表达式、记法名、右表达式)
“print("吃了么")”
说("吃了么")

“// 简单值部分”

“var 某变量 = 42
某变量 = 50”
变数 某变量 = 42
某变量 = 50
变参 k:数 = 1 “type inference is supported”

“let 某常量 = 42”
常数 某常量 = 42 “只能在文件作用域或「例」作用域声明和定义”

“let 隐式整数 = 70
let 隐式小数 = 70.0
let 显式小数: Double = 70”
量 隐式整数 = 七十
量 隐式小数 = 70.0
量 显式小数:实数 = 70.0 “小数点不能去!”

“let 标签 = "宽度为"
let 宽度 = 94
let 宽度标签 = 标签 + String(宽度)”
量 标签 = "宽度为"
量 宽度 = 94
量 宽度标签 = 标签去接(宽度去化文())

“let 苹果 = 3
let 桔子 = 5
let 苹果小结 = "我有\(苹果)个苹果."
let 水果小结 = "我有\(苹果 + 桔子)个水果." ”
解量 (苹果、桔子) = 元二(3、5)
量苹果小结="我有${苹果}个苹果"
量水果小结="我有${苹果+桔子}个水果"

“let 引用 = """
我说"我有\(苹果)个苹果."
我又说"我有\(苹果 + 桔子)个水果."
""" ”
量 引用 = """ 为
我说"我有${苹果}个苹果."
我又说"我有${苹果 + 桔子}个水果."

“var 购物单 = ["鱼", "水", "花"]
购物单[1] = "瓶水" ”
量购物单=动行一("鱼"、"水"、"花")
购物单[1] = "瓶水"

“var 职位 = [
"小二": "船长",
"小王": "机械师",
]
职位["小刘"] = "公关" ”
量 职位 = 动表一("小二"对"船长"、"小王"对"机械师")
职位["小王"] = "公关"

“购物单.append("颜料")
print(购物单)”
购物单去加入("颜料")
说(购物单)

“let 空数组 = [String]()
let 空字典 = [String: Float]()”
量 空数组 = 组<文>(0),“初始化器为”不可能。
量 空字典 = 表<文>(初始大小=0)。

“购物单 = []”
购物单=动行空()
“职位 = [:]”
职位=动表空()

“// 控制流部分”

“let 个人得分 = [75, 43, 103, 87, 12]
var 队得分 = 0
for 得分 in 个人得分 {
if 得分 > 50 {
队得分 += 3
} else {
队得分 += 1
}
}
print(队得分)”
量 人得分 = 行一(75、43、103、87、12)
变数 队得分 = 0
对人得分里的分数,
判存分数,
于0..50,队得分=队得分+1。
否则,队得分=队得分+3。 “这是假设绝句还没到第一个正式版的时候,没有存储抽象”
“有的话:队得分令置为「它后」“只是说可以这么写”、队得分令置为「+3」”

“var 可缺字符串: String? = "Hello"
print(可缺字符串 == nil)”
量 可缺字符串:文? = "Hello"
说(可缺字符串是空)

“var 可缺名字: String? = "鸟布拉斯基"
var 问好 = "吃了么!"
if let 名字 = 可缺名字 {
问好 = "吃了么, \(名字)"
}”
变文? 可缺名字 = "鸟布拉斯基"
变文 问候 = "吃了么!"
可缺名字? 令为,
问候 = "吃了么,$名字?"
“可见绝句要好好考虑一下这个标识符允许什么东西的问题,我的建议是:”
“(1) 参考Kotlin,因为Java/Kotlin 都不允许Unicode中符号的部分字符作为标识符成分,比如'?'。”
“(2) 针对全角半角的常见中文和程序设计语言文法符号,令解析器创建有针对性的镇静解析容错策略。”

“let 绰号: String? = nil
let 全名: String = "鸟布拉斯基"
let 打招呼 = "你好\(绰号 ?? 全名)"”
量 绰号:文? = 空
量 全名:文 = "鸟布拉斯基"
量 招呼 = "你好${绰号空则全名}"

“let 蔬菜 = "红椒"
switch 蔬菜 {
case "西芹":
print("纤维素高")
case "黄瓜", "胡萝卜":
print("干啃不错")
case let x where x.hasSuffix("椒"):
print("\(x)辣么?")
default:
print("炖汤里都行")
}”
引记法 绝句.符号 「以」
引记法 绝句.数据.文 「~终」

量 蔬菜 = "甜椒"
量 建议 = 判蔬菜,
"西芹","纤维素高"。
"黄瓜"、"胡萝卜","干啃不错"。
“它以("椒")终……” “这也是可选的。”
否则,
若蔬菜以("椒")终,"${蔬菜}辣么?"。
否则,"炖汤里都行"。
“这是绝句的带宾语判断(subjective when),中缀链表示法也是可以使用的,不过要在前面加上「它」以与值判断区分。”

判断,
蔬菜是"西芹",说("纤维素高")。
蔬菜是"黄瓜"、蔬菜是"胡萝卜",说("干啃不错")。
上皆,说(“那些是正常情况hhh”)。
“when语句不需要exhaustive也不需要有「否则」”

“顺便说一句,如果每一个 when branch 都是常量,最好还是用 `表一("A"对1、"B"对2)` 吧”
“可见,第三人称形式需要我们好好考虑何处该有,何处不该有。词法作用域技术上还是没问题的。”
“绝句不能学着类似Scala、Swift、Ruby一样什么都抄它们的,就随机判断而言我很不支持那种模式匹配做法,Haskell也不支持(这里,「随机」的机是当机立断的机)”
“这就是我说的「90%」以外的极端情况,为什么判断要有顺序?
判断、判x、判属、判存这些都是无序的,
允许 where x.hasSuffix() 就可能引入了副作用,这是不规范的。”
“相比之下,一般而言绝句的「」中缀记法的实现(和「算符」是不同的,算符是『元方法』)都不会有副作用,所以是相对一致的。”
#security 忍不住让我想到了以前的 war dial-up 攻击。
Forwarded from Albert News | 您可能感兴趣的内容 (Albert Xu)
Facebook Messenger is removing the ability to find someone by entering their phone number

Facebook Messenger正在删除通过输入其电话号码来查找某人的功能

来源:
https://twitter.com/wongmjane/status/1210864489358184448
翻译成中文就是
量 userProfile:AlipayProfile
@GetMapping @RequireRoles("consumer") 取者,
回 currentUser 令为(alipayUserService去::getProfile)
?去令为(::AlipayProfileData)
空则,抛下BusinessEx("unexpected_exception") 。
接着翻译就是
量 用户资料:支付宝资料传输 【身份要求 "消费者"】
【GET路径】的取者,
回 当前用户令为(支付宝用户服务去::取资料)?
去令为(::支付宝资料传输)
空则,抛下BusinessEx("unexpected_exception")。
Forwarded from dnaugsuz
所以说这样的无参 getter 就得用 val 的形式写了……虽然好像 Kotlin 的 annotation 无法把 getter 作为方法 annote?

val userProfile: AlipayProfile
@GetMapping @RequireRoles("consumer") get() {
return currentUser.let(alipayUserService::getProfile)
?.let(::AlipayProfileData)
?: throw BusinessEx("unexpected_exception")
}
duangsuse::Echo
“print("吃了么")” 说("吃了么") “// 简单值部分” “var 某变量 = 42 某变量 = 50” 变数 某变量 = 42 某变量 = 50 变参 k:数 = 1 “type inference is supported” “let 某常量 = 42” 常数 某常量 = 42 “只能在文件作用域或「例」作用域声明和定义” “let 隐式整数 = 70 let 隐式小数 = 70.0 let 显式小数: Double = 70” 量 隐式整数 = 七十 量 隐式小数 = 70.0 量…
“let 有趣的数 = [
"质数": [2, 3, 5, 7, 11, 13],
"斐波那契": [1, 1, 2, 3, 5, 8],
"平方": [1, 4, 9, 16, 25],
]”
量 有趣的数们 = 表一(
"质数"对 行一(2、3、5、7、11、13)、
"Fibo"对 行一(1、1、2、3、5、8)、
"平方"对 行一(1、4、9、16、25) ) “但这不是绝句一般的风格”

量『有趣的数们 一般风格』:表<文、行<数>> = 动表一() 顺便, “我觉得强行合法化规则还是和Kotlin一样吧”
它加入("质数"对 行一(2、3、5、7、11、13))
它加入("Fibo"对 行一(1、1、2、3、5、8))
它加入("平方"对 行一(1、4、9、16、25))
“好吧,这更不是一般风格……”

“var 最大 = 0
for (种类, 数) in 有趣的数 {
for 某数 in 数 {
if 某数 > 最大 {
最大 = 某数
}
}
}
print(最大)”
变数 最大 = 零 “皮一下”
解对『有趣的数们』里的(_种、数们),
对数们里的此数,
若此数大『最大』,最大 = 此数。
“若此数是最大,什么都不做。”
“所以说逻辑推导也是类型检查(会是这样)或者lint的时候必须的啊,还得考虑什么多线程,这又是一个难点”
“不过绝句应该好像可以加『语者』来允许 variable 的 smart cast、判定 exhaustive 什么的?”
“ ‘!语者 单线程逻辑’ ”

“var 翻番 = 2
while 翻番 < 100 {
翻番 *= 2
}
print(翻番)”
变数 『二翻番』 = 2
重复若『二翻番』小一百, “不良实践呢”
翻番令置为「*2」 “刻意用正式版的特性,以显得绝句的『高明』之处。”
“这个「」呢你可以理解为函数调用里另一个类似逗号的东西,不需要额外加括号才能调用了,不过它们也不可能作为值单独出现。”
“当然,绝句的记法(自定义中后缀)也是利用了这种括号的,不过个属于定义的就不一样了。最大的区别是调用的「」可以进行中后连缀、「定记法」和「记法的」很死。”

“var 也翻 = 2
repeat {
也翻 *= 2
} while 也翻 < 100
print(也翻)”
引记法 绝句.符号 「止」 “本来实现是在 绝句.区间.数步进 的,许多绝句的符号哪怕是「~前」「~后」都必须先「引记法」才能用,除非很内部的比如+-*/、且或非”

说((2止100)的末项)

变数 也翻=2
重复,也翻 = 也翻*2。若也翻小100; “加「;」皮一下”

“看,这里「重复……若…」里「若」的布局深度,就是父层的深度。一个「若」只能对应上一个「重复」”
“上一个也可以优雅地写进一行内,哪怕是包含多条语句也一样,这是逗号表示法最突出的一个优点。”

重复,
也翻 = 也翻*2
若也翻小100
说(也翻)

“var 总和 = 0
for i in 0..<4 {
总和 += i
}
print(总和)”
“看到这里的 0..<4,我突然觉得 Apple 的 Swift 设计得真是不考虑简单性…… 那么多特化的语法,却远远不如 Kotlin 的 a..b 和 a until b 好学、优雅”

变数 总和 = 0
对0止4里的i,总和令置为「+i」。 “再用一次正式版的特性,嘲讽一下 Swift。”
说(总和)

“// 函数和闭包”

“func 问好(人: String, 日子: String) -> String {
return "吃了么\(人), 今天是\(日子)." //“你看看这个语序不当的,表意语而不是上下文放前边。”
}
问好(人: "小白", 日子: "周二")”

“好吧,name: Type、name: Value of Type 算这个还能看得的。”

事 问好(人:文、日子:文):文 为
回"($日子)吃了么$人?"
事 问好1(人:文、日子:文) = "($日子)吃了么$人?" “传统Kotlin简化定义方式,还能返回类型推导”

问好(人="江小白"、日子="星期二") “代名调用,这样可以尽可能大的利用默认参数,规则和Kotlin一致同时只能使用带名不带名之一。”

“Kotlin fun a(x:Int=2, y:Int)=x”
“a(1) 会认为只是提供了 x 的参数,而绝句认为,形式参数跟在可选参数后是没有意义的,因为它的意义基本都可以等价代换到后面,而利用具名调用和不具名方式切分传参顺序相当令人困惑,所以类似C++地,不允许这种写法。”
“只解决不得不解决的问题(比如调用参数的模板化),不把解决方案本身做成一种问题。”

例物 星期(“公开的”量 号:文) 为 “很多东西默认都是公开的,而不是莫名其妙写一大堆public,这是鼓励大家把私下的逻辑写精炼一点。”
第一("一")、第二("二")、第三("三")、
第四("四")、第五("五")、第六("六")、
第七("日")
“本身有 name(名字)、ordinal(序号)”
“伴生例里有 values(取值)、valueOf(String)(值于)”

“func 问好(_ 人: String, 在 日子: String) -> String {
return "吃了么\(人), 今天是\(日子)."
}
问好("小黑", 在: "周三")”

“按照上面的说法,『绝句』绝不会在这种无聊的地方下功夫,为了解决一个不该存在的问题让代码更不和谐、更难理解。”
“绝句利用「记法」「内联的物」「扩物」完全有能力实现 `在("周三")向("小黑")去问好()` 这种形式且有能力进行『语序变动』的DSL,但它默认不那么做,难道这不比keyword arguments「高级」?只是不想给别人制造写出问题代码的可能性而已。”

“参数列表的特性上下功夫,甚至最后跪舔『脚本语言』Python式的弄,不如好好斟酌一下标准库怎么设计好。”

“func 统计(得分: [Int]) -> (最小: Int, 最大: Int, 总和: Int) {
var 最小 = 得分[0]
var 最大 = 得分[0]
var 总和 = 0

for 分 in 得分 {
if 分 > 最大 {
最大 = 分
} else if 分 < 最小 {
最小 = 分
}
总和 += 分
}

return (最小, 最大, 总和)
}
let 结果 = 统计(得分: [5, 3, 100, 3, 9])
print(结果.总和)
print(结果.2)”

“绝句里单引号是文档,可以在工具里看到。”
“一个类/物的类型参数可以直接加入文档,参数和返回值的文档可以直接加在前面也可以独立加”
“和Kotlin,也是Markdown的”
事 统计(得分:组<数>):‘最小、最大、总和’ 元三<数、数、数> 为
对得分里的分,
判分, “一时间我也找不到更好的方法把「对」和「判」连在一起”
它大最大,最大 = 它。 “「它」是此分支局部的”
它小最小,最小 = 它。
上皆,总和令置为「+分」。
回元三(最小、最大、总和)
这里,
变数 最小 初0;变数 最大 初0;变数 总和 初0 “不是一般的编程风格,但不置可否。”
“这个版本里,暂时我不会把对「变(属)(名)初(言)」的修改加上,请兼容前面的一部分。”

“func 返回十五() -> Int {
var y = 10
func 加() {
y += 5
}
加()
return y
}
返回十五()”
duangsuse::Echo
“print("吃了么")” 说("吃了么") “// 简单值部分” “var 某变量 = 42 某变量 = 50” 变数 某变量 = 42 某变量 = 50 变参 k:数 = 1 “type inference is supported” “let 某常量 = 42” 常数 某常量 = 42 “只能在文件作用域或「例」作用域声明和定义” “let 隐式整数 = 70 let 隐式小数 = 70.0 let 显式小数: Double = 70” 量 隐式整数 = 七十 量 隐式小数 = 70.0 量…
以前我偶尔以『艺术品』的心态想到『用中文写程序』,把中文看得比编程重,结果写出来的东西不像中文更不能编程。

现在我多学习了几门『不常见』的编程语言,Haskell、Scala、Kotlin,结果写出来的东西不仅符合编程逻辑而且像中文,这真是奇怪啊。

如果你连文字都不会敲、逗号顿号傻傻分不清,是设计不出『中文编程语言』的,这一点不必多说吧。
duangsuse::Echo
😏 Sticker
FONT = Font.FreeTypeFont.read('/usr/...')
(BASE_X, FIXED_Y) = (..., ...)
def compositeText(s):
img = Image.open('panda.png')
(txtW, txtH) = FONT.getSize(s)
txtWd2 = txtW/2 #atom layout calc (width-balance)
img.draw_text(x=(BASE_X-txtWd2), y=FIXED_Y, font=FONT, text=s)
return img #effect
def main():
for text in input().split(" "):
img = compositeText(text)
img.save(f'panda_{text}.png')


别测试,我说着玩的,没看见我没写导入吗? 😂
其实我把 Binarie 的类图都画好了,难点也的 swapIntegral, fromIntegral, toIntegral 也整理到 Convert.kt 里了,可就是没时间实现了,算。
其实 ParserKt 也一样,我完全建模好了 Input 和 Parser(以及 PredicateParser:AtomParser, ReduceParser, Seq, Repeat、OrParser) 架构,可就是没时间实现…… 也是天注定吧。