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

In V, multi-line (or block) comments are enclosed between /* and */.

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 (x and y).
It performs multiplication and returns the integer product.

/*
Note: In V, block comments can be nested.
This is a nested block comment. In standard C, nesting block comments
would cause a compile error, but V's compiler parses them correctly.
*/
This is the end of the outer block comment.
*/
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_name = '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() {
	first_name, last_name, age := 'Ada', 'Lovelace', 36
	println('${first_name} ${last_name} is ${age} years old')
	println('Next milestone: ${first_name} will speak at the conference')
}

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.

fn main() {
	mut greeting, mut recipient := 'Hi', 'world'
	println('${greeting}, ${recipient}!')

	greeting, recipient = 'Hello', 'Ada'
	println('${greeting}, ${recipient}!')
}

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 message, count := 'Hello', 32
	println(message)
	message = 'Hi'
	println(message)
	println(count)
}

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 greeting := 'Hi'
	println(greeting)

	greeting = greeting + ' there'
	println(greeting)

	greeting += ', how are you today?'
	println(greeting)
}

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 score := 10
	println(score)

	score = score + 5
	println(score)

	score += 5
	println(score)
}

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 counter := 0
	counter += 1
	println(counter)
}

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

In V, variables are immutable by default. This design choice prevents accidental state mutation bugs, making code easier to reason about and safer for concurrency. When you declare a variable using the declaration operator :=, you are creating a read-only variable. If you try to reassign this variable later, the compilation will fail. This approach is similar to declaring constants in other languages, but it operates at the local scope level.

This example demonstrates how to declare an immutable variable and print its value.

Additional Context from Repository docs:

This example demonstrates the concepts of declare immutable variable.

fn main() {
	// 'msg' is initialized as an immutable string variable using :=
	msg := 'Hello'
	println(msg)
}

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

In V, variables are strictly scoped to the function or block in which they are declared. This lexical scoping means that two different functions can declare variables with the exact same name (e.g., msg) without any collision or interference. The compiler guarantees that these variables occupy separate locations in memory and are completely isolated from one another. This allows developers to use common, context-appropriate names like temp, id, or msg locally inside individual functions without worrying about global or cross-functional namespace pollution.

This program illustrates how msg is declared separately in both method1 and method2, showing scope isolation in action.

Additional Context from Repository docs:

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

module main

fn method1() {
	// 'msg' is local only to method1
	msg := 'Hello from Method1'
	println(msg)
}

fn method2() {
	// 'msg' is local only to method2; does not conflict with method1's 'msg'
	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 an if block, a loop, or a function body) has the same name as a variable in an outer scope. V strictly forbids variable shadowing at the compiler level. Prohibiting shadowing prevents a class of common bugs where a developer accidentally updates a local inner variable instead of the intended outer variable, or vice versa.

