2026-11-13 00:00:00
走在路上,我对路边的小草说:“有人说人是被抛到这世上的,你怎么看?”
小草看了我一眼,说到:“不是这样的,你可否记得,你站在世界选择器前的情景?”
“世界选择器?”这个词击中了我内心深处的秘密,一段回忆浮现在我的脑海中。
我站在一个悬浮在空中的巨大正方形“屏幕”前。屏幕有小山坡那么高,分成无数个小格子,每个小格子都在展示着一种人间风景的动画。我知道,每个格子都代表着某个时间地点,某个家庭。我可以选择在那个时空出生。
“没错,你之所以出生在这个时代、这个国家、这个家庭,是因为那时你做出了选择。你相信这是最好的选择,你知道这将会是最精彩的人生。”
“想起来了的话就回去吧”小草说到。
我从马路上醒来,忘记了我刚才跟谁说过话。
眼前的商业大厦上的玻璃窗格,让我感到既熟悉又陌生。“原来我曾在世界选择器前,做出过选择”我喃喃自语道。
本文初稿完成于 2023-08-23
2024-04-28 00:00:00
字符串格式化是很常见的功能,传统上,我们使用 C 语言的 printf 来格式化。但作为一位 C++ 爱好者,printf 的缺点也很明显:
std::cout 的问题在于:
流行的新一代格式化库如 fmt 的问题在于:
市面上其他的 C++ 格式化库也无法让我满意,于是我在自己的 C++ 通用库 xlib 中实现了一个简单的 fmt 模块,使用方法如下:
BasicFormat fmt;
// pad 可实现用 0 补齐
fmt("pi = ", fmt.pad(4, 314), ' '); // => "pi = 0314 "
可以通过继承来添加自定义类型:
struct Date {
int year, month, day;
};
struct MyFormat: public BasicFormat {
using BasicFormat::append;
static void append(const Date& d, StringPusher& push) {
append_all(push, d.year, '-', pad(2, d.month), '-', pad(2, d.day));
}
X_FMT_IMPLEMENT_FORMAT
};
MyFormat fmt;
fmt(Date { 2012, 4, 1 }); // => "2012-04-01"
支持自定义类型的方法有这么几种:
operator<< ,std::cout 就用的这种我一开始用的是模板偏特化的方法,但这种方案的问题是,相关定义是全局的。所以对某一个自定义类型,同一个程序里只能定义一种格式化方法。而且 C++ 的 namespace 是开放的:即后面 include 进来的文件可以往任意 namespace 添加东西,我认为这样太动态。
我后来改为用继承实现,因为:
附:fmt 的简化实现
class StringPusher {
std::string& str;
public:
StringPusher(std::string& str): str(str) {}
void operator()(char c) {
str.push_back(c);
}
void operator()(std::string_view buf) {
str.append(buf.data(), buf.size());
}
};
// 待格式化整数
template<class Int>
struct FormattedInt {
Int n;
uint8_t radix; // 进制
CharCase charCase; // 大小写
uint8_t padTo; // 补齐位数,0 表示不补齐
};
/**
* https://stackoverflow.com/questions/27375089/what-is-the-easiest-way-to-print-a-variadic-parameter-pack-using-stdostream
*/
#define X_FMT_IMPLEMENT_FORMAT template<class... Args>\
static void append_all(StringPusher& push, Args&&... args) {\
using _expander = int[];\
(void)_expander{ (append(std::forward<Args>(args), push), 0)... };\
}\
template<class... Args>\
std::string operator()(Args&&... args) {\
std::string res;\
StringPusher push(res);\
append_all(push, args...);\
return res;\
}
struct BasicFormat {
// 字符串
static void append(char c, StringPusher& push) {
push(c);
}
static void append(const char* s, StringPusher& push) {
push(s);
}
static void append(std::string_view s, StringPusher& push) {
push(s);
}
static void append(const std::string& s, StringPusher& push) {
push(s);
}
// 整数
template<class Int, typename std::enable_if_t<std::is_integral_v<Int>>* = nullptr>
static void append(Int n, StringPusher& push) {
x::ser::formatInt(n, 10, CharCase::Lower, 0, push); // 省略 formatInt 定义
}
template<class Int>
static FormattedInt<Int> pad(uint8_t n, Int x) {
return FormattedInt<Int> { x, 10, CharCase::Lower, n };
}
template<class Int>
static void append(FormattedInt<Int> fn, StringPusher& push) {
x::ser::formatInt(fn.n, fn.radix, fn.charCase, fn.padTo, push); // 省略 formatInt 定义
}
X_FMT_IMPLEMENT_FORMAT
};
2023-12-26 00:00:00
读了我的上一篇文章的读者可能仍然会觉得状态机,或者说 Puhser 这个概念太抽象,不知道该怎么用。因此我在这篇文章中讲一个实际的例子。
考虑一个常见的数据汇总问题:有一个文件,每行是一个数据,每行数据中包含一个日期和一些统计数字(比如销售额、用户活跃数、用户付费等),需要按月度汇总这些统计数字,并且输出到另一个文件。
我们还有一些限制条件和设计要点:
这个问题我们一般称为“resample”,在处理时间序列型数据时非常常见。著名的 Python 数据处理库 pandas 还有专门的教程页面。
回到函数式编程,哪种序列变换函数对这个问题最合适?可以一步步地分解思考这个问题:
可见这里的重点是,如何将序列中相邻的且 key 相同的元素分组,有什么现成的函数吗?
我首先想到的是,这个需求有点像 GroupBy ,但 GroupBy 跟这个需求有一些不同:
Map[Key, Item[]] ,而我们需要输出另一个序列然后我找到一个看上去很接近的 lo.PartitionBy ,但仔细观察后发现,这个函数会调整元素的顺序,依然不是我们需要的。
所以只能自己实现了,我称之为“SeqGroupBy”:
type Pusher[T any] interface {
Push(T)
Flush()
}
type PusherSeqGroupBy[K comparable, A any] struct {
next Pusher[[]A]
getKey func(A) K
curKey K
items []A
}
func NewPusherSeqGroupBy[K comparable, A any](getKey func(A) K, next Pusher[[]A]) *PusherSeqGroupBy[K, A] {
return &PusherSeqGroupBy[K, A]{next: next, getKey: getKey}
}
func (t *PusherSeqGroupBy[K, A]) Push(a A) {
newKey := t.getKey(a)
if len(t.items) == 0 {
t.items = append(t.items, a)
t.curKey = newKey
} else {
if newKey == t.curKey {
t.items = append(t.items, a)
} else {
t.next.Push(t.items)
t.curKey = newKey
t.items = []A{a}
}
}
return
}
func (t *PusherSeqGroupBy[K, A]) Flush() {
if len(t.items) > 0 {
t.next.Push(t.items)
t.next.Flush()
}
t.items = nil
return
}
构造一个 PusherSeqGroupBy 需要传入两个参数:
我们可以画出程序的数据流图(dataflow diagram)如下:
按行读文件 → SeqGroupBy 分组 → 每个组放进汇总器 → 每条汇总结果输出
每个右箭头“→”都对应了一个 Pusher.Push() 的调用。最终可以实现内存中最多持有一个汇总组的数据,做到了随用随销毁。
程序的剩余部分已经很显然了,我想可以留给读者自己完成。从这个例子也可以看出为什么 Pusher 的接口定义中需要有 Flush 。
这个例子我们还可以看出基于状态机的,或 push-style 函数式编程的一个特点:如果说基于迭代器的函数式编程是以数据的源(source)为基础,经过层层变换,最终输出到数据的汇(sink);那么基于状态机的函数式编程则是反过来将数据的汇(sink)层层包装,最后接入数据源。当然,实际上我们也可以同时使用这两种风格,既用迭代器把源变形,又用状态机把汇变形,然后在中间的某个地方拼接在一起,这样,我们可以自由地选择最合适的工具。
2023-12-22 00:00:00
在编程中,我们常用的迭代器(iterator)与我今天要说的状态机(state machine)都是对“流”(stream)的抽象,只不过一个是拉(pull),一个是推(push)。
迭代器的定义一般是这样的:
class Iterator[T] {
T next();
}
即调用一个函数,它不断返回流中的下一个元素。通常还需要其他机制来指示迭代结束,比如添加一个 bool hasNext() 方法(Java),返回两个值,第二个 bool 值表示迭代是否结束(js),抛一个特定异常(Python)等。
任何数据流都有生产者(Producer)和消费者(Consumer),迭代器是生产者的一种抽象,那如果我们把消费者抽象出来,会是什么样的?
我这篇文章还是使用计算机科学的术语,称其为状态机。我理解的状态机的接口定义是这样的:
class Pusher[T] {
void Push(T); // 将一个元素推给状态机
void Flush(); // 标记一个阶段结束
}
如果跟 Go 语言中的 io.Writer 接口对比,是不是非常相似?事实上,我认为 Go 的 io.Reader 可以类比为迭代器,io.Writer 可以类比为状态机。
下面就是有意思的部分了:如果我们可以在迭代器的接口上实现各种函数式编程的操作(如 filter, map ),那我们能否在状态机的接口上实现同样的操作呢(只不过是以 push 的视角)?答案是肯定的。
当然,Rx 框架也可以看作一种实现,只不过我认为它太复杂了,还不如我自己实现。
下面是我用 Go 语言实现的简易 Pusher 及其 filter 定义:
type Pusher[T any] interface {
Push(T)
Flush()
}
type PusherFilter[A any] struct {
next Pusher[A]
filter func(A) bool
}
func NewPusherFilter[A any](f func(A) bool, next Pusher[A]) *PusherFilter[A] {
return &PusherFilter[A]{next, f}
}
func (t *PusherFilter[A]) Push(a A) {
if t.filter(a) {
t.next.Push(a)
}
}
func (t *PusherFilter[A]) Flush() {
t.next.Flush()
}
使用:
pusher := NewPusherFilter(func(item *Item) bool { return productSet[item.Product] }, files)
这种东西有什么用?我们通常更习惯使用迭代器和基于迭代器的函数式操作,但很多时候,设计一个基于迭代器的流式接口可能是很麻烦的。考虑一个例子:遍历文件目录树,流式地返回每个文件的信息。如果一定要做成迭代器,调用一个函数才返回下一个文件信息,那我们不得不手动构造一个栈(stack)来保存中间状态,程序写起来并不直观。
但如果我们用状态机来设计这个东西的接口又如何?我们可能会得到如下接口:
void walk_dir(string dirname, Pusher[FileInfo] pusher);
这样做的好处是让 walk_dir 可以用递归来实现。这里的 pusher 就是一个状态机,你也可以把它近似地看成一个回调函数,但跟回调函数的不同之处在于,Pusher 是可组合(composable)的!我们可以通过 map 、filter 等组合子(combinators)构造出新的匿名 Pusher 。这种可组合性(composability)跟迭代器如出一辙。当然也有不好的一面:失去了迭代器的可以在中间任意位置停下来的能力。
回到 Go 语言本身,由于 Go 语言的迭代器接口还遥遥无期,我这里提出的 Pusher 是一种围魏救赵的办法。关于 pull 和 push 的对偶性(duality),也可以参考 Go 语言核心开发者 rsc 的讨论:user-defined iteration using range over func values · golang/go · Discussion #56413 。
相关文章:
2023-08-17 00:00:00
筛选即 Curated Computing ,也就是像苹果生态这种“所有软件只能从一个经过筛选的应用商店下载”的模式。
编辑指 Editor ,在以前的杂志、报纸时代,人们看的东西都经过编辑编辑,编辑的权力甚至比作者还大,有时可以决定部分内容(想想《三体》和《科幻世界》杂志的编辑,再想想日本漫画杂志编辑对漫画连载内容的影响)。不过随着互联网的兴起,编辑似乎越来越被人们轻视。
以下引用自《科技创业者不是好编辑》:
她们认为自己可以做编辑,但是又打心眼里轻视编辑。这种轻视就她们的立场而言是正确的,因为编辑就是反规模化。
还是去读真正的编辑编出来的东西吧。
过去信息匮乏的时代,重要的是多找信息;而在如今这个信息过剩的时代,重要的是从海量的信息中筛选出真正有价值的东西。而这项工作,是可以外包的,因为别人做得可能比我们自己做得更好,而且可以节省我们的时间。
做这种工作的人就是编辑。
| 领域 | 筛选 | 不筛选 |
|---|---|---|
| 软件 | 苹果 | 安卓 / Windows |
| 信息获取 | 杂志 | 网络 |
| 论坛 | 控评 | 自由发言 |
| 政治 | 独裁 | 民主 |
选择不筛选就是选择自由,你可以做任何事,比如在你的设备上安装任何软件,但你也要承担相应的责任或代价:你要为自己设备的安全负责。下载到流氓软件?中勒索病毒?微软公司会告诉你:你要自己负责,至少学习一下如何安全使用计算机。但苹果公司告诉你:交给我们吧,你只能用我们挑选过的这些应用,但你不必再劳心费神地负责电脑的安全了。我相信这对很多人来说是一种理性的选择,可能也是更好的选择。
以前我更相信自由,现在我明白,很多时候,限制自由可能是更好的选择。当然前提是,你有选择筛选或者不筛选的自由。
再比如网络文章,理论上你可以看网络上所有的东西,但实际上你能做到吗?所以我们一定要有某种筛选机制。这种信息的筛选可以由人——编辑来完成,也可以由机器——推荐算法来实现。
现在流行的信息流推荐,背后隐含的假设是,编辑这项工作,推荐算法可以做得比人更好。但经过这么多年对网络的观察,我认为,这个假定可能是不正确的。
很多基于算法推荐的网站让我感觉推荐的内容质量很差,所以我还是更倾向阅读博客或听播客,也就是让另一个人来告诉我上网应该去看什么、了解什么,而不是推荐算法。
编辑是有观点(不中立)但有品味的,每个人都有自己的个性,你能从编辑筛选出来的文章上学到一个人的品味和个性。而推荐算法在我看来是无情的、“中立”的,“客观”的、没有观点,同时也没有品味。
再比如网络社区建设:让所有人都自由地发言,就能够自发出现一个良好互动的社区吗?这很可能会让社区变成人们倾倒情绪垃圾的“垃圾场”,比如某著名网络垃圾场,所以我认为一定程度的管理还是有必要的。
另一个例子:我发现 QQ 音乐有一些歌是 VIP ,另外一些不是。如果这些 VIP 歌曲是经过 QQ 音乐内部的人工标注,这何尝又不是一种筛选呢?
汉娜·阿伦特在她的《人的境况》中提出了著名的劳动、工作、行动三分法,这启发了我:很多时候事物不是两分的,而可能是三分的。
| 领域 | 筛选 | 中间地带 | 不筛选 |
|---|---|---|---|
| 软件 | 苹果 | 社区软件仓库,如 F-Droid, Chocolatey | 用户自由下载安装软件 |
| 信息获取 | 官媒 | 民间杂志 | 网络 |
| 论坛 | 站长控评 | 版主自治 | 自由发言 |
| 政治 | 独裁 | 民主 | 无政府主义 |
这里推荐一下我最近看到的一篇文章:The Federation Fallacy
这篇文章告诉我们,从电子邮件、BT 下载,再到最近的长毛象,每次人们都心怀“去中心化之梦”创建一种社区,但每次都失败了。最后的结果证明,互联网的中心化是不可避免的。似乎人们从来没能从历史中学习到经验教训。
原因在于,所谓“去中心化”的理想固然美好,但对每个人的技术要求未免太高。
每个人理论上都可以部署自己的电子邮件服务器,但现在有多少人在用自己的邮件服务器收发邮件?
每个人理论上都可以部署自己的长毛象实例,但又有多少人有技术能力去维护它?
BT 下载对技术能力的要求够低了吧,只要打开一个软件一直挂着就行。为什么一样衰落了?(提示:做种需要带宽、磁盘、电费、法务)
所以作者在文章中提出,也许现实中更可行的,并不是完全的去中心化,而是中心化的网站 + 民主的治理机制。作者举的例子是维基百科。我认为广义上也包括各种维基(比如 Fandom)。
我能想到的例子是过去的论坛有站长,站长可以为每个版选择版主,论坛坛友也可以自荐或投票产生版主。
其他例子包括众包做 minecraft 地图、开源社区管理等等。
世界上不只有两条路,还有第三条路等待我们去发现。
P.S. 有什么不错的网络杂志?我认为作为一本面向程序员的杂志,阮一峰的网络日志就不错。关键是它的创作机制:可以由读者投稿,再由编辑挑选。有人说阮一峰的东西深度不够,但我认为,作为编辑,阮一峰的工作是不错的。