Functions in V (Vlang)

Functions are the primary unit of code organization in V. You have already met one in every program so far – fn main(), the entry point – but V functions go well beyond a place to put statements. They are first-class values you can pass around, return from other functions, and capture into closures.

V’s function design reflects its core philosophy: explicit, simple, and safe. Arguments are immutable by default, just like ordinary variables, so a function cannot quietly mutate the data you hand it unless you opt in with mut. There are no global variables by default, which makes the inputs and outputs of every function obvious from its signature alone. And because V is statically typed, every parameter and return value carries a type the compiler checks for you.

In this tutorial you will learn how to define functions with parameters and return values, return multiple values at once, write recursive functions, treat functions as values (higher-order functions and closures), and attach methods to your own structs. Along the way you’ll see where V deliberately differs from languages like Go and Rust.

Defining and Calling Functions

A function is declared with the fn keyword, followed by its name, a parenthesized parameter list, and an optional return type. Each parameter is written as name type. V also supports returning multiple values as a tuple – a common pattern that avoids out-parameters and special wrapper types.

Create a file named functions.v:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// A function with two parameters and a return value
fn add(a int, b int) int {
	return a + b
}

fn multiply(a int, b int) int {
	return a * b
}

// A function with no return value (a "procedure")
fn greet(name string) {
	println('Hello, ${name}!')
}

// Multiple return values
fn min_max(numbers []int) (int, int) {
	mut min := numbers[0]
	mut max := numbers[0]
	for n in numbers {
		if n < min {
			min = n
		}
		if n > max {
			max = n
		}
	}
	return min, max
}

fn main() {
	sum := add(3, 4)
	product := multiply(3, 4)
	println('Sum: ${sum}')
	println('Product: ${product}')

	greet('V')

	low, high := min_max([5, 2, 9, 1, 7])
	println('Min: ${low}, Max: ${high}')
}

Notice that min and max are declared mut because the loop reassigns them – everything in V is immutable until you say otherwise. The call low, high := min_max(...) unpacks the two returned values into two variables in a single statement.

No default arguments. Unlike Python or C++, V functions do not support default parameter values. The idiomatic alternative is to pass a struct of options (V supports default struct field values), keeping call sites explicit.

Recursion

A function may call itself. V handles recursion naturally, and because there are no hidden control-flow surprises, recursive definitions read exactly like their mathematical counterparts. The classic examples are factorial and the Fibonacci sequence.

Create a file named recursion.v:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Factorial: n! = n * (n-1) * ... * 1
fn factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n - 1)
}

// Fibonacci: each number is the sum of the two before it
fn fib(n int) int {
	if n < 2 {
		return n
	}
	return fib(n - 1) + fib(n - 2)
}

fn main() {
	println('5! = ${factorial(5)}')
	println('10! = ${factorial(10)}')

	mut series := []int{}
	for i in 0 .. 10 {
		series << fib(i)
	}
	println('Fibonacci: ${series}')
}

The 0 .. 10 range loop runs i from 0 up to (but not including) 10, and series << fib(i) appends each result to the array. String interpolation can hold a full expression, so ${factorial(5)} calls the function inline.

Higher-Order Functions and Closures

In V, functions are first-class values. A function’s type is written fn (ParamTypes) ReturnType, so you can accept functions as parameters, return them, and store them in variables. Closures – functions that capture variables from their surrounding scope – require an explicit capture list in [brackets], keeping V’s “no hidden behavior” promise: you can always see exactly what a closure holds onto.

Create a file named higher_order.v:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// Takes a function as a parameter
fn apply(f fn (int) int, value int) int {
	return f(value)
}

// Returns a function (a closure capturing `factor`)
fn make_multiplier(factor int) fn (int) int {
	return fn [factor] (x int) int {
		return x * factor
	}
}

