c++ 就用 std::function 。std::function 可以接受函数、方法、静态方法、lambda 表达式，只要参数和返回值类型匹配。
https://en.cppreference.com/w/cpp/utility/functional/function

抽象基类虽然功能上能实现，但是太啰嗦，对于每一种函数类型要定义一个基类，每一个函数要定义一个包装类。
而且运行时多一次查虚函数表的操作，同时也阻止了编译器优化。

函数指针仅仅是一个地址，不包含数据。std::function 还可以包含数据。
例如 lambda 表达式可以捕获外层的变量，形成一个闭包。这时就不能用函数指针了。

生成器里面第一个表达式是延迟求值的。
相当于:
map(lambda i: l[i], range(2))
每次计算会去读 l 的值。

函数式编程需要避免赋值这些有副作用的操作。

/*
典型的生产者消费者模型，限制并发的话只创建 2 个消费者就可以了。
Queue 用于传送任务和同步。
Queue 还可以优化，这里用 array 实现效率不高。
Queue 还可以添加容量限制。
*/

class Queue {
#queue = [];
#getter = [];

put(x) {
if (this.#getter.length > 0) {
this.#getter.shift()(x);
} else {
this.#queue.push(x);
}
}

get() {
return new Promise(resolve => {
if (this.#queue.length > 0) {
resolve(this.#queue.shift());
} else {
this.#getter.push(resolve);
}
});
}
}

function sleep(n) {
return new Promise(resolve => {
setTimeout(resolve, n);
});
}

async function consumer(queue, id) {
while (true) {
const task = await queue.get();
if (task === 'end') {
console.log(`consumer ${id}, exit`);
break;
}
console.log(`consumer ${id}, task ${task}, start`);
await sleep(1000 * Math.random());
console.log(`consumer ${id}, task ${task}, end`);
}
}

async function producer(queue) {
for (let i = 0; i < 10; i++) {
console.log(`producer, task ${i}`);
queue.put(i);
}
console.log(`producer, end`);
queue.put('end');
queue.put('end');
}

const q = new Queue();
const c = [consumer(q, 0), consumer(q, 1)];
const p = producer(q);

用 pycharm 可以实时提示语法错误，再加上类型标注可以避免类型错误。
单元测试可以确保一个函数得到期望的结果。
logging 可以在运行时输出一些信息，比 print 更好用。

btrfs 可以做快照，是不是快照占用了大量空间？

@jeeyong
这里是举例，实际应该从文件读取。
buffer = open(name, 'rb').read()

或者直接用 np.fromfile

思路很直接：
先得到 numpy 的数组。
再提取灰度和 alpha 的数组。
再拼接成二维数组，灰度重复 3 次。
最后 reshape 成需要的形状。

直接用 numpy 就可以了，python 的循环太慢。
```
import numpy as np

width = 5022
height = 4200

# buffer 直接从文件读取
buffer = bytes([208, 4]) * (width * height)
assert len(buffer) == width * height * 2

b = np.frombuffer(buffer, dtype=np.uint8)
grey = b[::2][..., None]
alpha = b[1::2][..., None]
image = np.hstack((grey, grey, grey, alpha)).reshape((width, height, 4))
```

如果 zpool 只有一块硬盘，且 zfs 的 copies 设置为 1 ，那么通过校验值可以发现文件损坏了，但是没办法恢复了。
mirror 和 raid-1 一样，只要有一块硬盘在，数据都不会丢，所以应该一样可靠。
raidz1 允许最多坏 1 块硬盘，raidz2 允许最多坏 2 块硬盘，raidz3 允许最多坏 3 块硬盘。
raidz 和 mirror 还可以组合，情况就比较复杂了。

两块硬盘就用 mirror 的方式组 zpool ，相当于 raid-1 。
zfs 有校验，可以发现错误，能不能恢复看 zpool 配置。
zfs 还有压缩、加密、去重、逻辑卷管理等功能。
不过一般的 linux 图形安装界面都不支持 zfs ，需要手动配置 zfs 手动安装。

html 元素的 font-size 使用 em 是相对于默认字体大小（通常为 16px ）。
其它元素的 font-size 使用 em 是相对于父元素的 font-size 。
其它 CSS 属性使用 em 是相对于本元素的 font-size 。

font-size 设置为 inherit 或 1em 是一样的。

font-size 使用 em 不是相对于自身。
一个元素的 font-size 不能是它的 font-size 的两倍，除非 font-size 为 0 。

@danielzz

https://developer.mozilla.org/zh-CN/docs/Learn/CSS/Building_blocks/Values_and_units
em: 在 font-size 中使用是相对于父元素的字体大小，在其他属性中使用是相对于自身的字体大小，如 width

wolfram mathematica 可以。
参考： https://blog.wolfram.com/2013/05/17/making-formulas-for-everything-from-pi-to-the-pink-panther-to-sir-isaac-newton/

第 3 行最后应该是 j++

最新的 pycharm ，默认设置。
可以折叠，只要子语句块有两条以上语句。

用 markdown 写注释，markdown 可以引用图片，再用工具生成文档就可以了。

如果 x 的值来自一个复杂函数，函数运行时间可能很久甚至无限。
如果 x 的值来自用户输入。
类型检查是在不运行程序的情况下对程序进行分析，能够在有限的时间给出结果。
类型检查是保守的，通过检查代表没有类型错误，不通过不代表一定有问题，ts 不通过检查也可以继续运行。

ps: ts 里面 10 是一个合法的类型，它只有一个值。

如果 B 的构造函数有引用参数，还需要用到 std::forward 。

利用模版构造函数和可变长模版参数，按 C++ 11 标准可编译。

```
template<typename T>
class A {
public:
T t;

template<typename ...ARGS>
A(ARGS... args) : t{args...} {}
};

class B {
public:
B(int x, int y) {}
};

A<B> a{1, 2};
```

应该是用统计学里的假设检验来验证，这里是离散均匀分布，可以用皮尔森卡方检定。
假设检验本身就可能犯第一类错误（拒绝正确结果）和第二类错误（接受错误结果）。
我试过，轻微改变分布还是能通过。

```
import bisect
import random


class Solution:
....def __init__(self, n: int, blacklist: List[int]):
........self.m = n - len(blacklist)
........self.ss = [a - i for i, a in enumerate(sorted(blacklist))]

....def pick(self) -> int:
........r = random.randrange(self.m)
........return r + bisect.bisect_right(self.ss, r)
```

```
import bisect
import random


class Solution:
....def __init__(self, n: int, blacklist: List[int]):
........self.m = n - len(blacklist)
........self.ss = [a - i for i, a in enumerate(sorted(blacklist))]

....def pick(self) -> int:
........if random.random() < 1 / (100 * self.m):
............r = 0
........else:
............r = random.randrange(self.m)
........return r + bisect.bisect_right(self.ss, r)
```