技术笔记

今天，Aura 正式发布了第一个版本（nightly-2026.10.10）。

这不是又一个“给 AI 写代码用的工具”，而是一个为 LLM Agent 运行时自我修改 而设计的 AI 原生 Lisp 运行时。

什么是 Aura？

Aura 是 AI-native Lisp —— 代码自己进化。

它让 AI Agent 在运行时拥有精确读写和修改自身代码的能力。代码不再是静态文本，而是可查询、可变异、可版本化的一等公民。

传统编译器是批处理工具：写完、编译、运行。Aura 把编译器变成常驻服务，Agent 可以在毫秒级完成「查询 → 变异 → 增量重编译 → 评估」的闭环，实现真正的自主代码生成、编辑与演化。

为什么需要它？

当前的 AI Agent（包括各种 coding agent）大多停留在“生成代码 → 外部执行 → 观察结果 → 再生成”的循环。这个循环有三个根本问题：

1. 精度不足：Agent 只能通过字符串/diff 操作代码，难以精确定位和安全修改 AST 节点。
2. 反馈太慢：完整编译或解释成本高，迭代速度受限。
3. 状态不可控：缺乏版本化、回滚、并发安全的自修改机制。

Aura 直接在语言运行时层面解决这些问题。

核心能力

• 代码即数据（FlatAST）
  代码被表示为可查询、可变异、可版本化的 FlatAST。Agent 通过 query:* / mutate:* 原语在运行时精确读写自身代码，通过 ast:snapshot / ast:rollback 管理版本。

• Agent 编排
  内置 agent:spawn、orch:conduct、orch:pipeline、orch:parallel 等原语，支持多 Agent 协作管线（并行/串行/重试/条件分支）。

• 增量编译
  EDSL cache 基于 source-hash 失效，mutate 后只重编译受影响的 define。eval-current 通常在 1–5ms 完成，支撑高频自修改循环。

• 并发与安全
  多线程 fiber scheduler + work-stealing，配合 workspace 级锁与符号级 staleness 检测，保证自修改过程的并发安全。

• JIT / AOT
  LLVM ORC JIT 后端将核心 opcode 编译为 native code，提供显著加速；同时支持 AOT 二进制 emit。

这些能力共同支撑一个关键场景：Agent 可以在运行时安全地修改自己的策略、规则或代码，并立即验证效果。

快速体验

1
2
3

# 本地构建（需要合适的 C++26 环境）
cmake -B build && cmake --build build --target aura -j
echo '(+ 1 2)' | ./build/aura   # → 3

推荐使用官方开发镜像：

1
2
3
4
5
6
7
8
9

docker run -d -it --name aura-dev \
  --cap-add=SYS_PTRACE \
  -e USER_UID=$(id -u) -e USER_GID=$(id -g) \
  -v $(pwd):/home/dev/code/aura \
  -w /home/dev/code/aura \
  ghcr.io/cybrid-systems/dev:latest

docker exec -it -u dev aura-dev /bin/zsh -l
python3 build.py build

环境基于 GCC 16 + CMake 4.3 + LLVM 22。

定位与愿景

Aura 不是又一个通用 Lisp，也不是普通的编译器。它是为 自演化 Agent 设计的运行时底座：

• 让 Agent 拥有“代码即数据”的精确操作能力
• 让自修改从危险的字符串操作变成可版本化、可回滚、可增量编译的安全原语
• 让多 Agent 编排与运行时进化成为语言的一等公民

项目采用 Apache-2.0 许可证，仓库地址：
https://github.com/cybrid-systems/aura

欢迎 Star、Issue 与贡献。如果你在做 AI Agent 的自修改、热更新、增量编译或运行时演化相关工作，Aura 值得一看。

Aura 首个版本，今天正式亮相。代码，自己进化。

45分钟完整课程 | 四年级原理进阶篇
主题：彻底搞懂“为什么重叠要加了再减、减了再加”！不再死记公式，而是像数学家一样推导！
适用对象：已学完001-011课（for循环、define函数、if判断、简单算术）的小朋友
课程目标：

1. 用文氏图“看到”重叠
2. 通过“被算几次”表格“懂为什么”
3. 亲手推导两个集合 + 三个集合公式
4. 抽象总结一般容斥原理
5. 用Racket代码一键验证所有小测验答案

课程准备（3分钟）

• 每人一张空白文氏图纸（2圆 + 3圆模板）+ 彩色笔
• 投影仪（展示下面动态图片 + 表格）
• DrRacket已打开（#lang racket）
• 魔法咒语卡片（打印本课公式 + 表格模板）

1. 开场故事 + 提出核心问题（6分钟）

“同学们！果果拿到二胡数学‘我特别爱做小测验06’，里面全是重叠难题！
40个小精灵都喜欢馒头糖或米饭糖……光明小学三个活动小组很多人同时参加……
核心问题：为什么不能直接相加？重叠的人被多算了！
今天我们不抄答案，而是画图 → 拆区域 → 推公式 → 彻底懂魔法！
口号：重叠不怕！原理来救！🪄”

2. 核心1：两个集合的容斥原理（12分钟）—— 底层逻辑大揭秘

步骤1：画文氏图 + 标区域

老师投影（学生同步画）：

三个区域：

• 只喜欢馒头（A-B）
• 只喜欢米饭（B-A）
• 两种都喜欢（A∩B）

步骤2：详细推导过程（关键！）

总人数 = 只馒头 + 只米饭 + 两种都喜欢
= (喜欢馒头 - 两种都喜欢) + (喜欢米饭 - 两种都喜欢) + 两种都喜欢
公式诞生：
|A ∪ B| = |A| + |B| - |A ∩ B|

步骤3：第1题演算

40 = 30 + 喜欢米饭 - 7
→ 喜欢米饭 = 40 - 30 + 7 = 17人

动手：改成“总50人，喜欢馒头35，两种都喜欢8”，自己推一次！

Racket验证

1
2

(define 喜欢米饭 (- (+ 40 7) 30))
(printf "第1题：~a 人\n" 喜欢米饭)  ; 17

3. 核心2：三个集合的容斥原理（15分钟）—— 最精彩拆解！

子步骤1：认识7个区域（4分钟）

老师投影3圆图（学生标号）：

区域编号：
① 只体育　② 只音乐　③ 只书法
④ 体育+音乐（不书法）　⑤ 体育+书法（不音乐）　⑥ 音乐+书法（不体育）
⑦ 三个都参加

子步骤2：魔法计数表格（最重要！6分钟）

投影这张表格（学生抄写+填数字，这是本课灵魂！）：

「被算几次」分析表（第2题真实数据）

老师讲解金句：

• 只参加一个（①②③）：算1次，刚好！
• 参加两个（④⑤⑥）：算2次，多1次 → 要减！
• 三个都参加（⑦）：算3次，减完剩0 → 要加回来！
  所以公式最后要 +ABC（救命的+2）！

子步骤3：公式诞生 + 演算

|A ∪ B ∪ C| = |A| + |B| + |C| - |AB| - |AC| - |BC| + |ABC|

54 + 46 + 36 - 4 - 7 - 10 + 2 = 117人

验证：表格“实际人数”列相加 = 117（完全一致！）

