深入 Rx.NET 的代数根基:Monad、Catamorphism、Anamorphism 与函数式组合原理

原创2026-09-28 19:44:511,651 阅读
文章标签:后端

深入 Rx.NET 的代数根基:Monad、Catamorphism、Anamorphism 与函数式组合原理

导读

本文是 Rx.NET(Reactive Extensions for .NET)核心文档《Appendix D: Rx's Algebraic Underpinnings》的完整展开,系统讲解 IObservable<T> 背后的范畴论基础——Monad、Catamorphism(余积/折叠)与 Anamorphism(展开/生成),并深入分析 SelectMany 的三大 Monad 定律、Aggregate 与 Generate 的代数本质,以及副作用对 Rx 管线组合性的破坏。读完本文,你将理解"为什么 Rx 操作符可以任意自由组合"这一核心问题的数学答案,掌握用 SelectMany 重建 Where/Select 的技巧,并学会用纯函数式风格编写可靠、可测试、无死锁的响应式代码。

为什么 Rx 操作符可以自由组合:契约与代数

Rx 操作符几乎可以按任意方式组合,而且组合之后通常不会出问题。这并非巧合——软件组件之间的集成通常是开发中最痛苦的部分之一,而 Rx 能组合得如此顺畅,很大程度上得益于其背后的数学理论。Rx 的设计让你无需了解这些细节就能使用它,但好奇的开发者往往想知道这些底层原理。

书中前面的章节已经讨论过 Rx 的一个形式化方面:可观察源与其观察者之间的契约。IObserver<T> 存在一套明确定义的语法(grammar),规定 OnNext、OnCompleted、OnError 这三个方法的合法调用方式。这套语法超出了 .NET 类型系统能够强制执行的范畴,因此我们依赖代码"做正确的事"。System.Reactive 库本身始终遵守这一契约,同时还提供了一些防护类型(guard types),用于检测应用程序代码是否违反了规则,并防止这种违规造成严重破坏。

操作符自身依赖上游契约

IObserver<T> 语法之所以重要,是因为组件依赖它来保证正确运行。以 Where 操作符为例:它提供自己的 IObserver<T> 实现来订阅底层源,接收源传来的元素,然后决定哪些转发给订阅 IObservable<T> 的下游观察者。它的核心逻辑大致如下:

public class OverSimplifiedWhereObserver<T> : IObserver<T>
{
    private IObserver<T> downstreamSubscriber;
    private readonly Func<T, bool> predicate;

    public OverSimplifiedWhereObserver(
        IObserver<T> downstreamSubscriber, Func<T, bool> predicate)
    {
        this.downstreamSubscriber = downstreamSubscriber;
        this.predicate = predicate;
    }

    public void OnNext(T value)
    {
        if (this.predicate(value))
        {
            this.downstreamSubscriber.OnNext(value);
        }
    }

    public void OnCompleted()
    {
        this.downstreamSubscriber.OnCompleted();
    }

    public void OnError(Exception x)
    {
        this.downstreamSubscriber.OnError(x);
    }
}

这个类没有显式采取任何步骤来遵守 IObserver<T> 语法,因为它不需要——只要它所订阅的源遵守这些规则即可。由于它只在自己的 OnNext 中调用下游的 OnNext(OnCompleted、OnError 同理),只要上游源遵守这三个方法的调用规则,这个类就会自动地同样遵守这些规则。

实际上,System.Reactive 并没有那么"轻信":它确实有一些代码能检测语法违规,但这些措施只保证一旦进入 Rx 的执行边界语法即被遵守。系统边界处有一些检查,但 Rx 内部机制高度依赖上游源遵守规则这一前提。

不过,IObservable<T> 的语法并不是 Rx 依赖形式化保证正确运行的唯一场所。它还依赖一组特定的数学概念:

  • Monad(单子)
  • Catamorphisms(余积/折叠)
  • Anamorphisms(展开/生成)

标准 LINQ 操作符可以纯粹用这三个概念来表达。

范畴论与函数式编程的历史渊源

这些概念来自范畴论,这是一个相当抽象的、研究数学结构的数学分支。20 世纪 80 年代末,一些计算机科学家开始探索用这些数学概念来建模程序行为。意大利计算机科学家 Eugenio Moggi(当时在爱丁堡大学工作)在 1991 年的论文 Notions of computations and monads 中提出:Monad 特别适合描述计算。随后 Philip Wadler 和 Simon Peyton Jones 将这些理论思想融入了 Haskell 语言,并于 1992 年发表了 monadic handling of IO 的提案。到 1996 年,Haskell v1.3 已将其完全整合,用于以纯函数式语言的强数学基础处理程序输入输出。这被广泛认为是 Haskell 早期 IO 建模方式的一次重大改进。

为什么这些理论重要? 因为这些数学基础正是 LINQ 操作符可以自由组合的原因。范畴论对数学结构有非常深刻的理解,对程序员最有用的成果之一是:它提供了一些规则,只要遵循这些规则,就能保证软件元素组合在一起时表现良好。

