許多語言都具有元編程功能：即編寫生成或修改代碼的代碼。Python 具有動態(tài)元編程功能：裝飾器、元類等功能。這些功能使 Python 非常靈活且高效，但由于它們是動態(tài)的，因此會產生運行時開銷。其他語言具有靜態(tài)或編譯時元編程功能，如 C 預處理器宏和 C++ 模板。這些功能可能受到限制且難以使用。

為了支持 Modular 在 AI 領域的工作，Mojo 旨在提供功能強大、易于使用且運行時成本為零的元編程。這種編譯時元編程使用與運行時程序相同的語言，因此您無需學習新語言 - 只需學習一些新功能即可。

主要新功能是參數(shù)。您可以將參數(shù)視為編譯時變量，該變量將成為運行時常量。這種“參數(shù)”用法可能與您在其他語言中習慣的用法不同，在其他語言中，“參數(shù)”和“參數(shù)”通常可以互換使用。在 Mojo 中，“參數(shù)”和“參數(shù)表達式”指的是編譯時值，而“參數(shù)”和“表達式”指的是運行時值。

在 Mojo 中，您可以向結構或函數(shù)添加參數(shù)。您還可以定義命名參數(shù)表達式（別名），將其用作運行時常量。

參數(shù)化函數(shù)

要定義參數(shù)化函數(shù)，請在參數(shù)列表前面的方括號中添加參數(shù)。每個參數(shù)的格式與參數(shù)一樣：參數(shù)名稱，后跟冒號和類型（必填）。在以下示例中，該函數(shù)有一個參數(shù)count類型為Int。

fn repeat[count: Int](msg: String):@parameterfor i in range(count):print(msg)

@parameter此處顯示的指令導致在for編譯時評估循環(huán)。僅當循環(huán)限制是編譯時常量時，該指令才有效。由于count是參數(shù)， 因此range(count)可以在編譯時計算。

調用參數(shù)化函數(shù)時，您可以為參數(shù)提供值，就像函數(shù)參數(shù)一樣：

repeat[3]("Hello")

輸出：

Hello
Hello
Hello

編譯器在編譯期間解析參數(shù)值，并為每個唯一參數(shù)值創(chuàng)建函數(shù)的具體版本repeat。解析參數(shù)值并展開循環(huán)后，該repeat3 函數(shù)大致相當于：

fn repeat_3(msg: String):print(msg)print(msg)print(msg)

參數(shù)和泛型

“泛型”是指可以作用于多種類型值的函數(shù)，或可以容納多種類型值的容器。例如， List可以容納不同類型的值，因此您可以擁有一個值列表Int，或一個String值列表。

在 Mojo 中，泛型使用參數(shù)來指定類型。例如，List 采用類型參數(shù)，因此整數(shù)向量寫為List[Int]。因此，所有泛型都使用參數(shù)，但并非所有使用參數(shù)的東西都是泛型。

例如，repeat上一節(jié)中的函數(shù)包含類型為 的形參Int和類型為 的實參String。它是參數(shù)化的，但不是泛型的。泛型函數(shù)或結構體在類型上是參數(shù)化的。例如，我們可以重寫repeat以采用符合以下Stringable特征的任何類型的參數(shù)：

fn repeat[MsgType: Stringable, count: Int](msg: MsgType):@parameterfor i in range(count):print(msg)# Must use keyword parameter for `count`
repeat[count=2](42)

42
42

fn repeat[MsgType: Stringable, //, count: Int](msg: MsgType):@parameterfor i in range(count):print(msg)# MsgType is always inferred, so first positional keyword `2` is passed to `count`
repeat[2](42)

參數(shù)化結構

您還可以向結構體添加參數(shù)。您可以使用參數(shù)化結構體來構建通用容器。例如，通用數(shù)組類型可能包含如下代碼：

from memory.unsafe_pointer import UnsafePointer, initialize_pointee_copy, destroy_pointeestruct GenericArray[ElementType: CollectionElement]:var data: UnsafePointer[ElementType]var size: Intfn __init__(inout self, *elements: ElementType):self.size = len(elements)self.data = UnsafePointer[ElementType].alloc(self.size)for i in range(self.size):initialize_pointee_move(self.data.offset(i), elements[i])fn __del__(owned self):for i in range(self.size):destroy_pointee(self.data.offset(i))self.data.free()fn __getitem__(self, i: Int) raises -> ref [__lifetime_of(self)] ElementType:if (i < self.size):return self.data[i]else:raise Error("Out of bounds")

該結構體有一個參數(shù)，ElementType它是您想要存儲在數(shù)組中的數(shù)據(jù)類型的占位符，有時稱為類型參數(shù)。ElementType其類型為 CollectionElement，它是一種 表示可以復制和移動的任何類型的特征。

與參數(shù)化函數(shù)一樣，使用參數(shù)化結構體時需要傳入?yún)?shù)值。在這種情況下，創(chuàng)建的實例時 GenericArray，需要指定要存儲的類型，如Int、 或 Float64。（這有點令人困惑，因為在這種情況下傳遞的參數(shù)值是類型。沒關系：Mojo 類型是有效的編譯時值。）