Racket通用函数

1
2
3

(define (容斥-三个集合 A B C AB AC BC ABC)
  (+ A B C (- AB) (- AC) (- BC) ABC))
(容斥-三个集合 54 46 36 4 7 10 2)  ; 117

4. 原理应用：解决第3、4题（6分钟）

第3题（1～1000不被2或3或5整除）
先算“被2或3或5整除的人”：用公式
|2 ∪ 3 ∪ 5| = 500 + 333 + 200 - 166 - 100 - 66 + 33 = 734
→ 不被整除 = 1000 - 734 = 266个

第4题（面向老师人数）
变形容斥：100 - (25 + 16 - 2×8) = 75名

Racket一键验证

1
2
3
4
5

(define (不被235整除 n)
  (- n (容斥-三个集合 (quotient n 2) (quotient n 3) (quotient n 5)
                      (quotient n 6) (quotient n 10) (quotient n 15)
                      (quotient n 30))))
(不被235整除 1000)  ; 266

第5题（小数复习）：
(1) 7.6×0.82 = 6.23
(2) 0.59÷1.4 ≈ 0.42

5. 抽象总结 + 原理升华（3分钟）

容斥原理本质：
“直接加会重复计数 → 用‘奇加偶减’修正（单+、双-、三+……）”

一般公式（n个集合）：
∑单个 - ∑两个交集 + ∑三个交集 - …

今天收获：
文氏图让你“看到”，表格让你“懂为什么”，公式让你“秒杀所有题”！

课堂PK + 作业（2分钟）

• PK：谁能最快把表格里7个实际人数全算对？
• 家庭作业（必做）：
  1. 画第2题完整带数字的7区域文氏图，用自己的话解释“为什么最后要+2”
  2. 用公式算1～100不被2或3整除的数（答案自己验证）

完整一键运行代码（复制到DrRacket直接出全部答案）：

1
2
3
4
5
6
7
8
9
10

#lang racket
(define (容斥-三个集合 A B C AB AC BC ABC)
  (+ A B C (- AB) (- AC) (- BC) ABC))

(printf "第1题：~a 人\n" (- (+ 40 7) 30))
(printf "第2题：~a 人\n" (容斥-三个集合 54 46 36 4 7 10 2))
(printf "第3题：~a 个\n" (- 1000 (容斥-三个集合 (quotient 1000 2) (quotient 1000 3) (quotient 1000 5)
                                          (quotient 1000 6) (quotient 1000 10) (quotient 1000 15)
                                          (quotient 1000 30))))
(printf "第4题：~a 名\n" (- 100 (quotient 100 4) (quotient 100 6) (- (* 2 (quotient 100 12)))))

预告：第013课 —— 容斥 + 闭包魔法盒子（果果宠物店多重喜好统计）

同学们，这节课不是为了做对题，而是为了懂魔法！
现在拿起彩笔，把容斥原理的秘密画出来吧～ 🪄📊
（本课零新语法，只用已学知识 + 原理拆解，孩子看完真正“会了”！）

课程时长：45分钟
目标年龄：6-12岁儿童（适合已学过基本闭包的小朋友，回顾前10课）
主题：你的“私人宠物喂食器”——用闭包创建隐藏的饥饿值空间，让函数像你的小助手一样，记住宠物的饥饿程度、喂食或玩耍，但别人看不到或乱动！
教学模式：生活故事引导 + 简单比喻 + 互动演示 + 代码练习 + 动手小游戏。用DrRacket继续学Racket，焦点在宠物喂食这个真实例子上。例子就一个，但我们一步步讲清楚，像讲故事一样，让你完全懂！前置：快速复习基本闭包，如果忘了，就想想“函数记住名字”的例子。

课前准备与故事开场（5分钟）

嗨，小朋友！你们养过小宠物吗？比如小狗、小猫或小鱼？宠物饿了要喂食，玩耍了会更饿，但你得记住它现在饿不饿。如果忘了，宠物就难受了！这就像现实生活里的“宠物护理”问题：需要跟踪饥饿值，但要私密管理，别让别人乱改（比如弟弟多喂，宠物吃撑）。今天，我们用编程的闭包来解决它。想象你有一个魔法宠物喂食器：里面藏着宠物的饥饿值（比如0是饱，10是饿），只有你能喂食（减饥饿）、玩耍（加饥饿）、查状态，别人碰不到。

问问你：“如果你有宠物，怎么知道它饿不饿？用本子记吗？怕不怕忘了或别人改？”互动一下，激发兴趣。这个例子超级真实，因为很多小朋友有宠物或想养，它帮你学责任感，还连上编程！

核心内容：用宠物喂食例子讲闭包（20分钟）

我们就用“宠物喂食器”这个例子，从头讲透。闭包不是抽象的，它像你的日常生活：喂宠物、玩耍、查饿度，还安全。一步步来，结合代码看。

• 关键1：闭包的“记忆力”——记住饥饿值，还能变化
  现实中：你的宠物初始饥饿值是0（刚吃饱）。玩耍1小时，饥饿加2，现在2；喂一顿饭，饥饿减3，剩-1（但我们设最低0）。喂食器“记住”最新饥饿值，但藏在你的房间里，别人看不到！这样，你能随时知道宠物需不需要喂，不会乱。
  编程中：闭包用let藏饥饿值（变量），用lambda做助手函数，能改值（用set!）。这升级了基本闭包，让饥饿“动”起来。
  代码演示：建一个宠物饥饿计数器。
  

  1 2 3 4 5 6 7

  (define (make-pet-feeder initial-hunger) (let ([hunger initial-hunger]) ; 闭包藏饥饿值，像魔法喂食器！ (lambda (action amount) (cond [(equal? action "play") (set! hunger (+ hunger amount)) hunger] ; 玩耍，加饥饿 [(equal? action "feed") (set! hunger (- hunger amount)) (if (< hunger 0) 0 hunger)] ; 喂食，减饥饿，最低0 [else "只能用正确方式哦！"])))) ; 防错

  • 怎么玩：(define my-pet (make-pet-feeder 0)) 创建你的喂食器（初始0饥饿）。
    (my-pet "play" 5) → 输出5（玩耍，加5饥饿）。
    (my-pet "feed" 3) → 输出2（喂3，减到2）。
    为什么安全？试试外面直接改hunger——报错！饥饿值藏在闭包里，只有助手能动。
    
  • 透彻解释：就像你每天记宠物状态，喂食器自动更新，但私密。现实中，这帮你养宠物不乱喂（比如鱼喂多会死），编程中教你管理变化的东西。饿度加减像简单数学，但闭包让它持久记住，不用每次重算。
• 关键2：多个助手共享同一个喂食器
  现实中：你有一个“玩耍助手”（出去玩时用，加饥饿）、“喂食助手”（吃饭时用，减饥饿）、“查饿助手”（想知道宠物饿不饿时用，只看不改）。他们都管同一个喂食器，饥饿值实时共享，不会乱！比如玩耍加3后，马上查就是3。
  编程中：闭包工厂返回多个函数，共享藏的变量。
  代码演示：升级宠物系统。
  

  1 2 3 4 5 6

  (define (make-pet-manager initial-hunger) (let ([hunger initial-hunger]) ; 共享的藏饥饿处 (list (lambda (amount) (set! hunger (+ hunger amount)) hunger) ; 玩耍助手，加饥饿 (lambda (amount) (set! hunger (- hunger amount)) (if (< hunger 0) 0 hunger)) ; 喂食助手，减饥饿 (lambda () hunger)))) ; 查饿助手，只看不改

  • 怎么玩：(define tools (make-pet-manager 2))
