Chapter 1 Getting Started with V

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Code Comments

• Single Line Comments
• Multi Line Comments
• Programm Commented All Places

This chapter introduces the core design philosophies of V. You will learn how to set up your development environment, compile and run programs, and document your code using comments.

Code Comments

Single Line Comments

Single Line Comments

Comments are non-executable lines of text in a program that explain what the code does. They are ignored by the compiler but are essential for human developers. This lesson on Single Line Comments demonstrates how to write and format comments in V.

Additional Context from Repository docs:

This example demonstrates the concepts of single line comments.

module main

// greet function prints greetings to the console
pub fn greet() {
	println('Hello, Welcome to the Jungle!')
}

fn main() {
	greet()
}

Multi Line Comments

Multi Line Comments

Comments are non-executable lines of text in a program that explain what the code does. They are ignored by the compiler but are essential for human developers. This lesson on Multi Line Comments demonstrates how to write and format comments in V.

Additional Context from Repository docs:

This example demonstrates the concepts of multi line comments.

module main

/*
multiply is a function that accepts two integer arguments
namely x and y.
It then performs multiplication of input arguments and returns the product which is again a type of integer as specified in the function signature.
x is an input argument accepts values of type of int
y is an input argument accepts values of type of int
multiply function returns the result of type int which is a multiplication of input arguments x and y
*/
fn multiply(x int, y int) int {
	return x * y
}

fn main() {
	println(multiply(4, 5))
}

Programm Commented All Places

Programm Commented All Places

Comments are non-executable lines of text in a program that explain what the code does. They are ignored by the compiler but are essential for human developers. This lesson on Programm Commented All Places demonstrates how to write and format comments in V.

Additional Context from Repository docs:

This example demonstrates the concepts of programm commented all places.

module main

// Space3D A struct indicating the 3 dimensional coordinate system
struct Space3D {
mut:
	x int
	// x is an integer field that represents coordinate
	y int
	// y is an integer field that represents coordinate
	z int
	// z is an integer field that represents coordinate
}

/*
get_point is a function that returns a struct of Type Space3D with points x,y,z passed as input arguments to it
x is an input argument accepts values of type of int
y is an input argument accepts values of type of int
z is an input argument accepts values of type of int
get_point function returns a Struct result of type Space3D with its coordinates set as value passed as input arguments x, y and z
*/
fn get_point(x int, y int, z int) Space3D {
	return Space3D{
		x: x
		y: y
		z: z
	}
}

const origin = get_point(0, 0, 0)

// Defining origin as a constant
fn main() {
	// origin := Space3D {x: 0, y: 0, z:0}
	println(origin)
}

Chapter 2 Variables and Constants

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Constants

• Define Single Constant
• Define Multiple Constants
• Define Constant Of Type Struct
• Define Constant Of Type Function
• Define Module Level Constants
• Cannot Define Constants Inside Functions
• Constants Module - Main (main.v)
• Constant Module Prefix - Helper (file1.v)

Variables

• Parallel Declaration Immutable Variables
• Parallel Declaration Mutable Variables
• Parallel Declaration Mut And Immutable Vars
• Augmented Assignment String
• Augmented Assignment Integer
• Declare Mutable Variable
• Cannot Update Mutable With Another Type
• Declare Immutable Variable
• Cannot Update Immutable Variables
• Declared And Assigned
• Declared And Not Assigned
• Unused Variables Will Be Warned
• Global Variables Not Allowed - Scope Demo
• Global Variables Not Allowed - File Scope Demo
• Variable Redeclaration
• Variable Scope For Same Variable Names
• Variable Shadowing Not Allowed

Variables are the basic storage units of any program. In this chapter, we explore how V handles variables with a safety-first mindset: variables are immutable by default, variable shadowing is forbidden, and constants are declared in module scopes. You will learn to manage program data safely and cleanly.

Constants

Define Single Constant

Define Single Constant

Constants in V are defined using the const block. Constants are values that are known at compile time and never change throughout the execution of the program. By convention, constant names are written in lowercase, unlike many other languages.

This example shows how to define and use a single constant.

Additional Context from Repository docs:

This example demonstrates the concepts of define single constant.

const app_name = 'V on Wheels'

fn main() {
	println(app_name)
}

Define Multiple Constants

Define Multiple Constants

You can define multiple constants within a single const block. This keeps related constants grouped together and makes the code cleaner.

This example shows how to declare multiple constants (integers, strings, floats) together.

Additional Context from Repository docs:

This example demonstrates the concepts of define multiple constants.

const app_name2 = 'V on Wheels'
const max_connections = 1000
const decimal_places = 2
const pi = 3.14

fn main() {
	println(app_name)
	println(max_connections)
	println(decimal_places)
	println(pi)
}

Define Constant Of Type Struct

Define Constant Of Type Struct

Variables and constants store state in V programs. This lesson on Define Constant Of Type Struct covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of define constant of type struct.

module main

struct Space3D {
mut:
	x int
	y int
	z int
}

const origin = Space3D{
	x: 0
	y: 0
	z: 0
}

fn main() {
	println(origin)
}

Define Constant Of Type Function

Define Constant Of Type Function

Variables and constants store state in V programs. This lesson on Define Constant Of Type Function covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of define constant of type function.

module main

struct Space3D {
mut:
	x int
	y int
	z int
}

fn get_point(x int, y int, z int) Space3D {
	return Space3D{
		x: x
		y: y
		z: z
	}
}

const origin = get_point(0, 0, 0)

fn main() {
	println(origin)
}

Define Module Level Constants

Define Module Level Constants

Variables and constants store state in V programs. This lesson on Define Module Level Constants covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of define module level constants.

module main

const app_name = 'V on Wheels'

fn main() {
	println(app_name)
}

Cannot Define Constants Inside Functions

Cannot Define Constants Inside Functions

Variables and constants store state in V programs. This lesson on Cannot Define Constants Inside Functions covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of cannot define constants inside functions.

module main

const app_name = 'V on Wheels'

fn main() {
        const greet = 'hi' // this is not top level constant definition, throws error.
        println(app_name)
}

Constants Module - Main (main.v)

Constants Module - Main

Variables and constants store state in V programs. This lesson on Main covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of main.

module main

import mod1

fn main() {
	mod1.do_work()
}

Constant Module Prefix - Helper (file1.v)

Constant Module Prefix - Helper

Variables and constants store state in V programs. This lesson on File1 covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of file1.

module mod1

const greet_count = 5

pub fn do_work() {
	println(greet_count)
}

Variables

Parallel Declaration Immutable Variables

Parallel Declaration Immutable Variables

In V, you can declare and initialize multiple variables in a single line. This is known as parallel declaration. By default, variables in V are immutable (read-only). Once assigned a value, they cannot be changed.

This program demonstrates declaring two variables a and b at the same time and assigning them initial values. Any attempt to modify a or b later in the code will cause a compile-time error.

Additional Context from Repository docs:

This example demonstrates the concepts of parallel declaration immutable variables.

fn main() {
	name, age, city := 'Ada', 36, 'London'
	println('${name} is ${age} years old and lives in ${city}.')
}

Parallel Declaration Mutable Variables

Parallel Declaration Mutable Variables

If you want to modify parallelly declared variables later, you must explicitly mark them as mutable using the mut keyword. In V, mutability is always explicit to make code safer and easier to reason about.

Here, we declare two mutable variables a and b at the same time using mut. We then reassign their values using the standard assignment operator (=).

Additional Context from Repository docs:

This example demonstrates the concepts of parallel declaration mutable variables.

// mutable variables parallel assignment

fn main() {
	mut i, mut j := 'Hi', 'Hello'
	println(i)
	println(j)

	// updating mutable variables in parallel
	i, j = 'Hi there', 'Hello, Good Day!'
}

Parallel Declaration Mut And Immutable Vars

Parallel Declaration Mut And Immutable Vars

Variables and constants store state in V programs. This lesson on Parallel Declaration Mut And Immutable Vars covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of parallel declaration mut and immutable vars.

fn main() {
	mut msg, i := 'Hello', 32
	println(msg) // Hello
	msg = 'Hi'
	println(msg) // Hi
	println(i) // 32
	i = 2 // error: `i` is immutable, declare it with `mut` to make it mutable
}

Augmented Assignment String

Augmented Assignment String

Variables and constants store state in V programs. This lesson on Augmented Assignment String covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of augmented assignment string.

fn main() {
	mut greet := 'Hi'
	println(greet)

	greet = greet + ' there, How are you?'
	println(greet)

	greet += ' Hope you have a great day!'
	println(greet)
}

Augmented Assignment Integer

Augmented Assignment Integer

Variables and constants store state in V programs. This lesson on Augmented Assignment Integer covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of augmented assignment integer.

fn main() {
	mut cnt := 10
	println(cnt)
	cnt = cnt + 5
	println(cnt)
	cnt += 5
	println(cnt)
}

Declare Mutable Variable

Declare Mutable Variable

By default, all variables in V are immutable (their values cannot change). To declare a variable whose value can be modified later, you must prepend the mut keyword before the variable name.

This example shows how to declare a mutable variable, change its value, and print the results.

Additional Context from Repository docs:

This example demonstrates the concepts of declare mutable variable.

fn main() {
	mut count := 0
	count += 1
	count += 2
	println('Current count: ${count}')
}

Cannot Update Mutable With Another Type

Cannot Update Mutable With Another Type

Variables and constants store state in V programs. This lesson on Cannot Update Mutable With Another Type covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of cannot update mutable with another type.

fn main() {
	mut i := 10
	i = 100
	i = 'Apple' // throws error
}

Declare Immutable Variable

Declare Immutable Variable

Variables and constants store state in V programs. This lesson on Declare Immutable Variable covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of declare immutable variable.

fn main() {
	greeting := 'Hello'
	message := greeting + ', V!'
	println(message)
}

Cannot Update Immutable Variables

Cannot Update Immutable Variables

One of V's core safety features is immutability by default. If you declare a variable without the mut keyword and then try to reassign it a new value, the compiler will refuse to compile the program.

This example demonstrates what happens when you try to update an immutable variable (expect a compiler error).

Additional Context from Repository docs:

This example demonstrates the concepts of cannot update immutable variables.

fn main() {
	msg := 'Hello'
	msg = 'Good Day!' // throws error
}

Declared And Assigned

Declared And Assigned

Variables and constants store state in V programs. This lesson on Declared And Assigned covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of declared and assigned.

fn main() {
	mut i := 0
	// declared and assigned
	println(i)
}

Declared And Not Assigned

Declared And Not Assigned

V does not allow variables to be declared without an initial value. Unlike other languages that initialize variables to a default 'zero' value or null, V forces you to explicitly provide a value. This prevents uninitialized variable bugs.

This example illustrates that declaring a variable without an assignment is a compilation error.

Additional Context from Repository docs:

This example demonstrates the concepts of declared and not assigned.

fn main() {
	mut a // throws error
}

Unused Variables Will Be Warned

Unused Variables Will Be Warned

To keep codebases clean and efficient, the V compiler detects if you declare a variable but never use (consume) it. By default, V treats unused variables as a compilation warning/error, encouraging you to clean up dead code.

This example shows a declared variable that is never used.

Additional Context from Repository docs:

This example demonstrates the concepts of unused variables will be warned.

fn main() {
	i := 'hello' // i is not used anywhere, so warns when run in dev mode and throws error when run in prod mode
	x := 3
	y := 2
	println(x + y)
}

Global Variables Not Allowed - Scope Demo

Global Variables Not Allowed - Scope Demo

V does not allow global variables by default. Global state is a major source of bugs, race conditions in multi-threaded applications, and poor code structure. By forbidding globals, V enforces clean, modular code passing state via arguments.

These examples demonstrate that declaring variables outside of the main function or modules is strictly prohibited.

Additional Context from Repository docs:

This example demonstrates the concepts of global variables not allowed.

module main

fn method1() {
	msg := 'Hello from Method1'
	println(msg)
}

fn main() {
	method1()
	println(msg) // Will throw error as msg declared and accessible only in method1
}

Global Variables Not Allowed - File Scope Demo

Global Variables Not Allowed - File Scope Demo

V does not allow global variables by default. Global state is a major source of bugs, race conditions in multi-threaded applications, and poor code structure. By forbidding globals, V enforces clean, modular code passing state via arguments.

These examples demonstrate that declaring variables outside of the main function or modules is strictly prohibited.

Additional Context from Repository docs:

This example demonstrates the concepts of global variables not allowed.

module main

fn method1() {
	if true {
		mut b := 10
		b++
	}
	println(b)
}