您將看到它ElementType在整個結構體中被使用，而您通常會看到類型名稱。例如，作為elements構造函數(shù)中的正式類型，以及方法的返回類型__getitem__()。

以下是使用的示例GenericArray：

var array = GenericArray[Int](1, 2, 3, 4)
for i in range(array.size):print(array[i], end=" ")

輸出：

1
2
3
4

參數(shù)化結構體可以使用類型Self來表示結構體的具體實例（即指定了所有參數(shù)）。例如，您可以添加一個靜態(tài)工廠方法，GenericArray其簽名如下：

struct GenericArray[ElementType: CollectionElement]:...@staticmethodfn splat(count: Int, value: ElementType) -> Self:# Create a new array with count instances of the given value

這里，Self相當于寫成GenericArray[ElementType]。也就是說，你可以像splat()這樣調用該方法：

GenericArray[Float64].splat(8, 0)

該方法返回 的一個實例GenericArray[Float64]。

案例研究：SIMD類型

為了得到參數(shù)化類型的真實示例，讓我們看一下Mojo中的SIMD標準庫中的類型。

單指令多數(shù)據(jù) (SIMD)是許多現(xiàn)代 CPU、GPU 和自定義加速器內置的并行處理技術。SIMD 允許您同時對多個數(shù)據(jù)執(zhí)行單個操作。例如，如果您想對數(shù)組中每個元素求平方根，則可以使用 SIMD 來并行化工作。

處理器使用硬件中的低級向量寄存器來實現(xiàn) SIMD，這些寄存器可保存標量數(shù)據(jù)類型的多個實例。為了在這些處理器上使用 SIMD 指令，必須將數(shù)據(jù)調整為適當?shù)?SIMD 寬度（數(shù)據(jù)類型）和長度（向量大小）。處理器可能支持 512 位或更長的 SIMD 向量，并支持從 8 位整數(shù)到 64 位浮點數(shù)的多種數(shù)據(jù)類型，因此定義所有可能的 SIMD 變體并不實際。

Mojo 的SIMD類型（定義為結構）通過其方法公開常見的 SIMD 操作，并使 SIMD 數(shù)據(jù)類型和大小值參數(shù)化。這允許您將數(shù)據(jù)直接映射到任何硬件上的 SIMD 向量。

以下是 Mojo 類型定義的精簡版（非功能性版本）SIMD：

struct SIMD[type: DType, size: Int]:var value: … # Some low-level MLIR stuff here# Create a new SIMD from a number of scalarsfn __init__(inout self, *elems: SIMD[type, 1]):  ...# Fill a SIMD with a duplicated scalar value.@staticmethodfn splat(x: SIMD[type, 1]) -> SIMD[type, size]: ...# Cast the elements of the SIMD to a different elt type.fn cast[target: DType](self) -> SIMD[target, size]: ...# Many standard operators are supported.fn __add__(self, rhs: Self) -> Self: ...

因此，您可以像這樣創(chuàng)建和使用 SIMD 向量：

var vector = SIMD[DType.int16, 4](1, 2, 3, 4)
vector = vector * vector
for i in range(4):print(vector[i], end=" ")

輸出：

1
4
9
16

如您所見，將簡單的算術運算符*應用于一對 SIMD向量會對每個向量中的相應元素進行運算。

使用參數(shù)定義每個 SIMD 變體非常有利于代碼重用，因為類型 SIMD可以靜態(tài)地表達所有不同的向量變體，而不需要語言預先定義每個變體。

由于SIMD是參數(shù)化類型，self其函數(shù)中的參數(shù)會攜帶這些參數(shù) — 完整類型名稱是SIMD[type, size]。雖然將其寫出是有效的（如 的返回類型所示splat()），但這可能很冗長，因此我們建議像示例中那樣使用Self類型（來自 PEP673