Monad:容器抽象的数学本质

Monad 是支撑 LINQ(因此也是 Rx)设计的最重要数学概念。使用 Rx 完全不需要知道 Monad 是什么,最重要的在于:Monad 的数学特性(尤其是对组合的支持)使得 Rx 操作符能够自由组合。

从实用角度看,我们只需知道"它就是这么工作的"。但从理解角度,我们需要明白 LINQ 是如何使用这个概念的:LINQ 把 Monad 视为"物品容器"(container of items)的通用表示。数组、IList<T> 等集合类型都是容器;数据库表虽然与数组差别很大,但也有相似之处。LINQ 背后的基本洞察是:存在一个数学抽象,抓住了"容器"的共同本质。一旦确定某个 .NET 类型是 Monad,数学家们多年来对 Monad 特性的所有研究成果都可以直接应用于该类型。

例如,IEnumerable<T> 是 Monad,IQueryable<T> 也是。对 Rx 至关重要的 IObservable<T> 同样如此。LINQ 的设计依赖 Monad 的性质,因此如果某个 .NET 类型是 Monad,它就有资格成为 LINQ 实现的对象(反之,如果试图为不是 Monad 的类型构建 LINQ provider,很可能遇到问题)。

Monad 依赖的第一个特性与"包含"直接相关:必须能把某个值放入 Monad 之中。所有 Monad 都是泛型类型——这不是巧合,Monad 本质上是类型构造器(type constructor),类型参数表示 Monad 要包含的物品种类。给定一个 T 类型的值,就能把它包装进该类型的 Monad:给定 int 可以得到 IEnumerable<int>。如果不能做到这一点,IEnumerable<T> 就不具备 Monadic 性质。

第二个特性更抽象:如果存在可以应用于单个包含项的函数,且这些函数能以有用的方式组合,那么我们就能创建不作用于单个值、而作用于整个容器的新函数,且这些函数同样可以组合。这使得我们能像自由操作单个值一样自由地操作整个容器。

Monad 的两个操作:return 与 bind

Monad 不只是类型,还必须提供某些操作。第一个操作——把值包装进 Monad——在数学文献中有时叫 unit,在计算领域更常称为 return。这正是 Observable.Return 名称的由来。

技术上并不一定需要一个实际的函数:只要存在某种机制能把值放入 Monad,Monadic 定律即可满足。例如,与 Observable 不同,Enumerable 类型并没有定义 Return 方法,但没关系——直接写 new[] { value } 就够了。

Monad 还要求提供另一个操作。数学文献称之为 bind,一些编程系统叫它 flatMap,LINQ 中则称为 SelectMany。这个操作最容易让人困惑:虽然它有清晰的形式定义,但要说明它"实际做了什么"比 return 更难。不过从容器视角看,bind/SelectMany 的含义很直白:它让我们取出一个"每一项都是嵌套容器"的容器(例如数组的数组,或 IEnumerable<IEnumerable<T>>),并将其扁平化(flatten)。例如,列表的列表会变成一个列表,包含所有列表中的每一项。这个直观解释与 bind 正式数学定义并不显然对应,但与它相容——这就足够我们享受数学家们工作的成果了。

SelectMany 在 IEnumerable<T> 上的形式如下:

public static IEnumerable<TResult> SelectMany<TSource, TResult> (
    this IEnumerable<TSource> source,
    Func<TSource,IEnumerable<TResult>> selector);

这是一个接收两个输入的函数:第一个是 IEnumerable<TSource>;第二个本身是一个函数,输入一个 TSource 产生一个 IEnumerable<TResult>。调用 SelectMany(即 bind)后返回 IEnumerable<TResult>。虽然 bind 的正式定义要求它具备这个形状,但不规定具体行为——任何符合定律的实现都是可接受的。不过在 LINQ 语境下,我们期望特定行为:对源枚举中的每个 TSource 调用一次函数(第二个参数),然后收集所有 IEnumerable<TResult> 产生的结果,包装成一个大的 IEnumerable<TResult>。对 IEnumerable<T> 而言,可以描述为"每个输入值得到一个输出集合,然后拼接所有输出集合"。

但我们不能太具体:即使只看 LINQ 用 Monad 表示通用容器这一层,SelectMany 也未必意味着拼接。它只要求返回的容器包含函数产生的所有元素。拼接是一种策略,而 Rx 做了不同的事:由于可观察序列倾向于"想产生值时随时产生",Observable.SelectMany 返回的 IObservable<TResult> 会在每个 IObservable<TResult> 产生值时立即产生一个值(它会做一些同步以确保遵守 Rx 调用 IObserver<T> 的规则——如果其中一个可观察序列在向下游订阅者调用 OnNext 的过程中产生值,它会等待该调用返回后再推送下一个值)。因此源值在这里本质上是**交错(interleaved)**而非拼接的。但更宽泛的原则——结果是包含回调为每个输入产生的所有值的容器——仍然成立。

