v0.26.1 (2026-01-29)

mojo_hub

✨ 亮点

扩展反射模块。 reflection 模块现在提供广泛的编译时内省功能：结构体字段枚举、类型和字节偏移量；源代码位置跟踪；以及对动态获取类型进行特质一致性检查。这些 API 支持高级元编程模式，如自动序列化和调试格式化。
显式销毁类型。 Mojo 现在对显式销毁类型（有时称为“线性类型”）提供了一流的支持。AnyType、Movable 和 Copyable 特质不再要求 __del__() 方法；当你需要隐式销毁时，请使用 ImplicitlyDestructible。显式销毁类型让你能够编码需要显式资源处理的强大不变式。
类型化错误。 函数现在可以指定它们引发的错误类型，而不再默认使用 Error（例如，fn foo() raises CustomError -> Int）。类型化错误非常高效——它们编译为一个替代返回值，无需栈展开——使其适用于 GPU 和嵌入式目标。
具有默认实现的特质。 Hashable、Writable 和 Equatable 特质现在提供了默认实现，这些实现使用反射根据结构体字段自动派生行为。简单的结构体无需编写任何样板代码即可符合这些特质——只需确保所有字段都符合同一特质即可。
UInt 类型重新设计。 UInt 结构体已被替换为 Scalar[DType.uint] 的类型别名，从而支持对机器字长的无符号 SIMD 数据类型进行更强大的泛型编程。
字符串 UTF-8 安全性。 String 现在为原始字节提供了三个显式构造函数：from_utf8=（验证并在错误时引发异常）、from_utf8_lossy=（将无效序列替换为 �）和 unsafe_from_utf8=（无验证）。这使得 UTF-8 处理的保证在构造时变得明确。

文档

新的 Mojo 快速入门页面提供了“5分钟”介绍，指导安装 Mojo 和探索基本语言特性。
新的反射页面描述了 Mojo 新的编译时反射功能，包括示例用例。
在 值销毁 页面添加了一个关于如何实现和使用显式销毁类型的章节。
新的 Jupyter Notebooks 页面提供了在 Google Colab 和本地 JupyterLab 环境中使用 Mojo 进行编程（包括 GPU 编程示例）的分步指南。
新的具象化页面描述了如何使编译时值在运行时可用。

语言增强

Mojo 现在支持引发“类型化错误”，即函数可以指定其引发的类型，而不是默认使用 Error 类型。这是通过在 raises 关键字后指定来完成的，例如 fn foo() raises CustomError -> Int。

Mojo 中引发的错误非常高效——它们作为替代返回值工作：例如，像 fn () raises Int -> Float32: 这样的函数编译成返回 Int 或 Float32 的代码，并使用隐式布尔结果来确定哪个是有效的——没有昂贵的栈展开或隐含的慢速动态逻辑。这意味着抛出的错误在 GPU 和其他嵌入式目标上也能正常工作。

try 块中“捕获”的类型会自动推断为 try 主体内第一个抛出的类型，例如：

    try:
        print(foo())
    except err:       # "err" 的类型为 CustomError
        print(err)

类型化抛出与泛型“协同工作”，允许定义高阶函数，例如：

    fn parametric_raise_example[ErrorType: AnyType](fp: fn () raises ErrorType) raises ErrorType:
        # ... 假设这里有一些迭代或其他令人兴奋的事情发生。
        fp()

这与其他支持相配合，允许上下文泛型抛出类型，例如：

    fn call_parametric_raise_example[GenTy: AnyType](func_ptr: fn () raises GenTy):
      fn raise_int() raises Int: pass
      try:
          parametric_raise_example(raise_int)
      except err_int:   # 类型为 Int
          ref x: Int = err_int
      fn raise_string() raises String: pass
      try:
        parametric_raise_example(raise_string)
      except err_string: # 类型为 String
          ref s: String = err_string
      try:
        parametric_raise_example(func_ptr)
      except err_gen: # 类型为 GenTy
          ref s: GenTy = err_gen
      # 非引发函数推断错误类型为 `Never`，这允许这些
      # 函数方便地在泛型高阶函数中传播非引发性。
      fn doesnt_raise(): pass
      # 注意这不位于 try 块中。Mojo 知道 'parametric_raise_example'
      # 不会引发，因为 'doesnt_raise' 函数不会。
      parametric_raise_example(doesnt_raise)

作为此功能的一部分，上下文管理器已扩展以支持类型化抛出，并且如果需要处理错误，也可以推断错误类型，例如：

    struct MyGenericExitCtxtMgr:
      # 在进入 with 块时调用。
      fn __enter__(self): ...
      # 在没有抛出错误的情况下退出 with 块时调用。
      fn __exit__(self): ...
      # 在抛出错误的情况下退出 with 块时调用。
      fn __exit__[ErrType: AnyType](self, err: ErrType) -> Bool: ...