fn main() {
	method1()
}

Variable Redeclaration

Variable Redeclaration

Variables and constants store state in V programs. This lesson on Variable Redeclaration covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of variable redeclaration.

module main

fn main() {
        x := 3
        y := 2
        println(x + y)
        x := 5 // re-definition of variable x is not allowed
}

Variable Scope For Same Variable Names

Variable Scope For Same Variable Names

Variables and constants store state in V programs. This lesson on Variable Scope For Same Variable Names covers declaration rules, default values, scopes, or constant naming conventions.

Additional Context from Repository docs:

This example demonstrates the concepts of variable scope for same variable names.

module main

fn method1() {
	msg := 'Hello from Method1'
	println(msg)
}

fn method2() {
	msg := 'Hello from Method2'
	println(msg)
}

fn main() {
	method1()
	method2()
}

Variable Shadowing Not Allowed

Variable Shadowing Not Allowed

Variable shadowing happens when a variable declared within an inner scope (like a loop or a function block) has the same name as a variable in an outer scope. V strictly forbids variable shadowing to prevent confusion and accidental bugs where a developer modifies the wrong variable.

This example shows how V rejects shadowed variable declarations.

Additional Context from Repository docs:

This example demonstrates the concepts of variable shadowing not allowed.

module main

fn scope_demo() {
	x := 10
	println(x)
	if true {
		x := 20 // throws error as shadowing is not allowed
		println(x)
	}
	println(x)
}

fn main() {
	scope_demo()
}

Chapter 3 Primitive Data Types

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Primitive Types Demo

• Primitive Types Demo Code

Boolean Type

• Logical Operators
• Relational Operators
• Boolean Methods

Numeric Types

• Declaring Integers
• Hex Binary Octa Notation Of Declaring Integers
• Promoting Numeric Types
• Arithmetic Operators
• Bitwise Operators
• Shift Operators
• Shift Operator On Range Of Integers
• Integer Methods
• Float Methods
• U8 Methods
• Size Pointer Methods

Rune Type

• Declare Rune
• Rune Operations With Strings
• Rune Methods

String Type

• Declare String
• String Read Only Array Of Bytes
• Strings Immutable By Default
• Declaring Mutable Strings
• Cannot Mutate String Elements
• String Interpolation
• Escape Special Characters
• Declare Raw Strings
• String Concatenation Using Plus Sign
• String Concatenation Using Interpolation
• Extract Substring From String Literal
• Split String
• String To Runes Array
• Count Sub String Occurences
• Check String Contains Substring
• String Contains Is Case Sensitive
• Common String Methods

Primitive Types Demo

Primitive Types Demo Code

Primitive Types Demo Code

This comprehensive example demonstrates every primitive data type in V:

• Boolean: bool (representing true or false).
• String: string (representing an immutable array of bytes).
• Rune: rune (representing a single Unicode code point, alias for u32).
• Signed Integers: i8 (8-bit), i16 (16-bit), int (32-bit), i64 (64-bit).
• Unsigned Integers: u8 (8-bit, alias byte), u16 (16-bit), u32 (32-bit), u64 (64-bit).
• Platform-dependent sizes: isize (signed size of a pointer), usize (unsigned size of a pointer).
• Floating Point Numbers: f32 (32-bit single-precision), f64 (64-bit double-precision).

For each type, the example initializes a value and prints its value, type (using typeof(var).name), and size in bytes (using sizeof(var)).

Additional Context from Repository docs:

This example demonstrates the concepts of primitive types demo.

module main

fn main() {
	println('==================================================')
	println('        Vlang Primitive Data Types Demo           ')
	println('==================================================')

	// 1. Boolean Type
	b := true
	println('Boolean: val: ${b} | type: ${typeof(b).name} | size: ${sizeof(b)} byte')

	// 2. String Type
	s := 'Hello, V!'
	println('String:  val: "${s}" | type: ${typeof(s).name} | size: ${sizeof(s)} bytes')

	// 3. Rune Type (unicode character, represented as `r` prefix or backticks)
	r := `V`
	println('Rune:    val: ${r} (char: ${r.str()}) | type: ${typeof(r).name} | size: ${sizeof(r)} bytes')

	// 4. Signed Integers
	i_8 := i8(-128)
	i_16 := i16(-32768)
	i_32 := int(-2147483648)
	i_64 := i64(-9223372036854775808)
	println('i8:      val: ${i_8} | type: ${typeof(i_8).name} | size: ${sizeof(i_8)} byte')
	println('i16:     val: ${i_16} | type: ${typeof(i_16).name} | size: ${sizeof(i_16)} bytes')
	println('int:     val: ${i_32} | type: ${typeof(i_32).name} | size: ${sizeof(i_32)} bytes')
	println('i64:     val: ${i_64} | type: ${typeof(i_64).name} | size: ${sizeof(i_64)} bytes')

	// 5. Unsigned Integers
	u_8 := u8(255)
	u_16 := u16(65535)
	u_32 := u32(4294967295)
	u_64 := u64(18446744073709551615)
	println('u8:      val: ${u_8} | type: ${typeof(u_8).name} | size: ${sizeof(u_8)} byte')
	println('u16:     val: ${u_16} | type: ${typeof(u_16).name} | size: ${sizeof(u_16)} bytes')
	println('u32:     val: ${u_32} | type: ${typeof(u_32).name} | size: ${sizeof(u_32)} bytes')
	println('u64:     val: ${u_64} | type: ${typeof(u_64).name} | size: ${sizeof(u_64)} bytes')

	// 6. Platform-dependent Sizes
	isize_val := isize(-12345)
	usize_val := usize(12345)
	println('isize:   val: ${isize_val} | type: ${typeof(isize_val).name} | size: ${sizeof(isize_val)} bytes')
	println('usize:   val: ${usize_val} | type: ${typeof(usize_val).name} | size: ${sizeof(usize_val)} bytes')

	// 7. Floating Point Numbers
	f_32 := f32(3.14159)
	f_64 := f64(2.718281828459)
	println('f32:     val: ${f_32} | type: ${typeof(f_32).name} | size: ${sizeof(f_32)} bytes')
	println('f64:     val: ${f_64} | type: ${typeof(f_64).name} | size: ${sizeof(f_64)} bytes')

	println('==================================================')
}

V is a statically-typed language, meaning every variable has a fixed data type at compile time. In this chapter, you will learn about V's primitive types: booleans for logic, numeric types for numbers, runes for single characters, and strings for text. You will also learn about V's rich set of built-in methods on these types.

Boolean Type

Logical Operators

Logical Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Logical Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of logical operators.

module main

fn main() {
	t := true
	f := false

	// Logical And using && operator
	and_tt := t && t
	and_tf := t && f
	and_ft := f && t
	and_ff := f && f

	println('Logical And using && operator')
	println('${t} && ${t} = ${and_tt}')
	println('${t} && ${f} = ${and_tf}')
	println('${f} && ${t} = ${and_ft}')
	println('${f} && ${f} = ${and_ff}')
	println('')

	// Logical OR using || operator
	or_tt := t || t
	or_tf := t || f
	or_ft := f || t
	or_ff := f || f

	println('Logical OR using || Operator')
	println('${t} || ${t} = ${or_tt}')
	println('${t} || ${f} = ${or_tf}')
	println('${f} || ${t} = ${or_ft}')
	println('${f} || ${f} = ${or_ff}')
	println('')

	// Logical not using ! Operator
	not_t := !t
	not_f := !f

	println('Logical not using ! Operator')
	println('!${t} = ${not_t}')
	println('!${f} = ${not_f}')
}

Relational Operators

Relational Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Relational Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of relational operators.

module main

struct Note {
	id        int
	detail    string
	completed bool
}

fn main() {
	mut n := Note{
		id:     1001
		detail: 'get groceries'
	}
	println(n.completed) // un-assigned bool field will be false by default

	// Comparing using Relational operator >
	if n.id > 1000 { // comparison of note id of integer type to another integer evaluates to a boolean
		println('The note id is greater than 1000')
	} else {
		println('The note id is less than 1000')
	}

	// Comparing using Relational operator ==
	if n.detail == 'get groceries' {
		println('The note details about groceries')
	}

	// Comparing using Relational operator !=
	if n.detail != 'get dairy products' {
		println('The note does not details about dairy products')
	}
}

Boolean Methods

Boolean Methods

Booleans in V are simple true or false values. V provides built-in methods on boolean types, such as str(), which converts the boolean value to its string representation ('true' or 'false').

This is useful for logging, printing, or interpolating booleans into strings.

Additional Context from Repository docs:

This example demonstrates the concepts of boolean methods.

module main

fn main() {
	t := true
	f := false

	// str() returns string representation ('true' or 'false')
	println(t.str()) // true
	println(f.str()) // false
}

Numeric Types

Declaring Integers

Declaring Integers

V has several built-in integer types, both signed and unsigned, of various sizes (e.g., i8, i16, i32, i64 for signed integers, and u8, u16, u32, u64 for unsigned integers). If you declare an integer using :=, V defaults to the standard 32-bit integer (int).

This example demonstrates how to declare different integer types.

Additional Context from Repository docs:

This example demonstrates the concepts of declaring integers.

module main

fn main() {
	x := 1
	println(typeof(x).name)
	// int

	i := 1_000
	j := 1000

	println(i == j) // true
}

Hex Binary Octa Notation Of Declaring Integers

Hex Binary Octa Notation Of Declaring Integers

V has several built-in integer types, both signed and unsigned, of various sizes (e.g., i8, i16, i32, i64 for signed integers, and u8, u16, u32, u64 for unsigned integers). If you declare an integer using :=, V defaults to the standard 32-bit integer (int).

This example demonstrates how to declare different integer types.

Additional Context from Repository docs:

This example demonstrates the concepts of hex binary octa notation of declaring integers.

module main

fn demo() {
	h1 := 0x64 // hexadecimal starts with 0x
	b1 := 0b1100100 // binary starts with 0b
	o1 := 0o144 // Octal starts with 0o
	println('Value of var h1 with hexadecimal value : ${h1}')
	println('Data type of var h1 with hexadecimal value : ${typeof(h1).name}')
	println('Value of var b1 with binary value : ${b1}')
	println('Data type of var b1 with binary value : ${typeof(b1).name}')
	println('Value of var o1 with octal value : ${o1}')
	println('Data type of var o1 with octal value : ${typeof(o1).name}')
}

fn main() {
	demo()
}

Promoting Numeric Types

Promoting Numeric Types

V is very strict about types. It does not perform implicit type conversion (coercion) between different numeric types to prevent accidental precision loss or overflow bugs. If you want to perform arithmetic operations on different types, you must explicitly cast them.

This example shows how to cast (promote) smaller integer types to larger ones or to floats.

Additional Context from Repository docs:

This example demonstrates the concepts of promoting numeric types.

module main

fn demo() {
	ia := i8(2)
	ib := i16(2)
	ic := int(2)

	println('----type definitions----')
	println('variable ia is of type: ${typeof(ia).name}')
	println('variable ib is of type: ${typeof(ib).name}')
	println('variable ic is of type: ${typeof(ic).name}')
	println('')
	iaa := ia + ia // i8 with i8 results i8
	ibb := ib + ib // i16 with i16 results i16
	icc := ic + ic // int with int results int
	println('----mixing types----')
	println('variable iaa is of type: ${typeof(iaa).name}, after adding type ${typeof(ia).name} with itself')
	println('variable ibb is of type: ${typeof(ibb).name}, after adding type ${typeof(ib).name} with itself')
	println('variable icc is of type: ${typeof(icc).name}, after adding type ${typeof(ic).name} with itself')
	println('')
	iab := ia + ib // i8 with i16 results in i16
	ibc := ib - ic // i16 with i32 results in i32
	println('----type promotion----')
	println('variable iab is promoted to type: ${typeof(iab).name}, after adding type ${typeof(ia).name} with ${typeof(ib).name}')
	println('variable ibc is promoted to type: ${typeof(ibc).name}, after subtracting type ${typeof(ib).name} with ${typeof(ic).name}')

	iba := ib / ia // the division of i16 and i8 types
	println('Variable iba is promoted to the higher data type ${typeof(iba).name} which is carried from ib of type ${typeof(ib).name} divided from variable ia of type ${typeof(ia).name}')

	fa := f32(2)

	fa_iba := fa + iba // fa is type of f32 and iba is of type i32
	println('Variable fa_iba is promoted to the higher data type ${typeof(fa_iba).name} which is carried from fa of type ${typeof(fa).name} when added with variable iba of type ${typeof(iba).name}')
}