Monadic bind 的数学定义具有相同的基本形状,只是不规定特定行为。任何 Monad 的 bind 操作都接收两个输入:为某个输入值类型(TSource)构造的 Monad 实例,以及一个接收 TSource、产生为某个输出值类型(TResult)构造的 Monad 实例的函数。调用后得到为输出值类型构造的 Monad 实例。我们无法在 C# 类型系统中精确表达这个通用概念,但可以给出大致的味道:

// An impressionistic sketch of the general form of a monadic bind
public static M<TResult> SelectMany<TSource, TResult> (
    this M<TSource> source,
    Func<TSource, M<TResult>> selector);

把你选择的 Monadic 类型(IObservable<T>、IEnumerable<T>、IQueryable<T> 等)代入 M<T>,就知道该类型的 bind 应该长什么样。

三大 Monad 定律

一个 Monad 由类型构造器(如 IObservable<T>)和两个函数 Return 与 SelectMany 组成。但要称得上 Monad,还必须遵守三条"定律":

  1. Return 是 SelectMany 的左单位元(left-identity)
  2. Return 是 SelectMany 的右单位元(right-identity)
  3. SelectMany 应具有结合性(associativity)

这些定律是基于 Monad 的操作可以组合的基石。定律比较抽象,并不显然"为什么"它们能带来组合性,但它们是不可协商的:如果你的类型和操作不遵守这些定律,你就没有 Monad,也就无法依赖 Monad 保证的特性。

定律 1:Return 是 SelectMany 的左单位元

这条定律意味着:把某个值 x 传入 Return,再把结果作为 SelectMany 的输入之一(另一个输入是函数 SomeFunc),结果应与直接把 x 传入 SomeFunc 完全相同。例如:

// Given a function like this:
//  IObservable<bool> SomeFunc(int)
// then these two should be identical.
IObservable<bool> o1 = Observable.Return(42).SelectMany(SomeFunc);
IObservable<bool> o2 = SomeFunc(42);

非正式地理解:SelectMany 把输入容器中的每个元素推入 SomeFunc,每次调用产生一个 IObservable<bool> 容器,再把这些容器合并成一个大容器。但本例中输入给 SelectMany 的容器只有一个元素,没有合并工作要做——SelectMany 只调用一次函数,产生一个输出 IObservable<bool>,它必须返回一个包含该单次调用产生的容器中全部内容的新容器。既然只有一个调用,无需合并多个容器的元素,因此直接对单个输入项调用 SomeFunc 即可。

如果 o1 与 o2 有任何不同,就意味着以下三种情况之一:

  • o1 包含 o2 中没有的元素(即它包含了 SomeFunc 没有产生的元素)
  • o2 包含 o1 中没有的元素(即 SelectMany 遗漏了 SomeFunc 产生的某些元素)
  • o1 与 o2 包含相同元素,但在该 Monad 类型可检测的意义上不同(例如元素顺序不同)

这条定律实质上是形式化了这样一个观点:SelectMany 不应增加或删除元素,也不应破坏 Monad 通常会保留的特性(如顺序)。注意在 .NET LINQ provider 中,这通常不要求它们是完全相同的对象(它们通常不是),只要求它们表示完全相同的内容——例如这里 o1 和 o2 都是 IObservable<bool>,意味着它们应产生完全相同的 bool 值序列。

定律 2:Return 是 SelectMany 的右单位元

这条定律意味着:把 Return 作为函数输入传给 SelectMany,再把某个 Monadic 类型的值作为另一个参数传入,输出应得到这个值本身。例如:

// These two should be identical.
IObservable<int> o1 = GetAnySource();
IObservable<int> o2 = o1.SelectMany(Observable.Return);

把 Return 用作 SelectMany 的函数,相当于"把输入容器中的每个元素包进它自己的容器(Return 包装单个元素),再把所有这些容器扁平化回单个容器"。我们加了一层包装又把它去掉,因此它理应对结果没有影响。

定律 3:SelectMany 应具有(有效的)结合性

假设有两个函数 Tx1 和 Tx2,都适合作为 SelectMany 的参数。应用它们有两种方式:

// These two should be identical.
IObservable<int> o1 = source.SelectMany(x => Tx1(x).SelectMany(Tx2));
IObservable<int> o2 = source.SelectMany(x => Tx1(x)).SelectMany(Tx2);

区别只是括号位置的变化:第二个 SelectMany 调用(用于 Tx2)是放在传给另一个 SelectMany 的函数内部,还是作用在另一个 SelectMany 的结果之上。用等价的直接函数引用重写更能看清结构差异:

IObservable<int> o1 = source
    .SelectMany(x => Tx1(x).SelectMany(Tx2));
IObservable<int> o2 = source
    .SelectMany(Tx1)
    .SelectMany(Tx2);

第三条定律要求这两种写法效果相同——Tx2 的 SelectMany 调用发生在第一个 SelectMany 调用"内部"还是"之后",无关紧要。

