duangsuse::Echo

学不会算法尤其是看不懂数学公式，找不着等价算式的人废话最多

32 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], 11:29

duangsuse::Echo

虽然数学不好，但其实也可以勉强弄一些逻辑性比数学性强的
比如说，一个深度为 N 的满二叉树，我知道它有 1+2**(N-1)个节点，而这个式子我能把它对应到二叉树的图形上（模糊地，因为这个抽象就是模糊的……
比如说，稍微想想还是能够想出Category甚至Functor里面的样子的，可惜我看到的是一堆模糊的东西，没有态射因为我只知 2=0.inc().inc(); 所以范畴就是一堆模糊的对象……
我实在没有办法，因为我就是数学不好。

我说的数学不好主要还是算术实在是做不过来，这样一些我需要枚举/计算一些东西的时候就会出差错或者至少影响我的思路
比如说，假如有一个 val a = if (p) 1 else 2，然后
下面哪怕是一个简单的

val b = a * 3

我根本没办法想出 p 不 p 时 b 有啥区别
可能稍微花个5秒我能想出来，不过这样的速度面向排错编程肯定是用不上了……（可能要尝试N遍来找一个可能的修法

其次是抽象上也不过关，比如说我经常忘记 1/2 是啥意思，好像它和 2/1 没区别一样。
实例就是，a*n/k 比率计算我都会觉得有点莫名其妙，要是再复杂一点的公式就GG了。
等式性质（比如 a*(a+1) 什么的）上可能勉强一点

34 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 11:39

duangsuse::Echo

#book 这些是我在学校里想起曾经看过的书……
感觉还是没有什么进步啊
果然是这样吗？

— 注，书名作者名全都是我记忆里的版本，不对正确性作出担保
《ES6标准入门》by 阮一峰
《Kotlin极简教程》by 陈光剑
《The Little Scheme — 递归与函数式的奥妙》虽然现在表述式(过程式,命令式)、定义式(函数式,声明式)、逻辑式(描述式)都不流行hhhh？就是那个 The Little Schemer 的中文版
《嵌入式Linux系统与工程实践》
《完美应用OpenSUSE》by 何晓龙
《算法图解》 Grokking Algorithms
《算法I-IV(C++实现)》 Algorithms in C++ I-IV: Fundamentals, Data Structure, Sorting, Searching by Robert Sedgewick
《Ruby元编程 II》 Metaprogramming Ruby II
《深入剖析Ruby虚拟机》 Ruby under a Microscope by Paolo Patrick
《CLR via C# 中文版》 CLR via C# by Jeff Richester
《快速轻量级JavaEE开发》 Continuous Enterprise Development in JavaEE
《Qt5.9 C++实战》
《操作系统笔记2019》
《一本通二级C语言》
《软件工程导论》
《有趣的二进制》
《Internet原理与技术》
《手把手教你FPGA设计——基于大道至简的设计法》
《职场新生代嵌入式600问》
《小白都能看懂的Python大数据分析》
《LLVM Cookbook中文版》 LLVM Cookbook
《深入分析GCC》
《深入理解Java虚拟机——JVM高级特性与最佳实践》by 周志明
《PHP内核分析》
《Lua设计与实践》by codedump

37 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 12:03

duangsuse::Echo

最后还有一点我做的笔记 #CS #sysadmin #linux 我懒得详细讲了，照本宣科当人肉 OCR……

AWK -F
/regex/ {}
BEGIN {} END {}
gsub(/(\d)/, $1 "n")
print;
a=1;
for (i=0; i<10; i++)
NF, RS
str sprintf("%i", n)
while (1)

SED s/origin/substitution/g; s/a/b/g
tr -d '[:blank:]'
grep -E|-P, sort, uniq
[] || &&, |, >, >>
<<END
heredoc
END
head tail
head -n|-c
tail -c +N

cmd=`printf "str"`
$cmd

BasicBlock, CFG, CallGraph, SSA
AST,GENERIC,HL GIMPLE, LL GIMPLE, SSA GIMPLE, RTL, instruction scheduling, register allocation, coloring, spilling, peephole, pipeline
输入/输出、存储、运算、控制
nested function
(!partial)full parser
source map

.text .data .bss .rodata .symtab

call set use clobber return
对称(symmetric)、交换(commutative)

reg, subreg, mem, cc0, pc, scratch

asmos, sched, vector, call, emutls, c, cxx, option_hooks

38 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 12:13

duangsuse::Echo

