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

#if os(macOS)                       // 平台分支，替代 #ifdef __APPLE__
let platform = "macOS"
#elseif os(Linux)
let platform = "Linux"
#else
let platform = "other"
#endif

#if swift(>=5.9)                    // 按编译器语言版本分支
let modern = true
#else
let modern = false
#endif

#if canImport(Foundation)           // 按模块可导入性分支
import Foundation
let hasFoundation = true
#else
let hasFoundation = false
#endif

func report() {
    #warning("对标 #warning：编译期警告")     // 编译时打印一条警告
    print(platform, modern, hasFoundation)   // macOS true true
}
report()

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

// 编译约束必须单独占一行，必须在 package 之前，并与它空一行
//go:build linux || darwin

package main

import (
	_ "embed"
	"fmt"
)

// 把文件内容编进二进制：替代 C23 的 #embed
//go:embed data.txt
var data string

const buildTag = "linux || darwin"

func main() {
	fmt.Println(data)          // hello
	fmt.Println(buildTag)      // linux || darwin
	fmt.Println(len(data))     // 5
}

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

import sys
from functools import singledispatch
from typing import TYPE_CHECKING

if TYPE_CHECKING:                       # 只有类型检查器看得见，运行时不执行
    from collections.abc import Sequence

assert sys.version_info >= (3, 10)      # 运行期断言，不是编译期检查
DEBUG = __debug__                       # python -O 运行时为 False

@singledispatch                         # 用单分派替代 C11 的 _Generic
def describe(x):
    return "unknown"
@describe.register
def _(x: int):
    return "int"
@describe.register
def _(x: str):
    return "str"

print(sys.platform)                     # darwin 或 linux
print(describe(1), describe("a"), describe(1.5))   # int str unknown
print(DEBUG)                            # True

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

// 多平台：声明与实现分离，替代 #ifdef 平台分支
expect fun platformName(): String

// 编译期常量：会被内联进调用点，等价于 #define MAX_RETRY 3
const val MAX_RETRY = 3

// JVM 上唯一类似 #if 的东西是构建工具注入的常量
// Gradle: buildConfigField("boolean", "DEBUG", "true")
object BuildConfigLike {
    const val DEBUG = false          // 由源集或代码生成决定真假
}

fun main() {
    println(MAX_RETRY)               // 3
    println(BuildConfigLike.DEBUG)   // false
    if (BuildConfigLike.DEBUG) {     // 编译期常量条件，编译器能整段消除
        println("only in debug")
    }
}

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

public class Main {
    // 常量表达式 + if = Java 唯一的“编译期分支”
    private static final boolean DEBUG = false;
    private static final int MAX_RETRY = 3;

    public static void main(String[] args) {
        if (DEBUG) {                       // javac 会整段删除这个分支
            System.out.println("only in debug");
        }
        System.out.println(MAX_RETRY);     // 3
        assert args.length >= 0;           // 需要 -ea 才生效
        System.out.println(String.join(",", args));  // 传入参数拼接
    }
}

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <cstdio>
#include <source_location>
#include "guard.hpp"

#define VERSION 3
#define SQUARE(x) ((x) * (x))          // 每个参数都要加括号
#define STR(x) #x                      // # 把实参变成字符串
#define XSTR(x) STR(x)                 // 两级展开才能把宏参数也展开
#define CAT(a, b) a##b                 // ## 拼接记号
#define LOG(...) std::printf(__VA_ARGS__)
/* 多行宏用反斜杠续行，续行符后不能有任何字符 */
#define CHECK(cond) do {                          \
        if (!(cond)) std::printf("failed: %s\n", #cond); \
    } while (0)
#define LOGF(fmt, ...) std::printf(fmt __VA_OPT__(,) __VA_ARGS__)  // C++20

#if defined(VERSION) && VERSION >= 3
#  define LEVEL 3
#elifdef FALLBACK                      // C++23 新增的 #elifdef / #elifndef
#  define LEVEL 2
#else
#  define LEVEL 1
#endif

#ifndef FROM_HEADER
#  error "guard.hpp 没有被包含进来"
#endif

#if __has_include(<string_view>)       // C++17 起的 __has_include
#  define HAS_SV 1
#endif

#ifdef EMIT_WARNING
#  warning "显式打开的警告"
#endif

