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 that V is not a purely functional language however.

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.

Struct update syntax

V makes it easy to return a modified version of an object:

struct User {
    name          string
    age           int
    is_registered bool
}
fn register(u User) User {
    return User{
        ...u
        is_registered: true
    }
}
mut user := User{
    name: 'abc'
    age: 23
}
user = register(user)
println(user)

Variable number of arguments

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.

// oksyntax
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.

// oksyntax
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.

// oksyntax
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. Warning: you need to make sure the reference is always valid, otherwise this can result in undefined behavior.

// oksyntax
mut i := 0
mut ref := &i
print_counter := fn [ref] () {
    println(*ref)
}
print_counter() // 0
i = 10
print_counter() // 10