匹配表达式（模式匹配）如何不需要运行时类型信息来工作？

Question

匹配 表达式 在高层实现？为了让编译器知道如何将某些代码片段定向到一个分支与另一个分支，并在编译时弄清楚它，在幕后会发生什么？我不明白如果不存储运行时使用的类型信息，这怎么可能。

像这样的例子：

fn tree_weight_v1(t: BinaryTree) -> i32 {
    match t {
        BinaryTree::Leaf(payload) => payload,
        BinaryTree::Node(left, payload, right) => {
            tree_weight_v1(*left) + payload + tree_weight_v1(*right)
        }
    }
}

/// Returns tree that Looks like:
///
///      +----(4)---+
///      |          |
///   +-(2)-+      [5]
///   |     |   
///  [1]   [3]
///
fn sample_tree() -> BinaryTree {
    let l1 = Box::new(BinaryTree::Leaf(1));
    let l3 = Box::new(BinaryTree::Leaf(3));
    let n2 = Box::new(BinaryTree::Node(l1, 2, l3));
    let l5 = Box::new(BinaryTree::Leaf(5));

    BinaryTree::Node(n2, 4, l5)
}

#[test]
fn tree_demo_1() {
    let tree = sample_tree();
    assert_eq!(tree_weight_v1(tree), (1 + 2 + 3) + 4 + 5);
}

通过运行时类型信息，我的意思是你实际上存储了一个指向类型定义的指针或类似的东西，所以当运行时执行到达 match 时，它只是检查 value.type ==给定_模式_表达式或它的一些变体。据我了解，事实并非如此。也就是说，Rust 不会在运行时将类型与结构/记录一起存储。根据我的理解，它是在编译时计算的。

如果我在每个结构/记录上存储.type，我可能可以实现这种功能。然后您只需查找类型并查看是否匹配即可。但是，我看不到在编译器级别实现此功能的方法，因此它在运行时提前计算出匹配。

我认为它发生在编译时，因为像 是否可以对 Rust 中的泛型进行编译时类型检查？ 或 运行时特征实现检查？，以及许多其他帖子似乎暗示了一切发生在编译时，除了极少数情况下您可以选择加入运行时检查。 （这是我这几天总结几十篇文章的理解）。或者另一个引用是：

确实需要检查给定的二叉树是叶子还是节点，但编译器静态地确保完成此类检查：您不能意外地将叶子的数据解释为节点，反之亦然。

对我来说，编译器静态地计算出我上面发布的 BinaryTree 案例中的模式匹配。不知何故。

将模式匹配与类型检查集成是一篇关于编程语言的随机帖子这与我的理解一致，您需要运行时类型信息来完成此操作。所以我很困惑。

如果类型是模式，则您需要能够在运行时确定值的类型。一般来说，这需要运行时类型信息（许多语言故意删除这些信息）；但它还需要一些包含这两种情况的超类型（许多语言故意没有）。

为 Rust

Answer 1

match 表达式不需要需要运行时类型信息；由于 match 只接受单个已知类型的单个表达式，根据定义，它可以利用编译时信息。

另请参阅：

• 是否可以在 Rust 中进行多种类型的模式匹配？
• 如何在 Rust 中匹配数据类型？

匹配在编译时与运行时

在编译时，每个match 表达式将被验证为详尽：处理值的所有可能形状。

在运行时，代码将确定执行哪个特定的匹配臂。您可以将 match 视为通过奇特的 if-else 链实现的。

由于我们人类在沟通时往往不是非常精确，因此某些资源很可能模糊了这两个方面之间的界限。

具体关注枚举

枚举变体不是独立的类型。也就是说，给定枚举 Foo，Foo::Bar 不是类型 — 它是 Foo 类型的值。这与 false 不是类型相同 - 它是 bool 类型的值。相同的逻辑适用于i32（类型）和42（值）。

在大多数情况下，枚举被实现为与每个枚举变体可能的值相对应的大量字节，每个变体的数据彼此分层。这称为联合。

然后在这堆字节旁边添加一个判别式。这是一个整数值，指定该值是哪个变体。添加判别式使其成为标记联合。

概念上类似于此伪 Rust：

if discriminant(&enum_value) == VARIANT_1_DISCR {
    let data = mem::transmute(data(&enum_value));
} else if discriminant(&enum_value) == VARIANT_2_DISCR {
    let data = mem::transmute(data(&enum_value));
}

另请参阅：

• 为什么枚举需要额外的内存大小？

枚举上的匹配在

Rust 为何没有运行时反射

我不同意它没有有它，但它默认肯定没有它。 Rust 中的运行时类型信息通常会利用 Any< /code> 特征：

fn thing(value: &dyn std::any::Any) {
    if let Some(s) = value.downcast_ref::<String>() {
        dbg!(s.len());
    } else if let Some(i) = value.downcast_ref::<i32>() {
        dbg!(i + 1);
    }
}

匹配时缺少 Any 特征是一个额外的提示，表明不存在运行时类型信息。

其他语言

您需要能够在运行时确定值的类型

只有当你允许一个值有多种类型时，这才是正确的——Rust 不允许，因为它是一种静态类型语言。在动态类型语言中，您想要使用类型来匹配值，您确实需要拥有一定数量的运行时类型信息。

Answer 2

Rust 使用的可以保存数据的枚举类型通常被称为“标记联合”。一般概念是它们或多或少通过应用区分标签以及可能值的联合来工作。

Rust 中的标记联合

例如，这里我使用匹配在 Rust 中打印一个枚举值：

pub enum Foo {
    Bar(i32),
    Baz {
        a: i32,
        b: i8,
    }
}

match foo {
    Foo::Bar(x) => println!("Bar({})", x),
    Foo::Baz { a, b } => println!("Baz {{ a: {}, b: {} }}", a, b),
}

内存中的标记联合

下面是如何使用没有标记联合的语言（如 C）做同样的事情：

struct Foo {
    enum {
        Bar, Baz
    } tag;

    union {
        // Data for Bar
        int32_t Bar;
        
        // Data for Baz
        struct {
            int32_t a;
            int8_t b;
        } Baz;
    } data;
}

// Check the tag to distinguish variants before accessing data
switch foo.tag {
    case Bar:
        printf("Bar(%d)", foo.data.Bar);
        break;
    case Baz:
        printf("Baz { a: %d, b: %d }", foo.data.Baz.a, foo.data.Baz.b);
}

现在，我可能犯了一个错误或我的 C 版本中有两个，有人可能能够指出一些改进，但我希望它通常能够显示标记联合如何在获取数据时区分变体。

Rust 中的标记联合

我不太了解 Rust 中如何实现标记联合，但很容易想象，Rust 可能会在这些系统上进行扩展，以进一步提高匹配效率。例如，如果您有一个枚举类型嵌套在另一个枚举类型中，您可以将它们的标签合并在一起，这样您就不需要进行多次比较（例如：编译器可能会压缩 Option> ） 到 OptionResultAB 中，只需要一个标签）。

另一个众所周知的例子是 Option> 与 *mut T 具有相同的大小，因为 null 可以用作 None > 价值。还有一些其他类似的情况，例如函数指针。

虽然我只是推测 Rust 中标记联合的形式，但

我确实找到了一个更好的研究解释，它很好地解释了这个概念：

• https://patshaughnessy.net/2018/3/15/how-rust-implements-tagged-unions#:~:text=The%20Rust%20compiler%20implements%20tagged,unions%20at%20the%20same% 20次。