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

var total = 0
let addTotal = { total += 1; return total }        // 捕获变量本身，共享同一份存储
print("shared:", addTotal(), addTotal(), total)    // shared: 1 2 2

var local = 10
let freeze = { [local] in local * 2 }              // 捕获列表：创建时按值拷贝
local = 99
print("list:", freeze(), "outer:", local)          // list: 20 outer: 99

final class Counter {
    var n = 0
    func makeGetter() -> () -> Int {
        { [weak self] in self?.n ?? -1 }           // [weak self] 打破循环引用
    }
}
let c = Counter()
c.n = 7
print("weak self:", c.makeGetter()())              // weak self: 7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import "fmt"

func main() {
	x := 1
	inc := func() int { x++; return x } // 闭包按变量捕获，共享同一份 x
	fmt.Println("ref:", inc(), inc(), x) // ref: 2 3 3

	mk := func() func() int {
		n := 0
		return func() int { n++; return n }
	}
	c := mk()
	fmt.Println("counter:", c(), c()) // counter: 1 2

	var fs []func() int
	for i := 0; i < 3; i++ { // Go 1.22 起每轮新建 i
		fs = append(fs, func() int { return i })
	}
	for _, f := range fs {
		fmt.Print(f(), " ") // 0 1 2
	}
	fmt.Println()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def counter():
    n = 0
    def inc():
        nonlocal n          # 没有 nonlocal 就只能读、不能重绑定 n
        n += 1
        return n
    return inc

c = counter()
print("nonlocal:", c(), c())        # nonlocal: 1 2

g = 0
def bump():
    global g                        # 绑定模块级变量
    g += 1
    return g
print("global:", bump(), g)         # global: 1 1

fs = [lambda: i for i in range(3)]
print("late:", [f() for f in fs])   # late: [2, 2, 2]  延迟绑定
fs2 = [lambda i=i: i for i in range(3)]
print("default:", [f() for f in fs2])  # default: [0, 1, 2]

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

fun counter(): () -> Int {
    var n = 0
    return { n += 1; n }        // 闭包捕获 var，改动对外可见
}

fun main() {
    val c = counter()
    println("var: ${c()} ${c()}")        // var: 1 2

    val k = 10
    val f: (Int) -> Int = { it + k }     // 捕获 val
    println("val: ${f(1)}")              // val: 11

    val outer = listOf(1, 2, 3)
    var sum = 0
    outer.filter { it > 0 }.forEach { sum += it }   // Java 里这样写不合法
    println("sum: $sum")                 // sum: 6
}

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

import java.util.function.IntSupplier;

public class Main {
    public static void main(String[] args) {
        int base = 10;                    // 有效 final：之后不再赋值
        IntSupplier add = () -> base + 1; // 只能捕获有效 final
        System.out.println("effectively final: " + add.getAsInt());   // 11

        int[] box = {0};                  // 需要可变状态就用单元素数组
        IntSupplier next = () -> ++box[0];
        System.out.println("box: " + next.getAsInt() + " " + next.getAsInt());  // 1 2

        // int n = 0; IntSupplier bad = () -> n++;   // 🛑 n 不是有效 final
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include <string>
#include <utility>

struct S {
    int v = 7;
    auto f() {
        return [=, this] { return v; };   // C++20 起允许显式写 [=, this]
    }
};

int main() {
    int a = 1, b = 2;
    auto byValue = [=] { return a + b; };                  // 按值拷贝
    auto byRef = [&] { a += 10; return a; };               // 按引用
    auto one = [b] { return b * 2; };                      // 只捕获 b
    std::string s = "hello";
    auto moved = [s = std::move(s)] { return s.size(); };  // 初始化捕获 + 移动
    byRef();
    std::cout << byValue() << ' ' << a << ' ' << one() << ' ' << moved() << '\n';
    // 3 11 4 5
    std::cout << "this: " << S{}.f()() << '\n';            // this: 7
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <stdio.h>

/* C 没有闭包：把要“捕获”的状态放进结构体，函数通过 void* 上下文访问 */
typedef struct { int base; } Adder;

static int apply(void *ctx, int x) { return ((Adder *)ctx)->base + x; }

int main(void) {
    Adder a = {41};                     /* 状态由调用者显式持有 */
    printf("ctx: %d\n", apply(&a, 1));  /* ctx: 42 */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function counter()
    n = 0
    () -> (n += 1)          # 闭包捕获 n，n 被装箱（box）到堆上
end
c = counter()
println("box: ", (c(), c()))    # box: (1, 2)

function make_adder(k)
    x -> x + k              # 只读捕获
end
println("adder: ", make_adder(10)(5))   # adder: 15

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

using System;

class Program
{
    static Func<int> Counter()
    {
        int n = 0;                       // 被提升为编译器生成类的字段
        return () => ++n;
    }

    static void Main()
    {
        var c = Counter();
        Console.WriteLine($"closure: {c()} {c()}");   // closure: 1 2

        int outer = 10;
        Func<int, int> add = x => x + outer;          // 捕获变量（引用语义）
        outer = 99;
        Console.WriteLine($"later: {add(1)}");        // later: 100

        Func<int, int> sq = static x => x * x;        // static lambda：禁止捕获
        Console.WriteLine($"static: {sq(4)}");        // static: 16
    }
}

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

Function makeCounter() {
  var n = 0;
  return () => ++n;           // 闭包捕获变量本身（引用语义）
}

late String config;           // late：第一次读取时才算初始化完成

void main() {
  final c = makeCounter();
  print('closure: ${c()} ${c()}');   // closure: 1 2

  config = 'ready';                  // 若从不赋值，读它抛 LateInitializationError
  final read = () => config;         // 闭包里的 late 变量同样延迟初始化
  print('late: ${read()}');          // late: ready
}

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

counter <- function() {
  n <- 0
  function() { n <<- n + 1; n }   # <<- 修改外层环境的 n
}
ctr <- counter()
a <- ctr()
b <- ctr()
print(c(a, b))                     # [1] 1 2

make_adder <- function(k) function(x) x + k   # 词法作用域
print(make_adder(10)(5))           # [1] 15

f <- function(a) "a 从未被使用"
print(f(stop("永远不会执行")))      # [1] "a 从未被使用"

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

const std = @import("std");

// Zig 没有闭包：把“捕获”的状态放进结构体，连同函数一起传
const Adder = struct {
    base: i32,
    fn apply(ctx: *const Adder, x: i32) i32 {
        return ctx.base + x;      // 显式的上下文参数
    }
};

pub fn main() void {
    const a = Adder{ .base = 41 };
    std.debug.print("{d}\n", .{Adder.apply(&a, 1)});   // 42
    const add: *const fn (*const Adder, i32) i32 = Adder.apply;   // 函数指针
    std.debug.print("{d}\n", .{add(&a, 1)});           // 42
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

local function counter()
  local n = 0
  return function() n = n + 1; return n end   -- n 是 upvalue
end
local c = counter()
local first = c()
local second = c()
print(first, second)    -- 1  2

local x = 20
local t = {}
for i = 1, 3 do
  local y = 0
  t[i] = function() y = y + 1; return x + y end   -- 每个闭包有各自的 y
end
print(t[1](), t[2](), t[3]())    -- 21  21  21

local function with_env(env)
  local _ENV = env          -- 之后的自由名字都在 env 里查
  return function() return answer end
end
print(with_env({ answer = 42 })())   -- 42

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

function counter(): () => number {
  let n = 0;
  return () => ++n;              // 与 JS 一致：按变量（引用）捕获
}
const c = counter();
console.log("ref:", c(), c());   // ref: 1 2

const byVar: Array<() => number> = [];
for (var i = 0; i < 3; i++) byVar.push(() => i);
console.log("var:", byVar.map((f) => f()));   // var: [ 3, 3, 3 ]

const byLet: Array<() => number> = [];
for (let j = 0; j < 3; j++) byLet.push(() => j);
console.log("let:", byLet.map((f) => f()));   // let: [ 0, 1, 2 ]

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

function counter() {
  let n = 0;
  return () => ++n;            // 捕获变量 n（引用），不是快照
}
const c = counter();
console.log("ref:", c(), c(), c());   // ref: 1 2 3

const byVar = [];
for (var i = 0; i < 3; i++) byVar.push(() => i);
console.log("var:", byVar.map((f) => f()));   // var: [ 3, 3, 3 ]

const byLet = [];
for (let j = 0; j < 3; j++) byLet.push(() => j);
console.log("let:", byLet.map((f) => f()));   // let: [ 0, 1, 2 ]

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

<?php
$y = 1;
$fn1 = fn($x) => $x + $y;              // 箭头函数：自动按值捕获
$fn2 = function ($x) use ($y) {         // 匿名函数：必须写 use
    return $x + $y;
};
$n = 0;
$bump = function () use (&$n) { return ++$n; };   // use (&$n)：按引用捕获
$y = 100;                                // 不影响已按值捕获的副本
$a = $fn1(3);
$b = $fn2(3);
$p = $bump();
$q = $bump();
echo $a, " ", $b, " ", $p, " ", $q, "\n";   // 4 4 1 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def counter
  n = 0
  -> { n += 1 }              # lambda 捕获局部变量 n（引用）
end
c = counter
p [c.call, c.call, c.call]   # [1, 2, 3]

x = 0
[1, 2].each { x += 1 }       # 块内赋值写回外层局部变量
p x                          # 2

y = 0
[1, 2].each { |y| y += 1 }   # 块参数遮蔽外层 y
p y                          # 0

fs = []
for i in 1..3
  fs << -> { i }             # for 不引入新作用域，三个闭包共享同一个 i
end
p fs.map(&:call)             # [3, 3, 3]

fs2 = (1..3).map { |i| -> { i } }   # 块参数每轮新建
p fs2.map(&:call)                   # [1, 2, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

var handlers: [() -> Int] = []

func store(_ h: @escaping () -> Int) { handlers.append(h) }  // 逃逸：必须 @escaping
func call(_ h: () -> Int) -> Int { h() }                     // 默认 non-escaping

func makeCounter() -> () -> Int {
    var n = 0
    return { n += 1; return n }   // 返回闭包 ⇒ 捕获的 n 被提升到堆
}

let c = makeCounter()
store(c)
print("escaping:", handlers[0](), call(c))    // escaping: 1 2

final class Node {
    var name: String
    var onChange: (() -> Void)?
    init(name: String) { self.name = name }
    deinit { print("deinit \(name)") }
}
do {
    let n = Node(name: "leaky")
    n.onChange = { print("changed", n.name) }   // 🛑 self → 闭包 → self 强引用环
    n.onChange?()
}                                                // 没有 deinit 输出：对象泄漏
print("end")                                     // end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

type Acc struct{ n int }

func makeCounter() func() int { // 返回的闭包逃逸，n 被分配到堆
	n := 0
	return func() int { n++; return n }
}

func newAcc() *Acc { // 返回局部变量的地址 ⇒ 逃逸到堆
	a := Acc{}
	return &a
}

func main() {
	c := makeCounter()
	fmt.Println("counter:", c(), c()) // counter: 1 2
	fmt.Println("acc:", newAcc().n)    // acc: 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import gc
import weakref

class Big:
    pass

def make():
    b = Big()
    ref = weakref.ref(b)
    def get():
        return b            # 闭包持有 b：只要闭包活着，对象就不会被回收
    return get, ref

get, ref = make()
gc.collect()
print("alive:", ref() is not None)   # alive: True
del get                              # 闭包被回收
gc.collect()
print("alive:", ref() is not None)   # alive: False

def make_counter():
    n = 0
    return lambda: n + 1             # 闭包把 n 的 cell 挂到函数对象上
print("cell:", make_counter()(), make_counter()())   # cell: 1 1

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

fun make(): () -> Int {
    var n = 0
    return { n += 1; n }     // 逃逸：n 被放进 Ref 对象，分配到堆
}

fun main() {
    val c = make()
    println("escaped: ${c()} ${c()}")        // escaped: 1 2

    val big = StringBuilder("x".repeat(1000))
    val keep = { big.length }                // 闭包持有引用，big 无法被回收
    println("retained: ${keep()}")            // retained: 1000
}

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

import java.util.function.IntSupplier;

public class Main {
    static IntSupplier make() {
        int[] n = {0};
        return () -> ++n[0];          // 委托持有捕获的副本，存活到委托被回收
    }

    public static void main(String[] args) {
        IntSupplier c = make();
        System.out.println("heap: " + c.getAsInt() + " " + c.getAsInt());   // heap: 1 2

        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += new int[]{i}[0];   // 不逃逸的分配：JIT 可做标量替换
        }
        System.out.println("ea: " + sum);   // ea: 3
    }
}

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

#include <functional>
#include <iostream>
#include <string>

std::function<int()> safe() {
    int local = 42;
    return [local] { return local; };   // ✅ 按值捕获，可以安全返回
}

std::function<int()> dangling() {
    int local = 42;
    return [&] { return local; };       // 🛑 悬垂：返回后 local 已销毁
}

int main() {
    std::cout << "safe: " << safe()() << '\n';   // safe: 42
    // std::cout << dangling()() << '\n';        // 🛑 未定义行为，不要运行
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>
#include <stdlib.h>

/* “闭包”= 函数指针 + 上下文指针；生命周期由程序员保证 */
typedef struct {
    int (*fn)(void *ctx);
    void *ctx;
} Closure;

typedef struct { int base; } Adder;

static int adder_apply(void *ctx) { return ((Adder *)ctx)->base + 1; }

/* 上下文在堆上分配，因此可以安全地“逃逸”出本函数 */
static Closure make_adder(int base) {
    Adder *a = malloc(sizeof *a);
    a->base = base;
    Closure c = { adder_apply, a };
    return c;
}

int main(void) {
    Closure c = make_adder(41);
    printf("heap ctx: %d\n", c.fn(c.ctx));   /* heap ctx: 42 */
    free(c.ctx);                             /* 谁分配谁释放，语言不帮忙 */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

function make_closure()
    n = 0
    () -> (n += 1)     # n 逃逸 ⇒ 装箱到堆，闭包与 n 一起被 GC 管理
end

f = make_closure()
println("escaped: ", (f(), f()))    # escaped: (1, 2)

function abmult(r0::Int)
    r = r0
    if r < 0
        r = -r
    end
    x -> x * r          # r 被改写 ⇒ 解析器为它生成 Core.Box
end
println("boxed: ", abmult(-3)(4))   # boxed: 12

function abmult2(r0::Int)
    r = abs(r0)
    let r = r
        x -> x * r      # let 新建只读变量 ⇒ 不装箱
    end
end
println("unboxed: ", abmult2(-3)(4))   # unboxed: 12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

using System;
using System.Collections.Generic;

class Program
{
    static Func<int> Make()
    {
        int n = 0;
        return () => ++n;      // 委托持有闭包对象 ⇒ n 存活到委托被回收
    }

    static void Main()
    {
        var c = Make();
        Console.WriteLine($"heap: {c()} {c()}");   // heap: 1 2

        Span<int> span = stackalloc int[2];
        // Action capture = () => Console.WriteLine(span.Length);
        // 🛑 编译错误：不能捕获 ref struct 变量

        var handlers = new List<Action>();
        for (int i = 0; i < 2; i++)
            handlers.Add(() => Console.WriteLine(i));   // for 共享 i
    }
}

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

Function makeCounter() {
  var n = 0;
  return () => ++n;      // Dart 的闭包由 GC 管理，没有手动生命周期
}

void main() {
  final c = makeCounter();
  print('gc: ${c()} ${c()}');   // gc: 1 2

  // Dart 没有“引用悬垂”：捕获的变量被提升到堆上的 context 对象
  final fns = <Function>[];
  for (var i = 0; i < 3; i++) {
    fns.add(() => i);            // 规范保证每轮是独立变量
  }
  print(fns.map((f) => f()).toList());   // [0, 1, 2]
}

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

make <- function() {
  n <- 0
  function() { n <<- n + 1; n }   # 闭包环境由 GC 管理，不会悬垂
}
ctr <- make()
a <- ctr()
b <- ctr()
print(c(a, b))            # [1] 1 2

# R 的 for 循环变量活在当前环境里：循环结束后仍然存在
for (i in 1:3) {}
print(exists("i"))        # [1] TRUE
print(i)                  # [1] 3

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

const std = @import("std");

const Counter = struct {
    n: u32 = 0,
    fn bump(ctx: *Counter) u32 {
        ctx.n += 1;
        return ctx.n;
    }
};

pub fn main() !void {
    const a = std.heap.page_allocator;
    const c = try a.create(Counter);   // 上下文放堆上，生命周期由你控制
    defer a.destroy(c);                // 忘记这行就是泄漏，提前调用就是 use-after-free
    std.debug.print("{d} {d}\n", .{ Counter.bump(c), Counter.bump(c) });   // 1 2
}

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

local function make()
  local n = 0
  return function() n = n + 1; return n end   -- upvalue 由 GC 管理
end
local c = make()
local first = c()
local second = c()
print(first, second)     -- 1  2

-- 断开引用后剩下的交给 GC
local f = make()
f = nil
collectgarbage("collect")
print("collected")   -- collected

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Session {
  readonly id: string;
  constructor(id: string) { this.id = id; }
}

function keepSession(): () => string {
  const s = new Session("s1");
  return () => s.id;              // 闭包让 s 在函数返回后仍可达
}
const read = keepSession();
console.log("kept:", read());     // kept: s1

function getUrl(url: string | URL, names: string[]): string {
  if (typeof url === "string") url = new URL(url);
  return names
    .map((n) => {
      url.searchParams.set("name", n);   // TS 5.4：收窄在闭包内保留
      return url.toString();
    })
    .join("");
}
console.log("narrowed:", getUrl("https://x.test/", ["a"]));   // narrowed: https://x.test/?name=a

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

function makeReader() {
  const data = new Array(3).fill(7);   // 局部数组
  return () => data.length;            // 闭包让 data 在函数返回后继续存活
}
const read = makeReader();
console.log("kept alive:", read());    // kept alive: 3

// 事件监听不取消 ⇒ 闭包与它捕获的对象一直可达
const bus = new EventTarget();
const state = { hits: 0 };
const onPing = () => { state.hits += 1; };
bus.addEventListener("ping", onPing);
bus.dispatchEvent(new Event("ping"));
console.log("listener:", state.hits);  // listener: 1
bus.removeEventListener("ping", onPing);   // 必须配对移除，否则闭包泄漏

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

class Conn {
  #closed = false;
  [Symbol.dispose]() { this.#closed = true; console.log("disposed"); }
  use() { return this.#closed ? "closed" : "open"; }
}

function makeReader() {
  using conn = new Conn();
  console.log("inside:", conn.use());   // inside: open
  return () => conn.use();              // 闭包逃逸，资源却已随作用域释放
}

const read2 = makeReader();             // disposed（作用域退出时同步释放）
console.log("after:", read2());         // after: closed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?php
function make() {
    $n = 0;
    return function () use (&$n) { return ++$n; };   // 闭包对象持有变量槽
}
$c = make();
$a = $c();
$b = $c();
echo $a, " ", $b, "\n";          // 1 2

class Bus {
    private array $listeners = [];
    public function on(callable $l): void { $this->listeners[] = $l; }
    public function off(callable $l): void {
        $this->listeners = array_filter($this->listeners, fn($x) => $x !== $l);
    }
    public function emit(): void { foreach ($this->listeners as $l) { $l(); } }
}

$bus = new Bus();
$state = new stdClass();
$state->hits = 0;
$on = function () use ($state) { $state->hits++; };   // 捕获对象句柄
$bus->on($on);
$bus->emit();
echo $state->hits, "\n";         // 1
$bus->off($on);                  // 取消订阅：否则闭包与 $state 一直可达
$bus->emit();
echo $state->hits, "\n";         // 1（已取消订阅）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def make
  n = 0
  -> { n += 1 }        # Proc 是闭包，n 由 GC 管理
end
c = make
p [c.call, c.call]     # [1, 2]

class Bus
  def initialize = @listeners = []
  def on(&blk) = @listeners << blk
  def off(&blk) = @listeners.delete(blk)
  def emit = @listeners.each(&:call)
end
bus = Bus.new
hits = 0
on = -> { hits += 1 }
bus.on(&on)
bus.emit
p hits            # 1
bus.off(&on)
bus.emit
p hits            # 1

1
2
3
4
5
6
7
8

var fs: [() -> Int] = []
for i in 0..<3 { fs.append { i } }        // for-in 每轮新建 i
print("for-in:", fs.map { $0() })          // for-in: [0, 1, 2]

var gs: [() -> Int] = []
var j = 0
while j < 3 { gs.append { j }; j += 1 }    // while 里 j 始终是同一个变量
print("while:", gs.map { $0() })           // while: [3, 3, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import "fmt"

func main() {
	var fs []func() int
	for i := 0; i < 3; i++ { // Go 1.22 起：每轮新建变量
		fs = append(fs, func() int { return i })
	}
	for _, f := range fs {
		fmt.Print(f(), " ") // 0 1 2
	}
	fmt.Println()

	var gs []func() int
	i := 0
	for i < 3 { // 循环外的 i 仍然只有一份
		gs = append(gs, func() int { return i })
		i++
	}
	for _, f := range gs {
		fmt.Print(f(), " ") // 3 3 3
	}
	fmt.Println()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from functools import partial

fs = [lambda: i for i in range(3)]
print("late:", [f() for f in fs])        # late: [2, 2, 2]

fs2 = [lambda i=i: i for i in range(3)]      # 默认参数在定义时求值
print("default:", [f() for f in fs2])        # default: [0, 1, 2]

fs3 = [partial(lambda i: i, i) for i in range(3)]
print("partial:", [f() for f in fs3])        # partial: [0, 1, 2]