fn main() {
	demo()
}

Arithmetic Operators

Arithmetic Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Arithmetic Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of arithmetic operators.

module main

fn main() {
	price := 120
	tax_rate := 8
	tax := price * tax_rate / 100
	total := price + tax

	println('Subtotal: ${price}')
	println('Tax: ${tax}')
	println('Total: ${total}')
}

Bitwise Operators

Bitwise Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Bitwise Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of bitwise operators.

module main

fn main() {
	a := 0b00000110 // 6
	b := 0b00000010 // 2

	// bitwise AND operation of two binary nums using & operator
	b_and := a & b

	// bitwise OR operation of two binary nums using | operator
	b_or := a | b

	// bitwise XOR operation of two binary nums using ^ operator
	b_xor := a ^ b

	// bitwise NOT operation of an binary nums using ~ operator
	not_a := ~a // Not operation yields value which is equal to -(a+1) in its integer form
	println('Bitwise AND: ${a:08b} & ${b:08b} = ${b_and:08b}')
	println('Bitwise OR: ${a:08b} | ${b:08b} = ${b_or:08b}')
	println('Bitwise XOR: ${a:08b} ^ ${b:08b} = ${b_xor:08b}')
	println('Bitwise NOT: ~${a:b} = ${not_a:b}')
}

Shift Operators

Shift Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Shift Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of shift operators.

module main

fn main() {
	// declare 8 bit integer with value 3
	a := i8(3)

	// 8 bits equals to 1 byte
	println('a is ${sizeof(a)} byte(s)') // a is 1 byte(s)

	// declare 8-bit unsigned integer to shift by 1 position
	pos := byte(1)

	// Shift left the value 3 by 1 position
	a_left_shift := a << pos
	println('${a} << ${pos} = ${a_left_shift}')
}

Shift Operator On Range Of Integers

Shift Operator On Range Of Integers

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Shift Operator On Range Of Integers in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of shift operator on range of integers.

module main

fn main() {
	val := i8(1)

	bits := sizeof(val) * 8

	println('Performing left shift using << Operator')

	for i in 0 .. bits {
		after_shift := val << i
		println('$val << $i = $after_shift \/\/ type after shift operation: ${typeof(after_shift).name}')
	}
}

Integer Methods

Integer Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Integer Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of integer methods.

module main

fn main() {
	x := 42

	// str() returns string representation of the integer
	println(x.str()) // "42"

	// hex() returns hexadecimal representation without prefix
	println(x.hex()) // "2a"

	// hex2() returns hexadecimal representation with "0x" prefix
	println(x.hex2()) // "0x2a"

	// hex_full() returns hexadecimal representation with full width padding for the type (8 digits for 32-bit int)
	println(x.hex_full()) // "0000002a"
}

Float Methods

Float Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Float Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of float methods.

module main

fn main() {
	f := 12345.6789

	// str() returns string representation of the float
	println(f.str()) // "12345.6789"

	// strg() returns string representation (often identical to str())
	println(f.strg()) // "12345.6789"

	// strlong() returns a full/long string representation of the float
	println(f.strlong()) // "12345.6789"

	// strsci(precision) returns scientific notation with specified precision/decimal places
	println(f.strsci(4)) // "1.2346e+04"

	// eq_epsilon(other) performs a comparison using machine epsilon (for near-equality)
	f2 := 12345.678900000001
	println(f.eq_epsilon(f2)) // true
}

U8 Methods

U8 Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use U8 Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of u8 methods.

module main

fn main() {
	b := u8(65) // ASCII code for 'A'

	// str() returns string representation of the numeric value
	println(b.str()) // "65"

	// ascii_str() returns string of length 1 containing the character
	println(b.ascii_str()) // "A"

	// hex() returns hexadecimal representation
	println(b.hex()) // "41"

	// hex_full() returns hexadecimal representation (same as hex() for u8)
	println(b.hex_full()) // "41"

	// is_alnum() checks if the character is alphanumeric
	println(b.is_alnum()) // true

	// is_bin_digit() checks if the character is a binary digit ('0' or '1')
	println(b.is_bin_digit()) // false

	// is_capital() checks if the character is an uppercase letter
	println(b.is_capital()) // true

	// is_digit() checks if the character is a decimal digit ('0'-'9')
	println(b.is_digit()) // false

	// is_hex_digit() checks if the character is a hexadecimal digit ('0'-'9', 'a'-'f', 'A'-'F')
	println(b.is_hex_digit()) // true

	// is_letter() checks if the character is an alphabetic letter
	println(b.is_letter()) // true

	// is_oct_digit() checks if the character is an octal digit ('0'-'7')
	println(b.is_oct_digit()) // false

	// is_space() checks if the character is a whitespace character
	println(b.is_space()) // false

	// repeat(count) repeats the character count times and returns a string
	println(b.repeat(3)) // "AAA"

	// str_escaped() returns an escaped string representation of the character
	println(b.str_escaped()) // "A"
}

Size Pointer Methods

Size Pointer Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Size Pointer Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of size and pointer methods.

module main

fn main() {
	// isize and usize methods
	sz := isize(100)
	usz := usize(200)

	// str() returns string representation
	println(sz.str())  // "100"
	println(usz.str()) // "200"

	// voidptr methods
	x := 42
	p := voidptr(&x)

	// str() returns the memory address as string
	println(p.str().starts_with('0x')) // true

	// hex_full() returns full-width hex representation of address
	println(p.hex_full().len > 0) // true

	// vbytes(len) returns a byte array representation of the memory pointed to (must be called in unsafe block)
	unsafe {
		bytes := p.vbytes(int(sizeof(int)))
		println(bytes) // [42, 0, 0, 0]
	}
}

Rune Type

Declare Rune

Declare Rune

A rune in V represents a single Unicode code point. Runes are declared using backticks (e.g., \a\, \🔥\) and are represented internally as 32-bit unsigned integers (u32). This allows V to support multi-byte Unicode characters (like emojis or Chinese characters) as single character tokens.

This example shows how to declare and print runes.

Additional Context from Repository docs:

This example demonstrates the concepts of declare rune.

fn main() {
	initial := `A`
	symbol := `🔥`

	println(typeof(initial).name)
	println(typeof(symbol).name)
	println('Initial: ${initial.str()}')
	println('Symbol: ${symbol.str()}')
}

Rune Operations With Strings

Rune Operations With Strings

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Rune Operations With Strings in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of rune operations with strings.

fn main() {
	beverage := 'café'
	s := `é`
	// declare rune
	println(beverage.count(s.str()))
	// 1
}

Rune Methods

Rune Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Rune Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of rune methods.

module main

fn main() {
	r := `A`

	// bytes() returns the byte representation (UTF-8 bytes) of the rune
	println(r.bytes()) // [65]

	// hex() returns the hexadecimal representation of the rune code point
	println(r.hex()) // "41"

	// length_in_bytes() returns the size of the rune in bytes (1 to 4)
	println(r.length_in_bytes()) // 1

	// repeat(count) returns a string with the rune repeated count times
	println(r.repeat(3)) // "AAA"

	// str() returns the string representation of the rune
	println(r.str()) // "A"

	// to_lower() returns the lowercase rune
	println(r.to_lower().str()) // "a"

	// to_upper() returns the uppercase rune
	println(r.to_upper().str()) // "A"

	// to_title() returns the titlecase rune
	println(r.to_title().str()) // "A"

	// Testing with a multi-byte UTF-8 rune (dog emoji 🐕)
	r2 := `🐕`
	println(r2.bytes())           // [240, 159, 144, 149]
	println(r2.hex())             // "1f415" (Unicode code point in hex)
	println(r2.length_in_bytes()) // 4
	println(r2.repeat(2))         // "🐕🐕"
	println(r2.str())             // "🐕"
}

String Type

Declare String

Declare String

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Declare String in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of declare string.

fn main() {
	greeting := 'hello'
	name := 'Ada'
	message := greeting + ', ' + name + '!'

	println(message)
	println(message.len)
	println(typeof(message).name)
}

String Read Only Array Of Bytes

String Read Only Array Of Bytes

In V, a string is internally represented as a read-only array of bytes (u8). This means you can access individual bytes of a string using array indexing (str[index]), but you cannot change them.

This example shows how to read bytes from a string and print their values.

Additional Context from Repository docs:

This example demonstrates the concepts of string read only array of bytes.

fn main() {
	fruit := 'Orange'
	println(typeof(fruit[0]).name)
	// byte
	println(fruit[0])
	// 79
}

Strings Immutable By Default

Strings Immutable By Default

Strings in V are completely immutable. Once a string is created, its characters cannot be modified in place. Any operation that manipulates a string (such as replacing characters or converting to uppercase) returns a brand new string instead of modifying the original.

This example demonstrates that strings are read-only and cannot be changed.

Additional Context from Repository docs:

This example demonstrates the concepts of strings immutable by default.

fn main() {
	s := 'hello'
	// variable s is immutable
	s = 'Hello!'
	// this results in error
}

Declaring Mutable Strings

Declaring Mutable Strings

While strings are immutable, you can declare a mutable string variable using mut. This allows the variable to be reassigned to a new string value, or appended to using the += operator.

This example shows how to declare a mutable string and append text to it.

Additional Context from Repository docs:

This example demonstrates the concepts of declaring mutable strings.

fn main() {
	mut msg := 'Hello Friend!'
	msg = 'Hope you are doing good.'
	println(msg)
	// Hope you are doing good.
	msg = msg + ' There is a surprise for you.'
	println(msg)
	// Hope you are doing good. There is a surprise for you.
}

Cannot Mutate String Elements

Cannot Mutate String Elements

Even if a string variable is declared with mut, you cannot mutate its individual characters or bytes directly via index assignment (e.g., s[0] = \a\``). The compiler will throw an error to protect string integrity.

This program shows that element mutation is strictly forbidden.

Additional Context from Repository docs:

This example demonstrates the concepts of cannot mutate string elements.

fn main() {
	mut greet := 'good Day'

	greet[0] = 'G' // this results in error
}

String Interpolation

String Interpolation

String interpolation is a clean way to insert variables or expressions inside a string literal. In V, you do this by wrapping the variable or expression in ${variable} inside a single-quoted string.

This example demonstrates how to format strings with variable values.

Additional Context from Repository docs:

This example demonstrates the concepts of string interpolation.

fn main() {
	a := 'coding'
	b := 'fun'
	println('${a} is ${b}')
	println('${a} is ${b}')
}

Escape Special Characters

Escape Special Characters

V strings support standard escape characters (like \n for newlines, \t for tabs, and \\ for backslashes) to represent special characters inside a string literal.

This example shows how these escape sequences are rendered in the console.

Additional Context from Repository docs:

This example demonstrates the concepts of escape special characters.

module main

fn main() {
	// 1. Newline escape character (\n)
	println('Hello\nWorld!')

	// 2. Tab escape character (\t)
	println('Name:\tAlice\tAge:\t25')

	// 3. Backslash escape character (\\)
	println('File path: C:\\Program Files\\V')

	// 4. Escaping single quotes (\') in a single-quoted string
	println('It\'s my Daughter\'s birthday!')

	// 5. Escaping double quotes (\") in a double-quoted string
	println("She said, \"V is fast!\"")
}

Declare Raw Strings

Declare Raw Strings