非正式的理解是:SelectMany 有效执行了两个操作——变换和解包(unwrap)。变换由传入的函数定义,但由于该函数返回 Monad 类型(即返回一个可能包含任意数量元素的容器),SelectMany 会把函数每次返回的容器解包,以把所有元素收集进最终返回的单一容器。当这种操作嵌套时,解包发生的顺序无关紧要。例如:

IObservable<int> Tx1(int i) => Observable.Range(1, i);
IObservable<string> Tx2(int i) => Observable.Return(i.ToString());

第一个函数把数字转换成同长度的数字区间:1 变成 [1],3 变成 [1,2,3]。先用 Select 作用于产生数字区间的源:

IObservable<int> input = Observable.Range(1, 3); // [1,2,3]
IObservable<IObservable<int>> expandTx1 = input.Select(Tx1);

得到一个序列的序列,即:

[
    [1],
    [1,2],
    [1,2,3],
]

如果改用 SelectMany:

IObservable<int> expandTx1Collect = input.SelectMany(Tx1);

它会应用同样的变换,但把结果扁平化回单个序列:

[
    1,
    1,2,
    1,2,3,
]

(保留换行是为了强调与前述输出的联系,其实可以直接写成 [1,1,2,1,2,3]。)

再应用第二个变换,若用 Select:

IObservable<IObservable<string>> expandTx1CollectExpandTx2 = expandTx1Collect
    .SelectMany(Tx1)
    .Select(Tx2);

每个数字传入 Tx2 后被转换成包含单个字符串的序列:

[
    ["1"],
    ["1"],["2"],
    ["1"],["2"],["3"]
]

若最后一层也改用 SelectMany:

IObservable<string> expandTx1CollectExpandTx2Collect = expandTx1Collect
    .SelectMany(Tx1)
    .SelectMany(Tx2);

则扁平化回纯字符串序列:

[
    "1",
    "1","2",
    "1","2","3"
]

结合性要求:把 Tx1 放在传给第一个 SelectMany 的函数内部,与把它作用于第一个 SelectMany 的结果上,效果应当相同。所以与其从 input.Select(Tx1) 开始:

IObservable<IObservable<IObservable<string>>> expandTx1ExpandTx2 =
    input.Select(x => Tx1(x).Select(Tx2));

(产生 [ [["1"]], [["1"],["2"]], [["1"],["2"],["3"]] ])

不如把嵌套调用改为 SelectMany:

IObservable<IObservable<string>> expandTx1ExpandTx2Collect =
    input.Select(x => Tx1(x).SelectMany(Tx2));

(扁平化内部元素,但外层仍是 Select,所以还是列表的列表:[ ["1"], ["1","2"], ["1","2","3"] ])

再把外层 Select 也改为 SelectMany:

IObservable<string> expandTx1ExpandTx2CollectCollect =
    input.SelectMany(x => Tx1(x).SelectMany(Tx2));

(扁平化最外层,得到与之前相同的最终结果:[ "1", "1","2", "1","2","3" ]。)

这正是第三条 Monad 定律要求的结果。总结一下,两条路径分别是:

  • 展开并变换 Tx1,扁平化,展开并变换 Tx2,扁平化
  • 展开并变换 Tx1,展开并变换 Tx2,扁平化,扁平化

两者都应用了两次变换,并展开了这些变换添加的多余容器层。尽管中间步骤看起来不同,最终结果相同——因为在每次变换后解包,与先完成两个变换再解包,并无区别。

为什么这些定律重要

这三条定律直接对应普通函数组合对数字成立的定律。如果有两个函数 ff 和 gg,可以写一个新函数 h=g(f(x))h = g(f(x))。这种组合方式叫复合(composition),常写作 g∘fg \circ f。如果恒等函数叫 idid,那么以下命题为真:

  • id∘fid \circ f 等价于 ff
  • f∘idf \circ id 等价于 ff
  • (f∘g)∘s(f \circ g) \circ s 等价于 f∘(g∘s)f \circ (g \circ s)

它们与三条 Monad 定律一一对应。非正式地说,这反映了 Monadic bind 操作(SelectMany)与函数复合在结构上具有深刻相似性——这正是我们能自由组合 LINQ(以及 Rx)操作符的原因。

用 SelectMany 重建其他操作符

前面提到 LINQ 核心有三个数学概念:Monad、Anamorphism 和 Catamorphism。虽然前面的讨论聚焦于 SelectMany,其意义远不止于此,因为其他标准 LINQ 操作符可以用这些原语表达。例如,只用 Return 和 SelectMany 实现 Where:

public static IObservable<T> Where<T>(this IObservable<T> source, Func<T, bool> predicate)
{
    return source.SelectMany(item =>
        predicate(item)
            ? Observable.Return(item)
            : Observable.Empty<T>());
}

以及实现 Select:

public static IObservable<TResult> Select<TSource, TResult>(
    this IObservable<TSource> source, Func<TSource, TResult> f)
{
    return source.SelectMany(item => Observable.Return(f(item)));
}

有些操作符需要 Catamorphism 或 Anamorphism,下面分别讨论。

Catamorphisms:把容器折叠成结果

Catamorphism 本质上是"考虑容器中每个元素的处理"的推广。在 LINQ 实践中,它通常指检查所有值并产生单一结果的过程,例如 Observable.Sum。更一般地说,任何形式的聚合(aggregation)都是 Catamorphism。Catamorphism 的数学定义比这更宽泛——它不一定要把东西归约为单个值——但就理解 LINQ 而言,这个容器视角是最直接的思考方式。

Catamorphism 是 LINQ 的基本构件之一,因为你无法用其他元素构造出 Catamorphism。但许多 LINQ 操作符可以由 LINQ 最基本的 Catamorphism——Aggregate 操作符构建。例如用 Aggregate 实现 Count:

public static IObservable<int> MyCount<T>(this IObservable<T> items)
    => items.Aggregate(0, (total, _) => total + 1);

以及实现 Sum:

public static IObservable<T> MySum<T>(this IObservable<T> items)
    where T : INumber<T>
    => items.Aggregate(T.Zero, (total, x) => x + total);

后者比聚合章节中的类似求和示例更灵活——那个示例只适用于 IObservable<int>,这里用 C# 11.0 与 .NET 7.0 引入的**泛型数学(generic math)**特性,使 MySum 能处理任何类似数字的类型。基本原理是相同的。

F-代数视角下的 Catamorphism

Catamorphism 的定义之一是"从初始代数到某个其他代数的唯一同态"(the unique homomorphism from an initial algebra into some other algebra)。与范畴论中许多表述一样,这只有在你已经理解它要描述的概念时才容易懂。Catamorphism 对"代数"持更一般的观点:它本质上指"某种表达式可以被构造和求值的系统"。

更精确地说,Catamorphism 与 F-代数(F-algebra) 相关,后者是三个东西的组合:

  1. 一个函子(Functor) FF,在某个范畴 CC 上定义某种结构
  2. 范畴 CC 中的某个对象 AA
  3. 从 FAF A 到 AA 的一个态射(morphism),它有效地求值该结构

什么是 Functor?从 LINQ 视角看,它本质上是任何实现了 Select 的东西(有些编程系统称之为 fmap)。从容器视角看它是两件事:1)一个容器类的类型构造器(如 IEnumerable<T> 或 IObservable<T>),2)某种把函数应用于容器内所有元素的手段。所以如果你有一个把 string 转换为 int 的函数,Functor 允许你一步把它应用于容器中的每个元素。

IEnumerable<T> 与其 Select 扩展方法的组合就是一个 Functor——可以用 Select 把 IEnumerable<string> 转换为 IEnumerable<int>。IObservable<T> 与其 Select 构成另一个 Functor。至于"在某个范畴 CC 上"——这涉及 Functor 的数学描述更宽泛的一面。开发者使用范畴论时通常局限于代表"类型(如 int)与函数"的范畴。严格来说 Functor 从一个范畴映射到另一个范畴,但编程中我们总是使用代表类型的范畴,因此所用 Functor 的 CC 与 DD 相同——严格讲应称它们为 Endofunctor(自函子),但没人这么较真,实践中直接用 Functor 这个名字,默认指代类型与函数范畴上的 Endofunctor。

回到 F-代数的三个部分:对象 AA 可能是 string 类型;若所选 Functor 是 IObservable<T> 与其 Select 的组合,则 FAF A 就是 IObservable<string>。而"态射"在我们的语境下就是函数。因此 F-代数可重述为更熟悉的形式:

  1. 某个容器类泛型类型,如 IObservable<T>
  2. 一个元素类型 AA(如 string、int)
  3. 一个接收 IObservable<A> 并返回 A 类型值的函数(如 Observable.Aggregate<A>)

这具体多了。范畴论通常关心数学结构最一般的真理,这种重构丢弃了那种一般性;但从想借助数学理论的程序员角度看,这没问题——只要所做之事符合 F-代数的模式,数学家推导出的通用结论就适用于我们对理论的专业化应用。

值得一提的是,F-代数的一般概念还能做更多事:Functor 可以是表示编程语言表达式的类型,你可以创建求值这些表达式的 F-代数——这类似于 LINQ 的 Aggregate,遍历 Functor 表示的整个结构(IEnumerable<T> 中的每个元素,或表达式中的每个子表达式),归约为单个值,只是 Functor 表示的不是序列而是更复杂的结构。

从理论角度看,第三部分不一定要归约:理论上类型可以是递归的,元素类型 AA 就是 FAF A(这对表达式这类固有递归结构很重要)。而且通常存在一个最一般的 F-代数,其函数(态射)只处理结构、不做任何归约。Catamorphism 的概念是:同一 Functor 还有其他不那么一般的 F-代数。