Mojo 现在支持 Never 类型，该类型永远无法实例化。此类型可用于没有正常返回值的函数（如 abort()），以及保证会引发而不会返回正常值的函数。声明为引发 Never 的函数（以及使用 Never 作为其错误类型实例化的泛型函数）编译成的 ABI 与不 raise 的函数相同。

Mojo 现在允许使用 comptime(x) 表达式强制子表达式在编译时求值。当你无法（或不想）将某些类型具体化为运行时值时，这可以使处理这些类型变得更加优雅。例如，如果你只想从编译时布局获取大小：

    fn takes_layout[a: Layout]():
      # 具体化整个布局值仅仅是为了从中获取大小
      print(a.size())
      # 已经可以用编译时声明冗余地解决此问题。
      comptime a_size = a.size()
      print(a_size)
      # 现在可以告诉 Mojo 在编译时对表达式进行求值。
      print(comptime(a.size()))

Mojo 现在区分了特质方法中的 ... 和 pass。使用 ... 继续表示没有默认实现——pass 现在指定一个默认的什么都不做的实现。例如：

    trait T:
        # 无默认实现
        fn foo(self): ...
        # 默认实现，什么都不做
        fn bar(self) : pass

编译器将对使用 pass 为具有返回值的特质方法定义默认实现的情况报错：

    trait T:
        foo.mojo:2:26: error: trait method has results but default implementation returns no value; did you mean '...'?
        fn foo(self) -> Int: pass
                         ^
        trait.mojo:2:8: note: in 'foo', declared here
        fn foo(self) -> Int: pass
           ^

Mojo 现在允许从非引发函数到引发函数的函数类型之间进行隐式转换。它还允许结果类型可隐式转换的函数类型之间进行隐式转换。

    fn takes_raising_float(a: fn () raises -> Float32): ...
    fn returns_int() -> Int: ...
    fn example():
        # 现在这是可以的。
        takes_raising_float(returns_int)

Mojo 现在允许返回引用的函数转换为返回值的函数，如果该类型可隐式复制或可隐式转换为目标类型：

    fn fn_returns_ref(x: SomeType) -> ref [x.field] Int: ...
    fn examples():
        # 正确，来自 fn_returns_ref 的 Int 结果可以被隐式复制。
        var f1 : fn (x: SomeType) -> Int = fn_returns_ref
        # 正确，来自 fn_returns_ref 的 Int 结果可隐式转换为 Float64。
        var f2 : fn (x: SomeType) -> Float64 = fn_returns_ref

上下文管理器（在 with 语句中使用）现在可以定义消耗性退出方法——即 fn __exit__(var self)——这对于显式销毁的上下文管理器很有用。这也可与 deinit 一起使用。
deinit 参数约定现在可以应用于结构体方法的任何参数，但参数类型仍必须是封闭结构体类型。

Mojo 现在支持 ... 表达式。它是 EllipsisType 的逻辑上空值。它可以在重载函数中使用，例如 getitem() 调用：

    struct YourType:
      fn __getitem__(self, idx: Int) -> Int:
        # ... 传递 x[i] 时的行为
      fn __getitem__(self, idx: EllipsisType) -> Int:
        # ... 传递 x[...] 时的行为

语言变更

Mojo 语言基本特质层次结构已更改，以扩展对显式销毁类型（有时称为“线性类型”）的一流支持。

AnyType、Movable 和 Copyable 特质不再要求类型提供编译器可能在拥有值未被使用时隐式调用的 __del__() 方法。相反，泛型代码中应使用 ImplicitlyDestructible 特质来要求类型是隐式可销毁的。

显式销毁类型使 Mojo 程序能够在类型系统中编码强大的不变式，通过以某种方式建模类型，要求用户“将来”采取行动，而不是简单地隐式丢弃一个实例。

使用 T: AnyType 的代码可以更改为使用 T: ImplicitlyDestructible 以在此更改后保留其现有行为。