If you want to write a string literal where escape sequences (like \n) are treated as literal text instead of special commands, you can declare a raw string by prefixing the string literal with r (e.g., r\'hello\nworld\').

This is extremely useful when writing regular expressions or file paths.

Additional Context from Repository docs:

This example demonstrates the concepts of declare raw strings.

module main

fn main() {
	i := r'hi \how are you/?'
	println(i)
}

String Concatenation Using Plus Sign

String Concatenation Using Plus Sign

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String Concatenation Using Plus Sign in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of string concatenation using plus sign.

module main

fn main() {
	a := 'con'
	b := 'cat'
	println(a + b)
	// concat
}

String Concatenation Using Interpolation

String Concatenation Using Interpolation

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String Concatenation Using Interpolation in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of string concatenation using interpolation.

module main

fn main() {
	i := 1
	j := 'man army'
	println('${i} ${j}')
}

Extract Substring From String Literal

Extract Substring From String Literal

V provides two main techniques to extract substrings from a string literal or variable:

1. The .substr(start, end) Method: Takes the starting index (inclusive) and ending index (exclusive) as parameters.
2. Range Slicing Syntax [start..end]: A clean and idiomatic syntax (similar to Go and Rust) where you specify range offsets. If the starting index is omitted (e.g. [..end]), it defaults to 0. If the ending index is omitted (e.g. [start..]), it defaults to the length of the string.

Both techniques are demonstrated in the example below.

Additional Context from Repository docs:

This example demonstrates the concepts of extract substring from string literal.

module main

fn main() {
	a := 'Camel'

	// Method 1: Using the substr(start, end) method
	// Extracts characters from index 0 up to (but not including) index 3
	b := a.substr(0, 3)
	println(b) // Output: Cam

	// Method 2: Using idiomatic range slicing syntax [start..end] (similar to Go/Rust)
	// Slices from index 1 up to (but not including) index 4
	c := a[1..4]
	println(c) // Output: ame

	// Method 3: Slicing from start to index [..end]
	// If the start index is omitted, it defaults to 0
	d := a[..3]
	println(d) // Output: Cam

	// Method 4: Slicing from index to end [start..]
	// If the end index is omitted, it defaults to the string length
	e := a[2..]
	println(e) // Output: mel
}

Split String

Split String

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Split String in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of split string.

module main

fn main() {
	sp := 'The tiny tiger tied the tie tighter to its tail'
	res := sp.split(' ')
	// split by space as delimiter
	println(typeof(res).name)
	// []string
	println(res)
	// ['The', 'tiny', 'tiger', 'tied', 'the', 'tie', 'tighter', 'to', 'its', 'tail']
}

String To Runes Array

String To Runes Array

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String To Runes Array in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of string to runes array.

module main

fn main() {
	doge_moon := '🐕+🚀=🌑'
	doge_moon_runes := doge_moon.runes()
	println(doge_moon_runes)
	println(typeof(doge_moon_runes).name) // []rune
}

Count Sub String Occurences

Count Sub String Occurences

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Count Sub String Occurences in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of count sub string occurences.

module main

fn main() {
	sp := 'The tiny tiger tied the tie tighter to its tail'
	println(sp.count('t'))
	// 10
	println(sp.count('T'))
	// 1
	println(sp.count('tie'))
	// 2
	println(sp.count('-'))
	// 0
}

Check String Contains Substring

Check String Contains Substring

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Check String Contains Substring in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of check string contains substring.

module main

fn main() {
	hs := 'monday'

	if hs.contains('mon') {
		println('${hs} contains mon')
	} else {
		println('${hs} does not contains mon')
	}
}

String Contains Is Case Sensitive

String Contains Is Case Sensitive

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String Contains Is Case Sensitive in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of string contains is case sensitive.

module main

fn main() {
	hs := 'Monday'

	if hs.contains('mon') {
		println('${hs} contains mon')
	} else {
		println('${hs} does not contains mon')
	}
}

Common String Methods

Common String Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Common String Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

Additional Context from Repository docs:

This example demonstrates the concepts of common string methods.

module main

fn main() {
	s := '  Hello, V!  '

	// to_lower() returns the lowercase version of the string
	println(s.to_lower()) // "  hello, v!  "

	// to_upper() returns the uppercase version of the string
	println(s.to_upper()) // "  HELLO, V!  "

	// trim_space() trims leading and trailing whitespaces
	println(s.trim_space()) // "Hello, V!"

	// trim(cutset) trims leading and trailing characters that match any character in the cutset
	println(s.trim(' ')) // "Hello, V!"

	// replace(old, new) replaces all occurrences of old with new
	println(s.replace('V', 'World')) // "  Hello, World!  "

	// replace_once(old, new) replaces the first occurrence of old with new
	println(s.replace_once('l', 'x')) // "  Hexlo, V!  "

	// index(sub) returns the start index of the first occurrence of sub as an optional ?int
	idx := s.index('Hello') or { -1 }
	println(idx) // 2

	// last_index(sub) returns the start index of the last occurrence of sub as an optional ?int
	last_idx := s.last_index('l') or { -1 }
	println(last_idx) // 5

	// starts_with(prefix) checks if the string starts with the prefix
	println(s.starts_with('  ')) // true

	// ends_with(suffix) checks if the string ends with the suffix
	println(s.ends_with('!')) // false (ends with spaces)

	// is_pure_ascii() checks if all characters in the string are pure ASCII
	println(s.is_pure_ascii()) // true

	// split_into_lines() splits a string into an array of lines
	multiline := "line 1\nline 2"
	println(multiline.split_into_lines()) // ["line 1", "line 2"]

	// split_by_space() splits a string by space as delimiter
	println(s.split_by_space()) // ["Hello,", "V!"]
}

Chapter 4 Control Flow

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Control Flow Extras

• Chaining Else If
• If With Goto
• Cascade Match Conditions
• Match As Switch Case
• Match Pattern Matching
• Match With Enum
• Match With Enum And Else
• Bare For
• Break For
• Continue For
• For C Style
• For On Array Without Index
• For On Arrays
• For On Maps
• For On Maps Ignore Key
• For On Range
• For With Continue Break And Labels
• Reverse For

Control flow determines the execution path of your code. In this chapter, we cover conditionals (if-else), pattern matching (match), and the versatile for loop. V simplifies control flow by using fewer keywords, making code highly readable.

Control Flow Extras

Chaining Else If

Chaining Else If

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Chaining Else If in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of chaining else if.

module main

fn breakfast_menu(day string) {
	if day == 'Monday' {
		println('Bread, Jam, Half boiled Egg')
	} else if day == 'Tuesday' {
		println('Bread, Jam, Juice')
	} else if day == 'Wednesday' {
		println('Milk, Bread, Fruit Bowl')
	} else if day == 'Thursday' {
		println('Bread, Jam, Juice')
	} else if day == 'Friday' {
		println('Cereals, Bread, Jam, Half boiled Egg')
	} else if day == 'Saturday' {
		println('Milk, Bread, Fruit Bowl')
	} else if day == 'Sunday' {
		println('Cereals, Bread, Jam, Half boiled Egg')
	} else {
		println('invalid input')
	}
}

fn main() {
	breakfast_menu('Saturday')
}

If With Goto

If With Goto

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of If With Goto in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of if with goto.

module main

import os

fn main() {
	improper_input_age:
	println('Invalid input. Please provide value greater than 0.')

	next_person:
	inp := os.input('Enter your age:')

	if inp != 'stop' {
		age := inp.int()

		if age >= 13 {
			println('You are allowed to watch this movie')
		} else if age > 0 && age < 13 {
			println('Parental Guidance is required to watch this movie')
		} else if age <= 0 {
			unsafe {
				goto improper_input_age
			}
		}
		unsafe {
			goto next_person
		}
	}
}

Cascade Match Conditions

Cascade Match Conditions

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Cascade Match Conditions in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of cascade match conditions.

module main

fn breakfast_menu(day string) string {
	return match day {
		'Monday' {
			'Bread, Jam, Half boiled Egg'
		}
		'Tuesday', 'Thursday' {
			'Bread, Jam, Juice'
		}
		'Wednesday' {
			'Milk, Bread, Fruit Bowl'
		}
		'Friday', 'Sunday' {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		'Saturday' {
			'Milk, Bread, Fruit Bowl'
		}
		else {
			'invalid input'
		}
	}
}

fn main() {
	friday_menu := breakfast_menu('Friday')
	println(friday_menu)

	sunday_menu := breakfast_menu('Sunday')
	println(sunday_menu)

	tuesday_menu := breakfast_menu('Tuesday')
	println(tuesday_menu)

	thursday_menu := breakfast_menu('Thursday')
	println(thursday_menu)
}

Match As Switch Case

Match As Switch Case

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match As Switch Case in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of match as switch case.

module main

fn breakfast_menu(day string) {
	match day {
		'Monday' { println('Bread, Jam, Half boiled Egg') }
		'Tuesday' { println('Bread, Jam, Juice') }
		'Wednesday' { println('Milk, Bread, Fruit Bowl') }
		'Thursday' { println('Bread, Jam, Juice') }
		'Friday' { println('Cereals, Bread, Jam, Half boiled Egg') }
		'Saturday' { println('Milk, Bread, Fruit Bowl') }
		'Sunday' { println('Cereals, Bread, Jam, Half boiled Egg') }
		else { println('invalid input') }
	}
}

fn main() {
	breakfast_menu('Sunday')
}

Match Pattern Matching

Match Pattern Matching

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match Pattern Matching in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of match pattern matching.

module main

fn main() {
	age := 18
	res := match age {
		0...18 { 'Person with age $age classified as a Child' }
		19...120 { 'Person with age $age classified as an Adult' }
		else { '$age is must be in the range 0 to 120' }
	}
	println(res)
}

Match With Enum

Match With Enum

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match With Enum in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of match with enum.

module main

enum Day {
	sunday
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
}

fn breakfast_menu(day Day) string {
	return match day {
		.monday {
			'Bread, Jam, Half boiled Egg'
		}
		.tuesday, .thursday {
			'Bread, Jam, Juice'
		}
		.wednesday {
			'Milk, Bread, Fruit Bowl'
		}
		.friday, .sunday {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		.saturday {
			'Milk, Bread, Fruit Bowl'
		}
	}
}

fn main() {
	friday_menu := breakfast_menu(Day.friday)
	println(friday_menu)

	sunday_menu := breakfast_menu(Day.sunday)
	println(sunday_menu)

	tuesday_menu := breakfast_menu(Day.tuesday)
	println(tuesday_menu)

	thursday_menu := breakfast_menu(Day.thursday)
	println(thursday_menu)
}

Match With Enum And Else

Match With Enum And Else

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match With Enum And Else in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of match with enum and else.

module main

enum Day {
	sunday
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
}

fn weekend_breakfast_menu(day Day) string {
	return match day {
		.sunday {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		.saturday {
			'Milk, Bread, Fruit Bowl'
		}
		else {
			'Sorry, we are closed on weekdays!'
		}
	}
}

fn main() {
	sunday_menu := weekend_breakfast_menu(Day.sunday)
	println(sunday_menu)

	tuesday_menu := weekend_breakfast_menu(Day.tuesday)
	println(tuesday_menu)
}

Bare For

Bare For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Bare For in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of bare for.

module main

fn main() {
	mut count := 1
	for {
		println('Hi $count times')
		count += 1
	}
}

Break For

Break For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Break For in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of break for.

module main

import os

fn main() {
	mut count := 0
	input := os.input('Enter number of times to Greet:')
	limit := input.int()
	for {
		if count >= limit {
			break
		}
		println('Hi')
		count += 1
	}
	println('Greeted Hi $count times')
}

Continue For

Continue For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Continue For in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of continue for.

module main

fn main() {
	for i in 0 .. 10 {
		if i % 2 == 0 { // skips printing number that is a multiple of 2
			continue
		}
		println(i)
	}
}

For C Style

For C Style

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For C Style in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for c style.

module main

fn main() {
	sample := [3, 4, 23, 12, 4, 1, 45, 12, 42, 17, 92, 38]
	for i := 0; i < sample.len; i += 3 {
		println(sample[i])
	}
}

For On Array Without Index

For On Array Without Index

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Array Without Index in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for on array without index.

module main

fn main() {
	col := [1, 2, 3, 4, 5, 6, 7]
	for val in col {
		if val % 2 == 0 {
			println('$val is Even')
		} else {
			println('$val is Odd')
		}
	}
}

For On Arrays

For On Arrays

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Arrays in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for on arrays.

module main

fn main() {
	fruits := ['apple', 'banana', 'coconut']
	for idx, ele in fruits {
		println('idx: $idx \t fruit: $ele')
	}
}

For On Maps

For On Maps

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Maps in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for on maps.

module main

fn main() {
	lottery := {
		'First':       1000
		'Second':      700
		'Consolation': 200
	}

	for k, v in lottery {
		println('$k prize lottery amount: $v')
	}
}

For On Maps Ignore Key

For On Maps Ignore Key

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Maps Ignore Key in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for on maps ignore key.

module main

fn main() {
	basket := {
		'apples':  10
		'bananas': 12
	}

	mut total := 0
	for _, v in basket {
		total += v
	}
	println('Total number of fruits: $total')
}

For On Range

For On Range

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Range in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for on range.

module main

fn main() {
	for val in 0 .. 4 {
		println(val)
	}
}

For With Continue Break And Labels

For With Continue Break And Labels

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For With Continue Break And Labels in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of for with continue break and labels.

module main

import os

fn main() {
	input := os.input('Enter the number of multiplication tables to print:')
	limit := input.int()
	if limit <= 0 {
		return
	}
	first_loop: for i := 1; i <= 10; i++ {
		println('Printing multiplication table for $i')
		for j := 1; j <= 10; j++ {
			mul := i * j
			println('$i * $j = $mul')
			if mul >= limit * 10 {
				break first_loop
			}
		}
		println('*********')
	}
}

Reverse For

Reverse For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Reverse For in V, showing how to control execution paths cleanly and safely.

Additional Context from Repository docs:

This example demonstrates the concepts of reverse for.

module main

fn main() {
	subjects := ['zoology', 'chemistry', 'physics', 'algebra']

	for i := subjects.len - 1; i >= 0; i-- {
		println(subjects[i])
	}
}

Chapter 5 Collections: Arrays and Maps

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Arrays

• Declare And Initialize
• Declare Empty Array
• Declare Array With Len
• Declare Array With Init And Len
• Declare Array With Cap
• Working With Array Properties
• Access Array Elements Using Index
• Access Array Elements Using Slices
• In Operator With Array
• Append Array
• Define Fixed Size Array
• Update Fixed Size Array Elements
• Determining Type Of Fixed Array
• Slicing Fixed Size Array Results In Ordinary Array
• Declaring Multi Dimensional Arrays
• Updating Multi Dimensional Array Indices
• Reassigning Multi Dimensional Arrays
• Clone Array
• Copy Array
• Sort Integer Array
• Sort String Array
• Sort Struct Array
• Filter Array
• Filter With Anonymous Funcs On Array
• Map Array Items
• Map Using Anonymous Funcs On Array
• Array Methods

Maps

• Explicit Map Initialization
• Short Syntax Initialization Of Map
• Count Key Value Pairs In Map
• Value Given Key Of Map
• Value Given Non Existent Key Of Map
• Handling Missing Keys In Map
• Update Value Given A Key In Map
• Delete Key Value Pair From Map
• Map Methods

Collections allow you to group multiple data items together. V provides two primary built-in collection types: arrays (ordered lists of elements) and maps (key-value dictionaries). This chapter covers creating, accessing, and manipulating these collections using modern functional patterns like map and filter.

Arrays

Declare And Initialize

Declare And Initialize

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declare and initialize.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	println(sports)
}

Declare Empty Array

Declare Empty Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declare empty array.

fn main() {
	mut animals := []string{}
	println(animals)
	// prints empty array: []
	animals << 'Chimpanzee'
	animals << 'Dog'
	println(animals)
	// ['Chimpanzee', 'Dog']
}

Declare Array With Len

Declare Array With Len

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declare array with len.

fn main() {
	mut i := []int{len: 3}
	println(i)
}

Declare Array With Init And Len

Declare Array With Init And Len

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declare array with init and len.

fn main() {
	mut j := []int{len: 3, init: 1}
	println(j)
}

Declare Array With Cap

Declare Array With Cap

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declare array with cap.

fn main() {
	mut k := []int{cap: 2}
	println(k)
}

Working With Array Properties

Working With Array Properties

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of working with array properties.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	println(sports.len)
	// Length of sports array
	println(sports.cap)
	// Capacity of sports array
	println('----Deleting football----')
	sports.delete(2)
	// deleting football
	println('Length of sports array: ${sports.len}')
	println('Capacity of sports array: ${sports.cap}')

	println('----Adding volleyball and baseball----')

	sports << ['volleyball', 'baseball']
	println(sports)
	println('Length of sports array: ${sports.len}')
	println('Capacity of sports array: ${sports.cap}')
}

Access Array Elements Using Index

Access Array Elements Using Index

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of access array elements using index.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	s := sports[1]
	println(s) // hockey
}

Access Array Elements Using Slices

Access Array Elements Using Slices

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of access array elements using slices.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	println(sports[1..3])
}