对 IObservable<T> 而言,最一般的概念是:源产生的每个元素都可以通过反复应用某个二元函数来处理——一个参数是容器中的 T 值,另一个是某种累加器(accumulator),代表迄今聚合的全部信息——函数返回更新后的累加器,准备与下一个 T 一起再次传入函数。然后是更具体的形式,应用特定的累加逻辑(求和、求最大值等)。技术上,Catamorphism 是"从一般形式到特殊形式"的联系;但实践中,通常把具体的特殊形式(如 Sum 或 Average)也称为 Catamorphism。

留在容器内部:Rx 聚合的务实选择

虽然一般意义上 Catamorphism 可以剥离容器(如 IEnumerable<int> 的 Sum 产生 int),但这并非必需——而且 Rx 中大多数 Catamorphism 不会这么做。正如调度与线程章节的 Lock-ups 一节所述,阻塞某个线程等待只有 IObservable<T> 完成特定动作后才会出现的结果(例如计算总和必须等看到所有元素),在实践中是死锁的温床。

因此,大多数 Catamorphism 执行某种归约,但继续把结果包装在 IObservable<T> 中产出。这也是为什么 Rx 的聚合操作符(如 Aggregate、Sum、Min、Max)返回的是 IObservable<T> 而非裸值——聚合值在源完成时以单个值的形式推送给订阅者。

Anamorphisms:从种子展开结构

Anamorphism 大致是 Catamorphism 的对偶(dual)。Catamorphism 把某种结构折叠成更简单的东西,而 Anamorphism 把输入展开成更复杂的结构。例如,给定某个数字(如 5),可以想象一种机制把它变成具有指定数量元素的序列(如 [0,1,2,3,4])。

我们甚至不用想象——这正是 Observable.Range 做的事。我们也可以把 Monadic 的 Return 操作看作一个非常简单的 Anamorphism:给定 T 类型的值,Observable.Return 把它展开成一个 IObservable<T>。Anamorphism 本质上是这类思想的推广。

Anamorphism 的数学定义是"把余代数(coalgebra)指派到其到某个自函子最终余代数的唯一态射"——这是 Catamorphism 定义的对偶,从范畴论看就是反转所有态射的方向。在我们的非完全一般化的应用中,涉及的态射在 Catamorphism 里是"把元素归约为输出",在 Anamorphism 中就变成"把某个值展开为容器类型的实例"(如从 int 到 IObservable<int>)。

与 Catamorphism 类似的核心观点是:Functor 最一般的余代数(coalgebra)体现了 Functor 本质结构的理解,Anamorphism 利用它定义各种展开。Observable.Generate 代表了这种最一般的能力:它有产生 IObservable<T> 的能力,但需要提供特定的展开函数来生成任何特定的可观察序列。

在仓库源码中可以看到 Generate 的完整签名(Observable.Creation.cs):

public static IObservable<TResult> Generate<TState, TResult>(
    TState initialState,
    Func<TState, bool> condition,
    Func<TState, TState> iterate,
    Func<TState, TResult> resultSelector)

public static IObservable<TResult> Generate<TState, TResult>(
    TState initialState,
    Func<TState, bool> condition,
    Func<TState, TState> iterate,
    Func<TState, TResult> resultSelector,
    IScheduler scheduler)

Generate 接收四个函数式参数:初始状态 initialState、继续条件 condition、迭代函数 iterate 和结果选择器 resultSelector,并可选调度器 scheduler。这正是"最一般展开能力"的体现——Range 只是它的一个特例。仓库还在 Observable.Time.cs 提供了带 timeSelector 的 Generate 重载,可基于状态生成带时间间隔的序列(Observable.Generate 的定时版本),进一步展示展开能力与调度/时间的结合。

三种运算与操作符的对应关系

现在回顾我们如何使用这些理论概念。共有三种运算:

  • Anamorphism 进入序列:T1 --> IObservable<T2>
  • Bind 修改序列:IObservable<T1> --> IObservable<T2>
  • Catamorphism 离开序列:逻辑上 IObservable<T1> --> T2,但实践中通常是 IObservable<T1> --> IObservable<T2>(输出可观察序列只产生单个值)

顺带一提,bind 与 catamorphism 因 Google 的 MapReduce 框架而闻名——Google 借用了某些函数式语言中更常用的名字 Map 和 Reduce 来称呼 Bind 与 Catamorphism。

大多数 Rx 操作符实际上是这些高阶函数式概念的特化。举几个例子:

在真实源码中,Select 的 Monadic 身份与 SelectMany 的 bind 身份在 Observable.StandardSequenceOperators.cs 有清晰体现——SelectMany 提供从 Func<TSource, IObservable<TResult>> 选择器(bind 的标准形态)到携带索引的 Func<TSource, int, IObservable<TResult>> 选择器、再到 Task<TResult> 与 CancellationToken 重载的一系列版本,说明 bind 这一单一概念在 Rx 中被扩展到了异步任务世界;而 Aggregate 的 Catamorphism 形态(种子 TAccumulate + Func<TAccumulate, TSource, TAccumulate> 累加器)位于 Observable.Aggregates.cs。