(define play-with-pet (first tools))
(define feed-pet (second tools))
(define check-hunger (third tools))
(play-with-pet 4) → 6；(check-hunger) → 6；(feed-pet 5) → 1。
    
  • 透彻解释：助手们像爸妈和你一起照顾宠物，但饥饿值只有一个地方。现实中，如果你和家人分担喂鱼（爸妈喂饭，你玩耍），查饿时大家知道一样的信息。闭包让编程像团队合作，安全共享，不怕数据错乱。为什么加最低0？因为宠物不能“负饿”，像现实不让饿度负数。
• 关键3：为什么闭包比全局变量好？（简单回顾）
  如果用全局变量，像把喂食器放客厅，谁都能改——弟弟乱加饥饿，宠物就“饿坏”或“撑坏”！闭包藏起来，只你和助手用。现实教你：养宠物要专人管，编程也一样，避免混乱。

动手练习与互动（15分钟）

• 练习1（简单）：改代码加“reset”动作，重置饥饿为0。测试玩/喂/重置，像宠物新的一天。
• 练习2（中等）：建你的宠物经理，初始5饥饿。试玩加3、喂减2、查饿度。想想：这怎么帮你现实养宠物？
• 练习3（挑战）：加“警报”功能，如果饿度超10，输出“快喂食啦！”。用闭包记住警报线。
• 互动游戏：角色扮演——一个当“玩耍助手”，另一个“查饿”，用代码演示。出错调试，像检查宠物真饿不饿。

课后延伸与小结（5分钟）

• 小结：闭包像你的宠物喂食器——记住饿度、能变化、安全共享！为什么酷？现实中帮你学照顾宠物，编程中建聪明工具。透彻了吗？闭包藏秘密（let），助手改动（lambda + set!），多助手共享一个藏处。
• 作业：用闭包做“作业进度经理”——初始0页，支持“do”（加页）、“rest”（减页？不，改成其他），想想怎么连上生活。
• 下节预告：闭包在游戏分数里的应用。

这个课用宠物喂食例子讲透闭包，让你不只学代码，还懂生活！有疑问再问哦~

果果编程课 第010课（拆分版）：闭包魔法——盒子里的秘密（基础篇）

拆分说明

原第010课内容较丰富，我已拆分成两节课（可根据需要扩展）： - 第010课（基础篇）：专注闭包概念。循序渐进，从故事到代码示例，确保小白（6-12岁孩子）明白。强调比喻（如“魔法盒子”），互动游戏，避免数学复杂。只用简单计数器示例，与Racket真实闭包（let + lambda）匹配（书籍第3章）。 - 第011课（应用篇）：应用闭包解决数学问题（平均、折扣、面积）。延续故事，实践四年级数学。预告在总结中。

这样确保第一课“讲透彻闭包”，不分散注意力。后续课渐进式加深。

课程概述（基础篇）

• 目标年龄：6-12岁（四年级水平）。
• 时长：45分钟。
• 编程语言：Racket（DrRacket IDE）。
• 主题："魔法糖果店"——果果发现“闭包盒子”，能锁住秘密数字，帮助记住东西。
• 数学轻触：只涉及简单加法（计数），不深入。四年级：理解“记住值”像累加游戏。
• 预备知识：前009课（变量、Lambda、For）。书籍第3章闭包基础。
• 学习目标：
  • 明白闭包：像“带锁盒子”，锁住变量（秘密），外面函数反复用。
  • 会写简单闭包代码。
  • 趣味：通过游戏和故事，让孩子觉得闭包是“魔法”。

课程结构（45分钟）

1. 开场故事（10分钟）

• 内容：果果的糖果店有秘密配方（如加糖次数），但每次计算都忘上次结果。果果找到“闭包魔法盒子”：里面锁秘密数字（变量），外面钥匙（函数）能打开加东西，但秘密不丢！
  • 故事：果果数糖果：第一次1个，第二次+2=3，第三次+3=6。但不用闭包，每次从0开始（错！）。用闭包，盒子记住上次总和，像“聪明日记本”。
• 互动游戏（让孩子明白“记住”）：
  • 道具：纸盒子（闭包）、纸条（秘密数字，如“总糖果=0”）。
  • 玩法：孩子轮流“加糖果”——说数字（1、2、3），放进盒子（更新秘密纸条，如0+1=1），锁上。下一个孩子打开，加新数（记住上次）。
  • 问题：不用盒子，为什么会忘？用盒子，为什么聪明？（答案：闭包锁住“记忆”！）
• 过渡：现在用Racket代码做“魔法盒子”！

2. 核心讲解：闭包是什么？怎么用？（15分钟）

• 步骤1：闭包像什么？（比喻，小白易懂）
  • 闭包 = “带锁的魔法盒子”：
    • 盒子里面：秘密变量（let锁住，像count=0）。
    • 外面钥匙：函数（lambda），能打开盒子改秘密，但秘密不跑掉。
    • 为什么魔法？正常变量用完就忘；闭包记住上次值，下次继续用。
  • 可视化：画图——盒子（let [count 0]），箭头钥匙（lambda () (set! count (+ count 1))）。
  • 真实匹配：书籍第3章闭包是“捕捉外部变量的函数”，这里用let+lambda实现。
• 步骤2：简单代码示例（一步步建，孩子跟敲）
  1. 最简单：固定秘密盒子
     • 代码：

       1 2 3 4 5 6 7 8 9 10

       #lang racket ; 第一行，告诉电脑用Racket (define (make-box secret) ; 创建盒子函数 (let ([hidden secret]) ; 锁住秘密（变量hidden） (lambda () ; 钥匙函数 hidden))) ; 返回秘密 (define my-box (make-box "糖果密码")) ; 召唤盒子，锁"糖果密码" (my-box) ; 输出: "糖果密码"（打开盒子，看秘密） (my-box) ; 又输出: "糖果密码"（记住，不变！）

     • 解释：
       • let：锁盒子，藏hidden。
       • lambda：钥匙，每次打开都看到一样秘密（不变）。
       • 运行：孩子敲代码，看输出。问：“为什么第二次还记得？”（闭包魔法！）
     • 互动：改秘密为数字1，运行两次。问：“正常变量会忘吗？”（演示无闭包变量，证明会忘）。
  2. 进阶：会变的秘密盒子（计数器）
     • 代码（书籍第3章闭包计数器示例）：

       1 2 3 4 5 6 7 8 9 10

       (define (make-counter) ; 创建计数盒子 (let ([count 0]) ; 锁住秘密count=0 (lambda () ; 钥匙 (set! count (add1 count)) ; 改秘密：加1 count))) ; 返回新秘密 (define fruit-counter (make-counter)) ; 召唤盒子 (fruit-counter) ; 输出: 1（第一次加1） (fruit-counter) ; 输出: 2（记住上次，加1） (fruit-counter) ; 输出: 3（继续加！）

     • 解释（小白版）：
       • 盒子锁count=0。
       • 钥匙每次打开：看秘密、加1、再锁回去。
       • 为什么记住？闭包让count不丢，像“聪明计数器”。
     • 匹配真实实现：Racket闭包用let捕获变量，lambda访问/修改（set!）。书籍强调“捕获外部变量”。
     • 互动：孩子运行，数“果果糖果个数”。问：“如果不用闭包，怎么办？”（演示全局变量，解释不安全）。
