第2章：英雄之旅的函数式编程——坎贝尔单一神话的模块化

hero = ordinaryWorld()                    // 1. 平凡世界
quest = callToAdventure(hero)            // 2. 冒险召唤
if (refusalOfCall(hero, quest)) {        // 3. 拒绝召唤
    hero = meetingMentor(hero)            // 4. 遇见导师
}
hero = crossingThreshold(hero)           // 5. 跨越门槛
trials = bellyOfWhale(hero)              // 6. 试炼之路
hero = initiation(hero, trials)          // 7. 最深洞穴
reward = ordeal(hero)                    // 8. 严峻考验
hero = seizeReward(hero, reward)         // 9. 获得报酬
hero = roadBack(hero)                    // 10. 归途
hero = resurrection(hero)                // 11. 复活重生
return apotheosis(hero)                  // 12. 带宝归来

while (!hero.isReady()) {
    challenge = generateChallenge()
    result = hero.face(challenge)
    hero.exp += calculateExp(result)
    hero.levelUp()
}

function heroJourney({
    ordinary = true,          // 是否展示平凡世界
    refusal = false,         // 是否包含拒绝召唤
    mentor = null,           // 导师角色（可为空）
    trials = 3,              // 试炼次数
    death = 'symbolic',      // 死亡类型：literal | symbolic | none
    return = true            // 是否返回原世界
}) { ... }

{
    refusal: false,        // 毫不犹豫接受命运
    mentor: false,         // 没有指导
    death: 'literal',      // 真实死亡
    return: false          // 无法归来
}

{
    ordinary: true,        // 强调对比
    refusal: true,         // 初始抗拒
    trials: many,          // 大量试炼
    death: 'symbolic',     // 精神重生
    return: true           // 必须回归
}

{
    ordinary: false,       // 直接开始
    mentor: multiple,      // 多个导师
    trials: extensive,     // 漫长试炼
    death: 'multiple',     // 多次重生
    return: 'transformed'  // 改变世界
}

callToAdventure(MessageType message)
// 霍格沃茨来信、莱娅公主求救

callToAdventure(DesireType desire)
// 复仇的渴望、证明自己的需要

callToAdventure(AccidentType accident)
// 意外获得超能力、偶然发现秘密

class WiseMentor implements Mentor {
    teach() { return "explicit_knowledge" }
    support() { return "emotional_guidance" }
}
// 甘道夫、邓布利多

class AntagonistMentor implements Mentor {
    teach() { return "learning_by_conflict" }
    support() { return "growth_through_challenge" }
}
// 《龙珠》中的贝吉塔、《火影》中的佐助

class CollectiveMentor implements Mentor {
    teach() { return "distributed_wisdom" }
    support() { return "community_support" }
}
// 《海贼王》的草帽团、《哈利波特》的DA军团

class SelfMentor implements Mentor {
    teach() { return "self_discovery" }
    support() { return "inner_strength" }
}
// 《少年派》的派、《荒野求生》的主角

function combatTrials(hero) {
    enemies = [weak, medium, strong]
    for (enemy of enemies) {
        hero.fight(enemy)
        hero.powerLevel++
    }
}

function puzzleTrials(hero) {
    puzzles = [simple, complex, paradox]
    for (puzzle of puzzles) {
        hero.solve(puzzle)
        hero.intelligence++
    }
}

function socialTrials(hero) {
    relationships = [trust, betrayal, love]
    for (relationship of relationships) {
        hero.navigate(relationship)
        hero.empathy++
    }
}

function moralTrials(hero) {
    dilemmas = [minor, major, ultimate]
    for (dilemma of dilemmas) {
        hero.choose(dilemma)
        hero.wisdom++
    }
}

function calculateReward(heroLevel, challengeDifficulty) {
    return heroLevel * challengeDifficulty * REWARD_MULTIPLIER
}

function determineOutcome(heroStrength, enemyStrength) {
    return heroStrength > enemyStrength ? 'victory' : 'defeat'
}

class StoryState {
    hero: Hero
    world: World
    relationships: Map

    // 所有状态改变都通过方法进行
    transformHero(transformation) {
        this.hero = transformation(this.hero)
        this.logChange('hero', transformation)
    }
}

class StoryEvents {
    emit(event, data) {
        // 记录所有副作用
        this.eventLog.push({event, data, timestamp})
        // 触发相关变化
        this.listeners[event].forEach(listener => listener(data))
    }
}

class StoryMonad {
    constructor(value) {
        this.value = value
        this.sideEffects = []
    }

    map(fn) {
        const result = fn(this.value)
        return new StoryMonad(result.value)
            .addSideEffect(result.sideEffect)
    }

    addSideEffect(effect) {
        this.sideEffects.push(effect)
        return this
    }
}

function createMentor(philosophy) {
    return function(hero, challenge) {
        switch(philosophy) {
            case 'eastern':
                return situation => hero.meditate(situation)
            case 'western':
                return situation => hero.analyze(situation)
            case 'practical':
                return situation => hero.experiment(situation)
        }
    }
}

// 使用
const yoda = createMentor('eastern')
const gandalf = createMentor('western')
const ironman = createMentor('practical')

// 英雄获得的不是答案，而是解决问题的方法
hero.problemSolver = yoda(hero, currentChallenge)

function createThreshold(requirements) {
    return function(hero) {
        const tests = [
            hero => hero.courage > requirements.minCourage,
            hero => hero.wisdom > requirements.minWisdom,
            hero => hero.hasItem(requirements.keyItem),
            hero => hero.hasCompleted(requirements.prerequisite)
        ]

        return tests.every(test => test(hero))
    }
}

// 不同的门槛
const enterMordor = createThreshold({
    minCourage: 10,
    keyItem: 'ring',
    prerequisite: 'destroyIsengard'
})

const enterHogwarts = createThreshold({
    minWisdom: 5,
    keyItem: 'letter',
    prerequisite: 'turn11'
})

function createTransformation(...stages) {
    return function(hero) {
        return stages.reduce((currentHero, stage) => {
            return stage(currentHero)
        }, hero)
    }
}

// 复杂的转变过程
const becomeJedi = createTransformation(
    hero => ({...hero, forceSensitive: true}),
    hero => ({...hero, lightsaber: true}),
    hero => ({...hero, training: 'complete'}),
    hero => ({...hero, wisdom: hero.wisdom * 2}),
    hero => ({...hero, alignment: 'light'})
)

const becomeSuperhero = createTransformation(
    hero => ({...hero, powers: acquirePowers()}),
    hero => ({...hero, identity: 'secret'}),
    hero => ({...hero, responsibility: 'great'}),
    hero => ({...hero, nemesis: createNemesis(hero)})
)

function recursiveHeroJourney(hero, depth = 0) {
    if (depth > MAX_DEPTH) return hero

    const newHero = miniJourney(hero)
    if (newHero.hasAchievedGoal()) {
        return newHero
    }

    return recursiveHeroJourney(newHero, depth + 1)
}

function* iterativeGrowth(hero) {
    while (true) {
        hero = faceChallenge(hero)
        hero = learnLesson(hero)
        hero = incrementPower(hero)
        yield hero

        if (hero.isReady()) break
    }
    return hero
}