这类分析应该有小窍门，但我现在还找不到好的方法... 据说 HM 类型推导很火，不知道是不是讲这个的

HM: Hindley-Milner，是 Haskell 的类型系统名称

即使什么代码都不写，也无法逃脱爆炸的命运么？

#notes #daily #tech #cs #pl 又是一周的 duangsuse 随机瞎想集合


+ #China #life 重庆公交车坠江事件

http://www.sohu.com/a/271969492_398039

简｜一女子坐公交坐过站要求司机往回开，司机开始好好解释但后来与女子争吵，女子与司机争夺方向盘。司机未能及时刹车导致公交撞上对面过来的小轿车，公交坠入江中。无人生还。

一站错过，二人争执，三秒互殴，四轮悬空，无人身还，六亲悲痛，生命再无重来机会

 小公交，大社会，戾气愤怒的怨妇，激愤无脑的司机，沉默麻木的看客，诱发了一场不该发生的惨祸，到底谁之错，或无可以置身度外者

+ Sketch

这个词，只是我某次晚自习时突然忘记了当年 @drakeet 那个软件叫啥名字来着？叫啥名字来着？？？然后我就死想了两个小时... 居然想出来了，然后我就特激动... （SketchUp!!!!!!!!）🤔
没有别的事情了
当然，感触就是... 有些东西想想还是能想到的，不过花了俩小时...

+ 44 路公交车（短电影） #video #Low #China

https://movie.douban.com/subject/1308627/

推荐观看，看客精神杰出教材

+ 韩寒《他的国》 #China

我打算给你们拷贝一下人们围观跳楼那段场面的... 算了

+ 数学和直觉 #math

我的意思大概是数学的有些表述方式简洁不易懂，往往要经过非常特殊的专业训练才能懂...

+ 昨日青空 #media

主题曲比较好听，想做 vocaloid 合成曲

+ javax.stream 和 ReactiveX

Rx 是最开始 C# 的一个扩展，现在已经不只是 C# 的扩展了
它的目的是提供统一的流处理模式 API
当然，它也是很好的异步／消息（aka. 广播、事件）式编程函数库
这被称为 Observable 「可观测的」
http://reactivex.io/documentation/operators.html

onNext(T)
onError(Exception)
onCompleted()

这是一种 Observable 的核心特征，实际上 RxJava 的 Observable 定义包括文档有 8k 行左右

Observable 上还允许发送集合处理消息（调用方法），类似 map flatMap join zip merge concat 这种

我只是想告诉你们它是做什么的（类似 Promise、Future）一样的工作
因为我之前根本懒得了解它...

+ 蓝真天白真云

一种 Yuda 表示法... (blue == sky.color && white == sky.clouds.color)

参考王垠博客「Surely I'm Joking」和游戏「崩坏 3」

+ Python 的独特语法

for ... in ... if
我以为是惰性数组？（跑
http://zetcode.com/lang/python/lists/
（其实是 Python 的语法糖，类似 Ruby puts while true 这种）
e.g.

a = [1, 2, 3]
b = [4, 2, 6]
c = [str(i) for i in a if (i in b)] #=> ['2']

<del>告诉你们一个你们不知道的 Python 语法</del>（迫真）

+ Java8 with Android 简单入门

我很想写一本关于这个的书... 后来 toc（Table of contents，目录）写着写着就变成杂学书了... 一会还扯到 CPU 应用层面的玩意... 还扯到了解释器什么求值顺序什么的

+ CABuild

我也忘记原义了，大概就是些构建（依赖型）系统啥的项目

+ RegularPP LALR

... 算了，LALR 那种大佬级别的解析算法我写不起啊，跟写红黑树一样的...

+ Kookle lang

这玩意是我打算写编译到 C 的语言... 当 C 的扩展吧，其实同样的东西大概有许多名字（maybe）

+ Haskell 模式匹配

我之前才知道... Haskell 的 function 貌似都是模式匹配定义出来的，也就是说其实我说的不在所有情况下全是对的（废话）（而且我说的错误往往比较多）

比如说