• 步骤3：为什么用闭包？（让孩子明白）
  • 好处：安全（秘密不漏）、方便（记住状态，像游戏分数计数器）。
  • 比正常函数：正常函数用完忘；闭包像有记忆的机器人。
  • 游戏：孩子分组，模拟代码——一人当“盒子”（藏纸条数字），别人当“钥匙”（加1，读纸条）。演示“忘秘密” vs. “记住”。

3. 动手练习：自己做闭包盒子（15分钟）

• 练习1：简单秘密盒子
  • 任务：做“果果生日盒子”，锁生日日期（"2026-03-11"），钥匙返回日期。
    
  • 代码模板：提供半成品，孩子填空（let、lambda）。
    
  • 运行：改秘密为今天日期（2026-03-11），输出看是否记住。
• 练习2：计数器升级
  • 任务：果果数顾客，用闭包计数器。加For循环（前课）：数5个顾客。
    

    1 2 3

    (define my-counter (make-counter)) ; 从讲解复制 (for ([i 5]) ; For循环（课008） (displayln (my-counter))) ; 输出1到5

  • 扩展：加参数——(lambda (add-num) (set! count (+ count add-num)))。孩子试加2、3等。
• 小组活动：分小组，设计“糖果分数盒子”（赢糖果加分）。分享代码，谁的盒子“最聪明”？

4. 总结与预告（5分钟）

• 总结：闭包是“魔法盒子”——用let锁变量，lambda当钥匙。记住秘密，不忘！今天我们做了计数器，下节用它算数学题。
• 作业：1. 改代码做“年龄盒子”（每年加1）。2. 画“闭包盒子”漫画。3. 想：闭包像生活什么？（如日记锁）。
• 预告：第011课——闭包帮果果算钱！用闭包求平均价、打折、面积（四年级数学）。

教学资源

• 代码文件：.rkt模板，孩子填空。
• 可视化：画盒子图、用玩具盒演示。
• 评估：孩子解释“闭包为什么记住？”运行代码无错。
• 安全：代码简单，无复杂数学，确保孩子不挫败。

这节课专注闭包基础，故事+示例+互动，让小白孩子透彻明白！后续课应用数学，渐进式。

（45分钟魔法课 · 适合6-12岁小朋友）

课程目标（今天彻底玩懂这个超级魔法）

• 明白词法作用域（Lexical Scoping）：每个糖果名字（变量）都有自己的“领地”，只在它出现的“文字环境”（写代码时的盒子范围）里有效！
• 区分大公开盒子（define，全店都知道）和小私人盒子（let / lambda，只在房间里有效）
• 搞懂 let（兄弟们同时贴标签）和 let*（哥哥先贴，后面的能看见前面）
• 学会嵌套盒子：外层房间的名字，内层房间看得见
• 画出“名字领地图”，用身体感受“谁能喊出这个名字”

核心理念：编程就像果果魔法糖果店，不同房间贴不同的糖果价格标签。标签的“可见领地”由它写在哪决定，不会到处乱飞！

第一部分：开场故事 + 全局大招牌（8分钟）

小朋友们好！今天我们来玩“名字侦探”游戏～

想象一下果果的魔法糖果店：

• 店门口挂着一个超级大招牌：(define candy-price 10)
  这代表“原价糖果”这个名字到处都能用！全店所有小精灵、顾客、收银机都知道它值10元。

1
2
3
4

#lang racket
(define candy-price 10)
candy-price
; 输出：10

魔法口诀：全局名字像大喇叭，全店喊得响！
但果果老师提醒：大招牌要珍惜哦～最好只放重要常量和函数（像店里的大价格表），不要乱贴小零食名字！

第二部分：小房间里的临时名字（10分钟）

现在我们进“计算游戏室”玩临时名字！

还记得lambda魔法吗？它给小朋友临时起代号，用完就消失：

1
2

((λ (x y) (+ (* 2 x) y)) 4 5)
; 输出：13

这里 x=4、y=5 只在这个咒语房间里有效。一算完，名字就“飞走”了！

let 是lambda的好兄弟，写起来更清楚：

1
2
3
4

(let ([x 4]
      [y 5])
  (+ (* 2 x) y))
; 输出：13

可视化：想象一个粉色小礼盒，里面贴着 x 和 y 两个标签。盒子关上后，外面的人就看不见了！

第三部分：let 的小心机 vs let* 救场（10分钟）

果果要考考大家啦！

下面这个会不会成功呢？

1
2
3
4

(let ([x 4]
      [y 5]
      [z (* 2 x)])   ; 这里出错啦！
  (+ z y))

为什么失败？
因为 let 是同时贴标签的！在给 z 贴标签的时候，x 还没完全打开给大家看。
就像三个小朋友同时发代号，第三个不能偷看第一个的名字～

救星来啦！let*（顺序聪明版）：

1
2
3
4
5

(let* ([x 4]
       [y 5]
       [z (* 2 x)])
  (+ z y))
; 输出：13 ✓

魔法口诀（大家一起念三遍！）：
“let 兄弟手拉手，同时出现！
let* 哥哥先来，一个一个来！”

第四部分：套娃房间的秘密（8分钟）

还有更厉害的玩法——嵌套let（像俄罗斯套娃糖果礼盒！）

1
2
3
4
5

(let ([x 4]          ; 外层大礼盒
      [y 5])
  (let ([z (* 2 x)]) ; 内层小礼盒
    (+ z y)))
; 输出：13

为什么成功？ 外层礼盒的名字（x、y），内层小礼盒看得见！
这就是词法作用域的核心：名字的领地由“文字位置”决定，外盒管内盒！

身体游戏（全班动起来！）：

• 外圈小朋友代表外层let，喊出“x=4”
• 内圈小朋友代表内层let，能听到外圈的名字，但外圈听不到内圈的“z”
  （像套娃层层打开，超级好玩！）

第五部分：动手练习 + 回家作业（9分钟）

课堂小侦探游戏（5分钟）：

1. 把圆面积魔法 ((λ (r) (* 3.14 r r)) 5) 改成 let 版（糖果店要算圆形包装盒面积）
2. 用 let 计算：原价=6元，打折后 y=原价+3，促销 z=原价y，最后输出总价
3. 试试把上面改成嵌套 let，看看谁先成功！

回家作业（超级重要！）：

1. 画图挑战：在纸上画一个“魔法糖果礼盒领地图”（大盒子套小盒子，标出每个名字谁能看见）
2. 糖果店计算器：用 let* 写一个程序：买10个糖果（每个2元），付20元，算找零多少
3. 把代码截图 + 手绘图发给果果老师！（优秀作品下节课展示）