相关地，UnknownDestructibility 特质现在不再需要，因为它等同于新的 AnyType 行为。
Mojo 不再支持仅对参数进行函数重载：例如，它不会尝试区分 fn foo[a: Int8](): 和 fn foo[a: Int32]():。Mojo 从未以可靠的方式完全实现先前的支持，移除这一特性简化了语言。它当然仍然支持基于函数参数的重载。
for-each 循环中的 __next_ref__() 方法已被移除。现在你可以实现迭代器的 __next__() 方法来返回一个值或一个引用。直接使用集合时，Mojo 将使用返回引用的变体，但将允许其符合 Iterator 以与使用复制值的泛型算法一起使用。
origin_of(x) 运算符现在返回 Origin 类型的值，而不是内部 MLIR 类型，并且像 ImmutOrigin 这样的别名现在也是 Origin 类型。
Origin.cast_from[x] 语法已被替换为从任何起源到不可变起源（ImmutOrigin(x)）的安全隐式转换和显式不安全转换（unsafe_origin_mutcast[origin, mut=m]）。
用于显式解包参数的 *_ 和 **_ 语法已被简化的 ... 语法取代。现在可以使用 T[4, 5, ...] 来代替 T[4, 5, *_, **_]。... 会延迟关键字和非关键字参数的绑定。
编译器现在会对使用 alias 关键字发出警告，并建议使用 comptime。

编译器现在会对不合格访问结构体参数发出警告，例如

    @fieldwise_init
    struct MyStuff[my_param: Int]:
        fn give_me_stuff(self) -> Int:
            # 警告：不合格访问结构体参数 'my_param'；请改用 'Self.my_param'
            return my_param

Mojo 编译器在诊断无效调用时会生成更清晰的错误消息：它会提及参数名称，而不是“argument #4”。

库变更

反射和内省

reflection 模块已通过新的编译时内省功能得到显著扩展。该模块已从 compile.reflection 移至顶级 reflection 模块（将导入从 from compile.reflection import ... 更新为 from reflection import ...）。在内部，该模块现在被组织为 type_info 和 struct_fields 子模块，但通过 from reflection import ... 的公共 API 保持不变。

结构体字段内省 - 用于编译时结构体分析的新 API：
- struct_field_count[T]() - 返回结构体中的字段数
- struct_field_names[T]() - 以 [StaticString, N] 形式的 InlineArray 返回字段名称
- struct_field_types[T]() - 返回所有字段类型的可变参数列表
- struct_field_index_by_name[T, name]() - 按名称返回字段索引
- struct_field_type_by_name[T, name]() - 返回包装在 ReflectedType 中的字段类型
  
  这些 API 适用于具体类型和泛型类型参数：
```
    fn print_fields[T: AnyType]():
        comptime names = struct_field_names[T]()
        comptime types = struct_field_types[T]()
        @parameter
        for i in range(struct_field_count[T]()):
            print(names[i], get_type_name[types[i]]())
```
  按索引访问字段 - 两个新的神奇函数支持基于索引的字段访问而无需复制：
- __struct_field_type_at_index(T, idx) - 返回索引处的字段类型
- __struct_field_ref(idx, ref s) - 返回字段的引用
  
  与复制数据的 kgen.struct.extract 不同，__struct_field_ref() 返回一个引用，使反射实用程序能够与非可复制类型一起工作：
```
    fn print_all_fields[T: AnyType](ref s: T):
        comptime names = struct_field_names[T]()
        @parameter
        for i in range(struct_field_count[T]()):
            print(names[i], "=", __struct_field_ref(i, s))
```
  字段字节偏移量 - offset_of[T, name=field_name]() 返回结构体内命名字段的字节偏移量，实现无需复制的序列化和其他低级内存操作。偏移量是使用目标的数据布局在编译时计算的，正确考虑了对齐填充。这类似于 C/C++ 的 offsetof 和 Rust 的 offset_of! 宏。还有一个 offset_of[T, index=i]() 重载可用于按字段索引查找。
```
    from reflection import offset_of
    struct Point:
        var x: Int      # 偏移量 0
        var y: Float64  # 偏移量 8（对齐后）
    fn main():
        comptime x_off = offset_of[Point, name="x"]()  # 0
        comptime y_off = offset_of[Point, name="y"]()  # 8
```
  类型内省实用程序：
- is_struct_type[T]() - 如果 T 是 Mojo 结构体类型则返回 True。对于保护使用结构体特定 API 的反射代码以避免非结构体类型（例如，MLIR 原始类型）上的编译器错误很有用。使用 @parameter if，因为这些 API 在编译时求值。
- get_base_type_name[T]() - 返回参数化类型基类型的非限定名称。例如，get_base_type_name[List[Int]]() 返回 "List"。对于识别集合类型而不管其元素类型很有用。
  
  源代码位置内省：
- SourceLocation - 保存文件名、行号和列信息的结构体
- source_location() - 返回其被调用位置
- call_location() - 返回调用者被调用的位置（要求调用者是 @always_inline）
  
  这些以前是 builtin._location 中的内部 API（_SourceLocation、__source_location、__call_location）。旧的模块已被移除。