// 编译期计算的替代路线：模板 + constexpr + consteval + inline 函数
template <typename T> constexpr T square(T x) { return x * x; }
inline int square_i(int x) { return x * x; }     // inline 函数替代函数宏
consteval int twice(int n) { return n * 2; }     // C++20：只允许编译期求值
constinit static int counter = 0;                // C++20：必须静态初始化

int main() {
    std::printf("%d\n", SQUARE(1 + 2));                  // 9
    std::printf("%s %s\n", STR(VERSION), XSTR(VERSION)); // VERSION 3
    int CAT(my, var) = 7;
    std::printf("%d\n", myvar);                          // 7
    CHECK(myvar == 7);                                   // 条件成立，什么都不打印
    LOGF("no varargs\n");                                // no varargs
    LOG("with %d\n", 1);                                 // with 1
    std::printf("%d %d %d\n", LEVEL, HAS_SV, FROM_HEADER);  // 3 1 1
    std::printf("%d %d %d\n", square(3), square_i(3), twice(21));  // 9 9 42
    auto loc = std::source_location::current();          // 替代 __LINE__，且是类型安全的
    std::printf("%s:%d %s\n", __FILE__, __LINE__, loc.function_name());  // 文件、行号、函数名
    std::printf("%s %s\n", __DATE__, __TIME__);          // 编译日期与时间
    std::printf("%d\n", counter);                        // 0
#undef LEVEL
#ifndef LEVEL
    std::printf("undef ok\n");                           // undef ok
#endif
    return 0;
}

1
2

#pragma once                      // 现代写法；传统写法是 #ifndef GUARD_HPP 守卫
#define FROM_HEADER 1

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#include <stdio.h>
#include "guard.h"                       /* #include：文本包含，guard.h 见下一个代码块 */

#define VERSION 3                        /* 对象宏 */
#define SQUARE(x) ((x) * (x))            /* 函数宏：每个参数都要加括号 */
#define STR(x) #x                        /* #：把实参变成字符串字面量 */
#define XSTR(x) STR(x)                   /* 两级展开，让实参也展开 */
#define CAT(a, b) a##b                   /* ##：拼接两个记号 */
#define LOG(...) fprintf(stderr, "[log] " __VA_ARGS__)             /* C99 */
/* do { } while (0)：多行宏的惯用法，用反斜杠续行，行尾不能有空格 */
#define CHECK(cond) do {                         \
        if (!(cond)) {                           \
            printf("check failed: %s\n", #cond); \
        }                                        \
    } while (0)
#define LOGF(fmt, ...) printf(fmt __VA_OPT__(,) __VA_ARGS__)       /* C23 */

/* C23 的 #embed：把文件字节展开成整数字面量列表 */
static const unsigned char payload[] = {
#embed "data.txt"
};
_Static_assert(sizeof payload == 5, "payload must be 5 bytes");    /* C11 */

/* C11 的 _Generic：编译期按类型选择表达式 */
#define TYPE_NAME(x) _Generic((x), int: "int", double: "double", char *: "char*", default: "other")

#if defined(VERSION) && VERSION >= 3     /* #if / #ifdef / #ifndef / #defined */
#  define LEVEL 3
#elifdef FALLBACK                        /* C23：#elifdef / #elifndef */
#  define LEVEL 2
#elif VERSION >= 2
#  define LEVEL 2
#else
#  define LEVEL 1
#endif

#ifdef __STDC_VERSION__                  /* 预定义宏：C 标准版本 */
#  if __STDC_VERSION__ >= 202311L
#    define IS_C23 1
#  endif
#endif

#if __has_include(<stdio.h>)             /* C23：头文件存在性检测 */
#  define HAS_STDIO 1
#endif

#if __has_embed("data.txt") == __STDC_EMBED_FOUND__
#  define EMBED_OK 1
#endif

#ifdef EMIT_WARNING
#  warning "显式打开的警告，C23 起是标准指令"
#endif
#if 0
#  error "条件为假，这行不会被编译"
#endif

