Functions 2
Immutable function args by default
In V function arguments are immutable by default, and mutable args have to be
marked on call.
Since there are also no globals, that means that the return values of the functions,
are a function of their arguments only, and their evaluation has no side effects
(unless the function uses I/O).
Function arguments are immutable by default, even when references are passed.
[!NOTE]
However, V is not a purely functional language.
There is a compiler flag to enable global variables (-enable-globals
), but this is
intended for low-level applications like kernels and drivers.
Mutable arguments
It is possible to modify function arguments by declaring them with the keyword mut
:
struct User {
name string
mut:
is_registered bool
}
fn (mut u User) register() {
u.is_registered = true
}
mut user := User{}
println(user.is_registered) // "false"
user.register()
println(user.is_registered) // "true"
In this example, the receiver (which is just the first argument) is explicitly marked as mutable,
so register()
can change the user object. The same works with non-receiver arguments:
fn multiply_by_2(mut arr []int) {
for i in 0 .. arr.len {
arr[i] *= 2
}
}
mut nums := [1, 2, 3]
multiply_by_2(mut nums)
println(nums)
// "[2, 4, 6]"
Note that you have to add mut
before nums
when calling this function. This makes
it clear that the function being called will modify the value.
It is preferable to return values instead of modifying arguments,
e.g. user = register(user)
(or user.register()
) instead of register(mut user)
.
Modifying arguments should only be done in performance-critical parts of your application
to reduce allocations and copying.
For this reason V doesn't allow the modification of arguments with primitive types (e.g. integers).
Only more complex types such as arrays and maps may be modified.
Variable number of arguments
V supports functions that receive an arbitrary, variable amounts of arguments, denoted with the
...
prefix.
Below, a ...int
refers to an arbitrary amount of parameters that will be collected
into an array named a
.
fn sum(a ...int) int {
mut total := 0
for x in a {
total += x
}
return total
}
println(sum()) // 0
println(sum(1)) // 1
println(sum(2, 3)) // 5
// using array decomposition
a := [2, 3, 4]
println(sum(...a)) // <-- using prefix ... here. output: 9
b := [5, 6, 7]
println(sum(...b)) // output: 18
Anonymous & higher order functions
fn sqr(n int) int {
return n * n
}
fn cube(n int) int {
return n * n * n
}
fn run(value int, op fn (int) int) int {
return op(value)
}
fn main() {
// Functions can be passed to other functions
println(run(5, sqr)) // "25"
// Anonymous functions can be declared inside other functions:
double_fn := fn (n int) int {
return n + n
}
println(run(5, double_fn)) // "10"
// Functions can be passed around without assigning them to variables:
res := run(5, fn (n int) int {
return n + n
})
println(res) // "10"
// You can even have an array/map of functions:
fns := [sqr, cube]
println(fns[0](10)) // "100"
fns_map := {
'sqr': sqr
'cube': cube
}
println(fns_map['cube'](2)) // "8"
}
Closures
V supports closures too.
This means that anonymous functions can inherit variables from the scope they were created in.
They must do so explicitly by listing all variables that are inherited.
my_int := 1
my_closure := fn [my_int] () {
println(my_int)
}
my_closure() // prints 1
Inherited variables are copied when the anonymous function is created.
This means that if the original variable is modified after the creation of the function,
the modification won't be reflected in the function.
mut i := 1
func := fn [i] () int {
return i
}
println(func() == 1) // true
i = 123
println(func() == 1) // still true
However, the variable can be modified inside the anonymous function.
The change won't be reflected outside, but will be in the later function calls.
fn new_counter() fn () int {
mut i := 0
return fn [mut i] () int {
i++
return i
}
}
c := new_counter()
println(c()) // 1
println(c()) // 2
println(c()) // 3
If you need the value to be modified outside the function, use a reference.
mut i := 0
mut ref := &i
print_counter := fn [ref] () {
println(*ref)
}
print_counter() // 0
i = 10
print_counter() // 10
Parameter evaluation order
The evaluation order of the parameters of function calls is NOT guaranteed.
Take for example the following program:
fn f(a1 int, a2 int, a3 int) {
dump(a1 + a2 + a3)
}
fn main() {
f(dump(100), dump(200), dump(300))
}
V currently does not guarantee that it will print 100, 200, 300 in that order.
The only guarantee is that 600 (from the body of f
) will be printed after all of them.
This may change in V 1.0 .