factorial :: Int -> Int
factorial 0 = 1
factorial n = (factorial n - 1) * n

fac :: (Integral a) => a -> a
fac 0 = 1
fac n = n * fac (n - 1)

这个例子不好，而且你们最好不要在 REPL 上试... 可能会死机（Haskell 蜜汁 BigDecimal 实现？）
（而且堆栈的深度又不是无限的... 但在栈爆之前溢出的 Disk IO 就要把泥的 PC 撑炸）

lenList :: [x] -> Integer
lenList [] = 0
lenList (_:xs) = 1 + lenList xs

sumList :: Num n => [x] -> n
sumList [] = 0
sumList (x:xs) = x + (sumList xs)

main = print  $ sumList [1..10]

我们举个栗子（使用 : 来表示列表「Cons」是另一种表示方式）

sumList [1, 2, 3]

sumList 1 : (2 : 3) = 1 + sumList (2 : 3)
sumList 2 : (3)     = 2 + sumList (3 : [])
sumList 3 : ([])    = 

3 + sumList []


sumList [] = 0

1 + (2 + (3 + 0)) = 6

这就是所谓的模式匹配，Rust 里也有

+ naive bfs

呃，之前怀疑自己写的那个 naive bfs GC 是不是写错为 naive DFS GC 了，要真是那样我老脸可就真 naive 了 🐸

个人感觉深度优先搜索记录搜索路径并且要求深查找到顶端枝叶，广度的不需要记录路径

+ 线程同步与枪战游戏

教程灵感...

就是说现在的网游数据同步问题（当然不只是现在的）（当然现实生活一般不会考虑这个问题，有人处理）

e.g. 两个人同时捡起一个医疗包，但第一个人「a」捡起来的时候，第二个人「b」的设备不知道医药包已经被人捡走了，结果两个人都捡到了一个医疗包... 所以我们要想办法「同步」解决这个问题

<第一次同步>
[a] 捡拾医疗包（状态：医疗包存在）
[b] 捡拾医疗包（状态：医疗包存在）
[a] 捡到医疗包，请求删除对象
[b] 捡到医疗包，请求删除对象
<最终>
[a] [b] 获得医疗包

结果嘛... 有很多种可能，数据竞争造成的后果一般比较迷

个人感觉这种抽象程度更低一些，所以会容易理解很多，本质上的东西「发布啊... 原子性啊...」是没有变的

就是教线程同步的... 大概 虽然我也不会

+ MOD 和 XOR

Modulo 和 Xor 是非常常见的数学运算符

Java 8 里 Modulo（余数 aka. 模数） 10 / 3 = 3 ··· 1 是 10 % 3 //=> 1
Xor （异或）则是经典位运算，真值表「输入 a 和 b 相同就输出假，否则输出真」

a | b | o
1 | 0 | 1
0 | 1 | 1
1 | 1 | 0
0 | 0 | 0

0b10010 ^ 0b00000 什么的... Xor 还有很好玩的特性可以自己找

+ MinBase64 和 randomSelection：极简设计自豪

... 我觉得没啥好自豪的呢... 不过我觉得 MinBase64 的交互设计得真的比很多同类应用要好，虽然代码很不怎么样
rs 现在也就一个晚上的熬夜战而已，不能说明什么...

+ Net、Async、Mixin、ApplectiveOrder Y Combinator、JavaVM、Algorithm 不会 和 Bottleneck

....就是说我 duangsuse 计算机网络、异步和并发编程、面向对象理论和流行技巧、某种 Y 组合子不会而已

JavaVM 不会是因为我不理解类加载机制（真的？）
算法不是我的强项，或许（
瓶颈（就是字面上的意思）（好吧不是）
总感觉最近看书没啥效果一样，该菜的还是菜

附赠 Y 组合子一份（lambda 演算）

Y = λf. (λx. f (x x)) (λx. f (x x))

https://en.wikipedia.org/wiki/Fixed-point_combinator

附赠一些 FP 概念，从《极简 #Kotlin 教程取用》（叫你们买这本书... 因为的确是好书啊（跑））