```
    from reflection import source_location, call_location, SourceLocation
    fn main():
        var loc = source_location()
        print(loc)  # main.mojo:5:15
    @always_inline
    fn log_here():
        var caller_loc = call_location()
        print("Called from:", caller_loc)
```
  注意：这些 API 在参数表达式（编译时上下文）中无法正常工作（它们返回占位符值）。
  
  特质一致性检查 - conforms_to() 内置函数现在接受来自 struct_field_types[T]() 等反射 API 的类型，从而能够对动态获取的字段类型进行一致性检查：
```
    @parameter
    for i in range(struct_field_count[MyStruct]()):
        comptime field_type = struct_field_types[MyStruct]()[i]
        @parameter
        if conforms_to(field_type, Copyable):
            print("Field", i, "is Copyable")
```

具有默认实现的特质

现在有几个特质具有使用反射从结构体字段自动派生行为的默认实现。这意味着简单的结构体无需实现任何方法即可符合这些特质——所有字段只需要符合相同的特质：

Hashable - 默认的 __hash__() 哈希所有字段：
```
    @fieldwise_init
    struct Point(Hashable):
        var x: Float64
        var y: Float64
    hash(Point(1.5, 2.7))  # 自动生效
```
Writable - 默认的 write_to() 格式化所有字段：
```
    @fieldwise_init
    struct Point(Writable):
        var x: Float64
        var y: Float64
    print(Point(1.5, 2.7))  # Point(x=1.5, y=2.7)
```
Equatable - 默认的 __eq__() 比较所有字段：
```
    @fieldwise_init
    struct Point(Equatable):
        var x: Int
        var y: Int
    print(Point(1, 2) == Point(1, 2))  # True
```
注意：默认的 Equatable 执行成员逐个相等性比较，这可能不适用于具有浮点字段的类型（由于 NaN 语义）。重写这些方法中的任何一个以实现自定义行为。

集合和迭代器

移除了 List 可变参数初始化器。

类似下面的语句：

        var x = List[Int32](1, 2, 3)

可以更新为：

        var x: List[Int32] = [1, 2, 3]

类似下面的表达式：
```
        var x = foo(List[Float32](1, 2, 3))
```
可以更新为将显式类型“提示”移到第一个元素周围：
```
        var x = foo([Float32(1), 2, 3])
```

类似下面的表达式：

        var data = Span(List[Byte](1, 2, 3))

可以更新为将显式元素类型移到 Span：

        var data = Span[Byte]([1, 2, 3])

没有跨步的 List 切片现在返回 Span，而不是 List，并且不再分配内存。
InlineArray 不再符合 ImplicitlyCopyable。用户必须显式复制数组或获取引用。
IndexList 不再可隐式从 Int 构造。以前，填充构造函数（将单个 Int 广播到所有元素）被标记为 @implicit，允许像 var x: IndexList[3] = 5 这样的代码，这将创建 (5, 5, 5)。已移除此隐式转换以提高类型安全性。请改用显式构造：IndexList[3](5)。

Dict 现在在失败时引发自定义的 DictKeyError 类型，使得处理查找失败更加高效。

    var d = Dict[String, Int]()
    var key = "missing_key"
    try:
        _ = d[key]
    except e:
        print(e)  # 打印: DictKeyError

builtin_slice 模块中添加了新的 ContiguousSlice 和 StridedSlice 类型，以支持对没有跨步的切片进行专门化处理。
Span 现在符合 Iterable。
any() 和 all() 现在适用于 Iterable，这意味着它们可以作用于 map() 的结果。
Tuple 已得到改进：
- 现在可以使用 Tuple.concat() 连接元组。
- 现在可以使用 Tuple.reverse() 反转元组。
peekable() 函数已添加到 iter 模块中。这允许用户在不推进迭代器的情况下窥视下一个元素。

字符串和文本

String 的 UTF-8 保证已得到加强。
- 现在有三个独立的构造函数用于将原始字节（Span[Byte]）转换为 String：
  - String(from_utf8=...)：如果字节是无效的 UTF-8 则引发错误
  - String(from_utf8_lossy=...)：将无效的 UTF-8 字节序列转换为 (U+FFFD, �) 替换字符，并且不引发错误。
  - String(unsafe_from_utf8=...)：不安全地假定输入字节是有效的 UTF-8，不做任何检查。
- append_byte() 已被弃用，并被 append() 取代。
String 和 StringSlice 的 strip()、lstrip() 和 rstrip() 方法现在支持剥离多字节 Unicode 码点。此外，如果“chars”字符串包含的字符与要剥离的字符串中的某个字符共享其首字节，lstrip() 和 strip() 将不再产生无效的 UTF-8。