In Operator With Array

In Operator With Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of in operator with array.

fn main() {
	odd := [1, 3, 5, 7]

	println(3 in odd)
	// prints: true
	println(8 !in odd)
	// prints: true
}

Append Array

Append Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of append array.

fn main() {
	mut even := [2, 4, 6]
	even << 8
	println(even)
	// prints [2, 4, 6, 8]
	even << [10, 12, 14]
	println(even)
	// prints: [2, 4, 6, 8, 10, 12, 14]
}

Define Fixed Size Array

Define Fixed Size Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of define fixed size array.

fn main() {
	mut fix := [4]int{}
	println(fix)
	// [0, 0, 0, 0]
}

Update Fixed Size Array Elements

Update Fixed Size Array Elements

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of update fixed size array elements.

fn main() {
	mut fix := [4]int{}
	fix[1] = 33
	println(fix)
	//[0, 33, 0, 0]
}

Determining Type Of Fixed Array

Determining Type Of Fixed Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of determining type of fixed array.

fn main() {
	mut fix := [4]int{}
	println(typeof(fix).name) // [4]int
}

Slicing Fixed Size Array Results In Ordinary Array

Slicing Fixed Size Array Results In Ordinary Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of slicing fixed size array results in ordinary array.

fn main() {
	mut fix := [4]int{}
	fix[1] = 33
	s := fix[1..]
	println(s)
	// [33, 0, 0]
	println(typeof(s).name) // prints: []int
}

Declaring Multi Dimensional Arrays

Declaring Multi Dimensional Arrays

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of declaring multi dimensional arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(typeof(coordinates_2d).name)
	// [][]int
	println(coordinates_2d)
	// [[0, 0], [0, 0], [0, 0], [0, 0]]
}

Updating Multi Dimensional Array Indices

Updating Multi Dimensional Array Indices

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of updating multi dimensional arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(coordinates_2d.len)

	point_1 := [0, 0]
	point_2 := [0, 1]
	point_3 := [1, 0]
	point_4 := [1, 1]

	coordinates_2d[0] = point_1
	coordinates_2d[1] = point_2
	coordinates_2d[2] = point_3
	coordinates_2d[3] = point_4
	println(coordinates_2d)
}

Reassigning Multi Dimensional Arrays

Reassigning Multi Dimensional Arrays

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of updating multi dimensional arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(coordinates_2d.len)
	coordinates_2d = [
		[0, 0],
		[0, 1],
		[1, 0],
		[1, 1],
	]
	println(coordinates_2d)
}

Clone Array

Clone Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of clone array.

fn main() {
	r := [1, 2, 3, 4]
	mut u := r.clone()
	// copies the array r to u
	println(u)
}

Copy Array

Copy Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of copy array.

fn main() {
	r := [1, 2, 3, 4]
	s := unsafe { r }
	println(s)
	unsafe {
		r.free()
	}
}

Sort Integer Array

Sort Integer Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of sort integer array.

fn main() {
	mut i := [3, 2, 8, 1]
	i.sort()
	// ascending order
	println(i)
	i.sort(a > b)
	// descending order
	println(i)
}

Sort String Array

Sort String Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of sort string array.

fn main() {
	mut fruits := ['Apples', 'avocado', 'banana', 'Orange']

	fruits.sort()
	// ascending order
	println(fruits)
	fruits.sort(a > b)
	// reverse order
	println(fruits)
}

Sort Struct Array

Sort Struct Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of sort struct array.

module main

struct Student {
	id    int
	name  string
	class int
}

fn main() {
	// Declare an empty array
	mut students := []Student{}

	// Create students
	st1 := Student{
		id:    1
		name:  'Ram'
		class: 9
	}
	st2 := Student{
		id:    2
		name:  'Katy'
		class: 3
	}
	st3 := Student{
		id:    3
		name:  'Tom'
		class: 6
	}

	// Append all the students to the array
	students << [st1, st2, st3]
	println(students)

	// Reverse Sort students by id
	students.sort(a.id > b.id)

	println('Students sorted in reverse order of id:')
	println(students)

	// Sort students by class in ascending order
	students.sort(a.class < b.class)

	println('Students sorted in ascending order of class:')
	println(students)

	// Sort students by name in reverse order
	students.sort(a.name > b.name)

	println('Students sorted in reverse order of name:')
	println(students)
}

Filter Array

Filter Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of filter array.

fn main() {
	f := [1, 2, 3, 4, 5, 6, 7, 8, 9]
	multiples_of_3 := f.filter(it % 3 == 0)
	println(multiples_of_3)
	// [3, 6, 9]
}

Filter With Anonymous Funcs On Array

Filter With Anonymous Funcs On Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of filter with anonymous funcs on array.

fn main() {
	fruits := ['apple', 'mango', 'water melon', 'musk melon']

	fruits_starting_m := fruits.filter(fn (f string) bool {
		return f.starts_with('m')
	})

	println(fruits_starting_m)
}

Map Array Items

Map Array Items

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of map array items.

fn main() {
	visitor := ['Tom', 'Ram', 'Rao']
	res := visitor.map('Mr. ' + it)
	println(res)
}

Map Using Anonymous Funcs On Array

Map Using Anonymous Funcs On Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of map using anonymous funcs on array.

fn main() {
	colors := ['red', 'blue', 'green', 'white', 'black']

	colors_with_letter_e := colors.map(fn (c string) int {
		if c.contains('e') { return 1 } else { return 0 }
	})

	println(colors_with_letter_e)
}

Array Methods

Array Methods

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

Additional Context from Repository docs:

This example demonstrates the concepts of array methods.

module main

// A custom comparison function for sorting.
// It accepts references to elements (e.g. &int) and returns -1, 1, or 0.
fn compare_ints(a &int, b &int) int {
	val_a := *a
	val_b := *b
	if val_a < val_b { return -1 }
	if val_a > val_b { return 1 }
	return 0
}