函数式编程又称泛函编程，是一种编程范式（programming paradigm），也就是如何编写程序的方法论。它的基础是 λ 演算（lambda calculus），λ 演算可以接受函数当作输入（参数）和输出（返回值）

和指令式相比，函数式的思维方式更加注重函数的计算，它的主要思想是把问题的解决方式写成一系列嵌套的函数调用。

在 OOP 里，一切皆是对象，程序是由对象交织构成的世界，而 FP 里，一切皆为函数，程序是由函数交合创造的世界。

（推荐使用 Common Lisp、Scheme 什么的入门）

「OOP 中常用模式，FP 里基本都可以使用高阶函数（Higer-Order Function）实现」

Strategy = HigherOrderFunction
|
——-----/—--————/———————/—————----------—/———---—/————-
Command Observer AbstractFactory State Visitor


「范畴」
函数式编程中，一切皆是函数，也就是面向函数编程。

范畴论里，一个范畴由三部分组成

+ 对象（object）
+ 态射（morphism）
+ 组合（composition）操作符

如果把函数式编程看作一个范畴，那么函数就是其中的对象，函数之间的组合就是对应的态射和组合操作符

『范畴的对象』
这里可以看作一类东西，如 Boolean、String、Integer 或者数学上的群、环有理数等
『范畴的态射』
态射就是映射，用箭头表示

element -> element

e.g.

translate :: String -> String
translate "Hello" = "你好"
translate "Bye" = "再见"
translate "Thanks" = "谢谢"

『范畴的组合』
组合用「·」来描述，用于将态射进行组合

f :: A -> B
g :: B -> C

g·f :: A -> C

一个结构要想成为一个范畴，必须满足以下三个限制：

〖结合律（colsure）〗
f · (g · h) = (f · g) · h
〖封闭律（associative）〗
如果存在态射 f 和 g，则一定存在态射 h = f · g
〖同一律（identity）〗
对结构内的每个对象 a，存在一个单位态射 I :: A -> A 使得 I · a = a

群论中，一个群只满足上前两点被称为半群（semigroup），全部满足被称为含宏半群（monoid）

正如范畴论对象和对象之间有映射关系一样，范畴和范畴之间也有映射关系，能将一个范畴映射为另一个范畴，这种关系被称为「Functor」（函子）
函子反映了不同范畴之间的内在联系，这和函数式编程中泛函数（高阶函数）的思想是相通的

+ Foldl 和 reduce

Fold （foldr 的简称）是有初始值版本的 reduce

+ E2IM wait() notify()

就是说 duangsuse/e2im 这个函数库异步没有做好...

睡觉了，还有很多很多很多没有说的..... 有一大堆两页的内容

是的

111 Members 吉利（迫真）数字庆祝（

不过其实我比较好奇，因为本频道发的很多内容都不是大部分工业系（或者说，非真正的「工业系」）程序员看得懂的，但居然还有人要关注

#telegram 频道主 duangsuse 预计，这种 subscriber 的动机和我自己以前 star 那些 #GitHub 代码库的动机一致，只是觉得很厉害就 Star 了一个，实际上，看的人也是比较少了

我以前都是那种看都不看一眼就 Star 的。现在我没有了，这后面也有我程序设计项目分析能力提升的原因 — 以前可能要看的话，根本不知道哪是哪，现在三分钟就能快速理解项目结构，找到工程构建、界面、定义文件的位置

不过，在此也建议大家不要为了 Star 或者让别人看到而 Star，最好还是多看一下

🐱

毕竟现在很多甚至是（资深）「工程师」
都没看过本本的。我很尊敬看书的人，但其实不看本本们也有能做高级一点工程（e.g. @RikkaW's Riru framework）的人也有很多

现在嘛... 感觉自己技能和理解能力都有很大的提升了（真的？）

论文和编译原理方面的，表达方式比较数学化的偏序原理也能看懂了，虽然还是有点没耐心看完

一直以来自我感觉智力水平都比身边的同学差个一年的（果然？

热爱技术的人从来都是不知足的？（