fn main() {
	// Anonymous function stored in a variable
	square := fn (x int) int {
		return x * x
	}
	println('square(6) = ${apply(square, 6)}')

	// Anonymous function passed inline
	cube := apply(fn (x int) int {
		return x * x * x
	}, 4)
	println('cube of 4 = ${cube}')

	// A closure: `triple` remembers factor = 3
	triple := make_multiplier(3)
	println('triple(7) = ${triple(7)}')

	// `map` is a built-in higher-order method; `it` is each element
	nums := [1, 2, 3, 4, 5]
	doubled := nums.map(it * 2)
	println('doubled = ${doubled}')
}

The capture list fn [factor] (x int) int is what makes the returned function a closure – it explicitly copies factor into the function so it survives after make_multiplier returns. The array method .map(it * 2) shows that V’s standard library leans on higher-order functions too, with it as the implicit element variable.

Methods on Structs

V has no classes, but you can attach methods to any struct (or other type) by writing a receiver between fn and the method name. A plain receiver is read-only; mark it mut to let the method modify the value it was called on. This is how V models behavior without inheritance.

Create a file named methods.v:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

struct Rectangle {
	width  int
	height int
}

// Read-only receiver `r`
fn (r Rectangle) area() int {
	return r.width * r.height
}

fn (r Rectangle) perimeter() int {
	return 2 * (r.width + r.height)
}

struct Counter {
mut:
	count int
}

// Mutable receiver: this method changes the Counter
fn (mut c Counter) increment() {
	c.count++
}

fn main() {
	rect := Rectangle{
		width:  4
		height: 3
	}
	println('Area: ${rect.area()}')
	println('Perimeter: ${rect.perimeter()}')

	mut counter := Counter{}
	counter.increment()
	counter.increment()
	counter.increment()
	println('Count: ${counter.count}')
}

Because increment mutates its receiver, the method uses fn (mut c Counter), the count field is declared under a mut: block, and the variable must itself be declared mut counter. V forces all three to line up, so mutation is never accidental.

Running with Docker

Run each example using the official V image – no local install required:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Pull the official V image
docker pull thevlang/vlang:alpine

# Run the basic functions example
docker run --rm -v $(pwd):/app -w /app thevlang/vlang:alpine v run functions.v

# Run the recursion example
docker run --rm -v $(pwd):/app -w /app thevlang/vlang:alpine v run recursion.v

# Run the higher-order functions example
docker run --rm -v $(pwd):/app -w /app thevlang/vlang:alpine v run higher_order.v

# Run the methods example
docker run --rm -v $(pwd):/app -w /app thevlang/vlang:alpine v run methods.v

Expected Output

Running functions.v:

Sum: 7
Product: 12
Hello, V!
Min: 1, Max: 9

Running recursion.v:

5! = 120
10! = 3628800
Fibonacci: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Running higher_order.v:

square(6) = 36
cube of 4 = 64
triple(7) = 21
doubled = [2, 4, 6, 8, 10]

Running methods.v:

Area: 12
Perimeter: 14
Count: 3

Key Concepts

• fn name(param type) ReturnType – Functions are declared with fn; every parameter and return value is explicitly typed and checked at compile time.
• Multiple return values – Functions can return a tuple like (int, int), unpacked at the call site with low, high := ..., avoiding out-parameters and wrapper structs.
• Immutable arguments by default – Parameters cannot be modified unless declared mut, so functions can’t quietly mutate your data.
• No default arguments – V omits default parameter values; pass an options struct (struct fields can have defaults) when you need them.
• Recursion is first-class – Functions call themselves naturally; with no hidden control flow, recursive code mirrors its mathematical definition.
• Functions are values – The type fn (int) int lets you pass functions as arguments, return them, and store them in variables.
• Closures capture explicitly – A closure lists captured variables in [brackets], so what it holds is always visible – consistent with V’s no-hidden-behavior design.
• Methods, not classes – Behavior is attached via a receiver fn (r Type) method(); use a mut receiver to modify the value, which V requires you to opt into at every level.