核心总结口诀（回家也要念！）：
“全局名字满天飞，局部名字关小屋！
let 同时绑，let* 顺序来，
外盒名字里面见，名字规矩记心头！”

下节课预告

当小礼盒里的名字“逃出”房间还能继续使用时，会发生什么神奇的事？
第010课：闭包 Closure 魔法 —— 把递归 + map + filter + 词法作用域合成超级糖果店管理系统！（无限糖果树 + 自动算账 + 促销套餐，一次搞定！）

小朋友们，今天你们都成了“名字侦探”大师！
快去试试让你的糖果名字听话吧～
果果老师下节课见！🍬✨

（本课完全基于Racket官方词法作用域规则 + 001-008课的糖果店主题设计，代码在DrRacket直接运行哦！）

（45分钟魔法课 · 适合6-12岁小朋友）

课程目标（今天彻底玩懂这个超级魔法）

• 看懂递归：一个函数可以自己召唤自己，像俄罗斯套娃一层套一层！
• 牢牢记住两大铁律：停止条件 + 自己召唤更小的问题
• 亲眼看到递归怎么一步步“展开”又“收回来”
• 用身体真实感受“调用”和“返回”的过程（动觉学习者狂喜！）
• 学会3个最简单最可爱的递归函数
• 自己动手做4个小练习

核心口诀（全班一起喊3遍！）：
“Big problem = smaller same problem + call myself again!
First say STOP! or it will spin forever～”

第一部分：问题引入（5分钟）—— 果果收到无限糖果套娃盒！

故事时间：
果果的魔法糖果店今天收到一个大礼盒！打开一看，里面有一个一模一样的更小糖果盒，再打开还有更小……一直到最小的一颗小糖果！

果果问：“这个盒子一共有多少层啊？怎么才能知道呢？”

这就是递归的魔法——不用一个一个数，而是让“自己”去打开更小的盒子，直到打开最小的那一个！

（老师可以让小朋友拿纸画一排套娃，或者用手机搜“Russian nesting doll”看视频）

第二部分：递归两大铁律（讲透！10分钟）—— 像剥洋葱一样

铁律1：停止条件（Base Case）
“到了最小的问题，就直接回答，不再召唤自己！”
→ 就像套娃里最小的那个娃娃，打开就到底了，不用再打开。

铁律2：递归调用（Recursive Call）
“把大问题变成一个小一点的同样问题 + 自己再召唤一次！”
→ 大盒子的问题 = 打开它 + 让更小的盒子自己解决

可视化：展开 vs 收回来
想象果果在剥洋葱：
一层一层剥下去（展开）→ 剥到最中心（停止）→ 再一层一层包回去（收回来）

第三部分：可视化一步步展开（重头戏！12分钟）—— 3个超级简单例子

我们用超级慢动作一步一步看清楚！（函数全部用英文命名）

例子1：countdown-candies（倒数吃糖果）

1
2
3
4
5
6
7
8

(define (countdown-candies n)
  (if (= n 0)                          ; 停止条件
      (printf "Stop! Eat candy! 🍭\n")
      (begin
        (printf "Candy ~a !\n" n)
        (countdown-candies (- n 1)))))  ; 自己召唤自己

(countdown-candies 3)

一步步可视化展开（老师边说边在黑板画树）：

1
2
3
4
5
6
7
8
9
10
11

countdown-candies(3)
  Print "Candy 3 !"
  ↓ call countdown-candies(2)
      Print "Candy 2 !"
      ↓ call countdown-candies(1)
          Print "Candy 1 !"
          ↓ call countdown-candies(0)
              → Stop! Eat candy! 🍭     ← BASE CASE！
          ↑ return
      ↑ return
  ↑ return

例子2：sum-candies（糖果总颗数）

1
2
3
4
5
6
7

(define (sum-candies lst)
  (if (empty? lst)               ; 停止条件：盒子空了
      0
      (+ (first lst)             ; 拿第一颗
         (sum-candies (rest lst)))))  ; 自己算剩下的

(sum-candies (list 5 3 2))  ; → 10

可视化树形展开：

1
2
3
4

sum-candies([5,3,2]) = 5 + sum-candies([3,2])
                       = 5 + (3 + sum-candies([2]))
                       = 5 + (3 + (2 + sum-candies([])))
                       = 5 + (3 + (2 + 0)) = 10

例子3：candy-factorial（糖果打包组合数）

1
2
3
4
5
6

(define (candy-factorial n)
  (if (= n 0)                    ; 停止条件
      1
      (* n (candy-factorial (- n 1)))))

(candy-factorial 4)  ; → 24

一步步展开：

1
2
3
4

candy-factorial(4) = 4 × candy-factorial(3)
                     = 4 × (3 × candy-factorial(2))
                     = 4 × (3 × (2 × candy-factorial(1)))
                     = 4 × (3 × (2 × (1 × 1))) = 24

超级动觉游戏时间！（3分钟）—— 站起来玩人体俄罗斯套娃！

（放在第三部分结束后，全班站起来，动觉学习者最爱！）

老师说：“现在我们用身体来感受递归！大家站起来排成一排（3-5人一组）！”

游戏玩法（老师带头示范）： - 老师是大娃娃（第1层），大声喊：“I want to know total number of people!” - 老师拍拍同学A肩膀：“You are my smaller me! You calculate how many left!” - 同学A拍拍同学B：“You are my smaller me! You calculate how many left!” - …… 一直拍到最后一个同学（最小娃娃）大喊：“Stop! Only me 1 person!”（停止条件） - 然后层层返回： - 最后一个同学告诉前面的人：“I have 1!” - 前一个人加上自己再告诉上一个人：“I have 2!” - …… 最后老师宣布：“Total 3 people!”

全班玩2-3组，边玩边喊“call down!” “return up!”
孩子们笑成一团，但瞬间就懂了“调用下去”和“返回上来”的真实感觉！

第四部分：简单练习（10分钟 + 回家作业）

课堂马上试试（老师带做）： 1. 改 countdown-candies 从5数到1，打印“Eat the Xth candy!” 2. 写 candy-sum n 求 1+2+…+n （提示：(+ n (candy-sum (- n 1)))） 3. 写 candy-length lst 返回列表里有几颗糖果（空列表返回0） 4. 想一想生活中哪里还有“自己召唤自己”：折纸、讲故事“从前有座山……”、剥橘子…

回家作业（截图发爸爸妈妈或果果老师）： 1. 运行 candy-factorial 5，手写展开过程（像上面那样画箭头） 2. 用 candy-sum 6 算出结果，并告诉家人这是什么意思 3. 把人体游戏拍个小视频，发给果果老师看～

下节课预告
第009课：魔法升级！把递归 + map + filter 合成超级糖果店管理系统

老师寄语：
哇！今天果果不但用眼睛看懂了，还用身体玩懂了自己召唤自己的无限魔法！
递归就像果果长大：每解决一个小问题，就离大梦想更近一步～

把今天的英文函数代码粘到DrRacket跑一跑，手写展开过程，玩人体游戏拍视频，发给我们看！
下课啦！记得多吃糖果（适量哦）🍭✨

（本课100%聚焦基础原理、全程可视化+身体游戏、函数全英文命名、完美45分钟节奏，直接复制上课即可～）