StringLiteral.format() 现在在格式字符串无效时发出编译时约束错误（而不是运行时错误）。

    "Hello, {!invalid}".format("world")
    # note: constraint failed: Conversion flag "invalid" not recognized.

StringSlice.char_length() 已重命名为 count_codepoints()。相同的函数已添加到 String 和 StringLiteral。
添加了 CStringSlice 作为与以空字符结尾的 C 风格字符串（const char*）进行类型安全交互的方式。
移除了接受可变参数序列的 String.join(*Writable) 重载，因为它可能与剩余的 String.join(Span[Writable]) 重载产生歧义。
移除了 Int.__init__(self, value: StringSlice, base: UInt) 构造函数。用户应直接调用 atol()。

指针和内存

OwnedDLHandle.get_symbol() 现在返回 UnsafePointer[T, MutAnyOrigin] 而不是 UnsafePointer[T, ImmutAnyOrigin]。从共享库加载的绝大多数符号旨在可变使用，从可变→不可变（通过 .as_immutable()）比从不可变→可变（通过 .unsafe_mut_cast[True]()）更安全。现在需要不可变指针的用户只需对结果调用 .as_immutable() 即可。
“LegacyUnsafePointer”类型已更改为将其可变性作为第一个推断参数而不带默认值，而不是作为后面带有默认值 true 的显式参数。我们建议尽快移除此类型，但要大致模拟先前的行为，请尝试：
```
    from memory import LegacyUnsafePointer
    comptime UnsafePointer = LegacyUnsafePointer[mut=True, *_, **_]
```
外部起源现在使用类型级别的 {Mut,Immut,}ExternalOrigin 别名来表示，而不是拼写为 Origin[True].external 这样的形式，提高了与其他起源类型的一致性。
UnsafePointer 现在可以使用 unsafe_from_address 初始化器从原始内存地址初始化。
alloc() 现在具有 debug_assert()，确保计数为非负数。

显式销毁类型

标准库中现在提供了对显式销毁类型的基本支持。显式销毁类型——有时称为“线性类型”——是不定义 __del__() 方法的类型，编译器无法自动调用该方法来销毁实例。相反，显式销毁类型必须提供一个接受 deinit self 的命名方法，程序员需要在拥有实例不再使用时显式调用该方法。

更新后的 AnyType 特质可用于参数中，表示支持无法隐式销毁的对象实例的泛型代码。
- Span、UnsafePointer、Pointer 和 OwnedPointer 可以指向显式销毁类型。
  - 添加了 UnsafePointer.destroy_pointee_with()，用于使用指向该类型析构函数的函数指针就地销毁显式销毁类型。
- List、InlineArray、Optional、Variant、VariadicListMem 和 VariadicPack 现在可以包含显式销毁类型。
  - Variant.take() 现在接受 deinit self 而不是 mut self。
  - 添加了 Variant.destroy_with()，通过传入类型的析构函数来就地销毁显式销毁类型。
  - 用于参数的 *args 语言语法现在支持显式销毁类型。
- Iterator.Element 不再要求 ImplicitlyDestructible。
- UnsafeMaybeUninitialized 现在可以包含显式销毁类型。

类型系统和特质

使用一种新的“无条件一致性”技术，利用 conforms_to() 和 trait_downcast() 来执行“后期”元素类型一致性检查，现在一些标准库类型能够符合以前无法符合的特质：
- List、Dict、Set、Deque、InlineArray 和 LinkedList 现在符合 Writable、Stringable 和 Representable。List 也符合 Equatable。
- Pointer、ArcPointer 和 OwnedPointer 现在符合 Writable。
- Iterator、Tuple、Variant 和 Optional 不再要求其元素类型为 Copyable。
Iterator 特质和 for-each 循环移除了 __has_next__() 方法，现在使用一个会引发 StopIteration 的 __next__() 方法。这更好地遵循了 Python 的先例，实现起来更方便，并且在某些情况下可能带来轻微的性能提升。
已移除 ImplicitlyBoolable 特质。该特质使类型能够隐式转换为 Bool。这种行为很少使用，并且可能导致细微的错误，例如错误地将 Int 或 UnsafePointer 等类型传递给期望 Bool 的参数会静默编译成功。
Error 类型不再符合 Boolable 或 Defaultable。现在必须使用有意义的上下文来构造错误，应该通过 Optional[Error] 来表达可选性，而不是将错误视为布尔值。
Copyable 特质现在细化（refine）了 Movable 特质。这意味着已经要求 Copyable 的结构体和泛型算法不需要再提及它们也需要 Movable。
EqualityComparable 特质已被弃用，转而使用功能相同的 Equatable。
我们已经从枚举类类型（如 DType 和 AddressSpace）中移除了 Identifiable。此更改与 Identifiable 用于比较内存地址的概念有关。