🤔可悲不进步的 duangsuse 总是想弄一门自己的程序设计语言。
可不管他怎么写代码，连一个有函数和局部作用域的计算器都弄不出来。

于是他又准备设计一门……

这个计算器是Lambda calculus的计算器。
所谓的Lambda演算就是说，词法作用域(Lexical scoping)，不过我还给它加上了 Haskell 一样的 Currying。
Lambda 就是 \formals. body abstraction
不过 currying 的 lambda 只能有一个参数，\formals 需要foldRight才行。
然后可以 apply: substitute + reduce
这次我不用解析组合子了（这是看项目而定，何况现在我已经写过很多，暂时没找到好的架构），手写基于 Feed 的递归下降解析器。

中缀链的解析算法选用普通的左折叠栈式。
一时间不打算支持自定义infix operator，因为我的trie树还没写对一个。
计算器是弱类型的。

下面的语法规则是这种格式：
—
名字定义
——
也可能是
—
名字
定义
——
终结符（一个字符）的名字是小写
非终结符（一个子语法）的名字都是大写
但是 newline, whitespace 可以不大写

a b c 这是按顺序读这三项
为了表示上的方便，我们默认这三项里都可以有空格也即

a b c = a ws b ws c

  ws = {whitespace}?

然后 . 出现的地方不得自动加

ws

a | b | c

是读一项可能是a,b,c之一
{a} 是重复读

a
(a)

是结合group的标记，无实际含义
a~t 是重复读取 a，直到 t 成立的意思 (不是 do while…… 只要t成立一遍都不会解析的）
a!t 是读取a，但 t 必须不成立才算的意思

anychar 是任何字符的意思
keyword 除了用来引用终结符，如果引用到的名字不存在则是表示读一

"keyword"

然后，a? 表示a可能存在也可能没有

字符的表示基本和Kotlin一样，'a', \t(\的形式不必加'')
字符串也差不多
[] 和正则表达式差不多，不过支持 [ab(rule)] 这种格式
所谓的差不多就是 [123], [0-9a-z] 都支持这种

现在是语法规则

whitespace [ \t\n\r] | Comment
newline CRLF|lineFeed
CRLF "\r\n"
lineFeed '\n'

Comment "{-" (Comment|anychar) ~"-}"

File
  { Def|Expr.}
Def
  def Name = Expr
 |def Name Abstract
Expr
  Let | Abstract | Apply
 |If | InfixChain | Atom
Let
  let Binding in Expr
Binding Bind { , Bind.}
Bind
  Name = Expr

Abstract {— Reduce right —} 
  lambda LexicalScoped
LexicalScoped
  Name LexicalScoped {— one substitution —}
 |There Expr {— body with substitutions —}
There "->"
lambda bslash

Apply {— Reduce left —}
  Expr Expr | Apply Expr

If
  if Expr then Expr else Expr
InfixChain
  infixChain(||; &&; ==,!=; <,>,<=,>=; +,-; *,/,%; **;)
Atom
  Group | Unary | Name | Literal
Group '(' Expr ')'
Unary UnaryOps Atom
UnaryOps unary(!, -)
Name {— Single _ is reserved —}
  (_ | [A-Za-z一-鿕]).{[_A-Za-z0-9一-鿕]}?
 |`anychar~newline`
Literal
  Integral | Rational | Boolean | Char

hexDigit [0-9a-fA-F]
NumpartP(digit)
  digit | {digit _?} digit
Numpart NumpartP([0-9])
sign '+'|'-'

Integral
  sign? . ("0b".NumpartP([0-1])
  |"0x".NumpartP(hexDigit)
  |[1-9].Numpart
  |[0-9]).[lL]?
Rational
  sign? . Numpart.(dot Numpart).([eE] . sign? . Numpart)?.[fF]?
Boolean
  true | false
Char quote.(
  anychar![(quote)(bslash)(newline)]
  | EscapeSeq).quote
EscapeSeq
  bslash.(UnicodeLiteral | Escape)
UnicodeLiteral
  u . hexDigit.hexDigit.hexDigit.hexDigit
Escape
  [tbnr(quote)(dqoute)(bslash)$]

dot '.'
quote '\''
dqoute '"'
bslash '\\'

45 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 12:56

duangsuse::Echo

我去看看 Kotlin 好像已经被绝大部分 Android 开发者采用了，真是良币驱逐劣币，可怜的 Jawa。

其实Kotlin细节上的实现难度还挺多的，比如 fun <E> E? 和 when (val a = 1) 这种语法糖或者类型推导的
我这种描述式没入门是不可以的
就语言的实现而言，Kotlin显然不是入门选项

37 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 16:11

duangsuse::Echo

Forwarded from dnaugsuz

typealias PredicateOn<T> = T.() -> Boolean
typealias Producer<R> = R
fun <R> retry(n: Int, terminate: PredicateOn<T> = { true }, op: Producer<R?>): R? {
  for (_i in 1..n) { 
    val res = op() ?: return null
    if (terminate(res)) return res
  }
  return null
}

这么写岂不是也可以……
骚操作一点（不建议）甚至可以这么写

fun <R> retry(n: Int, terminate: PredicateOn<T> = { true }, op: Producer<R?>): R? {
  for (_i in 1..n) { 
    val res = op() ?: return null
    res.takeIf(terminate)?.let { return it }
  }
  return null
}

写成Java一样意义不明的风格是哪般……
真鼓吹数学的人都去学抽象代数机器证明了，次一点的也搞范畴论Monad学descriptive甚至逻辑式去了，应用编程就写好看点，为什么起名字喜欢起数学糟粕形式的名字……
难道还真应验了王某人的那句话『你越是看不懂越觉得自己智商低、越觉得我牛逼』……

也可以 functional inline
加个 inline 就行，然后如果报错就继续加 crossinline……

3 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], 16:22

