组合模式

Rotifer 提供形式化的基因代数，用于将简单基因组合为复杂行为。

组合算子

Seq — 顺序执行

依次执行基因，将每个基因的输出作为下一个基因的输入。

Seq(A, B, C) = A → B → C

import { Seq } from "@rotifer/algebra";

const pipeline = Seq(
  "genesis-web-search",    // 第 1 步：搜索网页
  "text-summarize",        // 第 2 步：摘要结果
  "text-translate"         // 第 3 步：翻译摘要
);

Par — 并行执行

并发执行基因并收集所有结果。使用线程池实现真正的 CPU 并行。

Par(A, B, C) = A ‖ B ‖ C → [resultA, resultB, resultC]

import { Par } from "@rotifer/algebra";

const multiSearch = Par(
  "genesis-web-search",
  "genesis-web-search-lite",
  "academic-search"
);

Cond — 条件分支

基于运行时谓词选择执行哪个基因。

import { Cond } from "@rotifer/algebra";

const smartSearch = Cond(
  (input) => input.query.length > 100,
  "deep-research-gene",    // 长查询：深度研究
  "genesis-web-search"     // 短查询：快速搜索
);

Try — 错误恢复

执行主基因；如果失败，回退到备选基因。

import { Try } from "@rotifer/algebra";

const resilientSearch = Try(
  "premium-api-search",    // 先尝试高级 API
  "genesis-web-search"     // 回退到免费搜索
);

Transform — 数据转换

在基因之间应用转换函数重塑数据。

import { Transform, Seq } from "@rotifer/algebra";

const pipeline = Seq(
  "genesis-web-search",
  Transform((r) => ({
    text: r.results.map(r => r.snippet).join("\n"),
    maxLength: 200
  })),
  "text-summarize"
);

组合模式

模式 1：搜索 → 摘要 → 翻译管线

const researchPipeline = Seq(
  "genesis-web-search",
  Transform((r) => ({ text: r.results[0].snippet })),
  "text-summarize",
  Transform((r) => ({ text: r.summary, targetLang: "zh" })),
  "text-translate"
);

模式 2：并行搜索与聚合

const multiSourceSearch = Seq(
  Par("web-search", "academic-search", "code-search"),
  Transform((results) => ({
    text: results.flat().map(r => r.title).join(", ")
  })),
  "text-summarize"
);

模式 3：带回退的弹性管线

const robustPipeline = Seq(
  Try("premium-search", "free-search"),
  Try("gpt4-summarize", "local-summarize"),
  "text-translate"
);

类型安全

组合代数在组合时强制类型兼容性：

• Seq(A, B) 要求 A.outputSchema ⊇ B.inputSchema
• Par(A, B) 要求 A.inputSchema = B.inputSchema
• Cond(p, T, F) 要求 T.outputSchema = F.outputSchema

不兼容的组合会产生编译时错误。

适应度影响

组合基因从其组件继承适应度：

• Seq — F(Seq) = min(F(components)) × latency_penalty
• Par — F(Par) = avg(F(components)) × parallelism_bonus
• Try — F(Try) = F(primary) × success_rate + F(fallback) × (1 - success_rate)