Python 互操作性

ConvertibleFromPython 特质及其关联的初始化器现在有一个必需的关键字参数。之前：Int(pyObj)。之后：Int(py=pyObj)。这避免了在多种重载可能适用，或者隐式转换为 PythonObject 可能掩盖正在进行的 Python 操作的情况下产生歧义。

PythonObject 现在支持从 None 进行隐式转换，允许更自然的类似 Python 的代码：

    var obj: PythonObject = None  # 现在无需显式的 PythonObject(None) 即可工作
    fn returns_none() -> PythonObject:
        return None  # 隐式转换

文件 I/O 和操作系统

io 模块中的基本文件 I/O 操作现在使用直接的 libc 系统调用（open()、close()、read()、write()、lseek()）在 Mojo 中原生实现。FileHandle 类型不再依赖于 CompilerRT 函数，提供了更好的性能和透明度。错误处理现在包含基于 errno 的消息，以改进诊断。
添加了 os.process 子模块，其中包含生成进程和等待进程的实用程序。这些使用 posix_spawn() 并且不通过系统 shell。
各种操作系统包装函数现在在引发的错误消息中包含 errno 的值。
os 模块现在公开了一个 link() 函数，包装了 Unix 的 link(2) 系统调用。
os 模块现在公开了一个 symlink() 函数，包装了 Unix 的 symlink(2) 系统调用。

GPU 编程

Layout 不再符合 ImplicitlyCopyable。此更改的动机是，使用 Layout.size() 等方法很容易意外地在运行时具体化 Layout。用户需要适应此更改带来的一些下游变化。以下是一些有助于此过渡的常见模式：

    from layout import Layout
    fn foo(a: Layout) -> Layout:
        return a.copy()  # `a` 需要显式复制。
    fn bar(var a: Layout) -> Layout:
        return a^  # 如果 a 是按值获取的，可以使用转移运算符。
    fn baz():
        comptime a = Layout.row_major(4, 4)
        # `a` 需要被具体化，因为 `foo` 返回一个不是 ImplicitlyCopyable 的类型（`Layout`）。
        var b = foo(materialize[a]())
        # `bar` 按值移动 `b`，但 `foo` 也按引用接受 `b`，
        # 所以我们需要显式复制。
        _ = bar(b.copy())
        _ = foo(b)
        # 由于我们不再使用 `b`，这里按值获取它没问题。
        _ = bar(b^)
        # 由于 `Layout.size()` 返回一个 `Int`，我们可以使用 `comptime`
        # 表达式来计算返回值，而无需具体化 `a`。
        for i in range(comptime (a.size())):
            ...

DeviceContext.enqueue_function_checked() 和 DeviceStream.enqueue_function_checked() 已重命名为 enqueue_function()。同样，DeviceContext.compile_function_checked() 已重命名为 compile_function()。
对于指定了 shared_mem_bytes 但未指定 func_attribute 的 NVIDIA GPU（分配 > 48KB），DeviceContext.enqueue_function() 和 DeviceContext.enqueue_function_experimental() 现在会自动将 func_attribute 推断为 FuncAttribute.MAX_DYNAMIC_SHARED_SIZE_BYTES(shared_mem_bytes)。这消除了在许多情况下需要两次指定相同共享内存大小的需求，减少了样板代码并防止值不匹配。在 AMD GPU 上或对于分配 ≤ 48KB 的情况，应在需要时提供显式的 func_attribute 值。

inlined_assembly() 函数现在从 sys 模块公开导出，允许用户将原始汇编指令直接嵌入到 Mojo 代码中。这提供了使用 LLVM 风格的内联汇编语法对硬件操作进行细粒度控制。示例：

    from sys import inlined_assembly
    # 在 NVIDIA GPU 上使用 PTX 汇编将 bfloat16 转换为 float32。
    var result = inlined_assembly[
        "cvt.f32.bf16 $0, $1;",
        Float32,
        constraints="=f,h",
        has_side_effect=False,
    ](my_bf16_as_int16)

格式化和输出