duangsuse::Echo

dnaugsuz

typealias PredicateOn<T> = T.() -> Boolean typealias Producer<R> = R fun <R> retry(n: Int, terminate: PredicateOn<T> = { true }, op: Producer<R?>): R? { for (_i in 1..n) { val res = op() ?: return null if (terminate(res)) return res } return…

https://t.me/dsuses/3073

duangsues.is_a? SaltedFish

typealias PredicateOn<T> = T.() -> Boolean
typealias Producer<R> = R
fun <R> retry(n: Int, terminate: PredicateOn<T> = { true }, op: Producer<R?>): R? {
for (_i in 1..n) {
val res = op() ?: return null
if (terminate(res)) return res
}
return…

33 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], 16:22

duangsuse::Echo

今天不开明天开。

36 viewsduangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ], edited 16:24

duangsuse::Echo

我去看看 Kotlin 好像已经被绝大部分 Android 开发者采用了，真是良币驱逐劣币，可怜的 Jawa。其实Kotlin细节上的实现难度还挺多的，比如 fun <E> E? 和 when (val a = 1) 这种语法糖或者类型推导的我这种描述式没入门是不可以的就语言的实现而言，Kotlin显然不是入门选项

表达这些语法的语言本身也很容易用它来描述：

whitespace [' '\t\n\r]
comment "{—" anychar|Comment ~"—}"
metachar
  ['[' ']' '(' ')' '{' '}'
   '.' '|' '~' '!' '?'
   (dquote) (bslash) (quote) '-']

Single
  "anychar"
 |Char
 |SetChar
Char
  anychar!metachar {— a, b, c —}
 |EscapeSeq {— \t, \r —}
 |quote.anychar.quote {— 'x' —}
SetChar {— [0-9A-Z(identchar)$#] —}
  '['.{SetElement}.']'
SetElement
  Char.'-'.Char
 |'('.Name.')'
 |Char

Complex OrComplex | Seq
  {— a b c => a ws b ws c —}
  {— a.b.c => a b c —}
  {— ws {whitespace}? —}
Seq OrComplex { dot? OrComplex .}
OrComplex AtomComplex | Or {— a | b | c —}
Or AtomComplex { mid AtomComplex .}

AtomComplex
  Grouped {— (a) —}
 |NameRef_Keyword
 |Keyword
 |Repeat {— {a} —}
 |Optional {— a? —}
 |RepeatUntil {— a~t —}
 |TakeUnless {— a!t —}

Grouped '(' Complex ')'
NameRef_Keyword Name
Name [_A-Za-z]. {[_A-Za-z0-9]}?
Keyword '"'. anychar!metachar|EscapeSeq ~'"'

EscapeSeq
  bslash. (UnicodeLiteral | Escape)
UnicodeLiteral
  u. hexDigit.hexDigit.hexDigit.hexDigit
Escape
  [tbnr(quote)(dqoute)(bslash)$]

quote '\''
dquote '"'
bslash '\\'

AnyTerm Single | Complex
{— 终结符小写、非终结符大写、newline,whitespace作为非终结符可以小写 —}
Definition Name AnyTerm
File {Definition}