int main(void) {
    printf("%d\n", VERSION);             /* 3 */
    printf("%d\n", SQUARE(1 + 2));       /* 9：括号保住了运算顺序 */
    printf("%s %s\n", STR(VERSION), XSTR(VERSION));   /* VERSION 3 */
    int CAT(my, var) = 7;
    printf("%d\n", myvar);               /* 7 */
    LOG("level=%d\n", LEVEL);            /* [log] level=3，写到 stderr */
    CHECK(myvar == 7);                   /* 条件成立，什么都不打印 */
    LOGF("no varargs\n");                /* no varargs */
    LOGF("with %d\n", 1);                /* with 1 */
    printf("%d %s %s\n", payload[0], TYPE_NAME(1), TYPE_NAME(1.5));  /* 104 int double */
    printf("%d %d %d\n", FROM_HEADER, HAS_STDIO, IS_C23);   /* 1 1 1 */
    printf("%d\n", EMBED_OK);            /* 1 */
    printf("%s %d %s\n", __FILE__, __LINE__, __func__);   /* 文件、行号、函数名 */
    printf("%s %s\n", __DATE__, __TIME__);                /* 编译日期与时间 */
#undef LEVEL                             /* #undef：取消定义 */
#ifndef LEVEL
    printf("undef ok\n");                /* undef ok */
#endif
    return 0;
}

1
2

#pragma once                     /* 现代写法；传统写法是 #ifndef GUARD_H 守卫 */
#define FROM_HEADER 1

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

macro twice(ex)
    return quote
        local v = $(esc(ex))     # esc：放到调用者作用域里求值
        v + v
    end
end

@static if Sys.isapple()          # 解析期条件编译，等价于 #ifdef __APPLE__
    const PLATFORM = "macOS"
else
    const PLATFORM = "other"
end

const DATA = read(joinpath(@__DIR__, "data.txt"), String)   # 替代 #embed

println(@twice(21))              # 42
println(PLATFORM)                # macOS
println(length(DATA))            # 5
println(@__FILE__)               # 当前文件名，替代 __FILE__

 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
30

#define FEATURE_X                        // 只能定义符号，不能定义值
#undef  FEATURE_Y

using System;
using System.Diagnostics;

public class Main1 {
    [Conditional("FEATURE_X")]           // 调用点按符号整段消失
    static void Trace(string msg) => Console.WriteLine(msg);

    public static void Main() {
#if FEATURE_X
        Console.WriteLine("FEATURE_X on");    // FEATURE_X on
#elif FEATURE_Y
        Console.WriteLine("FEATURE_Y on");
#else
        Console.WriteLine("neither");
#endif
        Trace("traced");                 // traced：符号已定义
        Console.WriteLine(DEBUG_SYMBOL);  // 由 -define 或 csproj 决定
#line 200 "generated.cs"                 // 改写后续诊断的行号与文件名
        Console.WriteLine("line remapped");
    }

#if DEBUG_SYMBOL
    const string DEBUG_SYMBOL = "debug";
#else
    const string DEBUG_SYMBOL = "release";
#endif
}

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

import 'dart:io' if (dart.library.html) 'dart:html' as impl;  // 条件导入

// 构建期注入的常量：dart run --define=DEBUG=true
const bool debugMode = bool.fromEnvironment('DEBUG', defaultValue: false);
const String apiUrl = String.fromEnvironment('API_URL', defaultValue: '/api');

void main() {
  assert(() {                       // 只在 --enable-asserts 下执行
    print('assertions on');
    return true;
  }());
  print(debugMode);                 // false（未传 --define 时）
  print(apiUrl);                    // /api
  print(impl.Platform.numberOfProcessors > 0);   // true
}

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

# 下面全是运行期判断，没有编译期这一层
if (.Platform$OS.type == "windows") {          # 平台分支
  path_sep <- "\\"
} else {
  path_sep <- "/"
}

has_png <- capabilities("png")                 # 能力探测，运行时查询
r_version <- paste(R.version$major, R.version$minor, sep = ".")

# 替代“文件嵌入”：运行时读入，或把数据做成 .rda 随包分发
data <- readBin("data.txt", "raw", n = 5L)

cat(path_sep, "\n")                            # /
cat(has_png, "\n")                             # TRUE 或 FALSE
cat(r_version, "\n")                           # 4.6.0
cat(length(data), "\n")                        # 5

 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

const std = @import("std");
const build_options = @import("build_options");   // 由 build.zig 注入

// 编译期常量：等价于 #define VERSION 3
const version: u32 = 3;

// 等价于 #embed：把文件内容读成编译期已知的字节数组
const data = @embedFile("data.txt");

