Functions 2

Pure functions by default

V functions are pure by default, meaning that their return values are a function of their arguments only, and their evaluation has no side effects (besides I/O).

This is achieved by a lack of global variables and all function arguments being immutable by default, even when references are passed.

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 using the keyword mut:

  1. struct User {
  2.     name string
  3. mut:
  4.     is_registered bool
  5. }
  7. fn (mut u User) register() {
  8.     u.is_registered = true
  9. }
  11. mut user := User{}
  12. println(user.is_registered) // "false"
  13. user.register()
  14. println(user.is_registered) // "true"

In this example, the receiver (which is simply the first argument) is marked as mutable, so register() can change the user object. The same works with non-receiver arguments:

  1. fn multiply_by_2(mut arr []int) {
  2.     for i in 0 .. arr.len {
  3.         arr[i] *= 2
  4.     }
  5. }
  7. mut nums := [1, 2, 3]
  8. multiply_by_2(mut nums)
  9. println(nums)
  10. // "[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. 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.

Use user.register() or user = register(user) instead of register(mut user).

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

  1. struct User {
  2.     name          string
  3.     age           int
  4.     is_registered bool
  5. }
  7. fn register(u User) User {
  8.     return {
  9.         u |
  10.         is_registered: true
  11.     }
  12. }
  14. mut user := User{
  15.     name: 'abc'
  16.     age: 23
  17. }
  18. user = register(user)
  19. println(user)

Anonymous & high order functions

  1. fn sqr(n int) int {
  2.     return n * n
  3. }
  5. fn run(value int, op fn (int) int) int {
  6.     return op(value)
  7. }
  9. fn main() {
  10.     println(run(5, sqr)) // "25"
  11.     // Anonymous functions can be declared inside other functions:
  12.     double_fn := fn (n int) int {
  13.         return n + n
  14.     }
  15.     println(run(5, double_fn)) // "10"
  16.     // Functions can be passed around without assigning them to variables:
  17.     res := run(5, fn (n int) int {
  18.         return n + n
  19.     })
  20. }