fn main() {
	println('--- Array Built-in Methods ---')

	// 1. ensure_cap(required)
	// Ensures that the array has at least the specified capacity.
	mut a := [10, 20, 30]
	a.ensure_cap(10)
	println('ensure_cap: cap is ${a.cap >= 10}') // true

	// 2. repeat(count)
	// Repeats the array count times and returns a new array.
	rep := a.repeat(2)
	println('repeat: ${rep}') // [10, 20, 30, 10, 20, 30]

	// 3. repeat_to_depth(count, depth) (unsafe)
	// Recursively repeats a multi-dimensional array count times to the specified depth.
	grid := [[1, 2], [3, 4]]
	unsafe {
		rep_grid := grid.repeat_to_depth(2, 1)
		// Cast the raw array struct back to typed [][]int
		typed_grid := *(&[][]int(&rep_grid))
		println('repeat_to_depth: ${typed_grid}') // [[1, 2], [3, 4], [1, 2], [3, 4]]
		rep_grid.free()
	}

	// 4. insert(index, val)
	// Inserts a new element at the specified index.
	a.insert(1, 15)
	println('insert: ${a}') // [10, 15, 20, 30]

	// 5. prepend(val)
	// Prepends a new element at the beginning of the array.
	a.prepend(5)
	println('prepend: ${a}') // [5, 10, 15, 20, 30]

	// 6. delete(index)
	// Deletes the element at the specified index.
	a.delete(1) // Deletes index 1 (which is 10)
	println('delete: ${a}') // [5, 15, 20, 30]

	// 7. delete_many(index, size)
	// Deletes size elements starting from the specified index.
	a.delete_many(1, 2) // Deletes 2 elements starting at index 1
	println('delete_many: ${a}') // [5, 30]

	// 8. clear()
	// Sets the array length to 0, retaining capacity.
	mut a_clear := [1, 2, 3]
	a_clear.clear()
	println('clear: len is ${a_clear.len}') // 0

	// 9. reset() (unsafe)
	// Sets all elements of the array to 0 / empty values without altering len or cap.
	mut a_reset := [1, 2, 3]
	unsafe {
		a_reset.reset()
	}
	println('reset: ${a_reset}') // [0, 0, 0]
	unsafe {
		a_reset.free()
	}

	// 10. trim(index)
	// Truncates the array length to index.
	mut a_trim := [1, 2, 3, 4]
	a_trim.trim(2)
	println('trim: ${a_trim}') // [1, 2]

	// 11. drop(num)
	// Drops the first num elements in-place.
	mut a_drop := [1, 2, 3, 4]
	a_drop.drop(2)
	println('drop: ${a_drop}') // [3, 4]

	// 12. first()
	// Returns the first element of the array.
	println('first: ${a_drop.first()}') // 3

	// 13. last()
	// Returns the last element of the array.
	println('last: ${a_drop.last()}') // 4

	// 14. pop_left()
	// Removes and returns the first element of the array.
	mut a_pop := [1, 2, 3]
	first_val := a_pop.pop_left()
	println('pop_left: value = ${first_val}, array = ${a_pop}') // 1, [2, 3]

	// 15. pop()
	// Removes and returns the last element of the array.
	last_val := a_pop.pop()
	println('pop: value = ${last_val}, array = ${a_pop}') // 3, [2]

	// 16. delete_last()
	// Deletes the last element of the array.
	mut a_del_last := [1, 2, 3]
	a_del_last.delete_last()
	println('delete_last: ${a_del_last}') // [1, 2]

	// 17. clone()
	// Returns a deep copy of the array.
	a_clone := a_del_last.clone()
	println('clone: ${a_clone}') // [1, 2]

	// 18. clone_to_depth(depth) (unsafe)
	// Recursively clones a multi-dimensional array up to the specified depth.
	grid2 := [[1, 2], [3, 4]]
	unsafe {
		grid_clone := grid2.clone_to_depth(1)
		typed_clone := *(&[][]int(&grid_clone))
		println('clone_to_depth: ${typed_clone}') // [[1, 2], [3, 4]]
		grid_clone.free()
	}

	// 19. push_many(val, size) (unsafe)
	// Appends size elements starting from a raw pointer val to the array.
	mut a_push := [1, 2]
	vals := [3, 4]
	unsafe {
		a_push.push_many(vals.data, 2)
	}
	println('push_many: ${a_push}') // [1, 2, 3, 4]
	unsafe {
		a_push.free()
		vals.free()
	}

	// 20. reverse()
	// Returns a new reversed copy of the array.
	a_rev := [1, 2, 3]
	println('reverse: ${a_rev.reverse()}') // [3, 2, 1]

	// 21. reverse_in_place()
	// Reverses the array elements in-place.
	mut a_rev_ip := [1, 2, 3]
	a_rev_ip.reverse_in_place()
	println('reverse_in_place: ${a_rev_ip}') // [3, 2, 1]

	// 22. free() (unsafe)
	// Deallocates the array's buffer.
	mut a_free := [1, 2, 3]
	unsafe {
		a_free.free()
	}
	println('free: array freed')

	// 23. filter(it)
	// Filters elements that satisfy a predicate using compiler-defined `it` expression.
	a_filt := [1, 2, 3, 4]
	filtered := a_filt.filter(it % 2 == 0)
	println('filter: ${filtered}') // [2, 4]

	// 24. any(it)
	// Checks if any element satisfies the predicate.
	println('any: ${a_filt.any(it > 3)}') // true

	// 25. count(it)
	// Counts how many elements satisfy the predicate.
	println('count: ${a_filt.count(it % 2 == 0)}') // 2

	// 26. all(it)
	// Checks if all elements satisfy the predicate.
	println('all: ${a_filt.all(it > 0)}') // true

	// 27. map(it)
	// Maps elements to a new array using a transformation expression.
	mapped := a_filt.map(it * 10)
	println('map: ${mapped}') // [10, 20, 30, 40]

	// 28. sort() & sort(custom)
	// Sorts elements in-place. Uses optional boolean expression for custom order (uses magic vars a and b).
	mut a_sort := [3, 1, 4, 2]
	a_sort.sort()
	println('sort (default ascending): ${a_sort}') // [1, 2, 3, 4]
	a_sort.sort(a > b)
	println('sort (custom descending): ${a_sort}') // [4, 3, 2, 1]

	// 29. sorted() & sorted(custom)
	// Returns a sorted copy of the array. Uses optional boolean expression for custom order (uses magic vars a and b).
	a_sorted := [3, 1, 4, 2]
	println('sorted (default): ${a_sorted.sorted()}') // [1, 2, 3, 4]
	println('sorted (custom): ${a_sorted.sorted(a > b)}') // [4, 3, 2, 1]

	// 30. sort_with_compare(callback)
	// Sorts the array in-place using a custom comparison function.
	mut a_compare := [3, 1, 4, 2]
	a_compare.sort_with_compare(compare_ints)
	println('sort_with_compare: ${a_compare}') // [1, 2, 3, 4]

	// 31. sorted_with_compare(callback)
	// Returns a sorted copy of the array using a custom comparison function.
	a_sorted_comp := [3, 1, 4, 2]
	println('sorted_with_compare: ${a_sorted_comp.sorted_with_compare(compare_ints)}') // [1, 2, 3, 4]

	// 32. contains(value)
	// Checks if the array contains value.
	println('contains: ${a_filt.contains(3)}') // true

	// 33. index(value)
	// Returns the index of the first occurrence of value, or -1 if not found.
	println('index: ${a_filt.index(3)}') // 2

	// 34. last_index(value)
	// Returns the index of the last occurrence of value, or -1 if not found.
	a_dup := [1, 2, 3, 2]
	println('last_index: ${a_dup.last_index(2)}') // 3

	// 35. grow_cap(amount)
	// Increases the array capacity by the specified amount.
	mut a_grow := [1, 2]
	a_grow.grow_cap(10)
	println('grow_cap: cap is ${a_grow.cap >= 12}') // true

	// 36. grow_len(amount) (unsafe)
	// Increases the array length by the specified amount.
	unsafe {
		a_grow.grow_len(3)
	}
	println('grow_len: ${a_grow}') // [1, 2, 0, 0, 0]
	unsafe {
		a_grow.free()
	}

	// 37. pointers() (unsafe)
	// Returns an array of void pointers (pointers()) pointing to each element.
	a_ptrs := [10, 20]
	unsafe {
		ptrs := a_ptrs.pointers()
		println('pointers (first element): ${*(&int(ptrs[0]))}') // 10
		ptrs.free()
		a_ptrs.free()
	}
}

Maps

Explicit Map Initialization

Explicit Map Initialization

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of explicit map initialization.

fn main() {
	mut books := map[string]int{}
	books['V on Wheels'] = 320
	books['Go for Dummies'] = 279

	println(books)
}

Short Syntax Initialization Of Map

Short Syntax Initialization Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of short syntax initialization of map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	println(student_1)
}

Count Key Value Pairs In Map

Count Key Value Pairs In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of count key value pairs in map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	cnt := student_1.len
	println('There are ${cnt} key-value pairs in student_1 map')
}

Value Given Key Of Map

Value Given Key Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of value given key of map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println(student_1['physics']) // 83
}

Value Given Non Existent Key Of Map

Value Given Non Existent Key Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of value given non existent key of map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println(student_1['geography']) // 0
}

Handling Missing Keys In Map

Handling Missing Keys In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of handling missing keys in map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	sub := 'geography'
	res := student_1[sub] or { panic('marks for subject ${sub} not yet updated') } // throws error
}

Update Value Given A Key In Map

Update Value Given A Key In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of update value given a key in map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	student_1['english'] = 93
	println(student_1)
}

Delete Key Value Pair From Map

Delete Key Value Pair From Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of delete key value pair from map.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println('Key-Value pairs before deleting a key: ${student_1.len}')
	student_1.delete('physics')
	println('Key-Value pairs after deleting a key ${student_1.len}')
}

Map Methods

Map Methods

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

Additional Context from Repository docs:

This example demonstrates the concepts of map methods.

module main

fn main() {
	println('--- Map Built-in Methods ---')

	mut m := {
		'one': 1
		'two': 2
	}
	println('initial map: ${m}') // {"one": 1, "two": 2}

	// 1. keys()
	// Returns an array containing all keys in the map.
	println('keys: ${m.keys()}') // ["one", "two"]

	// 2. values()
	// Returns an array containing all values in the map.
	println('values: ${m.values()}') // [1, 2]

	// 3. clone()
	// Returns a deep copy of the map.
	mut m_clone := m.clone()
	println('clone: ${m_clone}') // {"one": 1, "two": 2}

	// 4. delete(key)
	// Removes a key-value pair from the map by key.
	m.delete('one')
	println('delete: ${m}') // {"two": 2}

	// 5. reserve(capacity)
	// Pre-allocates space for at least capacity elements in the map.
	m.reserve(10)
	println('reserve: reserved capacity successfully')

	// 6. clear()
	// Removes all key-value pairs from the map without deallocating data.
	m.clear()
	println('clear: len is ${m.len}') // 0

	// 7. move()
	// Moves the map contents to a new map variable and clears the original map to empty.
	mut m_move := {
		'three': 3
		'four': 4
	}
	moved := m_move.move()
	println('move (new map): ${moved}') // {"three": 3, "four": 4}
	println('move (original map): ${m_move}') // {}

	// 8. free() (unsafe)
	// Deallocates the map memory.
	mut m_free := {
		'temp': 100
	}
	unsafe {
		m_free.free()
	}
	println('free: map freed successfully')
}

Chapter 6 Functions

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Advanced Function Features

• Function Returns Value Example 1
• Function Returns Value Example 2
• Funtions Without Return Type
• Function With Input Arguments
• Function Return Multiple Values
• Ignore Function Return Value
• Function Calls Other Function
• Example 1
• Example 2
• Error Script Functions
• Script Functions
• Functions Module Variables - Main (main.v)
• Mymod
• Functions With Optional Return Types Example 1
• Function With Optional Return Type Example 2
• Mod1
• Public Function Demo1
• Public Function Demo2
• Public Function Demo3
• Function With Defer Block
• Functions As Elements Of Array Or Map

Function Extras

• Hello
• Basic Functions
• Anonymous Functions
• Functions As Input Arguments
• Functions That Return Other Functions

Functions let you turn repeated or complex logic into small, named building blocks. A useful mental model is: define the task, give it inputs if needed, do the work, and return a useful result. This chapter starts with simple functions and then introduces multiple returns, optional results, higher-order functions, and cleanup with defer.

Advanced Function Features

Function Returns Value Example 1

Function Returns Value Example 1

A simple function is a small helper that turns inputs into a useful result. The basic pattern is: define the function, pass in values, do some work, and return the answer. In this example, add takes two integers and returns their sum.

Additional Context from Repository docs:

This example demonstrates the concepts of function returns value example 1.

fn add(a int, b int) int {
	return a + b
}

fn main() {
	total := add(7, 5)
	println('7 + 5 = ${total}')
}

Function Returns Value Example 2

Function Returns Value Example 2

A function does not need to print anything itself. It can build a value and hand it back to the caller. Here, say_hello returns a greeting string, and main decides how to display it.

Additional Context from Repository docs:

This example demonstrates the concepts of function returns value example 2.

fn say_hello(name string) string {
	return 'Hello, ${name}!'
}

fn main() {
	message := say_hello('Ada')
	println(message)
}

Functions Without Return Type

Functions Without Return Type

Some functions are used for actions rather than calculations. They may print output, write files, or update state. In that case, you can leave out the return type and focus on the side effect.

Additional Context from Repository docs:

This example demonstrates the concepts of funtions without return type.

fn print_welcome_message() {
	println('Welcome to V!')
}

fn main() {
	print_welcome_message()
}

Function With Input Arguments

Function With Input Arguments

Functions become much more useful when they accept inputs. This example uses two numbers as arguments and returns their sum, showing the classic input → process → output flow.

Additional Context from Repository docs:

This example demonstrates the concepts of function with input arguments.

fn add(a int, b int) int {
	return a + b
}

fn main() {
	result := add(15, 27)
	println('15 + 27 = ${result}')
}

Function Return Multiple Values

Function Return Multiple Values

A function can return more than one value when those values belong together. A common pattern is returning both the main result and a related detail, such as a length or status. Here, greetandmessage_length returns both the greeting and its length.

Additional Context from Repository docs:

This example demonstrates the concepts of function return multiple values.

fn greet_and_message_length(name string) (string, int) {
	greeting := 'Hello, ${name}!'
	return greeting, greeting.len
}

fn main() {
	greeting, length := greet_and_message_length('Navule')
	println(greeting)
	println('Length: ${length}')
}

Ignore Function Return Value

Ignore Function Return Value

Sometimes you only care about one returned value. V lets you ignore the rest with _, which keeps the code readable when you are only interested in part of the result.

Additional Context from Repository docs:

This example demonstrates the concepts of ignore function return value.

fn greet_and_message_length(name string) (string, int) {
	greeting := 'Hello, ${name}!'
	return greeting, greeting.len
}

fn main() {
	greeting, _ := greet_and_message_length('Navule')
	println(greeting)
}

Function Calls Other Function

Function Calls Other Function

Functions can call other functions to split a bigger problem into smaller steps. This makes the code easier to understand and easier to reuse later.

Additional Context from Repository docs:

This example demonstrates the concepts of function calls other function.

fn greet(p string) string {
	return 'Hello, ${p}!'
}

fn welcome(p string) string {
	msg := 'Nice to meet you!'
	mut g := greet(p)
	g = g + ' ${msg}'
	return g
}

fn main() {
	res := welcome('Visitor')
	println(res)
}

Example 1

Example 1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of example 1.

fn increment_array_items(arr []int, inc int) []int {
	mut tmp := arr.clone()
	for mut i in tmp {
		i += inc
	}
	return tmp
}