Writer 已重新设计，仅支持 UTF-8 数据，而不是任意的 Byte 序列。write_bytes() 方法已被 write_string() 取代。
- 根据这些变化，String 的 write_bytes() 方法也已被弃用，其初始化器 __init__(out self, *, bytes: Span[Byte]) 的关键字参数已重命名为 unsafe_from_utf8。这使其更符合现有的 StringSlice 构造函数，并明确声明从任意字节构造本质上是不安全的。
Writer 和 Writable 已被移到一个新的 format 模块中，并从 io 中移出。这些特质与二进制 I/O 没有直接关系，而是与类型/值字符串格式化紧密相关。
Writable 特质现在通过可选的 write_repr_to() 方法支持调试格式化，该方法由 repr() 和 {!r} 格式说明符调用。此外，repr() 和字符串格式化方法（.format() 在 String、StringSlice 和 StringLiteral 上）现在接受 Writable 类型，从而实现无需中间字符串分配的高效格式化。为了保留现有行为，同时实现 Stringable & Representable 和 Writable 的类型将继续使用 Stringable & Representable 方法；只有实现 Writable 的类型才会使用新的代码路径。
Counter 现在符合 Writable、Stringable 和 Representable。
black_box() 已添加到 benchmark 实用程序中，作为防止编译器积极优化掉值的一种方法。类似于 keep()，但是它返回其参数。

其他库变更

UInt 结构体已被一个新的 UInt 类型别名替换，指向 Scalar[DType.uint]。这是一个重大更改，通过抽象机器字长的无符号 SIMD 数据类型，实现了更强大的泛型编程。

此更改可能会破坏依赖 UInt 与 Int/SIMD 之间隐式转换的代码。SIMD 类型在编译时的可折叠性也稍差一些，这可能导致 where 子句、编译时表达式和其他参数化上下文中的一些代码现在失败或崩溃。这些缺点将在后续补丁中根据需要解决。
已移除 Int 和 UInt 之间的隐式转换。
random 模块现在使用基于 Philox 算法的纯 Mojo 实现（通过内部包装器），取代了之前的 CompilerRT C++ 依赖。Philox 算法提供了出色的统计质量，适用于 CPU 和 GPU，并使随机数生成完全透明且源代码可用。请注意，这会更改给定种子值的随机数序列，可能会影响依赖可重现序列的测试或代码。
StringableRaising 已被弃用，并且已从标准库中移除其使用。
Variadic 现在拥有 zip_types()、zip_values() 和 slice_types()。

工具变更

Mojo 编译器现在支持 -Werror 标志，该标志将所有警告视为编译错误。这对于在 CI/CD 流水线中强制执行更严格的代码质量标准很有用。该标志适用于 Mojo 编译器工具（mojo run、mojo build、mojo package、mojo doc）。与 --disable-warnings 一起使用时，警告首先会升级为错误，因此错误不会被抑制。
- 对应的 -Wno-error 标志禁用将警告视为错误。当两个标志都指定时，最后一个标志生效。
使用 --target-accelerator 指定 CUDA 架构现在期望一个 sm 版本字符串，而不仅仅是计算能力。例如，--target-accelerator=nvidia:80 应更改为 --target-accelerator=nvidia:sm_80。如果版本格式不正确，编译器将默认使用支持的最低 sm 版本。
Mojo LSP 服务器现在会对文档更新进行防抖处理，以减少快速键入时的 CPU 使用率。以前，每次击键都会触发完整文档解析；现在更新会以 150 毫秒的延迟进行合并，在积极编辑期间将解析频率降低了 10-50 倍。
Mojo 编译器现在在错误消息中对非常长的类型进行“差异”比较，以更易于理解的方式解释正在发生的情况。
具有不同详细程度级别的细化错误打印提供了控制，当函数实例化失败时，参数值如何作为细化错误的一部分显示。--elaboration-error-verbose=value 现在接受一个值，其中：
- no-params 表示不显示任何具体参数值。这有助于将与递归相关的错误消息折叠成较短的块。
- simple-params 表示以用户友好的格式显示简单类型（包括数字类型和字符串）的具体化参数值（默认值）。
- all-params 表示显示所有具体参数值。这是为那些不介意阅读 MLIR 属性但希望更多了解参数值的高级程序员准备的。
添加了 --elaboration-max-depth 来控制最大细化器实例化深度。这个（无符号）值有助于检测编译时递归。默认值是 std::numeric_limits<unsigned>::max()。
使用 --validate-doc-strings 的文档字符串验证现在会在声明为引发错误的 fn 函数（raises）缺少 Raises 文档字符串时发出错误（以前只发出警告）。因为 Mojo 自动将所有 def 函数视为引发函数，所以我们不强制执行 def 函数的 Raises 文档（以避免嘈杂的误报）。
文档字符串验证现在包括 comptime 别名。--diagnose-missing-doc-strings 标志现在会检查公共别名是否具有正确格式化的文档字符串（摘要以句点结尾，以大写字母开头）。还会检查参数化别名是否具有正确的 Parameters: 部分。
--validate-doc-strings 标志在 mojo doc 中已被弃用，并从其他工具（mojo build、mojo run、mojo package）中移除。请改用 -Werror 将警告视为错误。
Mojo 编译器现在支持 -Xlinker 标志，以将选项直接传递给链接器，例如：
```
    mojo build -Xlinker -lfoo main.mojo
```
注意：此选项仅在使用 mojo build 时有效。使用 mojo run 时，参数将被忽略并发出警告。
Mojo 编译器现在支持 mojo build、mojo run 和 mojo package 的 --experimental-export-fixit 标志。此标志将修复建议导出到与 clang-apply-replacements 兼容的 YAML 文件，而不是直接应用它们。这对于将 Mojo 的修复建议集成到外部工具工作流中很有用。该标志与 --experimental-fixit（直接应用修复建议）互斥。
Mojo 调试器 mojo break-on-raise 功能现在在调试器实例中的多个目标上正常工作。该设置是针对每个目标的。