（45分钟魔法课 · 适合6-12岁小朋友）

课程目标（今天学会这些大魔法）

• 认识“for家族”：Racket里最强大、最好玩的遍历魔法！
• 用 for/list + #:when 完美解决第6课的遗留问题：只挑出「翻倍后加税 >100元」的超级贵糖果！
• 学会 for、for/list、for/sum、for/first、for/or 等小精灵。
• 还能用 in-range、in-naturals 做计数、打印、求和。
• 把果果糖果店计算器升级成超级智能版！

核心口诀：
“filter 只能筛一次，for 家族能又筛又数又挑又算，一口气搞定所有事！”

第一部分：复习第6课（5分钟）

上节课我们用五大超级魔法做了什么？

1
2
3
4
5
6
7
8
9

(define add-tax (lambda (p) (+ p (* p 0.1))))
(define double   (lambda (p) (* p 2)))
(define to-yuan  (lambda (p) (string-append (number->string p) "元")))

(define prices (list 10 50 100 30 55 120))

;; 第6课做法（用filter + compose）
(filter (lambda (p) (> (add-tax (double p)) 100))
        prices)

遗留问题：我们只拿到了数字，还想要“110元”“220元”这种带文字的漂亮列表，而且想直接在遍历时就过滤！

今天我们用for家族一口气解决！

第二部分：认识“流”（stream）—— 懒惰的魔法数字链（8分钟）

先来两个新朋友：

1
2

(in-range 10)          ; 魔法流：0 1 2 3 4 5 6 7 8 9
(in-naturals)          ; 无限魔法流：0 1 2 3 ... 永远不会结束！

比喻：普通list是“一次性把所有糖果倒出来”，stream是“客人要一个才给一个”，超级省力气！

小测试：

1
2

(stream-first (in-range 5))   ; → 0
(stream-ref (in-range 10) 7)  ; → 7

第三部分：for家族登场！（20分钟）

1. 最简单 for（像display一样打印）

1
2
3
4
5
6
7

(for ([p prices])
  (display (to-yuan p))
  (newline))
;; 输出：
;; 10元
;; 50元
;; ...

2. for/list —— 收集成新列表（最常用！）

1
2
3

(for/list ([p prices])
  (to-yuan (add-tax (double p))))
;; → '("22元" "110元" "220元" "66元" "121元" "264元")

3. 加过滤魔法 #:when —— 解决遗留问题！

1
2
3
4
5
6
7