This example demonstrates 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' is declared in the function's main scope
	x := 10
	println(x)
	if true {
		// ERROR: Declaring another variable named 'x' in an inner block is forbidden.
		// To fix this, you must name the inner variable something else.
		x := 20 
		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() {
	a := 10
	b := 2

	// add using +
	sum := a + b

	// subtract using -
	diff := b - a

	// product using *
	prod := a * b

	// / results in quotient
	quotient := a / b

	// % modulo results in remainder
	remainder := a % b

	println('Sum of ${a} and ${b} is ${sum}')
	println('Subtracting ${a} from ${b} is ${diff}')
	println('Product of ${a} and ${b} is ${prod}')
	println('Quotient when ${a} divided by ${b} is ${quotient}')
	println('Remainder when ${a} divided by ${b} is ${remainder}')
}

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() {
	// A rune stores a single Unicode character.
	l := `a`
	println(typeof(l).name)
	// rune
}

Rune Operations With Strings

Rune Operations With Strings

Since strings in V are arrays of UTF-8 encoded bytes, you cannot directly check for a rune inside a string using string operations unless the rune is first converted to a string. V provides .str() on the rune type to easily convert a rune to a 1-character string, allowing you to use string methods like .count(), .contains(), etc.

This example shows how to count occurrences of a Unicode rune in a string.

Additional Context from Repository docs:

This example demonstrates the concepts of rune operations with strings.

fn main() {
	beverage := 'café'
	// 's' is a rune representing the Unicode character 'é'
	s := `é`
	// Since .count() expects a string argument, we convert the rune 's' using .str()
	println(beverage.count(s.str()))
	// Outputs: 1
}

Rune Methods

Rune Methods

Runes in V are not just raw numbers; they are full-fledged Unicode characters that support several built-in methods. You can convert their case, check their byte length (which can range from 1 to 4 bytes depending on the character, such as emojis), obtain their byte array representation, or convert them to hexadecimal code points.

This lesson demonstrates common helper methods on the rune type.

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, strings are representing read-only arrays of bytes, encoded natively in UTF-8. You can declare string variables using single quotes ('hello') or double quotes ("hello"), though single quotes are preferred in idiomatic V. The string type in V comes with built-in metadata, such as the .len field, which returns the total number of bytes in the string (not necessarily the number of Unicode characters/runes). You can inspect the runtime type of any variable using V's built-in typeof() function.

This example illustrates how to declare string variables, concatenate them, check string lengths, and query variable types at runtime.

Additional Context from Repository docs:

This example demonstrates the concepts of declare string.

module main

fn main() {
	// Strings can be declared using single quotes
	greeting := 'hello'
	name := 'Ada'
	
	// String concatenation using the '+' operator
	message := greeting + ', ' + name + '!'

	println(message)
	// Access the length (in bytes) of the string using the .len field
	println('Length: ${message.len}')
	// Inspect the variable type at runtime using typeof()
	println('Type: ${typeof(message).name}')
}

String Read Only Array Of Bytes

String Read Only Array Of Bytes

In V, strings are represented internally as read-only arrays of UTF-8 encoded bytes (u8). This means you can index into a string using bracket notation (str[index]) to extract the raw byte value at that position. The type returned from indexing a string is always byte (an alias for u8 in V), not a string or rune.

This example shows how to read raw bytes from a string and prints the byte value and its type name.

Additional Context from Repository docs:

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

fn main() {
	fruit := 'Orange'
	// Accessing the first byte of the string 'Orange'.
	// This returns the ASCII value of 'O' (which is 79), and its type is 'byte'.
	println(typeof(fruit[0]).name)
	// Outputs: byte
	
	println(fruit[0])
	// Outputs: 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

Although declaring a string variable with mut lets you reassign the variable to reference a completely different string, it does NOT let you mutate individual characters or bytes within the existing string (e.g. s[0] = \G\``). String data elements are strictly read-only arrays of bytes, and attempting to mutate them will fail compilation.

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'

	// ERROR: Cannot assign directly to string indices.
	// Strings in V are read-only byte arrays and their contents cannot be mutated.
	greet[0] = 'G' 
}

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, joining strings together is performed using the + operator. Since strings are immutable byte arrays, each concatenation creates a brand-new string in memory and copies the contents of both source strings. While the + operator is extremely convenient and clear for joining a few strings, doing this in loops or performance-critical code paths is discouraged because it leads to excessive memory allocations. For high-performance string building, V offers the strings.Builder module.

This example illustrates the direct concatenation of two string variables.

Additional Context from Repository docs:

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

module main

fn main() {
	a := 'con'
	b := 'cat'
	// Concatenate a and b, creating a new string 'concat' in memory
	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

When your program must choose between multiple mutually exclusive paths, you can chain multiple else if blocks together. V evaluates these conditions sequentially from top to bottom. As soon as one condition evaluates to true, the corresponding block of code is executed, and all remaining branches (including any final fallback else block) are skipped entirely. Like single if statements, parentheses are not required around the condition expressions in V.

This example defines a helper function that takes a weekday string and prints a corresponding breakfast menu using a chained conditional statement.

Additional Context from Repository docs:

This example demonstrates the concepts of chaining else if.

module main

// This helper chooses a meal plan based on the weekday.
fn breakfast_menu(day string) {
	// Cascading conditional checks
	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 {
		// Fallback block executed if no prior conditions match
		println('invalid input')
	}
}

fn main() {
	// Call the helper with a sample weekday.
	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

In V, there is no switch statement. Instead, the match keyword is used for branching on values. The match statement is highly readable and type-safe. Each branch is evaluated in order, and unlike in C/Java/Javascript, there is no "fall-through" behavior—the matching block executes and the statement completes immediately. This eliminates bugs caused by forgetting break statements. V also enforces that a match must cover all possible cases or provide an else block.

This example shows how to use match on string values.

Additional Context from Repository docs:

This example demonstrates the concepts of match as switch case.

module main

fn breakfast_menu(day string) {
	// A match block branches on the value of 'day'.
	// In V, match is an expression and can also return values.
	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') } // Exhaustive match requirement handled by 'else'
	}
}

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

One of V's strongest safety guarantees is exhaustive enum matching. When you match on an enum value, V requires you to handle every single enum member. If you miss one, the compiler will refuse to compile the program. This ensures that when new items are added to an enum in the future, the compiler will automatically guide you to update all match expressions across your codebase. Additionally, V supports shorthand syntax where you can write .member_name instead of EnumName.member_name inside the match arms.

This example illustrates matching over an enum to return a string menu item.

Additional Context from Repository docs:

This example demonstrates the concepts of match with enum.

module main

// Define a Days-of-the-week enum
enum Day {
	sunday
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
}

fn breakfast_menu(day Day) string {
	// The match statement returns the value of the matching block.
	// Notice we use the shorthand dot syntax (.monday) since 'day' is known to be of type 'Day'.
	return match day {
		.monday {
			'Bread, Jam, Half boiled Egg'
		}
		.tuesday, .thursday {
			'Bread, Jam, Juice' // Grouping multiple enum members using comma
		}
		.wednesday {
			'Milk, Bread, Fruit Bowl'
		}
		.friday, .sunday {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		.saturday {
			'Milk, Bread, Fruit Bowl'
		}
	} // No else block is needed because all enum members are exhaustively handled.
}

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

V simplifies iteration by only offering a single keyword for loops: for. There is no while keyword in V. A "bare" for (a loop declaration without any conditions or loop ranges) represents an infinite loop, which behaves exactly like while true in other languages. To exit a bare for loop, you must use a break statement inside the loop body, or exit the function using return.

This example shows how to declare a bare infinite loop.

Additional Context from Repository docs:

This example demonstrates the concepts of bare for.

module main

fn main() {
	mut count := 1
	// Bare for starts an infinite loop.
	// WARNING: Running this without a break condition will loop forever.
	for {
		println('Hi ${count} times')
		count += 1
		
		// To break out, a developer would normally add:
		if count > 5 {
			break
		}
	}
}

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

Iterating over arrays is a very common requirement. In V, you can iterate over both the index and value of each element using the for index, value in array syntax. During each iteration, the index variable (e.g., idx) contains the zero-based array index, and the element variable (e.g., ele) contains a read-only copy of the item. Both variables are scoped exclusively to the body of the loop and cannot be mutated. If you only need the element values and not their indices, V allows you to omit the index variable (e.g. for value in array).

This example declares a list of fruits and iterates over them, printing each fruit alongside its corresponding index.

Additional Context from Repository docs:

This example demonstrates the concepts of for on arrays.

module main

fn main() {
	fruits := ['apple', 'banana', 'coconut']
	
	// Loop over the indices (idx) and elements (ele) of the fruits array
	for idx, ele in fruits {
		println('idx: ${idx} \t fruit: ${ele}')
	}
}

For On Maps

For On Maps

V makes iterating over key-value collections (maps) straightforward. By using the syntax for key, value in map, you can access both the key and the value of each entry directly during each iteration. Like arrays, the iteration variables (key and value) are local to the loop scope and are immutable. Note that iteration order over maps is not guaranteed to be stable or sorted, matching standard hash map behavior in other systems languages.

This example demonstrates how to declare a map and iterate over its key-value pairs.

Additional Context from Repository docs:

This example demonstrates the concepts of for on maps.

module main

fn main() {
	// Initialize a map with string keys and integer values
	lottery := {
		'First':       1000
		'Second':      700
		'Consolation': 200
	}

	// Loop over keys (k) and values (v) in the 'lottery' map.
	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, you can retrieve a subset of elements by slicing the array. Slicing uses the [start..end] syntax, which creates a new array containing elements from the start index up to (but not including) the end index.

Positive Slicing

Positive indices represent offsets from the beginning of the array (starting at 0). For example, sports[1..3] returns a slice from index 1 to 2.

Negative Slicing

V does not support negative indices natively in slices (e.g., sports[-2..] will cause a compiler error). To achieve the effect of negative slicing (indexing from the end of the array), you calculate the start and/or end index using the array's .len property:

• Excluding the last element: sports[..sports.len - 1] (equivalent to Python's sports[..-1])
• Range from the end: sports[sports.len - 3 .. sports.len - 1] (equivalent to Python's sports[-3..-1])
• Last N elements: sports[sports.len - 2 ..] (equivalent to Python's sports[-2..])

Slices are References

Additional Context from Repository docs:

This example demonstrates the concepts of access array elements using slices, including positive slicing, .len-based negative slicing, reference mutation via unsafe blocks, and copying by value with .clone().

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

	// Positive slicing: from index 1 to 3 (excluding index 3)
	println(sports[1..3]) // ['hockey', 'football']

	// V does not support negative indices natively in slices (e.g., sports[-2..] will not compile).
	// To achieve "negative slicing" (indexing from the end of the array), use the `.len` property:

	// Slice up to the last element (excluding it): Python's sports[..-1]
	println(sports[..sports.len - 1]) // ['cricket', 'hockey', 'football', 'basketball']

	// Slice from 3rd to last up to 1st to last (excluding it): Python's sports[-3..-1]
	println(sports[sports.len - 3..sports.len - 1]) // ['football', 'basketball']

	// Slice the last two elements: Python's sports[-2..]
	println(sports[sports.len - 2..]) // ['basketball', 'tennis']

	// --- REFERENCE VS VALUE BEHAVIOR ---
	// In V, slices are reference views of the original array.
	// If you modify an element of a slice, it affects the original array.
	// Note: To prevent unsafe behavior, assigning a slice to a variable requires an `unsafe` block
	// if you want it by-reference, or an explicit `.clone()` to get a copy by-value.

	// 1. Modifying by reference (using unsafe)
	mut original := [10, 20, 30, 40, 50]
	mut ref_slice := unsafe { original[1..4] }
	ref_slice[0] = 99
	println(original) // [10, 99, 30, 40, 50] (Original is modified!)

	// 2. Modifying by value (using .clone())
	mut original_two := [10, 20, 30, 40, 50]
	mut val_slice := original_two[1..4].clone()
	val_slice[0] = 99
	println(original_two) // [10, 20, 30, 40, 50] (Original remains unchanged!)
}

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()
	}
}

Array Update Syntax

Array Update Syntax

V lets you initialise an array by spreading an existing array (using ellipsis spread syntax ...), optionally followed by additional elements.

module main

fn main() {
	println('=== Array Update Syntax ===')
	
	// NOTE: Array spread update syntax `[...base, 3, 4]` is defined in the V language specification (docs.md)
	// but is not fully supported in V 0.5.1 parser.
	// Below is the specification representation:
	/*
	base := [1, 2]
	a := [...base, 3, 4]
	assert a == [1, 2, 3, 4]
	*/
	
	// Equivalent cloning & appending representation for V 0.5.1:
	base := [1, 2]
	mut a := base.clone()
	a << 3
	a << 4
	println('base: ${base}') // [1, 2]
	println('a: ${a}')       // [1, 2, 3, 4]
	assert a == [1, 2, 3, 4]
}

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')
}

Import Maps Helpers

Import Maps Helpers

The maps module provides higher-level helpers for filtering, transforming, inverting, merging, and converting between maps and arrays. These helpers are useful when you want to work with map data in a functional style without manually writing the loops yourself.

Additional Context from Repository docs:

This example demonstrates the concepts of import maps helpers.

module main

import maps

fn main() {
	println('--- Import Maps Module Helpers ---')

	// Start with a simple map of fruit counts.
	m1 := {
		'apple':  1
		'banana': 2
		'cherry': 3
	}

	// filter() keeps only the entries that satisfy the callback condition.
	filtered := maps.filter(m1, fn (k string, v int) bool {
		return v > 1
	})
	println('filter(): ${filtered}')

	// to_array() builds a new array by transforming each entry.
	keys_upper := maps.to_array(m1, fn (k string, v int) string {
		return k.to_upper()
	})
	println('to_array(): ${keys_upper}')

	// invert() swaps each key/value pair so the values become the keys.
	inverted := maps.invert(m1)
	println('invert(): ${inverted}')

	// from_array() creates a map from a list of strings.
	fruits := ['apple', 'banana', 'cherry']
	map_from_arr := maps.from_array(fruits)
	println('from_array(): ${map_from_arr}')

	// merge() combines two maps and lets the second map override duplicates.
	m2 := {
		'banana': 20
		'date':   4
	}
	merged := maps.merge(m1, m2)
	println('merge(): ${merged}')

	// merge_in_place() mutates the first map directly.
	mut mut_map := {
		'a': 1
	}
	maps.merge_in_place(mut mut_map, {
		'b': 2
		'c': 3
	})
	println('merge_in_place(): ${mut_map}')

	// flat_map() can expand each entry into multiple output values.
	flat_items := maps.flat_map[string, int, string](m1, fn (k string, v int) []string {
		return [k, v.str()]
	})
	println('flat_map(): ${flat_items}')

	// to_map() transforms each entry into a new key/value pair.
	transformed := maps.to_map[string, int, string, int](m1, fn (k string, v int) (string, int) {
		return k.to_upper(), v * 10
	})
	println('to_map(): ${transformed}')
}

Map Update Syntax

Map Update Syntax

Similar to structs, V lets you initialise a new map with updates applied on top of an existing map using the spread syntax .... This is functionally equivalent to cloning the map and updating it, except that it avoids declaring a mutable intermediate variable and allows inlining elements.

module main

fn main() {
	println('=== Map Update Syntax ===')

	base_map := {
		'a': 4
		'b': 5
	}

	// Create a new map by updating elements of base_map
	foo := {
		...base_map
		'b': 88
		'c': 99
	}

	println('base_map: ${base_map}') // {'a': 4, 'b': 5}
	println('foo: ${foo}')           // {'a': 4, 'b': 88, 'c': 99}
	
	assert base_map['b'] == 5
	assert foo['a'] == 4
	assert foo['b'] == 88
	assert foo['c'] == 99
}

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
• Lambda Expressions
• Closures

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() {
	println(add(2, 3))
}

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() string {
	return 'Hello!'
}

fn main() {
	// call the method
	res := say_hello()
	println(res)
	// prints: Hello!
}

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 console_greeter() {
	println('Hello!')
}

fn main() {
	console_greeter()
	// prints: Hello!
}

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() {
	res := add(2, 4)
	println(res)
	// prints: 6
}

Function Return Multiple Values

Function Return Multiple Values

In V, functions are not limited to returning a single value. A function can return a tuple containing two or more values when they logically belong together. A very common pattern in systems programming is returning both the main result of an operation and a secondary value (such as status flags, byte counts, or errors). Returning multiple values is clean, avoids wrapping results in temporary struct containers, and is assigned using parallel declaration at the call site.

This example shows how a function computes a string greeting and returns both the greeting string and its length as an integer.

Additional Context from Repository docs:

This example demonstrates the concepts of function return multiple values.

// The return types are declared within parentheses: (string, int)
fn greet_and_message_length(name string) (string, int) {
	mut greeting := 'Hello, ' + name + '!'
	// Multiple values are returned as a comma-separated list
	return greeting, greeting.len
}

fn main() {
	// Receive multiple return values using parallel assignment
	i, j := greet_and_message_length('Navule')
	println(i) // Prints: Hello, Navule!
	println(j) // Prints the length: 14
}

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) {
	mut greeting := 'Hello, ' + name + '!'
	return greeting, greeting.len
}

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

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

The defer keyword is a crucial feature for resource safety and cleanups. A defer block schedules a block of code to run automatically right before the containing function exits, regardless of which return path is taken. If there are multiple defer blocks in a function, they are executed in reverse order of their declaration (Last-In, First-Out). This ensures resources (like file descriptors, database connections, or socket connections) are closed safely without duplicating cleanup code across every return statement.

This example illustrates the execution sequence of statements inside a function containing a defer block.

Additional Context from Repository docs:

This example demonstrates the concepts of function with defer block.

module main

fn void_func_defer() {
	println('Hello')
	
	// This block is scheduled to execute at the very end of the function scope.
	defer {
		println('Hi from defer block')
	}
	
	println('How are you?')
	// The function ends here, triggering the deferred block execution automatically.
}

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.