但是嘛... 其实感觉好像自己的技术又没有提升多少而已，大概是工程做少了书看多了的那种。而且，我也还不了解计算机网络、TCP、Internet 系统呢
人工智能特别想学，没有时间和资料（因为打印机没墨了...），但是，先把基础的并发、操作系统、计算机结构、计算机图形学、计算机网络、编译原理、软件工程、面向对象设计模式、渐进式、模块化开发等基础学好了才能继续吧（ 🐱

« last pinned message

我上面也说了，建议大家还是尽可能去了解一下自己 Star 的那些东西真正是什么，其实从觉得很酷到懂只差一份好奇心和两年左右的持续努力（或许更短）

@drakeet 那件事（我现在居然还经常说...）其实我后来注意到他偶尔提到王垠

个人感觉... drakeet 目前还是对程序设计语言方面的理论不是特别了解，当然人各有所长，所以单凭某个方面去判断一个人的能力是不正确的。（当然，之前搞出那么大篓子的原因是我语文没学好，不知道别人还有自尊心，或者说，我个人比较「不要脸」，即使技术被人批评了也只是想着怎么提升而不会觉得丢脸，因为我还是很能做到「己所不欲勿施于人」的）

（当然，其实我之前也考虑到了自尊心？可能是我说的太直白了吧... 我明明说了他很擅长 Android 开发的... 只不过想让他不要在自己不是很擅长的方向发表太多看法）

（当然，或许我在之前那个我以为他不擅长的方面还不如他呢，或许他真的是对的，现在不重要了 :P）

其实嘛... 王垠的「40 行代码」
我开始来到 CS 大门前的时候当然就啥都不知道，比较好笑，我真的就是不明觉厉

不过，真的只有我一个人是不明觉厉吗？

不要害怕学习，不要和那群前端一样成天叫着别更新了、再学就要猝死了，人类社会就是向前发展的、技术就是向越来越好发展的，自己不努力追赶也有人追赶

现在上亚马逊去买书，跟着不管什么平台，知乎、CodeWars、各类 OJ、甚至 QQ 上的大佬们学习（其实只需要看他们的博文和代码即可）

相信 10000（10k，一万）个小时定律，只要付出的足够多，就能理解你之前不明觉历的那些东西

#inscript #PL #CS #java #code #recommended

同时，InScript 又新加了几个特性，包括模式匹配、惰性求值等等函数式 declarative （定义式）编程的特性

下面给大家一些代码，这周我不说其他（InScript 外）的东西了，先解决 InScript 语言定义的问题，FIFO 队列溢出就溢出吧（当然，这里溢出指「先进入的信息已经失去时效性」）...

有 imperative （表述式 e.g. Kotlin、JavaScript）的也有 declarative （声明式 e.g. Haskell、Scheme、Idris）的，全部都是 InScript（

其实后来感叹到 InScript 越设计越像 Haskell 了... not CFG（上下文无关）文法的锅？（迫真
不过真的不打算弄成 Haskell 一样，而且又加入类型检查推导和模式识别特性是很耗力气的... 估计不是现在可能做出来的那种设计
（duangsuse 的 Haskell 还有待入门，不过 Haskell 也怪好玩的，递归也比较熟悉了，就差拿 InScript 分支函数写 The Little Schemer 了（

（InScript 现在添加了这种函数式扩展以后语法歧义估计可是比 Julia 还多？（迫真

（把 imperative 或 declarative 作为一门语言的特点是不对的？）（怀疑

{- Toy progream: FizzBuzz judger-}

type scannerIter : Iterator<Int>
type judge : Int => String
type main : String[] => Nil



scannerIter = object : Iterator<Int>

new def next = gets.parseInt
new def hasNext = IN.open?

judge(x) = when x
% 3 zero -> 'Buzz'
% 5 zero -> 'Fizz'
both 1, 2 -> 'FizzBuzz'
otherwise -> x as String

main(args) = puts << judge <$> scannerIter

{- Toy program: Guessing game -}
using randInt from std.math