fn main() {
	a := [5, 6]

	res := increment_array_items(a, 100)

	println('a: ${a}')
	println('res: ${res}')
}

Example 2

Example 2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of example 2.

fn increment_array_items(mut arr []int, inc int) {
	for mut i in arr {
		i += inc
	}
}

fn main() {
	mut a := [5, 6]
	increment_array_items(mut a, 100)
	// Must specify mut keyword when sending value to mut arg of a function
	println('a: ${a}')
}

Error Script Functions

Error Script Functions

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

#!/usr/local/bin/v run

cnt := 2

for i in 0 .. cnt {
	log('iteration ${i}')
}

fn log(msg string) {
	println(msg)
}

Script Functions

Script Functions

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

#!/usr/local/bin/v run

fn log(msg string) {
	println(msg)
}

cnt := 2

for i in 0 .. cnt {
	log('iteration ${i}')
}

Functions Module Variables - Main (main.v)

Functions Module Variables - Main

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of main.

// file: main.v
module main

import mymod

fn main() {
	mymod.msg := 'global variable demo'
	println(mymod.msg)
}

Mymod

Mymod

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of mymod.

// file: mymod/mymod.v
module mymod

__global (
	msg string
)

Functions With Optional Return Types Example 1

Functions With Optional Return Types Example 1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of functions with optional return types example 1.

module main

fn is_teen(age int) ?string {
	if age < 0 {
		return none
	} else if age >= 13 && age <= 19 {
		return 'teenager'
	} else {
		return 'not teenager'
	}
}

fn main() {
	x := is_teen(-3) or { 'invalid age provided' }
	println(x)
}

Function With Optional Return Type Example 2

Function With Optional Return Type Example 2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of function with optional return type example 2.

module main

fn is_teen(age int) ?string {
	if age < 0 {
		return error('invalid age provided')
	} else if age >= 13 && age <= 19 {
		return 'teenager'
	} else {
		return 'not teenager'
	}
}

fn main() {
	x := is_teen(-3) or { err.msg }
	println(x)
}

Mod1

Mod1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of mod1.

// file: mod1/mod1.v
module mod1

fn greet1() string {
	return 'Hello from greet1'
}

pub fn greet2() string {
	return 'Hello from greet2'
}

pub fn greet_and_wish() string {
	wish := 'Have a nice day!'
	return greet1() + ', ' + wish
}

Public Function Demo1

Public Function Demo1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of public function demo1.

// file: public_function_demo1.v
import mod1

fn main() {
	g := mod1.greet1()
	println(g)
}

Public Function Demo2

Public Function Demo2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of public function demo2.

// file: public_function_demo2.v
import mod1

fn main() {
	g := mod1.greet2()
	println(g)
}

Public Function Demo3

Public Function Demo3

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

Additional Context from Repository docs:

This example demonstrates the concepts of public function demo3.

// file: public_function_demo3.v
import mod1

fn main() {
	g := mod1.greet_and_wish()
	println(g)
}

Function With Defer Block

Function With Defer Block

defer is useful when a function needs to clean up something before it exits, such as closing a file or releasing a resource. The deferred block runs automatically at the end of the function.

Additional Context from Repository docs:

This example demonstrates the concepts of function with defer block.

module main

fn void_func_defer() {
	println('Hello')
	defer {
		println('Hi from defer block')
	}
	println('How are you?')

	// the defer block will be executed when the execution control reaches here
}

fn main() {
	void_func_defer()
}

Functions As Elements Of Array Or Map

Functions As Elements Of Array Or Map

Functions can be stored in arrays and maps just like other values. This allows you to choose an operation dynamically at runtime, which is helpful in flexible programs.

Additional Context from Repository docs:

This example demonstrates the concepts of functions as elements of array or map.

module main

fn adder(i int, j int) int {
	return i + j
}

fn subtractor(i int, j int) int {
	return i - j
}

fn multiplier(i int, j int) int {
	return i * j
}

fn main() {
	i, j := 2, 5
	println('Functions as elements of an Array')
	funcs := [adder, subtractor, multiplier]

	for f in funcs {
		res := f(i, j)
		println(res)
	}
	println('Functions as elements of Map')
	d := {
		'sum':        adder
		'difference': subtractor
		'product':    multiplier
	}

	for key, val in d {
		res := val(i, j)
		println('${key} of ${i} and ${j}: ${res}')
	}
}

Function Extras

Hello

Hello

Every V program starts with main(). It is the entry point where execution begins, so it is the first function most beginners learn.

Additional Context from Repository docs:

This example demonstrates the concepts of hello.

module main

fn main() {
	println('Welcome to the World of V!')
}

Basic Functions

Basic Functions

A basic function packages a task so you can call it later instead of repeating the same code. This example shows a function that prints a message when invoked.

Additional Context from Repository docs:

This example demonstrates the concepts of basic functions.

fn greet(msg string) {
	println(msg)
}

fn main() {
	greet('Hello, Welcome to the world of V programming')
}

Anonymous Functions

Anonymous Functions

Anonymous functions are defined inline and are useful for short, one-off behavior. They are handy when you want a quick callback without creating a named function.

Additional Context from Repository docs:

This example demonstrates the concepts of anonymous functions.

module main

fn main() {
	greet := fn (name string) {
		println('Hello, ${name}')
	}
	greet('Pavan')
	greet('Sahithi')
}

Functions As Input Arguments

Functions As Input Arguments

Functions are reusable blocks of logic. This lesson on Functions As Input Arguments explains functional syntax, arguments, returns, or functional capabilities in V.

Additional Context from Repository docs:

This example demonstrates the concepts of functions as input arguments.

module main

fn greet_morning() string {
	return 'Good Morning'
}

fn greet_noon() string {
	return 'Good Afternoon'
}

fn greet_evening() string {
	return 'Good Evening'
}

fn greet(f fn () string, name string) string {
	return '${f()}, ${name}!'
}

fn main() {
	mut res := greet(greet_morning, 'Pavan')
	println(res)

	res = greet(greet_evening, 'Sahithi')
	println(res)

	res = greet(fn () string {
		return 'New year greetings to you'
	}, 'Sahithi')
	println(res)
}

Functions That Return Other Functions

Functions That Return Other Functions

Functions are reusable blocks of logic. This lesson on Functions That Return Other Functions explains functional syntax, arguments, returns, or functional capabilities in V.

Additional Context from Repository docs:

This example demonstrates the concepts of functions that return other functions.

module main

enum Operation {
	add
	sub
	mul
}

fn adder(i int, j int) int {
	return i + j
}

fn subtractor(i int, j int) int {
	return i - j
}

fn multiplier(i int, j int) int {
	return i * j
}

fn fetch(op Operation) fn (int, int) int {
	return match op {
		.add {
			adder
		}
		.sub {
			subtractor
		}
		.mul {
			multiplier
		}
	}
}

fn main() {
	i, j := 2, 5
	mut f := fetch(.add) // return adder function
	mut res := f(i, j) // calls adder(2, 5)
	println('sum of ${i} and ${j}: ${res}')

	f = fetch(.sub) // returns subtractor function
	res = f(i, j) // calls subtractor(2, 5)
	println('difference of ${i} and ${j}: ${res}')

	f = fetch(.mul) // returns multipler function
	res = f(i, j) // calls multiplier(2, 5)
	println('product of ${i} and ${j}: ${res}')
}

Chapter 7 Structs (Custom Types)

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Struct Basics & Fields

• Defining Struct
• Initialize Struct Example 1
• Initialize Struct Example 2
• Access Struct Fields
• Heap Structs
• Updating Immutable Struct Variable Throws Error
• Updating Mutable Fields Of Struct
• Updating Immutable Fields Throws Error
• Updating Struct With Unspecified Fields Are Zeroed
• Struct With Multiple Fields
• Grouping Struct Fields Based On Access Modifiers
• Required Fields Example 01
• Required Fields Example 02
• Struct Fields With Default Values
• Methods For Struct
• Adding Struct As Struct Field
• Updating Fields Of Type Struct
• Struct As Trailing Literal Arguments To Function

Structs are user-defined data structures that allow you to group related fields together. This chapter explains how to define structs, set default values, make fields required, attach methods to structs, and embed structs inside other structures.

Struct Basics & Fields

Defining Struct

Defining Struct

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of defining struct.

struct Note {
	id      int
	message string
}

fn main() {
}

Initialize Struct Example 1

Initialize Struct Example 1

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of initialize struct example 1.

struct Note {
	id      int
	message string
}

fn main() {
	n := Note{1, 'a simple struct demo'}

	println(n)
}

Initialize Struct Example 2

Initialize Struct Example 2

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of initialize struct example 2.

struct Note {
	id      int
	message string
}

fn main() {
	n := Note{
		message: 'a simple struct demo'
		id:      1
	}

	println(typeof(n).name)
	// Note
}

Access Struct Fields

Access Struct Fields

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of access struct fields.

struct Note {
	id      int
	message string
}

fn main() {
	n := Note{1, 'a simple struct demo'}
	println(n.message)
}

Heap Structs

Heap Structs

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of heap structs.

struct Note {
	id      int
	message string
}

fn main() {
	n1 := &Note{1, 'this note will be allocated on heap'}
	println(typeof(n1).name) // &Note
}

Updating Immutable Struct Variable Throws Error

Updating Immutable Struct Variable Throws Error

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of updating immutable struct variable throws error.

module main

struct Note {
	id int
mut:
	message string
}

fn main() {
	n := Note{1, 'a simple struct demo'}
	println(n)

	n.message = 'a simple struct updated' // throws error
}

Updating Mutable Fields Of Struct

Updating Mutable Fields Of Struct

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of updating mutable fields of struct.

module main

struct Note {
	id int
mut:
	message string
}

fn main() {
	mut n := Note{1, 'a simple struct demo'}
	println('before update')
	println(n)

	n.message = 'a simple struct updated'
	println('after update')
	println(n)
}

Updating Immutable Fields Throws Error

Updating Immutable Fields Throws Error

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of updating immutable fields throws error.

module main

struct Note {
	id int
mut:
	message string
}

fn main() {
	mut j := Note{1, 'a simple struct demo'}
	j.id = 2 // throws error
}

Updating Struct With Unspecified Fields Are Zeroed

Updating Struct With Unspecified Fields Are Zeroed

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of updating struct with unspecified fields are zeroed.

module main

struct Note {
	id int
mut:
	message string
}

fn main() {
	// declare
	mut n := Note{}

	// populate
	n = Note{
		id:      1
		message: 'updating struct fields demo'
	}
	println(n)

	// unspecified fields zeroed by default
	// id being type of int, will become 0 here
	println('unspecified id zeroed during short struct type initialization')
	n = Note{
		message: 'updating struct fields demo 2'
	}
	println(n)
}

Struct With Multiple Fields

Struct With Multiple Fields

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of struct with multiple fields.

struct Note {
	id int
mut:
	message string
	status  bool
}

fn main() {
}

Grouping Struct Fields Based On Access Modifiers

Grouping Struct Fields Based On Access Modifiers

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of grouping struct fields based on access modifiers.

pub struct Note {
pub:
	id int
pub mut:
	message string
	status  bool
}

fn main() {
}

Required Fields Example 01

Required Fields Example 01

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of required fields example 01.

pub struct Note {
pub:
	id int
pub mut:
	message string @[required]
	status  bool
}

fn main() {
	_ := Note{
		id:     1
		status: false
	}
}
// throws error

Required Fields Example 02

Required Fields Example 02

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of required fields example 02.

module main

pub struct Note {
pub:
	id int
pub mut:
	message string @[required]
	status  bool
}

fn main() {
	n := Note{
		id:      1
		message: 'a simple struct demo'
		status:  false
	}
	println(n)
}

Struct Fields With Default Values

Struct Fields With Default Values

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of struct fields with default values.

import time

pub struct Note {
pub:
	id      int
	created time.Time = time.now()
pub mut:
	message string @[required]
	status  bool
	due     time.Time = time.now().add_days(1)
}

fn main() {
	n := Note{
		id:      1
		message: 'order groceries'
	}
	println(n)
}

Methods For Struct

Methods For Struct

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of methods for struct.

module main

import time

pub struct Note {
pub:
	id      int
	created time.Time = time.now()
pub mut:
	message string @[required]
	status  bool
	due     time.Time = time.now().add_days(1)
}

// is_empty_message is a method that belongs to Note
pub fn (n Note) is_empty_message() bool {
	return n.message.len < 1
}

