62 lines
1.9 KiB
Mojo
62 lines
1.9 KiB
Mojo
def multiplier[factor: Int](x: Int) -> Int:
|
|
return x * factor
|
|
|
|
|
|
def main():
|
|
comptime times_ten = multiplier[10]
|
|
var x10 = times_ten(3)
|
|
```
|
|
|
|
Parameters accept both types and values at compile time. When a
|
|
parameter accepts a type, the result is type-parameterized code. When it
|
|
accepts a value, the result is value-parameterized code.
|
|
|
|
```mojo no-test
|
|
struct MyList[T: AnyType]:
|
|
# ... type-parameterized
|
|
|
|
struct FixedBuffer[size: Int]:
|
|
# ... value-parameterized
|
|
```
|
|
|
|
Mojo's parameters are similar to C++ template parameters or Rust generic
|
|
parameters.
|
|
|
|
In Mojo, "parameter" always means a compile-time value, and
|
|
"argument" always means a run-time value.
|
|
|
|
In most other languages, a parameter is part of a declaration and an
|
|
argument is the value you pass at the call site. Mojo changes the
|
|
meaning of "parameter" to refer specifically to compile-time values.
|
|
|
|
Mojo makes this distinction visible in syntax: use `[]` for
|
|
parameters and `()` for arguments.
|
|
|
|
In addition to parameterizing structs and functions, you can also define
|
|
parameterized `comptime` values.
|
|
|
|
## Parameterized functions {#parameters-and-generics}
|
|
|
|
To define a *parameterized function*, add parameters in square brackets ahead
|
|
of the argument list. Each parameter is formatted just like an argument: a
|
|
parameter name, followed by a colon and a type. In the
|
|
following example, the function has a single parameter, `count` of type `Int`.
|
|
|
|
```mojo
|
|
def repeat[count: Int](msg: String):
|
|
comptime for i in range(count):
|
|
print(msg)
|
|
```
|
|
|
|
The [`comptime`](/docs/manual/metaprogramming/comptime-evaluation/#comptime-for)
|
|
keyword shown here
|
|
causes the `for` loop to be fully unrolled at compile time. The `comptime for`
|
|
requires the loop limits to be known at compile time. Since `count` is a
|
|
parameter, `range(count)` can be calculated at compile time.
|
|
|
|
Calling a parameterized function, you provide values for the parameters, just
|
|
like function arguments:
|
|
|
|
```mojo
|
|
repeat[3]("Hello")
|