(define (super-price lst)
  (for/list ([p lst]
             #:when (> (add-tax (double p)) 100))   ; 只留下 >100元
    (to-yuan (add-tax (double p)))))

(super-price prices)
;; → '("110元" "220元" "121元" "264元")

哇！ 第6课的遗留问题一秒解决！🎉

4. for/sum —— 自动求和（买糖果总价神器）

1
2
3

(for/sum ([p prices])
  (add-tax (double p)))
;; → 803.0  （所有糖果翻倍加税后的总价）

5. for/first & for/last —— 挑第一个/最后一个符合条件的

1
2
3
4
5
6
7

(for/first ([p prices] #:when (> (add-tax (double p)) 100))
  (to-yuan (add-tax (double p))))
;; → "110元" （第一个超级贵糖果）

(for/last ([p prices] #:when (> p 50))
  p)
;; → 120 （最后一个>50的原始价格）

6. for/or —— 只要有一个满足就返回 #t

1

(for/or ([p prices]) (> p 100))   ; 有没有超过100元的？ → #t

7. 带计数的魔法（in-naturals）

1
2

(for ([p prices] [i (in-naturals)])
  (printf "第~a个糖果：~a\n" i (to-yuan p)))

第四部分：实战升级糖果店计算器（10分钟）

把第6课的超级计算器全部换成 for 写法，更简洁！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

(define (magic-shop prices)
  (printf "=== 果果魔法糖果店 ===\n")
  (for ([p prices] [i (in-naturals)])
    (printf "第~a个：原价~a → 会员价~a → 实付~a\n"
            i
            (to-yuan p)
            (to-yuan (double p))
            (to-yuan (add-tax (double p)))))
  
  (printf "\n超级贵糖果（>100元）：~a\n"
          (super-price prices))
  
  (printf "今日总收入：~a\n"
          (to-yuan (for/sum ([p prices]) (add-tax (double p))))))

(magic-shop (list 10 50 100 30 55 120))

第五部分：小练习（回家作业）

1. 用 for/list + #:when 做出「只显示打5折后仍然 >60元的糖果」
2. 用 for/sum 计算1到100所有偶数的平方和（提示：in-range 1 101 2）
3. 挑战：用 for*（嵌套版）打印九九乘法表（选做）

下节课预告

第8课：递归魔法 —— 像俄罗斯套娃一样，自己调用自己，无限强大！
（会用递归做出“汉诺塔搬糖果”“无限糖果树”）

老师寄语：
今天学会了 for 家族，果果糖果店从“手动挑糖果”变成了“魔法自动流水线”！
把今天的代码复制到 DrRacket 里跑一跑，截图发给爸爸妈妈看～

下课！下节见！🍭✨

课程目标（45分钟）
学会使用 cond、filter、foldr、apply、compose 这五个超级魔法，让程序变得更聪明、更简洁、更强大！

核心口诀：
小魔法一个一个用很累，把它们串起来，就能变出超级大魔法！

今天的故事背景
果果开了一家“魔法糖果店”！
客人买糖果有不同优惠规则，还要算总价、挑贵的糖果、给价格加税……
我们要用新学的魔法，一口气把这些事情都变得超级简单！

第一部分：问题引入（5分钟）

老师开场：

“上节课我们学会了 if 和 map，果果已经能给每个价格加标签了！
但是现在客人买很多糖果，要做这些事：

1. 根据数量决定打几折（10个以上9折、5-9个95折……）
2. 从一堆糖果里挑出贵的（>50元的）
3. 算所有糖果的总价
4. 把价格先翻倍、再加10%税、最后变成“XX元”显示

如果还用嵌套 if 和好几个 map，代码会变得很长很乱！
今天我们学习5个超级魔法，把这些小步骤像搭积木一样连起来！”

板书示意图：

1
2
3
4
5
6
7
8
9
10
11

原材料（糖果数量、价格列表）
      ↓
[cond] → 决定折扣
      ↓
[filter] → 挑出贵的
      ↓
[foldr] → 算总价
      ↓
[compose] → 超级价格流水线（翻倍 → 加税 → 转文字）
      ↓
超级结果！

第二部分：多条件选择神器 —— cond（8分钟）

基本写法

1
2
3
4
5
6

(define count 7)

(cond [(>= count 10) "9折！超级优惠🌟"]
      [(>= count 5)  "95折！很棒哦👍"]
      [(>  count 0)  "原价购买～💰"]
      [else          "下次再来玩哦～😊"])

运行结果（count = 7）："95折！很棒哦👍"

比喻：
cond 就像一个有很多岔路的选择精灵，每条路都有一个问题，只要回答“是”，就走这条路，不用一层套一层 if 了！

动手练习（学生自己改数字试试）

1
2
3
4
5
6

(define weather "cloudy")

(cond [(string=? weather "sunny")  "去踢足球！⚽"]
      [(string=? weather "cloudy") "去画画！🎨"]
      [(string=? weather "rainy")  "在家看动画！📺"]
      [else                        "先睡觉吧～😴"])

第三部分：魔法筛子 & 魔法累加器（12分钟）

1. filter —— 魔法筛子

1
2
3
4

(define prices (list 10 60 35 120 45 80))

(filter (lambda (p) (> p 50)) prices)
; 结果：'(60 120 80)

比喻：filter 就像一个会挑东西的筛子，只留下符合条件的糖果。

练习：挑出80分以上的成绩

1
2
3

(define scores (list 95 82 68 91 75 88 60))
(filter (lambda (s) (>= s 80)) scores)
; 结果：'(95 82 91 88)

2. foldr —— 魔法累加器（从右往左累加）

1
2
3
4
5

(define prices (list 10 60 35 120))

(foldr + 0 prices)                  ; 225
(foldr * 1 (list 2 3 4))            ; 24
(foldr string-append "" (list "果" "果" "最" "棒"))   ; "果果最棒"

比喻：foldr 就像一个从右边开始“叠加”的小工人，把所有东西按规则加/乘/拼接起来。

练习：算及格成绩的总分

1
2
3

(define scores (list 95 82 68 91 75 88 60))
(define pass-scores (filter (lambda (s) (>= s 60)) scores))
(foldr + 0 pass-scores)   ; 总分

第四部分：超级组合技 —— apply & compose（15分钟）

1. apply —— 一口气喂饱魔法

1
2
3

(apply + (list 10 20 30 40))          ; 100
(apply max (list 95 82 68 91 75))     ; 95
(apply string-append (list "果果" " " "超" "棒"))   ; "果果 超棒"

比喻：apply 就像把一篮子东西直接倒进魔法锅里，不用一个一个喂。

2. compose —— 终极魔法流水线（最重要！）

完整可运行代码（注意要加 require）

1
2
3
4
5
6
7
8
9
10
11

#lang racket

(define add-tax    (lambda (p) (+ p (* p 0.1))))     ; 加10%税
(define double     (lambda (p) (* p 2)))             ; 翻倍
(define to-yuan    (lambda (p) (string-append (number->string p) "元")))

(define super-price
  (compose to-yuan add-tax double))   ; 从右往左：先翻倍 → 加税 → 转文字

(map super-price (list 10 50 100))
; 结果：'("22元" "110元" "220元")

计算过程（以 50 为例）： 1. double → 100 2. add-tax → 100 + 10 = 110 3. to-yuan → "110元"

超级练习：自己设计一条流水线

1
2
3
4
5
6
7
8
9

; 目标：先×3 → 再+20 → 最后加“分”变成字符串
(define ×3   (lambda (n) (* n 3)))
(define add20  (lambda (n) (+ n 20)))
(define to-fen (lambda (n) (string-append (number->string n) "分")))

(define super-score (compose to-fen add20 ×3))

(map super-score (list 10 20 30))
; 应该得到：'("50分" "80分" "110分")

第五部分：综合创作时间（5分钟）

终极挑战：果果的超级糖果店计算器

请小朋友组合使用今天学的魔法，完成以下功能（老师可以给提示）：

输入：糖果价格列表 + 购买数量
输出： - 先用 cond 判断能打几折 - 用 filter 挑出 >50 元的贵糖果 - 用 foldr 算总价（可先打折） - 用 compose 做最终价格显示（翻倍模拟“会员价” → 加税 → 加“元”）

鼓励孩子们自由发挥，写出最酷的组合方式！

第六部分：总结与作业（3分钟）

今天学会的五大超级魔法

• cond → 多条件选择，比嵌套 if 更清晰
• filter → 魔法筛子，挑出想要的
• foldr → 累加/拼接神器
• apply → 一口气喂一堆参数
• compose → 把多个魔法串成流水线（最强！）

回家作业（三选二）

1. 用 cond 写一个“今天心情决定器”（心情 + 天气 → 决定做什么）
2. 用 filter + foldr 计算 (list 45 78 92 65 88 95 72) 中 85 分以上的总分和平均分
3. 用 compose 设计一个“超级分数处理器”：先×2 → 再+15 → 最后加“超级分”三个字

下节课预告
“下节课我们要学习递归魔法！
一个魔法可以自己召唤自己，就像俄罗斯套娃一样，无限强大！
准备好迎接最酷的循环方式了吗？✨”

果果们，今天你们已经从“单个小魔法师”升级成了“魔法工厂工程师”！
继续加油，下节课见～ 🚀

遗留问题，过滤>100元的。

1
2
3
4
5
6
7
8
9
10
11

#lang racket
(define add-tax (lambda (p) (+ p (* p 0.1)))) ; 加10%税
(define double (lambda (p) (* p 2))) ; 翻倍
(define to-yuan (lambda (p) (string-append (number->string p) "元")))

(define (super-price lst)
  (for/list ([p lst]
             #:when (> (add-tax (double p)) 100))
    (to-yuan (add-tax (double p)))))

(super-price (list 10 50 100))

课程目标（45分钟）
学会 if：让程序根据不同情况，做出不同选择！
核心口诀：如果（条件）就做A，否则做B

整体风格延续
- 口语化故事教学（果果攒钱、精灵冒险）
- 比喻：如果魔法 = “十字路口的选择精灵”
- 结合前几课：变量、列表、图形、lambda
- 逐步递进：从简单判断 → 嵌套判断 → 在map里用if
- 预告下节：compose 魔法（把多个机器连成超级机器）

第一部分：问题引入（5分钟）

老师故事：
“果果攒了好多零花钱，上节课我们用 map 把所有钱都翻倍了！
现在果果要去买最新款小天才手表（2399元）！

如果钱够了 → 果果开心跳舞！🎉
如果钱不够 → 果果伤心继续攒钱 😢

电脑怎么知道‘够不够’？今天教你一个超级魔法：如果魔法！
它就像路口的选择精灵：看情况，带你走不同的路！”

板书十字路口图：

1
2
3
4
5
6
7
8

┌──────────────┐
│  钱够吗？     │
└──────┬───────┘
       │
 是    │    否
   ┌──▼───┐   ┌──▼───┐
   │ 买！ │   │ 攒！ │
   └──────┘   └──────┘

第二部分：认识 if 魔法（15分钟）

1. 基本语法（5分钟）

1
2
3
4
5
6
7

#lang racket
(define my-money 2500)          ; 果果现在的钱
(define watch-price 2399)       ; 手表价格

(if (> my-money watch-price)
    "可以买！开心！🎉"
    "还差一点，继续攒钱😢")

运行结果："可以买！开心！🎉"

解释： - if = 选择精灵启动 - (> my-money watch-price) = 判断条件（真或假） - 第一个字符串 = 条件为真时做的事 - 第二个字符串 = 条件为假时做的事

比喻：
if 就像一个有三个口袋的精灵：
1. 放判断问题
2. 放“对的时候做的事”
3. 放“错的时候做的事”

2. 动手练习（10分钟）

练习1：钱够不够买玩具
改数字试试不同结果！

1
2
3
4
5
6

(define my-money 2000)
(define toy-price 2200)

(if (>= my-money toy-price)
    "买买买！"
    "再攒攒～")

练习2：图形版如果魔法（结合第一课）

1
2
3
4
5
6
7

(require 2htdp/image)

(define mood "happy")   ; 改成 "sad" 试试！

(if (string=? mood "happy")
    (circle 50 "solid" "yellow")    ; 开心画太阳
    (circle 50 "solid" "blue"))     ; 伤心画乌云

练习3：数字判断大挑战

1
2
3
4
5
6
7

(define score 85)

(if (>= score 90)
    "优秀！得小红花🌸"
    (if (>= score 70)
        "不错！继续加油🚀"
        "要努力哦～"))

老师提示：可以把 if 套 if！ 这叫“嵌套判断”

第三部分：如果魔法 + 列表 + map（15分钟）

故事：
“果果有好多朋友的成绩单！我们要给每个人发不同鼓励的话！”

1
2
3
4
5
6
7
8
9

(define scores (list 95 82 68 91 75))

(map (lambda (s)
       (if (>= s 90)
           "超级棒！🌟"
           (if (>= s 80)
               "很不错！👍"
               "加油哦！💪")))
     scores)

结果：'("超级棒！🌟" "很不错！👍" "加油哦！💪" "超级棒！🌟" "加油哦！💪")

小挑战：价格标签升级版（结合第4课）

1
2
3
4
5
6
7

(define prices (list 10 60 35 120))

(map (lambda (p)
       (if (> p 50)
           (string-append (number->string p) "元（贵！）")
           (string-append (number->string p) "元（便宜！）")))
     prices)

结果：'("10元（便宜！）" "60元（贵！）" "35元（便宜！）" "120元（贵！）")

第四部分：综合创作（8分钟）

终极任务：果果的冒险选择器

1
2
3
4
5
6
7
8

(define energy 80)     ; 果果的体力（0-100）
(define weather "sunny") ; 天气："sunny" 或 "rainy"

(if (>= energy 70)
    (if (string=? weather "sunny")
        "去公园玩！🌞"
        "在家画画！🎨")
    "先休息一下～😴")

创作时间：
让孩子们自己设计一个“冒险决策器”：
- 判断体力 + 天气 + 心情 → 决定今天做什么活动
- 或者：判断成绩 + 作业完成 → 决定周末玩多久游戏

老师巡回指导，鼓励多层if！

第五部分：总结与作业（2分钟）

核心口诀
if 就是选择魔法：
(if 判断题 对的时候做事 错的时候做事)

今天学会了： 1. 用 if 让程序会判断 2. 嵌套 if 做多层选择 3. 把 if 放进 map 批量判断

回家作业（简单又好玩）： 1. 写一个“天气预报机”：输入天气（"sunny"/"rainy"），输出今天穿什么衣服 2. 用 map + if 给 (list 45 78 92 65 88) 打等级：90+ A，80+ B，70+ C，其他 D

下节课预告
“下节课学 compose 组合魔法 —— 把多个变形机器连成一个超级大机器！
比如：先翻倍 → 再加10 → 再变字符串 → 再加‘元’……一行代码搞定！”

板书总结：

1
2
3
4

如果魔法 if
(if 条件  真→做事A  假→做事B)
可以嵌套！
可以和 map 一起用 → 批量判断！

教学小贴士
- 多用前几课内容（变量、列表、图形、map）做例子，强化衔接
- 遇到错误就说“选择精灵迷路了，我们帮他指路！”
- 进度快的孩子可以试 cond 多条件写法（预告高级魔法）

果果们，今天你们都变成了会“选择”的小魔法师啦！✨

课程目标（45分钟）

学会 map：一次性对列表中所有元素做同样的操作

第一部分：问题引入（5分钟）

老师故事： > "上节课果果攒了零花钱 (list 10 20 30 40 50)。如果每笔钱都变成2倍，怎么办？" > > 一个一个改？太累了！今天教你 数字变形工厂 —— 一个咒语，整串数字一起变！

第二部分：认识 map（15分钟）

1. 基本语法（5分钟）

1
2
3
4
5
6

#lang racket

(define savings (list 10 20 30 40 50))

; 启动变形工厂：每个数字×2
(map (lambda (n) (* n 2)) savings)

运行结果：'(20 40 60 80 100)

解释：

• map = 变形工厂启动
• (lambda (n) (* n 2)) = 机器说明书："拿数字n，输出n×2"
• savings = 原材料

2. 动手练习（10分钟）

练习1：加10机器

1
2

(map (lambda (n) (+ n 10)) savings)
; 结果：'(20 30 40 50 60)

练习2：变字符串机器

1
2

(map (lambda (n) (number->string n)) savings)
; 结果：'("10" "20" "30" "40" "50")

练习3：加"元"机器

1
2
3
4

  (map (lambda (n) 
         (string-append (number->string n) "元")) 
       savings)
; 结果：'("10元" "20元" "30元" "40元" "50元")

小挑战：把每个数字变成它的平方

1
2

(map (lambda (n) (* n n)) savings)
; 结果：'(100 400 900 1600 2500)

第三部分：string列表变形（15分钟）

1. 名字大变身（8分钟）

1
2
3
4
5

(define names (list "果果" "小明" "小红"))

; 加"同学"
(map (lambda (name) (string-append name "同学")) names)
; 结果：'("果果同学" "小明同学" "小红同学")

练习：加"你好，"在前面

1
2

(map (lambda (name) (string-append "你好，" name)) names)
; 结果：'("你好，果果" "你好，小明" "你好，小红")

2. 重复魔法（7分钟）

1
2
3

; 每个名字重复3遍
(map (lambda (name) (string-append name name name)) names)
; 结果：'("果果果果果果" "小明小明小明" "小红小红小红")

练习：名字变"名字！"

1
2

(map (lambda (name) (string-append name "！")) names)
; 结果：'("果果！" "小明！" "小红！")

第四部分：综合练习（8分钟）

挑战：制作价格标签

1
2
3
4
5
6
7
8

(define prices (list 10 25 50 100))

; 目标：'("价格：10元" "价格：25元" ...)
(map (lambda (p) 
       (string-append "价格：" 
                     (number->string p) 
                     "元")) 
     prices)

进阶：如果价格>50，加"（贵）"

1
2
3
4
5
6

(map (lambda (p)
       (if (> p 50)
           (string-append (number->string p) "元（贵）")
           (string-append (number->string p) "元")))
     prices)
; 结果：'("10元" "25元" "50元" "100元（贵）")

第五部分：总结（2分钟）

核心口诀

map 就是批量变形术： (map 变形机器 列表) → 新列表

回家作业

1. 把 (list 1 2 3 4 5) 每个数字变成 "第X名"（X是数字）
2. 把 (list "苹果" "香蕉" "橘子") 每个变成 "我爱吃XX"

都考100分哦

下节课预告

"下节课学 compose 组合魔法 —— 把多个变形机器拼成一个超级机器！"

板书：

1
2
3
4
5
6
7
8

map = 数字变形工厂
(map (lambda (x) ...) 列表)

常用变形：
(* x 2)        → 翻倍
(+ x 10)       → 加10
(number->string x) → 变文字
(string-append x "元") → 加单位