实验性变更

本节描述的变更都是实验性的，可能在未来的版本中更改、替换或移除。

Mojo 现在支持编译时特质一致性检查（通过 conforms_to()）和下转型（通过 trait_downcast()）。这允许用户实现基于特质一致性的静态调度等功能。例如：

    fn maybe_print[T : AnyType](maybe_printable : T):
      @parameter
      if conforms_to(T, Writable):
        print(trait_downcast[Writable](maybe_printable))
      else:
        print("[UNPRINTABLE]")

添加了对 where 子句中 DType 表达式的支持：
```
    fn foo[dt: DType]() -> Int where dt == DType.int32:
        return 42
```
目前支持以下表达式：
- 相等和不相等
- is_signed()、is_unsigned()、is_numeric()、is_integral()、is_floating_point()、is_float8()、is_half_float()
添加了对 where 子句中 SIMD 表达式的支持：
```
    fn foo[dt: DType, x: Int]() -> Int where SIMD[dt, 4](x) + 2 > SIMD[dt, 4](0):
        return 42
```
目前支持以下表达式：
- 默认构造和从 Int 及 IntLiteral 构造
- 相等、不相等和其他比较运算符
- 加法、减法和乘法
- 位逻辑运算（不包括移位）

已移除

以下已弃用的 GPU 兼容性模块已被移除：
- gpu.id - 请改用 from gpu import block_idx, thread_idx, ...
- gpu.block - 请改用 from gpu.primitives.block import ...
- gpu.warp - 请改用 from gpu.primitives.warp import ...
- gpu.cluster - 请改用 from gpu.primitives.cluster import ...
- gpu.grid_controls - 请改用 from gpu.primitives.grid_controls import ...
- gpu.mma - 请改用 from gpu.compute.mma import ...
- gpu.mma_operand_descriptor - 请改用 from gpu.compute.mma_operand_descriptor import ...
- gpu.mma_util - 请改用 from gpu.compute.mma_util import ...
- gpu.mma_sm100 - 请改用 from gpu.compute.arch.mma_nvidia_sm100 import ...
- gpu.semaphore - 请改用 from gpu.sync.semaphore import ...
- gpu.tcgen05 - 请改用 from gpu.compute.arch.tcgen05 import ...
已移除 DeviceContext 的 enqueue_function_unchecked() 和 compile_function_unchecked()。请将代码迁移到使用 enqueue_function() 和 compile_function()。
已移除 NDBuffer。请改用 LayoutTensor。

UnsafePointer.offset() 方法现已弃用。请改用指针算术运算：

    # 之前
    new_ptr = ptr.offset(n)
    # 之后
    new_ptr = ptr + n

mojo_hub

更新摘要

✨ 反射模块增强：提供全面的编译时自省能力，支持结构体字段枚举、类型/偏移量查询、源码位置追踪及动态类型特征检查，赋能高级元编程（如自动序列化）。
🛠️ 语言核心特性：
- 新增显式销毁类型（线性类型）的一流支持，AnyType/Movable/Copyable 不再要求 __del__ 方法。
- 支持类型化错误，函数可声明具体错误类型，编译为高效交替返回值，适用于 GPU/嵌入式场景。
- Hashable、Writable、Equatable 等特征现提供基于反射的默认实现，简化结构体适配。
📦 标准库重要变更：
- UInt 类型重构为 Scalar[DType.uint] 的别名，提升泛型编程能力。
- String 构造器明确区分 UTF-8 验证策略（严格验证、有损替换、不安全假定），增强安全性。
🔧 工具与其它：编译器支持 -Werror 标志；反射、类型系统多处改进与修复；移除多项已弃用 GPU 兼容模块。