Amb:来自 McCarthy 的歧义操作符

Amb 方法是我(作者)开始使用 Rx 时的新概念。这个函数最早由 John McCarthy 在 1961 年发表于《Proceedings of the Western Joint Computer Conference》的论文 'A Basis for a Mathematical Theory of Computation' 中引入(数字副本很难找,但 1963 年有修订版发表在《Computer Programming and Formal Systems》)。它是单词 Ambiguous(歧义)的缩写。Rx 在此处偏离了 .NET 类库的常规命名约定,使用这个缩写,一方面因为 amb 是这个操作符的既定名称,另一方面也是向 McCarthy 致敬——他的工作是 Rx 设计的灵感来源之一。

Amb 做什么

**歧义函数(ambiguous function)**的基本思想是:我们被允许定义多种产生结果的方式,其中部分或全部可能在实践中无法产生结果。假设我们定义了一个歧义函数 equivocate,对某个特定输入值,equivocate 的所有组成部分——我们给它的所有计算方式——都无法处理该值(例如每个组成部分都用输入做除数,若输入为 0,则所有组成部分都会尝试除以 0)。在这种情况下,equivocate 本身也无法产生结果。但如果输入的某个值恰好只有其中一个组成部分能产生结果,那么该结果就成为 equivocate 对该输入的结果。

本质上:我们提供一堆处理输入的不同方式;若恰好有一种能产生结果,就选择该结果;若没有一种能产生任何结果,歧义函数也不产生任何东西。

Rx 与 McCarthy 原始定义的差异

更微妙(也是 Rx 偏离 amb 原始定义之处)的地方在于:当歧义函数的多个组成部分都能产生结果时。在 McCarthy 的理论表述中,歧义函数实际上把所有结果都作为可能输出产生出来——这在技术上称为非确定性(nondeterministic)计算,但这个名称可能误导:它听起来像结果不可预测,但并非如此。可以这样想象:求值歧义函数的计算机克隆自己,为每个可能的结果生成一份副本,并继续执行每一份副本。你可以想象一个多线程实现——每次歧义函数产生多个可能结果时就创建那么多新线程以求值所有可能结果。这是非确定性计算的合理心智模型,但不是 Rx 的 Amb 操作符实际做的事。在引入歧义函数的那类理论工作中,歧义往往最终消失:计算本可以有许多种进行方式,但它们最终可能都产生相同结果。

Rx 的 Amb 提供了"没有输入产生任何东西"和"恰好一个输入能产生东西"这两种情形下描述的行为;但它不尝试支持非确定性计算,因此对"多个组成部分都能产生值"情形的处理是过度简化的。不过 McCarthy 的 amb 首先是一种分析工具,任何实际实现都不可能完全达到它。

留在 Monad 内部:混用编程范式的代价

使用 Rx 时,很容易在不同编程风格之间切换。在 Rx 适用性显而易见的部分,我们自然使用 Rx;但当事情变得棘手时,切换轨道可能看起来最容易——比如 await 一个可观察序列然后用普通顺序代码继续;或者让传给 Select、Where 等操作符的回调在执行主要工作的同时做额外的事情(产生有用的副作用)。

虽然这样做有时能工作,但范式切换应当谨慎,因为它通常是死锁、可扩展性等并发问题的常见根源。根本原因是:只要停留在 Rx 的做事方式内,你就会受益于数学基础的可靠性。但这要求你使用函数式风格:函数应处理输入并基于输入确定性地产生输出,既不应依赖外部状态,也不应改变它。这要求可能很高,也不总是能做到,但如果你打破这些规则,很多理论就会失效,组合无法像应该的那样可靠地工作。因此,使用函数式风格并把代码保持在 Rx 惯用法内,往往会提高可靠性。

副作用的代价与应对

程序要做出有用的事情就必须有副作用——如果程序运行后世界毫无变化,不如不运行——所以值得探讨副作用的问题,以便在必要时知道如何最好地处理。如果一个函数除了返回值之外还有其他可观察效应,就认为它有副作用。通常"可观察效应"是状态的修改。这种效应可能是:

  • 修改作用域超出函数本身的变量(全局、静态或某个参数)
  • I/O 操作,如读取或修改文件、发送或接收网络消息、更新显示
  • 引起物理活动,如自动售货机吐出一个物品,或把硬币导向硬币箱

函数式编程总体上尽量避免制造任何副作用。有副作用的函数(尤其是修改状态的)要求程序员理解的不只是函数的输入输出——完整理解函数操作可能要知道被修改状态的完整历史和上下文。这会大大增加函数复杂度,使其更难以正确理解和维护。

