🤔 我又考虑了下绝句的语言特性
语言层次:常量(literal)、言元(atom expression)、言(expression)、句(statement)、段(block)、构(item)、书(file)
面向对象构件:常(const val)、变(var)、量(val) 取者(getter) 置者(setter)、事(fun)、造于(constructor) 初(init)、例(object)、物(class) 伴生例(companion object)、类(interface)
特化物:扩物、内物(inner class)、储物(data class)、例物(enum class)、况物(sealed class)、标物(annotation class)、抽象物(abstract class)
预定义引用:亲(super)、我(this)、你、它
预定义常量:真、假、空
类型系统:函数重载、子类型多态、参数化多态、入/出 生产消费型变性声明、交集上界限制、可空性、『我属』预定义类型变量
语言特性:面向对象编程、构件可见性、函数及属性扩展、闭包、多态、操作符重载、Annotation
可见性:公开、族内、私下、内部
外部定义:待例、实际
标记:【(类型) {(名=)? (常量/常量组)}、】
函数及属性修饰:抽象、实现、内联、记法 「(记法)」
函数修饰:算符、尾递归
参数修饰:许多、跨嵌、不嵌
变参修饰:晚成
类型参数修饰:实化、入、出
— 定义
包(复合名)为
引(复合名) [的(名)].[成(名)]
引全(复合名) [的].[除(名或行)]
常(类型).(名)=(常量)
属别名(名)=(类型)
对何<(类型形参)> [其中 {(类型参数):(类型)}、] 皆有
事 (名)"(" (形参) ")" 为 …其中块
事 (名)"(" (形参) ")" = (言) …其中块
其中块
其中,{局部定义}
局部定义
(量/变参/事)
顶部定义
(局部定义/常参/例/物/类)
文件
Shell行? 包? {引记法}? {引入}? {文件标记}? {属别名}? {顶部定义}?
注意这里那个 (类型) 啊不是说这个在解析器里就检查,这里 (类型) 全都视为 (复合名)。
— 缩进和文法布局
类似「事」「例」「物」「类」的定义构件,都是使用「为」来限定起止部分的。
绝句里有两个形式开启新布局:「,」及「为」
新布局由它们开启,小于后随布局空格数的缩进结束。
绝句里有可以换行的语法形式:
(缩进)要求比当前布局宽:参数切分「、」和「。」
要求持平当前布局:「;」
— 记法(自定义中及后缀)
引记法(复合名) 「(记法)」
引记法(复合名).除 「(记法)」
定记法 「(记法)」
记法可以包含任何名字本身可以包含的部分,以及符号、数学符号区段的字符。
带
— 基本控制流
—— 变量
量(名)[:(类型)]=(言)
量 提(模式)=(言)
变(类型).(名) [初(言)]
变参(名)[:(类型)] [初(言)]
—— 判断
若(你?) (言)…… [ 否则…… ] (第二人称)
判断,{ (言或列)…… } [ 否则…… ]
判(你?) (言),{ (言或列)…… } [ 否则…… ] (第二人称)
判(你?) (言)属,{ 于(类型或列)…… } [ 否则…… ] (第二人称)
判(你?) (言)存,{ 于(言或列)…… } [ 否则…… ] (第二人称)
—— 重复
对(言)里的(名)……
对(言)里的 提(模式)……
对(言)里的 你…… (第二人称)
对(言)里的…… (第三人称)
重复 若(言)……
重复…… 若(言)。
—— 返回
回(标签?) (言?)
回 交(言)
回 重写(参数列表)
—— 跳转
停下(标签?)
略过(标签?)
— 结构化异常
尝试…… { 接迎(类型)…… } [ 终焉…… ] (第三人称)
抛下(言)
— 中缀链
「它 (记法及的链)」 (第三人称)
例:「它的名字+1」、「它前」
记法包括中缀记法如「以」和后缀记法「~上面」「~为零」
中及后缀记法有否定修饰,如「是」前跟“不”构成「不是」、「为零」前跟“不”构成「不为零」
「」形式可以在需要函数的地方被提供。
— 中缀简记
你(言) {(且/或) 记法链} (第二人称)
— 逗号表示法
逗号表示法可以用于「若」「判断」这样结构「段」的表达,也可以用于创建闭包。
逗号表示法有两种形式,逗号布局、逗顿句简写。
如果用于闭包则还有一种指定闭包参数的扩展。
— 可空性
(~)? // 空访问
(~)!! // 非空断言
(~)空则(言)
(~)空则……
— 访问语法
(~)的(名)
(~)去(名)(参数列表)
(~)去::(名)
(~)"["(言)"]"
(~)(参数列表)
::(名)
— 前缀
非(言)
— 连接词
且 // (&&)
或 // (||)
是 // (==) 试等
即是 // (===)
存于 // (in) 试含
.. // (..) 取至
(~)属于(类型) // (is)
(~)作成(类型) // (as)
(~)试成(类型) // (as?)
— 数学计算
+ // 加
- // 减
* // 乘
/ // 除
— 标签
「事」及逗号闭包的接收者会引入隐式标签
「对」「重复」后可以在后面加
逗号闭包可以用
— 常量
真假 Boolean
数 Int、长数 Long
— 符号 (+/-)?、后缀 (L/l)?
— 支持 0x 0b 表示法
— 支持汉字数
短浮 Float、浮 Double
— 支持 (+/-)? (E/e)? exponents
— 后缀 (F/f)?
字 Char
文 String
— 支持
— 支持
— 支持
名(标识符)
换 Kotlin 的
注释
— 支持可嵌套
— 保留构词
模板、类实例、性质推导
— 一些非语法细节
to ~ 到;upTo ~ 至;until ~ 止
语言层次:常量(literal)、言元(atom expression)、言(expression)、句(statement)、段(block)、构(item)、书(file)
面向对象构件:常(const val)、变(var)、量(val) 取者(getter) 置者(setter)、事(fun)、造于(constructor) 初(init)、例(object)、物(class) 伴生例(companion object)、类(interface)
特化物:扩物、内物(inner class)、储物(data class)、例物(enum class)、况物(sealed class)、标物(annotation class)、抽象物(abstract class)
预定义引用:亲(super)、我(this)、你、它
预定义常量:真、假、空
类型系统:函数重载、子类型多态、参数化多态、入/出 生产消费型变性声明、交集上界限制、可空性、『我属』预定义类型变量
语言特性:面向对象编程、构件可见性、函数及属性扩展、闭包、多态、操作符重载、Annotation
可见性:公开、族内、私下、内部
外部定义:待例、实际
标记:【(类型) {(名=)? (常量/常量组)}、】
函数及属性修饰:抽象、实现、内联、记法 「(记法)」
函数修饰:算符、尾递归
参数修饰:许多、跨嵌、不嵌
变参修饰:晚成
类型参数修饰:实化、入、出
— 定义
包(复合名)为
引(复合名) [的(名)].[成(名)]
引全(复合名) [的].[除(名或行)]
常(类型).(名)=(常量)
属别名(名)=(类型)
对何<(类型形参)> [其中 {(类型参数):(类型)}、] 皆有
事 (名)"(" (形参) ")" 为 …其中块
事 (名)"(" (形参) ")" = (言) …其中块
其中块
其中,{局部定义}
局部定义
(量/变参/事)
顶部定义
(局部定义/常参/例/物/类)
文件
Shell行? 包? {引记法}? {引入}? {文件标记}? {属别名}? {顶部定义}?
注意这里那个 (类型) 啊不是说这个在解析器里就检查,这里 (类型) 全都视为 (复合名)。
— 缩进和文法布局
类似「事」「例」「物」「类」的定义构件,都是使用「为」来限定起止部分的。
绝句里有两个形式开启新布局:「,」及「为」
新布局由它们开启,小于后随布局空格数的缩进结束。
绝句里有可以换行的语法形式:
(缩进)要求比当前布局宽:参数切分「、」和「。」
要求持平当前布局:「;」
— 记法(自定义中及后缀)
引记法(复合名) 「(记法)」
引记法(复合名).除 「(记法)」
定记法 「(记法)」
记法可以包含任何名字本身可以包含的部分,以及符号、数学符号区段的字符。
带
'~' 前缀的记法是后缀记法— 基本控制流
—— 变量
量(名)[:(类型)]=(言)
量 提(模式)=(言)
变(类型).(名) [初(言)]
若(你?) (言)…… [ 否则…… ] (第二人称)
判断,{ (言或列)…… } [ 否则…… ]
判(你?) (言),{ (言或列)…… } [ 否则…… ] (第二人称)
判(你?) (言)属,{ 于(类型或列)…… } [ 否则…… ] (第二人称)
判(你?) (言)存,{ 于(言或列)…… } [ 否则…… ] (第二人称)
—— 重复
对(言)里的(名)……
对(言)里的 提(模式)……
对(言)里的 你…… (第二人称)
对(言)里的…… (第三人称)
重复 若(言)……
重复…… 若(言)。
—— 返回
回(标签?) (言?)
回 交(言)
回 重写(参数列表)
—— 跳转
停下(标签?)
略过(标签?)
— 结构化异常
尝试…… { 接迎(类型)…… } [ 终焉…… ] (第三人称)
抛下(言)
— 中缀链
「它 (记法及的链)」 (第三人称)
例:「它的名字+1」、「它前」
记法包括中缀记法如「以」和后缀记法「~上面」「~为零」
中及后缀记法有否定修饰,如「是」前跟“不”构成「不是」、「为零」前跟“不”构成「不为零」
「」形式可以在需要函数的地方被提供。
— 中缀简记
你(言) {(且/或) 记法链} (第二人称)
— 逗号表示法
逗号表示法可以用于「若」「判断」这样结构「段」的表达,也可以用于创建闭包。
逗号表示法有两种形式,逗号布局、逗顿句简写。
若此人的名字是"林则徐",这是逗号布局。
说("苟利国家生死以")
若此人的名字是"林则徐",说("民族大义")、说("苟利国家生死以")。
这是逗顿句简写。如果用于闭包则还有一种指定闭包参数的扩展。
人们 映为,〖他〗他的名字。
人们 映为,〖他〗
他的名字
— 可空性
(~)? // 空访问
(~)!! // 非空断言
(~)空则(言)
(~)空则……
— 访问语法
(~)的(名)
(~)去(名)(参数列表)
(~)去::(名)
(~)"["(言)"]"
(~)(参数列表)
::(名)
— 前缀
非(言)
— 连接词
且 // (&&)
或 // (||)
是 // (==) 试等
即是 // (===)
存于 // (in) 试含
.. // (..) 取至
(~)属于(类型) // (is)
(~)作成(类型) // (as)
(~)试成(类型) // (as?)
— 数学计算
+ // 加
- // 减
* // 乘
/ // 除
— 标签
「事」及逗号闭包的接收者会引入隐式标签
「对」「重复」后可以在后面加
[] 引入标签逗号闭包可以用
,[label] 引入标签— 常量
真假 Boolean
数 Int、长数 Long
— 符号 (+/-)?、后缀 (L/l)?
— 支持 0x 0b 表示法
— 支持汉字数
短浮 Float、浮 Double
— 支持 (+/-)? (E/e)? exponents
— 后缀 (F/f)?
字 Char
文 String
— 支持
\"\'\t\b\n\r\$\\ escape— 支持
$(名) 和 ${(言)} 嵌入— 支持
""" """ 跨行文本名(标识符)
换 Kotlin 的
`` 成 『』注释
— 支持可嵌套
“” 全角双引号,‘’ 不可用— 保留构词
模板、类实例、性质推导
— 一些非语法细节
to ~ 到;upTo ~ 至;until ~ 止
/tmp/duangsuse.sock
🤔 我又考虑了下绝句的语言特性 语言层次:常量(literal)、言元(atom expression)、言(expression)、句(statement)、段(block)、构(item)、书(file) 面向对象构件:常(const val)、变(var)、量(val) 取者(getter) 置者(setter)、事(fun)、造于(constructor) 初(init)、例(object)、物(class) 伴生例(companion object)、类(interface) 特化物:扩物、内物(inner…
今天上午,我想了一些语言实现的细节。
1. 绝句的一些语法大体上是那样,但偶尔会有『插入模式』的修改,怎么做这一部分的代码复用
比如,绝句的逗号表示法偶尔会有带 [] 标签的版本和 〖〗 参数的版本、enum class 的布局也要允许在顿号后换行,怎么在兼容这样情况同时进行解析器的代码复用
2. 我说「回」「抛下」「停下」不是表达式,那么
况且绝句的逗号表示法的逗顿句简写,基本上可以认为是等同 Kotlin 的 {} brace block,那么它是否可以有值?是不是应该分出单句和多句的情况?
3. 关于语法实现难点——「,」「为」布局的细节定义和实现方法。
新布局由「,」及「为」开启,小于后随布局空格数的缩进结束,就是不知道哪里可以换行
一般的实现认为缩进 GT 即为「一行内」、EQ 即为「断行」、LT 即为「块结束」,我不打算支持。
🤔我刚才考虑了一下 enum class 的例子,EQ 和 GT 的区分容易导致一些滥用的表达
可是如果用
不过我觉得还是标准化一下比较好,这样吧,参数列表里的顿号也可以开启布局?
……算了还是支持原判吧,缩进比当前布局宽就是「一行内」,顿号后面可以换行。
但目前的解析器方案是 scannerless parsing,我们没有一个分词的阶段来刻意读取判断布局状态
顿号后只能是比当前布局宽的缩进,窄了的话不可以,一个逗号块和「为」块的断句方案也一样,也就是说我们的规则更严格一些,更容易死。
——记法的实现
记法就是自定义中缀、后缀运算符,并且这是不需要空格切分的,它必须动态修改『名』名字的语法以准确分词。
记法的分词,可以用字典树 walk,但我还不太会写那个
动态运算符优先级是比较简单的
1. 绝句的一些语法大体上是那样,但偶尔会有『插入模式』的修改,怎么做这一部分的代码复用
比如,绝句的逗号表示法偶尔会有带 [] 标签的版本和 〖〗 参数的版本、enum class 的布局也要允许在顿号后换行,怎么在兼容这样情况同时进行解析器的代码复用
2. 我说「回」「抛下」「停下」不是表达式,那么
空则,回。 这样的类型检查怎么做?况且绝句的逗号表示法的逗顿句简写,基本上可以认为是等同 Kotlin 的 {} brace block,那么它是否可以有值?是不是应该分出单句和多句的情况?
3. 关于语法实现难点——「,」「为」布局的细节定义和实现方法。
新布局由「,」及「为」开启,小于后随布局空格数的缩进结束,就是不知道哪里可以换行
一般的实现认为缩进 GT 即为「一行内」、EQ 即为「断行」、LT 即为「块结束」,我不打算支持。
🤔我刚才考虑了一下 enum class 的例子,EQ 和 GT 的区分容易导致一些滥用的表达
可是如果用
行一() 来定义一个列表的话,好像不得不支持这种传统的缩进断行方法不过我觉得还是标准化一下比较好,这样吧,参数列表里的顿号也可以开启布局?
……算了还是支持原判吧,缩进比当前布局宽就是「一行内」,顿号后面可以换行。
但目前的解析器方案是 scannerless parsing,我们没有一个分词的阶段来刻意读取判断布局状态
顿号后只能是比当前布局宽的缩进,窄了的话不可以,一个逗号块和「为」块的断句方案也一样,也就是说我们的规则更严格一些,更容易死。
——记法的实现
记法就是自定义中缀、后缀运算符,并且这是不需要空格切分的,它必须动态修改『名』名字的语法以准确分词。
记法的分词,可以用字典树 walk,但我还不太会写那个
动态运算符优先级是比较简单的
secret base ~君がくれたもの~ (10 years after Ver.)
茅野愛衣, 戸松遥, 早見沙織
「secret base ~君がくれたもの~ (10 years after Ver.)」
茅野愛衣, 戸松遥, 早見沙織
茅野愛衣, 戸松遥, 早見沙織
Forwarded from ┗|∵|┓Hz ❁ HoneyWorks
YouTube
15 分鐘內,一次就搞懂「合成器」!(Synthesizer)
好和弦頻道沒有開啟 YouTube 廣告,因此我不會從 YouTube 這邊得到任何收入,如果你覺得好和弦的課程有幫助到你,請你考慮購買「家庭號大包裝」來支持好和弦,讓好和弦能夠繼續提供免費的教學給所有人!到以下的連結喔:
好和弦 220 集紀念版大大大大大大大大大大包裝:https://gum.co/NiceChordBigPack220
好和弦家庭號大包裝(中國大陸):http://www.upchord.cn/downloads/nicechord/
好和弦 Instagram:https://…
好和弦 220 集紀念版大大大大大大大大大大包裝:https://gum.co/NiceChordBigPack220
好和弦家庭號大包裝(中國大陸):http://www.upchord.cn/downloads/nicechord/
好和弦 Instagram:https://…
sin wave; triangle wave
square wave; saw wave
high pass filter; low pass filter
ADSR
square wave; saw wave
high pass filter; low pass filter
ADSR
Forwarded from 2019-nCoV疫情实时播报🅥
Forwarded from 每日消费电子观察 (Dave Lin)
B社官方微博发毁灭战士x辐射漫画提醒:不要吃蝙蝠
https://www.gamersky.com/news/202001/1259733.shtml
https://www.gamersky.com/news/202001/1259733.shtml
streams.iterate(1, [](x) -> x * 2)
.filter([](x) -> x > 100_000)
.skip(5)
.take_while([](x) -> x <= 5000_000)
.for_each(system.out.println)
生成序列自(1),2*它。
去滤出「它大十万」
去略过(5)
去取当「它不大五百万」
去对所有(::说)
……怎么办呢……
.filter([](x) -> x > 100_000)
.skip(5)
.take_while([](x) -> x <= 5000_000)
.for_each(system.out.println)
生成序列自(1),2*它。
去滤出「它大十万」
去略过(5)
去取当「它不大五百万」
去对所有(::说)
……怎么办呢……
/tmp/duangsuse.sock
今天上午,我想了一些语言实现的细节。 1. 绝句的一些语法大体上是那样,但偶尔会有『插入模式』的修改,怎么做这一部分的代码复用 比如,绝句的逗号表示法偶尔会有带 [] 标签的版本和 〖〗 参数的版本、enum class 的布局也要允许在顿号后换行,怎么在兼容这样情况同时进行解析器的代码复用 2. 我说「回」「抛下」「停下」不是表达式,那么 空则,回。 这样的类型检查怎么做? 况且绝句的逗号表示法的逗顿句简写,基本上可以认为是等同 Kotlin 的 {} brace block,那么它是否可以有值?…
1. 很简单啊,解析器不是可以动态用子程序组织的吗?只要添加对应的参数,就可以把结果放到
2.
是不可能支持的。逗顿句不能有值,如果是逗号块那也需要写
所以说,「空则」提供多句可以,但最后都必须是……
算了,那样要分开来写控制流分析和类型检查啊…… 我感觉回到了 C _Noreturn 的时代,好无趣的样子啊
我在考虑 还是回到 Kotlin 的那种处理方法,{} block 内(逗顿句)也允许
「若」的表达式形式也是
……是不是有点 太严格了
而且这样
就很冗长啊
看来单句和多句的情况 必须要区分了
这段代码就无效了,多句不能有值……
可是…… 这个区分感觉好莫名其妙啊
这么说,Kotlin 真的做对了?
break continue 如果要支持 if 表达式,就必须要提供?
{} 里面的最后一项本来就应该表达块本身的值?
SyntaxTuple 里2.
空则,回。 这个空则 当然是要求最后得到一个 Nothing 了(按 Kotlin 的思路),、。 逗顿句简记,如果是多句的情况并且需求处要一个值,为了保证顿号的语义没问题是不可能支持的。逗顿句不能有值,如果是逗号块那也需要写
回[令为] 什么的。所以说,「空则」提供多句可以,但最后都必须是……
算了,那样要分开来写控制流分析和类型检查啊…… 我感觉回到了 C _Noreturn 的时代,好无趣的样子啊
我在考虑 还是回到 Kotlin 的那种处理方法,{} block 内(逗顿句)也允许
return@ 好了行一(回、停下、继续) 又该怎么办呢……「若」的表达式形式也是
量 某物 = 若p,
回[某物] 1
否则,
回[某物] 2 ……是不是有点 太严格了
而且这样
说(若[话]p,回[话]"你好"。否则,回[话]"再见"。)
println(if (p) "你好" else "再见") 就很冗长啊
说(若p,回[说]"你好"。否则,回[说]"再见"。)这样又显得特殊处理太多,又是 block 调用的 receiver 又是量的名字、调用的函数名,还区分情况。
看来单句和多句的情况 必须要区分了
说(若p,"你好"。否则,"再见"。)这是单句的情况,逗号表示法本身可以有值。
说(若p,说("啊")、"你好"。否则,"再见"。)
这段代码就无效了,多句不能有值……
可是…… 这个区分感觉好莫名其妙啊
说(若p,某事情()、偏好的招呼用语。否则,"再见"。)
、a。 其实给人「a是值」的感觉呢这么说,Kotlin 真的做对了?
break continue 如果要支持 if 表达式,就必须要提供?
{} 里面的最后一项本来就应该表达块本身的值?
/tmp/duangsuse.sock
1. 很简单啊,解析器不是可以动态用子程序组织的吗?只要添加对应的参数,就可以把结果放到 SyntaxTuple 里 2. 空则,回。 这个空则 当然是要求最后得到一个 Nothing 了(按 Kotlin 的思路) ,、。 逗顿句简记,如果是多句的情况并且需求处要一个值,为了保证顿号的语义没问题 是不可能支持的。逗顿句不能有值,如果是逗号块那也需要写 回[令为] 什么的。 所以说,「空则」提供多句可以,但最后都必须是…… 算了,那样要分开来写控制流分析和类型检查啊…… 我感觉回到了 C _Noreturn…
这么说,我想了半天的那个「改进」又归为虚无了……
那么,「空则」也没有必要提供令外一种写法了……
那么,「空则」也没有必要提供令外一种写法了……
/tmp/duangsuse.sock
1. 很简单啊,解析器不是可以动态用子程序组织的吗?只要添加对应的参数,就可以把结果放到 SyntaxTuple 里 2. 空则,回。 这个空则 当然是要求最后得到一个 Nothing 了(按 Kotlin 的思路) ,、。 逗顿句简记,如果是多句的情况并且需求处要一个值,为了保证顿号的语义没问题 是不可能支持的。逗顿句不能有值,如果是逗号块那也需要写 回[令为] 什么的。 所以说,「空则」提供多句可以,但最后都必须是…… 算了,那样要分开来写控制流分析和类型检查啊…… 我感觉回到了 C _Noreturn…
我想到了一种好方法,可以解决 if 表达式的问题
再引入以个新「若」语法,就可以回归 Java 的老式风格了
可是这样实在是不好看啊……
再引入以个新「若」语法,就可以回归 Java 的老式风格了
说(若p"你好"否则"再见") 可是这样实在是不好看啊……
说(若a去试等(2)"你好"否则"再见")我终于知道三目运算符 ternary 为什么是
p? a : b 那样写了。Forwarded from Deleted Account
刚才提到了点传统的类型理论,小白肯定蒙蔽吧。
类型是值的集合,会以「a, b, c 值都属于 A 类型」形式描述。
1, 2, 3 都是 Int
1.0, 2.0, 3.0 都是 Double
所以你就可以
比如,Int 和 Double 的交集是 Number,
A 和 B 的并集(union) 在可以同时视为 A 及 B
比如,Int 和 Double 的并集可以是 Number 以及 Any 以及 Any?
刚才我说
Any? 的意思是除了 Any 原有的元素还可是
Kotlin 里那个
就是不让用
类型是值的集合,会以「a, b, c 值都属于 A 类型」形式描述。
1, 2, 3 都是 Int
1.0, 2.0, 3.0 都是 Double
fun Int.plus(other: Int): Int是一个操作,接受两个 Int(receiver 处的也算)返回一个 Int
所以你就可以
(1 + 1) + 2 这么用,因为 (1+1) 本身也是 Int
A 和 B 的交集(intersection) 在类型上,就是说一个兼容AB交集的操作,同时兼容 A 和 B 作为输入比如,Int 和 Double 的交集是 Number,
fun Number.toInt(): Int,可以视为两者兼有的操作A 和 B 的并集(union) 在可以同时视为 A 及 B
比如,Int 和 Double 的并集可以是 Number 以及 Any 以及 Any?
刚才我说
listOf(1, return): List<T> 其中用的操作的签名是 fun <T> listOf(vararg item: T): List<T>
之所以说是 union 不是 intersection 是,举个例子吧,因为它上面的 List<T>.get(Int): T 需要同时兼容输出 Int 和 Nothing,自然是并集喽。Any? 的意思是除了 Any 原有的元素还可是
null Kotlin 里那个
in / out 的意思还是从那个类型参数的使用位置来看。fun main(args: Array<out String>) 就是不让用
Array<String>.set(Int, String) 了