pub fn main() !void {
    // 编译期分支：条件必须是 comptime 可求值的
    if (comptime version >= 3) {
        std.debug.print("modern\n", .{});          // modern
    }

    // 编译期断言，条件不成立直接编译失败：等价于 #error
    comptime {
        if (version < 3) @compileError("version too old");
        @compileLog(version);                      // 编译时打印：3
    }

    std.debug.print("{d}\n", .{data.len});         // 5
    std.debug.print("{s}\n", .{build_options.mode});  // debug 或 release
    std.debug.print("{s}\n", .{@typeName(@TypeOf(version))});  // u32
}

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

-- 运行期条件，不是编译期分支
local sep = package.config:sub(1, 1)          -- "/" 或 "\\"
local is_luajit = rawget(_G, "jit") ~= nil

-- 运行期“代码生成”：拼接字符串再加载
local src = "return function(a, b) return a * b end"
local mul = load(src)()                        -- load 返回函数或 nil 加错误
print(mul(6, 7))                               -- 42

-- 元表：改写字段访问，替代“编译期注入”
local cfg = setmetatable({}, { __index = function(_, k) return "missing:" .. k end })
print(sep)                                     -- /
print(is_luajit)                               -- true 或 false
print(cfg.timeout)                             -- missing:timeout

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

// 类型层面的条件编译：条件类型在编译期求值，运行时不产生任何代码
type IsString<T> = T extends string ? true : false;
type A = IsString<"x">;      // true（字面量收窄）
type B = IsString<1>;        // false

// 值层面的“编译期常量”由打包器 define 替换，例如 define: { __DEBUG__: false }
declare const __DEBUG__: boolean;
declare const __VERSION__: string;

type Config = { readonly version: string; readonly retries: 3 };
const cfg = { version: "1.0", retries: 3 } as const;   // 字面量类型，readonly

export function describe(v: A): string {
  return v ? "string" : "not string";
}

console.log(cfg.version);            // 1.0
console.log(cfg.retries);            // 3
console.log(describe(true));         // string
// console.log(describe(false));     // 编译错误：false 不是 true 类型

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

// 打包器会把 process.env.NODE_ENV 替换成 "production"，随后死代码消除
if (process.env.NODE_ENV !== "production") {
  console.log("dev only");            // 直接 node 跑会打印；打包后整段消失
}

// Vite 风格：import.meta.env 也是替换出来的字面量（此处手工模拟）
const env = { MODE: "production", DEV: false };
if (env.DEV) {
  console.log("dev only, vite");      // 条件为常量假，压缩后整段消失
}

// /*#__PURE__*/ 告诉压缩器这个调用没有副作用，可以整句删除
const value = /*#__PURE__*/ createThing();

function createThing() {
  console.log("called");              // 未压缩时会打印
  return 1;
}

console.log(env.MODE);       // production
console.log(value);          // 1
console.log(typeof window);  // undefined（Node）或 object（浏览器）

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

<?php
if (PHP_VERSION_ID >= 80400) {                 // 运行期版本分支
    echo "PHP 8.4+\n";                          // PHP 8.4+
} else {
    echo "older PHP\n";
}

define('APP_VERSION', '3');                     // 运行时常量，不是宏
const MAX_RETRY = 3;                            // 编译期常量（不能用于条件编译）

if (!extension_loaded('mbstring')) {            // 能力探测
    echo "mbstring missing\n";
}

#[\Attribute]                                   // 8.0 的属性，靠反射在运行时读取
class Route { public function __construct(public string $path) {} }

echo APP_VERSION, "\n";                         // 3
echo MAX_RETRY, "\n";                           // 3
echo PHP_OS_FAMILY, "\n";                       // Darwin 或 Linux
echo (new ReflectionClass(Route::class))->getAttributes()[0]->getName(), "\n";  // Route

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

# frozen_string_literal: true

puts __FILE__                       # s1.rb   替代 __FILE__
puts __LINE__                       # 4       替代 __LINE__
puts defined?(String).inspect       # "constant"
puts RUBY_PLATFORM                  # arm64-darwin25
puts RbConfig::CONFIG["host_os"]    # darwin25

if RUBY_VERSION >= "3.0"            # 运行期版本分支，没有预处理
  puts "modern"
end

# 字符串冻结：魔法注释生效后字面量不可变
s = "abc"
puts s.frozen?                      # true

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