main(String[] args): Nil = |>
scope let answer = randInt(1..100)
where while input = gets.parseInt
puts when input where
> answer -> 'Too big'
< answer -> 'Too small'
answer -> "$answer, Just right!"; break

{- Toy program: Selection sort -}

type <A : Comparable<A>> selectionSort : (A[]) -> A[]

scope let opt = |orig@(v, i), b, j| v > b ? orig : （b, j)
where findSmallest(xs) = let (_, res) =
foldWithIndex(opt, (Int::MIN, 0), xs) in res

selectionSort [] = []
selectionSort [findSmallest x in xs] = x >> tailrec

main(args) = puts selectionSort [2, 4, 1, 5, 3]

{- Toy program: binarySearch -}

type <A : Comparable<A>> binarySearch : |A[]| |A| |Range| Int

binarySearch xs o <srch = xs.indexRange> = |>
let index = srch.mid, guess = xs[index] in when
| srch.len zero -> nil
| guess is o -> index
| guess > o -> tailrec(srch.a..srch.mid.sub1)
| guess < o -> tailrec(srch.mid.add1..srch.b)


{- Toy program: dfs 在盒子堆里找指定物品，并且获得其路径 -}
data Box = BoxItem[] items, String name
data Item = String name
data BoxItem = Box box ^ Item item

findItemInBox(Box box, String target_name, String[] path = "")
box.items.each |>[:findItemInBox, "$box.name/$path"]

findItemInBox(Item item, String target_name, String[] path) = puts path if item.name is target_name



{- Toy program: Coroutine Fibonacci 序列 -}

using std.sequence

def fibonacciSequence: Sequence
let suspend fib(a, b) = tailrec(suspend b, a + b) in
return new Sequence(fib(1, 2))


def main(args) = puts fibonacciSequence().take(args.first.parseInt ?: 100)

... 不好意思蛤，刚才一激动（因为新设计加入的模式匹配特性）全写的是定义式，待会写点表述式的对照一下

#blog #recommended https://ice1000.org/2018/11/16/BeyondDependentType/

顺推冰封哥新文 dependent type 之上还有更高级的类型系统吗？

当然我个人 PLT（这里意味 Programming Language Types）毫无水平，只会 Kotlin、Jawa、Crystal 系简单语言的类型系统
可以说是非常菜了

当然这个是要看发展的，拿别人的水平批判 duangsuse 的话是不接受的（比如，冰封几年前就在写 C++ 搞 OI，我去年才会写简单的 Java 7），拿没有作品批判也是不接受的（原因我在本频道上说过）

btw. 真是高产啊，才一周不见就更了两篇文章

duangsuse 自己对程序静态分析检查还不是很了解，when 表达式的语法上面各种糖都还好说（毕竟手写 Recursive Descent 我还是熟悉的）
啥分支覆盖问题我也想过，不过啥都不懂就是了，打算如果以后就这种水平去实现的话，尽可能多做一点（或许是启发式的...（这里启发式和机器学习无关，意思是「假设各种情况做检查」））检查，不要求绝对正确，保证体积和解释器本身健壮即可，类型检查器重要性优先于类型推导器

〖对应用层开发者（e.g. Android 开发工程师、PHP 或者管他什么没有达到完全抛弃任何框架的程度能力者，尤其是语言特性贫瘠或非底层语言 Lua、ES5、Java、Groovy、Python 程序员）来说〗
像这种写 Agda、Idris、ML 等「具有证明程序正确性的程度能力」语言水平的人，最好还是不要在他们面前炫耀自己写了多少前端应用什么的，说实话，等你以后（或许）有了更高的视角，你会发现你死记硬背的那些 CSS 属性，学的反编译器使用、Bash 编程、GNU/Linux 系统配置、Git/Gradle/CMake 等「最佳实践」等等根本不值得一提，不是一个抽象复杂层次上的东西

不过至少是冰封来看，他没有那种高高在上的架子，比较平易近人（虽然最喜欢研究的理论不平易近人，笑），但如果自己没有足够的水平，有些圈子不必强融就是了（反正以后赶上了可以再进嘛）