Module 6: Control Flow

Complex Sentences — Branching, Looping, and Chaining Logic

You've got the runtime (word order), the type system (measure words), memory management (particles), error handling, a loaded stdlib, and character composition. You can build statements. But your programs are still single-line scripts.

Real programs need control flow — if/else, loops, try/catch, sequential execution. Real Chinese works the same way. Complex sentences use paired connectors that work exactly like the control flow structures you already know. Two keywords, working in tandem, shaping the logic.

// Your Chinese project so far:
import { SVO, TopicComment } from "grammar/runtime";      // Module 1
import { MeasureWords } from "grammar/types";              // Module 2
import { Particles } from "grammar/memory";                // Module 3
import { Negation, Questions } from "grammar/errors";      // Module 4
import * as stdlib from "vocab/core";                      // Module 5

// Now we need logic:
import { If, TryCatch, CauseEffect, And, Loop, EventListener, Chain }
    from "grammar/control-flow";   // THIS MODULE

1. if (condition) { result } — 如果...就...

The most fundamental control flow structure in any language. A condition, and a branch. In Chinese, 如果 sets up the condition, and 就 fires the result. The comma between them is your opening brace.

// Structure:
如果 [condition]，(subject) 就 [result]。

// Maps directly to:
if (condition) {
    result;
}

2. try { expectation } catch { reality } — 虽然...但是...

You expect one outcome, but reality throws an exception. 虽然 sets up what you'd expect, and 但是 catches the twist. It's concession logic: "I acknowledge X, however Y."

// Structure:
虽然 [expectation/concession]，但是 [actual result]。

// Maps to:
try {
    // You'd expect this to lead somewhere...
    expectation;
} catch (realityCheck) {
    // ...but here's what actually holds.
    actual_result;
}

3. cause: X → result: Y — 因为...所以...

Pure causal logic. 因为 states the cause, 所以 states the effect. It's structured logging: every outcome has a traceable reason.

// Structure:
因为 [cause]，所以 [effect]。

// Like a logger entry:
logger.info({ cause: "raining", effect: "stayed home" });

// Or an assertion:
// GIVEN cause → THEN effect

4. condition1 && condition2 — 不但...而且...

Both conditions are true, and the second one escalates. 不但 establishes the first truth, and 而且 stacks a second one on top. Like the && operator — both sides must be true, and the right side often carries more weight.

// Structure:
不但 [fact A]，而且 [fact B (often stronger)]。

// Like &&:
assert(factA && factB);  // both true, B escalates

// Or Array.every():
[factA, factB].every(Boolean);  // all conditions hold

5. while (more(X)) { more(Y) } — 越...越...

A recursive, escalating pattern. The more one thing increases, the more something else increases too. It's a feedback loop — like a recursive function whose output amplifies with each call, or a while loop where the condition and the body scale together.

// Structure:
越 [A] 越 [B]
// The more A, the more B.

// Like:
while (true) {
    A++;
    B++;  // B scales with A
}

// Or a reactive pattern:
X.subscribe(value => Y.set(value * scale));

6. on("event", callback) — 一...就...

An event listener. The instant something happens, the callback fires. 一 marks the trigger event, and 就 marks the immediate response. Zero delay between event and handler.

// Structure:
(subject) 一 [trigger event]，就 [immediate reaction]。

// Maps to:
element.addEventListener("event", () => {
    reaction();  // fires immediately
});

// Or:
emitter.on("trigger", callback);

7. await step1(); await step2(); — 先...然后...

Sequential execution. Do this first, then do that. No branching, no conditions — just ordered steps. It's a Promise chain, an async/await sequence, a pipeline where each stage runs after the previous one completes.

// Structure:
先 [step 1]，然后 [step 2]。

// Maps to:
await step1();
await step2();

// Or Promise chain:
step1()
    .then(() => step2());

8. Error Severity Levels: 但是 vs 可是 vs 不过

Chinese has multiple words for "but," and they differ in weight — like the difference between throwing a fatal error, logging a warning, or printing a debug message. They all signal contrast, but the severity varies.

// Error severity analogy:
throw new Error("...");     // 但是 — formal, strong contrast
console.warn("...");        // 可是 — informal, moderate contrast
console.log("btw...");      // 不过 — mild, "by the way though"

// All three mean "but." The weight is different.

See them in the same sentence frame to feel the difference:

Control Flow Summary

/**
 * Chinese Control Flow v1.0
 *
 * PAIRED CONNECTORS — your complex sentence toolkit:
 *
 * 1. 如果...就...    if/then         if (cond) { result }
 * 2. 虽然...但是...  although/but    try { X } catch { Y }
 * 3. 因为...所以...  because/so      { cause: X, effect: Y }
 * 4. 不但...而且...  not only/also   A && B
 * 5. 越...越...      the more/more   while(more) { scale++ }
 * 6. 一...就...      as soon as      on("event", callback)
 * 7. 先...然后...    first/then      step1().then(step2)
 *
 * "BUT" VARIANTS — error severity levels:
 * 8. 但是 = throw Error    (formal, strong)
 *    可是 = console.warn   (casual, moderate)
 *    不过 = console.log    (soft, gentle)
 *
 * KEY INSIGHT:
 * - Chinese paired connectors work like MATCHED DELIMITERS
 * - Both halves appear (unlike English which uses one or the other)
 * - First keyword = setup, second keyword = payoff
 * - Drop one in casual speech; keep both in writing
 *
 * NEXT MODULE: Module 7
 * → You've got control flow. Time to build real programs.
 */

You now have the full control flow toolkit. These seven patterns handle the vast majority of complex sentences in everyday Mandarin. The paired-connector system is elegant and predictable — once you hear the first keyword, your brain can already predict the structure of the rest of the sentence. That's not memorization. That's pattern matching. And you're an engineer. Pattern matching is what you do.