// @resultBuilder：把语句序列声明式地拼装成一个值（SwiftUI 的 DSL 基础）
@resultBuilder
struct StringBuilder {
    static func buildBlock(_ parts: String...) -> String { parts.joined(separator: " ") }
    static func buildOptional(_ part: String?) -> String { part ?? "" }
}

struct Doc {
    @StringBuilder var body: String {
        "hello"
        if Bool.random() { "maybe" }
        "world"
    }
}

let d = Doc()
print(d.body.split(separator: " ").count >= 2)   // true

// 没有通用的宏定义；宏声明要写成下面这样并指向外部实现
// @freestanding(expression)
// macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MyMacros", type: "StringifyMacro")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main

import "fmt"

//go:generate sh -c "printf 'package main\n\nconst generated = \"from go generate\"\n' > gen.go"

func main() {
	fmt.Println(generated)       // from go generate
	fmt.Println(len(generated))  // 16
}

 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

import ast
import inspect
from functools import wraps

# 装饰器：高阶函数，运行时包装对象（等价于 f = deco(f)）
def traced(fn):
    @wraps(fn)
    def wrapper(*a, **kw):
        return fn(*a, **kw)
    return wrapper

@traced
def add(a, b):
    return a + b

# ast：只能解析与改写“文本”，要自己接住源码
tree = ast.parse("x = 1 + 2", mode="exec")
tree.body[0].value = ast.BinOp(left=ast.Constant(6), op=ast.Mult(), right=ast.Constant(7))
ns = {}
ast.fix_missing_locations(tree)     # 手工构造的节点缺少 lineno，必须补上
exec(compile(tree, "<ast>", "exec"), ns)

print(add(1, 2))                    # 3
print(add.__name__)                 # add，靠 wraps 保住
print(ns["x"])                      # 42
print(isinstance(tree.body[0], ast.Assign))   # True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// inline + reified：Kotlin 唯一“接近宏”的语言内手段
inline fun <reified T> typeNameOf(): String = T::class.simpleName ?: "?"

// 编译器插件负责 IR 变换（如 kotlinx.serialization、Compose 编译器插件）
// KSP 负责声明级代码生成，接口长这样：
// interface SymbolProcessor { fun process(resolver: Resolver): List<KSAnnotated> }

fun main() {
    println(typeNameOf<Int>())        // Int
    println(typeNameOf<String>())     // String
}

 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

// 注解声明：运行时可用反射读，编译期可被处理器读
import java.lang.annotation.*;

@Retention(RetentionPolicy.CLASS)      // 只保留到 class 文件，处理器能看、反射看不到
@Target(ElementType.TYPE)
public @interface Builder {}

// JSR 269 处理器的骨架（需要 java.compiler 模块，编译期运行）
// @SupportedAnnotationTypes("Builder")
// public class BuilderProcessor extends AbstractProcessor {
//     @Override public boolean process(Set<? extends TypeElement> ann, RoundEnvironment env) {
//         for (Element e : env.getElementsAnnotatedWith(Builder.class)) {
//             String name = e.getSimpleName() + "Builder";
//             try (Writer w = processingEnv.getFiler().createSourceFile(name).openWriter()) {
//                 w.write("public class " + name + " {}");   // 只能生成新文件
//             } catch (java.io.IOException ex) { throw new RuntimeException(ex); }
//         }
//         return true;
//     }
// }