fn main() {
	mut n := Note{
		id:      1
		message: ''
	}

	if n.is_empty_message() {
		println('message is empty')
	} else {
		println('message not empty')
	}
}

Adding Struct As Struct Field

Adding Struct As Struct Field

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of adding struct as struct field.

import time

// NoteTimeInfo is a struct to store time info of Note
pub struct NoteTimeInfo {
pub:
	created time.Time = time.now()
pub mut:
	due time.Time = time.now().add_days(1)
}

// Note is a struct with struct NoteTimeInfo as a field, along with other fields
pub struct Note {
	NoteTimeInfo // Struct as another struct field
pub:
	id int
pub mut:
	message string @[required]
	status  bool
}

fn main() {
	n := Note{
		id:      1
		message: 'adding struct as struct field demo'
	}
	println('Due date: ${n.due}')
	println(n)
}

Updating Fields Of Type Struct

Updating Fields Of Type Struct

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of updating fields of type struct.

module main

import time

// NoteTimeInfo is a struct to store time info of Note
pub struct NoteTimeInfo {
pub:
	created time.Time = time.now()
pub mut:
	due time.Time = time.now().add_days(1)
}

// Note is a struct with struct NoteTimeInfo as a field, along with other fields
pub struct Note {
	NoteTimeInfo
pub:
	id int
pub mut:
	message string @[required]
	status  bool
}

fn main() {
	mut n := Note{
		id:      1
		message: 'adding struct as struct field demo'
	}

	println('Due date: ${n.due}')
	// approach 1: implicit access of struct fields of fields of type struct
	n.due = n.due.add_days(2)
	println('Due date after update: ${n.due}')

	// approach 2: explicitly specifying the field of type struct and its fields
	n.NoteTimeInfo.due = n.NoteTimeInfo.due.add_days(2)
	println('Due date updated second time: ${n.due}')
	println(n)
}

Struct As Trailing Literal Arguments To Function

Struct As Trailing Literal Arguments To Function

A struct is a user-defined custom type that groups related variables (called fields) together. Structs are fundamental to V's object-oriented programming model. By default, struct fields are private and immutable. V provides access modifiers like mut:, pub:, and pub mut: to control field access and mutability.

These examples demonstrate defining structs, updating fields, required fields, default values, and struct methods.

Additional Context from Repository docs:

This example demonstrates the concepts of struct as trailing literal arguments to function.

module main

import time

// NoteTimeInfo is a struct to store time info of Note
pub struct NoteTimeInfo {
pub:
	created time.Time = time.now()
pub mut:
	due time.Time = time.now().add_days(1)
}

// Note is a struct with embedding struct NoteTimeInfo along with other fields
pub struct Note {
	NoteTimeInfo
pub:
	id int
pub mut:
	message string @[required]
	status  bool
}

fn new_grocery_note(n Note) &Note {
	return &Note{
		id:      n.id
		message: 'Buy Groceries: ' + n.message
	}
}

fn extend_due_by_a_day(n Note) &Note {
	return &Note{
		NoteTimeInfo: NoteTimeInfo{
			due: n.due.add_days(1)
		}
		id:           n.id
		message:      n.message
	}
}

fn main() {
	g := new_grocery_note(Note{ id: 1, message: 'Milk' })
	println('${g.message} is due by ${g.due}')
	n := extend_due_by_a_day(g)
	println('After extending due date by a day')
	println('${n.message} is due by ${n.due}')
}

Chapter 8 Error Handling

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Option & Result Types

• Error Handling

V has no exceptions. Instead, it handles errors using Option and Result types, which are checked at compile time. This chapter teaches you how to write robust, error-free programs using V's clean error handling syntax.

Option & Result Types

Error Handling

In many programming languages, errors are handled using exceptions (with try, catch, and throw blocks). Exception blocks can make code hard to read and trace because control flow can jump unpredictably.

V takes a different approach. V does not have exceptions. Instead, V handles errors explicitly using two main concepts:

• Option Types (?T): Used when a value might simply be missing (like searching for an item that isn't in a list).
• Result Types (!T): Used when an operation might actually fail with a specific error (like division by zero or a database timeout).

By forcing you to handle these outcomes explicitly, V makes your code safer and easier to debug.

module main

// ==========================================
// Define Custom Error Types
// ==========================================

// CustomError embeds the builtin Error struct to implement the IError interface.
struct CustomError {
	Error // Required: provides default implementations of msg() and code()
	message string
	code    int
}

// Overwrite the msg() method for CustomError
fn (err CustomError) msg() string {
	return err.message
}

// Overwrite the code() method for CustomError
fn (err CustomError) code() int {
	return err.code
}

// DatabaseError represents another custom error type.
struct DatabaseError {
	Error
	query string
}

fn (err DatabaseError) msg() string {
	return 'Database error executing query: "${err.query}"'
}

// ==========================================
// 1. Option Types (?T)
// Options represent either a value of type T or nothing (none).
// ==========================================

// find_item returns a string if found, or none if not.
fn find_item(id int) ?string {
	if id == 42 {
		return 'V programming book'
	}
	return none // return absence of value
}

// find_item_wrapper demonstrates Option propagation with the `?` suffix.
fn find_item_wrapper(id int) ?string {
	// If find_item returns none, the execution stops here and propagates none up.
	item := find_item(id)?
	return 'Found: ' + item
}

// ==========================================
// 2. Result Types (!T)
// Results represent either a value of type T or an IError.
// ==========================================

// divide performs float division but returns an error for division by zero.
fn divide(a f64, b f64) !f64 {
	if b == 0.0 {
		return error('division by zero') // Return a standard error
	}
	return a / b
}

// fetch_data returns a string or a CustomError.
fn fetch_data(success bool) !string {
	if !success {
		return CustomError{
			message: 'Connection timed out'
			code: 504
		}
	}
	return 'Raw database records'
}

// query_db returns a string or a DatabaseError.
fn query_db(query string, success bool) !string {
	if !success {
		return DatabaseError{
			query: query
		}
	}
	return 'Query success'
}

// calculate_and_format demonstrates Result propagation using the `!` operator.
fn calculate_and_format(a f64, b f64) !string {
	// The `!` suffix propagates the error to the caller if divide fails.
	res := divide(a, b)!
	return 'Result is ${res:.2f}'
}

// ==========================================
// 3. Unrecoverable Errors (Panics)
// ==========================================
fn force_panic() {
	println('Simulating a critical failure...')
	panic('Fatal error: Out of memory or system crash.')
}

fn main() {
	println('=== 1. Option Types (?T) ===')

	// Option Handling: Option unwrapping using `or` block
	item_1 := find_item(42) or { 'Default Item' }
	println('Item 1 (with 42): ${item_1}')

	item_2 := find_item(99) or { 'Default Item' }
	println('Item 2 (with 99): ${item_2}')

	// Option Handling: Option unwrapping with variable binding using `if-let`
	if item := find_item(42) {
		println('If-let match: Found "${item}"')
	} else {
		println('If-let match: Item not found')
	}

	if item := find_item(99) {
		println('If-let match: Found "${item}"')
	} else {
		println('If-let match: Item not found (none)')
	}

	// Option Propagation Check
	wrapped_item := find_item_wrapper(99) or { 'None propagated successfully' }
	println('Propagation check: ${wrapped_item}\n')


	println('=== 2. Result Types (!T) ===')

	// Result Handling: Standard error message extraction via the `err` variable inside `or` block
	calc_success := calculate_and_format(10.0, 2.0) or { 'Error: ${err}' }
	println('Calc success: ${calc_success}')

	calc_fail := calculate_and_format(10.0, 0.0) or { 'Error: ${err}' }
	println('Calc failure: ${calc_fail}')


	println('\n=== 3. Custom Error Matching & Type Casting ===')

	// We can inspect the error type dynamically using the `is` check inside the `or` block.
	// Since fetch_data(false) returns a Result type (!string), the `or` block must either:
	// 1. Terminate control flow (e.g. using return, panic, exit)
	// 2. Evaluate to a fallback string value.
	// We use `''` (empty string) here as the fallback value to satisfy this type requirement.
	fetch_data(false) or {
		if err is CustomError {
			// Inside this block, `err` is smart-cast to CustomError automatically,
			// allowing direct access to custom fields like `code`.
			println('Caught CustomError! Message: "${err.msg()}", Code: ${err.code}')
		} else {
			println('Caught generic error: ${err.msg()}')
		}
		'' // Fallback empty string returned to satisfy the !string return type of the or block
	}

	// Similarly, query_db returns !string, so its or block must also evaluate to a string.
	query_db('SELECT * FROM users', false) or {
		if err is DatabaseError {
			// Smart-cast to DatabaseError, accessing the `query` field
			println('Caught DatabaseError!')
			println('Query attempted: "${err.query}"')
			println('Error message:   "${err.msg()}"')
		} else {
			println('Caught generic error: ${err.msg()}')
		}
		'' // Fallback empty string returned to satisfy the !string return type of the or block
	}


	println('\n=== 4. Panic (Unrecoverable Error) ===')
	// We wrap panic execution or run it last since it terminates the process.
	// You can uncomment the line below to test panic termination:
	// force_panic()
	println('To run a panic, uncomment force_panic() in main.')
}

Chapter 9 Organizing Code with Modules

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Modules & Project Structure

• Creating a Simple V Project - Main (modulebasics.v)
• Creating a Module - Helper (file1.v)
• Creating a Module - Main (modulebasics.v)
• Importing a Module - Helper (file1.v)
• Importing a Module - Main (modulebasics.v)
• Accessing Module Members - Helper (file1.v)
• Accessing Module Members - Main (modulebasics.v)
• Multiple Files (After Refactoring) - Helper 1 (file1.v)
• Multiple Files (After Refactoring) - Helper 2 (file2.v)
• Multiple Files (After Refactoring) - Main (modulebasics.v)
• Multiple Files (Before Refactoring) - Helper 1 (file1.v)
• Multiple Files (Before Refactoring) - Helper 2 (file2.v)
• Multiple Files (Before Refactoring) - Main (modulebasics.v)
• Member Scope (After Refactoring) - Helper 1 (file1.v)
• Member Scope (After Refactoring) - Helper 2 (file2.v)
• Member Scope (After Refactoring) - Main (modulebasics.v)
• Member Scope (Before Refactoring) - Helper 1 (file1.v)
• Member Scope (Before Refactoring) - Helper 2 (file2.v)
• Member Scope (Before Refactoring) - Main (modulebasics.v)
• Cyclic Imports - Module 1 Helper (file1.v)
• Cyclic Imports - Module 2 Helper (file1.v)
• Cyclic Imports - Main (modulebasics.v)
• Module Init Function - Helper (file1.v)
• Module Init Function - Main (modulebasics.v)
• Accessing Module Constants - Helper (file1.v)
• Accessing Module Constants - Main (modulebasics.v)
• Accessing Module Structs - Helper (file1.v)
• Accessing Module Structs - Main (modulebasics.v)

Installing External Packages

• How to Install Packages with vpm
• Common vpm Commands
• Importing and Using External Packages
• Redis Console Demo
• Redis Console Demo - Helper (redishelper.v)
• Redis Namespaced Demo - Helper (redishelper.v)
• Redis Namespaced Demo
• Redis Webview Demo
• Webview Demo

Modules help organize larger codebases. In this chapter, you will learn how to create modules, import them, manage member visibility using pub, and understand module initialization lifecycle.

Modules & Project Structure

Creating a Simple V Project - Main (modulebasics.v)

Creating a Simple V Project

Think of a module as a small toolbox. The main module is the entry point of your program, while other modules can hold reusable functions and types.

This first example is intentionally simple: it shows the structure of a single-file V program before we introduce imports and shared modules.

module main

fn main() {
	println('Welcome to the V module demo!')
}

Creating a Module - Helper (file1.v)

A Reusable Helper Module

A module can hold functions that other parts of your program can reuse. In this example, the helper module mod1 exposes a public function called greet.

module mod1

pub fn greet(name string) string {
	return 'Hello, ${name}!'
}

Creating a Module - Main (modulebasics.v)

Module Main Entry

This file acts as the application entry point. It imports the helper module and calls one of its public functions.

module main

import mod1

fn main() {
	println(mod1.greet('Ada'))
}

Importing a Module - Helper (file1.v)

Imported Module Helper

Importing a module gives your program access to its public members. The module name becomes the namespace you use when calling those functions.

module mod1

pub fn greet(name string) string {
	return 'Hello, ${name}!'
}

Importing a Module - Main (modulebasics.v)

Imported Module Main

The main program can now use the imported module without copying its code into the entry file.