副作用并不总是有意的。减少意外副作用的一个简单方法是减小变更的暴露面(surface area)。开发者可以采取两个简单行动:降低状态的可见性或作用域,以及尽可能让状态不可变。可以通过把变量限定在方法这样的代码块内(而不是作为字段或属性)来降低可见性;可以把类成员设为 private 或 protected 来降低可见性;不可变数据按定义无法被修改,因此不会表现出副作用。这些是明智的封装规则,能显著提高 Rx 代码的可维护性。

一个带有副作用的查询示例

为了给出带副作用的简单查询示例,我们尝试通过更新一个变量(闭包)来输出订阅收到的元素的索引和值:

IObservable<char> letters = Observable
    .Range(0, 3)
    .Select(i => (char)(i + 65));

int index = -1;
IObservable<char> result = letters.Select(
    c =>
    {
        index++;
        return c;
    });

result.Subscribe(
    c => Console.WriteLine("Received {0} at index {1}", c, index),
    () => Console.WriteLine("completed"));

输出:

Received A at index 0
Received B at index 1
Received C at index 2
completed

这看起来无害,但设想另一个开发者看到这段代码,认为这是团队使用的模式并加以效仿。为了说明问题,我们在前例中增加一个重复订阅:

var letters = Observable.Range(0, 3)
                        .Select(i => (char)(i + 65));

var index = -1;
var result = letters.Select(
    c =>
    {
        index++;
        return c;
    });

result.Subscribe(
    c => Console.WriteLine("Received {0} at index {1}", c, index),
    () => Console.WriteLine("completed"));

result.Subscribe(
    c => Console.WriteLine("Also received {0} at index {1}", c, index),
    () => Console.WriteLine("2nd completed"));

输出:

Received A at index 0
Received B at index 1
Received C at index 2
completed
Also received A at index 3
Also received B at index 4
Also received C at index 5
2nd completed

第二个订阅者的输出明显是错的——他们期望索引是 0、1、2,却得到 3、4、5。我在代码库中见过远比这险恶的副作用版本:讨厌的那些往往修改布尔状态,如 hasValues、isStreaming 等。

除了在现有软件中制造潜在不可预测的结果,表现出副作用的程序更难测试和维护。对带副作用的程序做未来重构、增强或其他维护,更容易变得脆弱——在异步或并发软件中尤其如此。

在管道中组合数据:正确的状态管理方式

捕获状态的首选方式是把它作为构成订阅的 Rx 操作符管道中流动信息的一部分。理想情况下,我们希望管道的每个部分独立且确定——管道中的每个函数应只有输入和输出作为其唯一状态。修正上面的示例,可以丰富管道中的数据,使其没有共享状态。这正是使用暴露索引的 Select 重载的好例子:

IObservable<int> source = Observable.Range(0, 3);
IObservable<(int Index, char Letter)> result = source.Select(
    (idx, value) => (Index: idx, Letter: (char) (value + 65)));

result.Subscribe(
    x => Console.WriteLine($"Received {x.Letter} at index {x.Index}"),
    () => Console.WriteLine("completed"));

result.Subscribe(
    x => Console.WriteLine($"Also received {x.Letter} at index {x.Index}"),
    () => Console.WriteLine("2nd completed"));

输出:

Received A at index 0
Received B at index 1
Received C at index 2
completed
Also received A at index 0
Also received B at index 1
Also received C at index 2
2nd completed

两次订阅现在都得到正确的索引 0、1、2,因为索引作为数据随元素流过管道,而不是驻留在被共享的可变变量中。

跳出常规思路,还可以用 Scan 等特性达到类似效果:

var result = source.Scan(
                new
                {
                    Index = -1,
                    Letter = new char()
                },
                (acc, value) => new
                {
                    Index = acc.Index + 1,
                    Letter = (char)(value + 65)
                });

这里的关键是隔离状态,减少或消除像修改可变状态那样的副作用。Scan 把累加器作为输入之一随流传递,每个元素产生新的累加器——状态始终在数据流中显式流动,符合 Catamorphism 的"容器内聚合"精神(Scan 可视为不等待完成的 Aggregate),也让每次订阅都拥有自己独立的累加历史。

结语:把数学基础当作工程纪律

Rx 之所以能成为 .NET 生态中组合性极强的响应式编程库,深层原因在于其操作符设计建立在一套经过数十年数学锤炼的概念之上:Monad 的 Return/SelectMany 及其三条定律保证了操作符可以像函数复合一样任意组合;Catamorphism(以 Aggregate 为代表)与 Anamorphism(以 Generate、Range、Return 为代表)分别负责"折叠"与"展开"两个方向的构造;Amb 则提醒我们,即便是最"歧义"的操作符也以明确的规则工作。理解了这些代数根基之后,最重要的实践收获是:坚持函数式风格、把状态留在数据管道中流动、避免共享可变状态——这样你的 Rx 代码不仅能自由组合,而且可靠、可测试、易于维护。这些理论细节你完全可以在日常编码中忽略,但正如本文所示,它们一直在幕后保证"它就这么工作"。

登录后查看全文
reactive