public class Main {
    public static void main(String[] args) {
        System.out.println(Builder.class.isAnnotationPresent(Builder.class));  // false
        System.out.println(Builder.class.getAnnotations().length);             // 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
25
26
27
28

#include <cstdio>
#include <string_view>
#include <type_traits>

// 可变参数模板 + 折叠表达式：做“接受任意个参数”的宏做不到的类型安全工作
template <typename... Ts>
constexpr auto sum(Ts... xs) { return (xs + ... + 0); }

// 偏特化模拟“按结构分派”
template <typename T> struct Kind { static constexpr std::string_view value = "other"; };
template <typename T> struct Kind<T*> { static constexpr std::string_view value = "pointer"; };
template <typename T> struct Kind<T&> { static constexpr std::string_view value = "reference"; };

// if constexpr：编译期分支，未选中的分支仍然要语法正确
template <typename T>
constexpr std::string_view describe() {
    if constexpr (std::is_integral_v<T>) return "integral";
    else if constexpr (std::is_floating_point_v<T>) return "floating";
    else return "other";
}

int main() {
    std::printf("%d\n", sum(1, 2, 3));                              // 6
    std::printf("%.*s\n", (int)Kind<int*>::value.size(), Kind<int*>::value.data());   // pointer
    std::printf("%.*s\n", (int)Kind<int>::value.size(), Kind<int>::value.data());     // other
    std::printf("%.*s\n", (int)describe<double>().size(), describe<double>().data()); // floating
    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
25
26

#include <stdio.h>

/* 用宏“声明”一套类型与函数：C 里最接近语法宏的写法 */
#define DEFINE_PAIR(T, Name)                       \
    typedef struct { T a; T b; } Name;             \
    static inline Name Name##_make(T a, T b) {     \
        Name p = { a, b };                         \
        return p;                                  \
    }

DEFINE_PAIR(int, IntPair)
DEFINE_PAIR(double, DoublePair)

#define PAIR_EQ(lhs, rhs) _Generic((lhs),                    \
    IntPair: ((lhs).a == (rhs).a && (lhs).b == (rhs).b),      \
    DoublePair: ((lhs).a == (rhs).a && (lhs).b == (rhs).b),   \
    default: 0)

int main(void) {
    IntPair p = IntPair_make(1, 2);
    DoublePair q = DoublePair_make(1.5, 2.5);
    printf("%d %d\n", p.a, p.b);            /* 1 2 */
    printf("%.1f %.1f\n", q.a, q.b);        /* 1.5 2.5 */
    printf("%d\n", PAIR_EQ(p, ((IntPair){1, 2})));   /* 1：复合字面量要再套一层括号 */
    return 0;
}

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

macro timeit(ex)
    return quote
        local t0 = time_ns()          # local：会被 gensym 重命名，不污染调用者
        local v = $(esc(ex))          # esc：在调用者作用域里求值
        println("elapsed ns: ", time_ns() - t0)
        v
    end
end

macro zerox()
    return esc(:(x = 0))              # 故意打破卫生：直接改调用者的 x
end

ex = @macroexpand @timeit(1 + 1)      # 看展开结果，不执行
println(ex.head)                      # block

x = 42
@zerox()
println(x)                            # 0

println(@timeit(6 * 7))               # 先打印 elapsed ns: <n>，再打印 42
println(Symbol("t0") in names(Main))  # false：宏内的 t0 没有泄漏到 Main

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

// C# 侧只能写“被生成”的用法，生成器本身是一个独立的 analyzer 项目
using System;

public partial class Person
{
    public string Name { get; set; } = "";
    // 源生成器会为这个 partial 类补上 ToString 或 Builder
}

public static class Program
{
    public static void Main()
    {
#if NET10_0_OR_GREATER
        Console.WriteLine("net10.0");      // net10.0
#else
        Console.WriteLine("older");
#endif
        var p = new Person { Name = "Ada" };
        Console.WriteLine(p.Name);          // Ada
        Console.WriteLine(p.GetType().IsSealed);   // False
    }
}

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

// 注解在源码里，生成器读它并写出新文件
import 'package:meta/meta_meta.dart';

@Target({TargetKind.classType})
class JsonModel {
  const JsonModel();
}

@JsonModel()
class User {
  const User({required this.id, required this.name});
  final int id;
  final String name;
}

void main() {
  // 生成出来的通常是 User.fromJson / toJson / copyWith
  // 由 `dart run build_runner build` 产出 user.g.dart
  const u = User(id: 1, name: "Ada");
  print(u.id);          // 1
  print(u.name);        // Ada
  print(u is Object);   // true
}

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

f <- function(x) substitute(x)          # 取实参的表达式，不求值
g <- function(x) bquote(.(x) * 2)       # 部分求值：x 先算出值再嵌进表达式

expr <- f(a + b)
print(expr)                             # a + b
print(typeof(expr))                     # language

built <- g(3)
print(built)                            # 3 * 2
print(eval(built))                      # 6

# 非卫生：substitute 出来的表达式在调用环境求值
h <- function(e) eval(substitute(e))
a <- 10; b <- 20
print(h(a + b))                         # 30

 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
30

const std = @import("std");

// comptime 函数参数 + 返回类型 type：这就是 Zig 的“泛型”，也是“宏”
fn Vec(comptime T: type, comptime n: usize) type {
    return struct {
        items: [n]T,
        fn sum(self: @This()) T {
            var total: T = 0;
            inline for (self.items) |v| {    // inline for：编译期展开循环
                total += v;
            }
            return total;
        }
    };
}

pub fn main() void {
    const V3 = Vec(i32, 3);
    const v = V3{ .items = .{ 1, 2, 3 } };
    std.debug.print("{d}\n", .{v.sum()});          // 6

    // @typeInfo：类型信息是编译期数据，可以遍历
    const info = @typeInfo(V3);
    std.debug.print("{s}\n", .{@tagName(info)});   // struct（标签在源码里写作 .@"struct"）
    std.debug.print("{d}\n", .{info.@"struct".fields.len});   // 1

    inline for (.{ u8, u16, u32 }) |T| {           // 编译期对类型集合展开
        std.debug.print("{s} ", .{@typeName(T)});  // u8 u16 u32
    }
}

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

-- 运行期拼装函数：把一段字符串变成闭包
local function make_adder(n)
  return load("local n = ... ; return function(x) return x + n end")(n)
end
print(make_adder(10)(5))            -- 15

-- debug 库：读取函数信息、改写上值（内省能力，慎用）
local function f() return 1 end
print(debug.getinfo(f, "S").what)   -- "Lua"
local i = 1
while true do
  local name, val = debug.getupvalue(f, i)
  if not name then break end
  print(name, val)                  -- 打印 f 的上值
  i = i + 1
end

-- 元表：拦截索引与调用，做“注解式”行为
local t = setmetatable({}, { __index = function(_, k) return "gen:" .. k end })
print(t.anything)                   -- gen:anything

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

// 映射类型：类型层面的“代码生成”，运行时不产生任何代码
type ReadonlyDeep<T> = { readonly [K in keyof T]: ReadonlyDeep<T[K]> };
type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface User { id: number; name: string; }
type FrozenUser = ReadonlyDeep<User>;
type DraftUser = PartialBy<User, "name">;

const u: FrozenUser = { id: 1, name: "Ada" };
const d: DraftUser = { id: 2 };            // name 可省略
// u.id = 9;                               // 编译错误：readonly

// 编译器 API 的 transformer 才是真正改 AST 的入口（示意）
// factory.updateSourceFile(sourceFile, visitEachChild(sourceFile, visitor, context))

console.log(u.name, d.id);                 // Ada 2
console.log(JSON.stringify(u));            // {"id":1,"name":"Ada"}

 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
30
31

// 一个最小的 Babel 插件形态（示意，需要 @babel/core 才能运行）
const plugin = ({ types: t }) => ({
  visitor: {
    CallExpression(path) {
      // 把 assert(cond, msg) 改写成 if (!cond) throw new Error(msg)
      if (path.node.callee.name !== "assert") return;
      const [cond, msg] = path.node.arguments;
      path.replaceWith(
        t.ifStatement(
          t.unaryExpression("!", cond),
          t.throwStatement(t.newExpression(t.identifier("Error"), [msg]))
        )
      );
    },
  },
});

// 不用工具链也能做的：运行期行为改写
const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
assert(1 + 1 === 2, "math works");
console.log("assert passed");        // assert passed

try {
  assert(false, "boom");
} catch (e) {
  console.log(e.message);            // boom
}

// 高阶函数是绝大多数“宏需求”的正解
const times = (n, f) => Array.from({ length: n }, (_, i) => f(i));
console.log(times(3, (i) => i * i)); // [0, 1, 4]

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

<?php
#[\Attribute(\Attribute::TARGET_METHOD)]
class Route {
    public function __construct(public string $path, public string $method = 'GET') {}
}

class Controller {
    #[Route('/users', 'GET')]           // 8.0 的属性：靠反射在运行时读
    public function users(): array { return ['a', 'b']; }

    // 8.4 的属性钩子：属性访问自带逻辑，是语言内建而不是宏
    public string $name = 'ada' {
        get => ucfirst($this->name);
    }
}

$rc = new ReflectionClass(Controller::class);
$rm = $rc->getMethod('users');
$route = $rm->getAttributes(Route::class)[0]->newInstance();
echo $route->path, ' ', $route->method, "\n";     // /users GET
echo (new ReflectionMethod(Controller::class, 'users'))->invoke(new Controller())[0], "\n";  // a

$c = new Controller();
echo $c->name, "\n";                              // Ada